//March15 2013
//by CHarriman Senior Product Manager Carmel Software Corporation
//this is a function only used internally. It is used to verify if an opening object only has four coordinates, and if those coordinates form
//a square or rectangle.
private static bool IsOpeningRegular(OpeningDefinitions Opening)
{
//tests to see if all candidate surfaces and the standard surface are regular (rectangular polygons)
bool isRegularPolygon = true;
//see if the standard surface has four coordinates defining its polyloop (one marker of a rectangle)
int standSurfaceCoordinateCount = Opening.PlCoords.Count;
if (standSurfaceCoordinateCount == 4)
{
//check the two potentially parallel sides, to ensure they are indeed parallel
Vector.CartVect v1 = Vector.CreateVector(Opening.PlCoords[0], Opening.PlCoords[1]);
Vector.CartVect v2 = Vector.CreateVector(Opening.PlCoords[2], Opening.PlCoords[3]);
Vector.CartVect v1xv2 = Vector.CrossProduct(v1, v2);
v1xv2 = Vector.UnitVector(v1xv2);
double magnitudev1xv2 = Vector.VectorMagnitude(v1xv2);
Vector.CartVect v3 = Vector.CreateVector(Opening.PlCoords[1], Opening.PlCoords[2]);
Vector.CartVect v4 = Vector.CreateVector(Opening.PlCoords[3], Opening.PlCoords[0]);
Vector.CartVect v3xv4 = Vector.CrossProduct(v3, v4);
v3xv4 = Vector.UnitVector(v3xv4);
double magnitudev3xv4 = Vector.VectorMagnitude(v3xv4);
//the unit vector will not be a number NaN if the Cross product detects a zero vector (indicating parallel vectors)
if (double.IsNaN(magnitudev1xv2) && double.IsNaN(magnitudev3xv4))
{
isRegularPolygon = true;
}
else
{
isRegularPolygon = false;
}
}
else
{
//might as well stop here because
isRegularPolygon = false;
return isRegularPolygon;
}
return isRegularPolygon;
}
private List<OpeningDefinitions> GetFileOpeningDefs(XmlDocument TestFile, XmlNamespaceManager TestNSM)
{
List<OpeningDefinitions> openings = new List<OpeningDefinitions>();
try
{
XmlNodeList nodes = TestFile.SelectNodes("/gbXMLv5:gbXML/gbXMLv5:Campus/gbXMLv5:Surface/gbXMLv5:Opening", TestNSM);
foreach (XmlNode openingNode in nodes)
{
//initialize a new instance of the class
OpeningDefinitions openingDef = new OpeningDefinitions();
openingDef.PlCoords = new List<Vector.MemorySafe_CartCoord>();
//get parent id
XmlAttributeCollection parentSurfaceAttributes = openingNode.ParentNode.Attributes;
foreach (XmlAttribute parentAt in parentSurfaceAttributes)
{
if (parentAt.Name == "id")
{
openingDef.ParentSurfaceId = parentAt.Value;
break;
}
}
//get Parent Azimuth and Tilt
XmlNode surfaceParentNode = openingNode.ParentNode;
if (surfaceParentNode.HasChildNodes)
{
XmlNodeList surfaceParentNodesChillun = surfaceParentNode.ChildNodes;
foreach (XmlNode chileNode in surfaceParentNodesChillun)
{
if (chileNode.Name == "RectangularGeometry")
{
if (chileNode.HasChildNodes)
{
foreach (XmlNode grandchileNode in chileNode)
{
if (grandchileNode.Name == "Tilt") { openingDef.ParentTilt = Convert.ToDouble(grandchileNode.InnerText); }
else if (grandchileNode.Name == "Azimuth") { openingDef.ParentAzimuth = Convert.ToDouble(grandchileNode.InnerText); }
}
}
}
}
}
else
{
}
//get surface Id and Opening Type
XmlAttributeCollection openingAtts = openingNode.Attributes;
foreach (XmlAttribute at in openingAtts)
{
if (at.Name == "id")
{
openingDef.OpeningId = at.Value;
}
else if (at.Name == "openingType")
{
openingDef.OpeningType = at.Value;
}
}
if (openingNode.HasChildNodes)
{
XmlNodeList surfChildNodes = openingNode.ChildNodes;
foreach (XmlNode node in surfChildNodes)
{
if (node.Name == "RectangularGeometry")
{
if (node.HasChildNodes)
{
XmlNodeList rectGeomChildren = node.ChildNodes;
foreach (XmlNode rgChildNode in rectGeomChildren)
{
if (rgChildNode.Name == "Azimuth") { openingDef.Azimuth = Convert.ToDouble(rgChildNode.InnerText); }
else if (rgChildNode.Name == "CartesianPoint")
{
if (rgChildNode.HasChildNodes)
{
XmlNodeList coordinates = rgChildNode.ChildNodes;
int pointCount = 1;
Vector.CartCoord od = new Vector.CartCoord();
foreach (XmlNode coordinate in coordinates)
{
switch (pointCount)
{
case 1:
od.X = Convert.ToDouble(coordinate.InnerText);
break;
case 2:
od.Y = Convert.ToDouble(coordinate.InnerText);
break;
case 3:
od.Z = Convert.ToDouble(coordinate.InnerText);
break;
}
pointCount++;
}
openingDef.InsertionPoint = new Vector.MemorySafe_CartCoord(od.X, od.Y, od.Z);
}
}
else if (rgChildNode.Name == "Tilt") { openingDef.Tilt = Convert.ToDouble(rgChildNode.InnerText); }
else if (rgChildNode.Name == "Height") { openingDef.Height = Convert.ToDouble(rgChildNode.InnerText); }
else if (rgChildNode.Name == "Width") { openingDef.Width = Convert.ToDouble(rgChildNode.InnerText); }
}
}
}
else if (node.Name == "PlanarGeometry")
{
XmlNode polyLoop = node.FirstChild;
if (polyLoop.HasChildNodes)
{
XmlNodeList cartesianPoints = polyLoop.ChildNodes;
foreach (XmlNode coordinatePt in cartesianPoints)
{
Vector.CartCoord coord = new Vector.CartCoord();
if (coordinatePt.HasChildNodes)
{
XmlNodeList coordinates = coordinatePt.ChildNodes;
int pointCount = 1;
foreach (XmlNode coordinate in coordinatePt)
{
switch (pointCount)
{
case 1:
coord.X = Convert.ToDouble(coordinate.InnerText);
break;
case 2:
coord.Y = Convert.ToDouble(coordinate.InnerText);
break;
case 3:
coord.Z = Convert.ToDouble(coordinate.InnerText);
break;
}
pointCount++;
}
openingDef.PlCoords.Add(new Vector.MemorySafe_CartCoord(coord.X,coord.Y,coord.Z));
}
}
}
}
}
}
Vector.MemorySafe_CartVect plRHRVect = GetPLRHR(openingDef.PlCoords);
openingDef.PlRHRVector = new Vector.MemorySafe_CartVect(plRHRVect.X, plRHRVect.Y, plRHRVect.Z);
//may want to forego the above since the orientation is embedded in the parent object. It may be smarter to just include the azimuth and tilt of the parent object?
openings.Add(openingDef);
}
return openings;
}
catch (Exception e)
{
return openings;
}
}
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 DOEgbXMLReportingObj GetPossibleOpeningMatches(OpeningDefinitions standardOpening, List<OpeningDefinitions> TestOpenings, DOEgbXMLReportingObj report)
{
report.testSummary = "This test checks the geometric accuracy of each opening in your test file against the standard file.";
report.testSummary += " For each opening (window, door, skylight) this validator seeks out a similar opening in your test file and";
//match surfaces at this stage so we know which surface is associated with the window
report.testSummary += " The validator first seeks to find all openings that have a parent surface (roof, external wall, etc.) with";
report.testSummary += " the same azimuth and tilt. If it finds more than one opening candidate that matches the parent surface tilt and azimuth,";
report.testSummary += " the validator will make all of these openings possible candidates.";
report.testSummary += " The validator then takes these candidates and looks at their polyloop coordinates. ";
report.testSummary += " and will keep only those openings that have similar polyLoop coordinates";
report.testSummary += " Next it matches the area, then the width and height, if applicable, and finally checks the insertion";
report.testSummary += " point coordinates. If all of these come back within tolerance, the opening has found a match.";
report.testSummary += " Otherwise, the test will fail.";
report.testSummary += " The summary at the bottom of the page will show the logic of how the test arrived at its conclusion.";
bool matchedParentAz = false;
bool matchedParentTilt = false;
bool matchedPolyLoopCoords = false;
List<OpeningDefinitions> possibleMatches = new List<OpeningDefinitions>();
List<OpeningDefinitions> possibleMatches2 = new List<OpeningDefinitions>();
try
{
//find match of parent surface
//try matching based on the surface matches
//if that does not work, then just try to match the parent tilt and parent azimuth to one another
int i = 0;
report.MessageList.Add("Starting Parent Azimuth and Tilt Match test....");
report.MessageList.Add("</br>");
while (true)
{
//reset
matchedParentAz = false;
matchedParentTilt = false;
OpeningDefinitions testOpening = TestOpenings[i];
if (testOpening.ParentAzimuth == standardOpening.ParentAzimuth && testOpening.ParentTilt == standardOpening.ParentTilt)
{
report.MessageList.Add("Candidate Found. Test file opening has EXACTLY matched its parent surface azimuth and tilt with the standard opening parent surface azimuth and tilt.");
report.MessageList.Add("Test Opening " + testOpening.OpeningId + "'s [parent, azimuth, tilt]: [" + testOpening.ParentSurfaceId + ", " + testOpening.ParentAzimuth + ", " + testOpening.ParentTilt + "]");
report.MessageList.Add("Standard Opening " + standardOpening.OpeningId + "'s [parent, azimuth, tilt]: [" + standardOpening.ParentSurfaceId + "," + standardOpening.ParentAzimuth + ", " + standardOpening.ParentTilt + "]");
matchedParentAz = true;
matchedParentTilt = true;
}
else
{
double azDifference = Math.Abs(testOpening.ParentAzimuth - standardOpening.ParentAzimuth);
double tiltDifference = Math.Abs(testOpening.ParentTilt - standardOpening.ParentTilt);
if (azDifference < DOEgbXMLBasics.Tolerances.SurfaceAzimuthTolerance && tiltDifference < DOEgbXMLBasics.Tolerances.SurfaceTiltTolerance)
{
report.MessageList.Add("Candidate found. Test file opening HAS matched WITHIN ALLOWABLE TOLERANCE its parent surface azimuth and tilt with the standard opening parent surface azimuth and tilt.");
report.MessageList.Add("Test Opening " + testOpening.OpeningId + "'s [parent, azimuth, tilt]: [" + testOpening.ParentSurfaceId + ", " + testOpening.ParentAzimuth + ", " + testOpening.ParentTilt + "]");
report.MessageList.Add("Standard Opening " + standardOpening.OpeningId + "'s [parent, azimuth, tilt]: [" + standardOpening.ParentSurfaceId + "," + standardOpening.ParentAzimuth + ", " + standardOpening.ParentTilt + "]");
matchedParentAz = true;
matchedParentTilt = true;
}
else
{
report.MessageList.Add("Candidate rejected. Test file opening HAS NOT matched WITHIN ALLOWABLE TOLERANCE its parent surface azimuth and tilt with the standard opening parent surface azimuth and tilt.");
report.MessageList.Add("Test Opening " + testOpening.OpeningId + "'s [parent, azimuth, tilt]: [" + testOpening.ParentSurfaceId + ", " + testOpening.ParentAzimuth + ", " + testOpening.ParentTilt + "]");
report.MessageList.Add("Standard Opening " + standardOpening.OpeningId + "'s [parent, azimuth, tilt]: [" + standardOpening.ParentSurfaceId + "," + standardOpening.ParentAzimuth + ", " + standardOpening.ParentTilt + "]");
report.MessageList.Add("</br>");
}
}
if (matchedParentAz && matchedParentTilt)
{
possibleMatches.Add(testOpening);
report.MessageList.Add("Successful Match Candidate Identified.");
report.MessageList.Add("</br>");
}
i++;
if (i == TestOpenings.Count)
{
if (possibleMatches.Count == 0)
{
//no candidates found
report.MessageList.Add("No candidates found in the test file to match standard file opening " + standardOpening.OpeningId);
report.passOrFail = false;
report.longMsg = "Test to find suitable opening candidate in the test file has failed. Parent Tilt and Azimuth matches could not be established.";
//no need to go further
return report;
}
break;
}
}
report.MessageList.Add("</br>");
report.MessageList.Add("Starting Opening PolyLoop Coordinate Match test.........");
i = 0;
while (true)
{
OpeningDefinitions testOpening = possibleMatches[i];
//continue to next test
//continue the next batch of tests
//polyloop absolute coordinates
//check the polyLoop coordinates
foreach (Vector.MemorySafe_CartCoord standardPolyLoopCoord in standardOpening.PlCoords)
{
report = GetOpeningPolyLoopCoordMatch(standardPolyLoopCoord, testOpening, report, standardOpening.OpeningId);
if (report.passOrFail)
{
matchedPolyLoopCoords = true;
continue;
}
else
{
report.MessageList.Add("Could not find a coordinate match in the test opening polyloop.");
matchedPolyLoopCoords = false;
break;
}
}
//if matchePolyLoopCoords comes back true, then a candidate has been found that matches all polyloop coords within tolerance
if (matchedPolyLoopCoords == true)
{
possibleMatches2.Add(testOpening);
}
i++;
if (i == possibleMatches.Count)
{
if (possibleMatches2.Count == 0)
{
report.MessageList.Add("No candidates found in the test file to match standard file opening " + standardOpening.OpeningId);
report.passOrFail = false;
report.longMsg = "Test to find suitable opening candidate in the test file has failed. Parent Tilt and Azimuth matches were established, but these candidates did not produce good polyLoop coordinate matches.";
//no need to go further
return report;
}
break;
}
}
//next set of tests
//polyloop area tests
report.MessageList.Add("</br>");
report.MessageList.Add("Starting Opening Surface Area Match test.........");
possibleMatches.Clear();
i = 0;
while (true)
{
#region
OpeningDefinitions testOpening = possibleMatches2[i];
if (Math.Abs(standardOpening.PlRHRVector.X) == 1 && standardOpening.PlRHRVector.Y == 0 && standardOpening.PlRHRVector.Z == 0)
{
List<Vector.MemorySafe_CartCoord> coordList = new List<Vector.MemorySafe_CartCoord>();
foreach (Vector.MemorySafe_CartCoord coord in standardOpening.PlCoords)
{
//only take the Y and Z coordinates and throw out the X because we can assume that they are all the same
Vector.MemorySafe_CartCoord c2 = new Vector.MemorySafe_CartCoord(0, coord.Y, coord.Z);
coordList.Add(c2);
}
double area = Math.Abs(GetAreaFrom2DPolyLoop(coordList));
standardOpening.surfaceArea = area;
if (area == -999)
{
//these messages should never occur and are a sign of some sort of serious, as of yet unknown error
//March 20 2013
report.MessageList.Add("The coordinates of the standard file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.MessageList.Add("Test may be inaccurate and requires gbXML.org support");
report.longMsg = "Fatal error. Please contact gbXML administrator";
report.passOrFail = false;
return report;
}
double testOpeningArea = 0;
if (Math.Abs(testOpening.PlRHRVector.X) == 1 && testOpening.PlRHRVector.Y == 0 &&
testOpening.PlRHRVector.Z == 0)
{
List<Vector.MemorySafe_CartCoord> testCoordList = new List<Vector.MemorySafe_CartCoord>();
foreach (Vector.MemorySafe_CartCoord coord in testOpening.PlCoords)
{
Vector.MemorySafe_CartCoord o2 = new Vector.MemorySafe_CartCoord(0, coord.Y, coord.Z);
testCoordList.Add(o2);
}
testOpeningArea = Math.Abs(GetAreaFrom2DPolyLoop(testCoordList));
testOpening.surfaceArea = testOpeningArea;
if (testOpeningArea == -999)
{
//these messages should never occur and are a sign of some sort of serious, as of yet unknown error
//March 20 2013
report.MessageList.Add("The coordinates of the test file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.longMsg = "Fatal error. Please contact gbXML administrator";
report.passOrFail = false;
return report;
}
double difference = Math.Abs(area) - Math.Abs(testOpeningArea);
if (difference < Math.Abs(area) * DOEgbXMLBasics.Tolerances.OpeningAreaPercentageTolerance)
{
if (difference == 0)
{
//then it perfectly matches, go on to check the poly loop coordinates
//then check the insertion point
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard opening: " + standardOpening.OpeningId + " exactly.");
possibleMatches.Add(testOpening);
}
else
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard opening: " + standardOpening.OpeningId + " within the allowable area percentage tolerance.");
possibleMatches.Add(testOpening);
}
}
else
{
report.MessageList.Add("The standard file opening cannot find a match for its surface area of opening: " + standardOpening.OpeningId + " through a comparison of its polyloop coordinates with test opening: " + testOpening.OpeningId);
//don't return here, it will be returned below
}
}
else
{
//by definition, the Window opening should always use coordinates that create a normal vector that points in the
//positive or negative X direction. If the test file does not do this, then this is in violation of the
//gbXML spec
report.longMsg = ("This test has failed because the test opening" + testOpening.OpeningId + "has polyloop coordinates ");
report.longMsg += (" that do not have the same normal vector as the standard opening.");
report.passOrFail = false;
}
}
else if (standardOpening.PlRHRVector.X == 0 && Math.Abs(standardOpening.PlRHRVector.Y) == 1 && standardOpening.PlRHRVector.Z == 0)
{
List<Vector.MemorySafe_CartCoord> coordList = new List<Vector.MemorySafe_CartCoord>();
foreach (Vector.MemorySafe_CartCoord coord in standardOpening.PlCoords)
{
//only take the Y and Z coordinates and throw out the X because we can assume that they are all the same
Vector.MemorySafe_CartCoord c2 = new Vector.MemorySafe_CartCoord(coord.X, 0, coord.Z);
coordList.Add(c2);
}
double area = Math.Abs(GetAreaFrom2DPolyLoop(coordList));
standardOpening.surfaceArea = area;
if (area == -999)
{
//these messages should never occur and are a sign of some sort of serious, as of yet unknown error
//March 20 2013
report.MessageList.Add("The coordinates of the standard file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.MessageList.Add("Test may be inaccurate and requires gbXML.org support");
report.longMsg = "Fatal error. Please contact gbXML administrator";
report.passOrFail = false;
return report;
}
double testOpeningArea = 0;
if (testOpening.PlRHRVector.X == 0 && Math.Abs(testOpening.PlRHRVector.Y) == 1 &&
testOpening.PlRHRVector.Z == 0)
{
List<Vector.MemorySafe_CartCoord> testCoordList = new List<Vector.MemorySafe_CartCoord>();
foreach (Vector.MemorySafe_CartCoord coord in testOpening.PlCoords)
{
Vector.MemorySafe_CartCoord o2 = new Vector.MemorySafe_CartCoord(coord.X, 0, coord.Z);
testCoordList.Add(o2);
}
testOpeningArea = Math.Abs(GetAreaFrom2DPolyLoop(testCoordList));
testOpening.surfaceArea = testOpeningArea;
if (testOpeningArea == -999)
{
//these messages should never occur and are a sign of some sort of serious, as of yet unknown error
//March 20 2013
report.MessageList.Add("The coordinates of the test file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.longMsg = "Fatal error. Please contact gbXML administrator";
report.passOrFail = false;
return report;
}
double difference = Math.Abs(area) - Math.Abs(testOpeningArea);
if (difference < Math.Abs(area) * DOEgbXMLBasics.Tolerances.OpeningAreaPercentageTolerance)
{
if (difference == 0)
{
//then it perfectly matches, go on to check the poly loop coordinates
//then check the insertion point
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard Opening: " + standardOpening.OpeningId + " exactly.");
possibleMatches.Add(testOpening);
}
else
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard Opening: " + standardOpening.OpeningId + " within the allowable area percentage tolerance.");
possibleMatches.Add(testOpening);
}
}
else
{
report.MessageList.Add("The standard file opening cannot find a match for its surface area of Opening: " + standardOpening.OpeningId + " through a comparison of its polyloop coordinates with test Opening: " + testOpening.OpeningId);
//don't return here, it will be returned below
}
}
else
{
//by definition, the Window opening should always use coordinates that create a normal vector that points in the
//positive or negative X direction. If the test file does not do this, then this is in violation of the
//gbXML spec
report.longMsg = ("This test has failed because the test opening" + testOpening.OpeningId + "has polyloop coordinates ");
report.longMsg += (" that do not have the same normal vector as the standard opening.");
report.passOrFail = false;
}
}
else if (standardOpening.PlRHRVector.X == 0 && standardOpening.PlRHRVector.Y == 0 && Math.Abs(standardOpening.PlRHRVector.Z) == 1)
{
List<Vector.MemorySafe_CartCoord> coordList = new List<Vector.MemorySafe_CartCoord>();
foreach (Vector.MemorySafe_CartCoord coord in standardOpening.PlCoords)
{
//only take the X and Y coordinates and throw out the Z because we can assume that they are all the same
Vector.MemorySafe_CartCoord c2 = new Vector.MemorySafe_CartCoord(coord.X, coord.Y, 0);
coordList.Add(c2);
}
double area = Math.Abs(GetAreaFrom2DPolyLoop(coordList));
standardOpening.surfaceArea = area;
if (area == -999)
{
report.MessageList.Add("The coordinates of the standard file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.MessageList.Add("Test may be inaccurate and requires gbXML.org support");
}
double testOpeningArea = 0;
if (testOpening.PlRHRVector.X == 0 && testOpening.PlRHRVector.Y == 0 &&
Math.Abs(testOpening.PlRHRVector.Z) == 1)
{
List<Vector.MemorySafe_CartCoord> testCoordList = new List<Vector.MemorySafe_CartCoord>();
foreach (Vector.MemorySafe_CartCoord coord in testOpening.PlCoords)
{
Vector.MemorySafe_CartCoord c02 = new Vector.MemorySafe_CartCoord(coord.X, coord.Y, 0);
testCoordList.Add(coord);
}
testOpeningArea = Math.Abs(GetAreaFrom2DPolyLoop(testCoordList));
testOpening.surfaceArea = testOpeningArea;
if (testOpeningArea == -999)
{
//these messages should never occur and are a sign of some sort of serious, as of yet unknown error
//March 20 2013
report.MessageList.Add("The coordinates of the test file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.longMsg = "Fatal error. Please contact gbXML administrator";
report.passOrFail = false;
return report;
}
double difference = Math.Abs(area) - Math.Abs(testOpeningArea);
if (difference < Math.Abs(area) * DOEgbXMLBasics.Tolerances.OpeningAreaPercentageTolerance)
{
if (difference == 0)
{
//then it perfectly matches, go on to check the poly loop coordinates
//then check the insertion point
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard Opening: " + standardOpening.OpeningId + " exactly.");
possibleMatches.Add(testOpening);
}
else
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard Opening: " + standardOpening.OpeningId + " within the allowable area percentage tolerance.");
possibleMatches.Add(testOpening);
}
}
else
{
report.MessageList.Add("The standard file opening cannot find a match for its surface area of Opening: " + standardOpening.OpeningId + " through a comparison of its polyloop coordinates with test Opening: " + testOpening.OpeningId);
//don't return here, it will be returned below
}
}
else
{
//by definition, the Window opening should always use coordinates that create a normal vector that points in the
//positive or negative X direction. If the test file does not do this, then this is in violation of the
//gbXML spec
report.longMsg = ("This test has failed because the test opening" + testOpening.OpeningId + "has polyloop coordinates ");
report.longMsg += (" that do not have the same normal vector as the standard opening.");
report.passOrFail = false;
}
}
//the opening is not aligned along a reference frame axis
else
{
report.MessageList.Add("This standard Opening is not aligned along a reference plane axis, and will be rotated into a new coordinate frame.");
report.MessageList.Add("Commencing rotation to 2-D.");
//New Z Axis for this plane is the normal vector, does not need to be created
//Get New Y Axis which is the surface Normal Vector cross the original global reference X unit vector (all unit vectors please
Vector.CartVect globalReferenceX = new Vector.CartVect();
globalReferenceX.X = 1;
globalReferenceX.Y = 0;
globalReferenceX.Z = 0;
Vector.MemorySafe_CartVect localY = Vector.UnitVector(Vector.CrossProductMSRetMSNV(standardOpening.PlRHRVector, globalReferenceX));
localY = Vector.UnitVector(localY);
//new X axis is the localY cross the surface normal vector
Vector.MemorySafe_CartVect localX = Vector.UnitVector(Vector.CrossProduct(localY, standardOpening.PlRHRVector));
//convert the polyloop coordinates to a local 2-D reference frame
//using a trick employed by video game programmers found here http://stackoverflow.com/questions/1023948/rotate-normal-vector-onto-axis-plane
List<Vector.MemorySafe_CartCoord> translatedCoordinates = new List<Vector.MemorySafe_CartCoord>();
Vector.MemorySafe_CartCoord newOrigin = new Vector.MemorySafe_CartCoord(0,0,0);
translatedCoordinates.Add(newOrigin);
for (int j = 1; j < standardOpening.PlCoords.Count; j++)
{
//randomly assigns the first polyLoop coordinate as the origin
Vector.MemorySafe_CartCoord origin = standardOpening.PlCoords[0];
//captures the components of a vector drawn from the new origin to the
Vector.CartVect distance = new Vector.CartVect();
distance.X = standardOpening.PlCoords[j].X - origin.X;
distance.Y = standardOpening.PlCoords[j].Y - origin.Y;
distance.Z = standardOpening.PlCoords[j].Z - origin.Z;
//x coordinate is distance vector dot the new local X axis
double tX = distance.X * localX.X + distance.Y * localX.Y + distance.Z * localX.Z;
//y coordinate is distance vector dot the new local Y axis
double tY = distance.X * localY.X + distance.Y * localY.Y + distance.Z * localY.Z;
double tZ = 0;
Vector.MemorySafe_CartCoord translatedPt = new Vector.MemorySafe_CartCoord(tX,tY,tZ);
translatedCoordinates.Add(translatedPt);
}
double area = GetAreaFrom2DPolyLoop(translatedCoordinates);
standardOpening.surfaceArea = area;
if (area == -999)
{
report.MessageList.Add("The coordinates of the standard file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
report.MessageList.Add("Test may be inaccurate and requires gbXML.org support");
}
//get the area of the test candidates using the polyloop coordinates
Vector.CartVect testglobalReferenceX = new Vector.CartVect();
globalReferenceX.X = 1;
globalReferenceX.Y = 0;
globalReferenceX.Z = 0;
Vector.MemorySafe_CartVect testlocalY = Vector.UnitVector(Vector.CrossProductMSRetMSNV(testOpening.PlRHRVector, testglobalReferenceX));
//new X axis is the localY cross the surface normal vector
Vector.MemorySafe_CartVect testlocalX = Vector.UnitVector(Vector.CrossProduct(testlocalY, testOpening.PlRHRVector));
//convert the polyloop coordinates to a local 2-D reference frame
//using a trick employed by video game programmers found here http://stackoverflow.com/questions/1023948/rotate-normal-vector-onto-axis-plane
List<Vector.MemorySafe_CartCoord> testtranslatedCoordinates = new List<Vector.MemorySafe_CartCoord>();
Vector.MemorySafe_CartCoord newOriginTest = new Vector.MemorySafe_CartCoord(0,0,0);
testtranslatedCoordinates.Add(newOriginTest);
for (int j = 1; j < testOpening.PlCoords.Count; j++)
{
//randomly assigns the first polyLoop coordinate as the origin
Vector.MemorySafe_CartCoord origin = testOpening.PlCoords[0];
//captures the components of a vector drawn from the new origin to the
Vector.CartVect distance = new Vector.CartVect();
distance.X = testOpening.PlCoords[j].X - origin.X;
distance.Y = testOpening.PlCoords[j].Y - origin.Y;
distance.Z = testOpening.PlCoords[j].Z - origin.Z;
//x coordinate is distance vector dot the new local X axis
double tX = distance.X * localX.X + distance.Y * localX.Y + distance.Z * localX.Z;
//y coordinate is distance vector dot the new local Y axis
double tY = distance.X * localY.X + distance.Y * localY.Y + distance.Z * localY.Z;
double tZ = 0;
Vector.MemorySafe_CartCoord translatedPt = new Vector.MemorySafe_CartCoord(tX,tY,tZ);
testtranslatedCoordinates.Add(translatedPt);
}
double testOpeningArea = GetAreaFrom2DPolyLoop(translatedCoordinates);
testOpening.surfaceArea = testOpeningArea;
if (testOpeningArea == -999)
{
report.MessageList.Add("The coordinates of the test file polyloop has been incorrectly defined.");
report.MessageList.Add("The coordinates should be 2D and could not be translated to 2D");
}
double difference = Math.Abs(area) - Math.Abs(testOpeningArea);
if (difference < Math.Abs(area) * DOEgbXMLBasics.Tolerances.OpeningAreaPercentageTolerance)
{
if (difference == 0)
{
//then it perfectly matches, go on to check the poly loop coordinates
//then check the insertion point
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard Opening: " + standardOpening.OpeningId + " exactly.");
possibleMatches.Add(testOpening);
}
else
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " polyloop surface area matches the polyLoop surface area of the standard Opening: " + standardOpening.OpeningId + " within the allowable area percentage tolerance.");
possibleMatches.Add(testOpening);
}
}
else
{
report.MessageList.Add("The standard file opening cannot find a match for its surface area of Opening: " + standardOpening.OpeningId + " through a comparison of its polyloop coordinates with test Opening: " + testOpening.OpeningId);
//don't return here, it will be returned below
}
}
i++;
if (i == possibleMatches2.Count)
{
if (possibleMatches.Count == 0)
{
report.MessageList.Add("No area match could be found for standard opening: " + standardOpening.OpeningId + ".");
report.longMsg = "The search routine has ended and could not find a match for opening: " + standardOpening.OpeningId +
". Attempt to match the area of the standard file with test file openings failed.";
return report;
}
else
{
//you are good to go with some more matches
report.MessageList.Add("Area matching SUCCESS for standard file Opening id: " + standardOpening.OpeningId);
report.MessageList.Add("Commencing comparisons of height, width, and insertion point.");
break;
}
}
#endregion
}
//test the width and height, if applicable
report.MessageList.Add("</br>");
report.MessageList.Add("Starting Width and Height Match test.........");
possibleMatches2.Clear();
i = 0;
//surface area using the coordinates of the polyloop. We already assume that they are planar, as previously tested
while (true)
{
//see if the openings are regular
bool isStandardRegular = IsOpeningRegular(standardOpening);
bool isTestRegular = IsOpeningRegular(possibleMatches[i]);
//if they are...go ahead and use width and height, otherwise the values are not reliable
if (isStandardRegular)
{
//output something
if (isTestRegular)
{
//output something
//perform tests
OpeningDefinitions testOpening = possibleMatches[i];
double testWidth = testOpening.Width;
double standardWidth = standardOpening.Width;
double testHeight = testOpening.Height;
double standardHeight = standardOpening.Height;
double widthDifference = Math.Abs(testWidth - standardWidth);
double heightDiffefence = Math.Abs(testHeight - standardHeight);
if (widthDifference <= DOEgbXMLBasics.Tolerances.OpeningWidthTolerance)
{
if (widthDifference == 0)
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " reported Width value matches the Width value of the standard Opening: " + standardOpening.OpeningId + " exactly.");
}
else
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " reported Width value matches the Width value of the standard Opening: " + standardOpening.OpeningId + " within the allowable tolerance.");
}
//check the height
if (heightDiffefence <= DOEgbXMLBasics.Tolerances.OpeningHeightTolerance)
{
if (heightDiffefence == 0)
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " reported Height value matches the Height value of the standard Opening: " + standardOpening.OpeningId + " exactly.");
possibleMatches2.Add(testOpening);
}
else
{
report.MessageList.Add("The test Opening: " + testOpening.OpeningId + " reported Height value matches the Height value of the standard Opening: " + standardOpening.OpeningId + " within the allowable tolerance.");
possibleMatches2.Add(testOpening);
}
}
else
{
//fail, did not match height
report.MessageList.Add("The standard file Opening: " + standardOpening.OpeningId + "The standard file opening cannot find a match for its surface area of Opening: " + standardOpening.OpeningId + " after comparison its Height value with test opening: " + testOpening.OpeningId);
report.passOrFail = false;
continue;
}
}
else
{
//failed, did not match width
report.MessageList.Add("The standard file Opening: " + standardOpening.OpeningId + " cannot find a match for its width after comparison the width value of test Opening: " + testOpening.OpeningId);
report.passOrFail = false;
continue;
}
}
else
{
//let them know the the test opening is not a square or rectangle, but the standard file opening is
//go ahead and break out of the while loop because we aren't testing for width and height
report.MessageList.Add("The standard file Opening: " + standardOpening.OpeningId + " is a rectangle or square, but the test file Opening: " + standardOpening.OpeningId + " is not. Cannot test for a valid width and height.");
report.MessageList.Add("Searching for another test Opening.");
continue;
}
}
else
{
//tell them that the widths and Heights will Not be checked
//because the standard file opening is not a square or rectangle
report.MessageList.Add("Will not be testing for the Width and Height values for standard Opening: " + standardOpening.OpeningId + ". The Opening is not shaped like a rectangle or square.");
report.MessageList.Add("Going on to check insertion point accuracy.");
//needed to transfer values over to possibleMatches2, so deep copy
possibleMatches2 = new List<OpeningDefinitions>(possibleMatches);
break;
}
i++;
if (possibleMatches.Count == i)
{
//means that there is no match for width and height
if (possibleMatches2.Count == 0)
{
report.MessageList.Add("There is no match found for the width and height for Opening: " + standardOpening.OpeningId);
report.passOrFail = false;
report.longMsg = "The opening test has ended at the search for width and height values equal to standard Opening: " + standardOpening.OpeningId;
return report;
}
break;
}
}
report.MessageList.Add("</br>");
report.MessageList.Add("Starting Insertion Point Coordinate Match test.........");
possibleMatches.Clear();
//test the insertion point coordinates
i = 0;
while (true)
{
OpeningDefinitions testOpening = possibleMatches2[i];
double diffX = Math.Abs(testOpening.InsertionPoint.X - standardOpening.InsertionPoint.X);
double diffY = Math.Abs(testOpening.InsertionPoint.Y - standardOpening.InsertionPoint.Y);
double diffZ = Math.Abs(testOpening.InsertionPoint.Z - standardOpening.InsertionPoint.Z);
if (diffX <= DOEgbXMLBasics.Tolerances.OpeningSurfaceInsPtXTolerance && diffY <= DOEgbXMLBasics.Tolerances.OpeningSurfaceInsPtYTolerance &&
diffZ <= DOEgbXMLBasics.Tolerances.OpeningSurfaceInsPtZTolerance)
{
if (diffX == 0)
{
//perfect X coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point X-Coordinate when compared with test Opening: " + testOpening.OpeningId);
if (diffY == 0)
{
//perfect Y coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point Y-Coordinate when compared with test Opening: " + testOpening.OpeningId);
if (diffZ == 0)
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point Z-Coordinate when compared with test Opening: " + testOpening.OpeningId);
possibleMatches.Add(testOpening);
}
else
{
// Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point Z-Coordinate when compared with Test opening: " + testOpening.OpeningId);
//we continue because we search for other matches if there are any
possibleMatches.Add(testOpening);
}
}
else
{
//y-coordinate is within tolerance
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point Y-Coordinate when compared with Test opening: " + testOpening.OpeningId);
if (diffZ == 0)
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point Z-Coordinate when compared with Test opening: " + testOpening.OpeningId);
possibleMatches.Add(testOpening);
}
else
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point Z-Coordinate when compared with test Opening: " + testOpening.OpeningId);
//we continue because we search for other matches if there are any
possibleMatches.Add(testOpening);
}
}
}
// X is within tolerance
else
{
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point X-Coordinate when compared with test Opening: " + testOpening.OpeningId);
if (diffY == 0)
{
//perfect Y coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point Y-Coordinate when compared with test Opening: " + testOpening.OpeningId);
if (diffZ == 0)
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point Z-Coordinate when compared with test Opening: " + testOpening.OpeningId);
possibleMatches.Add(testOpening);
}
else
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point Z-Coordinate when compared with test Opening: " + testOpening.OpeningId);
//we continue because we search for other matches if there are any
possibleMatches.Add(testOpening);
}
}
else
{
//y-coordinate is within tolerance
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point Y-Coordinate when compared with test Opening: " + testOpening.OpeningId);
if (diffZ == 0)
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a perfect match for its insertion point Z-Coordinate when compared with test Opening: " + testOpening.OpeningId);
possibleMatches.Add(testOpening);
}
else
{
//perfect Z coordinate match
report.MessageList.Add("Standard Opening: " + standardOpening.OpeningId + " has found a match within allowable tolerances for its insertion point Z-Coordinate when compared with test Opening: " + testOpening.OpeningId);
//we continue because we search for other matches if there are any
possibleMatches.Add(testOpening);
}
}
}
}
report.MessageList.Add("Standard Opening Ins Pt: (" + standardOpening.InsertionPoint.X.ToString() + "," + standardOpening.InsertionPoint.Y.ToString() + "," + standardOpening.InsertionPoint.Z.ToString() + ")");
report.MessageList.Add("Test File Opening Ins Pt: (" + testOpening.InsertionPoint.X.ToString() + "," + testOpening.InsertionPoint.Y.ToString() + "," + testOpening.InsertionPoint.Z.ToString() + ")");
i++;
if (possibleMatches2.Count == i)
{
if (possibleMatches.Count == 1)
{
List<string> openingMatch = new List<string>();
openingMatch.Add(possibleMatches[0].OpeningId);
report.MessageList.Add("Standard file Opening: " + standardOpening.OpeningId + " is matched to test file Opening: " + testOpening.OpeningId);
globalMatchObject.MatchedOpeningIds.Add(standardOpening.OpeningId, openingMatch);
report.passOrFail = true;
return report;
}
else
{
if (possibleMatches.Count == 0)
{
report.MessageList.Add("Standard file Opening: " + standardOpening.OpeningId + " found no match for insertion point in the test file of the remaining candidates.");
report.passOrFail = false;
return report;
}
else
{
report.MessageList.Add("Standard file Opening: " + standardOpening.OpeningId + " is matched to multiple openings:");
foreach (OpeningDefinitions opening in possibleMatches)
{
report.MessageList.Add("Test Opening:" + opening.OpeningId + "matched insertion point");
}
//resolve by trying to match to the standard opening and test opening parent surfaces.
//for the standard opening
if (globalMatchObject.MatchedSurfaceIds.ContainsKey(standardOpening.ParentSurfaceId))
{
List<string> possibleSurfaceMatches = globalMatchObject.MatchedSurfaceIds[standardOpening.ParentSurfaceId];
if (possibleSurfaceMatches.Count == 1)
{
//then a match was found originally during get possible surface matches. That is good, we only want one
foreach (OpeningDefinitions openingRemaining in possibleMatches)
{
if (openingRemaining.ParentSurfaceId == possibleSurfaceMatches[0])
{
//this is the match we want
//else we would have to continue
report.MessageList.Add("The test Opening: " + openingRemaining.OpeningId + " has been matched to the standard Opening: " + standardOpening.OpeningId +
". Their parent surface ids have been matched. Thus the conflict has been resolved. (Standard opening parent surface Id, test opening parent surface Id" + standardOpening.ParentSurfaceId + "," + openingRemaining.ParentSurfaceId);
report.passOrFail = true;
List<string> openingMatch = new List<string>();
openingMatch.Add(possibleMatches[0].OpeningId);
globalMatchObject.MatchedOpeningIds.Add(standardOpening.OpeningId, openingMatch);
return report;
}
else
{
//do nothing. Maybe report that the parent Surface Id does not match the standard Opening
report.MessageList.Add("Test Opening:" + openingRemaining.OpeningId + " does not match the standard Opening: " + standardOpening.OpeningId +
". Their parent surface ids do not coincide. (Standard Opening parent surface id, test Opening parent surface id)" + standardOpening.ParentSurfaceId + "," + openingRemaining.ParentSurfaceId);
}
}
}
}
report.passOrFail = false;
return report;
}
}
}
}
//finished
}
catch (Exception e)
{
report.longMsg = e.ToString();
}
return report;
}
