Esempio n. 1
0
    // Tests Intersector class
    // Currently tests:
    // Vector (T1)
    // InverseTransformVector (T2 - not implemented)
    // ViewVector alt. constructor (T3)
    // Intersection (small scale) (T4 - not implemented)
    // Intersection (large scale) (T5 - not implemented)
    static string TestIntersector(Intersector IntersectorObj)
    {
        string output = "\n<size=144>Testing Intersector...</size>\n\n";

        // Test 1: Vector from two points
        output += "<b>Test 1</b>\n";
        Vector3 p1 = new Vector3(0, 0, 0);
        Vector3 p2 = new Vector3(2, 2, 2);

        output += String.Format("Vector from two points: {0} to {1}\n", pointToStr(p1), pointToStr(p2));
        Vector3 result = new Vector3();

        IntersectorObj.Vector(p1, p2, ref result);
        output += String.Format("Resultant vector: {0}\n\n", pointToStr(result));

        // Cannot test Unity Library outside of Unity...
        // Test 2: InverseTransformVector
        output += "<b>Test 2</b>\n";
        GameObject view2 = new GameObject();

        view2.name = "ViewFieldTest2";
        view2.transform.Rotate(new Vector3(90, 90, 0));
        output += String.Format("InverseTransformVector... view-field position: {0}, view-field euler angles: {1}\n",
                                pointToStr(view2.transform.position), pointToStr(view2.transform.eulerAngles));
        Vector3[] unitVectors = unitVectorsArray();
        for (int i = 0; i < 8; i++)
        {
            output += String.Format("Vector{0}: World Space: {1}, View-Field Local Space: {2}\n",
                                    i + 1, pointToStr(unitVectors[i]), pointToStr(view2.transform.InverseTransformVector(unitVectors[i])));
        }
        output += "\n";
        // */

        // Test 3: View Vector alt. constructor
        output += "<b>Test 3</b>\n";
        output += String.Format("ViewVector creation from position vector (in local space)... 2D cross-sectional plane is XY plane.\n");
        Vector3 forward = new Vector3(0, 0, 1);

        for (int i = 0; i < 8; i++)
        {
            output += String.Format("Vector{0} {1}: ViewVector{0} (deg): {2}\n",
                                    i + 1, pointToStr(unitVectors[i]), viewVectorToStr(new ViewVector(unitVectors[i])));
        }
        output += String.Format("Vector {0}: ViewVector (deg): {1}\n",
                                pointToStr(forward), viewVectorToStr(new ViewVector(forward)));
        output += "\n";

        // Cannot test Unity Library outside of Unity...
        // Test 4: Intersection (small scale)
        output += "<b>Test 4</b>\n";
        List <Vector3> unitVectorList = new List <Vector3>();

        for (int i = 0; i < 8; i++)
        {
            unitVectorList.Add(unitVectors[i]);
        }
        GameObject view4 = new GameObject();

        view4.name = "ViewFieldTest4";
        ViewVector FOV4        = new ViewVector(170, 170);
        Frustum    projection4 = new Frustum(view4.transform, FOV4);

        byte[,] raster4 = new byte[100, 100];
        output         += String.Format("Intersection... Raster: ({0}x{1}), Frustum FOV: ({2}x{3}), " +
                                        "Frustum Pos: {4}, Frustum EA's: {5}\n" +
                                        "Tested all 8 unit vectors, found intersection points...\n",
                                        raster4.GetLength(0), raster4.GetLength(1), FOV4.Theta, FOV4.Phi,
                                        pointToStr(projection4.Transform.position), pointToStr(projection4.Transform.eulerAngles));
        List <PointValue <byte> > intersect = Intersector.Instance.Intersection(projection4, raster4, unitVectorList);

        foreach (PointValue <byte> pv in intersect)
        {
            output += String.Format("Point: {0}, ViewVector: {1}\n",
                                    pointToStr(pv.Point), viewVectorToStr(new ViewVector(pv.Point)));
        }
        output += "\n";


        // Cannot test Unity Library outside of Unity...
        // Test 5: Intersection (large scale)
        output += "<b>Test 5</b>\n";
        System.Random rand  = new System.Random();
        GameObject    view5 = new GameObject();

        view5.name = "ViewFieldTest5";
        ViewVector FOV5        = new ViewVector(179, 179);
        Frustum    projection5 = new Frustum(view5.transform, FOV5);

        byte[,] raster5 = new byte[100, 100];
        int            iterations  = 100;
        Stopwatch      stopWatch   = new Stopwatch();
        Vector3        boundsMin   = new Vector3(-5, -5, -5);
        Vector3        boundsMax   = new Vector3(5, 5, 5);
        List <Vector3> randVectors = new List <Vector3>();

        for (int i = 0; i < iterations; i++)
        {
            randVectors.Add(randomPoint(boundsMin, boundsMax, rand));
        }
        output += String.Format("Intersection... Raster: ({0}x{1}), Frustum FOV: ({2}x{3}). {4} Iterations...\n",
                                raster5.GetLength(0), raster5.GetLength(1), FOV5.Theta, FOV5.Phi, randVectors.Count);
        Intersector tmp = Intersector.Instance;

        stopWatch.Reset();
        stopWatch.Start();
        List <PointValue <byte> > result5 = tmp.Intersection(projection5, raster5, randVectors);

        stopWatch.Stop();
        long ms = (long)1000 * stopWatch.ElapsedTicks / Stopwatch.Frequency;

        output += String.Format("Took {0} ms ({1} us / op)... {2} vectors in view\n", ms,
                                ms / (double)iterations * 1000.0, result5.Count);
        output += "\n";

        // Test 6: RequiredGrid
        output += "<b>Test 6</b>\n";
        ViewVector FOV6 = new ViewVector(60, 60);

        output += String.Format("Testing RequiredGrid... FOV: {0}\n", viewVectorToStr(FOV6));
        Dictionary <string, int> pixels = Intersector.Instance.RequiredGrid(FOV6);

        output += String.Format("i: {0}, j: {1}\n", pixels["i"], pixels["j"]);
        output += "\n";

        /// Test 7: Occlusion (basic)
        output += "<b>Test 7</b>\n";
        GameObject view7 = new GameObject();

        view7.name = "ViewFieldTest7";
        ViewVector FOV7        = new ViewVector(170, 170);
        Frustum    projection7 = new Frustum(view7.transform, FOV7);

        byte[,] raster7 = new byte[100, 100];
        for (int i = 0; i < raster7.GetLength(0); i++)
        {
            for (int j = 0; j < raster7.GetLength(1); j++)
            {
                raster7[i, j] = (byte)(i + j);
            }
        }
        output += String.Format("Created Frustum: pos: {0}, EA's {1}, FOV: {2}\n",
                                pointToStr(projection7.Transform.position), pointToStr(projection7.Transform.eulerAngles),
                                viewVectorToStr(projection7.FOV));
        output += String.Format("Created Raster: {0}x{1}\n", raster7.GetLength(0), raster7.GetLength(1));
        Vector3        v1        = new Vector3(1, 1, 1);
        Vector3        v2        = new Vector3(2, 2, 2);
        Vector3        v3        = new Vector3(0, 0, 1);
        List <Vector3> vertices7 = new List <Vector3>();

        vertices7.Add(v2);
        vertices7.Add(v1);
        vertices7.Add(v2);
        vertices7.Add(v3);
        output += String.Format("Trying vertices: v1: {0}, v2: {1}, v3: {2}. Intersection return...\n",
                                pointToStr(v1), pointToStr(v2), pointToStr(v3));
        List <PointValue <byte> > intersectRet = Intersector.Instance.Intersection(projection7, raster7, vertices7);

        for (int i = 0; i < intersectRet.Count; i++)
        {
            output += String.Format("Point: {0}, Value: {1}\n",
                                    pointToStr(intersectRet[i].Point), intersectRet[i].Value);
        }
        output += "\n";

        // Test 8: Occlusion (large scale)
        output += "<b>Test 8</b>\n";
        GameObject view8 = new GameObject();

        view8.name = "ViewFieldTest8";
        ViewVector FOV8        = new ViewVector(170, 170);
        Frustum    projection8 = new Frustum(view8.transform, FOV8);

        byte[,] raster8 = new byte[100, 100];
        output         += String.Format("Created Frustum: pos: {0}, EA's {1}, FOV: {2}\n",
                                        pointToStr(projection8.Transform.position), pointToStr(projection8.Transform.eulerAngles),
                                        viewVectorToStr(projection8.FOV));
        output += String.Format("Created Raster: {0}x{1}\n", raster8.GetLength(0), raster8.GetLength(1));
        // create 'wall' vertices
        double         wallSize     = 4.0;
        double         wallRes      = 0.05;
        double         wallDistance = 3.0;
        float          wallWiggle   = 0.001f;
        int            wallPixels   = (int)(wallSize / wallRes);
        double         wallBotLeft  = -(wallSize / 2.0);
        int            wallValue    = 0;
        int            wallCount    = (int)Math.Pow(wallPixels, 2);
        List <Vector3> vertices     = new List <Vector3>();

        for (int i = 0; i < wallPixels; i++)
        {
            for (int j = 0; j < wallPixels; j++)
            {
                float   vertX = (float)(i * wallRes + wallBotLeft);
                float   vertY = (float)(j * wallRes + wallBotLeft);
                float   vertZ = (float)wallDistance;
                Vector3 vert  = new Vector3(vertX, vertY, vertZ);
                vertices.Add(wiggleVert(vert, wallWiggle, rand));
            }
        }
        // create 'box' vertices
        float   boxSize  = 1f;
        Vector3 boxMin   = new Vector3(-boxSize / 2, -boxSize / 2, (float)(wallDistance + 1));
        Vector3 boxMax   = new Vector3(boxSize / 2, boxSize / 2, (float)(wallDistance + 1 + boxSize));
        int     boxCount = 10000;

        for (int i = 0; i < boxCount; i++)
        {
            vertices.Add(randomPoint(boxMin, boxMax, rand));
        }
        // report progress
        output += String.Format("Created wall... ({0},{0}) to ({1},{1}), z: {2}, wiggle: {3}, " +
                                "vertices: {4}, resolution (m): {5}\n",
                                wallBotLeft, wallBotLeft + wallSize, wallDistance, wallWiggle, wallCount, wallRes);
        output += String.Format("Created box: {0} to {1}, vertices: {2}\n",
                                pointToStr(boxMin), pointToStr(boxMax), boxCount);
        // run intersection
        List <PointValue <byte> > intersectRet8 = Intersector.Instance.Intersection(projection8, raster8, vertices);
        int wallCountRet = 0;
        int boxCountRet  = 0;

        for (int i = 0; i < intersectRet8.Count; i++)
        {
            Vector3 point = intersectRet8[i].Point;
            if (within(point, boxMin, boxMax))
            {
                boxCountRet++;
            }
            else
            {
                wallCountRet++;
            }
        }
        output += String.Format("Intersection Return... wall vertices: {0}/{1}, box vertices: {2}/{3}",
                                wallCountRet, wallCount, boxCountRet, boxCount);

        return(output);
    }