Create mesh from an Object with Spatial Awareness Mesh Observer MHL2

I'm new here and also quite new at C#/Unity2019.4.14f with VS2019, MRTK V2.5.3, and Microsoft Hololens 2 programming. I would like to ask you for advice on a problem that I have not been able to solve for weeks. First of all, I would like to quickly explain what kind of problem it is. My task is to track an object that is in an examination cube with the Spatial Mesh and to represent its shape as well as possible.Explanation screen for the task description

The calculations of where the examination cube is located in space work without any problems. But for some reason, I cannot query the Spatial Awareness Mesh Observer. Anyway, no meshes seem to be present although they are visible.

Since I am at a complete loss and no one I have asked so far has been able to help me, I am publishing my code for this function below. Please bear with me, as I am still a beginner in writing code.

  public void ReadAndDrawMesh(){

        //Provide a list of the cube coordinates
        Vector3[] CubeCoordinateList = new Vector3[24];

        //Convert Local to World Coordinates
        var localToWorld = transform.localToWorldMatrix;

        Vector3 cubeWorldPos = Cube.transform.position; // Reading out the centre position
        Vector3[] cubeVertices = Cube.GetComponent<MeshFilter>().mesh.vertices; //World coordinates? 
        List<Vector3> cubeWorldVertices = new List<Vector3>();

        for (int i = 0; i <= (cubeVertices.Length) - 1; i++)
        {
            CubeCoordinateList[i] = localToWorld.MultiplyPoint3x4(cubeVertices[i]);
        }

        //CubeVerticies from Vector A[0] to E[4]
        float normalX1 = CubeCoordinateList[4].x - CubeCoordinateList[0].x;
        float normalY1 = CubeCoordinateList[4].y - CubeCoordinateList[0].y;
        float normalZ1 = CubeCoordinateList[4].z - CubeCoordinateList[0].z;

        float amount1 = Mathf.Sqrt((normalX1 * normalX1) + (normalY1 * normalY1) + (normalZ1 * normalZ1));

        //Create a new vector
        Vector3 direction1 = new Vector3(normalX1, normalY1, normalZ1);
        direction1 = direction1 / amount1;

        //CubeVerticies from Vector A[0] to B[2]
        float normalX2 = CubeCoordinateList[2].x - CubeCoordinateList[0].x;
        float normalY2 = CubeCoordinateList[2].y - CubeCoordinateList[0].y;
        float normalZ2 = CubeCoordinateList[2].z - CubeCoordinateList[0].z;

        float amount2 = Mathf.Sqrt((normalX2 * normalX2) + (normalY2 * normalY2) + (normalZ2 * normalZ2));


        //Create a new vector
        Vector3 direction2 = new Vector3(normalX2, normalY2, normalZ2);
        direction2 = direction2 / amount2;

        //CubeVerticies from Vector A[0] to D[3]
        float normalX3 = CubeCoordinateList[3].x - CubeCoordinateList[0].x;
        float normalY3 = CubeCoordinateList[3].y - CubeCoordinateList[0].y;
        float normalZ3 = CubeCoordinateList[3].z - CubeCoordinateList[0].z;

        float amount3 = Mathf.Sqrt((normalX3 * normalX3) + (normalY3 * normalY3) + (normalZ3 * normalZ3));

        //Create a new vector
        Vector3 direction3 = new Vector3(normalX3, normalY3, normalZ3);
        direction3 = direction3 / amount3;

        //From MRTK 2.5.3
        // Use CoreServices to quickly get access to the IMixedRealitySpatialAwarenessSystem
        var spatialAwarenessService = CoreServices.SpatialAwarenessSystem;

        // Cast to the IMixedRealityDataProviderAccess to get access to the data providers
        var dataProviderAccess = spatialAwarenessService as IMixedRealityDataProviderAccess;

        var meshObserverName = "SpatialAwarenessMeshObserverProfile";
        var MeshObserver = dataProviderAccess.GetDataProvider<IMixedRealitySpatialAwarenessMeshObserver>(meshObserverName);

        foreach (SpatialAwarenessMeshObject meshObject in MeshObserver.Meshes.Values)
        {

            Vector3[] meshObjectarray = meshObject.Filter.mesh.vertices;

            //Reading the Spatial Mesh of the room
            foreach (Vector3 verticiesCoordinaten in meshObjectarray)
            {

                //List for the mesh coordinates that come out of the scalar product calculation
                Vector3[] MeshPositionList = new Vector3[meshObjectarray.Length]; ;

                //Determining Direction between verticiesCoordinates of MeshObject with Centre of Cube
                var dir_vectorMesh = verticiesCoordinaten - cubeWorldPos;

                //Calculating the scalar product of the coordinates

                var result1 = Mathf.Abs(Vector3.Dot(dir_vectorMesh, direction1)) * 2;
                var result2 = Mathf.Abs(Vector3.Dot(dir_vectorMesh, direction2)) * 2;
                var result3 = Mathf.Abs(Vector3.Dot(dir_vectorMesh, direction3)) * 2;

                // If scalar product Negative, then write it in the list
                if (result1 > amount1 && result2 > amount2 && result3 > amount3)
                {
                    MeshPositionList[meshObjectarray.Length] = verticiesCoordinaten;
                }

                //Creating a new visible mesh from the points in the list 
                Mesh mesh = new Mesh();
                mesh.vertices = MeshPositionList;
                mesh.Optimize();
                Graphics.DrawMeshNow(mesh, Vector3.zero, Quaternion.identity);

                mesh.RecalculateNormals();
            }
        }
    }

I hope that one of you can help me and I look forward to any constructive answers. Thank you to everyone who reads this post and perhaps responds.

Thank You.