WIP Root to Solid conversion

cern-root-loader/src/commonMain/kotlin/ru/mipt/npm/root/jsonToRoot.kt

@@ -25,10 +25,10 @@ private fun <T> jsonRootDeserializer(tSerializer: KSerializer<T>, builder: (Json
 /**
  * Load Json encoded TObject
  */
-public fun TObject.Companion.decodeFromJson(serializer: KSerializer<out TObject>, jsonElement: JsonElement): TObject =
+public fun <T: TObject> TObject.Companion.decodeFromJson(serializer: KSerializer<T>, jsonElement: JsonElement): T =
     RootDecoder.decode(serializer, jsonElement)
 
-public fun TObject.Companion.decodeFromString(serializer: KSerializer<out TObject>, string: String): TObject {
+public fun <T: TObject> TObject.Companion.decodeFromString(serializer: KSerializer<T>, string: String): T {
     val json = RootDecoder.json.parseToJsonElement(string)
     return RootDecoder.decode(serializer, json)
 }
@@ -49,12 +49,14 @@ private object RootDecoder {
                 //Forward ref for shapes
                 when (tSerializer.descriptor.serialName) {
                     "TGeoShape" -> return TGeoShapeRef {
-                        //Should be not null at the moment of actualization
+                        refCache[refId].getOrPutValue {
-                        refCache[refId].value as TGeoShape
+                            input.json.decodeFromJsonElement(tSerializer, it) as TGeoShape
+                        }
                     } as T
                     "TGeoVolumeAssembly" -> return TGeoVolumeAssemblyRef {
-                        //Should be not null at the moment of actualization
+                        refCache[refId].getOrPutValue {
-                        refCache[refId].value as TGeoVolumeAssembly
+                            input.json.decodeFromJsonElement(tSerializer, it) as TGeoVolumeAssembly
+                        }
                     } as T
                     //Do unref
                     else -> refCache[refId]
@@ -138,7 +140,7 @@ private object RootDecoder {
     }
 
 
-    fun decode(sourceDeserializer: KSerializer<out TObject>, source: JsonElement): TObject {
+    fun <T: TObject> decode(sourceDeserializer: KSerializer<T>, source: JsonElement): T {
         val refCache = ArrayList<RefEntry>()
 
         fun fillCache(element: JsonElement) {

cern-root-loader/src/commonMain/kotlin/ru/mipt/npm/root/rootToSolid.kt

@@ -2,7 +2,7 @@ package ru.mipt.npm.root
 
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.asName
-import space.kscience.visionforge.setPropertyNode
+import space.kscience.dataforge.names.plus
 import space.kscience.visionforge.solid.*
 import kotlin.math.PI
 import kotlin.math.atan2
@@ -19,22 +19,20 @@ private operator fun Number.times(f: Float) = toFloat() * f
 
 private fun degToRad(d: Double) = d * PI / 180.0
 
-private class GdmlLoader {
+// converting to XYZ to Tait–Bryan angles according to https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
-
+private fun Solid.rotate(rot: DoubleArray) {
-    // converting to XYZ to Tait–Bryan angles according to https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix
-    private fun Solid.rotate(rot: DoubleArray) {
     val xAngle = atan2(-rot[5], rot[8])
     val yAngle = atan2(rot[2], sqrt(1.0 - rot[2].pow(2)))
     val zAngle = atan2(-rot[1], rot[0])
     rotation = Point3D(xAngle, yAngle, zAngle)
-    }
+}
 
-    private fun Solid.translate(trans: DoubleArray) {
+private fun Solid.translate(trans: DoubleArray) {
     val (x, y, z) = trans
     position = Point3D(x, y, z)
-    }
+}
 
-    private fun Solid.useMatrix(matrix: TGeoMatrix?) {
+private fun Solid.useMatrix(matrix: TGeoMatrix?) {
     when (matrix) {
         null, is TGeoIdentity -> {
             //do nothing
@@ -56,9 +54,9 @@ private class GdmlLoader {
             scale = Point3D(xScale, yScale, zScale)
         }
     }
-    }
+}
 
-    fun SolidGroup.addShape(shape: TGeoShape) {
+private fun SolidGroup.addShape(shape: TGeoShape) {
     when (shape) {
         is TGeoShapeRef -> addShape(shape.value)
         is TGeoCompositeShape -> {
@@ -113,9 +111,9 @@ private class GdmlLoader {
         is TGeoShapeAssembly -> volume(shape.fVolume)
         is TGeoBBox -> box(shape.fDX * 2, shape.fDY * 2, shape.fDZ * 2, name = shape.fName)
     }
-    }
+}
 
-    fun SolidGroup.node(obj: TGeoNode) {
+private fun SolidGroup.node(obj: TGeoNode) {
     if (obj.fVolume != null) {
         volume(obj.fVolume).apply {
             when (obj) {
@@ -128,9 +126,9 @@ private class GdmlLoader {
             }
         }
     }
-    }
+}
 
-    fun buildGroup(volume: TGeoVolume): SolidGroup {
+private fun buildGroup(volume: TGeoVolume): SolidGroup {
     return if (volume is TGeoVolumeAssemblyRef) {
         buildGroup(volume.value)
     } else {
@@ -143,34 +141,40 @@ private class GdmlLoader {
             }
         }
     }
-    }
+}
-
+
-    private val SolidGroup.rootPrototypes: SolidGroup get() = (parent as? SolidGroup)?.rootPrototypes ?: this
+private val SolidGroup.rootPrototypes: SolidGroup get() = (parent as? SolidGroup)?.rootPrototypes ?: this
-
+
-    fun SolidGroup.volume(volume: TGeoVolume): SolidGroup {
+private fun SolidGroup.volume(volume: TGeoVolume, cache: Boolean = true): Solid {
-        val group = buildGroup(volume)
+    val group = buildGroup(volume)
-        val ref = rootPrototypes.prototypes {
+    return if (!cache) {
-
+        group
-        }
+    } else newRef(
-        set(volume.fName.ifEmpty { null }?.asName(), group)
+        name = volume.fName.ifEmpty { null },
-        return group
+        obj = group,
-    }
+        prototypeHolder = rootPrototypes,
-
+        templateName = volumesName + Name.parse(volume.fName.ifEmpty { group.toString() })
-    fun load(geo: TGeoManager): SolidGroup {
+    )
-        /**
+}
-         * A special group for local templates
+
-         */
+//    private fun load(geo: TGeoManager): SolidGroup {
-        val proto = SolidGroup()
+////        /**
-
+////         * A special group for local templates
-        val solids = proto.group(solidsName) {
+////         */
-            setPropertyNode("edges.enabled", false)
+////        val proto = SolidGroup()
-        }
+////
-
+////        val solids = proto.group(solidsName) {
-        val volumes = proto.group(volumesName)
+////            setPropertyNode("edges.enabled", false)
-
+////        }
-        val referenceStore = HashMap<Name, MutableList<SolidReferenceGroup>>()
+////
-
+////        val volumes = proto.group(volumesName)
-        TODO()
+////
-    }
+////        val referenceStore = HashMap<Name, MutableList<SolidReferenceGroup>>()
-
+//    }
+
+
+public fun TGeoManager.toSolid(): SolidGroup = SolidGroup {
+    fNodes.arr.forEach {
+        node(it)
+    }
 }

cern-root-loader/src/jvmTest/kotlin/ru/mipt/npm/root/loadBMN.kt

@@ -31,7 +31,9 @@ fun main() {
 
     val time = measureTimeMillis {
         val geo = TObject.decodeFromString(TGeoManager.serializer(), string)
-        println(geo)
+        val solid = geo.toSolid()
+
+        println(solid)
     }
 
     println(Duration.ofMillis(time))

visionforge-solid/src/commonMain/kotlin/space/kscience/visionforge/solid/SolidReference.kt

@@ -158,21 +158,28 @@ public fun SolidGroup.ref(
     name: String? = null,
 ): SolidReferenceGroup = SolidReferenceGroup(templateName).also { set(name, it) }
 
-/**
- * Add new [SolidReferenceGroup] wrapping given object and automatically adding it to the prototypes
- */
 public fun SolidGroup.ref(
-    name: String,
+    templateName: String,
+    name: String? = null,
+): SolidReferenceGroup = ref(Name.parse(templateName), name)
+
+/**
+ * Add new [SolidReferenceGroup] wrapping given object and automatically adding it to the prototypes.
+ * One must ensure that [prototypeHolder] is the owner of this group.
+ */
+public fun SolidGroup.newRef(
+    name: String?,
     obj: Solid,
-    templateName: Name = Name.parse(name),
+    prototypeHolder: PrototypeHolder = this,
+    templateName: Name = Name.parse(name ?: obj.toString()),
 ): SolidReferenceGroup {
     val existing = getPrototype(templateName)
     if (existing == null) {
-        prototypes {
+        prototypeHolder.prototypes {
-            this[templateName] = obj
+            set(templateName, obj)
         }
     } else if (existing != obj) {
         error("Can't add different prototype on top of existing one")
     }
-    return this@ref.ref(templateName, name)
+    return ref(templateName, name)
 }

visionforge-solid/src/commonTest/kotlin/space/kscience/visionforge/solid/SerializationTest.kt

@@ -16,7 +16,7 @@ fun SolidGroup.refGroup(
     block: MutableVisionGroup.() -> Unit
 ): SolidReferenceGroup {
     val group = SolidGroup().apply(block)
-    return ref(name, group, templateName)
+    return newRef(name, group, templateName = templateName)
 }
 
 
@@ -42,7 +42,7 @@ class SerializationTest {
             z = -100
         }
         val group = SolidGroup {
-            ref("cube", cube)
+            newRef("cube", cube)
             refGroup("pg", Name.parse("pg.content")) {
                 sphere(50) {
                     x = -100

visionforge-solid/src/commonTest/kotlin/space/kscience/visionforge/solid/SolidReferenceTest.kt

@@ -14,7 +14,7 @@ class SolidReferenceTest {
         val theStyle by style {
             SolidMaterial.MATERIAL_COLOR_KEY put "red"
         }
-        ref("test", Box(100f,100f,100f).apply {
+        newRef("test", Box(100f,100f,100f).apply {
             color("blue")
             useStyle(theStyle)
         })