PS脚本案例

常用功能小集合

// 获取当前图层
var originalStem = app.activeDocument.activeLayer;

// 从用户获得输入
var stemsAmount = prompt("Processing \"" + originalStem.name + "\"\nHow many stems do you need? (From 2 to 100)", 12);

常用小案例：

将一个文件夹内的所有图片合并起来，生成一个pdf文档

var input = new Folder("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1");

 var data = input.getFiles("*.jpg");

 /*
 for(var index in data){
     var path = data[index];
     $.writeln(path);
}
*/

var output = new File ("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out/test.pdf");

app.makePDFPresentation(data, output);

alert("PDF制作完成", "我是一个提醒框", false);

批量裁剪表情包

var input = new Folder("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1");

 var data = input.getFiles("*.jpg");

// $.writeln (typeof data);


 for(var i = 0; i < data.length; i++)
 {
        open(data[i]);
        //定义一个变量[document]，用来表示Photoshop的当前文档。
        var document = app.activeDocument;

        //定义一个变量[bounds]，用来表示文档需要裁切的区域，即裁切从坐标[0,0]至[140,104]的区域。
        //注意Photoshop坐标原点在左上角。
        var bounds = [0, 266, 300, 322];

        //定义一个变量[angle]，用来设置裁切的旋转角度为0。
        var angle = 0;

        //调用[document]对象的[crop]方法，来裁切当前文档。
        document.crop(bounds, angle);

        //定义一个变量[document]，用来表示Photoshop当前的活动文档。
        var document = app.activeDocument;

        //定义一个变量[fileOut]，用来指定文件保存的路径。
        var fileOut = new File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out");

        //定义一个变量[options]，用来指定图片保存的格式为PNG。
        var options = PNGSaveOptions;

        //定义一个变量[asCopy]，用来指定图片以副本的方式保存。
        var asCopy = true;

        //定义一个变量[extensionType]，用来指定图片名称的后缀为小写的.png。
        var extensionType = Extension.LOWERCASE;

        //使用[document]对象的[saveAs]方法保存当前图片。
        document.saveAs(fileOut, options, asCopy, extensionType);
}

改变指定图层的可见性

// Macintosh Finder or the Windows Explorer
#target photoshop
// 使Photoshop成为最前端的应用程序
app.bringToFront();
// 获取当前文档
var srcDoc = app.activeDocument;

changeLayerVisible("aa");

function findThisLayer(aLayerName)
{
    try
    {
        //try to find the layer
        return srcDoc.layers.getByName(aLayerName);
    }
    catch(ee)
    {
        ;//do nothing
    }
}

function changeLayerVisible(aLayerName)
{
    try
    {
        findThisLayer(aLayerName).visible = !(findThisLayer(aLayerName).visible);
    }
    catch(ee)
    {
        alert("Layer :'" + aLayerName + "' Not found!");
    }
}

将该图层放入一个图层组里，根据用户输入复制并旋转图层（需要设置混合模式）

// 保存当前图层到变量originalStem中
var originalStem = app.activeDocument.activeLayer;

// 要求用户输入需要将该图像旋转多少次，系统会自动根据旋转的个数来计算每次旋转的角度
var stemsAmount = prompt("Processing \"" + originalStem.name + "\"\nHow many stems do you need? (From 2 to 100)", 12);

// 检查用户输入的数字是否是有效数字，如果不正确，展示错误信息，要求用户重新输入
while(isNaN(stemsAmount) || stemsAmount <= 0 || stemsAmount > 100){

    // 如果用户点击取消，那么退出循环
    if(stemAmount == null) break;

    // 展示错误信息
    alert("Please enter number in range from 2 to 100");

    // 要求再次输入
    stemsAmount = prompt("Processing \"" + originalStem.name + "\"\nHow many stems do you need? (From 2 to 100)", 12);
};

// 运行这个复制的过程
if(stemsAmount != null){
    // 计算旋转的角度
    var angle = 360 / parseInt(stemsAmount);

    // 创建一个图层组
    var stemsGroup = app.activeDocument.layerSets.add();
    stemsGroup.name = originalStem.name = " ("+stemsAmount + " stems)";

    // 把最开始的那个图层也放入图层组里
    originalStem.move(stemsGroup, ElementPlacement.INSIDE);

    // 复制并且旋转图层组里的图层
    for(var i = 1; i < stemsAmount; i++){

        // 复制最初的图层，并且将其保存为一个变量 newStem
        var newStem = originalStem.duplicate();

        // 旋转新图层
        newStem.rotate(angle * i, AnchorPosition.MIDDLECENTER);

        // 给新图层添加索引
        newStem.name = originalStem.name + " " + (i + 1);

        // 把新图层放入图层组里
        newStem.move(stemsGroup, ElementPlacement.PLACEATEND);
        };

        // 给最初的图层也添加一个索引1
        originalStem.name += " 1)";
};

将一个文档里的每一个图层都单独保存为png文件

/*
ps编程参考
https://www.adobe.com/content/dam/acom/en/devnet/photoshop/pdfs/photoshop-cc-javascript-ref-2019.pdf

ps编程指导
​https://www.adobe.com/content/dam/acom/en/devnet/photoshop/pdfs/photoshop-cc-scripting-guide-2019.pdf


我是gumou
*/


///////////////////////////////////Help Functions///////////////////////////////////////////////
function GetArtLayers (doc, allLayers){
    for (var m = 0; m < doc.layers.length; m++){
        var theLayer = doc.layers[m];
        if (theLayer.typename === "ArtLayer"){
            allLayers.push(theLayer);
        }else{
            GetArtLayers(theLayer, allLayers);
        }
    }
    return allLayers;
}
function printLayersName(layerss){
    var text  = "";
    for(var i = 0; i < layerss.length; i++){
        var layer = layerss[i];
        text = text + layer.name + "\n";
    }
    alert(text);
}
//////////////////////////////////////////////////////////////////////////////////



var doc = app.activeDocument;
var layers = [];
layers = GetArtLayers(doc,layers);

/////////////////////////////////////////
var prefix = "prefix_";      //在这里修改导出文件的前缀，单词文件名为 前缀+图层名
var folderpath = doc.path + "/";  //在这里修改导出的位置，默认为psd文件所在位置
/////////////////////////////////////////



var vlayers = [];
//保存所有可见的类，并隐藏
for(var i = 0; i < layers.length; i++){
    var layer = layers[i];
    if (layer.visible == true) {
        vlayers.push(layer);
        layer.visible = false;
    }
}

for(var i = 0; i < layers.length; i++){
    var layer = layers[i];
    //如果图层不是 allLocked状态，导出
    if (!layer.allLocked) {
        layer.visible = true;
        //保存
        var filename = prefix + layer.name;
        var file = new File(folderpath + filename+ ".png");
        var saveOptions = new PNGSaveOptions();
        doc.saveAs(file, saveOptions, true, Extension.NONE);
        //隐藏
        layer.visible = false;
    }
}

//printLayersName(vlayers)


for(var i = 0; i < vlayers.length; i++){
    var layer = vlayers[i];
    layer.visible = true;
}

①：Hello World

// 记住当前单位设置，然后将单位设置该脚本所指定的值
var originalUnit = preferences.rulerUnits
preferences.rulerUnits = Units.INCHES

// 创建一个新的2x4英寸文档并将其分配给变量
var docRef = app.documents.add( 2, 4 )

// 创建一个包含文字的新艺术层
var artLayerRef = docRef.artLayers.add()
artLayerRef.kind = LayerKind.TEXT


// 设置文本层的内容
var textItemRef = artLayerRef.textItem
textItemRef.contents = "大家好，我是大吉哥"


// 发布参考
docRef = null
artLayerRef = null
textItemRef = null

// 恢复原始标尺单位设置
app.preferences.rulerUnits = originalUnit

②： 三种弹框以及在控制台打印

$.writeln("我是第一个hello world");
$.write ("hello world");

// 这是第一种弹框
// alert ("Hello 我是一个警告框", "警告框的标题", false);

// 这是第二个弹框
// 第二个参数如果是false，默认选择yes，如果是true，默认选择no
// var a = confirm ("这是一个确认框", false, "这里是确认框的标题");
// $.writeln("你选择了：" + a);

// 确认框更多的时候会这样用
/*
if(a == true){
    $.writeln("用户选择了：" + a);
    }else if(a == false) {
        $.writeln("用户选择了:" + a);
        }
*/


// 这是第三个弹框
var b = prompt ("这是一个提示输入框", "我是提示输入框中的默认值哦", "这是提示输入框的标题");
$.writeln(b);

③：在一个新的工作文档中新建一个画布

var newDoc = app.documents.add();

④： 打开一张图片

open(File("C:/Users/CNX/Desktop/liuji/study/PS/0358.gif_wh300.gif"));

⑤：打开打开文件对话框

open(File(openDialog()));

⑥：将该图层旋转一定角度之后，复制一份新图层

// 保存选中的图层到变量originalStem 
var originalStem = app.activeDocument.activeLayer;

// 通过显示提示框要求用户输入并将输入的值保存到变量
var stemsAmount = prompt("Processing \"" + originalStem.name + "\"\nHow many stems do you need?", 12);

// 计算旋转的角度
var angle = 360 / stemsAmount;

//复制并且旋转图层
for(var i = 1; i < stemsAmount; i++){

    // 复制原始图层并将其保存到变量中newStem中
    var newStem = originalStem.duplicate();

    // 旋转新图层
    newStem.rotate(angle * i, AnchorPosition.BOTTOMCENTER);
};

⑦：通过构造器创建对象

function Person(name){
        this.name = name;

        this.play = function(param){
            $.writeln(param);
            }
    }

var a = new Person("小明");

$.writeln(a.name);

a.play("打篮球");

9：新建一个200*200的文档，并在背景图层上方新建一个同等大小的透明图层

preferences.rulerUnits = Units.PIXELS; 
var docRef = app.documents.add(200, 200); 
var layer = docRef.artLayers.add();
layer.name = 'footer';

10：PS执行播放提示音效命令

app.beep();

11：关闭当前文档

app.activeDocument.close();

12: 当前文档的当前选区的羽化值设定为10

app.activeDocument.selection.feather(10);

13：当前文档的当前图层的透明度设置为50

app.activeDocument.activeLayer.alpha = 50;

14：在弹框中显示当前应用名称以及该应用的版本信息

var message = "Welcome to" + app.name + "\r\nVersion" + app.version;
alert(message);

初识PS脚本

遍历最近打开的文档，并用alert弹框显示

// 义一个变量[recntFiles]，表示Photoshop最近打开的文件。
var recentFiels  = app.recentFiles;
// 定义一个变量[message]，用来在之后的代码中，存储所有曾经打开的文件的名称。
var message = "";

// 添加一个循环语句，用来遍历文件列表，用来把所有文件的名称添加到[message]变量。
for(var i=0; i<recentFiels.length; i++)
{
    message += (i+1) + ":" + recentFiels[i].name + "\r\n";
};

// 调用[alert]命令，将[message]存储的信息显示出来。点击[文件]菜单，保存当前文件。
alert(message);

输出当前文档的信息

// 定义一个变量[docs]，它是一个数组，用来存储Photoshop当前已打开的所有文档。
var docs = app.documents;
// 定义一个变量[message]，它的默认值为空。这个变量将在后面的代码中起到保存所有文档尺寸信息的作用。
var message = "";

// 添加一个for循环语句，用来遍历[docs]数组里面的元素，也就是Photoshop当前已打开的所有文档。
for(var i=0; i<docs.length; i++)
{
    // docs[i]表示第i个文档，这条语句的作用是将遍历到的文档的名称、宽度、高度等信息使用+号连接成一个字符串，并累加存入到[message]变量中。
    message += docs[i].name+":"+docs[i].width+"*"+docs[i].height+"\r\n";
}

// 调用[alert]命令，打开警告框，显示[message]的最终结果。
alert(message);

遍历系统中的所有字体

// 新建一个变量[fonts]，它是一个数组，用来存储系统中的所有字体。
var fonts   = app.fonts;
// 新建一个变量[message]，它的默认值为空。这个变量将在后面的代码中起到保存字体信息的作用。
var message = "";

// 创建一个for循环，用来遍历[fonts]数组里面的元素，也就是系统字体。
for(var i=0; i<fonts.length; i++)
{
    // fonts[i]表示第i个字体，这条语句的作用是将序号和字体的名称，用+号连接成一个字符串，并累加存入到[message]变量中。
    message += (i+1)+" - "+fonts[i].name+"\r\n";
}

// 使用[alert]命令，打开警告框，显示[message]的最终结果。
alert(message);

随机设置前景色和背景色

// [confirm]命令会弹出一个包含[是/否]的确认框，由用户决定是否执行某一个操作。
// 选择的结果[是/否]将保存在[answer]变量里。
var answer = confirm("您需要随机设置前景色和背景色吗？");

// 判断用户的选择，如果用户选择[是]，则执行接下来的动作。
if(answer) 
{
    app.foregroundColor.rgb.red   = Math.random() * 255;
    app.foregroundColor.rgb.green = Math.random() * 255;
    app.foregroundColor.rgb.blue  = Math.random() * 255;
    app.backgroundColor.rgb.red   = Math.random() * 255;
    app.backgroundColor.rgb.green = Math.random() * 255;
    app.backgroundColor.rgb.blue  = Math.random() * 255;
}

文档操作

创建一个空白文档

//定义一个变量[Width]，表示新文档的宽度。
var width = 560;

//定义一个变量[height]，表示新文档的高度。
var height = 560;

//定义一个变量[resolution]，表示新文档的分辨率。
var resolution = 72;

//定义一个变量[docName]，表示新文档的名称。
var docName = "New Document";

//定义一个变量[mode]，表示新文档的颜色模式。
var mode = NewDocumentMode.RGB;

//定义一个变量[initialFill]，表示新文档的默认背景填充颜色。
var initialFill = DocumentFill.TRANSPARENT;

//定义一个变量[pixelAspectRatio]，用来设置新文档的像素比率。
var pixelAspectRatio = 1;

//使用[Documents.add]命令创建一个新文档，将设置好的参数放在[add]方法里面。
app.documents.add(width, height, resolution, docName, mode, initialFill, pixelAspectRatio);

创建一个新文档和一个文字图层

//定义一个变量[docRef]，用来表示新建的文档。
//相对于上一节来说，[app.documents.add]命令只传入宽度和高度参数来创建一个空白文档。
var docRef = app.documents.add(500, 300);

//定义一个变量[artLayerRef]，用来表示新建的图层。调用[artLayers]对象的[add]命令，在当前文档新建一个图层。
var artLayerRef = docRef.artLayers.add();

//将新建图层的属性设置为文字图层。图层类型有十几种，例如3D、视频等，详情可查阅Adobe官网上的Photoshop脚本手册。 
artLayerRef.kind = LayerKind.TEXT;

//定义一个变量[textItemRef]，表示一个新的文本对象。
var textItemRef = artLayerRef.textItem;

//设置这个文本对象的文本内容。
textItemRef.contents = "Hello, Photoshop Script!";

//设置这个文本对象的文本尺寸。
textItemRef.size = 40;

//使用[translate]命令移动文本图层，[0]表示横向移动的距离，[120]表示纵向的移动距离。
//Photoshop的原点是在文档的左上角，而不是在左下角。
artLayerRef.translate(0, 120);

打开一个硬盘里面已经存在的图片文档

//定义一个变量[sampleDoc]，用来表示硬盘上的一个图片文档。
var sampleDoc = File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/galaxy-z-flip-screenshot-reset-network-settings.jpg");

//定义一个变量[message]，用来表示一个字符串。
var message = "您要打开示例文档吗？";

//定义一个变量[answer]，用来表示在弹出的确认警告框里，用户是点击了[是]还是[否]。
var answer = confirm(message);

// 如果用户点击了[是]，则使用[open]命令，在Photoshop中打开指定的图片。
if (answer) 
    open(sampleDoc);

打开一个目录下所有的文档

//定义一个变量[sampleFolder]，用来表示硬盘某个路径上的文件夹。
var samplesFolder = Folder("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1");

//定义一个变量[fileList]，用来表示使用[getFiles]命令获得的文件夹下的所有文档。
var fileList = samplesFolder.getFiles();

//创建一个for循环，用来遍历[fileList]数组里面的所有文档。
for (var i=0; i<fileList.length; i++) 
{
    //先判断是否正常文档，然后使用[open]命令打开文档。
    if (fileList[i] instanceof File) 
        open(fileList[i]);
}

另存当前文档

//定义一个变量[document]，用来表示Photoshop当前的活动文档。
var document = app.activeDocument;

//定义一个变量[fileOut]，用来指定文件保存的路径。
var fileOut = new File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out");

//定义一个变量[options]，用来指定图片保存的格式为PNG。
var options = PNGSaveOptions;

//定义一个变量[asCopy]，用来指定图片以副本的方式保存。
var asCopy = true;

//定义一个变量[extensionType]，用来指定图片名称的后缀为小写的.png。
var extensionType = Extension.LOWERCASE;

//使用[document]对象的[saveAs]方法保存当前图片。
document.saveAs(fileOut, options, asCopy, extensionType);

查看图层边界信息

//定义一个变量[activeLayer]，表示Photoshop当前文档的当前图层。
var activeLayer = app.activeDocument.activeLayer;

//定义一个变量[bounds]，表示当前图层的边界信息。
var bounds = activeLayer.bounds;

//使用[alert]命令，弹出警告框，显示变量[bounds]的具体内容。
alert(bounds);

复制当前文档

//定义一个变量[document]，用来表示Photoshop当前的活动文档。
var document = app.activeDocument;

//定义一个变量[name]，用来设置复制的新文档的名称。
var name = "New Document";

//定义一个变量[mergeLayersOnly]，用来表示是否只复制合并的图层。
var mergeLayersOnly = 1;

// 调用document的[duplicate]方法，复制当前文档。
document.duplicate(name, mergeLayersOnly);

将当前文档保存为一个新的gif文档

//定义一个变量[document]，用来表示Photoshop当前的活动文档。
var document = app.activeDocument;

//定义一个变量[fileOut]，用来表示导出的GIF图片路径。
var fileOut = new File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out/test1.gif");

//定义一个变量[exportOptionsSaveForWeb]，用来表示导出文档为Web格式的设置属性。
var exportOptionsSaveForWeb = new ExportOptionsSaveForWeb();

//设置导出文档时，是否支持文档的透明度。
exportOptionsSaveForWeb.transparency = false;

//设置导出文档时，是否包含文档中内置的颜色档案(即色彩空间配置文件)。
exportOptionsSaveForWeb.includeProfile = true;

//设置导出文档时，有损压缩的程度。
exportOptionsSaveForWeb.lossy = 0;

//设置导出文档时，图片包含的色彩量(256种颜色)。
exportOptionsSaveForWeb.colors = 256;

//设置导出文档时，图片的减色算法为默认值ColorReductionType.SELECTIVE。共有9种压缩算法，详情请查看Photoshop脚本手册。
exportOptionsSaveForWeb.colorReduction = ColorReductionType.SELECTIVE;

//设置导出文档时，图片将被存储为.gif格式。
exportOptionsSaveForWeb.format = SaveDocumentType.COMPUSERVEGIF;

//设置导出文档时，图片的像素抖动值。
exportOptionsSaveForWeb.ditherAmount = 0;

//设置导出文档时，图片的像素抖动类型。抖动类型共有4种，详情请查看Photoshop脚本手册。
exportOptionsSaveForWeb.dither = Dither.NOISE;

//设置导出文档时，图片的调色板的类型。调色板类型共有12种，详情请查看Photoshop脚本手册。
exportOptionsSaveForWeb.palette = Palette.LOCALADAPTIVE;

//调用[document]的[exportDocument]方法，使用上面设置的各种参数，将当前文档导出并转换为GIF格式的文档。
document.exportDocument(fileOut, ExportType.SAVEFORWEB, exportOptionsSaveForWeb);

压缩并输出jpg图片

//定义一个变量[document]，用来表示Photoshop当前的活动文档。
var document = app.activeDocument;

//定义一个变量[fileOut]，用来表示导出后的GIF图片路径。
var fileOut = new File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out/aaa.jpg");

//定义一个变量[exportOptionsSaveForWeb]，用来表示导出文档为Web格式的设置属性。
var exportOptionsSaveForWeb = new ExportOptionsSaveForWeb();

//设置导出文档时，图片将被存储为.jpeg格式。
exportOptionsSaveForWeb.format = SaveDocumentType.JPEG;

//设置导出文档时，图片的压缩质量。数字范围为1至100。
exportOptionsSaveForWeb.quality = 60;  

//调用[document]的[exportDocument]方法，使用上面设置的各种参数，将当前文档导出并转换为JPEG格式的文档。
document.exportDocument(fileOut, ExportType.SAVEFORWEB, exportOptionsSaveForWeb);

压缩并输出PNG图片

//定义一个变量[document]，用来表示Photoshop当前的活动文档。
var document = app.activeDocument;

//定义一个变量[fileOut]，用来表示导出后的GIF图片路径。
var fileOut = new File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out/bbb.png");

//定义一个变量[exportOptionsSaveForWeb]，用来表示导出文档为Web格式的设置属性。
var exportOptions = new ExportOptionsSaveForWeb();

//设置导出文档时，图片将被执行PNG-8压缩，如果值为false则执行PNG-24压缩，如果追求速度甚于质量请设置为true。
exportOptions.PNG8 = true;

// 调用[document]的[exportDocument]方法，使用上面设置的各种参数，将当前文档导出并转换为PNG格式的文档。
document.exportDocument(fileOut, ExportType.SAVEFORWEB, exportOptions);

关闭所有打开的文档

//使用[while]创建一个循环语句，循环执行大括号里的动作。
//直到while后面的条件为false，即当前Photoshop程序不存在打开的文档了。
while(app.documents.length > 0) 
{
    //调用[document]对象的[close]方法，关闭文档。[close]方法里的参数保证关闭文档时，不再保存文档。
    app.activeDocument.close(SaveOptions.DONOTSAVECHANGES);
}

图像处理

调节图像的亮度和对比度

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[brightness]，用来表示修改的亮度值。
var brightness = 30;

//定义一个变量[contrast]，用来表示修改的对比度值。
var contrast = 30;

//调用[layer]对象的[adjustBrightnessContrast]方法，并传入前面设置好的参数，来调整图像的亮度和对比度。
layer.adjustBrightnessContrast(brightness,contrast);

使用自动对比度

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[autoContrast]方法，来自动调整图像的对比度。
layer.autoContrast();

使用色阶调整图像

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[inputRangeStart]，用来表示阴影输入色阶值。
var inputRangeStart = 32;

//定义一个变量[inputRangeEnd]，用来表示高光输入色阶值。
var inputRangeEnd = 145;

//定义一个变量[inputRangeGamma]，用来表示中间调输入色阶值。
var inputRangeGamma = 1.00;

//定义一个变量[outputRangeStart]，用来表示阴影输出色阶值。
var outputRangeStart = 0;

//定义一个变量[outputRangeEnd]，用来表示高光输出色阶值。
var outputRangeEnd = 255;

//调用[layer]对象的[adjustLevels]方法，并传入前面设置好的参数，来调整图像的色阶。
layer.adjustLevels(inputRangeStart, inputRangeEnd, inputRangeGamma, outputRangeStart, 
outputRangeEnd);

使用自动色调

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[autoLevels]方法，来自动调整图像的色阶。
layer.autoLevels();

使用曲线调整图像

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[curveShape]，用来表示曲线上三个点的坐标。
//每个坐标的第一个值表示输入值(所选点的当前强度)，第二个值表示输出值(所选点的新强度)。
var curveShape = [[36, 2], [87, 135], [255, 255]];

//调用[layer]对象的[ajustCurves]方法，来调用曲线功能处理当前图像。
layer.adjustCurves(curveShape);

色彩平衡的使用

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[shadows]，用来表示阴影的色阶值。
var shadows = [0, 0, 0];

//定义一个变量[midtones]，用来表示中间调的色阶值。
var midtones = [100, 0, 60];

//定义一个变量[shadows]，用来表示高光的色阶值。
var highlights = [0, 0, 0];

//定义一个变量[preserveLuminosity]，用来表示是否保持明度。
var preserveLuminosity = true;

//调用[layer]对象的[ajustColorBalance]方法，来调整图像的色彩均衡。
layer.adjustColorBalance(shadows, midtones, highlights, preserveLuminosity);

照片滤镜的使用

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[fillColor]，用来表示[照片滤镜]的颜色。
var fillColor = app.foregroundColor;

//定义一个变量[density]，用来表示[照片滤镜]的颜色深度。
var density = 100;

//定义一个变量[preserveLuminosity]，用来表示是否保留明度。
var preserveLuminosity = true;

//调用[layer]对象的[photoFilter]方法，来调用系统的[照片滤镜]。
layer.photoFilter(fillColor, density, preserveLuminosity);

反相

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[invert]方法，来反转图像的色彩。
layer.invert();

图像的色调分离

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer  = app.activeDocument.activeLayer;

//定义一个变量[levels]，用来设置[色调分离]的[色阶]值。
var levels = 2;

//调用[layer]对象的[posterize]方法，来调用系统的[色调分离]功能。点击[Ctrl + S]快捷键保存完成的脚本。
layer.posterize(levels);

调整图像的阈值

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[levels]，用来设置[阈值]的[色阶]值。
var level = 109;

//调用[layer]对象的[threshould]方法，来调用系统的[阈值]功能。
layer.threshold(level);

使用去色功能

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[desaturate]方法，来调用系统的[去色]功能。
layer.desaturate();

色调均化的使用

//定义一个变量[layer]，用来表示Photoshop当前文档的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[equalize]方法，来调用系统的[色调均化]功能。点击[Ctrl + S]快捷键保存完成的脚本。
layer.equalize();

设置图像的大小

//定义一个变量[document]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//定义一个变量[width]，用来表示图像调整后的宽度。
var width = 600;

//定义一个变量[height]，用来表示图像调整后的高度。
var height = 400;

//定义一个变量[resolution]，用来表示图像调整后的分辨率。
var resolution = 72;

//定义一个变量[resampleMethod]，用来表示图像调整后的重采样方法为自动模式。
var resampleMethod = ResampleMethod.AUTOMATIC;

//定义一个变量[amount]，用来表示图像调整后的噪点值。
var amount = 50;

//调用[document]对象的[resizeImage]方法，来重新设置图像大小。
document.resizeImage(width, height, resolution, resampleMethod, amount);

设置画布的大小

//定义一个变量[document]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//定义一个变量[width]，用来表示画布调整后的宽度。
var width = 600;

//定义一个变量[height]，用来表示画布调整后的高度。
var height = 400;

//定义一个变量[anchor]，用来表示画布调整时的参考锚点。这里设置以画布的中心点为锚点。
var anchor = AnchorPosition.MIDDLECENTER;

//调用[document]对象的[reiszeCanvas]方法，来重新设置画布大小。
document.resizeCanvas(width, height, anchor);

翻转画布

//定义一个变量[document]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//调用[document]对象的[flipCanvas]方法，来翻转画布。此处设置为水平翻转。
document.flipCanvas(Direction.HORIZONTAL);

//然后进行一次垂直方向的翻转。
document.flipCanvas(Direction.VERTICAL);

旋转画布

//定义一个变量[document]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//定义一个变量[angle]，用来表示画布旋转的角度。
var angle = 45;

//调用[document]对象的[rotateCanvas]方法，来旋转当前画布。
document.rotateCanvas(angle);

裁剪文档

//定义一个变量[document]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//定义一个变量[bounds]，用来表示文档需要裁切的区域，即裁切从坐标[0,0]至[140,104]的区域。
//注意Photoshop坐标原点在左上角。
var bounds = [0, 0, 140, 104];

//定义一个变量[angle]，用来设置裁切的旋转角度为0。
var angle = 0;

//调用[document]对象的[crop]方法，来裁切当前文档。
document.crop(bounds, angle);

使用图层

新建图层

//调用[artLayers]对象的[add]方法，创建一个图层。
var layerRef = app.activeDocument.artLayers.add();

根据名称查找图层，然后设置该图层的填充

//调用[artLayers]对象的[getByName]方法，获得一个图层并将查找的结果用[layerRef]变量表示。
var layerRef = app.activeDocument.artLayers.getByName("Art");

//设置查找到的图层的透明度为20，透明度的取值范围为0至100。
layerRef.fillOpacity = 20;

删除当前图层

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;


//调用[layer]对象的[remove]方法，将该图层从图层列表中删除。
layer.remove();

通过拷贝建立一个新图层

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[copy]方法，将该图层拷贝到内存中。
layer.copy();

//调用[document]对象的[paste]方法，将内存中的拷贝，粘贴到当前文档。
app.activeDocument.paste();

剪切图层

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[cut]方法，将该图层剪切到内存中。
layer.cut();

//调用[document]对象的[paste]方法，将内存中的拷贝，粘贴到当前文档。
app.activeDocument.paste();

复制一个图层到指定的图层后面

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer  = app.activeDocument.activeLayer;

//定义一个变量[layers]，用来表示Photoshop的当前文档的所有图层。
var layers = app.activeDocument.layers;

//调用[layer]对象的[duplicate]方法，复制当前图层，并插入到所有图层的后面。
layer.duplicate(layers[5], ElementPlacement.PLACEAFTER);

移动图层到指定索引图层的后面

注：索引应该是从上到下，从0开始

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer  = app.activeDocument.activeLayer;

//定义一个变量[layers]，用来表示Photoshop的当前文档的所有图层。
var layers = app.activeDocument.layers;

//调用[layer]对象的[move]方法，移动当前图层，并插入到所有图层的后面。
layer.move(layers[4], ElementPlacement.PLACEAFTER);

移动图层在平面上的位置

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[translate]方法，让图层在横向和纵向各移动100像素。
layer.translate(100,100);

旋转当前图层一定的角度

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[rotate]方法，将图层旋转45度，旋转锚点处于图层的中心位置。
layer.rotate(45, AnchorPosition.MIDDLECENTER);

缩放当前图层

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[horizotalRate]，用来表示横向缩放比例为50%。
var horizontalRate = 50;

//定义一个变量[verticalRate]，用来表示纵向缩放比例为50%。
var verticalRate = 50;

//定义一个变量[anchor]，用来表示图层缩放的锚点为当前图层的中心位置。
var anchor = AnchorPosition.MIDDLECENTER;

//调用[layer]对象的[resize]方法，将图层沿横向和纵向均缩小50%。
layer.resize(horizontalRate, verticalRate, anchor);

将当前图层与所有图层进行链接

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[count]，用来表示当前文档所有图层的数量。
var count = app.activeDocument.layers.length;

//添加一个循环语句，用来遍历所有图层。
for (var x = 0; x < count; x++) 
{
    //调用[layer]对象的[link]方法，将当前图层与图层列表中所有图层进行链接。
    layer.link(app.activeDocument.layers[x]);
}

栅格化文字图层

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[rasterize]方法，将当前图层进行文本类型的栅格化。
layer.rasterize(RasterizeType.TEXTCONTENTS);

合并所有可见图层

//定义一个变量[layer]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//调用[document]对象的[mergeVisibleLayers]方法，合并当前文档的所有可见图层。
document.mergeVisibleLayers();

合并链接图层

//定义一个变量[layers]，用来表示Photoshop当前文档的所有图层。
var layers = app.activeDocument.artLayers;

//添加一个循环语句，用来遍历所有图层。
for(var i=0; i<layers.length; i++)
{
    //检测遍历到的图层如果不是背景图层，则继续后面的动作。
    if(!layers[i].isBackgroundLayer)
    {
        //定义一个变量[linkedLayers]，获取当前遍历到的图层的所有链接图层。
        var linkedLayers = layers[i].linkedLayers;
        //检测如果遍历到的图层拥有链接图层，则继续后面的动作。
        if(linkedLayers.length > 0)
        {
            //调用[layer]对象的[merge]方法，合并链接图层。
            layers[i].merge(linkedLayers[i]);
        }
    }
}

合并所有图层

//定义一个变量[document]，用来表示Photoshop的当前文档。
var document = app.activeDocument;

//调用[document]对象的[flatten]方法，合并文档的所有图层。
document.flatten();

锁定图层组里的所有图层

//定义一个变量[layerSetRef]，用来表示根据名称查找到的图层组。
var layerSetRef = app.activeDocument.layerSets.getByName("aaa");

//调用[layerSetRef]对象的[allLocked]方法，锁定图层组下所有图层。
layerSetRef.allLocked = true;

查看当前图层的锁定状态

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[alert]变量，弹出警告框，显示当前图层的像素是否被锁定。
alert("Is pixels locked:" + layer.pixelsLocked);

//调用[alert]变量，弹出警告框，显示当前图层的位置是否被锁定。
alert("Is position locked:" + layer.positionLocked);

//调用[alert]变量，弹出警告框，显示当前图层的透明度是否被锁定。
alert("Is transparentPixels locked:" + layer.transparentPixelsLocked);

使用选区

创建选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[20,20],[120,20],[120,120],[20,120]];

//定义一个变量[type]，表示构建选区的方式。
//当前使用的是默认选项，即如果当前文档已经存在选区，则取消已存在的选区后，再构建新的选区。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

同时创建多个选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region1  = [[0,0],[100,0],[100,100],[0,100]];

//定义一个变量[region2]，表示第二个选区的范围。
var region2  = [[150,150],[200,100],[100,100]];

//定义一个变量[type1]，表示第一个选区的类型。
var type1 = SelectionType.REPLACE;

//定义一个变量[type2]，表示第二个选区的类型。此类型设置为扩展(即与前一个选区相加)。
var type2 = SelectionType.EXTEND;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，创建第一个选区。
app.activeDocument.selection.select(region1, type1, feather, antiAlias);

//使用同样的方式，创建第二个选区。
app.activeDocument.selection.select(region2, type2, feather, antiAlias);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

如何取消选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region1  = [[20,20],[120,20],[120,120],[20,120]];

//定义一个变量[type]，表示创建选区的方式。
//当前使用的是默认选项，即如果当前文档已经存在选区，则取消已存在的选区后，再创建新的选区。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示创建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示创建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档创建一个选区。
app.activeDocument.selection.select(region1, type, feather, antiAlias);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

//通过调用[selection]对象的[deselect]方法，取消当前文档的选区。
app.activeDocument.selection.deselect();

清除一个选区的内容

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region1  = [[20,20],[120,20],[120,120],[20,120]];

//定义一个变量[type]，表示创建选区的方式。
//当前使用的是默认选项，即如果当前文档已经存在选区，则取消已存在的选区后，再创建新的选区。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示创建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示创建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档创建一个选区。
app.activeDocument.selection.select(region1, type, feather, antiAlias);

//通过调用[selection]对象的[clear]方法，清除当前选区里的内容。
app.activeDocument.selection.clear();

反转当前选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//通过调用[selection]对象的[invert]方法，反选当前选区之外的内容。
app.activeDocument.selection.invert();

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

羽化当前选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//通过调用[selection]对象的[feather]方法，给当前选区设置值为20像素的羽化效果。
app.activeDocument.selection.feather(20);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

平滑当前选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//通过调用[selection]对象的[smooth]方法，给当前选区设置值为10像素的平滑效果。
app.activeDocument.selection.smooth(10);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

扩大当前选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[number]，作为选区扩展的距离。
var number  = 20;

//通过调用[selection]对象的[expand]方法，将当前选区向外扩展20像素。
app.activeDocument.selection.expand(number);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

改变当前选区内容的尺寸

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[horizontal]，表示选区缩放的横向百分比。
var horizontal = 50;

//定义一个变量[vertical]，表示选区缩放的纵向百分比。
var vertical = 50;

//通过调用[selection]对象的[resize]方法，缩放当前选区。
app.activeDocument.selection.resize(horizontal, vertical, AnchorPosition.MIDDLECENTER);

改变当前选区的尺寸

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[horizontal]，表示选区缩放的横向距离。
var horizontal = 50;

//定义一个变量[vertical]，表示选区缩放的纵向距离。
var vertical = 50;

//通过调用[selection]对象的[resizeBoundary]方法，设置边框选区效果。
app.activeDocument.selection.resizeBoundary(horizontal, vertical, AnchorPosition.MIDDLECENTER);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

使用Grow命令扩展选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[tolerance]，表示选区的扩展程度值。
var tolerance = 30;

//通过调用[selection]对象的[grow]方法，选区将向四周扩展。
app.activeDocument.selection.grow(tolerance, antiAlias);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

选取相似的颜色的区域

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[tolerance]，表示选区的扩展程度值。
var tolerance = 32;

//通过调用[selection]对象的[similar]方法，选区将向四周按相似颜色的程度进行扩展。
app.activeDocument.selection.similar(tolerance,  antiAlias);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

移动当前选区的内容

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[deltaX]，表示横向的移动值。
var deltaX = 60;

//定义一个变量[deltaY]，表示纵向的移动值。
var deltaY = 60;

//通过调用[selection]对象的[translate]方法，在横向和纵向各移动选区内容60像素。
app.activeDocument.selection.translate(deltaX, deltaY);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

移动当前选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[deltaX]，表示横向的移动值。
var deltaX = 60;

//定义一个变量[deltaY]，表示纵向的移动值。
var deltaY = 60;

//通过调用[selection]对象的[translateBoundary]方法，在横向和纵向各移动选区60像素。
app.activeDocument.selection.translateBoundary(deltaX, deltaY);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

旋转当前选区的内容

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[angle]，表示选区的旋转角度。
var angle   = 45;

//定义一个变量[anchor]，表示选区的旋转锚点为选区的中心位置。
var anchor = AnchorPosition.MIDDLECENTER;

//通过调用[selection]对象的[rotate]方法，旋转当前选区的内容。
app.activeDocument.selection.rotate(angle, anchor);

旋转当前选区

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[angle]，表示选区的旋转角度。
var angle   = 45;

//定义一个变量[anchor]，表示选区的旋转锚点为选区的中心位置。
var anchor = AnchorPosition.MIDDLECENTER;

//通过调用[selection]对象的[rotate]方法，旋转当前选区的内容。
app.activeDocument.selection.rotateBoundary(angle, anchor);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

设置选区的边框

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[width]，表示边界的宽度。
var width = 10;

//通过调用[selection]对象的[selectBorder]方法，并传入之前设置好的各项参数，来在当前文档构建一个边界选区。
app.activeDocument.selection.selectBorder(width);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的前景色。
app.activeDocument.selection.fill(app.foregroundColor);

给选区添加描边效果

//定义一个变量[region]，表示一定范围的区域。它的值是四个点的坐标。
var region = [[50,50],[150,50],[150,150],[50,150]];

//定义一个变量[type]，表示选择的类型。当前使用的是默认选项即替换之前的选区(如果有的话)。
var type = SelectionType.REPLACE;

//定义一个变量[feather]，表示构建选区时的羽化值。
var feather = 0;

//定义一个变量[antiAlias]，表示构建选区时是否抗锯齿。
var antiAlias = true;

//通过调用[selection]对象的[select]方法，并传入之前设置好的各项参数，来在当前文档构建一个选区。
app.activeDocument.selection.select(region, type, feather, antiAlias);

//定义一个变量[strokeColor]，表示描边的颜色。
var strokeColor = app.foregroundColor;

//定义一个变量[width]，表示描边的宽度。
var width = 5;

//定义一个变量[location]，表示描边的位置，即在选区外部进行描边。
var location = StrokeLocation.OUTSIDE;

//定义一个变量[mode]，表示描边的颜色混合模式，这里采用正常的颜色混合模式。
var mode = ColorBlendMode.NORMAL;

//定义一个变量[opacity]，表示描边的透明度。
var opacity = 100;

//定义一个变量[preserveTransparency]，表示描边是否保留透明度。
var preserveTransparency = true;

//通过调用[selection]对象的[stroke]方法，并传入之前设置好的各项参数，来进行描边。
app.activeDocument.selection.stroke(strokeColor, width, location, mode, opacity, preserveTransparency);

//通过调用[selection]对象的[fill]方法，给当前选区填充系统的背景色。
app.activeDocument.selection.fill(app.foregroundColor);

通道基础

通过通道名称查找通道

//通过调用[channels]对象的[getByName]方法，获得当前图像的红色通道。
var channelRef = app.activeDocument.channels.getByName("红");

//通过调用[alert]命令，弹出警告框，显示该图像的直方图信息。
alert(channelRef.histogram);

改变通道的颜色

//通过调用[channels]对象的[getByName]方法，获得一个自定义的通道。请注意，您是无法更改图像默认通道属性的。
var channelRef = app.activeDocument.channels.getByName("Alpha 2");

//通过调用[alert]命令，弹出警告框，显示该通道的颜色信息。
alert(channelRef.color.rgb.red+"/"+channelRef.color.rgb.green+"/"+channelRef.color.rgb.blue);

//将该通道的RGB颜色的blue值修改为255。
channelRef.color.rgb.blue = 255;

//通过调用[alert]命令，弹出警告框，显示该图像的直方图信息。
alert(channelRef.color.rgb.red+"/"+channelRef.color.rgb.green+"/"+channelRef.color.rgb.blue);

查看通道的属性

//通过调用[channels]对象的[getByName]方法，获得当前图像的红色通道。
var channelRef1 = app.activeDocument.channels.getByName("红");

//通过调用[channels]对象的[getByName]方法，获得当前图像的[Alpha 1]通道。
var channelRef2 = app.activeDocument.channels.getByName("Alpha 1");

//通过调用[alert]命令，弹出警告框，显示红色通道的信息。
alert(channelRef1.kind);

//通过调用[alert]命令，弹出警告框显示[Alpha 1]通道的信息。
alert(channelRef2.kind);

遍历文档所有的通道

//通过[document]对象的[channels]属性，获得当前图像的所有通道。
var channels = app.activeDocument.channels;

//定义一个变量[count]，表示通道的数量。
var count = channels.length;

//添加一个循环语句，用来遍历所有的通道。
for(var i=0 ; i<count; i++)
{
    //通道[alert]语句，查看通道的名称。
    alert(channels[i].name);
}

删除某一个通道

//通过[document]对象的[channels]属性，获得当前图像的所有通道。
var channels = app.activeDocument.channels;

//通过调用[channels]对象的[getByName]方法，获得当前图像的红色通道。
var channel  = channels.getByName("红");

//通过调用[channel]对象的[remove]方法，删除该通道。
channel.remove();

将通道信息写入文本文件(暂未试验成功）

//定义一个变量[fileOut]，表示硬盘上某个路径的文件。通道的文本信息将写入到这个文件。
var fileOut = new File("C:/Users/CNX/Desktop/liuji/study/Script/PS Script/jpg1/out/ChannelsInformation.log");

//设置文件的操作模式为写入模式。
fileOut.open("w", "TEXT", "????");

//通过[document]对象的[channels]属性，获得当前图像的所有通道。
var channels = app.activeDocument.channels;

//定义一个变量[count]，表示通道的数量。
var count = channels.length;

//构建一个循环语句，用来遍历所有的通道。
for(var i=0; i<count; i++)
{
    //将通道的名称和通道的直方图拼接在一起，并写入到文本文件里。
    fileOut.write(channels[i].name + ":" + channels[i].histogram + "/r/n/r/n");
}

//文件写入成功后，关闭文件的输入流。
fileOut.close();

神奇滤镜

模糊滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//创建一个持续三次的循环，这样可以使[模糊滤镜]的效果更明显些。
for(var i=0;  i<3;  i++)
{
    //调用[layer]对象的[applyBlur]方法，给图层添加模糊效果。
    layer.applyBlur();
}

高斯模糊滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[radius]，用来表示[高斯模糊]的程度。
var radius = 2.5;

//调用[layer]对象的[applyGaussianBlur]方法，给图层添加高斯模糊效果。
layer.applyGaussianBlur(radius);

运动模糊滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[angle]，用来表示[运动模糊]的角度。
var angle = 10;

//定义一个变量[radius]，用来表示[运动模糊]的半径。
var radius = 55;

//调用[layer]对象的[applyMotionBlur]方法，给图层添加运动模糊效果。
layer.applyMotionBlur(angle, radius);

锐化滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[applySharpen]方法，给图层添加锐化效果。
layer.applySharpen();

//再次调用[layer]对象的[applySharpen]方法，使锐化效果更明显些。
layer.applySharpen();

给图层添加杂色

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[amount]，用来表示杂色的数量。
var amount = 10;

//定义一个变量[distribution]，用来表示杂色的分布方式为高斯模式。
var distribution = NoiseDistribution.GAUSSIAN;

//定义一个变量[monochromatic]，用来表示杂色为单色模式。
var monochromatic = true;

//调用[layer]对象的[applyAddNoise]方法，给图层添加杂色效果。
layer.applyAddNoise(amount, distribution, monochromatic);

蒙尘与划痕滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[radius]，用来表示半径的大小。
var radius = 7;

//定义一个变量[hreshold]，用来表示阈值的大小。
var threshold = 0;

//调用[layer]对象的[applyDustAndScratches]方法，给图层添加蒙尘与划痕效果。
layer.applyDustAndScratches(radius, threshold);

云彩滤镜的使用

//[云彩滤镜]是根据前景色和背景色来模拟生成的。在此将前景色设为蓝色，背景色设为白色。
//设置系统的前景色RGB值的red值。
app.foregroundColor.rgb.red = 0;

//设置系统的前景色RGB值的green值。
app.foregroundColor.rgb.green = 125;

//设置系统的前景色RGB值的blue值。
app.foregroundColor.rgb.blue = 255;

//设置系统的背景色RGB值的red值。
app.backgroundColor.rgb.red = 255;

//设置系统的背景色RGB值的green值。
app.backgroundColor.rgb.green = 255;

//设置系统的背景色RGB值的blue值。
app.backgroundColor.rgb.blue = 255;

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[applyClouds]方法，给图层添加云彩滤镜效果。
layer.applyClouds();

镜头光晕滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[brightness]，用来表示光晕的明亮程度。
var brightness = 80;

//定义一个变量[flareCenter]，用来表示光晕的中心点坐标，在此设置中心点在文档左上角。
var flareCenter = [60,40];

//定义一个变量[lensType]，用来表示镜头光晕的类型。
var lensType = LensType.ZOOMLENS;

//调用[layer]对象的[applyLensFlare]方法，给图层添加镜头光晕效果。
layer.applyLensFlare(brightness, flareCenter, lensType);

扩散亮光滤镜的使用

//定义一个变量[graininess]，用来设置亮光中的颗粒密度。
var graininess = 1;

//定义一个变量[glowAmount]，设置亮光的强度。值越大，光芒越强烈。
var glowAmount = 10;

//定义一个变量[clearAmount]，设置图像中受亮光影响的范围。值越大，受影响的范围越小，图像越清晰。
var clearAmount = 15;

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//调用[layer]对象的[applyDiffuseGlow]方法，给图层添加扩散亮光效果。
layer.applyDiffuseGlow(graininess, glowAmount, clearAmount);

去斑滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//创建一个持续五次的循环，这样可以使[去斑滤镜]的效果更明显些。
for(var i=0; i<5; i++)
{
    //调用[layer]对象的[applyDespeckle]方法，给图层添加去斑效果。
    layer.applyDespeckle();
}

高反差保留滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[radius]，用来设置高反差保留的半径值。
var radius = 240;

//调用[layer]对象的[applyHighPass]方法，给图层添加高反差保留效果。
layer.applyHighPass(radius);

海洋波纹滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[size]，用来表示波纹的大小。
var size = 10;

//定义一个变量[magnitude]，用来表示波纹的幅度。
var magnitude = 15;

//调用[layer]对象的[applyOceanRipple]方法，给图层添加海洋波纹效果。
layer.applyOceanRipple(size, magnitude);

挤压滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[amount]，用来表示挤压的程度。
var amount = 100;

//调用[layer]对象的[applyPinch]方法，给图层添加挤压效果。
layer.applyPinch(amount);

最大化滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[radius]，用来表示最大化滤镜的半径值。
var radius = 10;

//调用[layer]对象的[applyMaximum]方法，给图层添加最大化效果。
layer.applyMaximum(radius);

最小化滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[radius]，用来表示最小化滤镜的半径值。
var radius = 5;

//调用[layer]对象的[applyMinimum]方法，给图层添加最小化效果。
layer.applyMinimum(5);

极坐标滤镜的使用

//定义一个变量[layer]，用来表示Photoshop的当前图层。
var layer = app.activeDocument.activeLayer;

//定义一个变量[conversion]，用来表示极坐标类型为从平面坐标转极坐标。
var conversion = PolarConversionType.RECTANGULARTOPOLAR;

//调用[layer]对象的[applyPolarCoordinates]方法，给图层添加极坐标效果。
layer.applyPolarCoordinates(conversion);

综合实例

更改默认历史记录数量

//定义一个变量[number]，用来设置系统最多保存50条历史记录。
var number = 50;

//修改[app]对象的[preferences]属性，将[numberofHistoryStates]参数设置为50。
app.preferences.numberofHistoryStates = number;

//调用[app]对象的[beep]方法，用于在完成一系列动作后，播放一个系统音效提示用户操作完成。
app.beep();