WIP

Author: gselzer

pom.xml

@@ -122,6 +122,8 @@
 		<releaseProfiles>sign,deploy-to-scijava</releaseProfiles>
 
 		<imageio-tiff.version>3.9.4</imageio-tiff.version>
+
+		<scijava.ops.parse>true</scijava.ops.parse>
 	</properties>
 
 	<repositories>
@@ -131,6 +133,28 @@
 		</repository>
 	</repositories>
 
+	<build>
+		<plugins>
+			<plugin>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<configuration>
+					<annotationProcessorPaths>
+						<path>
+							<groupId>org.scijava</groupId>
+							<artifactId>scijava-ops-indexer</artifactId>
+							<version>1.0.1-SNAPSHOT</version>
+						</path>
+					</annotationProcessorPaths>
+					<fork>true</fork>
+					<compilerArgs>
+						<arg>-Ascijava.ops.parse=${scijava.ops.parse}</arg>
+						<arg>-Ascijava.ops.opVersion=${project.version}</arg>
+					</compilerArgs>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
 	<dependencies>
 		<!-- ImgLib2 dependencies -->
 		<dependency>

src/main/java/net/imglib2/mesh/MeshStats.java

@@ -48,6 +48,7 @@ public class MeshStats
 	/**
 	 * Computes the volume of the specified mesh.
 	 *
+	 * @param mesh the input {@link Mesh}
 	 * @return the volume in physical units.
 	 * @implNote op names='geom.size', label='Geometric (3D): Volume',
 	 *           priority='9999.'
@@ -282,7 +283,7 @@ public static double compactness( final Mesh mesh )
 	 * @param input
 	 *            the input mesh.
 	 * @return the centroid of the mesh.
-	 * @implNote op names='geom.centerOfGravity', priority='10000.'
+	 * @implNote op names='geom.centroid', priority='10000.'
 	 */
 	public static RealPoint centroid( final Mesh input )
 	{
@@ -340,6 +341,75 @@ public static RealPoint centroid( final Mesh input )
 		return new RealPoint( m100 / v, m010 / v, m001 / v );
 	}
 
+	/**
+	 * Returns the centroid of the mesh, that is the center of gravity of its
+	 * volume.
+	 * <p>
+	 * (As a side note, {@link Meshes#center(Mesh)} returns the center of
+	 * gravity of the mesh's surface.)
+	 *
+	 * @author Jean-Yves Tinevez
+	 * @param input
+	 *            the input mesh.
+	 * @return the centroid of the mesh.
+	 * @implNote op names='geom.centerOfGravity', priority='10000.'
+	 */
+	public static RealPoint centroid2( final Mesh input )
+	{
+		// Variable names from moment definition.
+		double m100 = 0.;
+		double m010 = 0.;
+		double m001 = 0.;
+		for ( int i = 0; i < input.triangles().size(); i++ )
+		{
+			final long v0 = input.triangles().vertex0( i );
+			final long v1 = input.triangles().vertex1( i );
+			final long v2 = input.triangles().vertex2( i );
+
+			final double x1 = input.vertices().x( v0 );
+			final double y1 = input.vertices().y( v0 );
+			final double z1 = input.vertices().z( v0 );
+			final double x2 = input.vertices().x( v1 );
+			final double y2 = input.vertices().y( v1 );
+			final double z2 = input.vertices().z( v1 );
+			final double x3 = input.vertices().x( v2 );
+			final double y3 = input.vertices().y( v2 );
+			final double z3 = input.vertices().z( v2 );
+			final double[] normals = new double[3];
+			// If
+			MeshUtil.cross(
+				// v1 - v0
+				x2 - x1, //
+				y2 - y1, //
+				z2 - z1, //
+				// v2 - v0
+				x3 - x1, //
+				y3 - y1, //
+				z3 - z1, //
+				normals);
+			final double normalDot =
+				input.triangles().nx(i) * normals[0] +
+				input.triangles().ny(i) * normals[1] +
+				input.triangles().nz(i) * normals[2];
+			if (normalDot < 0) {
+				throw new IllegalStateException("foooooo");
+			}
+
+
+			final double detA = //
+					x1 * (y2 * z3 - y3 * z2) - //
+					x2 * (y1 * z3 - y3 * z1) + //
+					x3 * (y1 * z2 - y2 * z1);
+
+			m100 += (1d / 24) * detA * (x1 + x2 + x3);
+			m010 += (1d / 24) * detA * (y1 + y2 + y3);
+			m001 += (1d / 24) * detA * (z1 + z2 + z3);
+		}
+
+		final double v = volume( input );
+		return new RealPoint( m100 / v, m010 / v, m001 / v );
+	}
+
 	/**
 	 * Describes the elogation of a {@link Mesh}. As elongation is a metric of a
 	 * two-dimensional object, this functionality describes elongation as a
@@ -433,13 +503,16 @@ public static long convexHullVerticesCount(final Mesh input) {
 
 
 	/**
-	 * Describes the spareness of {@code geom.spareness}. Based on ImageJ.
-	 *
-	 * @author Tim-Oliver Buchholz (University of Konstanz)
-	 * @implNote op names='geom.spareness', label='Geometric (3D): Spareness',
-	 *           priority='10000.'
-	 */
-	public static double spareness(final Mesh input) {
+     * Describes the ellipse variance of a {@link Mesh}. Ellipse variance is defined as the ratio of the {@code Mesh}'s volume to that of an ellipsoid with an identical bounding box.
+     * Inspiration drawn from <a href="https://hal.science/hal-00446037/PDF/ARS-Journal-SurveyPatternRecognition.pdf">here<a>
+     *
+     * @param input the input {@link Mesh}
+     * @return the ellipse variance
+     * @author Tim-Oliver Buchholz (University of Konstanz)
+     * @implNote op names='geom.ellipseVariance, geom.ellipticity, geom.spareness', label='Geometric (3D): Spareness',
+     *           priority='10000.'
+     */
+	public static double ellipseVariance(final Mesh input) {
 		final RealMatrix it = InertiaTensor.calculate(input);
 		final EigenDecomposition ed = new EigenDecomposition(it);
 

src/main/java/net/imglib2/mesh/Meshes.java

@@ -152,7 +152,8 @@ public static Mesh boundingBoxMesh(final Mesh input) {
 	 * @param src
 	 *            Source mesh, from which data will be copied.
 	 * @param dest
-	 *            Destination mesh, into which source will be copied.
+	 *            Destination mesh, into which source will be copied. (container)
+	 * @implNote op names="engine.copy, copy.mesh"
 	 */
 	public static void copy( final net.imglib2.mesh.Mesh src, final net.imglib2.mesh.Mesh dest )
 	{

src/main/java/net/imglib2/mesh/alg/InertiaTensor.java

@@ -28,6 +28,7 @@
  */
 package net.imglib2.mesh.alg;
 
+import net.imglib2.mesh.Meshes;
 import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
 import org.apache.commons.math3.linear.BlockRealMatrix;
 import org.apache.commons.math3.linear.RealMatrix;
@@ -54,11 +55,14 @@ public class InertiaTensor
 {
 
 	/**
+	 * Computes the inertia tensor.
+	 * @param input the input {@link Mesh}
+	 * @return a {@link RealMatrix} whose entries form the inertia tensor
 	 * @implNote op names='geom.secondMoment'
 	 */
 	public static RealMatrix calculate( final Mesh input )
 	{
-		final RealLocalizable cent = MeshStats.centroid( input );
+		final RealLocalizable cent = MeshStats.centroid(input);
 		final double originX = cent.getDoublePosition( 0 );
 		final double originY = cent.getDoublePosition( 1 );
 		final double originZ = cent.getDoublePosition( 2 );

src/main/java/net/imglib2/mesh/alg/Voxelization.java

@@ -28,18 +28,13 @@
  */
 package net.imglib2.mesh.alg;
 
-import net.imglib2.FinalDimensions;
-import net.imglib2.RandomAccess;
-import net.imglib2.RandomAccessibleInterval;
-import net.imglib2.RealLocalizable;
-import net.imglib2.RealPoint;
+import net.imglib2.*;
 import net.imglib2.img.Img;
 import net.imglib2.mesh.Mesh;
 import net.imglib2.mesh.Triangle;
 import net.imglib2.mesh.Vertices;
 import net.imglib2.type.BooleanType;
 import net.imglib2.type.logic.BitType;
-
 import net.imglib2.util.Util;
 import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
 
@@ -62,13 +57,43 @@ private Voxelization()
 		// NB: Prevent instantiation of utility class.
 	}
 
+	/**
+	 * Voxelizes {@code mesh}
+	 *
+	 * @param mesh the input {@link Mesh}
+	 * @param width the width of the resulting image
+	 * @param height the height of the resulting image
+	 * @param depth the depth of the resulting image
+	 * @return an {@link Img} containing a voxelization of {@code mesh}
+	 * @implNote op names="geom.voxelization"
+	 */
 	public static Img< BitType > voxelize( Mesh mesh, int width, int height, int depth )
 	{
-		Img< BitType > outImg = Util.getSuitableImgFactory( new FinalDimensions( width, height, depth ), new BitType() ).create( width, height, depth );
+		return voxelize(mesh, new FinalDimensions(width, height, depth));
+	}
+
+	/**
+	 * Voxelizes {@code mesh}
+	 *
+	 * @param mesh the input {@link Mesh}
+	 * @param dims the {@link Dimensions} of the output image
+	 * @return an {@link Img} containing a voxelization of {@code mesh}
+	 * @implNote op names="geom.voxelization"
+	 */
+	public static Img< BitType > voxelize( Mesh mesh, Dimensions dims )
+	{
+		Img< BitType > outImg = Util.getSuitableImgFactory(dims , new BitType() ).create(dims.dimensionsAsLongArray());
 		voxelize( mesh, outImg );
 		return outImg;
 	}
 
+	/**
+	 * Voxelizes {@code mesh}
+	 *
+	 * @param mesh the input {@link Mesh}
+	 * @param out an output buffer in which the voxelization will be stored (container)
+	 * @implNote op names="geom.voxelization"
+	 */
 	public static < B extends BooleanType< B > > void voxelize( Mesh mesh, RandomAccessibleInterval< B > out )
 	{
 		final long[] dims = out.dimensionsAsLongArray();

src/test/java/net/imglib2/mesh/MeshStatsTest.java

@@ -141,6 +141,14 @@ public void convexityMesh()
 		assertEquals( "Incorrect convexity returned.", expected, actual, EPSILON );
 	}
 
+	@Test
+	public void ellipseVariance()
+	{
+		final double actual = MeshStats.ellipseVariance( mesh );
+		final double expected = 0.9838757743034947;
+		assertEquals( "Incorrect ellipse variance returned.", expected, actual, EPSILON );
+	}
+
 	@Test
 	public void sizeConvexHullMesh()
 	{