1261 lines
32 KiB
JavaScript
1261 lines
32 KiB
JavaScript
const app = window.require("photoshop").app
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
const { executeAsModal } = require("photoshop").core
|
|
const export_png = require("./export_png")
|
|
const { selectionToFinalWidthHeight } = require("./selection")
|
|
// const { layerToSelection } = require('./helper')
|
|
|
|
const storage = require("uxp").storage
|
|
const fs = storage.localFileSystem
|
|
|
|
async function createSolidLayer(r, g, b) {
|
|
await executeAsModal(async () => {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "make",
|
|
_target: [
|
|
{
|
|
_ref: "contentLayer",
|
|
},
|
|
],
|
|
using: {
|
|
_obj: "contentLayer",
|
|
type: {
|
|
_obj: "solidColorLayer",
|
|
color: {
|
|
_obj: "RGBColor",
|
|
red: r,
|
|
grain: g,
|
|
blue: b,
|
|
},
|
|
},
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
})
|
|
}
|
|
|
|
async function makeGroupCommand() {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "make",
|
|
_target: [
|
|
{
|
|
_ref: "layerSection",
|
|
},
|
|
],
|
|
layerSectionStart: 405,
|
|
layerSectionEnd: 406,
|
|
name: "Group 16",
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
|
|
console.log("makeGroupCommand: ", result)
|
|
|
|
return result
|
|
}
|
|
async function createEmptyGroup(name = "New Group") {
|
|
let groupLayer
|
|
await executeAsModal(async () => {
|
|
await makeGroupCommand()
|
|
groupLayer = app.activeDocument.activeLayers[0]
|
|
groupLayer.name = name
|
|
})
|
|
console.log("groupLayer:", groupLayer)
|
|
return groupLayer
|
|
}
|
|
|
|
async function moveToGroupCommand(to_index, layerIDs) {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
console.log("to_index:", to_index)
|
|
console.log("layerIDs:", layerIDs)
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "move",
|
|
_target: [
|
|
{
|
|
_ref: "layer",
|
|
_enum: "ordinal",
|
|
_value: "targetEnum",
|
|
},
|
|
],
|
|
to: {
|
|
_ref: "layer",
|
|
_index: to_index,
|
|
},
|
|
adjustment: false,
|
|
version: 5,
|
|
layerID: layerIDs,
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
}
|
|
function MoveToGroupExe(toIndex, layerIDs) {
|
|
try {
|
|
executeAsModal(async () => {
|
|
await moveToGroupCommand(toIndex, layerIDs)
|
|
})
|
|
} catch (e) {
|
|
console.warn("executeCommand error:", e)
|
|
}
|
|
}
|
|
|
|
async function getIndexCommand(layer_id) {
|
|
const idx = batchPlay(
|
|
[
|
|
{
|
|
_obj: "get",
|
|
_target: [
|
|
{
|
|
_property: "itemIndex",
|
|
},
|
|
{
|
|
_ref: "layer",
|
|
// _name: 'myGroup'
|
|
_id: layer_id,
|
|
},
|
|
],
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{ synchronousExecution: true }
|
|
)[0]["itemIndex"]
|
|
console.log("index:", idx)
|
|
return idx
|
|
}
|
|
|
|
async function getLayerIndex(layer_id) {
|
|
const { executeAsModal } = require("photoshop").core
|
|
try {
|
|
let index
|
|
await executeAsModal(async () => {
|
|
index = await getIndexCommand(layer_id)
|
|
console.log("getIndex: ", index)
|
|
})
|
|
return index
|
|
} catch (e) {
|
|
console.warn("getIndex error:", e)
|
|
}
|
|
}
|
|
|
|
async function unselectActiveLayers() {
|
|
const layers = await app.activeDocument.activeLayers
|
|
for (layer of layers) {
|
|
layer.selected = false
|
|
}
|
|
}
|
|
async function unselectActiveLayersExe() {
|
|
await executeAsModal(async () => {
|
|
await unselectActiveLayers()
|
|
})
|
|
}
|
|
async function selectLayers(layers) {
|
|
await unselectActiveLayers()
|
|
for (layer of layers) {
|
|
try {
|
|
if (layer) {
|
|
const is_visible = layer.visible // don't change the visibility when selecting the layer
|
|
layer.selected = true
|
|
layer.visible = is_visible
|
|
}
|
|
} catch (e) {
|
|
console.warn(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
async function selectLayersExe(layers) {
|
|
await executeAsModal(async () => {
|
|
await selectLayers(layers)
|
|
})
|
|
}
|
|
async function selectGroup(layer) {
|
|
await unselectActiveLayers()
|
|
layer.parent.selected = true
|
|
}
|
|
async function collapseGroup(layer) {
|
|
await selectGroup(layer)
|
|
await app.activeDocument.activeLayers[0].merge()
|
|
}
|
|
|
|
async function createMaskCommand() {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "make",
|
|
new: {
|
|
_class: "channel",
|
|
},
|
|
at: {
|
|
_ref: "channel",
|
|
_enum: "channel",
|
|
_value: "mask",
|
|
},
|
|
using: {
|
|
_enum: "userMaskEnabled",
|
|
_value: "revealSelection",
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
}
|
|
|
|
async function createMaskExe() {
|
|
const { executeAsModal } = require("photoshop").core
|
|
await executeAsModal(createMaskCommand)
|
|
}
|
|
|
|
//unselect the rectangular marquee selection area
|
|
async function unSelectMarqueeCommand() {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "set",
|
|
_target: [
|
|
{
|
|
_ref: "channel",
|
|
_property: "selection",
|
|
},
|
|
],
|
|
to: {
|
|
_enum: "ordinal",
|
|
_value: "none",
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
|
|
return result
|
|
}
|
|
async function unSelectMarqueeExe() {
|
|
await executeAsModal(unSelectMarqueeCommand)
|
|
}
|
|
////selection:
|
|
async function selectMarqueeRectangularToolExe() {
|
|
async function selectMarqueeRectangularToolCommand() {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "select",
|
|
_target: [
|
|
{
|
|
_ref: "marqueeRectTool",
|
|
},
|
|
],
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
return result
|
|
}
|
|
await executeAsModal(async () => {
|
|
await selectMarqueeRectangularToolCommand()
|
|
})
|
|
}
|
|
|
|
async function promptForMarqueeTool() {
|
|
;(async () => {
|
|
const r1 = await dialog_box.prompt(
|
|
"Please Select a Rectangular Area",
|
|
"You Forgot to select a Rectangular Area",
|
|
["Cancel", "Rectangular Marquee"]
|
|
)
|
|
if ((r1 || "Rectangular Marquee") !== "Rectangular Marquee") {
|
|
/* cancelled or No */
|
|
console.log("cancel")
|
|
} else {
|
|
/* Yes */
|
|
console.log("Rectangular Marquee")
|
|
selectMarqueeRectangularToolExe()
|
|
}
|
|
})()
|
|
}
|
|
|
|
async function selectLayerChannelCommand() {
|
|
// const result = await batchPlay(
|
|
// [
|
|
// {
|
|
// _obj: 'set',
|
|
// _target: [
|
|
// {
|
|
// _ref: 'channel',
|
|
// _property: 'selection'
|
|
// }
|
|
// ],
|
|
// to: {
|
|
// _ref: [
|
|
// {
|
|
// _ref: 'channel',
|
|
// _enum: 'channel',
|
|
// _value: 'transparencyEnum'
|
|
// },
|
|
// {
|
|
// _ref: 'layer',
|
|
// _name: 'Group 5'
|
|
// }
|
|
// ]
|
|
// },
|
|
// _options: {
|
|
// dialogOptions: 'dontDisplay'
|
|
// }
|
|
// }
|
|
// ],
|
|
// {
|
|
// synchronousExecution: false,
|
|
// modalBehavior: 'execute'
|
|
// }
|
|
// )
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "set",
|
|
_target: [
|
|
{
|
|
_ref: "channel",
|
|
_property: "selection",
|
|
},
|
|
],
|
|
to: {
|
|
_ref: "channel",
|
|
_enum: "channel",
|
|
_value: "transparencyEnum",
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
}
|
|
|
|
async function getSelectionInfoCommand() {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "get",
|
|
_target: [
|
|
{
|
|
_property: "selection",
|
|
},
|
|
{
|
|
_ref: "document",
|
|
_id: app.activeDocument._id,
|
|
},
|
|
],
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
|
|
return result
|
|
}
|
|
|
|
function isSelectionValid(selection) {
|
|
if (
|
|
selection && // check if the selection is defined
|
|
selection.hasOwnProperty("left") &&
|
|
selection.hasOwnProperty("right") &&
|
|
selection.hasOwnProperty("top") &&
|
|
selection.hasOwnProperty("bottom")
|
|
) {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
async function getSelectionInfoExe() {
|
|
console.log("getSelectionInfo was called")
|
|
|
|
try {
|
|
const selection = (await executeAsModal(getSelectionInfoCommand))[0]
|
|
.selection
|
|
|
|
if (isSelectionValid(selection)) {
|
|
let selection_info = {
|
|
left: selection.left._value,
|
|
right: selection.right._value,
|
|
bottom: selection.bottom._value,
|
|
top: selection.top._value,
|
|
height: selection.bottom._value - selection.top._value,
|
|
width: selection.right._value - selection.left._value,
|
|
}
|
|
// console.dir({selection_info})
|
|
return selection_info
|
|
}
|
|
} catch (e) {
|
|
console.warn("selection info error", e)
|
|
}
|
|
}
|
|
|
|
async function reSelectMarqueeCommand(selectionInfo) {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "set",
|
|
_target: [
|
|
{
|
|
_ref: "channel",
|
|
_property: "selection",
|
|
},
|
|
],
|
|
to: {
|
|
_obj: "rectangle",
|
|
top: {
|
|
_unit: "pixelsUnit",
|
|
_value: selectionInfo.top,
|
|
},
|
|
left: {
|
|
_unit: "pixelsUnit",
|
|
_value: selectionInfo.left,
|
|
},
|
|
bottom: {
|
|
_unit: "pixelsUnit",
|
|
_value: selectionInfo.bottom,
|
|
},
|
|
right: {
|
|
_unit: "pixelsUnit",
|
|
_value: selectionInfo.right,
|
|
},
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
}
|
|
async function reSelectMarqueeExe(selectionInfo) {
|
|
await executeAsModal(async () => {
|
|
await reSelectMarqueeCommand(selectionInfo)
|
|
})
|
|
}
|
|
|
|
async function snapshot_layer() {
|
|
let psAction = require("photoshop").action
|
|
// const ids = (await app.activeDocument.activeLayers).map(layer => layer.id)
|
|
const ids = await app.activeDocument.layers.map((layer) => layer.id)
|
|
let command = [
|
|
// Select All Layers current layer
|
|
{
|
|
_obj: "selectAllLayers",
|
|
_target: [{ _enum: "ordinal", _ref: "layer", _value: "targetEnum" }],
|
|
},
|
|
// Duplicate current layer
|
|
// {"ID":[459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513],"_obj":"duplicate","_target":[{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"}],"version":5},
|
|
{
|
|
ID: ids,
|
|
_obj: "duplicate",
|
|
_target: [{ _enum: "ordinal", _ref: "layer", _value: "targetEnum" }],
|
|
// version: 5
|
|
},
|
|
|
|
// Merge Layers
|
|
{ _obj: "mergeLayersNew" },
|
|
// Make
|
|
{
|
|
_obj: "make",
|
|
at: { _enum: "channel", _ref: "channel", _value: "mask" },
|
|
new: { _class: "channel" },
|
|
using: { _enum: "userMaskEnabled", _value: "revealSelection" },
|
|
},
|
|
// Set Selection
|
|
{
|
|
_obj: "set",
|
|
_target: [{ _property: "selection", _ref: "channel" }],
|
|
to: { _enum: "ordinal", _ref: "channel", _value: "targetEnum" },
|
|
},
|
|
]
|
|
const result = await psAction.batchPlay(command, {
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
})
|
|
console.log("snapshot_layer: result: ", result)
|
|
return result
|
|
}
|
|
|
|
async function snapshot_layerExe() {
|
|
try {
|
|
await executeAsModal(
|
|
async () => {
|
|
await snapshot_layer()
|
|
},
|
|
{
|
|
commandName: "Action Commands",
|
|
}
|
|
)
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
}
|
|
|
|
// await runModalFunction();
|
|
|
|
async function fillAndGroup() {
|
|
let result
|
|
let psAction = require("photoshop").action
|
|
|
|
// let newCommand =[
|
|
// // snapshotLayer
|
|
|
|
// // makeGroupCommand
|
|
|
|
// // Make fill layer
|
|
// {"_obj":"make","_target":[{"_ref":"contentLayer"}],"using":{"_obj":"contentLayer","type":{"_obj":"solidColorLayer","color":{"_obj":"RGBColor","blue":255.0,"grain":255.0,"red":255.0}}}},
|
|
|
|
// ]
|
|
|
|
let command = [
|
|
// Make fill layer
|
|
{
|
|
_obj: "make",
|
|
_target: [{ _ref: "contentLayer" }],
|
|
using: {
|
|
_obj: "contentLayer",
|
|
type: {
|
|
_obj: "solidColorLayer",
|
|
color: { _obj: "RGBColor", blue: 255.0, grain: 255.0, red: 255.0 },
|
|
},
|
|
},
|
|
},
|
|
// Move current layer
|
|
// {"_obj":"move","_target":[{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"}],"adjustment":false,"layerID":[17],"to":{"_index":7,"_ref":"layer"},"version":5},
|
|
// Select layer “Layer 4 copy”
|
|
// {"_obj":"select","_target":[{"_name":"Layer 4 copy","_ref":"layer"}],"layerID":[17,15],"makeVisible":false,"selectionModifier":{"_enum":"selectionModifierType","_value":"addToSelectionContinuous"}},
|
|
// Make Group
|
|
// {"_obj":"make","_target":[{"_ref":"layerSection"}],"from":{"_enum":"ordinal","_ref":"layer","_value":"targetEnum"},"layerSectionEnd":19,"layerSectionStart":18,"name":"Group 1"}
|
|
]
|
|
const snapshotLayer = await app.activeDocument.activeLayers[0]
|
|
await makeGroupCommand()
|
|
const groupLayer = app.activeDocument.activeLayers[0]
|
|
result = await psAction.batchPlay(command, {})
|
|
const fillLayer = app.activeDocument.activeLayers[0]
|
|
snapshotLayer.moveAbove(fillLayer)
|
|
// await app.activeDocument.activeLayers[0].moveAbove()
|
|
// const layerIDs = []
|
|
// const to_index = await getIndexCommand(groupLayer.id)
|
|
// await moveToGroupCommand(to_index, layerIDs)
|
|
}
|
|
|
|
async function fillAndGroupExe() {
|
|
await require("photoshop").core.executeAsModal(fillAndGroup, {
|
|
commandName: "Action Commands",
|
|
})
|
|
}
|
|
async function fastSnapshot() {
|
|
await snapshot_layerExe()
|
|
await fillAndGroupExe()
|
|
}
|
|
|
|
function layerToFileName(layer, session_id) {
|
|
file_name = `${layer.name}_${layer.id}_${session_id}`
|
|
return file_name
|
|
}
|
|
function layerNameToFileName(layer_name, layer_id, session_id) {
|
|
file_name = `${layer_name}_${layer_id}_${session_id}`
|
|
return file_name
|
|
}
|
|
async function exportPngCommand(session_id) {
|
|
try {
|
|
// const result = await batchPlay { _obj: “exportSelectionAsFileTypePressed”}
|
|
|
|
// const destFolder = (await storage.localFileSystem.getDataFolder()).nativePath;
|
|
const storage = require("uxp").storage
|
|
const fs = storage.localFileSystem
|
|
|
|
let pluginFolder = await fs.getPluginFolder()
|
|
// await fs.getFolder("./init_images")
|
|
let init_images_dir = await pluginFolder.getEntry(
|
|
"./server/python_server/init_images"
|
|
)
|
|
const layer = await app.activeDocument.activeLayers[0]
|
|
const old_name = layer.name
|
|
//change the name of layer to unique name
|
|
const file_name = layerToFileName(layer, session_id)
|
|
layer.name = file_name
|
|
const id = await app.activeDocument.activeLayers[0].id
|
|
const exportCommand = {
|
|
_obj: "exportSelectionAsFileTypePressed",
|
|
// _target: { _ref: 'layer', _enum: 'ordinal', _value: 'targetEnum' },
|
|
_target: {
|
|
_ref: "layer",
|
|
_enum: "ordinal",
|
|
_value: "targetEnum",
|
|
_id: id,
|
|
},
|
|
|
|
fileType: "png",
|
|
quality: 32,
|
|
metadata: 0,
|
|
destFolder: init_images_dir.nativePath,
|
|
sRGB: true,
|
|
openWindow: false,
|
|
_options: { dialogOptions: "dontDisplay" },
|
|
}
|
|
const result = await batchPlay([exportCommand], {
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
})
|
|
|
|
return result
|
|
} catch (e) {
|
|
console.error(`exportPngCommand error:, ${e}`)
|
|
}
|
|
}
|
|
|
|
async function exportPng(session_id) {
|
|
console.log("exportPng() -> session_id:", session_id)
|
|
try {
|
|
const old_name = await app.activeDocument.activeLayers[0].name
|
|
await executeAsModal(async () => {
|
|
await exportPngCommand(session_id)
|
|
})
|
|
setTimeout(async () => {
|
|
console.log("setTimeout() -> old_name: ", old_name)
|
|
await executeAsModal(async () => {
|
|
app.activeDocument.activeLayers[0].name = old_name
|
|
})
|
|
}, 3000)
|
|
//after export rename the layer to it's original name by remove the "_${id}" from the name
|
|
} catch (e) {
|
|
console.error(`exportPng error:, ${e}`)
|
|
}
|
|
}
|
|
|
|
// await runModalFunction();
|
|
async function setInitImage(layer, session_id) {
|
|
try {
|
|
const html_manip = require("./utility/html_manip")
|
|
// const layer = await app.activeDocument.activeLayers[0]
|
|
const old_name = layer.name
|
|
const sdapi = require("./sdapi")
|
|
// await exportPng(session_id)
|
|
// image_name = await app.activeDocument.activeLayers[0].name
|
|
|
|
//convert layer name to a file name
|
|
image_name = layerNameToFileName(old_name, layer.id, session_id)
|
|
image_name = `${image_name}.png`
|
|
|
|
//the width and height of the exported image
|
|
const width = html_manip.getWidth()
|
|
const height = html_manip.getHeight()
|
|
await newExportPng(layer, image_name, width, height)
|
|
|
|
g_init_image_name = image_name
|
|
console.log(image_name)
|
|
|
|
const image_src = await sdapi.getInitImage(g_init_image_name)
|
|
let ini_image_element = document.getElementById("init_image")
|
|
ini_image_element.src = image_src
|
|
|
|
return image_name
|
|
} catch (e) {
|
|
console.error(`psapi.js setInitImage error:, ${e}`)
|
|
}
|
|
}
|
|
async function setInitImageMask(layer, session_id) {
|
|
try {
|
|
const html_manip = require("./utility/html_manip")
|
|
|
|
// const layer = await app.activeDocument.activeLayers[0]
|
|
const old_name = layer.name
|
|
const sdapi = require("./sdapi")
|
|
// await exportPng(session_id)
|
|
//get the active layer name
|
|
// image_name = await app.activeDocument.activeLayers[0].name
|
|
// image_name = layerNameToFileName(old_name,layer.id,random_session_id)
|
|
image_name = layerNameToFileName(old_name, layer.id, session_id)
|
|
image_name = `${image_name}.png`
|
|
const width = html_manip.getWidth()
|
|
const height = html_manip.getHeight()
|
|
await newExportPng(layer, image_name, width, height)
|
|
g_init_image_mask_name = image_name // this is the name we will send to the server
|
|
// g_init_mask_layer = layer
|
|
// g_mask_related_layers = {}
|
|
console.log(image_name)
|
|
|
|
const image_src = await sdapi.getInitImage(g_init_image_mask_name) // we should replace this with getInitImagePath which return path to local disk
|
|
const ini_image_mask_element = document.getElementById("init_image_mask")
|
|
ini_image_mask_element.src = image_src
|
|
ini_image_mask_element.dataset.layer_id = layer.id
|
|
|
|
//create viewer init image obj
|
|
return image_name
|
|
} catch (e) {
|
|
console.error(`psapi.js setInitImageMask error: `, e)
|
|
}
|
|
}
|
|
|
|
// remove the generated mask related layers from the canvas and "layers" panel
|
|
|
|
// async function cleanSnapAndFill(layers){
|
|
// // we can delete this function and use cleanLayers() instead
|
|
// //delete init image group
|
|
// //delete init image (snapshot layer)
|
|
// //delete fill layer
|
|
|
|
// for (layer of layers){
|
|
// try{
|
|
|
|
// await executeAsModal(async ()=>{await layer.delete()})
|
|
// }catch(e){
|
|
// console.warn("cleanSnapAndFill, issue deleting a layer",e)
|
|
// }
|
|
// }
|
|
// return []
|
|
// }
|
|
|
|
async function cleanLayers(layers) {
|
|
// g_init_image_related_layers = {}
|
|
// g_mask_related_layers = {}
|
|
// await loadViewerImages()// we should move loadViewerImages to a new file viewer.js
|
|
console.log("cleanLayers() -> layers:", layers)
|
|
for (layer of layers) {
|
|
try {
|
|
if (layer) {
|
|
await executeAsModal(async () => {
|
|
await layer.delete()
|
|
})
|
|
}
|
|
} catch (e) {
|
|
console.warn("warning attempting to a delete layer: ", e)
|
|
continue
|
|
}
|
|
}
|
|
return []
|
|
}
|
|
|
|
// async function cleanLayersOutpaint(layers){
|
|
// //delete group mask layer
|
|
// //delete mask layer
|
|
// //delete group init image layer
|
|
// //delete init image layer (snapshot layer)
|
|
// //delete fill layer
|
|
|
|
// for (layer of layers){
|
|
// try {
|
|
// await executeAsModal(async ()=>{await layer.delete()})}
|
|
// catch(e){
|
|
// console.warn("warning attempting to a delete layer: ",e)
|
|
// }
|
|
// }
|
|
|
|
// return []
|
|
// }
|
|
// async function cleanLayersInpaint(layers){
|
|
// //delete group mask layer
|
|
// //delete white mask layer
|
|
// //delete the black fill layer
|
|
// //delete init image layer (snapshot layer)
|
|
|
|
// for (layer of layers){
|
|
// await executeAsModal(async ()=>{await layer.delete()})
|
|
// }
|
|
|
|
// return []
|
|
// }
|
|
async function createClippingMaskExe() {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
async function createClippingMaskCommand() {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "make",
|
|
new: {
|
|
_class: "channel",
|
|
},
|
|
at: {
|
|
_ref: "channel",
|
|
_enum: "channel",
|
|
_value: "mask",
|
|
},
|
|
using: {
|
|
_enum: "userMaskEnabled",
|
|
_value: "revealSelection",
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
}
|
|
|
|
await executeAsModal(async () => {
|
|
await createClippingMaskCommand()
|
|
})
|
|
}
|
|
|
|
async function checkIfSelectionAreaIsActive() {
|
|
try {
|
|
let isSelectionAreaValid = await getSelectionInfoExe()
|
|
return isSelectionAreaValid
|
|
} catch (e) {
|
|
console.warn(e)
|
|
}
|
|
}
|
|
async function saveUniqueDocumentIdExe(new_id) {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
async function saveUniqueDocumentIdCommand() {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "set",
|
|
_target: [
|
|
{
|
|
_ref: "property",
|
|
_property: "fileInfo",
|
|
},
|
|
{
|
|
_ref: "document",
|
|
_enum: "ordinal",
|
|
_value: "targetEnum",
|
|
},
|
|
],
|
|
to: {
|
|
_obj: "fileInfo",
|
|
caption: new_id,
|
|
keywords: [new_id],
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
}
|
|
|
|
await executeAsModal(async () => {
|
|
await saveUniqueDocumentIdCommand()
|
|
})
|
|
}
|
|
|
|
async function readUniqueDocumentIdExe() {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
async function readUniqueDocumentIdCommand() {
|
|
const batchPlay = require("photoshop").action.batchPlay
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "get",
|
|
_target: [
|
|
{
|
|
_ref: "property",
|
|
_property: "fileInfo",
|
|
},
|
|
{
|
|
_ref: "document",
|
|
_enum: "ordinal",
|
|
_value: "targetEnum",
|
|
},
|
|
],
|
|
// to: {
|
|
// _obj: 'fileInfo',
|
|
// caption: new_id,
|
|
// keywords: [new_id]
|
|
// },
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
console.log("readUniqueDocumentIdCommand: result ", result)
|
|
return result
|
|
}
|
|
|
|
let uniqueDocumentId = ""
|
|
try {
|
|
await executeAsModal(async () => {
|
|
uniqueDocumentId = (await readUniqueDocumentIdCommand())[0].fileInfo
|
|
.caption
|
|
if (typeof uniqueDocumentId === "string") {
|
|
uniqueDocumentId = uniqueDocumentId.trim()
|
|
}
|
|
})
|
|
} catch (e) {
|
|
console.warn("readUniqueDocumentIdExe: ", e)
|
|
uniqueDocumentId = ""
|
|
}
|
|
|
|
return uniqueDocumentId
|
|
}
|
|
|
|
const readPng = async (image_name) => {
|
|
// image_name = 'test.png'
|
|
try {
|
|
await executeAsModal(
|
|
async (control) => {
|
|
// const tempFolder = await fs.getTemporaryFolder() ;
|
|
const pluginFolder = await fs.getPluginFolder()
|
|
|
|
let init_images_dir = await pluginFolder.getEntry(
|
|
"./server/python_server/init_images"
|
|
)
|
|
// let init_images_dir = await pluginFolder.getEntry(
|
|
// './server/python_server/init_images'
|
|
// )
|
|
const file = await init_images_dir.createFile(image_name, {
|
|
overwrite: true,
|
|
})
|
|
|
|
const currentDocument = app.activeDocument
|
|
await currentDocument.saveAs.png(
|
|
file,
|
|
// {
|
|
// compression: 6,
|
|
// },
|
|
null,
|
|
true
|
|
)
|
|
|
|
// const arrayBuffer = await file.read({format: formats.binary}) ;
|
|
// console.log(arrayBuffer, 'arrayBuffer') ;
|
|
},
|
|
|
|
{ commandName: "readPng" }
|
|
)
|
|
} catch (e) {
|
|
console.warn(e)
|
|
}
|
|
}
|
|
|
|
async function selectCanvasCommand() {
|
|
// const result = await batchPlay(
|
|
// [
|
|
// {
|
|
// _obj: "historyStateChanged",
|
|
// documentID: 1044,
|
|
// ID: 1058,
|
|
// name: "Select Canvas",
|
|
// hasEnglish: true,
|
|
// itemIndex: 7,
|
|
// commandID: 1017,
|
|
// _options: {
|
|
// dialogOptions: "dontDisplay"
|
|
// }
|
|
// }
|
|
// ],{
|
|
// synchronousExecution: true,
|
|
// modalBehavior: "execute"
|
|
// });
|
|
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "set",
|
|
_target: [
|
|
{
|
|
_ref: "channel",
|
|
_property: "selection",
|
|
},
|
|
],
|
|
to: {
|
|
_enum: "ordinal",
|
|
_value: "allEnum",
|
|
},
|
|
_options: {
|
|
dialogOptions: "dontDisplay",
|
|
},
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
|
|
return result
|
|
}
|
|
async function selectCanvasExe() {
|
|
await executeAsModal(
|
|
async () => {
|
|
await selectCanvasCommand()
|
|
},
|
|
{ commandName: "selectCanvasExe" }
|
|
)
|
|
}
|
|
async function newExportPng(layer, image_name, width, height) {
|
|
//store layers we want to export in variables
|
|
// let layerToExports =
|
|
// create new document
|
|
// duplicate the layers to the new documnet
|
|
//select the layer channel selectLayerChannelCommand
|
|
//document.crop
|
|
//export using readPng()
|
|
|
|
try {
|
|
//get the active layers
|
|
// const layersToExport = app.activeDocument.activeLayers
|
|
|
|
//create new document
|
|
// let exportDoc = await executeAsModal(app.documents.add)
|
|
let exportDoc
|
|
const makeDoc = async () => {
|
|
let exportDoc = await app.documents.add({
|
|
width: width,
|
|
height: height,
|
|
resolution: 300,
|
|
mode: "RGBColorMode",
|
|
fill: "transparent",
|
|
})
|
|
}
|
|
await executeAsModal(
|
|
async () => {
|
|
// await app.documents.add()
|
|
await makeDoc()
|
|
exportDoc = app.activeDocument
|
|
|
|
console.log("exportDoc.id: ", exportDoc.id)
|
|
// for (layer of layersToExport) {
|
|
|
|
console.log(layer.id)
|
|
const dupLayer = await layer.duplicate(exportDoc)
|
|
await selectLayers([dupLayer])
|
|
// await selectLayerChannelCommand()
|
|
await selectCanvasExe()
|
|
const canvas_selection_info = await getSelectionInfoExe()
|
|
await layerToSelection(canvas_selection_info)
|
|
// const selection_info = await getSelectionInfoExe()
|
|
// await exportDoc.crop(selection_info)
|
|
// export_image_name = `${layer.name}.png`
|
|
await readPng(image_name)
|
|
await exportDoc.closeWithoutSaving()
|
|
},
|
|
{ commandName: "NewExportPng" }
|
|
)
|
|
// }
|
|
} catch (e) {
|
|
console.error(`newExportPng error: ,${e}`)
|
|
}
|
|
}
|
|
async function mergeVisibleCommand() {
|
|
const result = await batchPlay(
|
|
[
|
|
{
|
|
_obj: "mergeVisible",
|
|
duplicate: true,
|
|
_isCommand: true,
|
|
// "_options": {
|
|
// // "dialogOptions": "dontDisplay"
|
|
// }
|
|
},
|
|
],
|
|
{
|
|
synchronousExecution: true,
|
|
modalBehavior: "execute",
|
|
}
|
|
)
|
|
|
|
return result
|
|
}
|
|
|
|
async function mergeVisibleExe() {
|
|
await executeAsModal(async () => {
|
|
await mergeVisibleCommand()
|
|
})
|
|
}
|
|
|
|
async function layerToSelection(selection_info) {
|
|
//store active layer for later
|
|
|
|
try {
|
|
//Store selection info
|
|
//unSelect
|
|
//move layer
|
|
//scale layer
|
|
//Select from selection info
|
|
// let selection_info = await getSelectionInfo()
|
|
|
|
console.log("selection_info:", selection_info)
|
|
|
|
console.log("unSelect")
|
|
|
|
function getLayerSize(layer) {
|
|
console.log("layer.bounds:")
|
|
console.dir(layer.bounds)
|
|
const bounds = layer.bounds
|
|
const height = bounds.bottom - bounds.top
|
|
const width = bounds.right - bounds.left
|
|
return {
|
|
height: height,
|
|
width: width,
|
|
left: bounds.left,
|
|
right: bounds.right,
|
|
top: bounds.top,
|
|
bottom: bounds.bottom,
|
|
}
|
|
}
|
|
//scale layer
|
|
async function scaleLayer(layer, selection_info) {
|
|
console.log("scaleLayer got called")
|
|
// const activeLayer = getActiveLayer()
|
|
// const activeLayer = await app.activeDocument.activeLayers[0]
|
|
|
|
let layer_info = getLayerSize(layer)
|
|
scale_x_ratio = (selection_info.width / layer_info.width) * 100
|
|
scale_y_ratio = (selection_info.height / layer_info.height) * 100
|
|
console.log("scale_x_y_ratio:", scale_x_ratio, scale_y_ratio)
|
|
await layer.scale(scale_x_ratio, scale_y_ratio)
|
|
}
|
|
|
|
async function moveLayerExe(layerToMove, selection_info) {
|
|
let layer_info = getLayerSize(layerToMove)
|
|
top_dist = layer_info.top - selection_info.top
|
|
left_dist = layer_info.left - selection_info.left
|
|
await layerToMove.translate(-left_dist, -top_dist)
|
|
}
|
|
// const activeLayer = await getActiveLayer()
|
|
|
|
//store all active layers
|
|
const activeLayers = await app.activeDocument.activeLayers
|
|
await unSelectMarqueeExe()
|
|
// await executeAsModal(unSelect, {'commandName': 'unSelect'})
|
|
// await executeAsModal(scaleLayer, {'commandName': 'scaleLayer'})
|
|
|
|
await executeAsModal(
|
|
async () => {
|
|
for (let layer of activeLayers) {
|
|
await selectLayers([layer]) // make sure only one layer is selected
|
|
await scaleLayer(layer, selection_info) //scale to selection size
|
|
await moveLayerExe(layer, selection_info) //move to selection
|
|
}
|
|
},
|
|
{ commandName: "moveLayerExe" }
|
|
)
|
|
|
|
// await reselect(selection_info)
|
|
} catch (e) {
|
|
console.warn(e)
|
|
}
|
|
}
|
|
|
|
module.exports = {
|
|
createSolidLayer,
|
|
createEmptyGroup,
|
|
getLayerIndex,
|
|
collapseGroup,
|
|
moveToGroupCommand,
|
|
MoveToGroupExe,
|
|
selectLayers,
|
|
selectLayersExe,
|
|
unselectActiveLayers,
|
|
unselectActiveLayersExe,
|
|
createMaskExe,
|
|
getSelectionInfoExe,
|
|
unSelectMarqueeCommand,
|
|
unSelectMarqueeExe,
|
|
reSelectMarqueeExe,
|
|
selectLayerChannelCommand,
|
|
snapshot_layer,
|
|
snapshot_layerExe,
|
|
fillAndGroupExe,
|
|
fastSnapshot,
|
|
setInitImage,
|
|
setInitImageMask,
|
|
exportPng,
|
|
layerToFileName,
|
|
layerNameToFileName,
|
|
// cleanLayersOutpaint,
|
|
// cleanLayersInpaint,
|
|
// cleanSnapAndFill,
|
|
cleanLayers,
|
|
createClippingMaskExe,
|
|
checkIfSelectionAreaIsActive,
|
|
selectMarqueeRectangularToolExe,
|
|
promptForMarqueeTool,
|
|
saveUniqueDocumentIdExe,
|
|
readUniqueDocumentIdExe,
|
|
newExportPng,
|
|
mergeVisibleExe,
|
|
selectCanvasExe,
|
|
layerToSelection,
|
|
isSelectionValid,
|
|
}
|