public static void collecLines(OctreeNode node, out List <Point3D> vertList, out List <int> lineIndex) { vertList = new List <Point3D>(); lineIndex = new List <int>(); if (node._children.Count == 0) { vertList.AddRange(node.nodeCellCuboid.cuboidPolyhedron.Vertices); int[] lines = { 0, 1, 2, 3, 0, 4, 5, 6, 7, 4, 5, 1, 2, 6, 7, 3 }; lineIndex.AddRange(lines); } else { foreach (OctreeNode child in node._children) { List <Point3D> verts; List <int> idx; OctreeNodeProcess.collecLines(child, out verts, out idx); if (verts.Count > 0) { int offset = vertList.Count; vertList.AddRange(verts); for (int i = 0; i < idx.Count; i++) { idx[i] += offset; // offset the indexes based ont the current count of the list } lineIndex.AddRange(idx); } } } }
public static bool collectCellIDs(OctreeNode node, out List <CellID64> collCellIDs, out List <int> collBorderFlag) { collCellIDs = new List <CellID64>(); collBorderFlag = new List <int>(); if (node._children.Count == 0) { // No child in this node, return its cellID if (node._flag != PolyhedronIntersectEnum.Disjoint) { collCellIDs.Add(node.nodeCellID); collBorderFlag.Add(node._flag == PolyhedronIntersectEnum.Intersect ? 1 : 0); } } else { foreach (OctreeNode child in node._children) { List <CellID64> coll = null; List <int> collFlag = null; if (child._flag != PolyhedronIntersectEnum.Disjoint) { OctreeNodeProcess.collectCellIDs(child, out coll, out collFlag); if (coll.Count > 0) { collCellIDs.AddRange(coll); collBorderFlag.AddRange(collFlag); } } } } return(true); }
/// <summary> /// Compute Octree for a Polyhedron /// </summary> /// <param name="elementID"></param> /// <param name="polyH"></param> /// <param name="forUserDict"></param> public void ComputeOctree(string elementID, Polyhedron polyH, bool forUserDict) { // Make sure ElementID string is 22 character long for correct encoding/decoding if (elementID.Length < 22) { elementID = elementID.PadLeft(22, '0'); } ElementID eidNo = new ElementID(elementID); Tuple <UInt64, UInt64> elementIDNo = eidNo.ElementIDNo; OctreeNode theTree = new OctreeNode(); // Do it in steps: // 1. Find the smallest containing cell based on the PolyH BB, it it to quickly eliminate the irrelevant cells very quickly theTree.nodeCellID = OctreeNodeProcess.getSmallestContainingCell(polyH); theTree._depth = theTree.nodeCellID.Level; // 2. Perform subdivision using the BB first: quick division since there is no expensive intersection. It leaves all the leaves based on BB OctreeNodeProcess.ProcessBB(theTree, polyH.boundingBox); // 3. Evaluate each leaf nodes for further subdivision using the actual polyhedron (the original algorithm) OctreeNodeProcess.Process(theTree, polyH); List <CellID64> collCellID; List <int> collBorderFlag; OctreeNodeProcess.collectCellIDs(theTree, out collCellID, out collBorderFlag); for (int i = 0; i < collCellID.Count; ++i) { if (forUserDict) { insertDataToUserDict(elementIDNo, collCellID[i], collBorderFlag[i], false); } else { //insertDataToDictDB(elementID, collCellID[i]); insertDataToDict(elementIDNo, collCellID[i]); } } }
/// <summary> /// Compute Octree for a Line Segment /// </summary> /// <param name="elementID"></param> /// <param name="lineS"></param> /// <param name="forUserDict"></param> public void ComputeOctree(string elementID, LineSegment3D lineS, bool forUserDict) { // Make sure ElementID string is 22 character long for correct encoding/decoding if (elementID.Length < 22) { elementID = elementID.PadLeft(22, '0'); } ElementID eidNo = new ElementID(elementID); Tuple <UInt64, UInt64> elementIDNo = eidNo.ElementIDNo; OctreeNode theTree = new OctreeNode(); // Add a step: // 1. Find the smallest containing cell based on the Face BB, it it to quickly eliminate the irrelevant cells very quickly theTree.nodeCellID = OctreeNodeProcess.getSmallestContainingCell(lineS); theTree._depth = theTree.nodeCellID.Level; OctreeNodeProcess.Process(theTree, lineS); List <CellID64> collCellID; List <int> collBorderFlag; OctreeNodeProcess.collectCellIDs(theTree, out collCellID, out collBorderFlag); for (int i = 0; i < collCellID.Count; ++i) { if (forUserDict) { insertDataToUserDict(elementIDNo, collCellID[i], collBorderFlag[i], false); } else { //insertDataToDictDB(elementID, collCellID[i]); insertDataToDict(elementIDNo, collCellID[i]); } } }
/// <summary> /// Process Octree for a line segment /// </summary> /// <param name="_polyH"></param> /// <param name="polyHF"></param> public static void Process(OctreeNode node, LineSegment3D lineSegment) { if (node._depth < Octree.MaxDepth) { int disjointCount = 0; OctreeNodeProcess.Split(node); List <int> childToRemove = new List <int>(); List <int> childToTraverse = new List <int>(); for (int i = 0; i < node._children.Count; i++) { OctreeNode childNode = node._children[i]; if (Polyhedron.intersect(childNode.nodeCellCuboid.cuboidPolyhedron, lineSegment)) { childToTraverse.Add(i); childNode._flag = PolyhedronIntersectEnum.Intersect; childNode.nodeCellID.setBorderCell(); continue; } // If doesn't intersect (passes the check above), either it is fully contained, full contains or disjoint // To optimize the operation, we will use a single sampling point instead of checking the entire polyhedron since a single point can tell if a polyhedron is inside the other one // Fully contains check only valid if the parent is fully contains, if intersect, it should never be full contains if (node._flag == PolyhedronIntersectEnum.FullyContains) { if (Polyhedron.insideCuboid(childNode.nodeCellCuboid.cuboidPolyhedron, lineSegment.startPoint)) { // if polyH is entirely inside the cuboid, we will set this for further split (the same as intersection childToTraverse.Add(i); // We will remove the node if it is disjoint, otherwise it will continue splitting until the condition met childNode._flag = PolyhedronIntersectEnum.FullyContains; childNode.nodeCellID.setBorderCell(); continue; } } // If the Line does not intersect the cuboid, or the cuboid does not fully contain the Line, it must be disjoint childNode._flag = PolyhedronIntersectEnum.Disjoint; disjointCount++; continue; } if (disjointCount == 8) { // All children are disjoint. Remove all children and set the node to Disjoint node._children.Clear(); node._flag = PolyhedronIntersectEnum.Disjoint; return; } if (childToTraverse.Count == 1) { OctreeNodeProcess.Process(node._children[childToTraverse[0]], lineSegment); } else if (childToTraverse.Count > 1) { Parallel.ForEach(childToTraverse, i => OctreeNodeProcess.Process(node._children[i], lineSegment)); } // If there is any disjoint, we need to keep this node as it is. This should be done after we processed all the children to be traversed!! if (disjointCount > 0 && disjointCount < 8) { return; } int countGrandChildren = 0; // If there is no disjoint, we need to check whether all children are terminal (i.e. child._children.Count == 0) foreach (OctreeNode child in node._children) { countGrandChildren += child._children.Count; } // All children are terminal and no disjoint (by implication of previous steps). Remove children if (countGrandChildren == 0) { node._children.Clear(); node._flag = PolyhedronIntersectEnum.IntersectOrInside; return; } } else { // at _depth == Octree.MaxDepth there is nothing else to do since the test has been done at the parent level and when entering this stage, the test has determined // that the cell is intersected with the polyH } return; }
public static void Process(OctreeNode node, Polyhedron _polyH, List <Face3D> polyHF) { // 3rd step. Subdivide the cells collected by the step 2 and operate on them with the actual polyhedron to get the detail if (node._depth < Octree.MaxDepth) { int disjointCount = 0; int insideCount = 0; Split(node); List <int> childToRemove = new List <int>(); List <int> childToTraverse = new List <int>(); List <Face3D> faceList; faceList = Face3D.exclFacesOutsideOfBound(polyHF, node.nodeCellCuboid.cuboidPolyhedron.boundingBox, 0x111); if (faceList.Count == 0) { // No face inside this cuboid left, no intersection nor completely enclosing the polyH. node._flag = PolyhedronIntersectEnum.Disjoint; node._children.Clear(); return; } for (int i = 0; i < node._children.Count; i++) { OctreeNode childNode = node._children[i]; //PolyhedronIntersectEnum intS = childNode.Process(polyH); if (Polyhedron.intersect(childNode.nodeCellCuboid.cuboidPolyhedron, faceList)) { childToTraverse.Add(i); childNode._flag = PolyhedronIntersectEnum.Intersect; childNode.nodeCellID.setBorderCell(); #if (DBG_OCTREE) if (childNode._depth >= _dbgDepth) { BIMRLCommon refCommon = new BIMRLCommon(); string dbgFile = "c:\\temp\\octree\\" + childNode.nodeCellID.ToString() + " - intersect polyH.x3d"; BIMRLExportSDOToX3D x3d = new BIMRLExportSDOToX3D(refCommon, dbgFile); x3d.drawCellInX3d(childNode.nodeCellID.ToString()); // draw the cell x3d.exportFacesToX3D(faceList); x3d.endExportToX3D(); } #endif continue; } // If doesn't intersect (passes the check above), either it is fully contained, full contains or disjoint // To optimize the operation, we will use a single sampling point instead of checking the entire polyhedron since a single point can tell if a polyhedron is inside the other one //if (Polyhedron.inside(childNode.nodeCellCuboid.cuboidPolyhedron, polyH)) //// No need to check this since the previous step (no 1) would have removed the fullycontaining cells // Fully contains check only valid if the parent is fully contains, if intersect, it should never be full contains //if (node._flag == PolyhedronIntersectEnum.FullyContains) //{ // if (Polyhedron.insideCuboid(childNode.nodeCellCuboid.cuboidPolyhedron, faceList[0].vertices[0])) // { // // if polyH is entirely inside the cuboid, we will set this for further split (the same as intersection // childToTraverse.Add(i); // We will remove the node if it is disjoint, otherwise it will continue splitting until the condition met // childNode._flag = PolyhedronIntersectEnum.FullyContains; // childNode.nodeCellID.setBorderCell(); // continue; // } //} //if (Polyhedron.inside(polyH, childNode.nodeCellCuboid.cuboidPolyhedron)) if (Polyhedron.inside(_polyH, childNode.nodeCellCuboid.cuboidPolyhedron.Vertices[3])) { childNode._flag = PolyhedronIntersectEnum.Inside; insideCount++; #if (DBG_OCTREE) if (childNode._depth >= _dbgDepth) { BIMRLCommon refCommon = new BIMRLCommon(); string dbgFile = "c:\\temp\\octree\\" + childNode.nodeCellID.ToString() + " - inside polyH.x3d"; BIMRLExportSDOToX3D x3d = new BIMRLExportSDOToX3D(refCommon, dbgFile); x3d.drawCellInX3d(childNode.nodeCellID.ToString()); // draw the cell x3d.exportFacesToX3D(_polyH.Faces); x3d.endExportToX3D(); } #endif continue; } // If the 2 polyH do not intersect, the cuboid does not fully contain the polyH, nor the cuboid is fully inside the polyH, it must be disjoint childNode._flag = PolyhedronIntersectEnum.Disjoint; disjointCount++; #if (DBG_OCTREE) if (childNode._depth >= _dbgDepth) { BIMRLCommon refCommon = new BIMRLCommon(); string dbgFile = "c:\\temp\\octree\\" + childNode.nodeCellID.ToString() + " - disjoint polyH.x3d"; BIMRLExportSDOToX3D x3d = new BIMRLExportSDOToX3D(refCommon, dbgFile); x3d.drawCellInX3d(childNode.nodeCellID.ToString()); // draw the cell x3d.exportFacesToX3D(_polyH.Faces); x3d.endExportToX3D(); } #endif continue; // else: the cuboid is completely inside the polyH, keep } if (disjointCount == 8) { // All children are disjoint. Remove all children and set the node to Disjoint node._children.Clear(); node._flag = PolyhedronIntersectEnum.Disjoint; return; } if (insideCount == 8) { // All children are inside. Remove all children and set the node to Inside node._children.Clear(); node._flag = PolyhedronIntersectEnum.Inside; return; } if (childToTraverse.Count == 1) { OctreeNodeProcess.Process(node._children[childToTraverse[0]], _polyH, faceList); } else if (childToTraverse.Count > 1) { #if (DEBUG_NOPARALLEL) // Non - parallel option for easier debugging foreach (int i in childToTraverse) { OctreeNodeProcess.Process(node._children[i], _polyH, faceList); } #else ParallelOptions po = new ParallelOptions(); po.MaxDegreeOfParallelism = 8; Parallel.ForEach(childToTraverse, po, i => OctreeNodeProcess.Process(node._children[i], _polyH, faceList)); #endif } // If there is any disjoint, we need to keep this node as it is. This should be done after we processed all the children to be traversed!! if (disjointCount > 0 && disjointCount < 8) { return; } int countGrandChildren = 0; // If there is no disjoint, we need to check whether all children are terminal (i.e. child._children.Count == 0) foreach (OctreeNode child in node._children) { countGrandChildren += child._children.Count; } // All children are terminal and no disjoint (by implication of previous steps). Remove children if (countGrandChildren == 0) { node._children.Clear(); node._flag = PolyhedronIntersectEnum.IntersectOrInside; return; } } else { // at _depth == Octree.MaxDepth there is nothing else to do since the test has been done at the parent level and when entering this stage, the test has determined // that the cell is intersected with the polyH } return; }