GDML converter refactoring

visionforge-gdml/src/commonMain/kotlin/hep/dataforge/vision/gdml/GDMLTransformer.kt

@@ -7,6 +7,7 @@ import hep.dataforge.names.Name
 import hep.dataforge.names.asName
 import hep.dataforge.names.plus
 import hep.dataforge.names.toName
+import hep.dataforge.vision.MutableVisionGroup
 import hep.dataforge.vision.set
 import hep.dataforge.vision.solid.*
 import hep.dataforge.vision.solid.SolidMaterial.Companion.MATERIAL_COLOR_KEY
@@ -19,7 +20,7 @@ import kotlin.random.Random
 private val solidsName = "solids".asName()
 private val volumesName = "volumes".asName()
 
-class GDMLTransformer(val root: GDML) {
+class GDMLTransformer internal constructor(val root: GDML) {
     //private val materialCache = HashMap<GDMLMaterial, Meta>()
     private val random = Random(222)
 
@@ -38,25 +39,35 @@ class GDMLTransformer(val root: GDML) {
     /**
      * A special group for local templates
      */
-    internal val proto by lazy { SolidGroup() }
+    private val proto by lazy { SolidGroup() }
 
-    internal val solids by lazy {
+    private val solids by lazy {
         proto.group(solidsName) {
             config["edges.enabled"] = false
         }
     }
 
-    internal val volumes by lazy {
+    private val referenceStore = HashMap<Name, MutableList<Proxy>>()
-        proto.group(volumesName)
+
+    private fun proxySolid(group: SolidGroup, solid: GDMLSolid, name: String): Proxy {
+        val templateName = solidsName + name
+        if (proto[templateName] == null) {
+            solids.addSolid(solid, name)
+        }
+        val ref = group.ref(templateName, name)
+        referenceStore.getOrPut(templateName) { ArrayList() }.add(ref)
+        return ref
     }
 
-//    fun proxySolid(group: SolidGroup, solid: GDMLSolid, name: String): Proxy {
+    private fun proxyVolume(group: SolidGroup, physVolume: GDMLPhysVolume, volume: GDMLGroup): Proxy {
-//        val fullName = solidsName + name
+        val templateName = volumesName + volume.name.asName()
-//        if (proto[fullName] == null) {
+        if (proto[templateName] == null) {
-//            solids.addSolid(this, solid, name)
+            proto[templateName] = volume(volume)
-//        }
+        }
-//        return group.ref(fullName, name)
+        val ref = group.ref(templateName, physVolume.name ?: "").withPosition(physVolume)
-//    }
+        referenceStore.getOrPut(templateName) { ArrayList() }.add(ref)
+        return ref
+    }
 
     private val styleCache = HashMap<Name, Meta>()
 
@@ -70,14 +81,14 @@ class GDMLTransformer(val root: GDML) {
         }
     }
 
-    fun Solid.useStyle(name: String, builder: MetaBuilder.() -> Unit) {
+    private fun Solid.useStyle(name: String, builder: MetaBuilder.() -> Unit) {
         styleCache.getOrPut(name.toName()) {
             Meta(builder)
         }
         useStyle(name)
     }
 
-    internal fun configureSolid(obj: Solid, parent: GDMLVolume, solid: GDMLSolid) {
+    private fun configureSolid(obj: Solid, parent: GDMLVolume, solid: GDMLSolid) {
         val material = parent.materialref.resolve(root) ?: GDMLElement(parent.materialref.ref)
 
         val styleName = "material[${material.name}]"
@@ -92,33 +103,12 @@ class GDMLTransformer(val root: GDML) {
 
     var onFinish: GDMLTransformer.() -> Unit = {}
 
-    internal fun finalize(final: SolidGroup): SolidGroup {
-        //final.prototypes = proto
-        final.prototypes {
-            proto.children.forEach { (token, item) ->
-                item.parent = null
-                set(token.asName(), item)
-            }
-        }
-        styleCache.forEach {
-            final.styleSheet {
-                define(it.key.toString(), it.value)
-            }
-        }
-        final.rotationOrder = RotationOrder.ZXY
-        onFinish(this@GDMLTransformer)
-        return final
-    }
 
-}
+    private fun <T : Solid> T.withPosition(
-
-private fun Solid.withPosition(
-    lUnit: LUnit,
-    aUnit: AUnit = AUnit.RADIAN,
         newPos: GDMLPosition? = null,
         newRotation: GDMLRotation? = null,
         newScale: GDMLScale? = null
-): Solid = apply {
+    ): T = apply {
         newPos?.let {
             val point = Point3D(it.x(lUnit), it.y(lUnit), it.z(lUnit))
             if (position != null || point != World.ZERO) {
@@ -139,28 +129,26 @@ private fun Solid.withPosition(
             }
         }
         //TODO convert units if needed
-}
+    }
 
-private fun Solid.withPosition(context: GDMLTransformer, physVolume: GDMLPhysVolume) = withPosition(
+    private fun <T : Solid> T.withPosition(physVolume: GDMLPhysVolume): T = withPosition(
-    context.lUnit, context.aUnit,
+        physVolume.resolvePosition(root),
-    physVolume.resolvePosition(context.root),
+        physVolume.resolveRotation(root),
-    physVolume.resolveRotation(context.root),
+        physVolume.resolveScale(root)
-    physVolume.resolveScale(context.root)
+    )
-)
 
-@Suppress("NOTHING_TO_INLINE")
+    @Suppress("NOTHING_TO_INLINE")
-private inline operator fun Number.times(d: Double) = toDouble() * d
+    private inline operator fun Number.times(d: Double) = toDouble() * d
 
-@Suppress("NOTHING_TO_INLINE")
+    @Suppress("NOTHING_TO_INLINE")
-private inline operator fun Number.times(f: Float) = toFloat() * f
+    private inline operator fun Number.times(f: Float) = toFloat() * f
 
-private fun SolidGroup.addSolid(
+    private fun SolidGroup.addSolid(
-    context: GDMLTransformer,
         solid: GDMLSolid,
         name: String = ""
-): Solid {
+    ): Solid {
         //context.solidAdded(solid)
-    val lScale = solid.lscale(context.lUnit)
+        val lScale = solid.lscale(lUnit)
         val aScale = solid.ascale()
         return when (solid) {
             is GDMLBox -> box(solid.x * lScale, solid.y * lScale, solid.z * lScale, name)
@@ -195,10 +183,10 @@ private fun SolidGroup.addSolid(
             }
             is GDMLScaledSolid -> {
                 //Add solid with modified scale
-            val innerSolid: GDMLSolid = solid.solidref.resolve(context.root)
+                val innerSolid: GDMLSolid = solid.solidref.resolve(root)
                     ?: error("Solid with tag ${solid.solidref.ref} for scaled solid ${solid.name} not defined")
 
-            addSolid(context, innerSolid, name).apply {
+                addSolid(innerSolid, name).apply {
                     scaleX *= solid.scale.x.toFloat()
                     scaleY *= solid.scale.y.toFloat()
                     scaleZ = solid.scale.z.toFloat()
@@ -225,8 +213,8 @@ private fun SolidGroup.addSolid(
                 }
             }
             is GDMLBoolSolid -> {
-            val first: GDMLSolid = solid.first.resolve(context.root) ?: error("")
+                val first: GDMLSolid = solid.first.resolve(root) ?: error("")
-            val second: GDMLSolid = solid.second.resolve(context.root) ?: error("")
+                val second: GDMLSolid = solid.second.resolve(root) ?: error("")
                 val type: CompositeType = when (solid) {
                     is GDMLUnion -> CompositeType.UNION
                     is GDMLSubtraction -> CompositeType.SUBTRACT
@@ -234,17 +222,15 @@ private fun SolidGroup.addSolid(
                 }
 
                 return composite(type, name) {
-                addSolid(context, first).withPosition(
+                    addSolid(first).withPosition(
-                    context.lUnit, context.aUnit,
+                        solid.resolveFirstPosition(root),
-                    solid.resolveFirstPosition(context.root),
+                        solid.resolveFirstRotation(root),
-                    solid.resolveFirstRotation(context.root),
                         null
                     )
 
-                addSolid(context, second).withPosition(
+                    addSolid(second).withPosition(
-                    context.lUnit, context.aUnit,
+                        solid.resolvePosition(root),
-                    solid.resolvePosition(context.root),
+                        solid.resolveRotation(root),
-                    solid.resolveRotation(context.root),
                         null
                     )
 
@@ -252,105 +238,133 @@ private fun SolidGroup.addSolid(
             }
             else -> error("Renderer for $solid not supported yet")
         }
-}
+    }
 
-private fun SolidGroup.addSolidWithCaching(
+    private fun SolidGroup.addSolidWithCaching(
-    context: GDMLTransformer,
         solid: GDMLSolid,
         name: String = solid.name
-): Solid? {
+    ): Solid? {
-    return when (context.solidAction(solid)) {
+        return when (solidAction(solid)) {
-        GDMLTransformer.Action.ADD -> {
+            Action.ADD -> {
-            addSolid(context, solid, name)
+                addSolid(solid, name)
             }
-        GDMLTransformer.Action.PROTOTYPE -> {
+            Action.PROTOTYPE -> {
-//            context.proxySolid(this, solid, name)
+                proxySolid(this, solid, name)
-            val fullName = solidsName + solid.name.asName()
-            if (context.proto[fullName] == null) {
-                context.solids.addSolid(context, solid, solid.name)
             }
-            ref(fullName, name)
+            Action.REJECT -> {
-        }
-        GDMLTransformer.Action.REJECT -> {
                 //ignore
                 null
             }
         }
-}
+    }
 
-private fun SolidGroup.addPhysicalVolume(
+    private fun SolidGroup.addPhysicalVolume(
-    context: GDMLTransformer,
         physVolume: GDMLPhysVolume
-) {
+    ) {
-    val volume: GDMLGroup = physVolume.volumeref.resolve(context.root)
+        val volume: GDMLGroup = physVolume.volumeref.resolve(root)
             ?: error("Volume with ref ${physVolume.volumeref.ref} could not be resolved")
 
         // a special case for single solid volume
         if (volume is GDMLVolume && volume.physVolumes.isEmpty() && volume.placement == null) {
-        val solid = volume.solidref.resolve(context.root)
+            val solid = volume.solidref.resolve(root)
                 ?: error("Solid with tag ${volume.solidref.ref} for volume ${volume.name} not defined")
-        addSolidWithCaching(context, solid, physVolume.name ?: "")?.apply {
+            addSolidWithCaching(solid, physVolume.name ?: "")?.apply {
-            context.configureSolid(this, volume, solid)
+                configureSolid(this, volume, solid)
-            withPosition(context, physVolume)
+                withPosition(physVolume)
             }
             return
         }
 
-    when (context.volumeAction(volume)) {
+        when (volumeAction(volume)) {
-        GDMLTransformer.Action.ADD -> {
+            Action.ADD -> {
-            val group: SolidGroup = volume(context, volume)
+                val group: SolidGroup = volume(volume)
-            this[physVolume.name ?: ""] = group.withPosition(context, physVolume)
+                this[physVolume.name ?: ""] = group.withPosition(physVolume)
             }
-        GDMLTransformer.Action.PROTOTYPE -> {
+            Action.PROTOTYPE -> {
-            val fullName = volumesName + volume.name.asName()
+                proxyVolume(this, physVolume, volume)
-            if (context.proto[fullName] == null) {
-                context.proto[fullName] = volume(context, volume)
             }
-            ref(fullName, physVolume.name ?: "").withPosition(context, physVolume)
+            Action.REJECT -> {
-        }
-        GDMLTransformer.Action.REJECT -> {
                 //ignore
             }
         }
-}
+    }
 
-private fun SolidGroup.addDivisionVolume(
+    private fun SolidGroup.addDivisionVolume(
-    context: GDMLTransformer,
         divisionVolume: GDMLDivisionVolume
-) {
+    ) {
-    val volume: GDMLGroup = divisionVolume.volumeref.resolve(context.root)
+        val volume: GDMLGroup = divisionVolume.volumeref.resolve(root)
             ?: error("Volume with ref ${divisionVolume.volumeref.ref} could not be resolved")
 
         //TODO add divisions
-    set(Name.EMPTY, volume(context, volume))
+        set(Name.EMPTY, volume(volume))
-}
+    }
 
-private fun volume(
+    private fun volume(
-    context: GDMLTransformer,
         group: GDMLGroup
-): SolidGroup = SolidGroup().apply {
+    ): SolidGroup = SolidGroup().apply {
         if (group is GDMLVolume) {
-        val solid: GDMLSolid = group.solidref.resolve(context.root)
+            val solid: GDMLSolid = group.solidref.resolve(root)
                 ?: error("Solid with tag ${group.solidref.ref} for volume ${group.name} not defined")
 
-        addSolidWithCaching(context, solid)?.apply {
+            addSolidWithCaching(solid)?.apply {
-            context.configureSolid(this, group, solid)
+                configureSolid(this, group, solid)
             }
 
             when (val vol: GDMLPlacement? = group.placement) {
-            is GDMLPhysVolume -> addPhysicalVolume(context, vol)
+                is GDMLPhysVolume -> addPhysicalVolume(vol)
-            is GDMLDivisionVolume -> addDivisionVolume(context, vol)
+                is GDMLDivisionVolume -> addDivisionVolume(vol)
             }
         }
 
         group.physVolumes.forEach { physVolume ->
-        addPhysicalVolume(context, physVolume)
+            addPhysicalVolume(physVolume)
+        }
+    }
+
+    private fun finalize(final: SolidGroup): SolidGroup {
+        //final.prototypes = proto
+        final.useStyle("GDML") {
+            Solid.ROTATION_ORDER_KEY put RotationOrder.ZXY
+        }
+
+        //inline prototypes
+//        referenceStore.forEach { (protoName, list) ->
+//            val proxy = list.singleOrNull() ?: return@forEach
+//            val parent = proxy.parent as? MutableVisionGroup ?: return@forEach
+//            val token = parent.children.entries.find { it.value == proxy }?.key ?: error("Inconsistent reference cache")
+//            val prototype = proto[protoName] as? Solid ?:  error("Inconsistent reference cache")
+//            prototype.parent = null
+//            parent[token] = prototype
+//            prototype.updateFrom(proxy)
+//
+//            //FIXME update prototype
+//            proto[protoName] = null
+//        }
+
+        final.prototypes {
+            proto.children.forEach { (token, item) ->
+                item.parent = null
+                set(token.asName(), item)
+            }
+        }
+        styleCache.forEach {
+            final.styleSheet {
+                define(it.key.toString(), it.value)
+            }
+        }
+        onFinish(this@GDMLTransformer)
+        return final
+    }
+
+    val result by lazy {
+        finalize(volume(root.world))
     }
 }
 
+
 fun GDML.toVision(block: GDMLTransformer.() -> Unit = {}): SolidGroup {
     val context = GDMLTransformer(this).apply(block)
-    return context.finalize(volume(context, world))
+    return context.result
 }
 
 /**

visionforge-gdml/src/commonMain/kotlin/hep/dataforge/vision/gdml/GdmlOptimizer.kt

@@ -18,20 +18,16 @@ expect class Counter() {
     fun incrementAndGet(): Int
 }
 
-@DFExperimental
+private fun Point3D?.safePlus(other: Point3D?): Point3D? = if (this == null && other == null) {
-private class GdmlOptimizer() : VisionVisitor {
-    val logger = KotlinLogging.logger("SingleChildReducer")
-
-    private operator fun Point3D?.plus(other: Point3D?): Point3D? = if (this == null && other == null) {
     null
-    } else {
+} else {
     (this ?: Point3D(0, 0, 0)) + (other ?: Point3D(0, 0, 0))
-    }
+}
 
-    private fun Vision.updateFrom(other: Vision): Vision {
+internal fun Vision.updateFrom(other: Vision): Vision {
     if (this is Solid && other is Solid) {
-            position += other.position
+        position = position.safePlus(other.position)
-            rotation += other.rotation
+        rotation = rotation.safePlus(other.rotation)
         if (this.scale != null || other.scale != null) {
             scaleX = scaleX.toDouble() * other.scaleX.toDouble()
             scaleY = scaleY.toDouble() * other.scaleY.toDouble()
@@ -44,46 +40,50 @@ private class GdmlOptimizer() : VisionVisitor {
         }
     }
     return this
-    }
-
-    private val depthCount = HashMap<Int, Counter>()
-
-    override suspend fun visit(name: Name, vision: Vision) {
-        val depth = name.length
-        depthCount.getOrPut(depth) { Counter() }.incrementAndGet()
-    }
-
-    override fun skip(name: Name, vision: Vision): Boolean = vision is Proxy.ProxyChild
-
-    override suspend fun visitChildren(name: Name, group: VisionGroup) {
-        if (name == "volumes".toName()) return
-        if (group !is MutableVisionGroup) return
-
-        val newChildren = group.children.entries.associate { (visionToken, vision) ->
-            //Reduce single child groups
-            if (vision is VisionGroup && vision !is Proxy && vision.children.size == 1) {
-                val (token, child) = vision.children.entries.first()
-                child.parent = null
-                if (token != visionToken) {
-                    child.config["solidName"] = token.toString()
-                }
-                visionToken to child.updateFrom(vision)
-            } else {
-                visionToken to vision
-            }
-        }
-        if (newChildren != group.children) {
-            group.removeAll()
-            newChildren.forEach { (token, child) ->
-                group[token] = child
-            }
-        }
-    }
-}
-
-@DFExperimental
-suspend fun SolidGroup.optimizeGdml(): Job = coroutineScope {
-    prototypes?.let {
-        VisionVisitor.visitTree(GdmlOptimizer(), this, it)
-    } ?: CompletableDeferred(Unit)
 }
+//
+//@DFExperimental
+//private class GdmlOptimizer() : VisionVisitor {
+//    val logger = KotlinLogging.logger("SingleChildReducer")
+//
+//    private val depthCount = HashMap<Int, Counter>()
+//
+//    override suspend fun visit(name: Name, vision: Vision) {
+//        val depth = name.length
+//        depthCount.getOrPut(depth) { Counter() }.incrementAndGet()
+//    }
+//
+//    override fun skip(name: Name, vision: Vision): Boolean = vision is Proxy.ProxyChild
+//
+//    override suspend fun visitChildren(name: Name, group: VisionGroup) {
+//        if (name == "volumes".toName()) return
+//        if (group !is MutableVisionGroup) return
+//
+//        val newChildren = group.children.entries.associate { (visionToken, vision) ->
+//            //Reduce single child groups
+//            if (vision is VisionGroup && vision !is Proxy && vision.children.size == 1) {
+//                val (token, child) = vision.children.entries.first()
+//                child.parent = null
+//                if (token != visionToken) {
+//                    child.config["solidName"] = token.toString()
+//                }
+//                visionToken to child.updateFrom(vision)
+//            } else {
+//                visionToken to vision
+//            }
+//        }
+//        if (newChildren != group.children) {
+//            group.removeAll()
+//            newChildren.forEach { (token, child) ->
+//                group[token] = child
+//            }
+//        }
+//    }
+//}
+//
+//@DFExperimental
+//suspend fun SolidGroup.optimizeGdml(): Job = coroutineScope {
+//    prototypes?.let {
+//        VisionVisitor.visitTree(GdmlOptimizer(), this, it)
+//    } ?: CompletableDeferred(Unit)
+//}