Improve AdHocMesh performance (#8905)

Avoiding some Vec3Double/Vec3Float allocations and conversions.

Measurements showed 10–20 percent improvement for a test box.

I did not end up using CPP/JNI optimizations because C++ marching cubes,
tested from elsewhere, is not significantly faster.

The large line change count is almost completely due to the formatter
introducing new line breaks in the marching cubes table.

### URL of deployed dev instance (used for testing):
- https://adhoccpp.webknossos.xyz

### Steps to test:
- Request ad-hoc meshes, should still work, be a little faster

------
- [x] Added changelog entry (create a `$PR_NUMBER.md` file in
`unreleased_changes` or use `./tools/create-changelog-entry.py`)
- [x] Considered [common edge
cases](../blob/master/.github/common_edge_cases.md)
- [x] Needs datastore update after deployment

---------

Co-authored-by: MichaelBuessemeyer <39529669+MichaelBuessemeyer@users.noreply.github.com>

Author: fm3

unreleased_changes/8905.md

@@ -0,0 +1,2 @@
+### Added
+- Improved speed of ad-hoc mesh computation by 10–20%

util/src/main/scala/com/scalableminds/util/geometry/Vec3Float.scala

@@ -25,6 +25,12 @@ case class Vec3Float(x: Float, y: Float, z: Float) {
 }
 
 object Vec3Float {
+  def apply(p: Vec3Int): Vec3Float =
+    Vec3Float(p.x.toFloat, p.y.toFloat, p.z.toFloat)
+
+  def apply(p: Vec3Double): Vec3Float =
+    Vec3Float(p.x.toFloat, p.y.toFloat, p.z.toFloat)
+
   implicit object Vec3FloatReads extends Reads[Vec3Float] {
     def reads(json: JsValue): JsResult[Vec3Float] = json match {
       case JsArray(ts) if ts.size == 3 =>

webknossos-datastore/app/com/scalableminds/webknossos/datastore/services/mcubes/MarchingCubes.scala

@@ -1,6 +1,6 @@
 package com.scalableminds.webknossos.datastore.services.mcubes
 
-import com.scalableminds.util.geometry.{BoundingBox, Vec3Double, Vec3Int}
+import com.scalableminds.util.geometry.{BoundingBox, Vec3Float, Vec3Int}
 
 import scala.collection.mutable
 
@@ -10,9 +10,9 @@ object MarchingCubes {
                        dataDimensions: Vec3Int,
                        boundingBox: BoundingBox,
                        segmentId: T,
-                       offset: Vec3Double,
-                       scale: Vec3Double,
-                       vertexBuffer: mutable.ArrayBuffer[Vec3Double]): Unit = {
+                       offset: Vec3Float,
+                       scale: Vec3Float,
+                       vertexBuffer: mutable.ArrayBuffer[Float]): Unit = {
 
     def getVoxelData(x: Int, y: Int, z: Int): T =
       data(x + (dataDimensions.x * y) + (dataDimensions.x * dataDimensions.y * z))
@@ -49,9 +49,10 @@ object MarchingCubes {
       if (getVoxelData(x, y + 1, z + 1) == segmentId) cubeIndex |= 128
       if (getVoxelData(x + 1, y + 1, z + 1) == segmentId) cubeIndex |= 64
 
-      val position = Vec3Double(x, y, z)
       MarchingCubesTable.triangleTable(cubeIndex).foreach { edgeDelta =>
-        vertexBuffer += (position + edgeDelta + offset) * scale
+        vertexBuffer += (x + edgeDelta.x + offset.x) * scale.x
+        vertexBuffer += (y + edgeDelta.y + offset.y) * scale.y
+        vertexBuffer += (z + edgeDelta.z + offset.z) * scale.z
       }
     }
   }