private static void UpdateGraphArcs(List <arc> reviewedArc) { foreach (Connection arc in reviewedArc) { //$ Incorperated the ability to add arcs, because otherwise resolving incomplete graphs // would be impossible bool reversed = false; var counterpart = (Connection)AssemblyGraph.arcs.FirstOrDefault(c => c.XmlFrom == arc.XmlFrom && c.XmlTo == arc.XmlTo); if (counterpart == null) { counterpart = (Connection)AssemblyGraph.arcs.FirstOrDefault(c => c.XmlTo == arc.XmlFrom && c.XmlFrom == arc.XmlTo); if (counterpart != null) { reversed = true; } } if (counterpart == null) { AssemblyGraph.addArc(AssemblyGraph.nodes.First(a => a.name == arc.XmlFrom), AssemblyGraph.nodes.First(a => a.name == arc.XmlTo), "", typeof(Connection)); counterpart = (Connection)AssemblyGraph.arcs.Last(); } else { if (arc.Certainty == 0) { AssemblyGraph.removeArc(counterpart); } } counterpart.FiniteDirections = AddDirections(arc.FiniteDirections); counterpart.InfiniteDirections = AddDirections(arc.InfiniteDirections); } }
// This class is added as an alternative for current Nonadjacent blocking determination approach. // The overal approach is the same as before (ray shooting), but number of both rays and blocking // triangles are droped to speedup the function. // Rays: Instead of checking blockings for every direction, for every two parts, their possible // blocking directions are found based upon the planes that can seperate the two CVHs linearlly. // (If the CVHs are not linearly seperable we cannot apply this.) // Triangles: Number of triangles (of the blocking solid) is the most affecting factor in blocking // determination. Code gets really really slow when it goes to check intersection of the ray // and all the triangles of the solid. We are avoiding this problem here by partitionaning // our search space into k number of sections obtained originally from OBB of the solid. internal static void Run(designGraph graph, Dictionary <string, List <TessellatedSolid> > subAssems, List <int> gDir) { Console.WriteLine("\n\nNonadjacent Blocking Determination is running ...."); long totalCases = 0; var subAssemsToList = subAssems.ToList(); for (var i = 0; i < subAssems.Count - 1; i++) { var subAssem1 = subAssemsToList[i]; for (var j = i + 1; j < subAssems.Count; j++) { var subAssem2 = subAssemsToList[j]; var tri2Sub1 = subAssem1.Value.Sum(s => s.Faces.Length); var tri2Sub2 = subAssem2.Value.Sum(s => s.Faces.Length); totalCases += tri2Sub1 * tri2Sub2; } } ObbFacesHashSet = new Dictionary <TessellatedSolid, HashSet <PolygonalFace> >(); CombinedCVHForMultipleGeometries = new Dictionary <string, TVGLConvexHull>(); long counter = 0; foreach (var subAssem in subAssems) { List <BoundingBox> pairList = new List <BoundingBox>(); foreach (var s in subAssem.Value) { //CvhHashSet.Add(s, new HashSet<PolygonalFace>(s.ConvexHull.Faces)); //$ What was used previously /* * ObbFacesHashSet.Add(s, * new HashSet<PolygonalFace>( * PartitioningSolid.TwelveFaceGenerator( * BoundingGeometry.OrientedBoundingBoxDic.First(b=> b.Key.Name == s.Name).Value.CornerVertices.Select( * cv => new Vertex(cv.Position)).ToArray()))); */ KeyValuePair <TessellatedSolid, BoundingBox> pair = BoundingGeometry.OrientedBoundingBoxDic.FirstOrDefault(b => b.Key.Name == s.Name); if (!pair.Equals(default(KeyValuePair <TessellatedSolid, BoundingBox>))) { ObbFacesHashSet.Add(s, new HashSet <PolygonalFace>(PartitioningSolid.TwelveFaceGenerator(pair.Value.CornerVertices.Select(cv => new Vertex(cv.Position)).ToArray()))); } } } CreateCombinedCVHs(subAssems); var solidsL = subAssems.ToList(); int width = 55; int total = (solidsL.Count + 1) * (solidsL.Count / 2); int refresh = (int)Math.Ceiling(((float)total) / ((float)(width))); int check = 0; LoadingBar.start(width, 0); for (var i = 0; i < solidsL.Count; i++) { var solidMoving = solidsL[i].Value; for (var j = i + 1; j < solidsL.Count; j++) { if (check % refresh == 0) { LoadingBar.refresh(width, ((float)check) / ((float)total)); } check++; var blocked = false; // check the convex hull of these two solids to find the planes tha can linearly seperate them // solid1 is moving and solid2 is blocking var solidBlocking = solidsL[j].Value; counter += solidMoving.Sum(s => s.Faces.Length) * solidBlocking.Sum(s => s.Faces.Length); if ( graph.arcs.Any( a => a is Connection && ((a.From.name == solidsL[i].Key && a.To.name == solidsL[j].Key) || (a.From.name == solidsL[j].Key && a.To.name == solidsL[i].Key)))) { continue; } // Add a secondary arc to the var from = GetNode(graph, solidsL[i].Key); var to = GetNode(graph, solidsL[j].Key); graph.addArc(from, to, from.name + to.name, typeof(SecondaryConnection)); var lastAddedSecArc = (SecondaryConnection)graph.arcs.Last(); var filteredDirections = FilterGlobalDirections(solidMoving, solidBlocking, gDir); var oppositeFiltrdDirs = filteredDirections.Select(d => DisassemblyDirections.DirectionsAndOppositsForGlobalpool[d]).ToList(); // remember this: if solid2 is not blocking solid1, we need to check if solid1 is blocking 2 in the opposite direction. // if filteredDirections.Count == gDir.Count then the CVHs overlap // Only directions need to be checked which the moving part can move along them: var scndFilteredDirectionsMoving = FinalSetOfDirectionsFinder(graph, solidMoving, filteredDirections); var scndFilteredDirectionsBlocking = new List <int>(); scndFilteredDirectionsBlocking = FinalSetOfDirectionsFinder(graph, solidBlocking, filteredDirections.Count == gDir.Count ? filteredDirections : oppositeFiltrdDirs); foreach ( var d in scndFilteredDirectionsMoving.Where( d => !scndFilteredDirectionsBlocking.Contains( DisassemblyDirections.DirectionsAndOppositsForGlobalpool[d]))) { scndFilteredDirectionsBlocking.Add(DisassemblyDirections.DirectionsAndOppositsForGlobalpool[d]); } foreach ( var d in scndFilteredDirectionsBlocking.Where( d => !scndFilteredDirectionsMoving.Contains( DisassemblyDirections.DirectionsAndOppositsForGlobalpool[d]))) { scndFilteredDirectionsMoving.Add(DisassemblyDirections.DirectionsAndOppositsForGlobalpool[d]); } if (filteredDirections.Count == gDir.Count) { //continue; Parallel.ForEach(scndFilteredDirectionsMoving, filtDir => //foreach (var filtDir in filteredDirections) { var direction = DisassemblyDirections.Directions[filtDir]; blocked = BlockingDeterminationWithCvhOverlapping(direction, solidMoving, solidBlocking); if (blocked) { lock (lastAddedSecArc.Directions) lastAddedSecArc.Directions.Add(filtDir); if ( scndFilteredDirectionsBlocking.Contains( DisassemblyDirections.DirectionsAndOppositsForGlobalpool[filtDir])) { scndFilteredDirectionsBlocking.Remove( DisassemblyDirections.DirectionsAndOppositsForGlobalpool[filtDir]); } } }); Parallel.ForEach(scndFilteredDirectionsBlocking, filtDir => //foreach (var filtDir in filteredDirections) { var direction = DisassemblyDirections.Directions[filtDir]; blocked = BlockingDeterminationWithCvhOverlapping(direction, solidBlocking, solidMoving); if (blocked) { lock (lastAddedSecArc.Directions) lastAddedSecArc.Directions.Add(DisassemblyDirections.DirectionsAndOppositsForGlobalpool[filtDir]); } }); if (lastAddedSecArc.Directions.Count == 0) { graph.removeArc(lastAddedSecArc); } } else { //continue; // If CVHs dont overlap: //$ Made this non-parallel for debugging purposes - switch back later Parallel.ForEach(scndFilteredDirectionsMoving, filtDir => //foreach (var filtDir in filteredDirections) { var direction = DisassemblyDirections.Directions[filtDir]; blocked = BlockingDeterminationNoCvhOverlapping(direction, solidMoving, solidBlocking); if (blocked) { lock (lastAddedSecArc.Directions) lastAddedSecArc.Directions.Add(filtDir); if ( scndFilteredDirectionsBlocking.Contains( DisassemblyDirections.DirectionsAndOppositsForGlobalpool[filtDir])) { scndFilteredDirectionsBlocking.Remove( DisassemblyDirections.DirectionsAndOppositsForGlobalpool[filtDir]); } } }); Parallel.ForEach(scndFilteredDirectionsBlocking, filtDir => //foreach (var filtDir in filteredDirections) { var direction = DisassemblyDirections.Directions[filtDir]; blocked = BlockingDeterminationNoCvhOverlapping(direction, solidBlocking, solidMoving); if (blocked) { lock (lastAddedSecArc.Directions) lastAddedSecArc.Directions.Add(DisassemblyDirections.DirectionsAndOppositsForGlobalpool[filtDir]); } }); if (lastAddedSecArc.Directions.Count == 0) { graph.removeArc(lastAddedSecArc); } } } } LoadingBar.refresh(width, 1); CreateSameDirectionDictionary(gDir); }