Esempio n. 1
0
        /// <inheritdoc/>
        internal override void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints, ItemJoin incommingJoin)
        {
            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.");
            }

            //skip the repetitive point so we can join to whatever shape part.
            cutPoints = cutPoints.Take(cutPoints.Length - 1).ToArray();

            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];

                speedPoints.Add(currentPoint.With(cuttingSpeed));

                var currentOutgoingJoins = workspace.GetOutgoingJoinsFrom(currentIndex, outJoins);
                foreach (var currentOutgoingJoin in currentOutgoingJoins)
                {
                    currentOutgoingJoin.Build(workspace, speedPoints);
                }
            }
        }
Esempio n. 2
0
        /// <inheritdoc/>
        internal override void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints, ItemJoin incommingJoin)
        {
            if (incommingJoin.Item1 != workspace.EntryPoint)
            {
                throw new NotSupportedException("Native controll item can be run only from entry point.");
            }

            var outJoins = workspace.FindOutgoingJoins(this);

            if (outJoins.Any())
            {
                throw new NotSupportedException("Native controll item cannot have outgoing joins.");
            }

            var cutPoints = CutPoints.ToArray();
            var speeds    = SegmentSpeeds.ToArray();

            if (cutPoints.Length != speeds.Length + 1)
            {
                throw new NotSupportedException("Invalid point/speed matching.");
            }

            for (var i = 1; i < cutPoints.Length; ++i)
            {
                speedPoints.Add(cutPoints[i].With(speeds[i - 1]));
            }
        }
Esempio n. 3
0
        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;
            }
        }
Esempio n. 4
0
        protected Point4Dmm[] applyKerf(IEnumerable <Point4Dmm> points, WorkspacePanel workspace)
        {
            /* var pointsUV = points.ToUV();
             *
             * var offsetCalculator = new OffsetCalculator(pointsUV.Reverse());
             * var offsetPoints = offsetCalculator.WithOffset(workspace.CuttingKerf / 2).First();
             *
             * return offsetPoints.DuplicateTo4Dmm().ToArray();
             *
             * throw new NotImplementedException();*/

            var pointsArr = points.ToArray();

            var result = new List <Point4Dmm>();

            for (var i = 0; i < pointsArr.Length; ++i)
            {
                var prevPoint = getNextDifferent(pointsArr, i, -1);
                var point     = pointsArr[i];
                var nextPoint = getNextDifferent(pointsArr, i, 1);

                result.Add(applyKerf(prevPoint, point, nextPoint, workspace));
            }

            return(result.ToArray());
        }
Esempio n. 5
0
        internal HeadCNC(Color headColor, WorkspacePanel parent)
        {
            var brush = new SolidColorBrush(headColor);

            brush.Opacity = 0.8;
            _headPen      = new Pen(brush, 4.0);
            _parent       = parent;

            Position = new Point2Dmm(0, 0);
        }
Esempio n. 6
0
        /// <inheritdoc/>
        internal override void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints, ItemJoin incommingJoin)
        {
            if (incommingJoin != null)
            {
                throw new NotSupportedException("Incomming join point has to be empty for entry point.");
            }

            foreach (var join in workspace.FindOutgoingJoins(this))
            {
                join.Build(workspace, speedPoints);
            }
        }
Esempio n. 7
0
        private double reCalculateKerf(double referentialKerf, double metricSpeed, WorkspacePanel workspace)
        {
            referentialKerf = reCalculateKerf(referentialKerf);
            var referentialSpeed       = workspace.CuttingSpeed;
            var metricReferentialSpeed = Constants.MilimetersPerStep * referentialSpeed.StepCount / (1.0 * referentialSpeed.Ticks / Constants.TimerFrequency);

            var referenceFactor = metricReferentialSpeed / metricSpeed;

            var wireKerf      = Math.Min(Constants.HotwireThickness / 2, Math.Abs(referentialKerf));
            var radiationKerf = Math.Abs(referentialKerf) - wireKerf;
            var adjustedKerf  = radiationKerf * referenceFactor + wireKerf;

            return(Math.Sign(referentialKerf) * adjustedKerf);
        }
Esempio n. 8
0
        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);
        }
Esempio n. 9
0
        protected Point4Dmm[] applyKerf(IEnumerable <Point4Dmm> points, WorkspacePanel workspace)
        {
            var pointsArr = points.ToArray();

            var result = new List <Point4Dmm>();

            for (var i = 0; i < pointsArr.Length; ++i)
            {
                var prevPoint = getNextDifferent(pointsArr, i, -1);
                var point     = pointsArr[i];
                var nextPoint = getNextDifferent(pointsArr, i, 1);

                result.Add(applyKerf(prevPoint, point, nextPoint, workspace));
            }

            return(result.ToArray());
        }
Esempio n. 10
0
        /// <summary>
        /// Builds path to <see cref="Item2"/> and the item recursively. Assumes it starts from <see cref="Item1"/> outgoing point.
        /// Path ends at the same point it started.
        /// </summary>
        internal void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints)
        {
            var outgoingPoint  = Item1.CutPoints.Skip(JoinPointIndex1).First();
            var incommingPoint = Item2.CutPoints.Skip(JoinPointIndex2).First();
            var cuttingSpeed   = workspace.CuttingSpeed;

            speedPoints.Add(incommingPoint.With(cuttingSpeed));
            Item2.Build(workspace, speedPoints, this);

            if (Item2 is NativeControlItem)
            {
                // Native controls are handled in special way.
                return;
            }

            speedPoints.Add(outgoingPoint.With(cuttingSpeed));
        }
Esempio n. 11
0
 /// <inheritdoc/>
 protected override Point4Dmm applyKerf(Point4Dmm p1, Point4Dmm p2, Point4Dmm p3, WorkspacePanel workspace)
 {
     // Native item does not follow kerf settup.
     return(p2);
 }
Esempio n. 12
0
 /// <inheritdoc/>
 internal override void RecalculateToWorkspace(WorkspacePanel workspace, Size size)
 {
     base.RecalculateToWorkspace(workspace, size);
     _wireLength = workspace.WireLength;
 }
Esempio n. 13
0
 /// <inheritdoc/>
 internal override void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints, ItemJoin incommingJoin)
 {
     //there is nothing to build
 }
 /// <summary>
 /// Builds cutting plan for the item and all joined items recursively.
 /// Build assumes we are at item join point. Closed shapes has to return back to that point.
 /// </summary>
 /// <param name="workspace">Workspace where joins are defined.</param>
 /// <param name="speedPoints">Output of the build.</param>
 /// <param name="incommingJoin">Join which was used to get into the item.</param>
 internal abstract void Build(WorkspacePanel workspace, List <Speed4Dstep> speedPoints, ItemJoin incommingJoin);
 /// <inheritdoc/>
 internal override void RecalculateToWorkspace(WorkspacePanel workspace, Size size)
 {
     _stepToVisualFactorC1 = size.Width / workspace.StepCountX;
     _stepToVisualFactorC2 = size.Height / workspace.StepCountY;
 }
Esempio n. 16
0
        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));
        }
Esempio n. 17
0
 internal virtual void RecalculateToWorkspace(WorkspacePanel workspace, Size size)
 {
     //nothing to do by default
 }
Esempio n. 18
0
        /// <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);
                }
            }
        }
Esempio n. 19
0
        /// <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));
        }
Esempio n. 20
0
 /// <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);