ND Datasets

MIGRATIONS.unreleased.md

@@ -17,3 +17,4 @@ UPDATE webknossos.multiUsers SET isEmailVerified = false;
 ### Postgres Evolutions:
 - [105-verify-email.sql](conf/evolutions/105-verify-email.sql)
 - [106-folder-no-slashes.sql](conf/evolutions/106-folder-no-slashes.sql)
+- [107-additional-coordinates](conf/evolutions/107-additional-coordinates.sql)

app/controllers/AnnotationController.scala

@@ -8,6 +8,7 @@ import com.scalableminds.util.time.Instant
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
 import com.scalableminds.webknossos.datastore.models.annotation.AnnotationLayerType.AnnotationLayerType
 import com.scalableminds.webknossos.datastore.models.annotation.{AnnotationLayer, AnnotationLayerType}
+import com.scalableminds.webknossos.datastore.models.datasource.AdditionalCoordinate
 import com.scalableminds.webknossos.tracingstore.tracings.volume.ResolutionRestrictions
 import com.scalableminds.webknossos.tracingstore.tracings.{TracingIds, TracingType}
 import io.swagger.annotations._
@@ -39,7 +40,8 @@ case class AnnotationLayerParameters(typ: AnnotationLayerType,
                                      autoFallbackLayer: Boolean = false,
                                      mappingName: Option[String] = None,
                                      resolutionRestrictions: Option[ResolutionRestrictions],
-                                     name: Option[String])
+                                     name: Option[String],
+                                     additionalCoordinate: Option[Seq[AdditionalCoordinate]])
 object AnnotationLayerParameters {
   implicit val jsonFormat: OFormat[AnnotationLayerParameters] =
     Json.using[WithDefaultValues].format[AnnotationLayerParameters]

app/controllers/LegacyApiController.scala

@@ -431,7 +431,8 @@ class LegacyApiController @Inject()(annotationController: AnnotationController,
             autoFallbackLayer = false,
             None,
             request.body.resolutionRestrictions,
-            name = Some(AnnotationLayer.defaultSkeletonLayerName)
+            name = Some(AnnotationLayer.defaultSkeletonLayerName),
+            None
           ))
     val volumeParameters =
       if (request.body.typ == "skeleton") None
@@ -443,7 +444,8 @@ class LegacyApiController @Inject()(annotationController: AnnotationController,
             autoFallbackLayer = false,
             None,
             request.body.resolutionRestrictions,
-            name = Some(AnnotationLayer.defaultVolumeLayerName)
+            name = Some(AnnotationLayer.defaultVolumeLayerName),
+            None
           ))
     List(skeletonParameters, volumeParameters).flatten
   }

app/models/annotation/AnnotationService.scala

@@ -11,6 +11,7 @@ import com.scalableminds.util.tools.{BoxImplicits, Fox, FoxImplicits, TextUtils}
 import com.scalableminds.webknossos.datastore.SkeletonTracing._
 import com.scalableminds.webknossos.datastore.VolumeTracing.{VolumeTracing, VolumeTracingOpt, VolumeTracings}
 import com.scalableminds.webknossos.datastore.geometry.{
+  AdditionalCoordinateProto,
   ColorProto,
   NamedBoundingBoxProto,
   Vec3DoubleProto,
@@ -24,6 +25,7 @@ import com.scalableminds.webknossos.datastore.models.annotation.{
   FetchedAnnotationLayer
 }
 import com.scalableminds.webknossos.datastore.models.datasource.{
+  AdditionalCoordinate,
   ElementClass,
   DataSourceLike => DataSource,
   SegmentationLayerLike => SegmentationLayer
@@ -77,7 +79,8 @@ case class RedundantTracingProperties(
     editPosition: Vec3IntProto,
     editRotation: Vec3DoubleProto,
     zoomLevel: Double,
-    userBoundingBoxes: Seq[NamedBoundingBoxProto]
+    userBoundingBoxes: Seq[NamedBoundingBoxProto],
+    editPositionAdditionalCoordinates: Seq[AdditionalCoordinateProto],
 )
 
 class AnnotationService @Inject()(
@@ -144,6 +147,8 @@ class AnnotationService @Inject()(
   ): Fox[VolumeTracing] = {
     val resolutions = VolumeTracingDownsampling.magsForVolumeTracing(dataSource, fallbackLayer)
     val resolutionsRestricted = resolutionRestrictions.filterAllowed(resolutions)
+    val additionalCoordinates =
+      fallbackLayer.map(_.additionalCoordinates).getOrElse(dataSource.additionalCoordinatesUnion)
     for {
       _ <- bool2Fox(resolutionsRestricted.nonEmpty) ?~> "annotation.volume.resolutionRestrictionsTooTight"
     } yield
@@ -163,7 +168,8 @@ class AnnotationService @Inject()(
         organizationName = Some(datasetOrganizationName),
         mappingName = mappingName,
         resolutions = resolutionsRestricted.map(vec3IntToProto),
-        hasSegmentIndex = Some(fallbackLayer.isEmpty)
+        hasSegmentIndex = Some(fallbackLayer.isEmpty),
+        additionalCoordinates = AdditionalCoordinate.toProto(additionalCoordinates)
       )
   }
 
@@ -240,13 +246,15 @@ class AnnotationService @Inject()(
               dataSetName = dataSet.name,
               editPosition = dataSource.center,
               organizationName = Some(datasetOrganizationName),
+              additionalCoordinates = AdditionalCoordinate.toProto(dataSource.additionalCoordinatesUnion)
             )
             val skeletonAdapted = oldPrecedenceLayerProperties.map { p =>
               skeleton.copy(
                 editPosition = p.editPosition,
                 editRotation = p.editRotation,
                 zoomLevel = p.zoomLevel,
-                userBoundingBoxes = p.userBoundingBoxes
+                userBoundingBoxes = p.userBoundingBoxes,
+                editPositionAdditionalCoordinates = p.editPositionAdditionalCoordinates
               )
             }.getOrElse(skeleton)
             for {
@@ -273,7 +281,8 @@ class AnnotationService @Inject()(
                   editPosition = p.editPosition,
                   editRotation = p.editRotation,
                   zoomLevel = p.zoomLevel,
-                  userBoundingBoxes = p.userBoundingBoxes
+                  userBoundingBoxes = p.userBoundingBoxes,
+                  editPositionAdditionalCoordinates = p.editPositionAdditionalCoordinates
                 )
               }.getOrElse(volumeTracing)
               volumeTracingId <- client.saveVolumeTracing(volumeTracingAdapted)
@@ -305,15 +314,17 @@ class AnnotationService @Inject()(
             s.editRotation,
             s.zoomLevel,
             s.userBoundingBoxes ++ s.userBoundingBox.map(
-              com.scalableminds.webknossos.datastore.geometry.NamedBoundingBoxProto(0, None, None, None, _))
+              com.scalableminds.webknossos.datastore.geometry.NamedBoundingBoxProto(0, None, None, None, _)),
+            s.editPositionAdditionalCoordinates
           )
         case Right(v) =>
           RedundantTracingProperties(
             v.editPosition,
             v.editRotation,
             v.zoomLevel,
             v.userBoundingBoxes ++ v.userBoundingBox.map(
-              com.scalableminds.webknossos.datastore.geometry.NamedBoundingBoxProto(0, None, None, None, _))
+              com.scalableminds.webknossos.datastore.geometry.NamedBoundingBoxProto(0, None, None, None, _)),
+            v.editPositionAdditionalCoordinates
           )
       }
 
@@ -384,7 +395,8 @@ class AnnotationService @Inject()(
         autoFallbackLayer = false,
         None,
         Some(ResolutionRestrictions.empty),
-        Some(AnnotationLayer.defaultNameForType(newAnnotationLayerType))
+        Some(AnnotationLayer.defaultNameForType(newAnnotationLayerType)),
+        None
       )
       _ <- addAnnotationLayer(annotation, organizationName, newAnnotationLayerParameters) ?~> "makeHybrid.createTracings.failed"
     } yield ()

app/models/annotation/nml/NmlParser.scala

@@ -4,7 +4,14 @@ import com.scalableminds.util.geometry.{BoundingBox, Vec3Double, Vec3Int}
 import com.scalableminds.util.tools.ExtendedTypes.{ExtendedDouble, ExtendedString}
 import com.scalableminds.webknossos.datastore.SkeletonTracing._
 import com.scalableminds.webknossos.datastore.VolumeTracing.{Segment, SegmentGroup, VolumeTracing}
-import com.scalableminds.webknossos.datastore.geometry.{ColorProto, NamedBoundingBoxProto, Vec3IntProto}
+import com.scalableminds.webknossos.datastore.geometry.{
+  AdditionalCoordinateDefinitionProto,
+  AdditionalCoordinateProto,
+  ColorProto,
+  NamedBoundingBoxProto,
+  Vec2IntProto,
+  Vec3IntProto
+}
 import com.scalableminds.webknossos.datastore.helpers.{NodeDefaults, ProtoGeometryImplicits, SkeletonTracingDefaults}
 import com.scalableminds.webknossos.datastore.models.datasource.ElementClass
 import com.scalableminds.webknossos.tracingstore.tracings.ColorGenerator
@@ -19,7 +26,7 @@ import play.api.i18n.{Messages, MessagesProvider}
 
 import java.io.InputStream
 import scala.collection.{immutable, mutable}
-import scala.xml.{NodeSeq, XML, Node => XMLNode}
+import scala.xml.{Attribute, NodeSeq, XML, Node => XMLNode}
 
 object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGenerator {
 
@@ -58,13 +65,15 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
         val organizationName =
           if (overwritingDataSetName.isDefined) None else parseOrganizationName(parameters \ "experiment")
         val activeNodeId = parseActiveNode(parameters \ "activeNode")
-        val editPosition =
-          parseEditPosition(parameters \ "editPosition").getOrElse(SkeletonTracingDefaults.editPosition)
+        val (editPosition, editPositionAdditionalCoordinates) =
+          parseEditPosition(parameters \ "editPosition").getOrElse((SkeletonTracingDefaults.editPosition, Seq()))
         val editRotation =
           parseEditRotation(parameters \ "editRotation").getOrElse(SkeletonTracingDefaults.editRotation)
         val zoomLevel = parseZoomLevel(parameters \ "zoomLevel").getOrElse(SkeletonTracingDefaults.zoomLevel)
         var userBoundingBoxes = parseBoundingBoxes(parameters \ "userBoundingBox")
         var taskBoundingBox: Option[BoundingBox] = None
+        val additionalCoordinates =
+          parseAdditionalCoordinateDefinitions(parameters \ "additionalCoordinates").getOrElse(Seq())
         parseTaskBoundingBox(parameters \ "taskBoundingBox", isTaskUpload, userBoundingBoxes).foreach {
           case Left(value)  => taskBoundingBox = Some(value)
           case Right(value) => userBoundingBoxes = userBoundingBoxes :+ value
@@ -92,7 +101,9 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
                 organizationName,
                 segments = v.segments,
                 segmentGroups = v.segmentGroups,
-                hasSegmentIndex = VolumeSegmentIndexService.canHaveSegmentIndex(v.fallbackLayerName)
+                hasSegmentIndex = VolumeSegmentIndexService.canHaveSegmentIndex(v.fallbackLayerName),
+                editPositionAdditionalCoordinates = editPositionAdditionalCoordinates,
+                additionalCoordinates = additionalCoordinates
               ),
               basePath.getOrElse("") + v.dataZipPath,
               v.name,
@@ -116,7 +127,9 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
                 None,
                 treeGroupsAfterSplit,
                 userBoundingBoxes,
-                organizationName
+                organizationName,
+                editPositionAdditionalCoordinates,
+                additionalCoordinates = additionalCoordinates
               )
             )
 
@@ -189,13 +202,15 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
         case (Some(x), Some(y), Some(z)) => Some(Vec3IntProto(x.toInt, y.toInt, z.toInt))
         case _                           => None
       }
+      val additionalCoordinates = parseAdditionalCoordinateValues(node)
       Segment(
         segmentId = getSingleAttribute(node, "id").toLong,
         anchorPosition = anchorPosition,
         name = getSingleAttributeOpt(node, "name"),
         creationTime = getSingleAttributeOpt(node, "created").flatMap(_.toLongOpt),
         color = parseColorOpt(node),
-        groupId = getSingleAttribute(node, "groupId").toIntOpt
+        groupId = getSingleAttribute(node, "groupId").toIntOpt,
+        additionalCoordinates = additionalCoordinates
       )
     })
 
@@ -248,6 +263,23 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
       depth <- getSingleAttribute(node, "depth").toIntOpt
     } yield BoundingBox(Vec3Int(topLeftX, topLeftY, topLeftZ), width, height, depth)
 
+  def parseAdditionalCoordinateDefinitions(nodes: NodeSeq) =
+    nodes.headOption.map(
+      _.child.flatMap(
+        additionalCoordinateNode => {
+          for {
+            name <- getSingleAttributeOpt(additionalCoordinateNode, "name")
+            indexStr <- getSingleAttributeOpt(additionalCoordinateNode, "index")
+            index <- indexStr.toIntOpt
+            minStr <- getSingleAttributeOpt(additionalCoordinateNode, "min")
+            min <- minStr.toIntOpt
+            maxStr <- getSingleAttributeOpt(additionalCoordinateNode, "max")
+            max <- maxStr.toIntOpt
+          } yield new AdditionalCoordinateDefinitionProto(name, index, Vec2IntProto(min, max))
+        }
+      )
+    )
+
   private def parseDataSetName(nodes: NodeSeq): String =
     nodes.headOption.map(node => getSingleAttribute(node, "name")).getOrElse("")
 
@@ -266,8 +298,15 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
   private def parseTime(nodes: NodeSeq): Long =
     nodes.headOption.flatMap(node => getSingleAttribute(node, "ms").toLongOpt).getOrElse(DEFAULT_TIME)
 
-  private def parseEditPosition(nodes: NodeSeq): Option[Vec3Int] =
-    nodes.headOption.flatMap(parseVec3Int)
+  private def parseEditPosition(nodes: NodeSeq): Option[(Vec3Int, Seq[AdditionalCoordinateProto])] =
+    nodes.headOption.flatMap(n => {
+      val xyz = parseVec3Int(n)
+      val additionalCoordinates = parseAdditionalCoordinateValues(n)
+      xyz match {
+        case Some(value) => Some(value, additionalCoordinates)
+        case None        => None
+      }
+    })
 
   private def parseEditRotation(nodes: NodeSeq): Option[Vec3Double] =
     nodes.headOption.flatMap(parseRotationForParams)
@@ -451,6 +490,7 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
     for {
       id <- nodeIdText.toIntOpt ?~ Messages("nml.node.id.invalid", "", nodeIdText)
       radius = getSingleAttribute(node, "radius").toFloatOpt.getOrElse(NodeDefaults.radius)
+      additionalCoordinates = parseAdditionalCoordinateValues(node)
       position <- parseVec3Int(node) ?~ Messages("nml.node.attribute.invalid", "position", id)
     } yield {
       val viewport = parseViewport(node)
@@ -459,8 +499,33 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
       val bitDepth = parseBitDepth(node)
       val interpolation = parseInterpolation(node)
       val rotation = parseRotationForNode(node).getOrElse(NodeDefaults.rotation)
-      Node(id, position, rotation, radius, viewport, resolution, bitDepth, interpolation, timestamp)
+      Node(id,
+           position,
+           rotation,
+           radius,
+           viewport,
+           resolution,
+           bitDepth,
+           interpolation,
+           timestamp,
+           additionalCoordinates)
     }
   }
 
+  private def parseAdditionalCoordinateValues(node: XMLNode): Seq[AdditionalCoordinateProto] = {
+    val regex = "additionalCoordinate-(\\w)".r("name")
+    node.attributes.flatMap {
+      case attribute: Attribute => {
+        if (attribute.key.startsWith("additionalCoordinate")) {
+          Some(
+            new AdditionalCoordinateProto(regex.findAllIn(attribute.key).group("name"),
+                                          attribute.value.toString().toInt))
+        } else {
+          None
+        }
+      }
+      case _ => None
+    }.toSeq
+  }
+
 }

app/models/annotation/nml/NmlWriter.scala

@@ -30,7 +30,9 @@ case class NmlParameters(
     zoomLevel: Double,
     activeNodeId: Option[Int],
     userBoundingBoxes: Seq[NamedBoundingBoxProto],
-    taskBoundingBox: Option[BoundingBoxProto]
+    taskBoundingBox: Option[BoundingBoxProto],
+    additionalCoordinates: Seq[AdditionalCoordinateDefinitionProto],
+    editPositionAdditionalCoordinates: Seq[AdditionalCoordinateProto]
 )
 
 class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
@@ -127,7 +129,9 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
             s.zoomLevel,
             s.activeNodeId,
             s.userBoundingBoxes ++ s.userBoundingBox.map(NamedBoundingBoxProto(0, None, None, None, _)),
-            s.boundingBox
+            s.boundingBox,
+            s.additionalCoordinates,
+            s.editPositionAdditionalCoordinates
           )
         case Right(v) =>
           NmlParameters(
@@ -142,7 +146,9 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
             v.zoomLevel,
             None,
             v.userBoundingBoxes ++ v.userBoundingBox.map(NamedBoundingBoxProto(0, None, None, None, _)),
-            if (annotation.exists(_._task.isDefined)) Some(v.boundingBox) else None
+            if (annotation.exists(_._task.isDefined)) Some(v.boundingBox) else None,
+            v.additionalCoordinates,
+            v.editPositionAdditionalCoordinates
           )
       }
     } yield nmlParameters
@@ -181,6 +187,7 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
         writer.writeAttribute("x", parameters.editPosition.x.toString)
         writer.writeAttribute("y", parameters.editPosition.y.toString)
         writer.writeAttribute("z", parameters.editPosition.z.toString)
+        parameters.editPositionAdditionalCoordinates.foreach(writeAdditionalCoordinateValue)
       }
       Xml.withinElementSync("editRotation") {
         writer.writeAttribute("xRot", parameters.editRotation.x.toString)
@@ -207,6 +214,18 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
       parameters.taskBoundingBox.foreach { b =>
         Xml.withinElementSync("taskBoundingBox")(writeBoundingBox(b))
       }
+      if (parameters.additionalCoordinates.nonEmpty) {
+        Xml.withinElementSync("additionalCoordinates") {
+          parameters.additionalCoordinates.foreach(a => {
+            Xml.withinElementSync("additionalCoordinate") {
+              writer.writeAttribute("name", a.name)
+              writer.writeAttribute("index", a.index.toString)
+              writer.writeAttribute("min", a.bounds.x.toString)
+              writer.writeAttribute("max", a.bounds.y.toString)
+            }
+          })
+        }
+      }
     }
 
   // Write volume things from FetchedAnnotationLayer. Caller must ensure that it is a volume annotation layer
@@ -249,6 +268,7 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
             writer.writeAttribute("anchorPositionX", a.x.toString)
             writer.writeAttribute("anchorPositionY", a.y.toString)
             writer.writeAttribute("anchorPositionZ", a.z.toString)
+            s.additionalCoordinates.foreach(writeAdditionalCoordinateValue)
           }
           s.color.foreach(_ => writeColor(s.color))
           s.groupId.foreach(groupId => writer.writeAttribute("groupId", groupId.toString))
@@ -293,6 +313,7 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
         writer.writeAttribute("bitDepth", n.bitDepth.toString)
         writer.writeAttribute("interpolation", n.interpolation.toString)
         writer.writeAttribute("time", n.createdTimestamp.toString)
+        n.additionalCoordinates.foreach(writeAdditionalCoordinateValue)
       }
     }
 
@@ -387,4 +408,8 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
     writer.writeAttribute("color.b", color.map(_.b.toString).getOrElse(""))
     writer.writeAttribute("color.a", color.map(_.a.toString).getOrElse(""))
   }
+
+  def writeAdditionalCoordinateValue(additionalCoordinate: AdditionalCoordinateProto)(
+      implicit writer: XMLStreamWriter): Unit =
+    writer.writeAttribute(s"additionalCoordinate-${additionalCoordinate.name}", additionalCoordinate.value.toString)
 }