altium-toolkit 1.1.2 → 1.1.22

package/src/ui/SchematicImageRenderer.mjs

@@ -4,9 +4,11 @@
 
 import { SchematicSvgUtils } from './SchematicSvgUtils.mjs'
 import { SchematicColorResolver } from './SchematicColorResolver.mjs'
+import { SchematicPowerDiagramImageProcessor } from './SchematicPowerDiagramImageProcessor.mjs'
 
 const { escapeHtml, formatNumber, projectSchematicY } = SchematicSvgUtils
 const MISSING_IMAGE_WRAP_SAFETY_FACTOR = 0.96
+const BLUEPRINT_IMAGE_FILTER_ID = 'schematic-blueprint-image-filter'
 
 /**
  * Renders normalized schematic image placements.
@@ -16,15 +18,19 @@ export class SchematicImageRenderer {
      * Builds markup for embedded schematic images and unresolved placeholders.
      * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType?: string, dataBase64?: string, diagnosticState?: string, keepAspect?: boolean }[]} images
      * @param {number} sheetHeight
+     * @param {{ colorizeImages?: boolean, colorize_images?: boolean }} options Image render options.
      * @returns {string}
      */
-    static buildMarkup(images, sheetHeight) {
-        return images
+    static buildMarkup(images, sheetHeight, options = {}) {
+        const renderOptions =
+            SchematicImageRenderer.#normalizeRenderOptions(options)
+        const imageMarkup = images
             .map((image) =>
                 image.dataBase64 && image.mimeType
                     ? SchematicImageRenderer.#buildEmbeddedImageMarkup(
                           image,
-                          sheetHeight
+                          sheetHeight,
+                          renderOptions
                       )
                     : SchematicImageRenderer.#buildPlaceholderMarkup(
                           image,
@@ -32,19 +38,82 @@ export class SchematicImageRenderer {
                       )
             )
             .join('')
+
+        return (
+            SchematicImageRenderer.#buildImageFilterMarkup(
+                images,
+                renderOptions
+            ) + imageMarkup
+        )
+    }
+
+    /**
+     * Normalizes image renderer options.
+     * @param {{ colorizeImages?: boolean, colorize_images?: boolean }} options Raw options.
+     * @returns {{ colorizeImages: boolean }}
+     */
+    static #normalizeRenderOptions(options) {
+        return {
+            colorizeImages:
+                options?.colorizeImages === true ||
+                options?.colorize_images === true
+        }
+    }
+
+    /**
+     * Builds any SVG filters needed by the embedded image set.
+     * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType?: string, dataBase64?: string }[]} images
+     * @param {{ colorizeImages: boolean }} options Normalized render options.
+     * @returns {string}
+     */
+    static #buildImageFilterMarkup(images, options) {
+        if (!options.colorizeImages) return ''
+
+        const hasDiagramImage = (images || []).some(
+            (image) =>
+                image?.dataBase64 &&
+                image?.mimeType &&
+                SchematicImageRenderer.#isDiagramImage(image) &&
+                !SchematicImageRenderer.#isPowerDiagramImage(image)
+        )
+
+        if (!hasDiagramImage) return ''
+
+        return (
+            '<defs>' +
+            SchematicImageRenderer.#buildBlueprintImageFilterMarkup() +
+            '</defs>'
+        )
     }
 
     /**
      * Builds one embedded SVG image node.
-     * @param {{ x: number, y: number, cornerX: number, cornerY: number, mimeType: string, dataBase64: string, keepAspect?: boolean }} image
+     * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string, mimeType: string, dataBase64: string, keepAspect?: boolean }} image
      * @param {number} sheetHeight
+     * @param {{ colorizeImages: boolean }} options Normalized render options.
      * @returns {string}
      */
-    static #buildEmbeddedImageMarkup(image, sheetHeight) {
+    static #buildEmbeddedImageMarkup(image, sheetHeight, options) {
         const bounds = SchematicImageRenderer.#resolveBounds(image, sheetHeight)
+        const isDiagramImage = SchematicImageRenderer.#isDiagramImage(image)
+        const isPowerDiagramImage =
+            SchematicImageRenderer.#isPowerDiagramImage(image)
+        const colorizeImage = options.colorizeImages
+        const dataBase64 =
+            colorizeImage && isPowerDiagramImage
+                ? SchematicPowerDiagramImageProcessor.process(image)
+                : image.dataBase64
 
         return (
-            '<image class="schematic-embedded-image" x="' +
+            '<image class="' +
+            escapeHtml(
+                isPowerDiagramImage
+                    ? 'schematic-embedded-image schematic-embedded-image--power-diagram'
+                    : isDiagramImage
+                      ? 'schematic-embedded-image schematic-embedded-image--diagram'
+                      : 'schematic-embedded-image'
+            ) +
+            '" x="' +
             formatNumber(bounds.x) +
             '" y="' +
             formatNumber(bounds.y) +
@@ -54,14 +123,60 @@ export class SchematicImageRenderer {
             formatNumber(bounds.height) +
             '" preserveAspectRatio="' +
             escapeHtml(image.keepAspect === false ? 'none' : 'xMidYMid meet') +
-            '" href="' +
-            escapeHtml(
-                'data:' + image.mimeType + ';base64,' + image.dataBase64
-            ) +
+            '"' +
+            (colorizeImage && isDiagramImage && !isPowerDiagramImage
+                ? ' filter="url(#' +
+                  escapeHtml(BLUEPRINT_IMAGE_FILTER_ID) +
+                  ')"'
+                : '') +
+            ' href="' +
+            escapeHtml('data:' + image.mimeType + ';base64,' + dataBase64) +
             '" />'
         )
     }
 
+    /**
+     * Builds a filter that maps black diagram artwork to the schematic blue
+     * ink while keeping white backgrounds white.
+     * @returns {string}
+     */
+    static #buildBlueprintImageFilterMarkup() {
+        return (
+            '<filter id="' +
+            escapeHtml(BLUEPRINT_IMAGE_FILTER_ID) +
+            '" color-interpolation-filters="sRGB">' +
+            '<feColorMatrix type="matrix" values="' +
+            '1 0 0 0 0 ' +
+            '0 0.431 0 0 0.569 ' +
+            '0 0 0.325 0 0.675 ' +
+            '0 0 0 1 0' +
+            '" />' +
+            '</filter>'
+        )
+    }
+
+    /**
+     * Identifies recovered diagram artwork by explicit file naming.
+     * @param {{ fileName?: string, mimeType?: string }} image
+     * @returns {boolean}
+     */
+    static #isDiagramImage(image) {
+        return /diagram/i.test(String(image?.fileName || ''))
+    }
+
+    /**
+     * Identifies recovered power-diagram PNG artwork for selective palette
+     * processing.
+     * @param {{ fileName?: string, mimeType?: string }} image
+     * @returns {boolean}
+     */
+    static #isPowerDiagramImage(image) {
+        return (
+            image?.mimeType === 'image/png' &&
+            /power/i.test(String(image?.fileName || ''))
+        )
+    }
+
     /**
      * Builds one placeholder frame when an image payload is unavailable.
      * @param {{ x: number, y: number, cornerX: number, cornerY: number, fileName?: string }} image

package/src/ui/SchematicJunctionRenderer.mjs

@@ -44,7 +44,7 @@ export class SchematicJunctionRenderer {
                     formatNumber(projectSchematicY(sheetHeight, junction.y)) +
                     '" r="2" fill="' +
                     escapeHtml(
-                        SchematicColorResolver.resolveColor(
+                        SchematicColorResolver.resolveNonTextColor(
                             junction.color,
                             '--schematic-default-ink-color'
                         )

package/src/ui/SchematicLineColorResolver.mjs

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import { SchematicColorResolver } from './SchematicColorResolver.mjs'
+
+/**
+ * Resolves schematic line stroke colors from normalized line metadata.
+ */
+export class SchematicLineColorResolver {
+    /**
+     * Resolves one schematic line stroke color.
+     * @param {{ color?: string, ownerIndex?: string, isBus?: boolean, recordType?: string, x1?: number, x2?: number }} line Line primitive.
+     * @returns {string}
+     */
+    static resolveColor(line) {
+        if (SchematicLineColorResolver.isElectricalLine(line)) {
+            return SchematicColorResolver.resolveNonTextColor(
+                line?.color,
+                '--schematic-default-ink-color'
+            )
+        }
+
+        if (SchematicLineColorResolver.#isOwnerVerticalLine(line)) {
+            const resolvedColor = SchematicColorResolver.resolveNonTextColor(
+                line?.color,
+                '--schematic-default-ink-color',
+                true
+            )
+            return resolvedColor.startsWith('var(')
+                ? resolvedColor
+                : SchematicColorResolver.resolveMutedSourceColor(
+                      line?.color,
+                      '--schematic-default-ink-color'
+                  )
+        }
+
+        return SchematicColorResolver.resolveColor(
+            line?.color,
+            '--schematic-default-ink-color'
+        )
+    }
+
+    /**
+     * Returns true when one normalized line can carry schematic net color.
+     * @param {{ ownerIndex?: string, isBus?: boolean, recordType?: string } | null | undefined} line Line primitive.
+     * @returns {boolean}
+     */
+    static isElectricalLine(line) {
+        if (line?.ownerIndex || line?.isBus === true) {
+            return false
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(line || {}, 'recordType')) {
+            return true
+        }
+
+        return !['6', '7', '26'].includes(String(line.recordType || ''))
+    }
+
+    /**
+     * Returns true when owner geometry encodes a vertical side rail as a line.
+     * @param {{ ownerIndex?: string, x1?: number, x2?: number } | null | undefined} line Line primitive.
+     * @returns {boolean}
+     */
+    static #isOwnerVerticalLine(line) {
+        return (
+            Boolean(String(line?.ownerIndex || '').trim()) &&
+            SchematicLineColorResolver.#isVerticalLine(line)
+        )
+    }
+
+    /**
+     * Returns true when one line is vertical within parser coordinate tolerance.
+     * @param {{ x1?: number, x2?: number } | null | undefined} line Line primitive.
+     * @returns {boolean}
+     */
+    static #isVerticalLine(line) {
+        const x1 = Number(line?.x1)
+        const x2 = Number(line?.x2)
+
+        return (
+            Number.isFinite(x1) &&
+            Number.isFinite(x2) &&
+            Math.abs(x1 - x2) <= 0.001
+        )
+    }
+}

package/src/ui/SchematicNativeFooterPartitioner.mjs

@@ -0,0 +1,275 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Splits native Altium footer/template primitives from scalable schematic
+ * content when a standard template page is larger than the stored custom size.
+ */
+export class SchematicNativeFooterPartitioner {
+    /**
+     * Partitions render primitives into scalable content and fixed footer
+     * chrome.
+     * @param {{ lines?: object[], polygons?: object[], rectangles?: object[], roundedRectangles?: object[], ellipses?: object[], arcs?: object[], beziers?: object[], pies?: object[], ieeeSymbols?: object[], texts?: object[], images?: object[] }} primitives Primitive families.
+     * @param {{ width?: number, height?: number, sourceWidth?: number, sourceHeight?: number, marginWidth?: number, paperSize?: string, borderOn?: boolean }} sheet Sheet metadata.
+     * @returns {{ content: Record<string, object[]>, footer: Record<string, object[]>, footerBounds: { minX: number, minY: number, maxX: number, maxY: number } | null }}
+     */
+    static partitionPrimitives(primitives, sheet) {
+        const families = [
+            'lines',
+            'polygons',
+            'rectangles',
+            'roundedRectangles',
+            'ellipses',
+            'arcs',
+            'beziers',
+            'pies',
+            'ieeeSymbols',
+            'texts',
+            'images'
+        ]
+        const content = {}
+        const footer = {}
+
+        for (const family of families) {
+            const values = primitives?.[family] || []
+            content[family] = values.filter(
+                (primitive) =>
+                    !SchematicNativeFooterPartitioner.#isNativeFooterPrimitive(
+                        primitive,
+                        sheet
+                    )
+            )
+            footer[family] = values.filter((primitive) =>
+                SchematicNativeFooterPartitioner.#isNativeFooterPrimitive(
+                    primitive,
+                    sheet
+                )
+            )
+        }
+
+        return {
+            content,
+            footer,
+            footerBounds:
+                SchematicNativeFooterPartitioner.#resolvePrimitiveSetBounds(
+                    Object.values(footer).flat()
+                )
+        }
+    }
+
+    /**
+     * Returns true when one primitive is native lower-page footer chrome.
+     * @param {object} primitive Primitive candidate.
+     * @param {{ width?: number, height?: number, sourceWidth?: number, sourceHeight?: number, marginWidth?: number, paperSize?: string, borderOn?: boolean }} sheet Sheet metadata.
+     * @returns {boolean}
+     */
+    static #isNativeFooterPrimitive(primitive, sheet) {
+        if (!SchematicNativeFooterPartitioner.#shouldSplitNativeFooter(sheet)) {
+            return false
+        }
+        if (!String(primitive?.ownerIndex || '').trim()) {
+            return false
+        }
+
+        const bounds =
+            SchematicNativeFooterPartitioner.#resolvePrimitiveBounds(primitive)
+        if (!bounds) {
+            return false
+        }
+
+        const margin = Math.max(Number(sheet?.marginWidth || 20), 10)
+        const footerLimit = Math.max(margin * 6, 120)
+        const footerStartX = Math.max(Number(sheet?.width || 0), 0) * 0.5
+
+        return bounds.maxY <= footerLimit && bounds.maxX >= footerStartX
+    }
+
+    /**
+     * Returns true when promoted standard-sheet content needs fixed native
+     * footer handling.
+     * @param {{ width?: number, height?: number, sourceWidth?: number, sourceHeight?: number, paperSize?: string, borderOn?: boolean }} sheet Sheet metadata.
+     * @returns {boolean}
+     */
+    static #shouldSplitNativeFooter(sheet) {
+        const width = Number(sheet?.width || 0)
+        const height = Number(sheet?.height || 0)
+        const sourceWidth = Number(sheet?.sourceWidth || 0)
+        const sourceHeight = Number(sheet?.sourceHeight || 0)
+
+        return Boolean(
+            sheet?.borderOn &&
+            sheet?.paperSize &&
+            sourceWidth > 0 &&
+            sourceHeight > 0 &&
+            (width > sourceWidth || height > sourceHeight)
+        )
+    }
+
+    /**
+     * Resolves one primitive's document-space bounds.
+     * @param {object} primitive Primitive candidate.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolvePrimitiveBounds(primitive) {
+        const points =
+            SchematicNativeFooterPartitioner.#collectPrimitivePoints(primitive)
+        if (!points.length) {
+            return null
+        }
+
+        return {
+            minX: Math.min(...points.map((point) => point.x)),
+            minY: Math.min(...points.map((point) => point.y)),
+            maxX: Math.max(...points.map((point) => point.x)),
+            maxY: Math.max(...points.map((point) => point.y))
+        }
+    }
+
+    /**
+     * Resolves combined bounds for a set of primitives.
+     * @param {object[]} primitives Primitive candidates.
+     * @returns {{ minX: number, minY: number, maxX: number, maxY: number } | null}
+     */
+    static #resolvePrimitiveSetBounds(primitives) {
+        const bounds = primitives
+            .map((primitive) =>
+                SchematicNativeFooterPartitioner.#resolvePrimitiveBounds(
+                    primitive
+                )
+            )
+            .filter(Boolean)
+
+        if (!bounds.length) {
+            return null
+        }
+
+        return {
+            minX: Math.min(...bounds.map((bound) => bound.minX)),
+            minY: Math.min(...bounds.map((bound) => bound.minY)),
+            maxX: Math.max(...bounds.map((bound) => bound.maxX)),
+            maxY: Math.max(...bounds.map((bound) => bound.maxY))
+        }
+    }
+
+    /**
+     * Collects point coordinates from one normalized primitive.
+     * @param {object} primitive Primitive candidate.
+     * @returns {{ x: number, y: number }[]}
+     */
+    static #collectPrimitivePoints(primitive) {
+        if (Array.isArray(primitive?.points)) {
+            return primitive.points
+                .map((point) =>
+                    SchematicNativeFooterPartitioner.#point(point?.x, point?.y)
+                )
+                .filter(Boolean)
+        }
+        if (Array.isArray(primitive?.segments)) {
+            return primitive.segments.flatMap((segment) =>
+                [
+                    SchematicNativeFooterPartitioner.#point(
+                        segment?.x1,
+                        segment?.y1
+                    ),
+                    SchematicNativeFooterPartitioner.#point(
+                        segment?.x2,
+                        segment?.y2
+                    )
+                ].filter(Boolean)
+            )
+        }
+        if (
+            Number.isFinite(Number(primitive?.x1)) &&
+            Number.isFinite(Number(primitive?.y1)) &&
+            Number.isFinite(Number(primitive?.x2)) &&
+            Number.isFinite(Number(primitive?.y2))
+        ) {
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x1,
+                    primitive.y1
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x2,
+                    primitive.y2
+                )
+            ]
+        }
+        if (
+            Number.isFinite(Number(primitive?.cornerX)) &&
+            Number.isFinite(Number(primitive?.cornerY))
+        ) {
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x,
+                    primitive.y
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.cornerX,
+                    primitive.cornerY
+                )
+            ].filter(Boolean)
+        }
+        if (
+            Number.isFinite(Number(primitive?.width)) &&
+            Number.isFinite(Number(primitive?.height))
+        ) {
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    primitive.x,
+                    primitive.y
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    Number(primitive.x || 0) + Number(primitive.width || 0),
+                    Number(primitive.y || 0) + Number(primitive.height || 0)
+                )
+            ].filter(Boolean)
+        }
+        if (
+            Number.isFinite(Number(primitive?.radius)) ||
+            Number.isFinite(Number(primitive?.radiusX))
+        ) {
+            const radiusX = Math.max(
+                Number(primitive?.radiusX || primitive?.radius || 0),
+                0
+            )
+            const radiusY = Math.max(
+                Number(primitive?.radiusY || primitive?.radius || 0),
+                0
+            )
+
+            return [
+                SchematicNativeFooterPartitioner.#point(
+                    Number(primitive.x || 0) - radiusX,
+                    Number(primitive.y || 0) - radiusY
+                ),
+                SchematicNativeFooterPartitioner.#point(
+                    Number(primitive.x || 0) + radiusX,
+                    Number(primitive.y || 0) + radiusY
+                )
+            ]
+        }
+
+        return [
+            SchematicNativeFooterPartitioner.#point(primitive?.x, primitive?.y)
+        ].filter(Boolean)
+    }
+
+    /**
+     * Builds one finite point.
+     * @param {number | string | undefined} x Raw x coordinate.
+     * @param {number | string | undefined} y Raw y coordinate.
+     * @returns {{ x: number, y: number } | null}
+     */
+    static #point(x, y) {
+        const normalizedX = Number(x)
+        const normalizedY = Number(y)
+
+        if (!Number.isFinite(normalizedX) || !Number.isFinite(normalizedY)) {
+            return null
+        }
+
+        return { x: normalizedX, y: normalizedY }
+    }
+}