protected override Point4Dmm applyKerf(Point4Dmm p1, Point4Dmm p2, Point4Dmm p3, WorkspacePanel workspace)
{
var kerf = reCalculateKerf(workspace.CuttingKerf);
var shift = calculateKerfShift(p1.ToUV(), p2.ToUV(), p3.ToUV(), kerf);
return(new Point4Dmm(p2.U + shift.X, p2.V + shift.Y, p2.X + shift.X, p2.Y + shift.Y));
}
public static IEnumerable <Point4Dmm> CircleToSquare()
{
var metricWidth = 30;
var points = new List <Point4Dmm>();
var scale = 100;
for (var i = 0; i <= scale; i += 1)
{
var percentage = 1.0 * i / scale;
var rectPercentage = percentage + 1.0 / 8;
if (rectPercentage > 1.0)
{
rectPercentage -= 1;
}
var circleCoord = ShapeDrawing.Circle(percentage, metricWidth);
var rectCoord = ShapeDrawing.Rectangle(rectPercentage, metricWidth);
var combinedCoord = new Point4Dmm(-circleCoord.C1 + metricWidth, circleCoord.C2 + metricWidth, -rectCoord.C1 + metricWidth, -rectCoord.C2 + metricWidth);
points.Add(combinedCoord);
}
return(points);
}
private void getSpeedVectors(WorkspacePanel workspace, Point4Dmm t1, Point4Dmm t2, out Vector speedVector12UVt, out Vector speedVector12XYt)
{
var maxSpeed = workspace.CuttingSpeed;
var maxSpeedRatio = (maxSpeed.StepCount * Constants.MilimetersPerStep) / (1.0 * maxSpeed.Ticks / Constants.TimerFrequency);
//tower speeds
speedVector12UVt = diffVector(t1.ToUV(), t2.ToUV());
speedVector12XYt = diffVector(t1.ToXY(), t2.ToXY());
if (speedVector12UVt.Length > speedVector12XYt.Length)
{
var speedRatio = speedVector12XYt.Length / speedVector12UVt.Length;
speedVector12UVt.Normalize();
speedVector12XYt.Normalize();
speedVector12UVt = speedVector12UVt * maxSpeedRatio;
speedVector12XYt = speedVector12XYt * speedRatio;
}
else
{
var speedRatio = speedVector12UVt.Length / speedVector12XYt.Length;
speedVector12UVt.Normalize();
speedVector12XYt.Normalize();
speedVector12UVt = speedVector12UVt * maxSpeedRatio;
speedVector12XYt = speedVector12XYt * speedRatio;
}
}
/// <inheritdoc/>
protected override Point4Dmm applyKerf(Point4Dmm p1, Point4Dmm p2, Point4Dmm p3, WorkspacePanel workspace)
{
double kerfUV, kerfXY;
if (UseExplicitKerf)
{
kerfUV = reCalculateKerf(KerfUV);
kerfXY = reCalculateKerf(KerfXY);
}
else
{
getShapeSpeedVectors(workspace, p1, p2, out Vector speedVector12UV, out Vector speedVector12XY);
getShapeSpeedVectors(workspace, p2, p3, out Vector speedVector23UV, out Vector speedVector23XY);
var speedUV = (speedVector12UV.Length + speedVector23UV.Length) / 2;
var speedXY = (speedVector12XY.Length + speedVector23XY.Length) / 2;
var referentialKerf = workspace.CuttingKerf;
kerfUV = reCalculateKerf(referentialKerf, speedUV, workspace);
kerfXY = reCalculateKerf(referentialKerf, speedXY, workspace);
}
var shiftUV = calculateKerfShift(p1.ToUV(), p2.ToUV(), p3.ToUV(), kerfUV);
var shiftXY = calculateKerfShift(p1.ToXY(), p2.ToXY(), p3.ToXY(), kerfXY);
return(new Point4Dmm(p2.U + shiftUV.X, p2.V + shiftUV.Y, p2.X + shiftXY.X, p2.Y + shiftXY.Y));
}
private IEnumerable <Point4Dmm> getAlignedPoints(FacetShape facet1, FacetShape facet2)
{
var points = new List <Primitives.Point4Dmm>();
var done = -1.0;
while (done < 1.0)
{
var nextPointPercentage1 = facet1.GetNextPointPercentage(done);
var nextPointPercentage2 = facet2.GetNextPointPercentage(done);
var nextPointPercentage = Math.Min(nextPointPercentage1, nextPointPercentage2);
var oldDone = done;
done = nextPointPercentage;
var percentageDelta = done - oldDone;
var perimeterDelta = percentageDelta * (facet1.TotalPerimeter + facet2.TotalPerimeter);
if (perimeterDelta < 0.00001)
{
//smooth out floating point errors
continue;
}
var point1 = facet1.GetPoint(done);
var point2 = facet2.GetPoint(done);
var point = new Point4Dmm(point1.C1, point1.C2, point2.C1, point2.C2);
points.Add(point);
}
return(points);
}
private Tuple <Speed, Speed> getSpeeds(Point4Dmm[] points, int currentIndex, Speed facetSpeed, PlaneProjector projector)
{
var currentPoint = points[currentIndex % points.Length];
var nextPoint = points[(currentIndex + 1) % points.Length];
getFacetVectors(currentPoint, nextPoint, out var facetUV, out var facetXY);
var facetSpeedConverted = 1.0 * facetSpeed.StepCount / facetSpeed.Ticks;
if (facetUV.Length <= Constants.MilimetersPerStep && facetXY.Length <= Constants.MilimetersPerStep)
{
//TODO this accounts for numerical instability
return(Tuple.Create(facetSpeed, facetSpeed));
}
double ratio;
switch (SpeedAlgorithm)
{
case SpeedAlgorithm.StickToFacetUV:
ratio = facetSpeedConverted / facetUV.Length;
break;
case SpeedAlgorithm.StickToFacetXY:
ratio = facetSpeedConverted / facetXY.Length;
break;
default:
throw new NotImplementedException("SpeedAlgorithm");
}
facetUV = facetUV * ratio;
facetXY = facetXY * ratio;
var speedPoint = new Point4Dmm(currentPoint.U + facetUV.X, currentPoint.V + facetUV.Y, currentPoint.X + facetXY.X, currentPoint.Y + facetXY.Y);
var currentProjected = projector.Project(currentPoint);
var speedProjected = projector.Project(speedPoint);
getFacetVectors(currentProjected, speedProjected, out var speedUV, out var speedXY);
var speedFactor = Constants.TimerFrequency;
var uvSpeed = speedUV.Length * speedFactor;
var xySpeed = speedXY.Length * speedFactor;
return(Tuple.Create(
new Speed((long)(uvSpeed), speedFactor),
new Speed((long)(xySpeed), speedFactor)
));
}
internal static Point4Dmm Project(Point4Dmm point, double shapeMetricThickness, double wireLength)
{
var shapeToTowerDistance = (shapeMetricThickness - wireLength) / 2;
var uvPoint = new Vector3D(point.U, point.V, -shapeMetricThickness / 2);
var xyPoint = new Vector3D(point.X, point.Y, +shapeMetricThickness / 2);
var projectionVector = uvPoint - xyPoint;
var projectionVectorScale = shapeToTowerDistance / projectionVector.Z;
var uvPointProjected = uvPoint + projectionVector * projectionVectorScale;
var xyPointProjected = xyPoint - projectionVector * projectionVectorScale;
return(new Point4Dmm(uvPointProjected.X, uvPointProjected.Y, xyPointProjected.X, xyPointProjected.Y));
}
private void getShapeSpeedVectors(WorkspacePanel workspace, Point4Dmm p1, Point4Dmm p2, out Vector speedVector12UV, out Vector speedVector12XY)
{
var wireLength = workspace.WireLength;
var t1 = projectToTowers(p1, wireLength);
var t2 = projectToTowers(p2, wireLength);
//tower speeds
getSpeedVectors(workspace, t1, t2, out Vector speedVector12UVt, out Vector speedVector12XYt);
var facetDistance = wireLength / 2 - MetricThickness / 2;
var facetRatio = 1.0 - facetDistance / wireLength;
speedVector12UV = speedVector12UVt * facetRatio + speedVector12XYt * (1.0 - facetRatio);
speedVector12XY = speedVector12XYt * facetRatio + speedVector12UVt * (1.0 - facetRatio);
}
public static IEnumerable <Point4Dmm> CircleToPoint()
{
var metricWidth = 30;
var size = metricWidth;
var points = new List <Point4Dmm>();
for (var i = 0; i <= 100; ++i)
{
var percentage = i / 100.0;
var point = new Point2Dmm(0, 0);
var circCoord = ShapeDrawing.Circle(percentage, size);
var combinedCoord = new Point4Dmm(-point.C1 + size, point.C2 + size, -circCoord.C1 + size, -circCoord.C2 + size);
points.Add(combinedCoord);
}
return(points);
}
/// <summary>
/// Rotates given point according to current rotation angle.
/// </summary>
protected Point4Dmm rotate(Point4Dmm point)
{
var c1 = _shapeMinC1 + _shapeMaxC1 / 2.0;
var c2 = _shapeMinC2 + _shapeMaxC2 / 2.0;
var centeredU = point.U - c1;
var centeredV = point.V - c2;
var centeredX = point.X - c1;
var centeredY = point.Y - c2;
var rotatedU = centeredU * _rotationCos - centeredV * _rotationSin;
var rotatedV = centeredV * _rotationCos + centeredU * _rotationSin;
var rotatedX = centeredX * _rotationCos - centeredY * _rotationSin;
var rotatedY = centeredY * _rotationCos + centeredX * _rotationSin;
return(new Point4Dmm(
rotatedU + c1, rotatedV + c2,
rotatedX + c1, rotatedY + c2
));
}
private IEnumerable <Point4Dmm> cutPointsWithWidthFinish()
{
//find top/bottom templates
var definitionPoints = TransformedShapeDefinitionWithKerf.ToArray();
double minHorizontalCoord, maxHorizontalCoord, minVerticalCoord;
int minHorizontalIndex, maxHorizontalIndex, minVerticalIndex;
findBoxPoints(definitionPoints, out minHorizontalCoord, out maxHorizontalCoord, out minVerticalCoord, out minHorizontalIndex, out maxHorizontalIndex, out minVerticalIndex);
var result = new List <Point4Dmm>();
for (var i = minHorizontalIndex; i < minHorizontalIndex + definitionPoints.Length; ++i)
{
//unwind shape in the desired form
result.Add(definitionPoints[i % definitionPoints.Length]);
}
var belowCutMargin = 5;
var syncMarginC1 = -5;
var marginC2 = -_finishCutMetricMarginC2;
var entryPoint = result.First();
var aboveEntryPoint = new Point4Dmm(entryPoint.U, entryPoint.V + marginC2, entryPoint.X, entryPoint.Y + marginC2);
var belowEntryPoint = new Point4Dmm(entryPoint.U, entryPoint.V + belowCutMargin, entryPoint.X, entryPoint.Y + belowCutMargin);
var syncEntryPoint = new Point4Dmm(entryPoint.U + syncMarginC1, entryPoint.V, entryPoint.X + syncMarginC1, entryPoint.Y);
var aboveSyncEntryPoint = new Point4Dmm(syncEntryPoint.U, syncEntryPoint.V + marginC2, syncEntryPoint.X, syncEntryPoint.Y + marginC2);
result.Insert(0, syncEntryPoint);
result.Add(syncEntryPoint);
result.Add(aboveSyncEntryPoint);
result.Add(aboveEntryPoint);
result.Add(belowEntryPoint);
result.Add(syncEntryPoint);
return(result);
}
internal Point4Dmm Project(Point4Dmm point)
{
return(PlaneProjector.Project(point, _shapeMetricThickness, _wireLength));
}
/// <summary> /// Calculates kerf on the p2 point. /// </summary> /// <param name="p1">Preceding point.</param> /// <param name="p2">Kerfed point.</param> /// <param name="p3">Following point.</param> /// <param name="workspace">Workspace defining the kerf.</param> /// <returns></returns> protected abstract Point4Dmm applyKerf(Point4Dmm p1, Point4Dmm p2, Point4Dmm p3, WorkspacePanel workspace);
private void getFacetVectors(Point4Dmm p1, Point4Dmm p2, out Vector v1, out Vector v2)
{
v1 = new Vector(p2.U - p1.U, p2.V - p1.V);
v2 = new Vector(p2.X - p1.X, p2.Y - p1.Y);
}
private IEnumerable <Point4Dmm> templatedCutPoints()
{
//find top/bottom templates
var definitionPoints = TransformedShapeDefinition.ToArray();
definitionPoints = addHorizontalKerf(definitionPoints).ToArray();
double minHorizontalCoord, maxHorizontalCoord, minVerticalCoord;
int minHorizontalIndex, maxHorizontalIndex, minVerticalIndex;
findBoxPoints(definitionPoints, out minHorizontalCoord, out maxHorizontalCoord, out minVerticalCoord, out minHorizontalIndex, out maxHorizontalIndex, out minVerticalIndex);
var templateMinMax = new List <Point4Dmm>();
var templateMaxMin = new List <Point4Dmm>();
var isMinMax = true;
for (var i = minHorizontalIndex; i < minHorizontalIndex + definitionPoints.Length; ++i)
{
var pointIndex = i % definitionPoints.Length;
var point = definitionPoints[pointIndex];
if (isMinMax)
{
//first template points
templateMinMax.Add(point);
}
if (pointIndex == maxHorizontalIndex)
{
isMinMax = false;
}
if (!isMinMax)
{
//second template points
templateMaxMin.Add(point);
}
}
//distinguish which template is top, and which bottom
var isMinMaxTop = minHorizontalIndex > minVerticalIndex && minVerticalIndex < maxHorizontalIndex;
if (minHorizontalIndex == minVerticalIndex || maxHorizontalIndex == minVerticalIndex)
{
throw new NotImplementedException("Degenerated shape, probably not good for templated cut");
}
templateMaxMin.Reverse();// the template was drawn in the opposite direction
var topTemplate = isMinMaxTop ? templateMinMax : templateMaxMin;
var bottomTemplate = isMinMaxTop ? templateMaxMin : templateMinMax;
//define template scaffold points
var startPoint = topTemplate.First();
var endPoint = topTemplate.Last();
var margin = 30;
var marginTop = 55;
var syncMargin = 5;
var topLineC2 = minVerticalCoord - marginTop; //TODO load from shape settings
var entryC1 = minHorizontalCoord - margin; //TODO load from shape settings
var finishC1 = maxHorizontalCoord + margin; //TODO load from shape settings
var entryScaffoldPoint = new Point4Dmm(entryC1, startPoint.V, entryC1, startPoint.Y);
var syncEntryScaffoldPoint = new Point4Dmm(startPoint.U - syncMargin, startPoint.V, startPoint.X - syncMargin, startPoint.Y);
var aboveEntryScaffoldPoint = new Point4Dmm(entryC1, topLineC2, entryC1, topLineC2);
var finishScaffoldPoint = new Point4Dmm(finishC1, endPoint.V, finishC1, endPoint.Y);
var syncFinishScaffoldPoint = new Point4Dmm(endPoint.U + syncMargin, endPoint.V, endPoint.X + syncMargin, endPoint.Y);
var aboveFinishScaffoldPoint = new Point4Dmm(finishC1, topLineC2, finishC1, topLineC2);
//construct the cut
var points = new List <Point4Dmm>();
//bottom template first
points.Add(entryScaffoldPoint);
points.Add(syncEntryScaffoldPoint);
points.AddRange(bottomTemplate);
points.Add(syncFinishScaffoldPoint);
points.Add(finishScaffoldPoint);
points.Add(aboveFinishScaffoldPoint);
points.Add(aboveEntryScaffoldPoint);
points.Add(entryScaffoldPoint);
points.Add(syncEntryScaffoldPoint);
//top template cut
points.AddRange(topTemplate);
points.Add(syncFinishScaffoldPoint);
points.Add(finishScaffoldPoint);
points.Add(aboveFinishScaffoldPoint);
points.Add(aboveEntryScaffoldPoint);
points.Add(entryScaffoldPoint);
//entry point at the end is implicit (shape is closed)
return(points);
}
/// <inheritdoc/>
protected override Point4Dmm applyKerf(Point4Dmm p1, Point4Dmm p2, Point4Dmm p3, WorkspacePanel workspace)
{
// Native item does not follow kerf settup.
return(p2);
}
private Point4Dmm projectToTowers(Point4Dmm p, double wireLength)
{
return(PlaneProjector.Project(p, this.MetricThickness, wireLength));
}
