pengchen-exam-java/ps/checkPSD.jsx

// 简单 JSON.stringify 兼容
if (typeof JSON === "undefined") {
    JSON = {};
}

var inputPath1 = '${inputPath1}';
var inputPath2 = '${inputPath2}';
// 载入XMP扩展支持（全局调用一次即可）
if (!ExternalObject.AdobeXMPScript) {
    ExternalObject.AdobeXMPScript = new ExternalObject('lib:AdobeXMPScript');
}
JSON.stringify = function (obj, replacer, space) {
    if (typeof space === "number") {
        space = new Array(space + 1).join(" ");
    }
    function format(value, indent) {
        var type = typeof value;
        if (value === null) return "null";
        if (type === "string") return '"' + value + '"';
        if (type === "number" || type === "boolean") return String(value);
        if (type === "object") {
            var isArray = (value instanceof Array);
            var items = [];
            var pad = indent + (space || "");
            for (var key in value) {
                if (value.hasOwnProperty(key)) {
                    var val = format(value[key], pad);
                    if (!isArray) {
                        val = '"' + key + '": ' + val;
                    }
                    items.push(val);
                }
            }
            if (isArray) {
                return "[\n" + pad + items.join(",\n" + pad) + "\n" + indent + "]";
            } else {
                return "{\n" + pad + items.join(",\n" + pad) + "\n" + indent + "}";
            }
        }
        return "null";
    }
    return format(obj, "");
};




// 递归遍历所有图层（包括图层组）
function processLayers(layers, resultArray) {
    for (var i = 0; i < layers.length; i++) {
        var layer = layers[i];
        app.activeDocument.activeLayer = layer;

        var info = {};

        // 先保存锁定状态
        var wasLocked = layer.allLocked;
        if (wasLocked) {
            try {
                layer.allLocked = false; // 临时解锁
            } catch (e) {
                // 有些锁可能无法解除，忽略异常
            }
        }
        info["图层名"] = layer.name;
        info["类型"] = getLayerKindName(layer.kind);
        if (layer.visible === true) {
            info["可见"] = true;
        }

        if (layer.allLocked === true) {
            info["锁定"] = true;
        }

        // 文字图层特殊信息
        if (layer.kind === LayerKind.TEXT) {
            var t = layer.textItem;
            try {
                info["文字内容"] = t.contents;
            } catch (e) {

            }
            try {
                var font = t.font;
                var fontMap = {
                    "SimSun": "宋体",
                    "SimHei": "黑体",
                    "FangSong_GB2312": "仿宋",
                    "KaiTi_GB2312": "楷体",
                    "MicrosoftYaHei": "微软雅黑",
                    "MicrosoftJhengHei": "微软正黑体",
                    "NSimSun": "新宋体",
                    "PMingLiU": "新细明体",
                    "MingLiU": "细明体",
                    "DFKai-SB": "标楷体",
                    "STKaiti": "华文楷体",
                    "STSong": "华文宋体",
                    "STHeiti": "华文黑体",
                    "STFangsong": "华文仿宋",
                    "STXihei": "华文细黑",
                    "STZhongsong": "华文中宋",
                    "STXinwei": "华文新魏",
                    "STLiti": "华文隶书",
                    "STHupo": "华文琥珀",
                    "STCaiyun": "华文彩云",
                    "STXingkai": "华文行楷",
                    "Arial": "Arial（英文字体）",
                    "TimesNewRomanPSMT": "Times New Roman",
                    "CourierNewPSMT": "Courier New",
                    "Georgia": "Georgia",
                    "Tahoma": "Tahoma",
                    "Verdana": "Verdana"
                };

                if (fontMap.hasOwnProperty(font)) {
                    info["字体"] = fontMap[font];
                } else {
                    info["字体"] = font;
                }
            } catch (e) {
                info["字体"] = "未知";
            }

            try {
                info["字号"] = t.size.toString(); }// 修正这里
            catch (e) {
            }

            try {
                info["颜色"] = getSolidColorHex(t.color);}
            catch (e) {

            }
            try {
                info["字距"] = t.tracking;}
            catch (e) {

            }
            try {
                if ('fauxItalic' in t && t.fauxItalic === true) {
                    info["仿斜体"] = true;
                }
            } catch (e) {}

            try {
                if ('fauxBold' in t && t.fauxBold === true) {
                    info["仿粗体"] = true;
                }
            } catch (e) {}

            var transformProps = getWarpTextProps();
            if (
                transformProps &&
                typeof transformProps === "object" &&
                (function(obj) {
                    for (var key in obj) {
                        if (obj.hasOwnProperty(key)) {
                            return true;  // 有至少一个属性，不为空
                        }
                    }
                    return false;  // 没有属性，为空
                })(transformProps)
            ) {
                info["变形"] = transformProps;
            }

        }

        // 读取图层样式
        var styles = getLayerStyles(layer);
        if (styles) {
            info["图层样式"] = styles;
        }

        // 检测滤镜信息
        var filterInfo = detectFilters(layer.name);
        if (filterInfo) {
            info["滤镜信息"] = filterInfo;
        }


        // 选中当前图层为智能对象后
        var soLayer = app.activeDocument.activeLayer;

        // 确保它是智能对象
        // if (soLayer.kind == LayerKind.SMARTOBJECT) {
        //     // 打开智能对象
        //     var openedDoc = soLayer.smartObject.open();

        //     // 现在 activeDocument 是智能对象内容，可以像普通文档一样读取图层
        //     var internalLayer = openedDoc.artLayers[0]; // 你可以遍历所有图层
        //     var styles = getLayerStyles(internalLayer);
        //     alert(JSON.stringify(styles));

        //     // 读取完后关闭文档（不保存）
        //     openedDoc.close(SaveOptions.DONOTSAVECHANGES);
        // }



        // 如果是图层组，递归遍历组内图层
        if (layer.typename === "LayerSet") {
            info["子图层"] = [];
            processLayers(layer.layers, info["子图层"]);
        }

        resultArray.push(info);

        // 还原锁定状态
        if (wasLocked) {
            try {
                layer.allLocked = true;
            } catch (e) {}
        }
    }
}
function unlockLayer(layer) {
    // 如果图层被完全锁定
    if (layer.allLocked) {
        layer.allLocked = false;
    }
    // 如果是背景图层（通常无法直接操作）
    if (layer.isBackgroundLayer) {
        // 将背景图层转换为普通图层
        layer.name = "解锁背景图层";
        layer.isBackgroundLayer = false;
    }

    // 分别检查并解锁其他锁定项
    if (layer.pixelsLocked) layer.pixelsLocked = false;
    if (layer.positionLocked) layer.positionLocked = false;
    if (layer.transparentPixelsLocked) layer.transparentPixelsLocked = false;
}


function openSmartObjectDocument(layer) {
    try {
        app.activeDocument.activeLayer = layer; // 先激活图层
        var idplacedLayerEditContents = stringIDToTypeID("placedLayerEditContents");
        var desc = new ActionDescriptor();
        var ref = new ActionReference();
        ref.putIdentifier(charIDToTypeID("Lyr "), layer.id);
        desc.putReference(charIDToTypeID("null"), ref);
        executeAction(idplacedLayerEditContents, desc, DialogModes.NO);

        return app.activeDocument; // 返回智能对象内部文档
    } catch (e) {
        $.writeln("打开智能对象内部文档失败：" + e.message);
        return null;
    }
}

function openSmartObjectDocumentEvenIfLocked(layer) {
    var wasLocked = layer.allLocked;
    try {
        if (wasLocked) {
            try { layer.allLocked = false; } catch(e) {}
            try { layer.pixelsLocked = false; } catch(e) {}
            try { layer.positionLocked = false; } catch(e) {}
            try { layer.transparentPixelsLocked = false; } catch(e) {}
        }

        var idPlacedLayerEditContents = stringIDToTypeID("placedLayerEditContents");
        var desc = new ActionDescriptor();
        var ref = new ActionReference();
        ref.putIdentifier(charIDToTypeID("Lyr "), layer.id);
        desc.putReference(charIDToTypeID("null"), ref);
        executeAction(idPlacedLayerEditContents, desc, DialogModes.NO);

        return app.activeDocument;
    } catch (e) {
        // alert("打开智能对象内部文档失败：" + e.message);
        return null;
    } finally {
        if (wasLocked) {
            try { layer.allLocked = true; } catch(e) {}
        }
    }
}



function getSmartObjectType(layer) {
    try {
        var ref = new ActionReference();
        ref.putIdentifier(charIDToTypeID("Lyr "), layer.id);
        var desc = executeActionGet(ref);
        if (desc.hasKey(stringIDToTypeID("smartObject"))) {
            var smObj = desc.getObjectValue(stringIDToTypeID("smartObject"));
            if (smObj.hasKey(stringIDToTypeID("linked"))) {
                var isLinked = smObj.getBoolean(stringIDToTypeID("linked"));
                return isLinked ? "链接智能对象" : "嵌入智能对象";
            }
        }
    } catch (e) {
        return "未知类型";
    }
    return "未知类型";
}

function processFile(path) {
    var fileRef = new File(path);
    if (!fileRef.exists) {
        // alert("PSD文件不存在: " + path);
        throw new Error("PSD文件不存在");
    }


    var doc = app.open(fileRef);

    var result = {};

    result["颜色模式"] = getColorModeName(doc.mode);
    result["颜色深度"] = getBitsPerChannelLabel(doc.bitsPerChannel);
    result["图像宽度"] = doc.width.as('px') + " 像素";
    result["图像高度"] = doc.height.as('px') + " 像素";
    result["画布宽度"] = doc.width.as('px') + " 像素";
    result["画布高度"] = doc.height.as('px') + " 像素";
    result["分辨率"] = doc.resolution + " dpi";

    // 使用递归遍历所有顶层图层和图层组
    result["图层信息"] = [];
    processLayers(doc.layers, result["图层信息"]);

    // 获取智能对象图层数（递归计算）
    result["智能对象图层数"] = countSmartObjectsRecursive(doc.layers);

    // 写入 JSON 文件
    var baseName = fileRef.name.replace(/\.psd$/i, "");
    var jsonFilePath = fileRef.path + "/" + baseName + ".json";
    var jsonFile = new File(jsonFilePath);

    if (jsonFile.open("w")) {
        jsonFile.encoding = "UTF8";
        jsonFile.write(JSON.stringify(result, null, 2));
        jsonFile.close();
        // alert("JSON 文件已生成: " + jsonFilePath);
    } else {
        // alert("无法打开文件进行写入");
    }

    doc.close(SaveOptions.DONOTSAVECHANGES);
}

// 递归计算智能对象图层数
function countSmartObjectsRecursive(layers) {
    var count = 0;
    for (var i = 0; i < layers.length; i++) {
        var layer = layers[i];
        if (layer.kind === LayerKind.SMARTOBJECT) count++;
        if (layer.typename === "LayerSet") {
            count += countSmartObjectsRecursive(layer.layers);
        }
    }
    return count;
}

// 运行两个 PSD 的处理
processFile(inputPath1);
processFile(inputPath2);



//////////////////////////////////////////////

/////////////////////////////////////////////

// 辅助函数 - 颜色模式
function getColorModeName(mode) {
    switch (mode) {
        case DocumentMode.RGB: return "RGB";
        case DocumentMode.CMYK: return "CMYK";
        case DocumentMode.GRAYSCALE: return "灰度";
        case DocumentMode.BITMAP: return "位图";
        case DocumentMode.INDEXEDCOLOR: return "索引颜色";
        default: return "未知";
    }
}
function getBitsPerChannelLabel(bits) {
    switch (bits) {
        case BitsPerChannelType.ONE: return "1 位/通道";
        case BitsPerChannelType.EIGHT: return "8 位/通道";
        case BitsPerChannelType.SIXTEEN: return "16 位/通道";
        case BitsPerChannelType.THIRTYTWO: return "32 位/通道";
        default: return "未知";
    }
}

// 辅助函数 - 图层类型名
function getLayerKindName(kind) {
    switch (kind) {
        case LayerKind.NORMAL: return "普通图层";
        case LayerKind.TEXT: return "文字图层";
        case LayerKind.SMARTOBJECT: return "智能对象图层";
        case LayerKind.SOLIDFILL: return "纯色填充图层";
        case LayerKind.GRADIENTFILL: return "渐变填充图层";
        case LayerKind.PATTERNFILL: return "图案填充图层";
        case LayerKind.BRIGHTNESSCONTRAST: return "亮度/对比度调整层";
        case LayerKind.LEVELS: return "色阶调整层";
        case LayerKind.CURVES: return "曲线调整层";
        case LayerKind.EXPOSURE: return "曝光度调整层";
        case LayerKind.VIBRANCE: return "自然饱和度调整层";
        case LayerKind.HUESATURATION: return "色相/饱和度调整层";
        case LayerKind.COLORBALANCE: return "色彩平衡调整层";
        case LayerKind.BLACKANDWHITE: return "黑白调整层";
        case LayerKind.PHOTOFILTER: return "照片滤镜调整层";
        case LayerKind.CHANNELMIXER: return "通道混合器调整层";
        case LayerKind.COLORLOOKUP: return "颜色查找调整层";
        case LayerKind.INVERSION: return "反相调整层";
        case LayerKind.POSTERIZE: return "色调分离调整层";
        case LayerKind.THRESHOLD: return "阈值调整层";
        case LayerKind.GRADIENTMAP: return "渐变映射调整层";
        case LayerKind.SELECTIVECOLOR: return "可选颜色调整层";
        default: return "未知类型";
    }
}

// 读取颜色为HEX
function getSolidColorHex(color) {
    if (!color) return null;
    if (color.typename === "SolidColor") {
        if (color.rgb) {
            var r = Math.round(color.rgb.red);
            var g = Math.round(color.rgb.green);
            var b = Math.round(color.rgb.blue);
            return "#" + toHex(r) + toHex(g) + toHex(b);
        }
    }
    return null;
}
function toHex(c) {
    var h = c.toString(16);
    return h.length == 1 ? "0" + h : h;
}

// 统计智能对象图层数量
function countSmartObjects(doc) {
    var count = 0;
    for (var i = 0; i < doc.artLayers.length; i++) {
        if (doc.artLayers[i].kind === LayerKind.SMARTOBJECT) {
            count++;
        }
    }
    return count;
}

// 读取文字图层的变形属性
// 读取文字图层的变形属性（分开返回属性并汉化样式）
function getWarpTextProps() {
    try {
        var ref = new ActionReference();
        ref.putEnumerated(charIDToTypeID("Lyr "), charIDToTypeID("Ordn"), charIDToTypeID("Trgt")); // 当前图层
        var desc = executeActionGet(ref);

        if (desc.hasKey(stringIDToTypeID("textKey"))) {
            var textDesc = desc.getObjectValue(stringIDToTypeID("textKey"));

            if (textDesc.hasKey(stringIDToTypeID("warp"))) {
                var warpDesc = textDesc.getObjectValue(stringIDToTypeID("warp"));

                // 获取英文样式
                var warpStyleEn = warpDesc.hasKey(stringIDToTypeID("warpStyle"))
                    ? typeIDToStringID(warpDesc.getEnumerationValue(stringIDToTypeID("warpStyle")))
                    : "none";

                // 样式汉化映射
                var warpStyleMap = {
                    "warpNone": "无",
                    "warpArc": "弧形",
                    "warpArcLower": "下弧形",
                    "warpArcUpper": "上弧形",
                    "warpArch": "拱形",
                    "warpBulge": "凸出",
                    "warpShellLower": "下壳形",
                    "warpShellUpper": "上壳形",
                    "warpFlag": "旗帜",
                    "warpWave": "波浪",
                    "warpFish": "鱼形",
                    "warpRise": "上升",
                    "warpFisheye": "鱼眼",
                    "warpInflate": "膨胀",
                    "warpSqueeze": "挤压",
                    "warpTwist": "扭曲"
                };

                // 汉化样式
                var warpStyleCn = warpStyleMap[warpStyleEn] || warpStyleEn;

                var warpHorizontal = warpDesc.hasKey(stringIDToTypeID("warpValue"))
                    ? warpDesc.getDouble(stringIDToTypeID("warpValue")) + "%"
                    : "0%";

                var warpVertical = warpDesc.hasKey(stringIDToTypeID("warpPerspective"))
                    ? warpDesc.getDouble(stringIDToTypeID("warpPerspective")) + "%"
                    : "0%";

                var warpEnabled = warpDesc.hasKey(stringIDToTypeID("warpFlag"))
                    ? warpDesc.getBoolean(stringIDToTypeID("warpFlag"))
                    : false;

                var result = {};

                if (warpStyleCn !== "无") {
                    result["样式"] = warpStyleCn;
                    result["水平扭曲"] = warpHorizontal;
                    result["垂直扭曲"] = warpVertical;
                }

                if (warpEnabled === true) {
                    result["是否变形"] = true;
                }

                return result;
            } else {
                return { "提示": "该文字图层没有使用变形文字" };
            }
        }
    } catch (e) {
        // alert("读取变形文字属性时出错: " + e.message);
    }

    return null;
}



function getLayerStyles(layer) {
    try {
        var ref = new ActionReference();
        ref.putIdentifier(charIDToTypeID("Lyr "), layer.id);
        var desc = executeActionGet(ref);

        if (!desc.hasKey(stringIDToTypeID("layerEffects"))) {
            $.writeln("图层无 layerEffects：" + layer.name);
            return null;
        }

        var effects = desc.getObjectValue(stringIDToTypeID("layerEffects"));
        var styles = {};

        // ============ 描边 ===============
        if (effects.hasKey(stringIDToTypeID("frameFX"))) {
            var frameFX = effects.getObjectValue(stringIDToTypeID("frameFX"));
            var keys = [];
            for (var i = 0; i < frameFX.count; i++) {
                keys.push(i + ": " + typeIDToStringID(frameFX.getKey(i)));
            }
            var enabled = frameFX.getBoolean(stringIDToTypeID("enabled"));
            styles["描边_启用"] = frameFX.getBoolean(stringIDToTypeID("enabled"));
            if (enabled) {
                if (frameFX.hasKey(stringIDToTypeID("size"))) {
                    styles["描边_大小"] = frameFX.getUnitDoubleValue(stringIDToTypeID("size")) + " 像素";
                }
                if (frameFX.hasKey(stringIDToTypeID("color"))) {
                    var colorDesc = frameFX.getObjectValue(stringIDToTypeID("color"));
                    styles["描边_颜色"] = colorDescToHex(colorDesc);
                }
                if (frameFX.hasKey(stringIDToTypeID("style"))) {
                    var posEnum = frameFX.getEnumerationValue(stringIDToTypeID("style"));
                    var posStringID = typeIDToStringID(posEnum);
                    styles["描边_位置"] = getStrokePositionName(posStringID);
                } else {
                    styles["描边_位置"] = "未知";
                }

                if (frameFX.hasKey(stringIDToTypeID("opacity"))) {
                    styles["描边_不透明度"] = Math.round(frameFX.getUnitDoubleValue(stringIDToTypeID("opacity"))) + "%";
                }
                if (frameFX.hasKey(stringIDToTypeID("mode"))) {
                    var blendMode = frameFX.getEnumerationValue(stringIDToTypeID("mode"));
                    styles["描边_混合模式"] = getBlendModeName(blendMode);
                }
            }
        }

        // ============ 内发光 ===============
        if (effects.hasKey(stringIDToTypeID("innerGlow"))) {
            var innerGlow = effects.getObjectValue(stringIDToTypeID("innerGlow"));
            //   var keys = [];
            // for (var i = 0; i < innerGlow.count; i++) {
            //     keys.push(i + ": " + typeIDToStringID(innerGlow.getKey(i)));
            // }
            styles["内发光_启用"] = innerGlow.getBoolean(stringIDToTypeID("enabled"));
            if (styles["内发光_启用"]) {
                if (innerGlow.hasKey(stringIDToTypeID("opacity"))) {
                    styles["内发光_不透明度"] = Math.round(innerGlow.getUnitDoubleValue(stringIDToTypeID("opacity")) ) + "%";
                }

                if (innerGlow.hasKey(stringIDToTypeID("mode"))) {
                    var modeID = innerGlow.getEnumerationValue(stringIDToTypeID("mode"));
                    styles["内发光_混合模式"] = getBlendModeName(modeID);
                }

                if (innerGlow.hasKey(stringIDToTypeID("blur"))) {
                    styles["内发光_大小"] = innerGlow.getUnitDoubleValue(stringIDToTypeID("blur")) + " 像素";
                }
                if (innerGlow.hasKey(stringIDToTypeID("color"))) {
                    styles["内发光_颜色"] = colorDescToHex(innerGlow.getObjectValue(stringIDToTypeID("color")));
                }
                // if (innerGlow.hasKey(stringIDToTypeID("glowTechnique"))) {
                //     var tech = innerGlow.getEnumerationValue(stringIDToTypeID("glowTechnique"));
                //     styles["内发光_技巧"] = getInnerGlowTechniqueName(tech);
                // }
                if (innerGlow.hasKey(stringIDToTypeID("source"))) {
                    var source = innerGlow.getEnumerationValue(stringIDToTypeID("source"));
                    styles["内发光_来源"] = getInnerGlowSourceName(source);
                }
                // if (innerGlow.hasKey(stringIDToTypeID("chokeMatte"))) {
                //     styles["内发光_阻塞"] = innerGlow.getUnitDoubleValue(stringIDToTypeID("chokeMatte")) + " 像素";
                // }
                // if (innerGlow.hasKey(stringIDToTypeID("blur"))) {
                //     styles["内发光_模糊"] = innerGlow.getUnitDoubleValue(stringIDToTypeID("blur")) + " 像素";
                // }
            }
        }

        // ========= 斜面和浮雕 =========
        if (effects.hasKey(stringIDToTypeID("bevelEmboss"))) {
            var bevel = effects.getObjectValue(stringIDToTypeID("bevelEmboss"));
            styles["斜面_启用"] = bevel.getBoolean(stringIDToTypeID("enabled"));
            if (styles["斜面_启用"]) {
                styles["斜面_样式"] = typeIDToStringID(bevel.getEnumerationValue(stringIDToTypeID("style")));
                styles["斜面_方法"] = typeIDToStringID(bevel.getEnumerationValue(stringIDToTypeID("technique")));
                styles["斜面_深度"] = bevel.getDouble(stringIDToTypeID("strength")) + "%";
                styles["斜面_方向"] = typeIDToStringID(bevel.getEnumerationValue(stringIDToTypeID("direction")));
                styles["斜面_大小"] = bevel.getUnitDoubleValue(stringIDToTypeID("size")) + " 像素";
                styles["斜面_软化"] = bevel.getUnitDoubleValue(stringIDToTypeID("soften")) + " 像素";
                styles["斜面_使用全局光"] = bevel.getBoolean(stringIDToTypeID("useGlobalAngle"));
                styles["斜面_角度"] = bevel.getInteger(stringIDToTypeID("localLightingAngle")) + "°";

                if (bevel.hasKey(stringIDToTypeID("highlightColor"))) {
                    var color = bevel.getObjectValue(stringIDToTypeID("highlightColor"));
                    styles["斜面_高光颜色"] = colorToHex(color);
                }
                if (bevel.hasKey(stringIDToTypeID("highlightMode"))) {
                    var mode = bevel.getEnumerationValue(stringIDToTypeID("highlightMode"));
                    styles["斜面_高光模式"] = typeIDToStringID(mode);
                }
            }
        }

        // ========= 光泽（Satin） =========
        if (effects.hasKey(stringIDToTypeID("satin"))) {
            var satin = effects.getObjectValue(stringIDToTypeID("satin"));
            styles["光泽_启用"] = satin.getBoolean(stringIDToTypeID("enabled"));
            if (styles["光泽_启用"]) {
                styles["光泽_混合模式"] = typeIDToStringID(satin.getEnumerationValue(stringIDToTypeID("mode")));
                styles["光泽_不透明度"] = satin.getInteger(stringIDToTypeID("opacity")) + "%";
                styles["光泽_角度"] = satin.getInteger(stringIDToTypeID("localLightingAngle")) + "°";
                styles["光泽_距离"] = satin.getUnitDoubleValue(stringIDToTypeID("distance")) + " 像素";
                styles["光泽_大小"] = satin.getUnitDoubleValue(stringIDToTypeID("size")) + " 像素";
            }
        }

        // ============ 外发光 ===============
        if (effects.hasKey(stringIDToTypeID("outerGlow"))) {
            var outerGlow = effects.getObjectValue(stringIDToTypeID("outerGlow"));
            styles["外发光_启用"] = outerGlow.getBoolean(stringIDToTypeID("enabled"));
            // 遍历输出所有 key 名称，方便调试
            // var keys = [];
            // for (var i = 0; i < outerGlow.count; i++) {
            //     var key = outerGlow.getKey(i);
            //     var keyName = typeIDToStringID(key);
            //     keys.push(keyName);
            // }

            if (styles["外发光_启用"]) {
                if (outerGlow.hasKey(stringIDToTypeID("opacity"))) {
                    styles["外发光_不透明度"] = Math.round(outerGlow.getUnitDoubleValue(stringIDToTypeID("opacity")) ) + "%";
                }
                if (outerGlow.hasKey(stringIDToTypeID("color"))) {
                    styles["外发光_颜色"] = colorDescToHex(outerGlow.getObjectValue(stringIDToTypeID("color")));
                }
                if (outerGlow.hasKey(stringIDToTypeID("glowTechnique"))) {
                    var techniqueEnum = outerGlow.getEnumerationValue(stringIDToTypeID("glowTechnique"));
                    var techniqueStr = typeIDToStringID(techniqueEnum);

                    styles["外发光_图素方法"] = getOuterGlowTechniqueName(techniqueStr); // 例如返回"精确"
                }

                if (outerGlow.hasKey(stringIDToTypeID("blur"))) {
                    styles["外发光_大小"] = outerGlow.getUnitDoubleValue(stringIDToTypeID("blur")) + " 像素";
                }
                if (outerGlow.hasKey(stringIDToTypeID("chokeMatte"))) {
                    styles["外发光_阻塞"] = outerGlow.getUnitDoubleValue(stringIDToTypeID("chokeMatte")) + " 像素";
                }
                try{
                    if (outerGlow.hasKey(stringIDToTypeID("transferSpec"))) {
                        var transferSpec = outerGlow.getObjectValue(stringIDToTypeID("transferSpec")); // 先获取对象
                        var nameID = stringIDToTypeID("name");
                        if (transferSpec.hasKey(nameID)) {
                            styles["外发光_等高线"] = transferSpec.getString(nameID);
                        }
                    }

                } catch (e) {
                    // alert("外发光_等高线: " + e.message);
                    return null;
                }



                if (outerGlow.hasKey(stringIDToTypeID("mode"))) {
                    var blendMode = outerGlow.getEnumerationValue(stringIDToTypeID("mode"));
                    styles["外发光_混合模式"] = getBlendModeName(blendMode);
                }

            }
        }


        return hasOwnProperties(styles) ? styles : null;

    } catch (e) {
        // alert("读取图层样式异常: " + e.message);
        return null;
    }
}




// 辅助函数：描边位置
function getStrokePositionName(posStringID) {
    switch(posStringID) {
        case "outsetFrame": return "外侧";
        case "insideFrame": return "内侧";
        case "centeredFrame": return "居中";
        default: return "未知";
    }
}


// 斜面和浮雕 样式名称
function getBevelStyleName(value) {
    switch (value) {
        case stringIDToTypeID("outerBevel"): return "外斜面";
        case stringIDToTypeID("innerBevel"): return "内斜面";
        case stringIDToTypeID("emboss"): return "浮雕";
        case stringIDToTypeID("pillowEmboss"): return "枕头状浮雕";
        default: return "未知";
    }
}
// 斜面和浮雕 方法
function getBevelTechniqueName(value) {
    switch (value) {
        case stringIDToTypeID("smooth"): return "平滑";
        case stringIDToTypeID("chiselHard"): return "雕刻清晰";
        case stringIDToTypeID("chiselSoft"): return "雕刻柔和";
        default: return "未知";
    }
}
// 斜面和浮雕 方向
function getBevelDirectionName(value) {
    switch (value) {
        case stringIDToTypeID("up"): return "上";
        case stringIDToTypeID("down"): return "下";
        default: return "未知";
    }
}

// 图层混合模式
function getBlendModeName(value) {
    switch (value) {
        case stringIDToTypeID("normal"): return "正常";
        case stringIDToTypeID("multiply"): return "正片叠底";
        case stringIDToTypeID("screen"): return "滤色";
        case stringIDToTypeID("overlay"): return "叠加";
        case stringIDToTypeID("softLight"): return "柔光";
        case stringIDToTypeID("linearLight"): return "亮光";
        case stringIDToTypeID("hardLight"): return "强光";
        case stringIDToTypeID("vividLight"): return "亮光";
        case stringIDToTypeID("pinLight"): return "点光";
        case stringIDToTypeID("difference"): return "差值";
        case stringIDToTypeID("colorBurn"): return "颜色加深";
        case stringIDToTypeID("colorDodge"): return "颜色减淡";
        case stringIDToTypeID("lighten"): return "变亮";
        case stringIDToTypeID("darken"): return "变暗";
        case stringIDToTypeID("dissolve"): return "溶解";
        case stringIDToTypeID("hue"): return "色相";
        case stringIDToTypeID("saturation"): return "饱和度";
        case stringIDToTypeID("color"): return "颜色";
        case stringIDToTypeID("luminosity"): return "明度";
        default: return "其他";
    }
}

// 外发光 图素方法
function getOuterGlowTechniqueName(techniqueStr) {
    var map = {
        "softMatte": "柔和",
        "preciseMatte": "精确"
    };
    return map[techniqueStr] || techniqueStr;
}

// 等高线名称（外发光等）
function getContourName(value) {
    switch (value) {
        case stringIDToTypeID("linear"): return "线性";
        case stringIDToTypeID("ring"): return "环形";
        case stringIDToTypeID("cone"): return "锥形";
        case stringIDToTypeID("cove"): return "凹形";
        case stringIDToTypeID("stairs"): return "阶梯";
        case stringIDToTypeID("custom"): return "自定义";
        case stringIDToTypeID("zigZag"): return "锯齿1";
        case stringIDToTypeID("roundedSteps"): return "圆角阶梯";
        default: return "未知";
    }
}
function colorDescToHex(colorDesc) {
    try {
        if (!colorDesc.hasKey(stringIDToTypeID('red')) ||
            !colorDesc.hasKey(stringIDToTypeID('green')) ||
            !colorDesc.hasKey(stringIDToTypeID('blue'))) {
            return null;
        }

        var red = Math.round(colorDesc.getDouble(stringIDToTypeID('red')));
        var green = Math.round(colorDesc.getDouble(stringIDToTypeID('green')));
        var blue = Math.round(colorDesc.getDouble(stringIDToTypeID('blue')));
        return rgbToHex(red, green, blue);
    } catch (e) {
        return null;
    }
}

function getInnerGlowTechniqueName(value) {
    switch(value) {
        case stringIDToTypeID("precise"): return "精确";
        case stringIDToTypeID("softer"): return "柔和";
        default: return "未知";
    }
}
function getInnerGlowSourceName(value) {
    switch(value) {
        case stringIDToTypeID("center"): return "中心";
        case stringIDToTypeID("edge"): return "边缘";
        default: return "未知";
    }
}

function rgbToHex(r, g, b) {
    function toHex(n) {
        return ("0" + n.toString(16)).slice(-2);
    }
    return "#" + toHex(r) + toHex(g) + toHex(b);
}


// 滤镜检测示例（只检测图层名包含的关键词）
// 修改后的detectFilters函数，优先用XMP元数据读取镜头光晕参数
function detectFilters(layerName) {
    var filters = {};
    if (!layerName || typeof layerName !== "string") {
        return null;
    }
    var name = layerName.toLowerCase();

    // 先尝试读取XMP中镜头光晕参数

    var lensFlareMeta = readHistoryFromXMP();
    if (lensFlareMeta) {
        return lensFlareMeta; // 直接返回读取的元数据
    }
    // else {
    //     // 没读到元数据，返回默认提示
    //     filters["滤镜类型"] = "镜头光晕";
    //     filters["亮度"] = "⚠️ 无法读取，建议人工确认";
    //     filters["镜头类型"] = "⚠️ 无法读取，建议人工确认";
    //     return filters;
    // }


}


// 结合你的读取函数用法举例
function readHistoryFromXMP() {
    try {
        if (typeof ExternalObject.AdobeXMPScript === "undefined") {
            ExternalObject.AdobeXMPScript = new ExternalObject("lib:AdobeXMPScript");
        }

        var xmp = new XMPMeta(app.activeDocument.xmpMetadata.rawData);
        var nsMM = "http://ns.adobe.com/xap/1.0/mm/";
        var nsEvt = "http://ns.adobe.com/xap/1.0/sType/ResourceEvent#";

        XMPMeta.registerNamespace(nsMM, "xmpMM");
        XMPMeta.registerNamespace(nsEvt, "stEvt");

        var count = xmp.countArrayItems(nsMM, "History");
        if (count === 0) {
            $.writeln("没有找到历史记录");
            return null;
        }


        for (var i = 1; i <= count; i++) {
            var itemXMP = xmp.getArrayItem(nsMM, "History", i);
            var historyLine = itemXMP.toString();

            $.writeln("历史记录第" + i + "条: " + historyLine);

            if (historyLine.indexOf("镜头光晕") !== -1 || historyLine.toLowerCase().indexOf("lens flare") !== -1) {
                var brightnessMatch = historyLine.match(/亮度[:：]?\s*(\d+%?)/);
                var typeMatch = historyLine.match(/类型[:：]?\s*([^\s]+)/);

                return {
                    "历史":historyLine,
                    "滤镜类型": "镜头光晕",
                    "亮度": brightnessMatch ? brightnessMatch[1] : "未知",
                    "镜头类型": typeMatch ? typeMatch[1] : "未知"
                };
            }
        }




    } catch (e) {
        return {
            "读取XMP历史记录失败：": e.message
        };

    }
}



// 判断对象是否含有自有属性（兼容无Object.keys的环境）
function hasOwnProperties(obj) {
    for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
            return true;
        }
    }
    return false;
}