internal void FilterSupportCones()
{
//find all available overhangdistancefactors
var availableOverhangDistanceFactors = new SortedList <float, bool>();
foreach (var surfaceIntersectionData in this.SupportCones.Keys)
{
if (!availableOverhangDistanceFactors.ContainsKey(surfaceIntersectionData.OverhangDistance))
{
availableOverhangDistanceFactors.Add(surfaceIntersectionData.OverhangDistance, false);
}
}
var currentDistanceIndex = 0;
//find all support cones that are lower
while (currentDistanceIndex < availableOverhangDistanceFactors.Count - 2)
{
var currentDistanceOverhangFactor = availableOverhangDistanceFactors.ElementAt(currentDistanceIndex).Key;
var currentSupportConesWithSameOverhangDistance = new Dictionary <MagsAISurfaceIntersectionData, SupportCone>();
var currentSupportConesWithLargerOverhangDistance = new Dictionary <MagsAISurfaceIntersectionData, SupportCone>();
foreach (var surfaceIntersectionData in this.SupportCones.Keys)
{
if (surfaceIntersectionData.OverhangDistance > currentDistanceOverhangFactor && surfaceIntersectionData.Filter == typeOfAutoSupportFilter.None)
{
currentSupportConesWithLargerOverhangDistance.Add(surfaceIntersectionData, this.SupportCones[surfaceIntersectionData]);
}
else if (surfaceIntersectionData.OverhangDistance == currentDistanceOverhangFactor && surfaceIntersectionData.Filter == typeOfAutoSupportFilter.None)
{
currentSupportConesWithSameOverhangDistance.Add(surfaceIntersectionData, this.SupportCones[surfaceIntersectionData]);
}
}
//find all support cones with larger distance factor that are below current support cone and within range
foreach (var currentSupportConeWithSameOverhangDistance in currentSupportConesWithSameOverhangDistance)
{
var intersectedSupportCones = new Dictionary <MagsAISurfaceIntersectionData, SupportCone>();
foreach (var currentSupportConeWithLargerOverhangDistance in currentSupportConesWithLargerOverhangDistance)
{
if (currentSupportConeWithLargerOverhangDistance.Key.SliceHeight <= currentSupportConeWithSameOverhangDistance.Key.SliceHeight)
{
intersectedSupportCones.Add(currentSupportConeWithLargerOverhangDistance.Key, currentSupportConeWithLargerOverhangDistance.Value);
}
}
//calc support cone contour
var currentSupportConeWithSameOverhangDistanceContour = MagsAIEngine.ConvertSupportPointsToCircles(currentSupportConeWithSameOverhangDistance.Key.TopPoint, 5);
foreach (var intersectedSupportCone in intersectedSupportCones.Keys)
{
if (Clipper.PointInPolygon(intersectedSupportCone.TopPoint, currentSupportConeWithSameOverhangDistanceContour) != 0)
{
intersectedSupportCone.Filter = typeOfAutoSupportFilter.FilteredBySupportConeOverhangWithinRange; //using internal references to update this.supportcones.keys
}
}
}
currentDistanceIndex++;
}
}
private void TbWizard_SelectedIndexChanged(object sender, EventArgs e)
{
if (tbWizard.SelectedTab == this.tbMagsAIOrientation)
{
var stlModel = ObjectView.Objects3D[1] as STLModel3D;
stlModel.Triangles.UpdateConnections();
this.magsAIOrientationTabPanel1.GLControl.Render();
}
else if (tbWizard.SelectedTab == this.tbPreview)
{
this.magsAIPreview1.GLControl.Render();
var stlModel = ObjectView.Objects3D[1] as STLModel3D;
Task.Run(() => MagsAIEngine.Calculate(stlModel, this.magsAIMaterialTabPanel1.SelectedMaterial, this.magsAIMaterialTabPanel1.SelectedPrinter));
}
}
private void CalcTrianglesWithinRange(Vector3Class supportPointPosition, SupportProfile selectedMaterialProfile, STLModel3D stlModel)
{
var boundryOffset = selectedMaterialProfile.SupportOverhangDistance;
var modelTrianglesLeftBoundry = supportPointPosition.X - boundryOffset;
var modelTrianglesRightBoundry = supportPointPosition.X + boundryOffset;
var modelTrianglesBackBoundry = supportPointPosition.Y - boundryOffset;
var modelTrianglesFrontBoundry = supportPointPosition.Y + boundryOffset;
var currentSupportConeSupportedLayer = MagsAIEngine.ConvertSupportPointsToCircles(new IntPoint(supportPointPosition), selectedMaterialProfile.SupportOverhangDistance);
currentSupportConeSupportedLayer.Add(new IntPoint(supportPointPosition));
this._trianglesWithinXYRange = new STLModel3D
{
Triangles = stlModel.Triangles.GetTrianglesWithinXYBoundry(modelTrianglesLeftBoundry, modelTrianglesBackBoundry, modelTrianglesRightBoundry, modelTrianglesFrontBoundry)
};
}
internal void CalcPolyNode(SupportProfile selectedMaterialProfile, AtumPrinter selectedPrinter, float sliceHeight, int objectIndex)
{
this.PolyTree = new PolyTree();
var polygonPoints = new List <IntPoint>();
foreach (var polyLinePart in this)
{
var tStart = (polyLinePart.P1 - new Vector3Class(selectedPrinter.ProjectorResolutionX / 2, selectedPrinter.ProjectorResolutionY / 2, 0)) / 10f;
tStart -= new Vector3Class(0.1f, 0.1f, 0);
DebugPoints.Add(tStart);
polygonPoints.Add(new IntPoint(tStart + new Vector3Class(0, 0, sliceHeight)));
}
//add the end of the line
var tEnd = (this.Last().P2 - new Vector3Class(selectedPrinter.ProjectorResolutionX / 2, selectedPrinter.ProjectorResolutionY / 2, 0)) / 10f;
tEnd -= new Vector3Class(0.1f, 0.1f, 0);
polygonPoints.Add(new IntPoint(tEnd));
//when not closed use normals to create offset points
if (!ClosedLine)
{
this.Reverse();
// this.Reverse();
var normalVector = new Vector3Class();
foreach (var polyLinePart in this)
{
normalVector += polyLinePart.Normal;
normalVector.Z = 0;
normalVector.Normalize();
normalVector *= selectedMaterialProfile.SupportOverhangDistance / 2;
//do point offset
var tPoint = normalVector + ((polyLinePart.P1 - new Vector3Class(selectedPrinter.ProjectorResolutionX / 2, selectedPrinter.ProjectorResolutionY / 2, 0)) / 10f);
tPoint -= new Vector3Class(0.1f, 0.1f, 0);
DebugPoints.Add(tPoint + new Vector3Class(0, 0, sliceHeight));
polygonPoints.Add(new IntPoint(tPoint));
normalVector = polyLinePart.Normal;
}
var polyTreeOffset = new PolyTree();
var polyNode = new PolyNode();
polyNode.m_polygon = polygonPoints;
polyTreeOffset._allPolys.Add(polyNode);
var c = new Clipper();
c.AddPath(polyTreeOffset._allPolys[0].Contour, PolyType.ptClip, true);
c.AddPath(new List <IntPoint>(), PolyType.ptSubject, true);
c.Execute(ClipType.ctXor, this.PolyTree, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd);
//if (sliceHeight >=13 && sliceHeight <=15f)
// TriangleHelper.SavePolyNodesContourToPng(this.PolyTree._allPolys, sliceHeight.ToString("0.00") + "-" + objectIndex.ToString() + "-t2");
}
else
{
var polyTreeOffset = new PolyTree();
var polyNode = new PolyNode();
polyNode.m_polygon = polygonPoints;
polyTreeOffset._allPolys.Add(polyNode);
polyTreeOffset = MagsAIEngine.ClipperOffset(polyTreeOffset, selectedMaterialProfile.SupportOverhangDistance / 2);
if (polyTreeOffset._allPolys.Count > 0)
{
var c = new Clipper();
c.AddPath(polygonPoints, PolyType.ptClip, true);
c.AddPath(polyTreeOffset._allPolys[0].Contour, PolyType.ptClip, true);
c.AddPath(new List <IntPoint>(), PolyType.ptSubject, true);
c.Execute(ClipType.ctXor, this.PolyTree, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd);
}
}
}
internal void UpdateLastSupportedHeight(STLModel3D stlModel, SupportProfile selectedMaterialProfile, SortedDictionary <float, PolyTree> modelLayers)
{
//find latest supportcone supported height
var supportPointPosition = this.TopPoint;
supportPointPosition.Z = this.SliceHeight - 1;
if (this._trianglesWithinXYRange == null)
{
CalcTrianglesWithinRange(supportPointPosition, selectedMaterialProfile, stlModel);
}
var trianglesAboveSupportPoint = new STLModel3D()
{
Triangles = new TriangleInfoList()
};
trianglesAboveSupportPoint.Triangles[0] = this._trianglesWithinXYRange.Triangles[0].Where(s => s.Bottom > supportPointPosition.Z && s.Normal.Z > 0).ToList();
var maxLayerHeight = float.MinValue;
var currentSupportConeSupportedLayer = MagsAIEngine.ConvertSupportPointsToCircles(new IntPoint(supportPointPosition), selectedMaterialProfile.SupportOverhangDistance);
currentSupportConeSupportedLayer.Add(new IntPoint(supportPointPosition));
foreach (var t in currentSupportConeSupportedLayer)
{
TriangleIntersection[] trianglesIntersected = null;
IntersectionProvider.IntersectTriangle(t.AsVector3(), new Vector3Class(0, 0, -1), trianglesAboveSupportPoint, IntersectionProvider.typeDirection.OneWay, false, new Vector3Class(), out trianglesIntersected);
var nearestTriangleIntersection = float.MaxValue;
TriangleIntersection nearestIntersectionPoint = null;
if (trianglesIntersected != null)
{
foreach (var triangleIntersected in trianglesIntersected)
{
if (triangleIntersected != null)
{
if (triangleIntersected.IntersectionPoint.Z >= this.SliceHeight)
{
var distance = (new Vector3Class(supportPointPosition.X, supportPointPosition.Y, triangleIntersected.IntersectionPoint.Z) - supportPointPosition).Length;
if (distance < nearestTriangleIntersection)
{
nearestTriangleIntersection = distance;
nearestIntersectionPoint = triangleIntersected;
}
}
}
}
}
if (nearestIntersectionPoint != null && nearestIntersectionPoint.IntersectionPoint.Z > maxLayerHeight)
{
maxLayerHeight = nearestIntersectionPoint.IntersectionPoint.Z;
}
}
if (maxLayerHeight == float.MinValue)
{
maxLayerHeight = 10000;
}
this.LastSupportedSliceHeight = maxLayerHeight;
}
internal Dictionary <IntPoint, MagsAISurfaceIntersectionData> CalcSupportPoints(SortedDictionary <float, PolyTree> modelLayers, ConcurrentDictionary <float, ConcurrentDictionary <MagsAIIntersectionData, bool> > currentModelSupportPoints, float firstSurfaceAngleDistanceFactor, SupportProfile selectedMaterialProfile, float overhangFactor, ConcurrentDictionary <float, ConcurrentDictionary <float, ConcurrentDictionary <IntPoint, MagsAISurfaceIntersectionData> > > previousOverhangDistanceFactorBasedSupportPoints, STLModel3D stlModel, TriangleSurfaceInfo surface)
{
this.AddedSupportPoints = new Dictionary <IntPoint, MagsAISurfaceIntersectionData>();
this.AddedSupportPointsByLayer = new Dictionary <float, Dictionary <IntPoint, MagsAISurfaceIntersectionData> >();
//create support cones that exists in each layer
var previousSliceHeight = float.MaxValue;
foreach (var sliceHeight in this.ModelContours.Keys.OrderBy(s => s))
{
var sliceContours = this.ModelContours[sliceHeight];
sliceContours = ContourHelper.IntersectModelSliceLayer(sliceContours, modelLayers[sliceHeight]); //create contour offset using max border as model contour instead of extrude contour
if (!this.AddedSupportPointsByLayer.ContainsKey(sliceHeight))
{
this.AddedSupportPointsByLayer.Add(sliceHeight, new Dictionary <IntPoint, MagsAISurfaceIntersectionData>());
}
if (previousSliceHeight != float.MaxValue)
{
var supportedLayerAsPolyTree = new PolyTree();
if (this.AddedSupportPointsByLayer.ContainsKey(previousSliceHeight))
{
foreach (var supportIntersectionData in this.AddedSupportPointsByLayer[previousSliceHeight].Values)
{
if (supportIntersectionData.UnsupportedContour)
{
this.AddedSupportPointsByLayer[sliceHeight].Add(supportIntersectionData.TopPoint, supportIntersectionData);
}
}
}
//added support circles from current diff layer with overhang distance
foreach (var overhangDistanceFactor in previousOverhangDistanceFactorBasedSupportPoints)
{
var previousAngleBasedSupportPointsAsCircles = new List <List <IntPoint> >();
if (overhangDistanceFactor.Value.ContainsKey(sliceHeight))
{
foreach (var previousAngleBasedSupportPoint in overhangDistanceFactor.Value[sliceHeight].Values)
{
AddPointToCurrentLayerWhenExistsInContour(sliceContours, previousAngleBasedSupportPoint, sliceHeight);
}
}
}
//check if supportcones where allready added using other algorithms
var supportSliceHeightsWithinRange = new List <float>()
{
(float)Math.Round(previousSliceHeight - (sliceHeight - previousSliceHeight), 2), sliceHeight
};
var supportSliceHeightsWithinRangeMin = supportSliceHeightsWithinRange[0];
var supportSliceHeightsWithinRangeMax = supportSliceHeightsWithinRange[1];
foreach (var supportPointIndex in currentModelSupportPoints)
{
foreach (var supportPointValue in supportPointIndex.Value.Keys)
{
if (supportPointValue.SliceHeight <= sliceHeight && supportPointValue.LastSupportSliceHeight >= supportSliceHeightsWithinRangeMin)
{
var supportSlicePointAsIntPoint = new IntPoint(supportPointValue.TopPoint);
if (!this.AddedSupportPointsByLayer[sliceHeight].ContainsKey(supportSlicePointAsIntPoint))
{
var supportConePoint2 = new MagsAISurfaceIntersectionData();
supportConePoint2.TopPoint = supportSlicePointAsIntPoint;
supportConePoint2.SliceHeight = sliceHeight;
supportConePoint2.OverhangDistanceFactor = firstSurfaceAngleDistanceFactor;
supportConePoint2.ModelIntersection = supportPointValue.ModelIntersection;
supportConePoint2.LastSupportSliceHeight = supportPointValue.LastSupportSliceHeight;
this.AddedSupportPointsByLayer[sliceHeight].Add(supportConePoint2.TopPoint, supportConePoint2);
}
}
}
}
//combine all previous found points
supportedLayerAsPolyTree = new PolyTree();
if (AddedSupportPointsByLayer.ContainsKey(sliceHeight))
{
var supportCircles = new List <List <IntPoint> >();
foreach (var addedSupportPointByLayer in AddedSupportPointsByLayer[sliceHeight].Values)
{
var outlineCirclePoints = MagsAIEngine.ConvertSupportPointsToCircles(addedSupportPointByLayer.TopPoint, selectedMaterialProfile.SupportOverhangDistance);
supportCircles.Add(outlineCirclePoints);
var outlineCirclePolygon = MagsAIEngine.MergeSupportCircles(new List <List <IntPoint> >()
{
outlineCirclePoints
});
var intersectedPolygons = ContourHelper.IntersectModelSliceLayer(ModelContours[sliceHeight], outlineCirclePolygon);
var intersectedPolygonFound = false;
foreach (var intersectedPolygon in intersectedPolygons._allPolys.Where(s => !s.IsHole))
{
if (ContourHelper.PointExistsInNotHolePolygon(intersectedPolygon, addedSupportPointByLayer.TopPoint))
{
supportedLayerAsPolyTree._allPolys.Add(intersectedPolygon);
break;
}
}
//check if intersected triangle is part of angle surface
if (!intersectedPolygonFound)
{
//check if triangle index is in surface
var pointFound = false;
foreach (var surfaceConnection in surface.Keys)
{
if (addedSupportPointByLayer.ModelIntersection != null)
{
if (surfaceConnection.ArrayIndex == addedSupportPointByLayer.ModelIntersection.Index.ArrayIndex && surfaceConnection.TriangleIndex == addedSupportPointByLayer.ModelIntersection.Index.TriangleIndex)
{
foreach (var intersectedPolygon in intersectedPolygons._allPolys.Where(s => !s.IsHole))
{
supportedLayerAsPolyTree._allPolys.Add(intersectedPolygon);
pointFound = true;
}
break;
}
}
}
if (!pointFound)
{
}
}
}
// TriangleHelper.SavePolyNodesContourToPng(ModelContours[sliceHeight]._allPolys, surface.Id.ToString("00") + "-" + sliceHeight.ToString("0.00") + "-" + overhangFactor.ToString(".00") + "-model");
// TriangleHelper.SavePolyNodesContourToPng(intersectedPolygons._allPolys, surface.Id.ToString("00") + "-" + sliceHeight.ToString("0.00") + "-" + overhangFactor.ToString(".00") + "-intersected");
//TriangleHelper.SavePolyNodesContourToPng(MagsAIEngine.MergeSupportCircles(supportCircles)._allPolys, surface.Id.ToString("00") + "-" + sliceHeight.ToString("0.00") + "-" + overhangFactor.ToString(".00") + "-supportcircles");
supportedLayerAsPolyTree = UnionModelSliceLayer(new PolyTree(), supportedLayerAsPolyTree);
//TriangleHelper.SavePolyNodesContourToPng(supportedLayerAsPolyTree._allPolys, surface.Id.ToString("00") + "-" + sliceHeight.ToString("0.00") + "-" + overhangFactor.ToString(".00") + "-supportedlayer");
}
// this.SupportedLayers.Add(sliceHeight, supportedLayerAsPolyTree);
var unsupportedLayer = DifferenceModelSliceLayer(sliceContours, supportedLayerAsPolyTree);
////if (sliceHeight >= 15f && sliceHeight <= 16f)
// {
foreach (var verticalSurface in stlModel.Triangles.MagsAIVerticalSurfaces)
{
verticalSurface.UpdateBoundries(stlModel.Triangles);
if (verticalSurface.BottomPoint <= this.BottomPoint)
{
foreach (var workingSliceHeight in verticalSurface.VerticalSurfaceModelPolygons.Keys)
{
if (workingSliceHeight >= previousSliceHeight - 0.4f && workingSliceHeight <= sliceHeight)
{
//TriangleHelper.SavePolyNodesContourToPng(verticalSurface.VerticalSurfaceModelPolygons[workingSliceHeight]._allPolys, sliceHeight.ToString("0.00") + "-" + workingSliceHeight + "-subtract-vertical-contour");
unsupportedLayer = DifferenceModelSliceLayer(unsupportedLayer, verticalSurface.VerticalSurfaceModelPolygons[workingSliceHeight]);
// TriangleHelper.SavePolyNodesContourToPng(unsupportedLayer._allPolys, sliceHeight.ToString("0.00") + "-unsupported-vertical-contour");
}
}
}
}
//}
//remove supportedLayer from current diff layer and previous found support points
//TriangleHelper.SavePolyNodesContourToPng(unsupportedLayer._allPolys, surface.Id.ToString("00") + "-" + sliceHeight.ToString(".00") + "-" + overhangFactor.ToString(".00") + "-surface-unsupported");
if (unsupportedLayer._allPolys.Count > 0)
{
while (unsupportedLayer._allPolys.Where(s => !s.IsHole).Count() > 0)
{
var skippedUnsupportedLayerPolyNodes = new List <PolyNode>();
foreach (var unsupportLayerHole in unsupportedLayer._allPolys.Where(s => s.IsHole))
{
skippedUnsupportedLayerPolyNodes.Add(unsupportLayerHole);
}
foreach (var areaToSmallPolygon in unsupportedLayer._allPolys.Where(s => !s.IsHole))
{
if ((Clipper.Area(areaToSmallPolygon.Contour) / (CONTOURPOINT_TO_VECTORPOINT_FACTOR * CONTOURPOINT_TO_VECTORPOINT_FACTOR)) < 2)
{
skippedUnsupportedLayerPolyNodes.Add(areaToSmallPolygon);
}
}
foreach (var removePolygon in skippedUnsupportedLayerPolyNodes)
{
unsupportedLayer._allPolys.Remove(removePolygon);
}
skippedUnsupportedLayerPolyNodes.Clear();
foreach (var unsupportedLayerPolyNode in unsupportedLayer._allPolys)
{
var contourPolyTree = new PolyTree();
contourPolyTree._allPolys.Add(unsupportedLayerPolyNode);
//TriangleHelper.SavePolyNodesContourToPng(contourPolyTree._allPolys, "b");
var supportConeIntersections = MagsAIEngine.CalcContourSupportStructure(contourPolyTree, null, null, selectedMaterialProfile, sliceHeight, this, true, false);
if (supportConeIntersections.Count > 0)
{
var supportConeIntersectionPolyTree = new PolyTree();
foreach (var supportConeIntersection in supportConeIntersections)
{
if (supportConeIntersection.LowestPoints.Count == 0)
{
skippedUnsupportedLayerPolyNodes.Add(unsupportedLayerPolyNode);
}
else
{
var k = 0;
foreach (var supportConeIntersectionPoint in supportConeIntersection.LowestPoints)
{
var supportConeIntersectionPointAsIntPoint = supportConeIntersectionPoint.Point;
supportConeIntersectionPointAsIntPoint.Z = (int)(sliceHeight * CONTOURPOINT_TO_VECTORPOINT_FACTOR);
var addedSupportPoint = new MagsAISurfaceIntersectionData()
{
TopPoint = supportConeIntersectionPointAsIntPoint, SliceHeight = sliceHeight
};
addedSupportPoint.OverhangDistanceFactor = selectedMaterialProfile.SupportOverhangDistance * overhangFactor;
var outlineCirclePoints = MagsAIEngine.ConvertSupportPointsToCircles(supportConeIntersectionPointAsIntPoint, selectedMaterialProfile.SupportOverhangDistance * overhangFactor);
var outlineCirclePolygon = MagsAIEngine.MergeSupportCircles(new List <List <IntPoint> >()
{
outlineCirclePoints
});
var intersectedPolygons = ContourHelper.IntersectModelSliceLayer(ModelContours[sliceHeight], outlineCirclePolygon);
var intersectionPointFound = false;
foreach (var intersectedPolygon in intersectedPolygons._allPolys.Where(s => !s.IsHole))
{
if (ContourHelper.PointExistsInNotHolePolygon(intersectedPolygon, addedSupportPoint.TopPoint))
{
supportConeIntersectionPolyTree._allPolys.Add(intersectedPolygon);
intersectionPointFound = true;
}
}
if (!intersectionPointFound)
{
foreach (var intersectedPolygon in intersectedPolygons._allPolys.Where(s => !s.IsHole))
{
supportConeIntersectionPolyTree._allPolys.Add(intersectedPolygon);
}
}
// TriangleHelper.SavePolyNodesContourToPng(outlineCirclePolygon._allPolys, sliceHeight.ToString("0.00") + "-" + k.ToString());
addedSupportPoint.UpdateLastSupportedHeight(stlModel);
addedSupportPoint.UpdateTriangleReference(stlModel);
if (!this.AddedSupportPoints.ContainsKey(addedSupportPoint.TopPoint))
{
this.AddedSupportPoints.Add(addedSupportPoint.TopPoint, addedSupportPoint);
}
if (!this.AddedSupportPointsByLayer[sliceHeight].ContainsKey(addedSupportPoint.TopPoint))
{
addedSupportPoint.UnsupportedContour = true;
this.AddedSupportPointsByLayer[sliceHeight].Add(addedSupportPoint.TopPoint, addedSupportPoint);
}
k++;
}
}
if (supportConeIntersectionPolyTree._allPolys.Count > 0)
{
unsupportedLayer = DifferenceModelSliceLayer(unsupportedLayer, supportConeIntersectionPolyTree);
// TriangleHelper.SavePolyNodesContourToPng(unsupportedLayer._allPolys, "s");
break;
}
}
}
}
if (skippedUnsupportedLayerPolyNodes.Count > 0)
{
foreach (var skippedUnsuppertedLayerPolyNode in skippedUnsupportedLayerPolyNodes)
{
unsupportedLayer._allPolys.Remove(skippedUnsuppertedLayerPolyNode);
}
}
}
}
previousSliceHeight = sliceHeight;
}
if (previousSliceHeight == float.MaxValue)
{
previousSliceHeight = sliceHeight;
}
}
return(this.AddedSupportPoints);
}
internal void UpdateLastSupportedHeight(STLModel3D stlModel, SortedDictionary <float, PolyTree> modelAngleLayers, SupportProfile selectedMaterialProfile)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (this.Id == null || this.Id == Guid.Empty)
{
this.Id = Guid.NewGuid();
}
//find latest supportcone supported height
TriangleIntersection[] trianglesIntersected = null;
var supportPointPosition = this.TopPoint.AsVector3();
supportPointPosition.Z = this.SliceHeight;
var currentSupportConeSupportedLayer = MagsAIEngine.ConvertSupportPointsToCircles(this.TopPoint, this.OverhangDistance * this.SupportOverhangDistanceFactor);
currentSupportConeSupportedLayer.Add(this.TopPoint);
if (this._trianglesWithinXYRange == null)
{
CalcTrianglesWithinRange(supportPointPosition, selectedMaterialProfile, stlModel);
}
var trianglesAboveSupportPoint = new STLModel3D()
{
Triangles = new TriangleInfoList()
};
trianglesAboveSupportPoint.Triangles[0] = this._trianglesWithinXYRange.Triangles[0].Where(s => s.Bottom > supportPointPosition.Z && s.Normal.Z > 0).ToList();
//IntersectionProvider.IntersectTriangle(supportPointPosition, new Vector3Class(0, 0, -1), trianglesAboveSupportPoint, IntersectionProvider.typeDirection.OneWay, false, new Vector3Class(), out trianglesIntersected);
//if (trianglesIntersected != null)
//{
// var nearestLastSupportedHeight = new Vector3Class();
// var nearestLastSupportedHeightDistance = float.MaxValue;
// foreach (var triangleIntersection in trianglesIntersected)
// {
// if (triangleIntersection != null)
// {
// var distance = (triangleIntersection.IntersectionPoint - supportPointPosition).Length;
// if (distance < nearestLastSupportedHeightDistance)
// {
// nearestLastSupportedHeightDistance = distance;
// nearestLastSupportedHeight = triangleIntersection.IntersectionPoint;
// }
// }
// }
// if (nearestLastSupportedHeight != new Vector3Class())
// {
// this.LastSupportedCenterSliceHeight = nearestLastSupportedHeight.Z;
// }
//}
////determine the last supported slice height using the half of material overhangdistance and removing the layers above
//if (this.LastSupportedCenterAngle == 0f)
//{
// this.UpdateTriangleReference(stlModel, selectedMaterialProfile);
//}
var maxLayerHeight = float.MinValue;
foreach (var t in currentSupportConeSupportedLayer)
{
var tAsVector = t.AsVector3();
tAsVector.Z = 1000;
TriangleIntersection[] trianglesIntersected2 = null;
IntersectionProvider.IntersectTriangle(tAsVector, new Vector3Class(0, 0, -1), trianglesAboveSupportPoint, IntersectionProvider.typeDirection.OneWay, false, new Vector3Class(), out trianglesIntersected2);
var nearestTriangleIntersection = float.MaxValue;
TriangleIntersection nearestIntersectionPoint = null;
if (trianglesIntersected2 != null)
{
foreach (var triangleIntersected in trianglesIntersected2)
{
if (triangleIntersected != null)
{
if (triangleIntersected.IntersectionPoint.Z >= this.SliceHeight)
{
var distance = (triangleIntersected.IntersectionPoint - supportPointPosition).Length;
if (distance < nearestTriangleIntersection)
{
nearestTriangleIntersection = distance;
nearestIntersectionPoint = triangleIntersected;
}
}
}
}
}
if (nearestIntersectionPoint != null && nearestIntersectionPoint.IntersectionPoint.Z > maxLayerHeight)
{
maxLayerHeight = nearestIntersectionPoint.IntersectionPoint.Z;
}
}
if (maxLayerHeight == float.MinValue)
{
maxLayerHeight = 10000;
}
this.LastSupportedSliceHeight = maxLayerHeight;
// Console.WriteLine("SurfaceIntersectionData: Measurement 2: " + maxLayerHeight);
// Console.WriteLine("SurfaceIntersectionData: Measurement 2: " + stopwatch.ElapsedMilliseconds + "ms");
}
