kscience/visionforge
8
1
Fork 1
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

WIP Root to Solid conversion

Browse Source
This commit is contained in:
Alexander Nozik 2021-08-25 23:00:05 +03:00
parent df30f8ecc3
commit 193665b99a
6 changed files with 166 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -25,10 +25,10 @@ private fun <T> jsonRootDeserializer(tSerializer: KSerializer<T>, builder: (Json
/** /**
* Load Json encoded TObject * 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) 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) val json = RootDecoder.json.parseToJsonElement(string)
return RootDecoder.decode(serializer, json) return RootDecoder.decode(serializer, json)
} }
@ -49,12 +49,14 @@ private object RootDecoder {
//Forward ref for shapes //Forward ref for shapes
when (tSerializer.descriptor.serialName) { when (tSerializer.descriptor.serialName) {
"TGeoShape" -> return TGeoShapeRef { "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 } as T
"TGeoVolumeAssembly" -> return TGeoVolumeAssemblyRef { "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 } as T
//Do unref //Do unref
else -> refCache[refId] 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>() val refCache = ArrayList<RefEntry>()
fun fillCache(element: JsonElement) { fun fillCache(element: JsonElement) {

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

@ -2,7 +2,7 @@ package ru.mipt.npm.root
import space.kscience.dataforge.names.Name import space.kscience.dataforge.names.Name
import space.kscience.dataforge.names.asName import space.kscience.dataforge.names.asName
import space.kscience.visionforge.setPropertyNode import space.kscience.dataforge.names.plus
import space.kscience.visionforge.solid.* import space.kscience.visionforge.solid.*
import kotlin.math.PI import kotlin.math.PI
import kotlin.math.atan2 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 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)
}
} }

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

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

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

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

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

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

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

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