public static TriangleInfoList ConvertStringToTriangles(string text, FontStyle fontStyle, float glyphFontSize = 10f)
{
FontFamily fontFamily = FontFamily.GenericSansSerif;
var triangles = new TriangleInfoList();
try {
var textAsPolygons = GeneratePolygonsFromGlyph(fontFamily, fontStyle, text, glyphFontSize, false);
var polygonSet = CreateSetFromList(textAsPolygons);
P2T.Triangulate(polygonSet);
foreach (var polygon in polygonSet.Polygons)
{
foreach (var polyTriangle in polygon.Triangles)
{
var triangle = new Triangle();
var triangleIndex = 0;
foreach (var trianglePoint in polyTriangle.Points)
{
triangle.Vectors [triangleIndex].Position.X = (float)trianglePoint.X;
triangle.Vectors [triangleIndex].Position.Y = (float)trianglePoint.Y;
triangleIndex++;
}
triangles[0].Add(triangle);
}
}
} catch (Exception exc) {
Debug.WriteLine(exc);
}
return(triangles);
}
private void Rotate(float angleY, float angleZ, TriangleInfoList triangles)
{
Matrix4 rotationMatrix = Matrix4.CreateRotationY(OpenTK.MathHelper.DegreesToRadians(angleY));
for (var arrayIndex = 0; arrayIndex < triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < triangles[arrayIndex].Count; triangleIndex++)
{
for (var vectorIndex = 0; vectorIndex < 3; vectorIndex++)
{
var rotatedVector = Vector3Class.Transform(triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position, rotationMatrix);
triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position = rotatedVector;
}
}
}
rotationMatrix = Matrix4.CreateRotationZ(OpenTK.MathHelper.DegreesToRadians(angleZ));
for (var arrayIndex = 0; arrayIndex < triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < triangles[arrayIndex].Count; triangleIndex++)
{
for (var vectorIndex = 0; vectorIndex < 3; vectorIndex++)
{
var rotatedVector = Vector3Class.Transform(triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position, rotationMatrix);
triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position = rotatedVector;
}
}
}
}
internal MeshOverhangSliceInfo()
{
this.OuterPathContourSegmentVectors = new List <List <IntPoint> >();
this.OuterPathIntersectionPlaneTriangles = new TriangleInfoList();
this.InnerIntersectedSplitTrianges = new List <MeshOverhangTriangleIntersection>();
this.InnerIntersectedTriangesOrg = new List <MeshOverhangTriangleIntersection>();
}
public static TriangleInfoList ConvertStringToTrianglesWithOuterPath(string text, FontStyle fontStyle, Polygon outerPath, out PolygonSet textAsPolygonSet, float glyphFontSize = 50f)
{
FontFamily fontFamily = FontFamily.GenericSansSerif;
textAsPolygonSet = new PolygonSet();
var triangles = new TriangleInfoList();
try
{
var textAsPolygons = GeneratePolygonsFromGlyph(fontFamily, fontStyle, text, glyphFontSize, true);
textAsPolygonSet = CreateSetFromList(textAsPolygons);
var polygonSetWithOuterPath = new PolygonSet();
foreach (var t in textAsPolygonSet.Polygons)
{
foreach (var hole in t.Holes)
{
polygonSetWithOuterPath.Add(hole);
}
//t.Holes.Clear();
outerPath.Holes.Add(t);
}
polygonSetWithOuterPath.Add(outerPath);
P2T.Triangulate(polygonSetWithOuterPath);
foreach (var polygon in polygonSetWithOuterPath.Polygons)
{
foreach (var polyTriangle in polygon.Triangles)
{
var triangle = new Triangle();
var triangleIndex = 0;
foreach (var trianglePoint in polyTriangle.Points)
{
triangle.Vectors[triangleIndex].Position.X = (float)trianglePoint.X;
triangle.Vectors[triangleIndex].Position.Y = (float)trianglePoint.Y;
triangleIndex++;
}
triangles[0].Add(triangle);
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc);
}
return(triangles);
}
internal Vector3Class CalcAvgNormal(TriangleInfoList triangles)
{
var avgNormal = new Vector3Class();
foreach (var triangleConnection in this.Keys)
{
avgNormal += triangles[triangleConnection.ArrayIndex][triangleConnection.TriangleIndex].Normal;
}
avgNormal /= this.Count;
return(avgNormal);
}
internal STLModel3D AsSTLModel3D(System.Drawing.Color modelColor)
{
var triangle = new Triangle();
var triangles = new TriangleInfoList();
for (var vertexIndex = 0; vertexIndex < this.VertexArray.Length; vertexIndex += 3)
{
var currentVertexIndex = vertexIndex % 3;
triangle = new Triangle();
triangle.Vectors[currentVertexIndex].Position = new Vector3Class(this.VertexArray[vertexIndex].Position) + new Vector3Class(0, 0, 1);
triangle.Vectors[currentVertexIndex + 1].Position = new Vector3Class(this.VertexArray[vertexIndex + 1].Position) + new Vector3Class(0, 0, 1);
triangle.Vectors[currentVertexIndex + 2].Position = new Vector3Class(this.VertexArray[vertexIndex + 2].Position) + new Vector3Class(0, 0, 1);
triangle.CalcMinMaxZ();
triangles[0].Add(triangle);
}
var stlModel = new STLModel3D(STLModel3D.TypeObject.Model, ObjectView.BindingSupported);
stlModel.Open(null, false, modelColor, ObjectView.NextObjectIndex, triangles, false, false);
return(stlModel);
}
public void CalcOuterSupportPoints(STLModel3D stlModel)
{
if (this.SupportPoints == null)
{
this.SupportPoints = new List <Vector3>();
}
this.SupportPoints.Clear();
if (this.OutlineDistanceFactor > 0)
{
var currentDistance = 0f;
var previousDistance = 0f;
if (this.DebugPoints == null)
{
this.DebugPoints = new List <Vector3>();
}
this.DebugPoints.Clear();
for (var correctedContourPartIndex = 0; correctedContourPartIndex < this.OuterPoints.Count; correctedContourPartIndex++)
{
var contourLine = this.OuterPoints[correctedContourPartIndex];
var intersectionPointsBelow = new TriangleInfoList();
var contourLineVector = (contourLine.SecondPoint - contourLine.FirstPoint);
var contourLineLength = contourLineVector.Length;
currentDistance += contourLineLength;
var startOffsetDistance = this.OutlineDistanceFactor - previousDistance;
while (currentDistance >= this.OutlineDistanceFactor)
{
var startOffsetVectorPercentage = (startOffsetDistance / contourLineLength);
var startOffsetVector = startOffsetVectorPercentage * contourLineVector;
this.SupportPoints.Add(contourLine.FirstPoint + startOffsetVector);
currentDistance -= this.OutlineDistanceFactor;
startOffsetDistance += this.OutlineDistanceFactor;
}
previousDistance = currentDistance;
}
//outside inner points
for (var innerPointIndex = 0; innerPointIndex < this.InnerPoints.Count; innerPointIndex++)
{
currentDistance = 0f;
previousDistance = 0f;
for (var correctedContourPartIndex = 0; correctedContourPartIndex < this.InnerPoints[innerPointIndex].Count; correctedContourPartIndex++)
{
var contourLineStart = this.InnerPoints[innerPointIndex][correctedContourPartIndex];
var intersectionPointsBelow = new TriangleInfoList();
Vector3 contourLineEnd = new Vector3();
if (correctedContourPartIndex == this.InnerPoints[innerPointIndex].Count - 1)
{
contourLineEnd = this.InnerPoints[innerPointIndex][0];
}
else
{
contourLineEnd = this.InnerPoints[innerPointIndex][correctedContourPartIndex + 1];
}
var contourLineVector = (contourLineEnd - contourLineStart);
var contourLineLength = contourLineVector.Length;
currentDistance += contourLineLength;
var startOffsetDistance = this.OutlineDistanceFactor - previousDistance;
while (currentDistance >= this.OutlineDistanceFactor)
{
var startOffsetVectorPercentage = (startOffsetDistance / contourLineLength);
var startOffsetVector = startOffsetVectorPercentage * contourLineVector;
this.SupportPoints.Add(contourLineStart + startOffsetVector);
currentDistance -= this.OutlineDistanceFactor;
startOffsetDistance += this.OutlineDistanceFactor;
}
previousDistance = currentDistance;
}
}
}
}
internal static void CreateXYZAxis()
{
_xTriangles = new TriangleInfoList();
_yTriangles = new TriangleInfoList();
_zTriangles = new TriangleInfoList();
var xAxis = new XYZAxisCone(60, 15f, 1.5f, 1.5f, 0f, 0f, 26, new Vector3(), Color.Red, 0, 0, null, false);
xAxis.RotateByAxis(0, 90, 0, RotationEventArgs.TypeAxis.Y);
_xTriangles[0].AddRange(xAxis.Triangles[0]);
var yAxis = new XYZAxisCone(60, 15f, 1.5f, 1.5f, 0f, 0f, 26, new Vector3(), Color.Green, 0, 0, null, false);
yAxis.RotateByAxis(-90, 0, 0, RotationEventArgs.TypeAxis.X);
_yTriangles[0].AddRange(yAxis.Triangles[0]);
var zAxis = new XYZAxisCone(60, 15f, 1.5f, 1.5f, 0f, 0f, 26, new Vector3(), Color.Blue, 0, 0, null, false);
_zTriangles[0].AddRange(zAxis.Triangles[0]);
if (DAL.OS.OSProvider.IsWindows)
{
//xLabel
_xLabel = new OrientationGizmoFaceText();
var xLabelOffset = new Vector3(60, -7.5f, 0);
_xLabel.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("X", FontStyle.Regular, 15f);
var xLabelClone = (STLModel3D)_xLabel.Clone();
foreach (var triangle in xLabelClone.Triangles[0])
{
triangle.Flip();
_xLabel.Triangles[0].Add(triangle);
}
foreach (var triangle in _xLabel.Triangles[0])
{
triangle.Vectors[0].Position += xLabelOffset;
triangle.Vectors[1].Position += xLabelOffset;
triangle.Vectors[2].Position += xLabelOffset;
}
//yLabel
_yLabel = new OrientationGizmoFaceText();
_yLabel.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("Y", FontStyle.Regular, 15f);
_yLabel.RotateText(0, 0, 180, RotationEventArgs.TypeAxis.Z);
_yLabel.UpdateBoundries();
_yLabel.UpdateDefaultCenter(true);
//_yLabel._rotationAngleX = 0;
var yLabelClone = (STLModel3D)_yLabel.Clone();
foreach (var triangle in yLabelClone.Triangles[0])
{
triangle.Flip();
_yLabel.Triangles[0].Add(triangle);
}
//zLabel
_zLabel = new OrientationGizmoFaceText();
_zLabel.Triangles = Engines.FontTessellationEngine.ConvertStringToTriangles("Z", FontStyle.Regular, 15f);
_zLabel.RotateText(180, 0, 0, RotationEventArgs.TypeAxis.X);
_zLabel.UpdateBoundries();
_zLabel.UpdateDefaultCenter(true);
_zLabel._rotationAngleX = 0;
var zLabelClone = (STLModel3D)_zLabel.Clone();
foreach (var triangle in zLabelClone.Triangles[0])
{
triangle.Flip();
_zLabel.Triangles[0].Add(triangle);
}
}
}
internal static List <MeshOverhangTriangleIntersection> FindTrianglesOnSliceLine(List <Triangle> mesh, MeshOverhangSliceInfo overhangSlice)
{
if (overhangSlice.OuterPathSourcePoint == new Vector3(-17.0105343f, -14.94091f, 0.332000017f))
{
}
//create intersection plate to determine intersecting triangles
var intersectionPlanes = new TriangleInfoList();
intersectionPlanes.Add(new List <Triangle>());
var firstPlaneTriangle = new Triangle();
firstPlaneTriangle.Vectors[0].Position = overhangSlice.OuterPathSourcePoint;
firstPlaneTriangle.Vectors[1].Position = new Vector3(overhangSlice.OuterPathSourcePoint.X, overhangSlice.OuterPathSourcePoint.Y, overhangSlice.OuterPathIntersectionPoint.Z);
firstPlaneTriangle.Vectors[2].Position = overhangSlice.OuterPathIntersectionPoint + (overhangSlice.OuterPathSourcePointEdgeNormal * 10);
firstPlaneTriangle.CalcNormal();
firstPlaneTriangle.CalcMinMaxX();
firstPlaneTriangle.CalcMinMaxY();
firstPlaneTriangle.CalcMinMaxZ();
intersectionPlanes[0].Add(firstPlaneTriangle);
var secondPlaneTriangle = new Triangle();
secondPlaneTriangle = new Triangle();
secondPlaneTriangle.Vectors[0].Position = new Vector3(overhangSlice.OuterPathSourcePoint.X, overhangSlice.OuterPathSourcePoint.Y, overhangSlice.OuterPathIntersectionPoint.Z);
secondPlaneTriangle.Vectors[1].Position = overhangSlice.OuterPathSourcePoint;
secondPlaneTriangle.Vectors[2].Position = overhangSlice.OuterPathIntersectionPoint + (overhangSlice.OuterPathSourcePointEdgeNormal * 10);
secondPlaneTriangle.CalcNormal();
secondPlaneTriangle.CalcMinMaxX();
secondPlaneTriangle.CalcMinMaxY();
secondPlaneTriangle.CalcMinMaxZ();
intersectionPlanes[0].Add(secondPlaneTriangle);
//result.AddRange(intersectionTriangles);
var intersectedTriangles = new List <MeshOverhangTriangleIntersection>();
//find all triangles that intersect with intersection plate
foreach (var triangle in mesh)
{
var intersectionWithPlane = new MeshOverhangTriangleIntersection();
var triangleIntersectionsCount = 0;
for (var vectorIndex = 0; vectorIndex < 3; vectorIndex++)
{
var lineStartPoint = triangle.Vectors[vectorIndex].Position;
var lineEndPoint = triangle.Vectors[0].Position;
if (vectorIndex < 2)
{
lineEndPoint = triangle.Vectors[vectorIndex + 1].Position;
}
if (lineStartPoint == new Vector3(-12.507534f, -9.86491f, 5.96000051f) || lineEndPoint == new Vector3(-12.507534f, -9.86491f, 5.96000051f))
{
}
if (lineStartPoint == overhangSlice.OuterPathSourcePoint)
{
intersectionWithPlane.Vectors = triangle.Vectors;
if (intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint == Vector3.Zero)
{
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint = lineStartPoint;
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPointLineEnd = lineEndPoint;
}
else if (intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint == Vector3.Zero && intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint != lineStartPoint)
{
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint = lineStartPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineEnd = lineEndPoint;
}
triangleIntersectionsCount++;
}
else if (lineStartPoint == overhangSlice.OuterPathIntersectionPoint)
{
intersectionWithPlane.Vectors = triangle.Vectors;
if (intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint == Vector3.Zero)
{
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint = lineStartPoint;
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPointLineEnd = lineEndPoint;
}
else if (intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint == Vector3.Zero && intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint != lineStartPoint)
{
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint = lineStartPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineEnd = lineEndPoint;
}
triangleIntersectionsCount++;
}
else
{
var intersectionPoints = Utils.IntersectionProvider.IntersectTriangles(lineStartPoint, lineEndPoint - lineStartPoint, intersectionPlanes, Utils.IntersectionProvider.typeDirection.OneWay);
if (intersectionPoints.Count > 0)
{
foreach (var intersectionPoint in intersectionPoints)
{
var validIntersectionPoint = false;
if (lineEndPoint.Z >= lineStartPoint.Z && intersectionPoint.Z >= lineStartPoint.Z && intersectionPoint.Z <= lineEndPoint.Z)
{
validIntersectionPoint = true;
}
else if (lineEndPoint.Z <= lineStartPoint.Z && intersectionPoint.Z <= lineStartPoint.Z && intersectionPoint.Z >= lineEndPoint.Z)
{
validIntersectionPoint = true;
}
if (validIntersectionPoint && intersectionPoint != Vector3.Zero)
{
var currentLineLength = (lineEndPoint - lineStartPoint).Length;
var intersectionPointStartLength = (intersectionPoint - lineStartPoint).Length;
var intersectionPointEndLength = (intersectionPoint - lineEndPoint).Length;
if (currentLineLength >= intersectionPointStartLength && currentLineLength >= intersectionPointEndLength)
{
intersectionWithPlane.Vectors = triangle.Vectors;
if (intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint == Vector3.Zero)
{
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint = intersectionPoint;
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint1Properties.IntersectionPointLineEnd = lineEndPoint;
}
else if (intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint == Vector3.Zero && intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint != intersectionPoint)
{
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint = intersectionPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineEnd = lineEndPoint;
}
else
{
//override intersectionpoint2 if previous points are sub same
var intersectionPoint1 = new Vector3((int)(intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint.X * 1000), (int)(intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint.Y * 1000), (int)(intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint.Z * 1000));
var intersectionPoint2 = new Vector3((int)(intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint.X * 1000), (int)(intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint.Y * 1000), (int)(intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint.Z * 1000));
if (intersectionPoint1 == intersectionPoint2)
{
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint = intersectionPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineStart = lineStartPoint;
intersectionWithPlane.IntersectionPoint2Properties.IntersectionPointLineEnd = lineEndPoint;
}
}
triangleIntersectionsCount++;
//break;
}
}
}
}
}
}
//only save the triangles which contains 2 intersectionpoints
if (triangleIntersectionsCount >= 2 && intersectionWithPlane.IntersectionPoint2Properties.IntersectionPoint != Vector3.Zero && intersectionWithPlane.IntersectionPoint1Properties.IntersectionPoint != Vector3.Zero)
{
intersectedTriangles.Add(intersectionWithPlane);
overhangSlice.InnerIntersectedTriangesOrg.Add(intersectionWithPlane);
}
}
//clean up intersected triangle which have same intersection points
for (var intersectedTriangleIndex = intersectedTriangles.Count - 1; intersectedTriangleIndex >= 0; intersectedTriangleIndex--)
{
var intersectedTriangle = intersectedTriangles[intersectedTriangleIndex];
var intersectedTrianglePoint1Simplified = new Vector3((int)(intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.X * 10000), (int)(intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Y * 10000), (int)(intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Z * 10000));
var intersectedTrianglePoint2Simplified = new Vector3((int)(intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.X * 10000), (int)(intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Y * 10000), (int)(intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Z * 10000));
if (intersectedTrianglePoint1Simplified == intersectedTrianglePoint2Simplified)
{
if ((intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint == overhangSlice.OuterPathSourcePoint || intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint == overhangSlice.OuterPathSourcePoint))
{
}
else
{
intersectedTriangles.RemoveAt(intersectedTriangleIndex);
}
}
else if (intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Z <= overhangSlice.OuterPathSourcePoint.Z && intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Z <= overhangSlice.OuterPathSourcePoint.Z)
{
intersectedTriangles.RemoveAt(intersectedTriangleIndex);
}
}
//sort triangles by connected points (down -> up)
var currentPoint = overhangSlice.OuterPathSourcePoint;
var connectedTriangles = new List <MeshOverhangTriangleIntersection>();
var sortedIntersectedTriangles = new List <MeshOverhangTriangleIntersection>();
//find edges that are connected to lowest point
var connectedIntersectionPointFound = true;
for (var intersectedTriangleIndex = intersectedTriangles.Count - 1; intersectedTriangleIndex >= 0; intersectedTriangleIndex--)
{
var intersectedTriangle = intersectedTriangles[intersectedTriangleIndex];
if (intersectedTriangle.Points[0] == currentPoint ||
intersectedTriangle.Points[1] == currentPoint ||
intersectedTriangle.Points[2] == currentPoint)
{
if (intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint != overhangSlice.OuterPathSourcePoint &&
intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint != overhangSlice.OuterPathIntersectionPoint)
{
if (intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Z < intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Z)
{
intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint = overhangSlice.OuterPathSourcePoint;
}
else if (intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Z > intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Z)
{
intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint = overhangSlice.OuterPathSourcePoint;
}
}
intersectedTriangles.RemoveAt(intersectedTriangleIndex);
sortedIntersectedTriangles.Add(intersectedTriangle);
connectedTriangles.Add(intersectedTriangle);
}
}
//when multiple found find the one that is ONLY connected to the outerpath
if (sortedIntersectedTriangles.Count > 1)
{
var currentSourcePointDistance = 0f;
var longestDistanceIntersectedTriangle = sortedIntersectedTriangles[0];
foreach (var sortedIntersectedTriangle in sortedIntersectedTriangles)
{
if (sortedIntersectedTriangle.IntersectionPoint1Properties.IntersectionPoint == overhangSlice.OuterPathSourcePoint)
{
var newSourcePointDistance = (sortedIntersectedTriangle.IntersectionPoint2Properties.IntersectionPoint - overhangSlice.OuterPathSourcePoint).Length;
if (newSourcePointDistance > currentSourcePointDistance)
{
currentSourcePointDistance = newSourcePointDistance;
longestDistanceIntersectedTriangle = sortedIntersectedTriangle;
}
}
if (sortedIntersectedTriangle.IntersectionPoint2Properties.IntersectionPoint == overhangSlice.OuterPathSourcePoint)
{
var newSourcePointDistance = (sortedIntersectedTriangle.IntersectionPoint1Properties.IntersectionPoint - overhangSlice.OuterPathSourcePoint).Length;
if (newSourcePointDistance > currentSourcePointDistance)
{
currentSourcePointDistance = newSourcePointDistance;
longestDistanceIntersectedTriangle = sortedIntersectedTriangle;
}
}
}
sortedIntersectedTriangles.Clear();
sortedIntersectedTriangles.Add(longestDistanceIntersectedTriangle);
}
while (connectedIntersectionPointFound && intersectedTriangles.Count > 0)
{
//find intersectedTriangles which contains 2 connected points
connectedIntersectionPointFound = false;
var newConnectedTriangles = new List <MeshOverhangTriangleIntersection>();
for (var intersectedTriangleIndex = intersectedTriangles.Count - 1; intersectedTriangleIndex >= 0; intersectedTriangleIndex--)
{
var intersectedTriangle = intersectedTriangles[intersectedTriangleIndex];
foreach (var previousIntersectedTriangle in connectedTriangles)
{
var connectedPointsCount = 0;
foreach (var previousVectorPoint in previousIntersectedTriangle.Points)
{
foreach (var vectorPoint in intersectedTriangle.Points)
{
if (vectorPoint == previousVectorPoint)
{
connectedPointsCount++;
break;
}
}
}
if (connectedPointsCount == 2)
{
intersectedTriangles.RemoveAt(intersectedTriangleIndex);
sortedIntersectedTriangles.Add(intersectedTriangle);
newConnectedTriangles.Add(intersectedTriangle);
break;
}
}
}
if (newConnectedTriangles.Count > 0)
{
connectedIntersectionPointFound = true;
connectedTriangles = newConnectedTriangles;
}
}
//remove triangles which contain same intersections
for (var intersectedTriangleIndex = sortedIntersectedTriangles.Count - 1; intersectedTriangleIndex >= 0; intersectedTriangleIndex--)
{
var intersectedTriangle = sortedIntersectedTriangles[intersectedTriangleIndex];
var intersectedTrianglePoint1Simplified = new Vector3((int)(intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.X * 1000), (int)(intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Y * 1000), (int)(intersectedTriangle.IntersectionPoint1Properties.IntersectionPoint.Z * 1000));
var intersectedTrianglePoint2Simplified = new Vector3((int)(intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.X * 1000), (int)(intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Y * 1000), (int)(intersectedTriangle.IntersectionPoint2Properties.IntersectionPoint.Z * 1000));
if (intersectedTrianglePoint1Simplified == intersectedTrianglePoint2Simplified)
{
sortedIntersectedTriangles.RemoveAt(intersectedTriangleIndex);
}
}
overhangSlice.InnerIntersectedTrianges = sortedIntersectedTriangles;
return(sortedIntersectedTriangles);
}
public static TriangleInfoList InsersectTriangleByCenterPoint(Vector3Class center, Vector3Class centerNormal, object model3d)
{
var intersectedTriangles = new TriangleInfoList();
if (model3d is TriangleInfoList)
{
var triangles = (TriangleInfoList)model3d;
for (var triangleIndex = 0; triangleIndex < triangles.Count; triangleIndex++)
{
foreach (var triangle in triangles[triangleIndex])
{
var p1 = new Vector3Class(triangle.Vectors[0].Position.X, triangle.Vectors[0].Position.Y, 0);
var p2 = new Vector3Class(triangle.Vectors[1].Position.X, triangle.Vectors[1].Position.Y, 0);
var p3 = new Vector3Class(triangle.Vectors[2].Position.X, triangle.Vectors[2].Position.Y, 0);
var movedTriangle = new TriangleIntersection();
movedTriangle.Vectors[0].Position = p1;
movedTriangle.Vectors[1].Position = p2;
movedTriangle.Vectors[2].Position = p3;
if (PointInsideTriangle(new Vector3Class(center.X, center.Y, 0), movedTriangle))
{
movedTriangle.Vectors[0].Position.Z = triangle.Vectors[0].Position.Z;
movedTriangle.Vectors[1].Position.Z = triangle.Vectors[1].Position.Z;
movedTriangle.Vectors[2].Position.Z = triangle.Vectors[2].Position.Z;
movedTriangle.CalcCenter();
movedTriangle.CalcNormal();
movedTriangle.Flip();
//if (!directionUP) { movedTriangle.Flip(); }
var edge1 = movedTriangle.Vectors[1].Position - movedTriangle.Vectors[0].Position;
var edge2 = movedTriangle.Vectors[2].Position - movedTriangle.Vectors[0].Position;
var originNormal = Vector3Class.Cross(centerNormal, edge2);
float det = Vector3Class.Dot(edge1, originNormal); //determined of matrix
if (det == 0)
{
break;
}
float invDet = 1 / det; //invert matrix
var s = center - movedTriangle.Vectors[0].Position;
var u = Vector3Class.Dot(s, originNormal) * invDet; //barycentric coordinates
if (u < 0 || u > 1)
{
break;
}
var qvec = Vector3Class.Cross(s, edge1);
var v = Vector3Class.Dot(centerNormal, qvec) * invDet; //barycentric coordinates
if (v < 0 || u + v > 1)
{
break;
}
var t = Vector3Class.Dot(edge2, qvec) * invDet; //distince of intersection point
movedTriangle.IntersectionPoint.Z = t;
intersectedTriangles[0].Add(movedTriangle);
}
}
}
}
return(intersectedTriangles);
}
public static List <Vector3Class> IntersectTriangles(Vector3Class origin, Vector3Class direction, TriangleInfoList triangles, typeDirection directionType)
{
var intersectionPoints = new List <Vector3Class>();
for (var arrayIndex = 0; arrayIndex < triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < triangles[arrayIndex].Count; triangleIndex++)
{
var triangle = triangles[arrayIndex][triangleIndex];
if (triangle.Center != origin)
{
if (direction.Z == 1 || direction.Z == -1)
{
if (!((triangle.Left <= origin.X && triangle.Right >= origin.X) && (triangle.Back <= origin.Y && triangle.Front >= origin.Y)))
{
continue;
}
}
//do translation off vector
var p1 = triangle.Vectors[0].Position;
var p2 = triangle.Vectors[1].Position;
var p3 = triangle.Vectors[2].Position;
float nDotD = Vector3Class.Dot(triangle.Normal, direction);
if (nDotD != 0)
{
// if (nDotD < 0)nDotD = 0 - nDotD;
float d = Vector3Class.Dot(triangle.Normal, p1);
float t = -(Vector3Class.Dot(triangle.Normal, origin) + d) / nDotD;
Vector3Class planeIntersection = new Vector3Class();
if (nDotD < 0)
{
t = -(Vector3Class.Dot(-triangle.Normal, origin) + d) / -nDotD;
planeIntersection = origin + (direction * t);
}
else if (directionType == typeDirection.TwoWay)
{
planeIntersection = origin + (direction * t);
}
for (var i = 0; i < 2; i++)
{
//pass 1
if (i == 0)
{
if (Vector3Class.Dot(Vector3Class.Cross(p1 - p3, planeIntersection - p3), direction) > 0)
{
continue;
}
if (Vector3Class.Dot(Vector3Class.Cross(p2 - p1, planeIntersection - p1), direction) > 0)
{
continue;
}
if (Vector3Class.Dot(Vector3Class.Cross(p3 - p2, planeIntersection - p2), direction) > 0)
{
continue;
}
}
else
{
if (Vector3Class.Dot(Vector3Class.Cross(p1 - p3, planeIntersection - p3), direction) < 0)
{
continue;
}
if (Vector3Class.Dot(Vector3Class.Cross(p2 - p1, planeIntersection - p1), direction) < 0)
{
continue;
}
if (Vector3Class.Dot(Vector3Class.Cross(p3 - p2, planeIntersection - p2), direction) < 0)
{
continue;
}
}
if (intersectionPoints == null)
{
intersectionPoints = new List <Vector3Class>();
}
intersectionPoints.Add(planeIntersection);
}
}
}
}
}
return(intersectionPoints);
}
internal static Dictionary <TriangleConnectionInfo, bool> GetConnectedMesh(TriangleConnectionInfo parentTriangle, Dictionary <TriangleConnectionInfo, bool> availableConnections, TriangleInfoList triangles)
{
var connectedTriangles = new Dictionary <TriangleConnectionInfo, bool>();
//if (triangles.Connections.Count == 0)
//{
// triangles.UpdateConnections();
//}
if (availableConnections.Count == 1)
{
connectedTriangles.Add(availableConnections.ElementAt(0).Key, false);
}
else
{
var foundChildConnections = GetConnectedTriangles(new List <TriangleConnectionInfo>()
{
parentTriangle
}, availableConnections, triangles, connectedTriangles);
while (foundChildConnections.Count > 0)
{
foundChildConnections = GetConnectedTriangles(foundChildConnections, availableConnections, triangles, connectedTriangles);
}
}
return(connectedTriangles);
}
internal static List <TriangleConnectionInfo> GetConnectedTriangles(List <TriangleConnectionInfo> parentConnections, Dictionary <TriangleConnectionInfo, bool> availableConnections, TriangleInfoList triangles, Dictionary <TriangleConnectionInfo, bool> connectedTriangles)
{
var foundChildConnections = new List <TriangleConnectionInfo>();
try
{
foreach (var parentConnection in parentConnections)
{
var childConnections = triangles.GetConnectedTriangles(parentConnection);
foreach (var childConnection in childConnections)
{
if (availableConnections.ContainsKey(childConnection))
{
if (!connectedTriangles.ContainsKey(childConnection))
{
connectedTriangles.Add(childConnection, false);
availableConnections.Remove(childConnection);
foundChildConnections.Add(childConnection);
}
}
}
}
}
catch (Exception exc)
{
LoggingManager.WriteToLog("Exception Manager", "GetConnectedTriangles", exc.StackTrace);
}
return(foundChildConnections);
}
