浅谈processing-java.exe应用程序的使用（与PowerShell的联合）

简单总结一下processing-java.exe的使用，以及和PowerShell结合，如何互相调用和传参。

Processing-java

这是 processing-java.exe 的官方说明:

Command line edition for Processing 1295 (Java Mode)

--help               Show this help text. Congratulations.

--sketch=<name>      Specify the sketch folder (required)
--output=<name>      Specify the output folder (optional and
                     cannot be the same as the sketch folder.)

--force              The sketch will not build if the output
                     folder already exists, because the contents
                     will be replaced. This option erases the
                     folder first. Use with extreme caution!

--build              Preprocess and compile a sketch into .class files.
--run                Preprocess, compile, and run a sketch.
--present            Preprocess, compile, and run a sketch in presentation mode.

--export             Export an application.
--variant            Specify the platform and architecture (Export only).
--no-java            Do not embed Java.

Starting with 4.0, the --platform option has been removed
because of the variety of platforms and architectures now available.
Use the --variant option instead, for instance:

variant        platform
-------------  ---------------------------
macos-x86_64   macOS (Intel 64-bit)
macos-aarch64  macOS (Apple Silicon)
windows-amd64  Windows (Intel 64-bit)
linux-amd64    Linux (Intel 64-bit)
linux-arm      Linux (Raspberry Pi 32-bit)
linux-aarch64  Linux (Raspberry Pi 64-bit)

The --build, --run, --present, or --export must be the final parameter
passed to Processing. Arguments passed following one of those four will
be passed through to the sketch itself, and therefore available to the
sketch via the 'args' field. To pass options understood by PApplet.main(),
write a custom main() method so that the preprocessor does not add one.

https://github.com/processing/processing/wiki/Command-Line

把它翻译出来看一下

Processing 1295 命令行版本（Java 模式）

--help            显示此帮助文本。恭喜你。

--sketch=<文件夹名称>   指定草图文件夹（必填项）

--output=<文件夹名称>   指定输出文件夹（可选，且不能与草图文件夹相同）。

--force           如果输出文件夹已存在，草图将不会进行构建，因为其中的内容会被替换。此选项会先删除该文件夹。使用时请务必谨慎！

--build           对草图进行预处理并将其编译成.class 文件。

--run            对草图进行预处理、编译并运行。

--present          对草图进行预处理、编译，并以演示模式运行。

--export            导出一个应用程序。

--variant           指定平台和架构（仅用于导出操作）。

--no-java          不嵌入 Java。

从 4.0 版本开始，--platform选项已被移除， 因为现在可用的平台和架构种类繁多。 请改用 --variant 选项，例如：

变体名称	平台
macos-x86_64	macOS（英特尔 64 位）
macos-aarch64	macOS（苹果芯片）
windows-amd64	Windows（英特尔 64 位）
linux-amd64	Linux（英特尔 64 位）
linux-arm	Linux（树莓派 32 位）
linux-aarch64	Linux（树莓派 64 位）

 

--build、--run、--present 或 --export 必须是传递给 Processing 的最后一个参数。
在这四个参数之一后面传递的参数将被传递给草图本身，
因此草图可以通过 “args” 字段获取这些参数。
要传递 PApplet.main () 所理解的选项，
请编写一个自定义的 main () 方法，这样预处理器就不会添加默认的 main () 方法了。

 

---

https://github.com/processing/processing/wiki/Command-Line

上面这个网页是Github上的相关说明：

 

在 Processing IDE 中运行草图固然有趣，但在命令行中运行则更加有趣！通过命令行运行意味着你可以自动化执行草图，无需打开 IDE 就能运行草图，在嵌入式设备上运行草图，甚至可以让草图在启动时运行……这些功能都非常实用！

 

安装 processing-java 命令

Windows/Linux：使用下载文件中的 processing-java 程序

Mac：在 Processing 应用程序中，进入“工具”>“安装 ‘processing-java’”

 

命令 (COMMAND)	说明 (INFO)
--help	显示此帮助文本 :)
--sketch=<path>	指定草图文件夹（必需）
--output=<path>	指定输出文件夹（可选，且不能与草图文件夹相同）
--force	如果输出文件夹已存在，草图将不会构建，因为内容会被替换；此选项会先删除文件夹：使用时需极度谨慎！
--build	预处理并将草图编译为 .class 文件
--run	预处理、编译并运行草图
--present	预处理、编译并以演示模式运行草图
--export	导出应用程序
--no-java	不嵌入 Java：使用时需自担风险！
--variant	指定变体（仅用于导出应用程序），应为以下之一：macos-x86_64、macos-aarch64、windows-amd64、linux-amd64、linux-arm 或 linux-aarch64

 

需要注意的几点：

--build、--run、--present 或 --export 命令必须是传递给 processing-java 的最后一个参数。 上述命令之后的参数将被传递给草图本身，因此可以通过草图中的 args 字段获取！（请参阅下面的示例） 要传递 PApplet.main() 能理解的选项，请编写一个自定义的 main() 方法，这样预处理器就不会添加一个。

以下是一些使用 processing-java 的示例...

 

运行草图而不使用任何特殊选项：

processing-java --sketch=yoursketchfolder --run 注意：--sketch 命令是必需的，应该是你草图文件夹的路径

将文件保存到草图所在位置以外的文件夹：

processing-java --sketch=yoursketchfolder  --output=youroutputfolder --run

包含可选的 --force 命令，这将覆盖输出目录，即使其中已有内容（使用时需谨慎！）：

processing-java --sketch=/full/path/to/your/sketch/dir --output=/path/to/output/folder --force --run

以演示模式运行草图：

processing-java --sketch=/full/path/to/your/sketch/folder --present

 

传递命令行参数：

如果你想将命令行传递的参数包含到你的草图中，可以在 --run、--present 等命令之后添加它们。例如，这里我们将宽度和高度传递给一个草图：

processing-java --sketch=/full/path/to/your/sketch/folder --present 600 600

在你的草图中，可以通过以下方式访问这些参数：

void settings() {
    // 如果存在参数，则更改草图的大小
    if (args != null) {
        int w = Integer.parseInt(args[0]); // 将第一个参数解析为宽度
        int h = Integer.parseInt(args[1]); // 将第二个参数解析为高度
        size(w, h); // 根据参数设置草图的大小
    }
    // 如果没有参数或者参数不完整，这里可以提供一个选择 —— 此处我们手动设置尺寸 :)
    else {
        size(400, 400); // 设置默认大小为 400x400
    }
}

常见问题 以下是一些可能会出错的常见情况：

错误：Sketchname 不存在 这可能是因为没有使用 --sketch 参数指定草图的完整路径，或者包含草图的文件夹名称与草图的名称不同。

之前安装的 processing-java 现在无法正常工作 在 Mac OSX 上，下载新版本的 Processing 后，可能需要重新安装命令行工具 :(

无头模式运行 以“无头模式”运行你的草图（即没有显示设备）可能需要额外的操作，更多信息请参考“无显示运行”（Running Without a Display）。

即使在启用了“无头模式”的情况下，--build 和 --export 选项也应该可以正常工作。

 

---

补充

可以看到官方给我们预留了很多开关/参数。不过相关使用的示例还是不全面。接下来笔者补充一些有关processing-java和命令行程序的相互调用、传参等使用示例。

 

一  Processing 调用 PowerShell 脚本

在 Processing 草图中，可以通过 Runtime。getRuntime().exec 或 ProcessBuilder 调用 PowerShell 命令。例如：

运行一个dir命令来获取C盘目录信息：

void setup() {
  size(400, 400);
  try {
    // 执行 PowerShell 命令（例如列出目录）
    Process p = Runtime.getRuntime().exec("powershell.exe dir C:\\");
    BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
    String line;
    while ((line = input.readLine()) != null) {
      println(line); // 在 Processing 控制台输出结果
    }
    input.close();
  } catch (Exception e) {
    e.printStackTrace();
  }
}

也可以在 Processing 中动态构造 PowerShell 命令：

void setup() {
  String folderPath = "C:\\Users\\YourName\\Documents";
  try {
    Process p = Runtime.getRuntime().exec("powershell.exe dir " + folderPath);
    // 读取输出...
  } catch (Exception e) {
    // 处理异常
  }
}

还可以传递参数给PowerShell脚本：

假设你有一个 PowerShell 脚本 script.ps1，它接受参数并执行一些复杂的任务。你可以在 Processing 草图中调用该脚本并传递参数：

void setup() {
    String scriptPath = "C:\\path\\to\\script.ps1"; // PowerShell 脚本路径
    String param1 = "value1";
    String param2 = "value2";

    try {
        // 构造命令
        String command = "powershell.exe -File " + scriptPath + " -param1 " + param1 + " -param2 " + param2;
        Process process = Runtime.getRuntime().exec(command);
        // 读取输出
        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            println(line); // 打印输出到 Processing 控制台
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

注意：代码中使用了InputStreamReader来读取PowerShell脚本反馈的信息。

二  PowerShell 脚本调用 Processing-java

直接运行 Processing 脚本

在 PowerShell 中执行 Processing-java.exe，并指定 .pde 文件所在的文件夹路径：

# 示例：运行指定路径的 Processing 脚本
"C:\Processing\processing-java.exe" --sketch="C:\path\to\yoursketchfolder" --run

如果频繁调用Processing-java程序，可以设置一下系统变量，将 其目录地址添加入Path中。

传递命令行参数

在 PowerShell 中传递参数给 Processing 程序，并在 Processing 代码中读取：

# PowerShell 命令
"C:\Processing\processing-java.exe" --sketch="C:\path\to\yoursketchfolder" --run --args "参数1" "参数2"

然后在 Processing 代码中通过 args 数组接收参数：

void setup() {
  size(400, 400);
  background(255);

  // 检查是否有参数传入
  if (null == args) {
  } else {

    if (args.length > 0) {
      for (int i = 0; i < args.length; i++) {
        println("接收到的参数 " + (i + 1) + ": " + args[i]);
      }
    } else {
      println("没有接收到任何参数。");
    }
  }
}

void draw() {
  // 这里可以添加其他绘图代码
}

有待传入参数可以单独放在一个字符串数组中，方便定义和管理，如：

# 定义要传递的参数
$parameters = "参数1", "参数2", "参数3"

# 构建完整的命令
$command = "$processingJavaPath --sketch=$sketchPath --run --args $($parameters -join ' ')"

捕获 Processing 输出

将 Processing 的控制台输出重定向到 PowerShell 变量，并做保存：

$output = "C:\Processing\processing-java.exe" --sketch="C:\path\to\yoursketchfolder" --run 2>&1
$output | Out-File -FilePath "output.log"

• 捕获输出：2>&1 确保捕获命令运行时的所有输出，包括标准输出和错误信息，并存放进$output变量中。
• 保存日志：将输出的信息，也就是$output变量数据保存到日志文件 output.log 中，方便查看命令运行的结果和潜在的错误信息。

如果情景简单，可以删除2>&1命令。

复杂情景 · 运行多个草图并导出应用

假设你需要自动化运行多个 Processing 草图，并将结果导出 .exe 应用到不同的文件夹。编写 PowerShell 脚本来实现：

# 定义草图列表和输出路径
$sketches = @(
    "D:\sketch\sk1",
    "D:\sketch\sk2",
    "D:\sketch\sk3"
)
$outputFolder = "D:\outputaa"

# 遍历每个草图并运行
foreach ($sketch in $sketches) {
    $outputPath = Join-Path $outputFolder (Split-Path $sketch -Leaf)
    New-Item -ItemType Directory -Path $outputPath -Force | Out-Null

    # 运行草图并导出
    processing-java --sketch=$sketch --output=$outputPath --force --export
}

Processing-java 中的 --output 参数允许你指定一个输出目录，用于存放草图的编译文件或导出文件。需要将构建或导出的文件组织到特定的文件夹结构中时非常有用。

要使用 --output 参数，你需要将其放在触发编译或导出的命令之前（如 --run、--export 或 --build）。以下是一个简单的示例：

processing-java --sketch="C:\path\to\yoursketchfolder" --output="C:\desired\output\folder" --run

注意事项

• --output 指定的目录不能与草图目录相同。如果尝试使用相同的目录，Processing-java 会抛出错误。
• 如果输出目录不存在，Processing-java 会在可能的情况下创建它。而在上述例子中，我手动创建了待输出目录，因此，需要加上--force让其忽略已存在的文件夹，强制输出文件，--force参数必须放在--export之前。
• 可以使用相对路径作为输出目录。

总结

通过结合使用 Processing-java 和 PowerShell，可以实现更强大的自动化部署和跨平台管理功能。当然，如果是针对数字媒体艺术的创作和展演，这种结合也必定会为创作和研发注入新的思路，也能更高效得创建项目和管理项目。