Metadata for Segments & Trees

app/models/annotation/nml/NmlParser.scala

@@ -4,6 +4,7 @@ import com.scalableminds.util.geometry.{BoundingBox, Vec3Double, Vec3Int}
 import com.scalableminds.util.tools.ExtendedTypes.{ExtendedDouble, ExtendedString}
 import com.scalableminds.util.tools.JsonHelper.bool2Box
 import com.scalableminds.webknossos.datastore.SkeletonTracing._
+import com.scalableminds.webknossos.datastore.MetadataEntry.MetadataEntryProto
 import com.scalableminds.webknossos.datastore.VolumeTracing.{Segment, SegmentGroup, VolumeTracing}
 import com.scalableminds.webknossos.datastore.geometry.{
   AdditionalAxisProto,
@@ -210,17 +211,46 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
         case _                           => None
       }
       val anchorPositionAdditionalCoordinates = parseAdditionalCoordinateValues(node)
+      val metadata = parseMetadata(node \ "metadata" \ "metadataEntry")
       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,
-        anchorPositionAdditionalCoordinates = anchorPositionAdditionalCoordinates
+        anchorPositionAdditionalCoordinates = anchorPositionAdditionalCoordinates,
+        metadata = metadata
       )
     })
 
+  private def parseMetadata(metadataEntryNodes: NodeSeq): Seq[MetadataEntryProto] =
+    metadataEntryNodes.map(node => {
+      MetadataEntryProto(
+        getSingleAttribute(node, "key"),
+        getSingleAttributeOpt(node, "stringValue"),
+        getSingleAttributeOpt(node, "boolValue").flatMap(_.toBooleanOpt),
+        getSingleAttributeOpt(node, "numberValue").flatMap(_.toDoubleOpt),
+        parseStringListValue(node)
+      )
+    })
+
+  private def parseStringListValue(node: XMLNode): Seq[String] = {
+    val regex = "^stringListValue-(\\d+)".r
+    val valuesWithIndex: Seq[(Int, String)] = node.attributes.flatMap {
+      case attribute: Attribute =>
+        attribute.key match {
+          case regex(indexStr) =>
+            indexStr.toIntOpt.map { index =>
+              (index, attribute.value.toString)
+            }
+          case _ => None
+        }
+      case _ => None
+    }.toSeq
+    valuesWithIndex.sortBy(_._1).map(_._2)
+  }
+
   private def parseTrees(treeNodes: NodeSeq,
                          branchPoints: Map[Int, List[BranchPoint]],
                          comments: Map[Int, List[Comment]])(implicit m: MessagesProvider) =
@@ -414,6 +444,7 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
       nodeIds = nodes.map(_.id)
       treeBranchPoints = nodeIds.flatMap(nodeId => branchPoints.getOrElse(nodeId, List()))
       treeComments = nodeIds.flatMap(nodeId => comments.getOrElse(nodeId, List()))
+      metadata = parseMetadata(tree \ "metadata" \ "metadataEntry")
       createdTimestamp = if (nodes.isEmpty) System.currentTimeMillis()
       else nodes.minBy(_.createdTimestamp).createdTimestamp
     } yield
@@ -427,7 +458,8 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
            createdTimestamp,
            groupId,
            isVisible,
-           treeType)
+           treeType,
+           metadata = metadata)
   }
 
   private def parseComments(comments: NodeSeq)(implicit m: MessagesProvider): Box[List[Comment]] =
@@ -513,6 +545,7 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
       val bitDepth = parseBitDepth(node)
       val interpolation = parseInterpolation(node)
       val rotation = parseRotationForNode(node).getOrElse(NodeDefaults.rotation)
+      val metadata = parseMetadata(node \ "metadata" \ "metadataEntry")
       Node(id,
            position,
            rotation,
@@ -522,7 +555,8 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
            bitDepth,
            interpolation,
            timestamp,
-           additionalCoordinates)
+           additionalCoordinates,
+           metadata = metadata)
     }
   }
 

app/models/annotation/nml/NmlWriter.scala

@@ -5,6 +5,7 @@ import com.scalableminds.util.time.Instant
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
 import com.scalableminds.util.xml.Xml
 import com.scalableminds.webknossos.datastore.SkeletonTracing._
+import com.scalableminds.webknossos.datastore.MetadataEntry.MetadataEntryProto
 import com.scalableminds.webknossos.datastore.VolumeTracing.{Segment, SegmentGroup}
 import com.scalableminds.webknossos.datastore.geometry._
 import com.scalableminds.webknossos.datastore.models.VoxelSize
@@ -274,13 +275,13 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
           if (skipVolumeData) {
             writer.writeComment(f"Note that volume data was omitted when downloading this annotation.")
           }
-          writeVolumeSegmentMetadata(volumeTracing.segments)
+          writeVolumeSegmentInfos(volumeTracing.segments)
           Xml.withinElementSync("groups")(writeSegmentGroupsAsXml(volumeTracing.segmentGroups))
         case _ => ()
       }
     }
 
-  private def writeVolumeSegmentMetadata(segments: Seq[Segment])(implicit writer: XMLStreamWriter): Unit =
+  private def writeVolumeSegmentInfos(segments: Seq[Segment])(implicit writer: XMLStreamWriter): Unit =
     Xml.withinElementSync("segments") {
       segments.foreach { s =>
         Xml.withinElementSync("segment") {
@@ -299,10 +300,30 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
           }
           s.color.foreach(_ => writeColor(s.color))
           s.groupId.foreach(groupId => writer.writeAttribute("groupId", groupId.toString))
+          if (s.metadata.nonEmpty)
+            Xml.withinElementSync("metadata")(s.metadata.foreach(writeMetadataEntry))
         }
       }
     }
 
+  private def writeMetadataEntry(p: MetadataEntryProto)(implicit writer: XMLStreamWriter): Unit =
+    Xml.withinElementSync("metadataEntry") {
+      writer.writeAttribute("key", p.key)
+      p.stringValue.foreach { v =>
+        writer.writeAttribute("stringValue", v)
+      }
+      p.boolValue.foreach { v =>
+        writer.writeAttribute("boolValue", v.toString)
+      }
+      p.numberValue.foreach { v =>
+        writer.writeAttribute("numberValue", v.toString)
+      }
+      p.stringListValue.zipWithIndex.foreach {
+        case (v, index) =>
+          writer.writeAttribute(s"stringListValue-$index", v)
+      }
+    }
+
   private def writeSkeletonThings(skeletonTracing: SkeletonTracing)(implicit writer: XMLStreamWriter): Unit = {
     writeTreesAsXml(skeletonTracing.trees)
     Xml.withinElementSync("branchpoints")(
@@ -321,6 +342,8 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
         t.`type`.foreach(t => writer.writeAttribute("type", t.toString))
         Xml.withinElementSync("nodes")(writeNodesAsXml(t.nodes.sortBy(_.id)))
         Xml.withinElementSync("edges")(writeEdgesAsXml(t.edges))
+        if (t.metadata.nonEmpty)
+          Xml.withinElementSync("metadata")(t.metadata.foreach(writeMetadataEntry))
       }
     }
 
@@ -341,6 +364,8 @@ class NmlWriter @Inject()(implicit ec: ExecutionContext) extends FoxImplicits {
         writer.writeAttribute("interpolation", n.interpolation.toString)
         writer.writeAttribute("time", n.createdTimestamp.toString)
         n.additionalCoordinates.foreach(writeAdditionalCoordinateValue)
+        if (n.metadata.nonEmpty)
+          Xml.withinElementSync("metadata")(n.metadata.foreach(writeMetadataEntry))
       }
     }
 

frontend/javascripts/components/fast_tooltip.tsx

@@ -60,7 +60,9 @@ export default function FastTooltip({
   onMouseLeave,
   wrapper,
   html,
+  className,
   style,
+  variant,
   dynamicRenderer,
 }: {
   title?: string | null | undefined;
@@ -71,7 +73,9 @@ export default function FastTooltip({
   onMouseLeave?: () => void;
   wrapper?: "div" | "span" | "p" | "tr"; // Any valid HTML tag, span by default.
   html?: string | null | undefined;
+  className?: string; // class name attached to the wrapper
   style?: React.CSSProperties; // style attached to the wrapper
+  variant?: "dark" | "light" | "success" | "warning" | "error" | "info";
   dynamicRenderer?: () => React.ReactElement;
 }) {
   const Tag = wrapper || "span";
@@ -107,8 +111,10 @@ export default function FastTooltip({
       data-tooltip-place={placement || "top"}
       data-tooltip-html={html}
       data-unique-key={uniqueKeyForDynamic}
+      data-tooltip-variant={variant}
       onMouseEnter={onMouseEnter}
       onMouseLeave={onMouseLeave}
+      className={className}
       style={style}
     >
       {children}

frontend/javascripts/dashboard/explorative_annotations_view.tsx

@@ -805,7 +805,7 @@ class ExplorativeAnnotationsView extends React.PureComponent<Props, State> {
 
   render() {
     return (
-      <div className="TestExplorativeAnnotationsView">
+      <div>
         <TopBar
           isAdminView={this.props.isAdminView}
           handleOnSearch={this.handleOnSearch}
@@ -816,7 +816,7 @@ class ExplorativeAnnotationsView extends React.PureComponent<Props, State> {
           archiveAll={this.archiveAll}
         />
         {this.renderSearchTags()}
-        <Spin spinning={this.state.isLoading} size="large">
+        <Spin spinning={this.state.isLoading} size="large" style={{ marginTop: 4 }}>
           {this.renderTable()}
         </Spin>
         <div