static public double FindTilt(Vector.MemorySafe_CartVect normalVector) { double calculatedTilt = -999; //may need to also take into account other factors that, at this stage, seem to not be important //building Direction of Relative North //zone Direction of Relative North //GlobalGeometryRules coordinate system //I may need to know this in the future then rotate the axis vectors I am making below //x-axis [1 0 0] points east, y-axis [0 1 0] points north, z-axis[0 0 1] points up to the sky //alignment with y axis means north pointing, alignment with z-axis means it is pointing up to the sky (like a flat roof) double nX = 0; double nY = 1; double nZ = 0; Vector.MemorySafe_CartVect northVector = new Vector.MemorySafe_CartVect(nX, nY, nZ); double uX = 0; double uY = 0; double uZ = 1; Vector.MemorySafe_CartVect upVector = new Vector.MemorySafe_CartVect(uX, uY, uZ); //rotate the axis vectors for the future //ensure the vector passed into the function is a unit vector normalVector = Vector.UnitVector(normalVector); //get tilt: cross product of normal vector and upVector //since parallel and anti parallel vectors will return the same cross product [0,0,0] I need to filter out the antiparalll case if (normalVector.X == upVector.X * -1 && normalVector.Y == upVector.Y * -1 && normalVector.Z == upVector.Z * -1) { calculatedTilt = 180; return calculatedTilt; } else { Vector.MemorySafe_CartVect tiltVector = Vector.CrossProduct(normalVector, upVector); double tiltVectorMagnitude = Vector.VectorMagnitude(tiltVector); calculatedTilt = Math.Round(Math.Asin(tiltVectorMagnitude) * 180 / Math.PI, 2); return calculatedTilt; } }
public static double FindAzimuth(Vector.MemorySafe_CartVect normalVector) { double calculatedAzimuth = -999; //may need to also take into account other factors that, at this stage, seem to not be important //building Direction of Relative North //zone Direction of Relative North //GlobalGeometryRules coordinate system //I may need to know this in the future then rotate the axis vectors I am making below //x-axis [1 0 0] points east, y-axis [0 1 0] points north, z-axis[0 0 1] points up to the sky //alignment with y axis means north pointing, alignment with z-axis means it is pointing up to the sky (like a flat roof) Vector.MemorySafe_CartVect northVector = new Vector.MemorySafe_CartVect(0, 1, 0); Vector.MemorySafe_CartVect southVector = new Vector.MemorySafe_CartVect(0, -1, 0); Vector.MemorySafe_CartVect eastVector = new Vector.MemorySafe_CartVect(1, 0, 0); Vector.MemorySafe_CartVect westVector = new Vector.MemorySafe_CartVect(-1, 0, 0); Vector.MemorySafe_CartVect upVector = new Vector.MemorySafe_CartVect(0, 0, 1); //rotate the axis vectors for the future //ensure the vector passed into the function is a unit vector normalVector = Vector.UnitVector(normalVector); //get X-Y projection of the normal vector //normalVector.Z = 0; //get azimuth: cross product of normal vector x-y projection and northVector //2-14-2014 we added last two statements to deal with normal //1st quadrant if ((normalVector.X == 0 && normalVector.Y == 1) || (normalVector.X == 1 && normalVector.Y == 0) || (normalVector.X > 0 && normalVector.Y > 0) || (normalVector.X > 0 && normalVector.Z != 0) || (normalVector.Y > 0 && normalVector.Z != 0)) { //get azimuth: cross product of normal vector x-y projection and northVector Vector.MemorySafe_CartVect azVector = Vector.CrossProduct(normalVector, northVector); double azVectorMagnitude = Vector.VectorMagnitude(azVector); //modification for when the vector is in different quadrants calculatedAzimuth = Math.Round(Math.Asin(azVectorMagnitude) * 180 / Math.PI, 2); return calculatedAzimuth; } //second quadrant else if ((normalVector.X < 0 && normalVector.Y > 0) ) { Vector.MemorySafe_CartVect azVector = Vector.CrossProduct(normalVector, westVector); double azVectorMagnitude = Vector.VectorMagnitude(azVector); //modification for when the vector is in different quadrants calculatedAzimuth = Math.Round(Math.Asin(azVectorMagnitude) * 180 / Math.PI, 2) + 270; return calculatedAzimuth; } //quadrant 3 else if ((normalVector.X < 0 && normalVector.Y < 0) || (normalVector.X == -1 && normalVector.Y == 0) || (normalVector.X < 0 && normalVector.Z !=0)) { Vector.MemorySafe_CartVect azVector = Vector.CrossProduct(normalVector, southVector); double azVectorMagnitude = Vector.VectorMagnitude(azVector); //modification for when the vector is in different quadrants calculatedAzimuth = Math.Round(Math.Asin(azVectorMagnitude) * 180 / Math.PI, 2) + 180; return calculatedAzimuth; } //quadrant 4 else if ((normalVector.X > 0 && normalVector.Y < 0) || (normalVector.X == 0 && normalVector.Y == -1) || (normalVector.Y < 0 && normalVector.Z != 0)) { Vector.MemorySafe_CartVect azVector = Vector.CrossProduct(normalVector, eastVector); double azVectorMagnitude = Vector.VectorMagnitude(azVector); //modification for when the vector is in different quadrants calculatedAzimuth = Math.Round(Math.Asin(azVectorMagnitude) * 180 / Math.PI, 2) + 90; return calculatedAzimuth; } //this will happen to vectors that point straight down or straight up because we are only interested in the X-Y projection and set the Z to zero anyways else if (normalVector.X == 0 && normalVector.Y == 0) { calculatedAzimuth = 0; return calculatedAzimuth; } //get the return calculatedAzimuth; }
private static DOEgbXMLReportingObj GetOpeningPolyLoopCoordMatch(Vector.MemorySafe_CartCoord standardPolyLoopCoord, OpeningDefinitions testOpening, DOEgbXMLReportingObj report, string standardOpeningId) { List<Vector.MemorySafe_CartCoord> possibleMatch = new List<Vector.MemorySafe_CartCoord>(); List<Vector.MemorySafe_CartCoord> exactMatch = new List<Vector.MemorySafe_CartCoord>(); report.MessageList.Add("Testing Polyloop coordinates for Standard opening " + standardOpeningId); report.MessageList.Add(" X: " + standardPolyLoopCoord.X.ToString() + ", Y: " + standardPolyLoopCoord.Y.ToString() + ", Z: " + standardPolyLoopCoord.Z.ToString()); foreach (Vector.MemorySafe_CartCoord testPolyLoopCoord in testOpening.PlCoords) { //find an appropriate match double diffX = Math.Abs(testPolyLoopCoord.X - standardPolyLoopCoord.X); if (diffX < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //found a perfect X Match if (diffX == 0) { //test Y double diffY = Math.Abs(testPolyLoopCoord.Y - standardPolyLoopCoord.Y); if (diffY < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Y Match if (diffY == 0) { double diffZ = Math.Abs(testPolyLoopCoord.Z - standardPolyLoopCoord.Z); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { report.MessageList.Add("Test Opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " exactly"); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); exactMatch.Add(testPolyLoopCoord); } else { //not a perfect Z match but within bounds report.MessageList.Add("Test Opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " X and Y coordinates exactly. Z coordinate within allowable tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } else { //z coordinate not within tolerance continue; } } //Y Match is within the allowable tolerance else { double diffZ = Math.Abs(testPolyLoopCoord.Z - standardPolyLoopCoord.Z); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { report.MessageList.Add("Test Opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " in the X and Z coordinates, exactly. Y coordinate is within tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } else { report.MessageList.Add("Test Opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " X exactly. Y and Z coordinates are within tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } else { //z coordinate is not within tolerance continue; } } } else { //a y match could not be found within tolerance continue; } } else { //not a perfect X match, but within tolerance //test Y double diffY = Math.Abs(testPolyLoopCoord.Y - standardPolyLoopCoord.Y); if (diffY < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Y Match if (diffY == 0) { double diffZ = Math.Abs(testPolyLoopCoord.Z - standardPolyLoopCoord.Z); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { report.MessageList.Add("Test Opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " Y and Z coordinate exactly. X is within tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } else { report.MessageList.Add("Test Opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " Y coordinate exactly. X and Z is within tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } else { //z is not matched so continue continue; } } // the Y match is not perfect but within tolerance else { double diffZ = Math.Abs(testPolyLoopCoord.Z - standardPolyLoopCoord.Z); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { report.MessageList.Add("Test opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + " Z coordinate exactly. The X and Y coordinates are within tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } else { report.MessageList.Add("Test opening " + testOpening.OpeningId + ": Found polyLoop coordinate that matches Standard Opening " + standardOpeningId + ". The X, Y, and Z coordinates are within tolerance."); report.MessageList.Add("Test Opening " + testOpening.OpeningId); report.MessageList.Add(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } // no match found for the Z else { continue; } } } //no match could be found for the Y else { continue; } } } else { //not a match found for the X and continue continue; } } if (exactMatch.Count > 1) { report.MessageList.Add("Error, overlapping polyLoop coordinates found in the Test Opening PolyLoop."); report.passOrFail = false; return report; } else if (exactMatch.Count == 1) { report.MessageList.Add("One coordinate candidate found. Exact match"); report.passOrFail = true; return report; } if (possibleMatch.Count > 1) { report.MessageList.Add("No exact solution for a match of the polyLoop coordinate. More than one coordinate candidate found."); report.passOrFail = false; return report; } else if (possibleMatch.Count == 1) { report.MessageList.Add("One coordinate candidate found."); report.passOrFail = true; return report; } else { report.MessageList.Add("No coordinate candidate found."); report.passOrFail = false; return report; } }
private static bool GetPolyLoopCoordMatch(Vector.MemorySafe_CartCoord standardPolyLoopCoord, SurfaceDefinitions testSurface, string standardSurfaceId, double testlengthConversion, double standardlengthConversion) { List<Vector.MemorySafe_CartCoord> possibleMatch = new List<Vector.MemorySafe_CartCoord>(); List<Vector.MemorySafe_CartCoord> exactMatch = new List<Vector.MemorySafe_CartCoord>(); logger.Debug("START SUBROUTINE: GetPolyLoopCoordMatch"); logger.Debug(standardSurfaceId +"Coordinates: "+" X: " + standardPolyLoopCoord.X.ToString() + ", Y: " + standardPolyLoopCoord.Y.ToString() + ", Z: " + standardPolyLoopCoord.Z.ToString()); foreach (Vector.MemorySafe_CartCoord testPolyLoopCoord in testSurface.PlCoords) { //find an appropriate match double diffX = Math.Abs((testPolyLoopCoord.X * testlengthConversion) - (standardPolyLoopCoord.X * standardlengthConversion)); if (diffX < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //found a perfect X Match if (diffX == 0) { //test Y double diffY = Math.Abs((testPolyLoopCoord.Y * testlengthConversion) - (standardPolyLoopCoord.Y * standardlengthConversion)); if (diffY < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Y Match if (diffY == 0) { double diffZ = Math.Abs((testPolyLoopCoord.Z * testlengthConversion) - (standardPolyLoopCoord.Z * standardlengthConversion)); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { logger.Debug("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " exactly"); logger.Debug("Test Surface " + testSurface.SurfaceId); logger.Debug(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); exactMatch.Add(testPolyLoopCoord); } else { //not a perfect Z match but within bounds logger.Debug("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " X and Y coordinates exactly. Z coordinate within allowable tolerance."); logger.Debug("Test Surface " + testSurface.SurfaceId); logger.Debug(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } else { //z coordinate not within tolerance continue; } } //Y Match is within the allowable tolerance else { double diffZ = Math.Abs((testPolyLoopCoord.Z * testlengthConversion) - (standardPolyLoopCoord.Z * standardlengthConversion)); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { logger.Debug("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " in the X and Z coordinates, exactly. Y coordinate is within tolerance."); logger.Debug("Test Surface " + testSurface.SurfaceId); logger.Debug(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } else { logger.Debug("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " X exactly. Y and Z coordinates are within tolerance."); logger.Debug("Test Surface " + testSurface.SurfaceId); logger.Debug(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } else { //z coordinate is not within tolerance continue; } } } else { //a y match could not be found within tolerance continue; } } else { //not a perfect X match, but within tolerance //test Y double diffY = Math.Abs((testPolyLoopCoord.Y * testlengthConversion) - (standardPolyLoopCoord.Y * standardlengthConversion)); if (diffY < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Y Match if (diffY == 0) { double diffZ = Math.Abs((testPolyLoopCoord.Z * testlengthConversion) - (standardPolyLoopCoord.Z * standardlengthConversion)); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { logger.Info("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " Y and Z coordinate exactly. X is within tolerance."); logger.Info("Test Surface " + testSurface.SurfaceId); logger.Info(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } else { logger.Info("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " Y coordinate exactly. X and Z is within tolerance."); logger.Info("Test Surface " + testSurface.SurfaceId); logger.Info(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } else { //z is not matched so continue continue; } } // the Y match is not perfect but within tolerance else { double diffZ = Math.Abs((testPolyLoopCoord.Z * testlengthConversion) - (standardPolyLoopCoord.Z * standardlengthConversion)); if (diffZ < DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance) { //perfect Z match if (diffZ == 0) { logger.Info("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + " Z coordinate exactly. The X and Y coordinates are within tolerance."); logger.Info("Test Surface " + testSurface.SurfaceId); logger.Info(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } else { logger.Info("Test Surface " + testSurface.SurfaceId + ": Found polyLoop coordinate that matches Standard Surface " + standardSurfaceId + ". The X, Y, and Z coordinates are within tolerance."); logger.Info("Test Surface " + testSurface.SurfaceId); logger.Info(" X: " + testPolyLoopCoord.X.ToString() + ", Y: " + testPolyLoopCoord.Y.ToString() + ", Z: " + testPolyLoopCoord.Z.ToString()); possibleMatch.Add(testPolyLoopCoord); } } // no match found for the Z else { continue; } } } //no match could be found for the Y else { continue; } } } else { //not a match found for the X and continue continue; } } if (exactMatch.Count > 1) { logger.Info("Error, overlapping polyLoop coordinates found in the Test Surface PolyLoop."); return false; } else if (exactMatch.Count == 1) { logger.Info("One coordinate candidate found. Exact match"); return true; } if (possibleMatch.Count > 1) { logger.Info("No exact solution for a match of the polyLoop coordinate. More than one coordinate candidate found."); return false; } else if (possibleMatch.Count == 1) { logger.Info("One coordinate candidate found."); return true; } else { logger.Info("No coordinate candidate found."); return false; } }
public bool EdgesShareVertex(Vector.MemorySafe_CartCoord vertex, DOEgbXMLBasics.EdgeFamily edge) { double lengthTol = DOEgbXMLBasics.Tolerances.SurfacePLCoordTolerance; double dx = Math.Abs(vertex.X - edge.startendpt[0].X); double dy = Math.Abs(vertex.Y - edge.startendpt[0].Y); double dz = Math.Abs(vertex.Z - edge.startendpt[0].Z); if(dx <= lengthTol && dy <= lengthTol && dz <= lengthTol) { return true; } dx = Math.Abs(vertex.X - edge.startendpt[1].X); dy = Math.Abs(vertex.Y - edge.startendpt[1].Y); dz = Math.Abs(vertex.Z - edge.startendpt[1].Z); if(dx <= lengthTol && dy <= lengthTol && dz <= lengthTol) { return true; } return false; }
public bool FoundVertexMatch(Vector.MemorySafe_CartCoord vertex, List<DOEgbXMLBasics.EdgeFamily> edges) { int vertexMatchCount = 0; for(int e = 0; e < edges.Count(); e++) { if(EdgesShareVertex(vertex,edges[e])) { vertexMatchCount++; } } if(vertexMatchCount == 1) { return true; } else { return false; } }
private static string MakeCoordString(Vector.MemorySafe_CartCoord coord) { return "(" + coord.X + "," + coord.Y + "," + coord.Z + ")"; }
public static CartesianPoint makegbCartesianPt(Vector.MemorySafe_CartCoord pt) { CartesianPoint cp = new CartesianPoint(); cp.Coordinate = new string[3]; cp.Coordinate[0] = gb.FormatDoubleToString(pt.X); cp.Coordinate[1] = gb.FormatDoubleToString(pt.Y); cp.Coordinate[2] = gb.FormatDoubleToString(pt.Z); return cp; }
//we have already proven that the neighboring edges are aligned with the edge //so we do not perform an exhaustive vector search to find the answer. All we do instead is try and position them correctly //in sequence as well as is possible. //we do not check for overlaps until later public static Vector.EdgeFamily[] AlignEdges(Vector.EdgeFamily[] alignededges, Vector.EdgeFamily edge, double tol) { try { List<double> magnitudes = new List<double>(); List<int> indices = new List<int>(); for (int i = 0; i < edge.relatedEdges.Count(); i++) { Vector.MemorySafe_CartCoord longstart = edge.startendpt[0]; Vector.MemorySafe_CartCoord longend = edge.startendpt[1]; Vector.MemorySafe_CartVect longv = Vector.CreateMemorySafe_Vector(longstart, longend); double maglong = Vector.VectorMagnitude(longv); Vector.EdgeFamily shortedge = edge.relatedEdges[i]; Vector.MemorySafe_CartCoord shortstart = shortedge.startendpt[0]; Vector.MemorySafe_CartCoord shortend = shortedge.startendpt[1]; Vector.MemorySafe_CartVect el1 = Vector.CreateMemorySafe_Vector(longstart, shortstart); Vector.MemorySafe_CartVect el2 = Vector.CreateMemorySafe_Vector(longstart, shortend); double magel1 = Vector.VectorMagnitude(el1); double magel2 = Vector.VectorMagnitude(el2); //put the greater of the two magnitudes in the list if (magel1 > magel2) { shortedge.startendpt.Reverse(); if (magnitudes.Count >= 1) { bool added = false; for (int m = 0; m < magnitudes.Count(); m++) { if (magel1 < magnitudes[m]) { magnitudes.Insert(m, magel1); indices.Insert(m, i); added = true; break; } } if (!added) { magnitudes.Add(magel1); indices.Add(i); } } else { magnitudes.Add(magel1); indices.Add(i); } } else { if (magnitudes.Count >= 1) { bool added = false; for (int m = 0; m < magnitudes.Count(); m++) { if (magel1 < magnitudes[m]) { magnitudes.Insert(m, magel2); indices.Insert(m, i); added = true; break; } } if (!added) { magnitudes.Add(magel2); indices.Add(i); } } else { magnitudes.Add(magel2); indices.Add(i); } } } int alignedcounter = 0; foreach (int i in indices) { alignededges[alignedcounter] = edge.relatedEdges[i]; alignedcounter++; } return alignededges; } catch (Exception e) { } return alignededges; }
private static bool isCoordUnique(Dictionary<Vector.CartCoord, Tuple<List<string>, List<bool>>> clist, Vector.CartCoord coord) { foreach (Vector.CartCoord approvedcoord in clist.Keys) { //a text for tolerances? if (approvedcoord.X == coord.X && approvedcoord.Y == coord.Y && approvedcoord.Z == coord.Z) { return false; } } return true; }