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,158 +19,162 @@ 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
+    val xAngle = atan2(-rot[5], rot[8])
-    private fun Solid.rotate(rot: DoubleArray) {
+    val yAngle = atan2(rot[2], sqrt(1.0 - rot[2].pow(2)))
-        val xAngle = atan2(-rot[5], rot[8])
+    val zAngle = atan2(-rot[1], rot[0])
-        val yAngle = atan2(rot[2], sqrt(1.0 - rot[2].pow(2)))
+    rotation = Point3D(xAngle, yAngle, zAngle)
-        val zAngle = atan2(-rot[1], rot[0])
+}
-        rotation = Point3D(xAngle, yAngle, zAngle)
+
-    }
+private fun Solid.translate(trans: DoubleArray) {
-
+    val (x, y, z) = trans
-    private fun Solid.translate(trans: DoubleArray) {
+    position = Point3D(x, y, z)
-        val (x, y, z) = trans
+}
-        position = Point3D(x, y, z)
+
-    }
+private fun Solid.useMatrix(matrix: TGeoMatrix?) {
-
+    when (matrix) {
-    private fun Solid.useMatrix(matrix: TGeoMatrix?) {
+        null, is TGeoIdentity -> {
-        when (matrix) {
+            //do nothing
-            null, is TGeoIdentity -> {
+        }
-                //do nothing
+        is TGeoTranslation -> {
-            }
+            translate(matrix.fTranslation)
-            is TGeoTranslation -> {
+        }
-                translate(matrix.fTranslation)
+        is TGeoRotation -> {
-            }
+            rotate(matrix.fRotationMatrix)
-            is TGeoRotation -> {
+        }
-                rotate(matrix.fRotationMatrix)
+        is TGeoCombiTrans -> {
-            }
+            translate(matrix.fTranslation)
-            is TGeoCombiTrans -> {
+            matrix.fRotation?.let { rotate(it.fRotationMatrix) }
-                translate(matrix.fTranslation)
+        }
-                matrix.fRotation?.let { rotate(it.fRotationMatrix) }
+        is TGeoHMatrix -> {
-            }
+            translate(matrix.fTranslation)
-            is TGeoHMatrix -> {
+            rotate(matrix.fRotationMatrix)
-                translate(matrix.fTranslation)
+            val (xScale, yScale, zScale) = matrix.fScale
-                rotate(matrix.fRotationMatrix)
+            scale = Point3D(xScale, yScale, zScale)
-                val (xScale, yScale, zScale) = matrix.fScale
+        }
-                scale = Point3D(xScale, yScale, zScale)
+    }
-            }
+}
-        }
+
-    }
+private fun SolidGroup.addShape(shape: TGeoShape) {
-
+    when (shape) {
-    fun SolidGroup.addShape(shape: TGeoShape) {
+        is TGeoShapeRef -> addShape(shape.value)
-        when (shape) {
+        is TGeoCompositeShape -> {
-            is TGeoShapeRef -> addShape(shape.value)
+            val bool: TGeoBoolNode = shape.fNode
-            is TGeoCompositeShape -> {
+            val compositeType = when (bool) {
-                val bool: TGeoBoolNode = shape.fNode
+                is TGeoIntersection -> CompositeType.INTERSECT
-                val compositeType = when (bool) {
+                is TGeoSubtraction -> CompositeType.SUBTRACT
-                    is TGeoIntersection -> CompositeType.INTERSECT
+                is TGeoUnion -> CompositeType.UNION
-                    is TGeoSubtraction -> CompositeType.SUBTRACT
+            }
-                    is TGeoUnion -> CompositeType.UNION
+            composite(compositeType, name = shape.fName) {
-                }
+                addShape(bool.fLeft).apply {
-                composite(compositeType, name = shape.fName) {
+                    useMatrix(bool.fLeftMat)
-                    addShape(bool.fLeft).apply {
+                }
-                        useMatrix(bool.fLeftMat)
+                addShape(bool.fRight).apply {
-                    }
+                    useMatrix(bool.fRightMat)
-                    addShape(bool.fRight).apply {
+                }
-                        useMatrix(bool.fRightMat)
+            }
-                    }
+        }
-                }
+        is TGeoXtru -> extruded(name = shape.fName) {
-            }
+
-            is TGeoXtru -> extruded(name = shape.fName) {
+            (0 until shape.fNvert).forEach { index ->
-
+                shape {
-                (0 until shape.fNvert).forEach { index ->
+                    point(shape.fX[index], shape.fY[index])
-                    shape {
+                }
-                        point(shape.fX[index], shape.fY[index])
+            }
-                    }
+
-                }
+            (0 until shape.fNz).forEach { index ->
-
+                layer(
-                (0 until shape.fNz).forEach { index ->
+                    shape.fZ[index],
-                    layer(
+                    shape.fX0[index],
-                        shape.fZ[index],
+                    shape.fY0[index],
-                        shape.fX0[index],
+                    shape.fScale[index]
-                        shape.fY0[index],
+                )
-                        shape.fScale[index]
+            }
-                    )
+        }
-                }
+        is TGeoTube -> tube(
-            }
+            radius = shape.fRmax,
-            is TGeoTube -> tube(
+            height = shape.fDz * 2,
-                radius = shape.fRmax,
+            innerRadius = shape.fRmin,
-                height = shape.fDz * 2,
+            name = shape.fName
-                innerRadius = shape.fRmin,
+        )
-                name = shape.fName
+        is TGeoTubeSeg -> tube(
-            )
+            radius = shape.fRmax,
-            is TGeoTubeSeg -> tube(
+            height = shape.fDz * 2,
-                radius = shape.fRmax,
+            innerRadius = shape.fRmin,
-                height = shape.fDz * 2,
+            startAngle = degToRad(shape.fPhi1),
-                innerRadius = shape.fRmin,
+            angle = degToRad(shape.fPhi2 - shape.fPhi1),
-                startAngle = degToRad(shape.fPhi1),
+            name = shape.fName
-                angle = degToRad(shape.fPhi2 - shape.fPhi1),
+        )
-                name = shape.fName
+        is TGeoPcon -> TODO()
-            )
+        is TGeoPgon -> TODO()
-            is TGeoPcon -> TODO()
+        is TGeoShapeAssembly -> volume(shape.fVolume)
-            is TGeoPgon -> TODO()
+        is TGeoBBox -> box(shape.fDX * 2, shape.fDY * 2, shape.fDZ * 2, name = shape.fName)
-            is TGeoShapeAssembly -> volume(shape.fVolume)
+    }
-            is TGeoBBox -> box(shape.fDX * 2, shape.fDY * 2, shape.fDZ * 2, name = shape.fName)
+}
-        }
+
-    }
+private fun SolidGroup.node(obj: TGeoNode) {
-
+    if (obj.fVolume != null) {
-    fun SolidGroup.node(obj: TGeoNode) {
+        volume(obj.fVolume).apply {
-        if (obj.fVolume != null) {
+            when (obj) {
-            volume(obj.fVolume).apply {
+                is TGeoNodeMatrix -> {
-                when (obj) {
+                    useMatrix(obj.fMatrix)
-                    is TGeoNodeMatrix -> {
+                }
-                        useMatrix(obj.fMatrix)
+                is TGeoNodeOffset -> {
-                    }
+                    x = obj.fOffset
-                    is TGeoNodeOffset -> {
+                }
-                        x = obj.fOffset
+            }
-                    }
+        }
-                }
+    }
-            }
+}
-        }
+
-    }
+private fun buildGroup(volume: TGeoVolume): SolidGroup {
-
+    return if (volume is TGeoVolumeAssemblyRef) {
-    fun buildGroup(volume: TGeoVolume): SolidGroup {
+        buildGroup(volume.value)
-        return if (volume is TGeoVolumeAssemblyRef) {
+    } else {
-            buildGroup(volume.value)
+        SolidGroup {
-        } else {
+            volume.fShape?.let { addShape(it) }
-            SolidGroup {
+            volume.fNodes?.let {
-                volume.fShape?.let { addShape(it) }
+                it.arr.forEach { obj ->
-                volume.fNodes?.let {
+                    node(obj)
-                    it.arr.forEach { obj ->
+                }
-                        node(obj)
+            }
-                    }
+        }
-                }
+    }
-            }
+}
-        }
+
-    }
+private val SolidGroup.rootPrototypes: SolidGroup get() = (parent as? SolidGroup)?.rootPrototypes ?: this
-
+
-    private val SolidGroup.rootPrototypes: SolidGroup get() = (parent as? SolidGroup)?.rootPrototypes ?: this
+private fun SolidGroup.volume(volume: TGeoVolume, cache: Boolean = true): Solid {
-
+    val group = buildGroup(volume)
-    fun SolidGroup.volume(volume: TGeoVolume): SolidGroup {
+    return if (!cache) {
-        val group = buildGroup(volume)
+        group
-        val ref = rootPrototypes.prototypes {
+    } else newRef(
-
+        name = volume.fName.ifEmpty { null },
-        }
+        obj = group,
-        set(volume.fName.ifEmpty { null }?.asName(), group)
+        prototypeHolder = rootPrototypes,
-        return group
+        templateName = volumesName + Name.parse(volume.fName.ifEmpty { group.toString() })
-    }
+    )
-
+}
-    fun load(geo: TGeoManager): SolidGroup {
+
-        /**
+//    private fun load(geo: TGeoManager): SolidGroup {
-         * A special group for local templates
+////        /**
-         */
+////         * A special group for local templates
-        val proto = SolidGroup()
+////         */
-
+////        val proto = SolidGroup()
-        val solids = proto.group(solidsName) {
+////
-            setPropertyNode("edges.enabled", false)
+////        val solids = proto.group(solidsName) {
-        }
+////            setPropertyNode("edges.enabled", false)
-
+////        }
-        val volumes = proto.group(volumesName)
+////
-
+////        val volumes = proto.group(volumesName)
-        val referenceStore = HashMap<Name, MutableList<SolidReferenceGroup>>()
+////
-
+////        val referenceStore = HashMap<Name, MutableList<SolidReferenceGroup>>()
-        TODO()
+//    }
-    }
+
-
+
+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)
         })