internal static void CalculateByModel(STLModel3D model, AtumPrinter selectedPrinter)
{
//convert polynode to pixel values
for (var arrayIndex = 0; arrayIndex < model.Triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < model.Triangles[arrayIndex].Count; triangleIndex++)
{
for (var vectorIndex = 0; vectorIndex < 3; vectorIndex++)
{
var pixelPoint = Helpers.VectorHelper.GetPixelPointFromModelPoint(model.Triangles[arrayIndex][triangleIndex].Points[vectorIndex], selectedPrinter);
var pixelPointX = (int)Math.Round(pixelPoint.X, 0);
var pixelPointY = (int)Math.Round(pixelPoint.Y, 0);
//transform pixelPoint
if (pixelPointX >= selectedPrinter.ProjectorResolutionX)
{
pixelPointX = selectedPrinter.ProjectorResolutionX - 1;
}
if (pixelPointY >= selectedPrinter.ProjectorResolutionY)
{
pixelPointY = selectedPrinter.ProjectorResolutionY - 1;
}
var transformedPixelPoint = selectedPrinter.LensWarpingCorrection.TransformationVectors[pixelPointX, pixelPointY];
pixelPoint = new Vector3Class(transformedPixelPoint.X, transformedPixelPoint.Y, pixelPoint.Z);
//pixelPoint to 3d space point
var modelPoint = Helpers.VectorHelper.GetModelPointFromPixelPoint(pixelPoint, selectedPrinter);
model.Triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position = modelPoint;
}
}
}
}
/*
* Return a list of polygons that intersect at this zlevel
*/
internal static List <Triangle> GetZPolys(STLModel3D stlModel, SortedDictionary <float, List <TriangleConnectionInfo> > indexKeys, float sliceHeightAsFloat)
{
var sliceHeight = (float)Math.Round(sliceHeightAsFloat, 3);
var lst = new List <Triangle>();
//List<TriangleConnectionInfo> triangleConnections = null;
var indexKey = sliceHeight;
if (indexKeys != null && indexKeys.ContainsKey(sliceHeight))
{
}
else
{
foreach (var sliceHeightKey in indexKeys.Keys)
{
if (sliceHeightKey > sliceHeight)
{
sliceHeight = sliceHeightKey;
break;
}
}
}
if (indexKeys != null && indexKeys.ContainsKey(sliceHeight))
{
foreach (var sliceIndex in indexKeys[sliceHeight])
{
lst.Add(stlModel.Triangles[sliceIndex.ArrayIndex][sliceIndex.TriangleIndex]);
}
}
return(lst);
}
public BleedingModel(STLModel3D stlModel, double bleedingDistance)
{
this.Triangles = new TriangleInfoList();
for (var arrayIndex = 0; arrayIndex < stlModel.Triangles.Count; arrayIndex++)
{
if (arrayIndex > 0)
{
this.Triangles.Add(new List <Triangle>());
}
for (var triangleIndex = 0; triangleIndex < stlModel.Triangles[arrayIndex].Count; triangleIndex++)
{
var fBleedingOffset = (float)bleedingDistance;
this.Triangles[arrayIndex].Add((Triangle)stlModel.Triangles[arrayIndex][triangleIndex].Clone());
this.Triangles[arrayIndex][triangleIndex].Vectors[0].Color = new Structs.Byte4(new byte[] { 255, 255, 0, 0 });
this.Triangles[arrayIndex][triangleIndex].Vectors[0].Position.Z -= fBleedingOffset;
this.Triangles[arrayIndex][triangleIndex].Vectors[1].Color = new Structs.Byte4(new byte[] { 255, 255, 0, 0 });
this.Triangles[arrayIndex][triangleIndex].Vectors[1].Position.Z -= fBleedingOffset;
this.Triangles[arrayIndex][triangleIndex].Vectors[2].Color = new Structs.Byte4(new byte[] { 255, 255, 0, 0 });
this.Triangles[arrayIndex][triangleIndex].Vectors[2].Position.Z -= fBleedingOffset;
this.Triangles[arrayIndex][triangleIndex].CalcMinMaxZ();
}
}
this.BindModel();
}
private static void ImportWorkspaceFile(object sender, DoWorkEventArgs args)
{
var fileName = ((List <object>)args.Argument)[0] as string;
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(WorkspaceFile));
WorkspaceFile workspaceFile = null;
frmStudioMain.SceneControl.DisableRendering();
using (var streamReader = new StreamReader(fileName))
{
workspaceFile = (WorkspaceFile)serializer.Deserialize(streamReader);
foreach (var object3d in workspaceFile.Objects)
{
var stlModel = new STLModel3D(STLModel3D.TypeObject.Model, ObjectView.BindingSupported, object3d, ObjectView.NextObjectIndex, false);
stlModel.Triangles.UpdateSelectedOrientationTriangles(stlModel);
stlModel.UpdateBoundries();
}
if (!string.IsNullOrEmpty(PrintJobManager.PrintjobName))
{
PrintJobManager.PrintjobName = workspaceFile.PrintJobName;
}
}
}
public void CreateOuterSupportStructure(STLModel3D stlModel, bool createOuterSupport, bool createInfillSupport, bool raiseOutersupportPointsChanged = true)
{
SupportEngine.CreateContourSupport(stlModel, this, createOuterSupport, createInfillSupport);
if (raiseOutersupportPointsChanged)
{
ContourOuterSupportPointsChanged?.Invoke(stlModel);
}
}
public List <SlicePolyLine3D> PostSlice(STLModel3D stlModel, float sliceHeight, PluginTypes.PostSliceActionType postSliceAction)
{
switch (postSliceAction)
{
case PluginTypes.PostSliceActionType.WarpCorrection:
return(Engines.RenderEngine.GetZIntersections(Engines.RenderEngine.GetZPolys(stlModel, stlModel.SliceIndexes, sliceHeight), sliceHeight));
}
return(new List <SlicePolyLine3D>());
}
public void CalcInfillSupportPoints(STLModel3D stlModel)
{
var decimalCorrectionFactor = 10000f;
if (this.InfillContour != null)
{
this.InfillContour.LeftPoint = 5000f;
this.InfillContour.RightPoint = -5000f;
this.InfillContour.BackPoint = 5000f;
this.InfillContour.FrontPoint = -5000f;
foreach (var infillSupportPoint in this.InfillContour.OuterPath)
{
this.InfillContour.LeftPoint = Math.Min(this.InfillContour.LeftPoint, infillSupportPoint.X / decimalCorrectionFactor);
this.InfillContour.RightPoint = Math.Max(this.InfillContour.RightPoint, infillSupportPoint.X / decimalCorrectionFactor);
this.InfillContour.BackPoint = Math.Min(this.InfillContour.BackPoint, infillSupportPoint.Y / decimalCorrectionFactor);
this.InfillContour.FrontPoint = Math.Max(this.InfillContour.FrontPoint, infillSupportPoint.Y / decimalCorrectionFactor);
}
//calc grid support points
var gridOffset = this.InfillDistanceFactor;
if (gridOffset > 0)
{
for (var gridPointX = 0f; gridPointX < (this.InfillContour.RightPoint - this.InfillContour.LeftPoint); gridPointX += gridOffset)
{
var pathPointX = (this.InfillContour.LeftPoint + gridPointX) * decimalCorrectionFactor;
for (var gridPointY = 0f; gridPointY < (this.InfillContour.FrontPoint - this.InfillContour.BackPoint); gridPointY += gridOffset)
{
var pathPointY = (this.InfillContour.BackPoint + gridPointY) * decimalCorrectionFactor;
var pathPoint = new Helpers.ContourHelper.IntPoint(pathPointX, pathPointY);
var isPointInOuterPath = Helpers.ContourHelper.Clipper.PointInPolygon(pathPoint, this.InfillContour.OuterPath);
if (isPointInOuterPath == -1 || isPointInOuterPath == 1)
{
var isPointInInnerPath = false;
foreach (var innerPath in this.InfillContour.InnerPaths)
{
if (Helpers.ContourHelper.Clipper.PointInPolygon(pathPoint, innerPath) == 1)
{
isPointInInnerPath = true;
break;
}
}
if (!isPointInInnerPath)
{
//this.InfillContour.SupportPoints.Add(new Vector3(pathPointX / decimalCorrectionFactor, pathPointY / decimalCorrectionFactor, this.OuterPoints[0].Z));
}
}
}
}
}
}
}
void CreateMeasureCube(Vector2 startPoint, string text, double width, double height)
{
//outerbox
var cubeModel = new STLModel3D(TypeObject.None, false);
//cubeModel = (new Cube(12.8f, 8f, 5f)).AsSTLModel3D(Managers.MaterialManager.DefaultMaterial);
var outerPath = new Polygon(new PolygonPoint(-(width / 2), -(height / 2)), new PolygonPoint((width / 2), -(height / 2)), new PolygonPoint((width / 2), (height / 2)), new PolygonPoint(-(width / 2), (height / 2)));
var textAsPolygonSet = new PolygonSet();
var letterPolygonsTop = FontTessellationEngine.ConvertStringToTrianglesWithOuterPath(text, FontStyle.Bold, outerPath, out textAsPolygonSet);
outerPath = new Polygon(new PolygonPoint(-(width / 2), -(height / 2)), new PolygonPoint((width / 2), -(height / 2)), new PolygonPoint((width / 2), (height / 2)), new PolygonPoint(-(width / 2), (height / 2)));
var letterPolygonsBottom = FontTessellationEngine.ConvertStringToTrianglesWithOuterPath(text, FontStyle.Bold, outerPath, out textAsPolygonSet);
foreach (var t in letterPolygonsBottom[0])
{
t.Flip();
}
cubeModel.Triangles = letterPolygonsTop;
foreach (var t in letterPolygonsTop[0])
{
t.Vectors[0].Position += new Vector3Class(0, 0, 5);
t.Vectors[1].Position += new Vector3Class(0, 0, 5);
t.Vectors[2].Position += new Vector3Class(0, 0, 5);
}
cubeModel.Triangles[0].AddRange(letterPolygonsBottom[0]);
cubeModel._scaleFactorX = cubeModel._scaleFactorY = cubeModel._scaleFactorZ = 1;
cubeModel.Scale(0.1f, 0.1f, 1f, Events.ScaleEventArgs.TypeAxis.ALL, true, true);
CreateExtrudeTriangles(cubeModel, outerPath.Points);
foreach (var polygon in outerPath.Holes)
{
CreateExtrudeTriangles(cubeModel, polygon.Points, true);
foreach (var holePolygon in polygon.Holes)
{
CreateExtrudeTriangles(cubeModel, holePolygon.Points, true);
}
}
//center triangle
cubeModel.UpdateBoundries();
cubeModel.UpdateDefaultCenter();
cubeModel.Triangles.UpdateWithMoveTranslation(new Vector3Class(startPoint.X, startPoint.Y, 0) - new Vector3Class(cubeModel.LeftPoint, cubeModel.BackPoint, -0.2f));
//orient model properly
cubeModel.HorizontalMirror(false, true);
cubeModel.Rotate(0, 0, 180, Events.RotationEventArgs.TypeAxis.Z);
cubeModel.UpdateTrianglesMinMaxZ();
this.Triangles[0].AddRange(cubeModel.Triangles[0]);
}
private static void FindNextChildRecursive(STLModel3D stlModel, List <TriangleConnectionInfo> startRecursiveTriangles, Dictionary <float, List <PolyNode> > connectedLayerPolyNodes, float currentHeight, float nextLayerHeight, SortedDictionary <float, PolyTree> modelContours, int lookUpRecursiveCount)
{
if (lookUpRecursiveCount < 25)
{
var totalTriangleConnections = new List <TriangleConnectionInfo>();
var allTrianglesBottomHigherThenNextLayerHeight = true;
foreach (var contourTriangleIndex in startRecursiveTriangles)
{
var firstContourTriangle = stlModel.Triangles[contourTriangleIndex.ArrayIndex][contourTriangleIndex.TriangleIndex];
//get connected triangles
var connectedTrianglesIndexes = stlModel.Triangles.GetConnectedTriangles(contourTriangleIndex);
totalTriangleConnections.AddRange(connectedTrianglesIndexes);
foreach (var connectedTriangleIndex in connectedTrianglesIndexes)
{
var connectedTriangle = stlModel.Triangles[connectedTriangleIndex.ArrayIndex][connectedTriangleIndex.TriangleIndex];
if (connectedTriangle.Bottom <= nextLayerHeight)
{
allTrianglesBottomHigherThenNextLayerHeight = false;
}
if (connectedTriangle.Top > firstContourTriangle.Top)
{
//find next polgon by using triangle index
foreach (var nextModelContour in modelContours[nextLayerHeight]._allPolys)
{
if (nextModelContour.TriangleConnections.ContainsKey(connectedTriangleIndex))
{
if (!connectedLayerPolyNodes.ContainsKey(nextLayerHeight))
{
connectedLayerPolyNodes.Add(nextLayerHeight, new List <PolyNode>());
}
if (!connectedLayerPolyNodes[nextLayerHeight].Contains(nextModelContour))
{
connectedLayerPolyNodes[nextLayerHeight].Add(nextModelContour);
}
}
}
}
}
}
if (!connectedLayerPolyNodes.ContainsKey(nextLayerHeight) && !allTrianglesBottomHigherThenNextLayerHeight)
{
lookUpRecursiveCount++;
FindNextChildRecursive(stlModel, startRecursiveTriangles, connectedLayerPolyNodes, currentHeight, nextLayerHeight, modelContours, lookUpRecursiveCount);
}
}
}
internal static void FindNextChildConnection(STLModel3D stlModel, float currentLayerHeight, float nextLayerHeight, Dictionary <float, List <PolyNode> > connectedLayerPolyNodes, SortedDictionary <float, PolyTree> modelContours)
{
//find by using an upper triangle connection
if (connectedLayerPolyNodes.ContainsKey(currentLayerHeight))
{
var totalTriangleConnections = new List <TriangleConnectionInfo>();
foreach (var contourTriangleIndex in connectedLayerPolyNodes[currentLayerHeight].First().TriangleConnections.Keys)
{
//var firstContourTriangleIndex = connectedLayerPolyNodes[currentLayerHeight].First().TriangleConnections.First();
var firstContourTriangle = stlModel.Triangles[contourTriangleIndex.ArrayIndex][contourTriangleIndex.TriangleIndex];
//get connected triangles
var connectedTrianglesIndexes = stlModel.Triangles.GetConnectedTriangles(contourTriangleIndex);
totalTriangleConnections.AddRange(connectedTrianglesIndexes);
foreach (var connectedTriangleIndex in connectedTrianglesIndexes)
{
var connectedTriangle = stlModel.Triangles[connectedTriangleIndex.ArrayIndex][connectedTriangleIndex.TriangleIndex];
if (connectedTriangle.Top > firstContourTriangle.Top)
{
//find next polgon by using triangle index
foreach (var nextModelContour in modelContours[nextLayerHeight]._allPolys)
{
if (nextModelContour.TriangleConnections.ContainsKey(connectedTriangleIndex))
{
if (!connectedLayerPolyNodes.ContainsKey(nextLayerHeight))
{
connectedLayerPolyNodes.Add(nextLayerHeight, new List <PolyNode>());
}
if (!connectedLayerPolyNodes[nextLayerHeight].Contains(nextModelContour))
{
connectedLayerPolyNodes[nextLayerHeight].Add(nextModelContour);
}
}
}
}
}
}
if (!connectedLayerPolyNodes.ContainsKey(nextLayerHeight))
{
//find recursive
FindNextChildRecursive(stlModel, totalTriangleConnections, connectedLayerPolyNodes, currentLayerHeight, nextLayerHeight, modelContours, 0);
}
}
}
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)
};
}
/*
* Return a list of polygons that intersect at this zlevel
*/
public static List <Triangle> GetZPolys(STLModel3D stlModel, float zlev)
{
var sliceHeight = (float)Math.Round(zlev, 3);
var lst = new List <Triangle>();
List <TriangleConnectionInfo> triangleConnections = null;
if (stlModel.SliceIndexes != null && stlModel.SliceIndexes.ContainsKey(sliceHeight))
{
triangleConnections = stlModel.SliceIndexes[sliceHeight];
for (var triangleConnectionIndex = 0; triangleConnectionIndex < triangleConnections.Count; triangleConnectionIndex++)
{
lst.Add(stlModel.Triangles[triangleConnections[triangleConnectionIndex].ArrayIndex][triangleConnections[triangleConnectionIndex].TriangleIndex]);
}
}
return(lst);
}
internal void UpdateTriangleReference(STLModel3D stlModel, SupportProfile selectedMaterialProfile)
{
var supportPointPosition = this.TopPoint;
supportPointPosition.Z = this.SliceHeight - 1f;
if (this._trianglesWithinXYRange == null)
{
CalcTrianglesWithinRange(supportPointPosition, selectedMaterialProfile, stlModel);
}
//find latest supportcone supported height
TriangleIntersection[] trianglesIntersected = null;
var trianglesAboveSupportPoint = new STLModel3D()
{
Triangles = new TriangleInfoList()
};
trianglesAboveSupportPoint.Triangles[0] = this._trianglesWithinXYRange.Triangles[0].Where(s => s.Top > 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)
{
if (triangleIntersection.IntersectionPoint.Z > supportPointPosition.Z)
{
var distance = triangleIntersection.IntersectionPoint.Z - supportPointPosition.Z;
if (distance < nearestLastSupportedHeightDistance)
{
nearestLastSupportedHeightDistance = distance;
nearestLastSupportedHeight = triangleIntersection.IntersectionPoint;
this.ModelIntersection = triangleIntersection;
}
}
}
}
}
}
public void UpdateSelectedAngleOverlay(STLModel3D selectedModel, RotationEventArgs.TypeAxis rotationAxis)
{
if (rotationAxis == RotationEventArgs.TypeAxis.None)
{
this.RotationOverlay = new SceneRotationGizmoAngle();
}
else if (selectedModel.PreviewRotationX != 0)
{
RotationOverlay.UpdatAngle(_modelDiameter, TORUSOUTSIDERINGDIAMETER * 2, TORUSSEGMENTCOUNT, TORUSSEGMENTBANDCOUNT, selectedModel.PreviewRotationX, rotationAxis);
}
else if (selectedModel.PreviewRotationY != 0)
{
RotationOverlay.UpdatAngle(_modelDiameter, TORUSOUTSIDERINGDIAMETER * 2, TORUSSEGMENTCOUNT, TORUSSEGMENTBANDCOUNT, -selectedModel.PreviewRotationY, rotationAxis);
}
else if (selectedModel.PreviewRotationZ != 0)
{
RotationOverlay.UpdatAngle(_modelDiameter, TORUSOUTSIDERINGDIAMETER * 2, TORUSSEGMENTCOUNT, TORUSSEGMENTBANDCOUNT, selectedModel.PreviewRotationZ, rotationAxis);
}
}
/// <summary>
/// Create a model footprint for a STL model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static ModelFootprint FromModel(STLModel3D model)
{
ModelFootprint modelFootprint = new ModelFootprint();
modelFootprint.Model = model;
if (model.SupportBasement)
{
if (model.SupportBasementStructure != null)
{
model.SupportBasementStructure.UpdateBoundries();
}
}
modelFootprint.SizeX = Math.Abs(model.FootprintRightPoint - model.FootprintLeftPoint);
modelFootprint.SizeY = Math.Abs(model.FootprintBackPoint - model.FootprintFrontPoint);
modelFootprint.Color = model.Color;
return(modelFootprint);
}
internal static List <SlicePolyLine3D> GetZIntersectionsBaseSTLModel3D(STLModel3D baseObject, float sliceHeight)
{
var lstlines = new List <SlicePolyLine3D>();
if (baseObject.BottomPoint <= sliceHeight && baseObject.TopPoint >= sliceHeight)
{
foreach (var triangle in baseObject.Triangles[0])
{
if (triangle.Bottom <= sliceHeight && triangle.Top >= sliceHeight)
{
var s3d = triangle.IntersectZPlane(sliceHeight);
if (s3d != null)
{
s3d.Normal = triangle.Normal;
lstlines.Add(s3d);
}
}
}
}
return(lstlines);
}
internal void CalcSlicesContours(Material selectedMaterial, AtumPrinter selectedPrinter)
{
var contours = new SortedDictionary <float, PolyTree>();
foreach (var triangle in this.Triangles[0])
{
triangle.CalcMinMaxZ();
}
this.CalcSliceIndexes(selectedMaterial, false);
var sliceIndex = 0;
foreach (var sliceHeight in this.SliceIndexes.Keys)
{
contours.Add(sliceHeight, STLModel3D.GetSliceContoursForBaseSTLModel3D(this, sliceIndex, sliceHeight, selectedPrinter));
sliceIndex++;
}
this.SliceContours = contours;
}
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);
}
internal void UpdateBottomSupportedHeight(STLModel3D stlModel)
{
//find latest supportcone supported height
TriangleIntersection[] trianglesIntersected = null;
var supportPointPosition = this.TopPoint.AsVector3();
supportPointPosition.Z = this.SliceHeight;
IntersectionProvider.IntersectTriangle(supportPointPosition, new Vector3Class(0, 0, -1), stlModel, IntersectionProvider.typeDirection.OneWay, false, new Vector3Class(), out trianglesIntersected);
this.BottomPoint = new Vector3Class(supportPointPosition.Xy);
if (trianglesIntersected != null)
{
var nearestLastSupportedHeight = new Vector3Class();
var nearestLastSupportedHeightDistance = float.MaxValue;
foreach (var triangleIntersection in trianglesIntersected)
{
if (triangleIntersection != null)
{
if (triangleIntersection.IntersectionPoint.Z < supportPointPosition.Z)
{
var distance = (triangleIntersection.IntersectionPoint - supportPointPosition).Length;
if (distance < nearestLastSupportedHeightDistance)
{
nearestLastSupportedHeightDistance = distance;
nearestLastSupportedHeight = triangleIntersection.IntersectionPoint;
}
}
}
}
if (nearestLastSupportedHeight != new Vector3Class())
{
this.BottomPoint = nearestLastSupportedHeight;
}
}
else
{
}
}
internal static TypeOfSurface GetSurfaceType(STLModel3D stlModel, TriangleSurfaceInfo currentSurface)
{
if (stlModel != null)
{
foreach (var surface in stlModel.Triangles.HorizontalSurfaces)
{
if (surface == currentSurface)
{
return(TypeOfSurface.Horizontal);
}
}
foreach (var surface in stlModel.Triangles.FlatSurfaces)
{
if (surface == currentSurface)
{
return(TypeOfSurface.Flat);
}
}
}
return(TypeOfSurface.Unknown);
}
void CreateExtrudeTriangles(STLModel3D cube, IList <TriangulationPoint> pathPolygonPoints, bool flipTriangles = false)
{
//create extrude triangles from polygons
for (var pathOuterPointIndex = 0; pathOuterPointIndex < pathPolygonPoints.Count; pathOuterPointIndex++)
{
var startPoint = new Vector3Class((float)pathPolygonPoints[pathOuterPointIndex].X, (float)pathPolygonPoints[pathOuterPointIndex].Y, 0) / 10;
var endPoint = new Vector3Class((float)pathPolygonPoints[0].X, (float)pathPolygonPoints[0].Y, 0) / 10;
if (pathOuterPointIndex < pathPolygonPoints.Count - 1)
{
endPoint = new Vector3Class((float)pathPolygonPoints[pathOuterPointIndex + 1].X, (float)pathPolygonPoints[pathOuterPointIndex + 1].Y, 0) / 10;
}
var outerPathTriangle = new Triangle();
outerPathTriangle.Vectors[0].Position = startPoint;
outerPathTriangle.Vectors[1].Position = endPoint;
outerPathTriangle.Vectors[2].Position = endPoint + new Vector3Class(0, 0, 5);
if (flipTriangles)
{
outerPathTriangle.Flip();
}
cube.Triangles[0].Add(outerPathTriangle);
outerPathTriangle = new Triangle();
outerPathTriangle.Vectors[0].Position = startPoint + new Vector3Class(0, 0, 5);
outerPathTriangle.Vectors[1].Position = startPoint;
outerPathTriangle.Vectors[2].Position = endPoint + new Vector3Class(0, 0, 5);
if (flipTriangles)
{
outerPathTriangle.Flip();
}
cube.Triangles[0].Add(outerPathTriangle);
}
}
internal static void Calculate(STLModel3D model, DAL.Materials.Material selectedMaterial, Vector3Class modelTranslation,
float maxBuildSizeX, float maxBuildSizeY,
float sideABHeight, float sideBDHeight, float sideBCAngleOffset, float sideABAngleOffset,
double sideABAngle, double sideBCAngle,
float sideB,
float calibrationModelSizeX, float calibrationModelSizeY)
{
model.UpdateBoundries();
var moveYFactor = -(maxBuildSizeY / 2);
for (var arrayIndex = 0; arrayIndex < model.Triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < model.Triangles[arrayIndex].Count; triangleIndex++)
{
model.Triangles[arrayIndex][triangleIndex].Vectors[0].Position += new Vector3Class(0, moveYFactor, 0);
model.Triangles[arrayIndex][triangleIndex].Vectors[1].Position += new Vector3Class(0, moveYFactor, 0);
model.Triangles[arrayIndex][triangleIndex].Vectors[2].Position += new Vector3Class(0, moveYFactor, 0);
}
}
model.UpdateBoundries();
float sideDHeightDifference = (float)(sideABHeight - sideBDHeight);
if (sideDHeightDifference < 0)
{
sideDHeightDifference = -sideDHeightDifference;
}
//change model vectors
if (float.IsNaN(sideABAngleOffset))
{
sideABAngleOffset = 0;
}
if (float.IsNaN(sideBCAngleOffset))
{
sideBCAngleOffset = 0;
}
var leftSideMaxCorrection = new Vector3((sideABAngleOffset), sideDHeightDifference, 0);
var rightSideMaxCorrection = new Vector3((sideBCAngleOffset), 0, 0);
if (sideABHeight >= sideBDHeight) //highest point at right side
{
leftSideMaxCorrection = new Vector3(leftSideMaxCorrection.X, 0, 0); //NO Y correction
rightSideMaxCorrection = new Vector3(rightSideMaxCorrection.X, sideDHeightDifference, 0);
}
for (var arrayIndex = 0; arrayIndex < model.Triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < model.Triangles[arrayIndex].Count; triangleIndex++)
{
for (var vectorIndex = 0; vectorIndex < 3; vectorIndex++)
{
var correctionVector = new Vector3Class();
var orgPoint = model.Triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position;
var vectorOffSetPercentageABY = orgPoint.Y / (float)sideABHeight;
var vectorOffSetPercentageBDY = orgPoint.Y / (float)sideBDHeight;
var horizontalABOffsetPercentage = ((calibrationModelSizeX / 2) + orgPoint.X) / calibrationModelSizeX;
var horizontalBCOffsetPercentage = (1 - (orgPoint.X / (calibrationModelSizeX / 2))) / 2;
if (orgPoint.X < 0)
{
horizontalABOffsetPercentage = 1 - (0.5f / (calibrationModelSizeX / 2)) * ((calibrationModelSizeX / 2) - orgPoint.X);
horizontalBCOffsetPercentage = (-orgPoint.X + (calibrationModelSizeX / 2)) / calibrationModelSizeX;
}
var verticalOffsetPercentage = vectorOffSetPercentageABY * (1 - horizontalABOffsetPercentage);
if (sideABHeight < sideBDHeight)
{
verticalOffsetPercentage = vectorOffSetPercentageBDY * (1 - horizontalBCOffsetPercentage);
}
if (sideABAngle <= 90) //angle A forward /
{
correctionVector = new Vector3Class(-vectorOffSetPercentageABY * rightSideMaxCorrection.X * horizontalABOffsetPercentage, 0, 0);
}
else if (sideABAngle > 90) //angle A backward
{
correctionVector = new Vector3Class(vectorOffSetPercentageABY * leftSideMaxCorrection.X * horizontalABOffsetPercentage, 0, 0);
}
if (sideBCAngle <= 90) //angle C forward \
{
correctionVector += new Vector3Class(-vectorOffSetPercentageBDY * leftSideMaxCorrection.X * horizontalBCOffsetPercentage, 0, 0);
}
else if (sideBCAngle > 90) //angle C backward /
{
correctionVector += new Vector3Class(vectorOffSetPercentageBDY * rightSideMaxCorrection.X * horizontalBCOffsetPercentage, 0, 0);
}
//Y correction
if (sideABHeight < sideBDHeight && sideDHeightDifference != 0)
{
correctionVector += new Vector3Class(0, verticalOffsetPercentage * sideDHeightDifference, 0);
}
else if (sideDHeightDifference != 0)
{
correctionVector += new Vector3Class(0, verticalOffsetPercentage * sideDHeightDifference, 0);
}
model.Triangles[arrayIndex][triangleIndex].Vectors[vectorIndex].Position += correctionVector;
}
}
}
//move model back to normal position
moveYFactor = (maxBuildSizeY / 2);
for (var arrayIndex = 0; arrayIndex < model.Triangles.Count; arrayIndex++)
{
for (var triangleIndex = 0; triangleIndex < model.Triangles[arrayIndex].Count; triangleIndex++)
{
model.Triangles[arrayIndex][triangleIndex].Vectors[0].Position += new Vector3Class(0, moveYFactor, 0);
model.Triangles[arrayIndex][triangleIndex].Vectors[1].Position += new Vector3Class(0, moveYFactor, 0);
model.Triangles[arrayIndex][triangleIndex].Vectors[2].Position += new Vector3Class(0, moveYFactor, 0);
}
}
//find highest vector and calc the scaling factor with original factor
var scaleFactorY = maxBuildSizeY / sideABHeight;
if (sideBDHeight > sideABHeight)
{
scaleFactorY = maxBuildSizeY / sideBDHeight;
}
var resolutionScalingFactor = maxBuildSizeX / 192f;
var modelScaleFactorX = ((maxBuildSizeX / sideB) / BasicCorrectionModel.ModelDefaultCorrectionFactorX) / resolutionScalingFactor * (float)selectedMaterial.ShrinkFactor * model.ScaleFactorX;
var modelScaleFactorY = ((scaleFactorY / BasicCorrectionModel.ModelDefaultCorrectionFactorY) / resolutionScalingFactor) * (float)selectedMaterial.ShrinkFactor * model.ScaleFactorY;
model.Scale(modelScaleFactorX, 1, 1, Events.ScaleEventArgs.TypeAxis.X, false);
model.Scale(1, modelScaleFactorY, 1, Events.ScaleEventArgs.TypeAxis.Y, false);
model.Scale(1, 1, model.ScaleFactorZ * (float)selectedMaterial.ShrinkFactor, Events.ScaleEventArgs.TypeAxis.Z, false);
//combine movetranslation with scaled vector
if (model is SupportCone)
{
model.MoveTranslation += modelTranslation;
}
model.UpdateBoundries();
var stopwatch = new Stopwatch();
stopwatch.Start();
//update triangle normals
foreach (var triangleArray in model.Triangles)
{
foreach (var triangle in triangleArray)
{
triangle.CalcNormal();
}
}
if (!(model is SupportCone))
{
if (model.SupportStructure != null)
{
foreach (var supportCone in model.TotalObjectSupportCones)
{
Calculate(supportCone, selectedMaterial, new Vector3Class(), maxBuildSizeX, maxBuildSizeY, sideABHeight, sideBDHeight, sideBCAngleOffset, sideABAngleOffset, sideABAngle, sideBCAngle, sideB, calibrationModelSizeX, calibrationModelSizeY);
}
}
}
if (model.SupportBasementStructure != null)
{
Calculate(model.SupportBasementStructure, selectedMaterial, modelTranslation, maxBuildSizeX, maxBuildSizeY, sideABHeight, sideBDHeight, sideBCAngleOffset, sideABAngleOffset, sideABAngle, sideBCAngle, sideB, calibrationModelSizeX, calibrationModelSizeY);
}
}
internal static void Calculate(STLModel3D model, DAL.Materials.Material selectedMaterial, Vector3Class modelTranslation)
{
model.UpdateBoundries();
//properties of right part of trapezoid
var sideA = PrintJobManager.SelectedPrinter.TrapeziumCorrectionInputA;
var sideB = PrintJobManager.SelectedPrinter.TrapeziumCorrectionInputB;
var sideC = PrintJobManager.SelectedPrinter.TrapeziumCorrectionInputC;
var sideD = PrintJobManager.SelectedPrinter.TrapeziumCorrectionInputD;
var sideE = PrintJobManager.SelectedPrinter.TrapeziumCorrectionInputE;
var sideF = PrintJobManager.SelectedPrinter.TrapeziumCorrectionInputF;
var sideBCAngleOffset = 0f;
var sideBCAngle = 90d;
var maxBuildSizeX = PrintJobManager.SelectedPrinter.MaxBuildSizeX;
var maxBuildSizeY = PrintJobManager.SelectedPrinter.MaxBuildSizeY;
var calibrationModelSizeX = BasicCorrectionModel.ModelSizeX;
var calibrationModelSizeY = BasicCorrectionModel.ModelSizeY;
var triangleBArea = Math.Sqrt(((sideC + sideB + sideF) / 2)
* (((sideC + sideB + sideF) / 2) - sideC)
* (((sideC + sideB + sideF) / 2) - sideB)
* (((sideC + sideB + sideF) / 2) - sideF));
var sideBDHeight = ((float)(triangleBArea * 2) / sideB);
if (sideA != calibrationModelSizeY || sideB != calibrationModelSizeX ||
sideC != calibrationModelSizeY || sideD != calibrationModelSizeX ||
sideE != sideF)
{
sideBCAngle = MathHelper.RadiansToDegrees(Math.Acos((Math.Pow(sideC, 2) + Math.Pow(sideB, 2) - Math.Pow(sideF, 2)) / (2 * sideC * sideB)));
sideBCAngleOffset = (float)Math.Sqrt(Math.Pow(sideC, 2) - Math.Pow(sideBDHeight, 2));
if (sideBCAngle > 90)
{
sideBCAngleOffset = -sideBCAngleOffset;
}
}
//properties of left part of trapezoid
var sideABAngleOffset = 0f;
var sideABAngle = 90d;
var triangleAArea = Math.Sqrt(((sideA + sideB + sideE) / 2)
* (((sideA + sideB + sideE) / 2) - sideA)
* (((sideA + sideB + sideE) / 2) - sideB)
* (((sideA + sideB + sideE) / 2) - sideE));
var sideABHeight = ((float)(triangleAArea * 2) / sideB);
if (sideA != calibrationModelSizeY || sideB != calibrationModelSizeX ||
sideC != calibrationModelSizeY || sideD != calibrationModelSizeX ||
sideE != sideF)
{
sideABAngleOffset = (float)Math.Sqrt(Math.Pow(sideA, 2) - Math.Pow(sideABHeight, 2));
sideABAngle = MathHelper.RadiansToDegrees(Math.Acos((Math.Pow(sideA, 2) + Math.Pow(sideB, 2) - Math.Pow(sideE, 2)) / (2 * sideA * sideB)));
if (sideABAngle < 90)
{
sideABAngleOffset = -sideABAngleOffset;
}
}
Calculate(model, selectedMaterial, modelTranslation, maxBuildSizeX, maxBuildSizeY, sideABHeight, sideBDHeight, sideBCAngleOffset,
sideABAngleOffset, sideABAngle, sideBCAngle, sideB, calibrationModelSizeX, calibrationModelSizeY);
}
internal SupportEventArgs()
{
this.SurfaceTriangles = new STLModel3D();
this.SurfaceTriangles.Triangles = new Shapes.TriangleInfoList();
}
public static void AddManualSupportCone(float totalHeight, float topHeight, float topRadius, float middleRadius, float bottomHeight, float bottomRadius,
int slicesCount, Vector3Class object3dPosition, Vector3Class position, Color color, STLModel3D stlModel, Vector3Class moveTranslation,
float rotationAngleX, float rotationAngleZ, bool groundSupport, bool useSupportPenetration = false, float supportBottomWidthCorrection = 0f)
{
var supportCone = new SupportCone(totalHeight, topHeight, topRadius, middleRadius, bottomHeight, bottomRadius, slicesCount, object3dPosition, color, rotationAngleX, rotationAngleZ, stlModel,
groundSupport: groundSupport, useSupportPenetration: useSupportPenetration, bottomWidthCorrection: supportBottomWidthCorrection);
supportCone.Selected = false;
supportCone.CreationBy = SupportCone.typeCreationBy.Manual;
supportCone.MoveTranslation = moveTranslation;
supportCone.UpdateBoundries();
if (groundSupport && !stlModel.SupportBasement)
{
supportCone.MoveTranslation = new Vector3Class(supportCone.MoveTranslation.X, supportCone.MoveTranslation.Y, 0);
}
lock (stlModel.SupportStructureLock)
{
stlModel.SupportStructure.Add(supportCone);
}
}
private STLModel3D CalcOrientationGizmoPart(float sizeCorrection, SideSelectionType firstSideSelectionType, SideSelectionType secondSideSelectionType, SideSelectionType thirdSideSelectionType, SideSelectionType cornerSelectionType)
{
var defaultSize = 5f * sizeCorrection;
var defaultOffsetSize = defaultSize - (1f * sizeCorrection);
var defaultOffsetSizeHalf = defaultSize + ((1f * sizeCorrection) / 2f);
var result = new STLModel3D();
result.Triangles = new TriangleInfoList();
var cubePoints = new List <Vector3Class>();
cubePoints.Add(new Vector3Class(0, 0, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(0, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, 0, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(0, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(0, -defaultSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, 0, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultSize, 0, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf)); //top
cubePoints.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf)); //top
var cubeColor = new Byte4Class((byte)(int)firstSideSelectionType, 57, 64, 69);
if (firstSideSelectionType == SelectedSide)
{
cubeColor = new Byte4Class((byte)(int)firstSideSelectionType, 255, 0, 0);
}
else if (firstSideSelectionType == HighlightedSide)
{
cubeColor = new Byte4Class((byte)(int)firstSideSelectionType, 255, 255, 255);
}
var cubeIndexes = new List <short[]>
{
new short[] { 0, 1, 2 }, //front
new short[] { 2, 3, 0 }, //front
new short[] { 4, 5, 6 }, //front
new short[] { 6, 7, 4 }, //front
new short[] { 8, 9, 10 }, //front
new short[] { 10, 11, 8 }, //front
new short[] { 12, 13, 14 }, //front
};
var xAngles = new List <int>()
{
0, -90
};
foreach (var xAngle in xAngles)
{
if (xAngle == -90)
{
if (secondSideSelectionType != SideSelectionType.Bottom)
{
cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 57, 64, 69);
}
else
{
cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 128, 128, 128);
}
if (secondSideSelectionType == SelectedSide)
{
cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 255, 0, 0);
}
else if (secondSideSelectionType == HighlightedSide)
{
cubeColor = new Byte4Class((byte)(int)secondSideSelectionType, 255, 255, 255);
}
}
var tList = new List <Triangle>();
var stlModel = new STLModel3D();
stlModel.Triangles = new TriangleInfoList();
foreach (var cubeIndex in cubeIndexes)
{
var triangle = new Triangle();
triangle.Vectors[0].Position = cubePoints[cubeIndex[0]];
triangle.Vectors[1].Position = cubePoints[cubeIndex[1]];
triangle.Vectors[2].Position = cubePoints[cubeIndex[2]];
triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = cubeColor;
triangle.CalcNormal();
tList.Add(triangle);
if (xAngle == -90)
{
triangle.Flip(true);
}
}
stlModel.Triangles[0].AddRange(tList);
stlModel.Rotate(xAngle, 0, 0, RotationEventArgs.TypeAxis.X, updateFaceColor: false);
if (xAngle == -90)
{
stlModel.MoveModelWithTranslationZ(new Vector3Class(0, -(2 * defaultOffsetSizeHalf), 0));
}
result.Triangles[0].AddRange(stlModel.Triangles[0]);
}
var tList2 = new List <Triangle>();
var stlModel2 = new STLModel3D();
stlModel2.Triangles = new TriangleInfoList();
cubeColor = new Byte4Class((byte)(int)thirdSideSelectionType, 57, 64, 69);
if (thirdSideSelectionType == SelectedSide)
{
cubeColor = new Byte4Class((byte)(int)thirdSideSelectionType, 255, 0, 0);
}
else if (thirdSideSelectionType == HighlightedSide)
{
cubeColor = new Byte4Class((byte)(int)thirdSideSelectionType, 255, 255, 255);
}
foreach (var cubeIndex in cubeIndexes)
{
var triangle = new Triangle();
triangle.Vectors[0].Position = cubePoints[cubeIndex[0]];
triangle.Vectors[1].Position = cubePoints[cubeIndex[1]];
triangle.Vectors[2].Position = cubePoints[cubeIndex[2]];
triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = cubeColor;
triangle.Flip(true);
tList2.Add(triangle);
}
stlModel2.Triangles[0].AddRange(tList2);
stlModel2.Rotate(0, -90, 0, RotationEventArgs.TypeAxis.Y, updateFaceColor: false);
stlModel2.MoveModelWithTranslationZ(new Vector3Class((2 * defaultOffsetSizeHalf), 0, 0));
result.Triangles[0].AddRange(stlModel2.Triangles[0]);
//highlight parts
var highlightParts = new List <Vector3Class>();
highlightParts.Add(new Vector3Class(0, -defaultSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(0, -defaultOffsetSizeHalf, defaultSize));
highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSizeHalf, defaultSize));
highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSizeHalf, defaultSize));
highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(0, -defaultSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultOffsetSize, defaultSize));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, 0f, defaultSize));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, 0f, defaultSize));
highlightParts.Add(new Vector3Class(defaultSize, 0, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, 0f));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, 0f));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, 0f));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultOffsetSizeHalf, defaultSize));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultOffsetSize, -defaultSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSize, defaultOffsetSizeHalf));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultOffsetSize, defaultSize));
highlightParts.Add(new Vector3Class(defaultSize, -defaultOffsetSizeHalf, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultSize, defaultOffsetSize));
highlightParts.Add(new Vector3Class(defaultOffsetSizeHalf, -defaultOffsetSize, defaultSize));
var highlightColor = new Byte4Class((byte)(int)cornerSelectionType, 0, 0, 0);
if (cornerSelectionType == SelectedSide)
{
highlightColor = new Byte4Class((byte)(int)cornerSelectionType, 255, 0, 0);
}
else if (cornerSelectionType == HighlightedSide)
{
highlightColor = new Byte4Class((byte)(int)cornerSelectionType, 255, 255, 255);
}
for (var highlightIndex = 0; highlightIndex < highlightParts.Count; highlightIndex += 3)
{
var triangle = new Triangle();
triangle.Vectors[0].Position = highlightParts[highlightIndex];
triangle.Vectors[1].Position = highlightParts[highlightIndex + 1];
triangle.Vectors[2].Position = highlightParts[highlightIndex + 2];
triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = highlightColor;
triangle.CalcNormal();
result.Triangles[0].Add(triangle);
}
return(result);
}
private void btnSupportApplyToAll_Click(object sender, EventArgs e)
{
if (this._datasource != null)
{
STLModel3D model = null;
if (ObjectView.SelectedModel is SupportCone)
{
model = (ObjectView.SelectedModel as SupportCone).Model;
}
else if (ObjectView.SelectedModel is STLModel3D)
{
model = ObjectView.SelectedModel as STLModel3D;
}
else if (this._datasource is SupportCone)
{
model = (this._datasource as SupportCone).Model;
}
if (model != null)
{
var supportUpdateArgs = new Core.Events.SupportEventArgs();
var selectedPGLabel = this.pgSupport.SelectedGridItem.Label;
if (selectedPGLabel != null)
{
if (selectedPGLabel == "Top Radius")
{
supportUpdateArgs.TopRadius = this._datasource.TopRadius;
}
else if (selectedPGLabel == "Top Height")
{
supportUpdateArgs.TopHeight = this._datasource.TopHeight;
}
else if (selectedPGLabel == "Middle Radius")
{
supportUpdateArgs.MiddleRadius = this._datasource.MiddleRadius;
}
else if (selectedPGLabel == "Bottom Height")
{
supportUpdateArgs.BottomHeight = this._datasource.BottomHeight;
}
else if (selectedPGLabel == "Bottom Radius")
{
supportUpdateArgs.BottomRadius = this._datasource.BottomRadius;
}
SupportEngine.UpdateModelSingleSupportCones(supportUpdateArgs, model);
}
//surface support
foreach (var supportCone in model.Triangles.HorizontalSurfaces.SupportStructure)
{
supportCone.Update(supportUpdateArgs, model);
}
//flat support
foreach (var supportCone in model.Triangles.FlatSurfaces.SupportStructure)
{
supportCone.Update(supportUpdateArgs, model);
}
}
//update main scene
this.ValueChanged?.Invoke(this);
}
}
public static void RenderSliceToPolygons(Slices.Slice slice, Slices.RenderSliceInfo renderSlice)
{
var pixelValues = new byte[renderSlice.PrinterResolutionX * renderSlice.PrinterResolutionY];
var pixelLength = pixelValues.Length;
// Array.Clear(pixelValues, 0, pixelLength);
int beginPixel = 0;
int beginPixelOfRow = 0;
int endPixel = 0;
int endPixelOfRow = 0;
SlicePoint2D p1;
SlicePoint2D p2;
//model points
if (slice.ModelPoints.Count % 2 == 0)
{
for (int cnt = 0; cnt < slice.ModelPoints.Count; cnt += 2) // increment by 2
{
p1 = slice.ModelPoints[cnt];
p2 = slice.ModelPoints[cnt + 1];
if (p1.X > p2.X) //flip over
{
var pTemp = p1;
p1 = p2;
p2 = pTemp;
}
p1.X++;
if (p1.X <= p2.X)
{
if (p2.Y >= 0 && p1.Y >= 0)
{
beginPixel = (p1.Y * renderSlice.PrinterResolutionX + p1.X);
beginPixelOfRow = (((p1.Y) * renderSlice.PrinterResolutionX));
if (p1.X < 0)
{
beginPixel = (p1.Y * renderSlice.PrinterResolutionX);
}
//get end pixel of row
endPixel = ((p2.Y * renderSlice.PrinterResolutionX + p2.X));
endPixelOfRow = (((p1.Y + 1) * renderSlice.PrinterResolutionX)) - 1;
if (endPixel > endPixelOfRow)
{
endPixel = endPixelOfRow;
}
if (pixelValues.Length - 1 >= beginPixel && beginPixel >= 0)
{
pixelValues[beginPixel] = 255;
}
if (p2.X < 0)
{
endPixel = ((p2.Y * renderSlice.PrinterResolutionX));
}
//fill color between begin and endpoints
if (pixelValues.Length - 1 >= endPixel && endPixel >= 0)
{
pixelValues[endPixel] = 255;
if (beginPixel < endPixel)
{
for (var betweenPixel = beginPixel + 1; betweenPixel < endPixel; betweenPixel++)
{
if (betweenPixel >= 0)
{
pixelValues[betweenPixel] = 255;
}
}
}
}
}
}
}
}
if (slice.SupportPoints.Count % 2 == 0) // is even
{
for (int cnt = 0; cnt < slice.SupportPoints.Count; cnt += 2) // increment by 2
{
p1 = slice.SupportPoints[cnt];
p2 = slice.SupportPoints[cnt + 1];
if (p1.X > p2.X) //flip over
{
var pTemp = p1;
p1 = p2;
p2 = pTemp;
}
p1.X++;
if (p1.X <= p2.X)
{
if (p2.Y >= 0 && p1.Y >= 0)
{
beginPixel = (p1.Y * renderSlice.PrinterResolutionX + p1.X);
beginPixelOfRow = (((p1.Y) * renderSlice.PrinterResolutionX));
if (p1.X < 0)
{
beginPixel = (p1.Y * renderSlice.PrinterResolutionX);
}
//get end pixel of row
endPixel = ((p2.Y * renderSlice.PrinterResolutionX + p2.X));
endPixelOfRow = (((p1.Y + 1) * renderSlice.PrinterResolutionX));
if (endPixel > endPixelOfRow)
{
endPixel = endPixelOfRow;
}
if (pixelValues.Length - 1 >= beginPixel && beginPixel >= 0)
{
pixelValues[beginPixel] = 255;
}
if (p2.X < 0)
{
endPixel = ((p2.Y * renderSlice.PrinterResolutionX));
}
if (pixelValues.Length - 1 >= endPixel && endPixel >= 0)
{
pixelValues[endPixel] = 255;
if (beginPixel < endPixel)
{
for (var betweenPixel = beginPixel + 1; betweenPixel < endPixel; betweenPixel++)
{
if (betweenPixel >= 0)
{
pixelValues[betweenPixel] = 255;
}
}
}
}
}
}
}
}
else // flag error
{
Console.WriteLine("Row y=" + " odd # of points = " + slice.SupportPoints.Count + " - Model may have holes");
}
//convert pixel values to polylines
for (var pixelRowIndex = 0; pixelRowIndex < renderSlice.PrinterResolutionY; pixelRowIndex++)
{
var beginRowIndex = renderSlice.PrinterResolutionX * pixelRowIndex;
var startOfPolygon = false;
var startOfPolygonIndex = 0;
var endOfPolygonIndex = 0;
for (var pixelColumnIndex = 0; pixelColumnIndex < renderSlice.PrinterResolutionX; pixelColumnIndex++)
{
if (pixelValues[beginRowIndex + pixelColumnIndex] == 255)
{
if (!startOfPolygon)
{
startOfPolygon = true;
startOfPolygonIndex = pixelColumnIndex;
}
}
else if (pixelValues[beginRowIndex + pixelColumnIndex] == 0)
{
if (startOfPolygon)
{
endOfPolygonIndex = pixelColumnIndex;
startOfPolygon = false;
//add polygon to return list
var slicePolygon = new SlicePolyLine3D();
slicePolygon.Points.Add(new Vector3(startOfPolygonIndex, pixelRowIndex, renderSlice.SliceHeight));
slicePolygon.Points.Add(new Vector3(endOfPolygonIndex, pixelRowIndex, renderSlice.SliceHeight));
SimulationPolyLines.Add(slicePolygon);
}
}
}
}
lock (_totalProcessedSlicesLock)
{
TotalProcessedSlices++;
}
if (TotalProcessedSlices == TotalAmountSlices)
{
if (SimulationPrintJobCompleted != null)
{
//convert polygons to vectors
STLModel = new STLModel3D(STLModel3D.TypeObject.Model, true);
STLModel.Triangles = new TriangleInfoList();
var triangleIndex = 0;
var arrayIndex = 0;
foreach (var polyLine in SimulationPolyLines)
{
if (polyLine != null)
{
var polygonCube = new Shapes.Cube(polyLine.Points[1].X - polyLine.Points[0].X + 1, polyLine.Points[1].Y - polyLine.Points[0].Y + 1, 1);
//Console.WriteLine(polygonCube.Center);
for (var cubeVertexIndex = 0; cubeVertexIndex < polygonCube.VertexArray.Length; cubeVertexIndex += 3)
{
var triangle = new Triangle();
triangle.Normal = polygonCube.VertexArray[cubeVertexIndex].Normal;
triangle.Vectors[0].Position = new Vector3(-48, -20, 0);
triangle.Vectors[0].Normal = triangle.Vectors[1].Normal = triangle.Vectors[2].Normal = triangle.Normal;
triangle.Vectors[0].Color = triangle.Vectors[1].Color = triangle.Vectors[2].Color = new Byte4()
{
A = 128, B = 255
};
triangle.Vectors[1].Position = new Vector3(-48, -20, 0);
triangle.Vectors[2].Position = new Vector3(-48, -20, 0);
triangle.Vectors[0].Position += polygonCube.VertexArray[cubeVertexIndex].Position / 20;
triangle.Vectors[1].Position += polygonCube.VertexArray[cubeVertexIndex + 1].Position / 20;
triangle.Vectors[2].Position += polygonCube.VertexArray[cubeVertexIndex + 2].Position / 20;
//add 0 point
triangle.Vectors[0].Position += new Vector3(polyLine.Points[0].X / 20, polyLine.Points[0].Y / 20, polyLine.Points[0].Z);
triangle.Vectors[1].Position += new Vector3(polyLine.Points[0].X / 20, polyLine.Points[0].Y / 20, polyLine.Points[0].Z);
triangle.Vectors[2].Position += new Vector3(polyLine.Points[0].X / 20, polyLine.Points[0].Y / 20, polyLine.Points[0].Z);
if (triangleIndex > 33333)
{
IsReadyForRendering = true;
break;
triangleIndex = 0;
arrayIndex++;
STLModel.Triangles.Add(new List <Triangle>());
}
triangleIndex++;
STLModel.Triangles[arrayIndex].Add(triangle);
}
}
}
IsReadyForRendering = true;
SimulationPrintJobCompleted(null, null);
}
}
}
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;
}
}
}
}
public static void AddGridSupportCone(float totalHeight, float topHeight, float topRadius, float middleRadius, float bottomHeight, float bottomRadius,
int slicesCount, Vector3 object3dPosition, Vector3 position, Color color, STLModel3D stlModel, Vector3 moveTranslation,
float rotationAngleX, float rotationAngleZ, bool groundSupport, TriangleSurfaceInfo surface, bool useSupportPenetration = false, float supportBottomWidthCorrection = 0f)
{
var supportCone = new SupportCone(totalHeight, topHeight, topRadius, middleRadius, bottomHeight, bottomRadius, slicesCount, new Vector3Class(object3dPosition), color, rotationAngleX, rotationAngleZ, stlModel,
groundSupport: groundSupport,
useSupportPenetration: useSupportPenetration,
bottomWidthCorrection: supportBottomWidthCorrection
);
supportCone.CreationBy = SupportCone.typeCreationBy.Manual;
supportCone.Selected = false;
supportCone.MoveTranslation = new Vector3Class(moveTranslation);
supportCone.UpdateBoundries();
lock (surface.SupportStructure)
{
surface.SupportStructure.Add(supportCone);
}
}
