Fix misspellings

scijava-concurrent/README.md

@@ -2,7 +2,7 @@
 
 This module provides a framework for executing `Runnable`s and `Callable`s. By abstracting the evaluation of functionality, we can enable the framework to intelligently execute code, increasing performance.
 
-## The `Parallelziation` class
+## The `Parallelization` class
 
 This class provides many static utilities for executing functionality.
 

scijava-concurrent/src/main/java/org/scijava/concurrent/Parallelization.java

@@ -38,7 +38,7 @@
  * The algorithm needs to use the {@link TaskExecutor} returned by
  * {@link Parallelization#getTaskExecutor()} to implement the parallelization.
  * Alternatively it can use {@link Parallelization#getExecutorService()}. But
- * {@link TaskExecutor} is simpler and better suited for image precessing
+ * {@link TaskExecutor} is simpler and better suited for image processing
  * algorithms.
  * <p>
  * The algorithm can be executed singleThreaded, multiThreaded or by using a

scijava-discovery/src/main/java/org/scijava/discovery/Discoverer.java

@@ -115,7 +115,7 @@ static Iterable<Discoverer> allProvided() {
 	 *          is capable of discovering all interfaces {@code use}d by the
 	 *          caller module. If we instead called
 	 *          {@link ServiceLoader#load(Class)} directly, we'd only be able to
-	 *          discover implmentations whose interface was {@code use}d by
+	 *          discover implementations whose interface was {@code use}d by
 	 *          {@code module org.scijava.discovery}.
 	 *          <p>
 	 *          It is in the user's best interest to make this {@link Function} as
@@ -143,7 +143,7 @@ static <T> List<Discoverer> all(
 	}
 
 	/**
-	 * Accumulates mutiple {@link Discoverer}s into one mega-{@code Discoverer}
+	 * Accumulates multiple {@link Discoverer}s into one mega-{@code Discoverer}
 	 *
 	 * @param discoverers the {@link Discoverer}s to be wrapped
 	 * @return the mega-{@link Discoverer}

scijava-ops-api/src/main/java/org/scijava/ops/api/Hints.java

@@ -84,7 +84,7 @@ public Hints plus(String... hints) {
 	}
 
 	/**
-	 * Reutrns a <b>new</b> {@link Hints} with:
+	 * Returns a <b>new</b> {@link Hints} with:
 	 * <ol>
 	 * <li>All hints in this {@link Hints}</li>
 	 * <li>All hints in {@code other}</li>

scijava-ops-api/src/main/java/org/scijava/ops/api/package-info.java

@@ -6,7 +6,7 @@
  * their own data structures, algorithm syntax, and other requirements. With all
  * of these differences, library interoperability can be a daunting task. This
  * can lead to algorithm reimplementations, unmaintained code, and a lack of
- * cooperation between open-source communitites. SciJava Ops seeks to unify
+ * cooperation between open-source communities. SciJava Ops seeks to unify
  * different libraries under a single framework, separating the development of
  * new algorithms from the way they are executed. Put more succinctly, the goals
  * of SciJava Ops are the following:
@@ -104,9 +104,9 @@
  * <li>Structural-equivalence in Ops allows us to consider similar Ops in
  * different languages as one, and to delegate to the proper Op using user
  * inputs. In other words, you can call structural-equivalent Ops identically,
- * and Scijava Ops will take care to call the correct Op based on the concrete
+ * and SciJava Ops will take care to call the correct Op based on the concrete
  * inputs provided.</li>
- * <li>Result-equivalence, and therefore reproducability, in Ops, is guaranteed
+ * <li>Result-equivalence, and therefore reproducibility, in Ops, is guaranteed
  * within an OpEnvironment and a set of input objects, but not just for Op
  * calls. This allows us to ensure reproducible pipelines, but also allows us to
  * introduce new Ops into the pipeline or to run pipelines on different inputs

scijava-ops-benchmarks/pom.xml

@@ -12,7 +12,7 @@
 	<artifactId>scijava-ops-benchmarks</artifactId>
 
 	<name>SciJava Ops Benchmarks</name>
-	<description>SciJava Operations Benchmarks: A set of benchmarking tests for the Scijava Ops Engine library</description>
+	<description>SciJava Operations Benchmarks: A set of benchmarking tests for the SciJava Ops Engine library</description>
 	<url>https://github.com/scijava/scijava-ops-benchmarks</url>
 	<inceptionYear>2023</inceptionYear>
 	<organization>

scijava-ops-engine/src/main/java/org/scijava/ops/engine/exceptions/impl/PrivateOpException.java

@@ -35,7 +35,7 @@
 import org.scijava.ops.engine.exceptions.InvalidOpException;
 
 /**
- * Exception thrown when an Op is declared as private. This is unallowed as the
+ * Exception thrown when an Op is declared as private. This is disallowed as the
  * Ops engine cannot access it.
  *
  * @author Gabriel Selzer

scijava-ops-engine/src/main/java/org/scijava/ops/engine/impl/DefaultOpHistory.java

@@ -62,7 +62,7 @@
  */
 public class DefaultOpHistory implements OpHistory {
 
-	// -- DATA STRCUTURES -- //
+	// -- DATA STRUCTURES -- //
 
 	private final Map<Object, List<RichOp<?>>> mutationMap = new WeakHashMap<>();
 

scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/MatchingResult.java

@@ -130,7 +130,7 @@ public static String matchInfo(final MatchingResult res) {
 			sb.append("Multiple '" + request.getLabel() + "' ops of priority " +
 				priority + ":\n");
 			if (typeCheckingIncomplete(matches)) {
-				sb.append("Incomplete output type checking may have occured!\n");
+				sb.append("Incomplete output type checking may have occurred!\n");
 			}
 			int count = 0;
 			for (final OpCandidate match : matches) {

scijava-ops-engine/src/main/java/org/scijava/ops/engine/matcher/convert/PrimitiveArrayConverters.java

@@ -124,7 +124,7 @@ public class PrimitiveArrayConverters<N extends Number> implements
 			return oa;
 		};
 
-	// -- Object Focusers -- //
+	// -- Object Converters -- //
 
 	@OpHints(hints = { Conversion.FORBIDDEN })
 	@OpField(names = "engine.convert")
@@ -157,7 +157,7 @@ public class PrimitiveArrayConverters<N extends Number> implements
 		.stream().map(d -> d == null ? null : d.doubleValue()).toArray(
 			Double[]::new);
 
-	// -- Primitive Focusers -- //
+	// -- Primitive Converters -- //
 
 	@OpHints(hints = { Conversion.FORBIDDEN })
 	@OpField(names = "engine.convert")

scijava-ops-engine/src/main/java/org/scijava/ops/engine/struct/OpResizingMemberParser.java

@@ -57,7 +57,7 @@ public class OpResizingMemberParser implements
 	 * {@code srcStruct}
 	 * <li>That there is <b>one</b> output {@link Member} in {@code srcStruct}
 	 * </ol>
-	 * We should consider adding the evalutation of these assumptions
+	 * We should consider adding the evaluation of these assumptions
 	 *
 	 * @param source the {@link RetypingRequest} from which we create the new
 	 *          {@link List} of {@link Member}s

scijava-ops-engine/src/main/java/org/scijava/ops/engine/struct/OpRetypingMemberParser.java

@@ -59,7 +59,7 @@ public class OpRetypingMemberParser implements
 	 * <li>That there is <b>one</b> output {@link Member} in
 	 * {@code srcStruct}</li>
 	 * </ol>
-	 * We should consider adding the evalutation of these assumptions
+	 * We should consider adding the evaluation of these assumptions
 	 *
 	 * @param source the {@link RetypingRequest} from which we create the new
 	 *          {@link List} of {@link Member}s

scijava-ops-engine/src/main/java/org/scijava/ops/engine/yaml/AbstractYAMLOpInfoCreator.java

@@ -61,7 +61,7 @@ public OpInfo create(final URI identifier, final Map<String, Object> yaml) {
 		final String srcString = identifier.getPath().substring(1);
 		// Parse version
 		final String version = yaml.get("version").toString();
-		// Parase names
+		// Parse names
 		final String[] names = parseNames(yaml, identifier);
 		// Create the OpInfo
 		OpInfo info;

scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingUtilsTest.java

@@ -198,16 +198,16 @@ abstract class SingleVarBoundedNestedWildcardAndOther<I extends Iterable<? exten
 	}
 
 	@Test
-	public void genericAssignabilitySingleVarMultipleOccurence() {
-		abstract class SingleVarBoundedNestedMultipleOccurence<I extends Iterable<String>>
+	public void genericAssignabilitySingleVarMultipleOccurrence() {
+		abstract class SingleVarBoundedNestedMultipleOccurrence<I extends Iterable<String>>
 			implements Function<I, I>
 		{}
 
-		abstract class SingleVarBoundedNestedWildcardMultipleOccurence<I extends Iterable<? extends Number>>
+		abstract class SingleVarBoundedNestedWildcardMultipleOccurrence<I extends Iterable<? extends Number>>
 			implements Function<I, I>
 		{}
 
-		abstract class SingleVarBoundedNestedWildcardMultipleOccurenceUsedNested<I extends Iterable<? extends Number>>
+		abstract class SingleVarBoundedNestedWildcardMultipleOccurrenceUsedNested<I extends Iterable<? extends Number>>
 			implements Function<I, List<I>>
 		{}
 
@@ -216,33 +216,33 @@ abstract class SingleVarBoundedNestedWildcardMultipleOccurenceUsedNested<I exten
 		Nil<Function<List<String>, List<Integer>>> n1 = new Nil<>() {};
 		Nil<Function<List<String>, Double>> n2 = new Nil<>() {};
 
-		assertAll(SingleVarBoundedNestedMultipleOccurence.class, true, y1, y2);
-		assertAll(SingleVarBoundedNestedMultipleOccurence.class, false, n1, n2);
+		assertAll(SingleVarBoundedNestedMultipleOccurrence.class, true, y1, y2);
+		assertAll(SingleVarBoundedNestedMultipleOccurrence.class, false, n1, n2);
 
 		Nil<Function<List<Double>, List<Double>>> y3 = new Nil<>() {};
 		Nil<Function<Iterable<Double>, Iterable<Double>>> y4 = new Nil<>() {};
 		Nil<Function<Iterable<Double>, Iterable<Integer>>> n3 = new Nil<>() {};
 		Nil<Function<List<String>, Integer>> n4 = new Nil<>() {};
 
-		assertAll(SingleVarBoundedNestedWildcardMultipleOccurence.class, true, y3,
+		assertAll(SingleVarBoundedNestedWildcardMultipleOccurrence.class, true, y3,
 			y4);
-		assertAll(SingleVarBoundedNestedWildcardMultipleOccurence.class, false, n3,
+		assertAll(SingleVarBoundedNestedWildcardMultipleOccurrence.class, false, n3,
 			n4);
 
 		Nil<Function<List<Double>, Iterable<List<Double>>>> n5 = new Nil<>() {};
 		Nil<Function<Iterable<Double>, List<Iterable<Double>>>> y5 = new Nil<>() {};
 
-		assertAll(SingleVarBoundedNestedWildcardMultipleOccurenceUsedNested.class,
+		assertAll(SingleVarBoundedNestedWildcardMultipleOccurrenceUsedNested.class,
 			true, y5);
-		assertAll(SingleVarBoundedNestedWildcardMultipleOccurenceUsedNested.class,
+		assertAll(SingleVarBoundedNestedWildcardMultipleOccurrenceUsedNested.class,
 			false, n5);
 
-		abstract class SingleVarMultipleOccurenceUsedNested<I> implements
+		abstract class SingleVarMultipleOccurrenceUsedNested<I> implements
 			Function<I, List<I>>
 		{}
 
 		Nil<Function<Integer, List<Number>>> n6 = new Nil<>() {};
-		assertAll(SingleVarMultipleOccurenceUsedNested.class, false, n6);
+		assertAll(SingleVarMultipleOccurrenceUsedNested.class, false, n6);
 	}
 
 	@Test
@@ -310,16 +310,16 @@ abstract class IBoundedByN<N extends Number, I extends Iterable<N>>
 	}
 
 	@Test
-	public void genericAssignabilityDoubleVarDependingImplicitelyBounded() {
-		abstract class IBoundedByNImplicitely<N extends Number, I extends Iterable<N>>
+	public void genericAssignabilityDoubleVarDependingImplicitlyBounded() {
+		abstract class IBoundedByNImplicitly<N extends Number, I extends Iterable<N>>
 			implements BiFunction<I, I, List<String>>
 		{}
 
 		Nil<BiFunction<Iterable<Double>, Iterable<Double>, List<String>>> y1 =
 			new Nil<>()
 			{};
 
-		assertAll(IBoundedByNImplicitely.class, true, y1);
+		assertAll(IBoundedByNImplicitly.class, true, y1);
 	}
 
 	@Test

scijava-ops-image/src/main/java/org/scijava/ops/image/coloc/maxTKendallTau/MTKT.java

@@ -51,7 +51,7 @@
 import org.scijava.ops.spi.OpDependency;
 
 /**
- * This algorithm calculates Maximum Trunctated Kendall Tau (MTKT) from Wang et
+ * This algorithm calculates Maximum Truncated Kendall Tau (MTKT) from Wang et
  * al. (2017); computes thresholds using Otsu method.
  *
  * @param <T> Type of the first image
@@ -235,12 +235,12 @@ static double calculateKendallTau(final double[][] rank,
 	{
 		final int an = activeIndex.size();
 
-		int indicatr = 0;
+		int indicator = 0;
 		final double[][] partRank = new double[2][an];
 		for (final Integer i : activeIndex) {
-			partRank[0][indicatr] = rank[i][0];
-			partRank[1][indicatr] = rank[i][1];
-			indicatr++;
+			partRank[0][indicator] = rank[i][0];
+			partRank[1][indicator] = rank[i][1];
+			indicator++;
 		}
 		final double[] partRank1 = partRank[0];
 		final double[] partRank2 = partRank[1];

scijava-ops-image/src/main/java/org/scijava/ops/image/coloc/pearsons/DefaultPearsons.java

@@ -107,7 +107,7 @@ private static void checkForSanity(final double value, final int iterations) {
 			 *   could get NaN. NaN
 			 */
 			throw new IllegalArgumentException(
-				"A numerical problem occured: the input data is unsuitable for this algorithm. Possibly too few pixels (in range were: " +
+				"A numerical problem occurred: the input data is unsuitable for this algorithm. Possibly too few pixels (in range were: " +
 					iterations + ").");
 		}
 	}
@@ -138,7 +138,7 @@ public Accumulator(final Iterable<Pair<T, U>> samples) {
 			this(samples, false, 0.0d, 0.0d);
 		}
 
-		protected Accumulator(final Iterable<Pair<T, U>> samples, boolean substract,
+		protected Accumulator(final Iterable<Pair<T, U>> samples, boolean subtract,
 			double xDiff, double yDiff)
 		{
 
@@ -147,7 +147,7 @@ protected Accumulator(final Iterable<Pair<T, U>> samples, boolean substract,
 				double value1 = sample.getA().getRealDouble();
 				double value2 = sample.getB().getRealDouble();
 
-				if (substract) {
+				if (subtract) {
 					value1 -= xDiff;
 					value2 -= yDiff;
 				}

scijava-ops-image/src/main/java/org/scijava/ops/image/create/DefaultCreateKernelGabor.java

@@ -49,9 +49,9 @@
  * instance, filtering only along 2nd axis is desired, one may provide the
  * sigmas array filled with zeroes (0) except for the 2nd element.
  * <p>
- * The period vector is a vector along which oscilates the frequency part of the
+ * The period vector is a vector along which oscillates the frequency part of the
  * Gabor filter. The length of this vector equals precisely the wave-length of
- * the oscilations (the length of 1 period).
+ * the oscillations (the length of 1 period).
  * <p>
  * All values are in units of pixels. Both input arrays have to be of the same
  * length.
@@ -119,13 +119,13 @@ RandomAccessibleInterval<C> createKernel(final double[] sigmas,
 				final double dx = dims[d] - centre[d];
 
 				if (sigmas[d] > 0.)
-					// normal case: cummulate exp's argument
+					// normal case: accumulate exp's argument
 					GaussExp += dx * dx / (sigmas[d] * sigmas[d]);
 				else if (dx != 0.)
 					// sigmas[d] == 0 && we are off the blocking axis
 					blockingExp = 0.f;
 
-				// cummulates scalar product...
+				// accumulate scalar product...
 				freqPart += dx * period[d];
 			}
 			GaussExp = Math.exp(-0.5 * GaussExp) * blockingExp;

scijava-ops-image/src/main/java/org/scijava/ops/image/features/haralick/DefaultClusterPromenence.java → scijava-ops-image/src/main/java/org/scijava/ops/image/features/haralick/DefaultClusterProminence.java

@@ -39,13 +39,13 @@
 import org.scijava.ops.spi.OpDependency;
 
 /**
- * Implementation of Cluster Promenence Haralick Feature
+ * Implementation of Cluster Prominence Haralick Feature
  *
  * @author Andreas Graumann (University of Konstanz)
  * @author Christian Dietz (University of Konstanz)
- * @implNote op names='features.haralick.clusterPromenence'
+ * @implNote op names='features.haralick.clusterProminence'
  */
-public class DefaultClusterPromenence<T extends RealType<T>> extends
+public class DefaultClusterProminence<T extends RealType<T>> extends
 	AbstractHaralickFeature<T>
 {
 

scijava-ops-image/src/main/java/org/scijava/ops/image/features/tamura2d/DefaultCoarsenessFeature.java

@@ -104,7 +104,7 @@ public void compute(final RandomAccessibleInterval<I> input, final O output) {
 	 *
 	 * @param input Input image
 	 * @param meanImages Mean images
-	 * @return Array containing all leadding difference values
+	 * @return Array containing all leading difference values
 	 */
 	private ArrayList<Double> sizedLeadDiffValues(
 		final RandomAccessibleInterval<I> input,
@@ -159,7 +159,7 @@ private ArrayList<Double> sizedLeadDiffValues(
 	 *
 	 * @param input Input image
 	 * @param i Size of rectangle shape
-	 * @return Filered mean image
+	 * @return Filtered mean image
 	 */
 	@SuppressWarnings("unchecked")
 	private Img<I> mean(final RandomAccessibleInterval<I> input, final int i) {

scijava-ops-image/src/main/java/org/scijava/ops/image/features/tamura2d/DefaultDirectionalityFeature.java

@@ -83,7 +83,7 @@ public void compute(final RandomAccessibleInterval<I> input,
 			"Only 2 dimensional images allowed!");
 		if (histogramSize == null) histogramSize = 16;
 
-		// List to store all directions occuring within the image on borders
+		// List to store all directions occurring within the image on borders
 		ArrayList<DoubleType> dirList = new ArrayList<>();
 
 		// Dimension of input region
@@ -128,7 +128,7 @@ public void compute(final RandomAccessibleInterval<I> input,
 		if (dirList.isEmpty()) {
 			output.setReal(0.0);
 		}
-		// Otherwise compute histogram over all occuring directions
+		// Otherwise compute histogram over all occurring directions
 		// and calculate inverse second moment on it as output
 		else {
 			Histogram1d<DoubleType> hist = histOp.apply(dirList, histogramSize);