Avoid the terms "ImageJ" and "ImageJ2"

ctrueden · ctrueden · commit 1505072d8389 · 2024-04-02T15:58:15.000-05:00
The SciJava Ops project is not built on those technologies,
although SciJava Ops Image did evolve from ImageJ Ops, and the
scijava-ops-legacy component enables backwards compatibility with
ImageJ and ImageJ2.
diff --git a/README.md b/README.md
@@ -37,7 +37,7 @@ Thank you!*
 The following narrative details the ways in which this approach refines and
 updates the SciJava development process, with the goal of improving and
 streamlining development of projects across the entire software stack,
-including SciJava, ImageJ2, SCIFIO, Fiji, and other SciJava-based software
+including SciJava, ImgLib2, SCIFIO, Fiji, and other SciJava-based software
 layers. This discussion assumes the reader is familiar with the
 [current SciJava development methodology and project
 architecture](https://imagej.net/develop/architecture).
@@ -114,9 +114,10 @@ remains a way to see what everyone is working on easily.
 ##### Minimize complexity
 
 The goal here is to make the projects accessible to potential contributors.
-Currently, even the naming of these projects is confusing&mdash;ImageJ, Fiji,
-SciJava, ImageJ2, SCIFIO... Is there a way moving forward where we can
-streamline naming and consider alternatives?
+Even the naming of projects during the ImageJ2 era was confusing&mdash;ImageJ,
+Fiji, SciJava, ImageJ2, ImgLib2, SCIFIO... To move forward, we are streamlining
+the naming to use "SciJava" in more situations, and eschew use of the terms
+"ImageJ" and "ImageJ2" to avoid confusion with the original ImageJ project.
 
 ##### Release as early as possible, but be completely stable once released
 
@@ -197,15 +198,14 @@ highlighted here needs to be reexamined.\]
 The next iteration of our core development process, addressing these challenges
 and applying lessons learned.
 
-The SciJava, ImageJ2 and Fiji projects are distinct, but heavily overlap.
+The SciJava, ImgLib2 and Fiji projects are distinct, but heavily overlap.
 
-* **ImageJ2** consists of *core libraries* and an *end-user application* for
+* **ImgLib2** consists of *core libraries* for
   scientific multidimensional image processing and analysis.
 * **SciJava** consists of *core Java libraries more general than image
   processing*, including an extensible framework for plugins, an application
   container, and many useful utilities.
-* **Fiji** is a *suite of ImageJ plugins for the life sciences* and a
-  *distribution of ImageJ including those plugins*.
+* **Fiji** is an *end-user application* and *suite of ImageJ plugins for the
 
 #### Proposed iteration of the SciJava development process: the SciJava incubator
 
@@ -318,10 +318,8 @@ together. Makes it clearer who is a "core developer" as well.
     * SciJava: Cultivate a sustainable development community where powerful
       scientific tools grow.
     * ImgLib2: Provide powerful reusable image processing libraries.
-    * ImageJ2: Broaden the paradigm of ImageJ beyond the limitations of the
-      original ImageJ application.
-    * Fiji: Make powerful scientific imaging software tools accessible to
-      biologists. Batteries included.
+    * Fiji: Make powerful scientific imaging software tools accessible to all.
+      Batteries included.
 
 **What about complexity compared to e.g. Python ecosystem?**
 The "genes" of our Java ecosystem, accessibility with type safety, play to
@@ -403,7 +401,6 @@ Multi-module codebase but everything has a single version for a given component.
 
 Which layers?
 - SciJava &rarr; scijava/scijava
-- ImageJ2 &rarr; imagej/imagej3 (!) (but should we move on from this name?)
 - SCIFIO &rarr; scifio/scifio (but it clashes with existing repo)
 - Fiji &rarr; consider consolidating things like `fiji-lib`, `Fiji_Developer`
   into fiji? `fiji-lib` is the thing other plugins can depend on. Unless we
diff --git a/ScriptingInFiji.md b/ScriptingInFiji.md
@@ -1,6 +1,6 @@
-# Scripting in ImageJ2
+# Scripting in Fiji
 
-Using SciJava Ops and ImageJ Ops2 within scripts provide the most powerful aspects of Ops. The following page will explain how you can write a script in ImageJ2's Script Editor that utilizes Ops for image processing.
+Using SciJava Ops within scripts unlocks the most powerful aspects of Ops. The following page will explain how you can write a script in Fiji's Script Editor that utilizes Ops for image processing.
 
 ## Obtaining an OpEnvironment
 
diff --git a/docs/ops/doc/Installation.md b/docs/ops/doc/Installation.md
@@ -2,13 +2,13 @@
 
 ## Fiji
 
-One easy way to use SciJava Ops is within ImageJ2/Fiji, using SciJava's Script Editor. **Note that to use ImageJ2/Fiji, you must use Java 11+. Instructions on using Java 11+ for ImageJ2/Fiji can be found [here](https://imagej.net/learn/faq#how-do-i-launch-imagej-with-a-different-version-of-java)**.
+One easy way to use SciJava Ops is within [Fiji](https://fiji.sc), using SciJava's Script Editor. **Note that to use Fiji, you must use Java 11+. Instructions on using Java 11+ for Fiji can be found [here](https://imagej.net/learn/faq#how-do-i-launch-imagej-with-a-different-version-of-java)**.
 
-### Installing the SciJava Ops update site
+### Installing SciJava Ops
 
-You can install the SciJava Ops update site (containing ImageJ Ops2, SciJava Ops, and all other required components) by following the [Update site tutorial](https://imagej.net/update-sites/following#add-update-sites). 
+You can install SciJava Ops into Fiji by enabling the SciJava Ops update site, as described in the [Update site tutorial](https://imagej.net/update-sites/following#add-update-sites). 
 
-1. With Fiji open, navigate to `Help --> Update...`
+1. With Fiji open, navigate to `Help &rarr; Update...`
 2. Click `Manage Update Sites` 
 3. In the `Search` bar at the top of the popup, search `SciJava Ops`
 4. Find the `SciJava Ops` row, and check the checkbox in the `Active` column.
diff --git a/docs/ops/doc/MigratingFromImageJOps.md b/docs/ops/doc/MigratingFromImageJOps.md
@@ -4,12 +4,14 @@ The [ImageJ Ops](https://imagej.net/libs/imagej-ops/index) framework is the pred
 
 ## Upgrading pom-scijava
 
-Before doing anything else, you should ensure that your version of pom-scijava is new enough to make use of SciJava 3 goodness.
+Before doing anything else, you should ensure that your version of pom-scijava is new enough to make use of SciJava Ops goodness.
 
 TODO: Replace with the pom-scijava version needed to grab this annotation processor.
 
-Until the SciJava 3 annotation processor is added to pom-scijava, developers must add the following block of code to the `build` section of your POM:
+Until the SciJava Ops annotation processor is integrated into [pom-scijava](https://github.com/scijava/pom-scijava), developers must add the following block of code to the `build` section of their project POM:
 
+TODO: Replace with the pom-scijava version needed to grab this annotation processor.
+TODO: Replace the SciJava Ops Indexer version with the correct initial version
 ```xml
 <build>
     <plugins>
@@ -19,14 +21,15 @@ Until the SciJava 3 annotation processor is added to pom-scijava, developers mus
                 <annotationProcessorPaths>
                     <path>
                         <groupId>org.scijava</groupId>
-                        <artifactId>scijava-javadoc-parser</artifactId>
-                        <version>${project.version}</version>
+                        <artifactId>scijava-ops-indexer</artifactId>
+                        <version>1.0.0</version>
                     </path>
                 </annotationProcessorPaths>
                 <fork>true</fork>
                 <showWarnings>true</showWarnings>
                 <compilerArgs>
-                    <arg>-Ajavadoc.packages="${therapi.packages}"</arg>
+                    <arg>-Aparse.ops=true</arg>
+                    <arg>-Aop.version="${project.version}"</arg>
                 </compilerArgs>
             </configuration>
         </plugin>
@@ -54,7 +57,7 @@ SciJava Ops uses a separate annotation processor to record plugins at compile ti
 
 Additional options include:
 * Providing multiple names by replacing `names='name1'` with `names='name1,name2,...'` to allow your Op to be discoverable under multiple names
-* Providing the Op's priority by appending `priority=<the priority>`. SciJava Ops uses the same priority values as ImageJ Ops2, and relative priorities can be retained by using the new SciJava Priority library.
+* Providing the Op's priority by appending `priority=<the priority>`. SciJava Ops uses the same priority values as ImageJ Ops, and relative priorities can be retained by using the new SciJava Priority library.
 
 The following diff shows the changes needed to replace the `@Plugin` annotation:
 
diff --git a/docs/ops/doc/README.md b/docs/ops/doc/README.md
@@ -1,3 +1,3 @@
 # Ops Reference Documentation
 
-To access SciJava Ops's and ImageJ Ops2's installation, initialization, tutorial, troubleshooting and API reference documentation please visit the [SciJava Ops ReadTheDocs](https://ops.scijava.org/en/latest/index.html) website or build the documentation locally (see [building the reference documentation](https://pyimagej.readthedocs.io/en/latest/Development.html#building-the-reference-documentation) for more details).
+To access SciJava Ops's installation, initialization, tutorial, troubleshooting and API reference documentation please visit the [SciJava Ops ReadTheDocs](https://ops.scijava.org/en/latest/index.html) website or build the documentation locally (see [building the reference documentation](https://pyimagej.readthedocs.io/en/latest/Development.html#building-the-reference-documentation) for more details).
diff --git a/docs/ops/doc/WhyOps.md b/docs/ops/doc/WhyOps.md
@@ -10,7 +10,7 @@ SciJava Ops takes strides to ease these burdens by separating the *what* ("I wan
 ## What are the driving values of SciJava Ops?
 
 1. **Consistency**:  All Ops are called in the same way, regardless of the mechanisms used by the underlying framework. This means that you don't have to learn Python to call Ops written in Python, but it also means that you could pass the output from an Op written in Python to an Op written in Java, all with the same syntax!
-2. **Reusability**: Ops extends Java's mantra of "write once, run anywhere" to image processing algorithms. Algorithms written for the SciJava Ops framework are usable as-is from any SciJava-compatible software project including ImageJ2/Fiji or from Python using PyImageJ. 
+2. **Reusability**: Ops extends Java's mantra of "write once, run anywhere" to image processing algorithms. Algorithms written for the SciJava Ops framework are usable as-is from any SciJava-compatible software project including Fiji, or from Python using PyImageJ. 
 3. **Reproducibility**: Ops are deterministic: calling the same op twice with the same arguments yields the same result, always. Ops are also versioned, meaning that if you use the same Op environment with the same library versions, you will always have reproducible workflows.
 4. **Flexibility**: Through adaptation and simplification pathways, Ops can be applied to all kinds of inputs, relaxing considerations for data structures. For example, binary numerical Ops are automatically looped and parallelized to operate on images. New data types extending core interfaces can be supported immediately, without rewriting existing algorithms.
 5. **Safety**: An op may consist of any number of strongly typed inputs, and calls to access those ops can be as specific as desired. This allows analyst users to use ops without regard for data structure, while developers can rely on the type safety guarantees needed for optimization.
diff --git a/docs/ops/doc/WritingYourOwnOpPackage.md b/docs/ops/doc/WritingYourOwnOpPackage.md
@@ -4,19 +4,16 @@ Right now, there are two ways to write and expose your own Ops.
 
 ## Ops Through Javadoc
 
-Ops can be declared directly through Javadoc - this yields a couple of benefits, namely:
-* No additional runtime dependencies needed for simple Ops
+The recommended way to declare your Ops is through Javadoc. This approach requires no additional runtime dependencies&mdash;only a correctly formatted `@implNote` tag in the javadoc block of each routine you wish to make available as an Op, plus the scijava-ops-indexer annotation processor component present on your annotation processor path at compile time.
 
-This mechanism of Op declaration is used by the ImageJ Ops2 project
+### Adding the SciJava Ops Indexer to your POM
 
-### Adding the SciJava Javadoc Parser to your POM
+Ops written through Javadoc are discovered by the SciJava Ops Indexer, which creates a file `op.yaml` containing all of the data needed to import each Op you declare.
 
-Ops written through Javadoc are discovered by the SciJava Javadoc Parser, which creates a file `op.yaml` containing all of the data needed to import each Op you declare.
-
-Until the SciJava 3 annotation processor is added to pom-scijava, developers must add the following block of code to the `build` section of your POM:
+Until the SciJava Ops annotation processor is integrated into [pom-scijava](https://github.com/scijava/pom-scijava), developers must add the following block of code to the `build` section of their project POM:
 
 TODO: Replace with the pom-scijava version needed to grab this annotation processor.
-TODO: Replace the SciJava Javadoc Parser version with the correct initial version
+TODO: Replace the SciJava Ops Indexer version with the correct initial version
 ```xml
 <build>
     <plugins>
@@ -26,14 +23,15 @@ TODO: Replace the SciJava Javadoc Parser version with the correct initial versio
                 <annotationProcessorPaths>
                     <path>
                         <groupId>org.scijava</groupId>
-                        <artifactId>scijava-javadoc-parser</artifactId>
-                        <version>${project.version}</version>
+                        <artifactId>scijava-ops-indexer</artifactId>
+                        <version>1.0.0</version>
                     </path>
                 </annotationProcessorPaths>
                 <fork>true</fork>
                 <showWarnings>true</showWarnings>
                 <compilerArgs>
-                    <arg>-Ajavadoc.packages="-"</arg>
+                    <arg>-Aparse.ops=true</arg>
+                    <arg>-Aop.version="${project.version}"</arg>
                 </compilerArgs>
             </configuration>
         </plugin>
@@ -141,9 +139,9 @@ Note again that the only supported functional interfaces that can be used withou
 
 ## Ops using JPMS
 
-The other way to expose Ops is by using the [Java Platform Module System](https://www.oracle.com/corporate/features/understanding-java-9-modules.html). This mechanism is used to expose the Ops declared within SciJava Ops Engine, and may be preferred for its usage of plain Java mechanisms:
+The other way to expose Ops is by using the [Java Platform Module System](https://www.oracle.com/corporate/features/understanding-java-9-modules.html). This mechanism is used to expose the Ops declared within SciJava Ops Engine, and may be preferred for its usage of plain Java mechanisms and strong type safety:
 
-In opposition to the Javadoc mechanism, all projects wishing to declare Ops using JPMS must add a dependency on the SciJava Ops SPI library:
+In contrast to the Javadoc mechanism, all projects wishing to declare Ops using JPMS must add a dependency on the SciJava Ops SPI library:
 
 ```xml
 <dependencies>
@@ -280,7 +278,7 @@ class DoubleSizeOp implements Function<double[], Double> {
 
 ### Element-wise Ops
 
-Simple pixel-wise operations like addition, inversion, and more can be written on a single pixel (i.e. `RealType`) - therefore, ImageJ Ops2 takes care to automagically adapt pixel-wise Ops across a wide variety of image types. If you would like to write a pixel-wise Op, we recommend the following structure.
+Simple pixel-wise operations like addition, inversion, and more can be written on a single pixel (i.e. `RealType`) - therefore, SciJava Ops Image takes care to automagically adapt pixel-wise Ops across a wide variety of image types. If you would like to write a pixel-wise Op, we recommend the following structure.
 
 ```java
 /**
@@ -297,7 +295,7 @@ class MyPixelwiseOp<T extends RealType<T>> implements Computers.Arity2<T, T, T>
 }
 ```
 
-If you then have ImageJ Ops2, the following Op call will match your pixel-wise Op using ImageJ Ops2's lifting mechanisms:
+The following Op call will match your pixel-wise Op using SciJava Ops's lifting mechanisms:
 
 ```java
 ArrayImg<UnsignedByteType> in1 = ...
@@ -349,7 +347,7 @@ class MyNeighborhoodOp<T extends RealType<T>> implements Computers.Arity1<Neighb
 }
 ```
 
-ImageJ Ops2 will then lift this algorithm to operate on images in parallel, requiring users to only define the shape of the neighborhoods to be used:
+SciJava Ops will then lift this algorithm to operate on images in parallel, requiring users to only define the shape of the neighborhoods to be used:
 
 ```java
 ArrayImg<DoubleType> input = ...
diff --git a/docs/ops/doc/conf.py b/docs/ops/doc/conf.py
@@ -19,8 +19,8 @@
 # -- Project information -----------------------------------------------------
 
 project = "SciJava Ops"
-copyright = "2022 ImageJ2 developers"
-author = "ImageJ2 developers"
+copyright = "2014-2024 SciJava developers"
+author = "SciJava developers"
 
 
 # -- General configuration ---------------------------------------------------
diff --git a/docs/ops/doc/index.rst b/docs/ops/doc/index.rst
@@ -5,7 +5,7 @@
 
 Welcome to the Ops documentation!
 ====================================
-SciJava Ops is a library for extensible algorithm retrieval and execution. ImageJ Ops2 is a library for scientific image processing, built atop SciJava Ops and deriving from `ImageJ Ops <https://imagej.net/libs/imagej-ops/>`_.
+SciJava Ops is a library for extensible algorithm retrieval and execution. SciJava Ops Image is a collection of Ops for scientific image processing, built on SciJava Ops.
 
 The combination of these libraries allows declarative image analysis workflows, allowing users to think more about the *what* than the *how*.
 
@@ -22,7 +22,7 @@ The combination of these libraries allows declarative image analysis workflows,
 
    CallingOps
    SearchingForOps
-   ScriptingInImageJ2
+   ScriptingInFiji
    Benchmarks
 
 .. toctree::
diff --git a/scijava-common3/src/main/java/org/scijava/common3/Apps.java b/scijava-common3/src/main/java/org/scijava/common3/Apps.java
@@ -218,12 +218,11 @@ public static File getBaseDirectory(final Class<?> c,
 	 * itself will reside <b>in its Maven build directory</b>. So as long as you
 	 * ask for the base directory relative to a class <em>of the executed
 	 * project</em> it will be found.</li>
-	 * <li><b>Running as an application bundle (e.g., ImageJ).</b> Typically this
-	 * means downloading ImageJ from the web site, unpacking it and running the
-	 * ImageJ launcher (double-clicking ImageJ-win32.exe on Windows,
-	 * double-clicking the {@code ImageJ.app} on OS X, etc.). In this case, all
-	 * components reside in the {@code jars} folder of the application bundle, and
-	 * the base directory will be found one level above that.</li>
+	 * <li><b>Running as an application bundle (e.g., Fiji).</b> Typically this
+	 * means downloading Fiji from its web site, unpacking it and running it using
+	 * its native launcher. In this case, all components reside in the
+	 * {@code jars} folder of the application bundle, and the base directory will
+	 * be found one level above that.</li>
 	 * </ol>
 	 *
 	 * @param classLocation The location from which the base directory should be
diff --git a/scijava-ops-tutorial/src/main/java/org/scijava/ops/tutorial/OpsIntro.java b/scijava-ops-tutorial/src/main/java/org/scijava/ops/tutorial/OpsIntro.java
@@ -43,8 +43,8 @@ public class OpsIntro {
 
 	public static void main(String... args) {
 		/*
-		ImageJ Ops2 is a library for scientific image processing. The fundamental
-		currency of this library are individual algorithms called Ops.
+		SciJava Ops Image is a library for scientific image processing. The
+		fundamental currency of this library are individual algorithms called Ops.
 
 		All Ops share a few traits that establish a baseline of expected behavior:
 
@@ -63,7 +63,7 @@ public static void main(String... args) {
 		 */
 
 		/*
-		The OpEnvironment is the core of ImageJ Ops2. It is a collection of Ops,
+		The OpEnvironment is the core of SciJava Ops. It is a collection of Ops,
 		along with API for accessing Ops, adding new Ops, and other utilities.
 
 		The easiest way to obtain an OpEnvironment is to use the following static
diff --git a/scijava-ops-tutorial/src/main/java/org/scijava/ops/tutorial/UsingNils.java b/scijava-ops-tutorial/src/main/java/org/scijava/ops/tutorial/UsingNils.java
@@ -41,7 +41,7 @@
 import net.imglib2.type.numeric.real.DoubleType;
 
 /**
- * ImageJ Ops2 allows users to take advantage of the strong type safety of the
+ * SciJvaa Ops allows users to take advantage of the strong type safety of the
  * Java language, which can provide benefits in certainty and efficiency. The
  * downside of this is verbosity, especially in obtaining generically-typed
  * outputs from OpBuilder calls.

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`# Ops Reference Documentation`
`2`	`2`
`3`		`-To access SciJava Ops's and ImageJ Ops2's installation, initialization, tutorial, troubleshooting and API reference documentation please visit the [SciJava Ops ReadTheDocs](https://ops.scijava.org/en/latest/index.html) website or build the documentation locally (see [building the reference documentation](https://pyimagej.readthedocs.io/en/latest/Development.html#building-the-reference-documentation) for more details).`
	`3`	`+To access SciJava Ops's installation, initialization, tutorial, troubleshooting and API reference documentation please visit the [SciJava Ops ReadTheDocs](https://ops.scijava.org/en/latest/index.html) website or build the documentation locally (see [building the reference documentation](https://pyimagej.readthedocs.io/en/latest/Development.html#building-the-reference-documentation) for more details).`