Example #1
0
    //semplifica l'octree
    public OctreeNode SimplifyOctree(OctreeNode node, float threshold)
    {
        if (node == null)
        {
            return(null);
        }

        if (node.type != NodeType.INTERNAL)
        {
            // can't simplify!
            return(node);
        }

        QefSolver qef = new QefSolver();

        int[] signs = new int[8] {
            -1, -1, -1, -1, -1, -1, -1, -1,
        };
        int  midsign       = -1;
        int  edgeCount     = 0;
        bool isCollapsible = true;

        for (int i = 0; i < 8; i++)
        {
            node.children[i] = SimplifyOctree(node.children[i], threshold);

            if (node.children[i] != null)
            {
                OctreeNode child = node.children[i];
                if (child.type == NodeType.INTERNAL)
                {
                    isCollapsible = false;
                }
                else
                {
                    qef.Add(child.nodeInfo.qef);
                    midsign  = (child.nodeInfo.corners >> (7 - i)) & 1;
                    signs[i] = (child.nodeInfo.corners >> i) & 1;
                    edgeCount++;
                }
            }
        }
        if (!isCollapsible)
        {
            // at least one child is an internal node, can't collapse
            return(node);
        }

        Vector3 qefPosition = new Vector3();
        float   error       = qef.Solve(qefPosition, QEF_ERROR, QEF_SWEEPS, QEF_ERROR);
        Vector3 position    = new Vector3(qefPosition.x, qefPosition.y, qefPosition.z);

        // at this point the masspoint will actually be a sum, so divide to make it the average
        if (error > threshold)
        {
            // this collapse breaches the threshold
            return(node);
        }

        if (position.x < node.min.x || position.x > (node.min.x + node.size) ||
            position.y < node.min.y || position.y > (node.min.y + node.size) ||
            position.z < node.min.z || position.z > (node.min.z + node.size))
        {
            position = qef.GetMassPoint();
        }

        // change the node from an internal node to a 'pseudo leaf' node
        NodeInfo info = new NodeInfo();

        for (int i = 0; i < 8; i++)
        {
            if (signs[i] == -1)
            {
                // Undetermined, use centre sign instead
                info.corners |= (midsign << i);
            }
            else
            {
                info.corners |= (signs[i] << i);
            }
        }
        info.avgNormal = new Vector3(0, 0, 0);
        for (int i = 0; i < 8; i++)
        {
            if (node.children[i] != null)
            {
                if (node.children[i].type == NodeType.PSEUDO ||
                    node.children[i].type == NodeType.LEAF)
                {
                    info.avgNormal += node.children[i].nodeInfo.avgNormal;
                }
            }
        }
        info.avgNormal = info.avgNormal.normalized;
        info.position  = position;
        info.qef       = qef.GetData();

        for (int i = 0; i < 8; i++)
        {
            DestroyOctree(node.children[i]);
            node.children[i] = null;
        }
        node.type = NodeType.PSEUDO;
        node.nodeInfo.Set(info);
        return(node);
    }
Example #2
0
        public static OctreeNode SimplifyOctree(OctreeNode node, double threshold)
        {
            if (node == null)
            {
                return(null);
            }

            if (node.Type != OctreeNodeType.Node_Internal)
            {
                // can't simplify!
                return(node);
            }

            var qef = new QefSolver();

            int[] signs = new int[8] {
                -1, -1, -1, -1, -1, -1, -1, -1
            };
            int  midsign       = -1;
            int  edgeCount     = 0;
            bool isCollapsible = true;

            for (int i = 0; i < 8; i++)
            {
                node.Children[i] = SimplifyOctree(node.Children[i], threshold);

                if (node.Children[i] != null)
                {
                    OctreeNode child = node.Children[i];

                    if (child.Type == OctreeNodeType.Node_Internal)
                    {
                        isCollapsible = false;
                    }
                    else
                    {
                        qef.Add(child.drawInfo.qefData);

                        midsign  = (child.drawInfo.corners >> (7 - i)) & 1;
                        signs[i] = (child.drawInfo.corners >> i) & 1;

                        edgeCount++;
                    }
                }
            }

            if (!isCollapsible)
            {
                // at least one child is an internal node, can't collapse
                return(node);
            }

            Vector3 position = qef.Solve(QEF_ERROR, QEF_SWEEPS, QEF_ERROR);
            double  error    = qef.GetError();

            // at this point the masspoint will actually be a sum, so divide to make it the average
            if (error > threshold)
            {
                // this collapse breaches the threshold
                return(node);
            }

            if (position.X < node.Min.X || position.X > (node.Min.X + node.Size.X) ||
                position.Y < node.Min.Y || position.Y > (node.Min.Y + node.Size.Y) ||
                position.Z < node.Min.Z || position.Z > (node.Min.Z + node.Size.Z))
            {
                position = qef.GetMassPoint();
            }

            // change the node from an internal node to a 'psuedo leaf' node
            var drawInfo = new OctreeDrawInfo();

            drawInfo.corners = 0;
            drawInfo.index   = -1;

            for (int i = 0; i < 8; i++)
            {
                if (signs[i] == -1)
                {
                    // Undetermined, use center sign instead
                    drawInfo.corners |= (midsign << i);
                }
                else
                {
                    drawInfo.corners |= (signs[i] << i);
                }
            }

            drawInfo.averageNormal = Vector3.Zero;
            for (int i = 0; i < 8; i++)
            {
                if (node.Children[i] != null)
                {
                    OctreeNode child = node.Children[i];
                    if (child.Type == OctreeNodeType.Node_Psuedo ||
                        child.Type == OctreeNodeType.Node_Leaf)
                    {
                        drawInfo.averageNormal += child.drawInfo.averageNormal;
                    }
                }
            }

            drawInfo.averageNormal = drawInfo.averageNormal.GetNormal();
            drawInfo.position      = position;
            drawInfo.qefData       = qef.QefData;

            for (int i = 0; i < 8; i++)
            {
                DestroyOctree(node.Children[i]);
                node.Children[i] = null;
            }

            node.Type     = OctreeNodeType.Node_Psuedo;
            node.drawInfo = drawInfo;

            return(node);
        }
Example #3
0
    //costruisce il nodo terminale (foglia) calcolando le NodeInfo per la generazione della mesh
    public OctreeNode BuildLeaf(OctreeNode leaf, int size)
    {
        if (leaf == null || leaf.size != size)
        {
            return(null);
        }

        int corners = 0;

        for (int i = 0; i < 8; i++)
        {
            Vector3 cornerPos = leaf.min + (CHILD_MIN_OFFSETS[i] * size);
            float   density   = Density.DensityFunc(cornerPos);
            int     material  = density < 0.0f ? SOLID : AIR;
            corners |= (material << i);
        }

        if (corners == 0 || corners == 255)
        {
            leaf = null;
            return(null);
        }

        int       edgeCount     = 0;
        Vector3   averageNormal = new Vector3();
        QefSolver qef           = new QefSolver();

        for (int i = 0; i < 12 && edgeCount < MAX_CROSSINGS; i++)
        {
            int c1 = edgevmap[i][0];
            int c2 = edgevmap[i][1];

            int m1 = (corners >> c1) & 1;
            int m2 = (corners >> c2) & 1;

            if ((m1 == AIR && m2 == AIR) || (m1 == SOLID && m2 == SOLID))
            {
                continue;
            }

            Vector3 p1 = leaf.min + (CHILD_MIN_OFFSETS[c1] * size);
            Vector3 p2 = leaf.min + (CHILD_MIN_OFFSETS[c2] * size);
            Vector3 p  = ApproximateZeroCrossingPosition(p1, p2, 8);
            Vector3 n  = CalculateSurfaceNormal(p);
            qef.Add(p.x, p.y, p.z, n.x, n.y, n.z);

            averageNormal += n;
            edgeCount++;
        }

        Vector3 qefPosition = new Vector3();

        qef.Solve(qefPosition, QEF_ERROR, QEF_SWEEPS, QEF_ERROR);

        NodeInfo info = new NodeInfo();

        info.index    = -1;
        info.corners  = 0;
        info.position = qefPosition;
        info.qef      = qef.GetData();

        Vector3 min = leaf.min;
        Vector3 max = new Vector3(leaf.min.x + leaf.size, leaf.min.y + leaf.size, leaf.min.z + leaf.size);

        if (info.position.x < min.x || info.position.x > max.x ||
            info.position.y < min.y || info.position.y > max.y ||
            info.position.z < min.z || info.position.z > max.z)
        {
            info.position = qef.GetMassPoint();
        }

        info.avgNormal = (averageNormal / (float)edgeCount).normalized;
        info.corners   = corners;

        leaf.type     = NodeType.LEAF;
        leaf.nodeInfo = info;
        return(leaf);
    }
Example #4
0
        public static OctreeNode ConstructLeaf(Func <Vector3, double> f, OctreeNode leaf)
        {
            if (leaf == null || leaf.Level != 1)
            {
                return(null);
            }

            int corners = 0;

            for (int i = 0; i < 8; i++)
            {
                Vector3 cornerPos = leaf.Min + CHILD_MIN_OFFSETS[i] * leaf.Size;
                double  density   = f(cornerPos);
                int     material  = density < 0.0f ? MATERIAL_SOLID : MATERIAL_AIR;
                corners |= (material << i);
            }

            if (corners == 0 || corners == 255)
            {
                // voxel is full inside or outside the volume
                //delete leaf
                return(null);
            }

            // otherwise the voxel contains the surface, so find the edge intersections
            const int MAX_CROSSINGS = 6;
            int       edgeCount     = 0;
            Vector3   averageNormal = Vector3.Zero;
            var       qefSolver     = new QefSolver();
            var       debugError    = .1;
            bool      is5Ish        = false;

            for (int i = 0; i < 12 && edgeCount < MAX_CROSSINGS; i++)
            {
                int c1 = edgevmap[i][0];
                int c2 = edgevmap[i][1];

                int m1 = (corners >> c1) & 1;
                int m2 = (corners >> c2) & 1;

                if ((m1 == MATERIAL_AIR && m2 == MATERIAL_AIR) || (m1 == MATERIAL_SOLID && m2 == MATERIAL_SOLID))
                {
                    // no zero crossing on this edge
                    continue;
                }

                Vector3 p1       = leaf.Min + CHILD_MIN_OFFSETS[c1] * leaf.Size;
                Vector3 p2       = leaf.Min + CHILD_MIN_OFFSETS[c2] * leaf.Size;
                Vector3 position = ApproximateZeroCrossingPosition(f, p1, p2);

                is5Ish  = Math.Abs(Math.Abs(position[0]) - 5) < debugError;
                is5Ish |= Math.Abs(Math.Abs(position[1]) - 5) < debugError;
                is5Ish |= Math.Abs(Math.Abs(position[2]) - 5) < debugError;

                if (!is5Ish)
                {
                    int a = 0;
                }
                Vector3 normal = CalculateSurfaceNormal(f, position);
                qefSolver.Add(position, normal);

                averageNormal += normal;

                edgeCount++;
            }

            Vector3 qefPosition = qefSolver.Solve(QEF_ERROR, QEF_SWEEPS, QEF_ERROR);

            is5Ish  = Math.Abs(Math.Abs(qefPosition[0]) - 5) < debugError;
            is5Ish |= Math.Abs(Math.Abs(qefPosition[1]) - 5) < debugError;
            is5Ish |= Math.Abs(Math.Abs(qefPosition[2]) - 5) < debugError;

            if (!is5Ish)
            {
                int a = 0;
            }

            var drawInfo = new OctreeDrawInfo();

            drawInfo.corners  = 0;
            drawInfo.index    = -1;
            drawInfo.position = new Vector3(qefPosition.X, qefPosition.Y, qefPosition.Z);
            drawInfo.qefData  = qefSolver.QefData;

            Vector3 min = leaf.Min;
            var     max = min + leaf.Size;

            if (drawInfo.position.X < min.X || drawInfo.position.X > max.X ||
                drawInfo.position.Y < min.Y || drawInfo.position.Y > max.Y ||
                drawInfo.position.Z < min.Z || drawInfo.position.Z > max.Z)
            {
                drawInfo.position = qefSolver.GetMassPoint();
            }

            drawInfo.averageNormal = Vector3.Normalize(averageNormal);
            drawInfo.corners       = corners;

            leaf.Type     = OctreeNodeType.Node_Leaf;
            leaf.drawInfo = drawInfo;

            return(leaf);
        }