public void generatePointTest()
{
RandomPointGenerator gen = new RandomPointGenerator();
PlaneProjector proj = new PlaneProjector();
Point p = gen.generatePoint(3);
//Assert.IsTrue(proj.isAddingToOne(p));
}
public static PlanBuilder Shape4dTest()
{
var metricShapeThickness = 300;
var points = ShapeDrawing.CircleToSquare();
var projector = new PlaneProjector(metricShapeThickness, Constants.FullWireLength);
var projectedPoints = projector.Project(points);
var planner = new StraightLinePlanner4D(Speed.FromDeltaT(3000));
return(planner.CreateConstantPlan(new Trajectory4D(projectedPoints.As4Dstep())));
}
public void Convert2DTo3DTest()
{
Vector2 itemPosition2D = new Vector2(2f, 1f);
Vector3 expected = new Vector3(2f, 0, -1f) * 4.0f;
Vector3 actual;
actual = PlaneProjector.Convert2DTo3D(itemPosition2D);
Assert.AreEqual(expected, actual);
//Assert.Inconclusive("Überprüfen Sie die Richtigkeit dieser Testmethode.");
}
private Point4Dmm projectToTowers(Point4Dmm p, double wireLength)
{
return(PlaneProjector.Project(p, this.MetricThickness, wireLength));
}
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)
));
}
/// <inheritdoc/>
internal override void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints, ItemJoin incommingJoin)
{
if (_speedAlgorithm == SpeedAlgorithm.TowerBased || !UseExplicitKerf)
{
base.Build(workspace, speedPoints, incommingJoin);
return;
}
if (incommingJoin.Item2 != this)
{
throw new NotSupportedException("Incomming join point is not valid.");
}
var cuttingSpeed = workspace.CuttingSpeed;
var cutPoints = CutPoints.ToArray();
if (!cutPoints.First().Equals(cutPoints.Last()))
{
throw new NotSupportedException("Shape is not closed.");
}
var definitionPoints = CutDefinition.ToArray();
if (cutPoints.Count() != definitionPoints.Count())
{
throw new NotSupportedException("Invalid cut points count.");
}
//skip the repetitive point so we can join to whatever shape part.
cutPoints = cutPoints.Take(cutPoints.Length - 1).ToArray();
definitionPoints.Take(definitionPoints.Length - 1).ToArray();
var projector = new PlaneProjector(_shapeMetricThickness, _wireLength);
var outJoins = workspace.FindOutgoingJoins(this);
var startIndex = incommingJoin.JoinPointIndex2;
for (var i = startIndex + 1; i <= startIndex + cutPoints.Length; ++i)
{
var currentIndex = i % cutPoints.Length;
var currentPoint = cutPoints[currentIndex];
var speeds = getSpeeds(definitionPoints, currentIndex, cuttingSpeed, projector);
//System.Diagnostics.Debug.Print(speeds.ToString());
var speed1Limit = speeds.Item1.ToDeltaT() >= Constants.StartDeltaT || speeds.Item1.ToDeltaT() < 0;
var speed2Limit = speeds.Item2.ToDeltaT() >= Constants.StartDeltaT || speeds.Item2.ToDeltaT() < 0;
if (!speed1Limit || !speed2Limit)
{
throw new PlanningException("Speed limit exceeded");
}
speedPoints.Add(currentPoint.With(speeds.Item1, speeds.Item2));
var currentOutgoingJoins = workspace.GetOutgoingJoinsFrom(currentIndex, outJoins);
foreach (var currentOutgoingJoin in currentOutgoingJoins)
{
currentOutgoingJoin.Build(workspace, speedPoints);
}
}
}
