Line between nodes move or change their rotatation/position after some time

[Fpaciello1]

Hello everyone, I created this simple script to place nodes when the user tap on the ar plane.
When the user created 2 nodes, I want to draw a line between them. I tried to do this and it works(sometimes).
The problem is quite simple, I'll attach some photos.
When I move the phone, or the ar view resets(ex. I put my hand on the phone), the nodes go back to their position but the lines many times change their orientation or even the position!
Thank you in advance for any type of help! 👍
This is how I place the nodes :

private fun placeNodes(hitResult: HitResult) {
        val job = GlobalScope.launch {
            val result = async {
                if (isToolActive) {
                    val anchor = hitResult.createAnchor()
                    val job = GlobalScope.launch {
                        val result = async {

                        }
                        // Load a new model instance for each tap
                        val modelInstance = GLBLoader.loadModelInstance(
                            context = context, glbFileLocation = nodeModel
                        ) as ModelInstance

                        val sphereModel = ArModelNode(arScene.engine)

                        sphereModel.scale = nodeScale
                        for (material in modelInstance.materialInstances) {
                            material.setBaseColor(nodeColor)
                        }
                        sphereModel.modelInstance = modelInstance
                        sphereModel.anchor = anchor
                        sphereModel.isPositionEditable = false
                        sphereModel.isRotationEditable = false
                        sphereModel.isScaleEditable = false
                        // Add the anchor node to the AR scene
                        arScene.addChild(sphereModel)

                        // Add the placed model to the list
                        placedModels.add(sphereModel)

                        // Draw a line between the new sphere and the previous one
                        if (placedModels.size >= 2) {
                            val startNode = placedModels[placedModels.size - 2]
                            val endNode = placedModels.last()

                            addLineBetweenPoints(
                                hitResult,
                                arScene,
                                startNode.position.toVector3(),
                                endNode.position.toVector3()
                            )
                        }
                    }
                }
            }

            result.await()
        }

        runBlocking {
            job.join()
        }
    }

This is how I place the lines :

private fun addLineBetweenPoints(hitResult: HitResult,scene: SceneView, from: Vector3, to: Vector3) {
        // prepare an anchor position
        val camQ = scene.cameraNode.worldQuaternion
        val f1 = floatArrayOf(to.x, to.y, to.z)
        val f2 = floatArrayOf(camQ.x, camQ.y, camQ.z, camQ.w)
        val anchorPose = Pose(f1, f2)

        // make an ARCore Anchor
        val anchor = hitResult.createAnchor()
        // Node that is automatically positioned in world space based on the ARCore Anchor.
        val anchorNode = ArNode(scene.engine)
        anchorNode.anchor = anchor
        anchorNode.parent = scene

        // Compute a line's length
        val lineLength = Vector3.subtract(from, to).length()

        val job = GlobalScope.launch {
            val result = async {
                // Load a new model instance for each tap
                val modelInstance = GLBLoader.loadModelInstance(
                    context = context,
                    glbFileLocation = lineModel
                ) as ModelInstance
                for (material in modelInstance.materialInstances) {
                    material.setBaseColor(lineColor)
                }
                // 3. make node
                val node = ArNode(scene.engine)
                node.parent = anchorNode
                node.modelInstance = modelInstance


                // 4. set rotation
                val difference = Vector3.subtract(to, from)
                val directionFromTopToBottom = difference.normalized()
                val rotationFromAToB =
                    Quaternion.lookRotation(
                        directionFromTopToBottom,
                        Vector3.up()
                    )

                val quaternionRot = Quaternion.multiply(
                    rotationFromAToB,
                    Quaternion.axisAngle(Vector3(1.0f, 0.0f, 0.0f), 90f)
                )
                node.worldPosition = Vector3.add(from, to).scaled(.5f).toFloat3()
                node.worldPosition.y = from.y
                node.worldQuaternion = dev.romainguy.kotlin.math.Quaternion(
                    quaternionRot.x,
                    quaternionRot.y,
                    quaternionRot.z,
                    quaternionRot.w
                )
                node.worldScale = Scale(lineScale, lineLength, lineScale)
                node.isPositionEditable = false
                node.isRotationEditable = false
                node.isScaleEditable = false

                placedLines.add(anchorNode)
                calculateMeasure()
            }

            result.await()
        }
        runBlocking {
            job.join()
        }
    }

These are the screenshots :

• After I place the nodes :

• After I move the phone around :

• After I place my hand on the camera to stop ar tracking :

[RGregat]

Two solutions come into my mind:

1. Don't create a separate Anchor for your Lines. Add every Line to the start Anchor (red circle) of a Line or as a Child Node of the Point (red circle).
2. Don't anchor at all and just position absolute. Check every X Frame the distance between the Points (red circles) and the Line to determine when the Lines have to be repositioned.

[Hanif-MI]

Hello @Fpaciello1 and @RGregat ,
I also want the same. have you found any solution?

[Hanif-MI]

Here is the code for drawing lines from node to node.

fun Position.toVector3(): Vector3 = Vector3(x, y, z)
fun Vector3.toPosition(): Position = Float3(x, y, z)


fun createLineNode(
    engine: Engine,
    anchor1: AnchorNode,
    anchor2: AnchorNode,
    materialLoader: MaterialLoader,
): Node {
    val point1 = anchor1.worldPosition
    val point2 = anchor2.worldPosition

    val point1Vector3 = point1.toVector3()
    val point2Vector3 = point2.toVector3()

    val difference = Vector3.subtract(point1Vector3, point2Vector3);
    val directionFromTopToBottom = difference.normalized();

    // Calculate the direction and length of the line
    val direction = Vector3(point2.x - point1.x, point2.y - point1.y, point2.z - point1.z)
    val length = direction.length()

    val rotationFromAToB = io.github.sceneview.collision.Quaternion.lookRotation(
        directionFromTopToBottom,
        Vector3.up()
    )

    val cube = CubeNode(
        engine,
        size = Size(0.01f, 0.01f, difference.length()), // Thin cube (small X/Z, stretched Y)
        center = Vector3.zero().toFloat3(),
        materialInstance = materialLoader.createColorInstance(Color.Yellow)
    ).apply {
        position = Vector3.add(point1Vector3, point2Vector3).scaled(.5f).toPosition()
        quaternion = Quaternion(
            rotationFromAToB.x,
            rotationFromAToB.y,
            rotationFromAToB.z,
            rotationFromAToB.w
        )
    }

    val cylinder = CylinderNode(
        engine,
        radius = 0.0025f,
        height = length,
        center = Vector3.zero().toFloat3(),
        materialInstance = materialLoader.createColorInstance(Color.Yellow)
    ).apply {
        worldPosition = Vector3.add(point1Vector3, point2Vector3).scaled(.5f).toPosition()
//        worldRotation = Rotation(quaternionCal.x,quaternionCal.y,quaternionCal.z)
//        worldQuaternion = quaternionCal // Adjusted rotation
    }

//    cube.parent = anchor1


    return cube
}

private fun calculateDistance(x: Float, y: Float, z: Float): Float {
    return sqrt(x.pow(2) + y.pow(2) + z.pow(2))
}

private fun changeUnit(distanceMeter: Float, unit: String): Float {
    return when (unit) {
        "cm" -> distanceMeter * 100
        "mm" -> distanceMeter * 1000
        else -> distanceMeter
    }
}