Esempio n. 1
0
 private void pictureBoxVideo_MouseUp(object sender, MouseEventArgs e)
 {
     if (e.Button == MouseButtons.Right)
     {
         measureAngleStop = (xyPoint)pictureBoxVideo.PointToClient(MousePosition);
         angle            = (float)measureAngleStart.AngleTo(measureAngleStop);
         measureAngle     = false;
         lblAngle.Text    = String.Format("{0:0.00}°", angle);
         if (angle != 0)
         {
             cmsPictureBox.Visible = false;
         }
         else
         {
             cmsPictureBox.Visible = true;
         }
     }
 }
Esempio n. 2
0
 private void pictureBoxVideo_MouseDown(object sender, MouseEventArgs e)
 {
     //cmsPictureBox.Visible = true;
     if (e.Button == MouseButtons.Right)
     {
         measureAngleStart = (xyPoint)pictureBoxVideo.PointToClient(MousePosition);
         measureAngle      = true;
     }
     if (e.Delta > 0)
     {
         nUDCameraZoom.Value += nUDCameraZoom.Increment;
         MessageBox.Show(e.Delta.ToString());
     }
     if (e.Delta < 0)
     {
         nUDCameraZoom.Value -= nUDCameraZoom.Increment;
     }
 }
Esempio n. 3
0
        private xyPoint getPicBoxOffset(Point mouseLocation)
        {   // backwards calculation to keep real coordinates on mouse-pos. on zoom-in -out
            double minx   = VisuGCode.drawingSize.minX;
            double miny   = VisuGCode.drawingSize.minY;
            double xRange = (VisuGCode.drawingSize.maxX - VisuGCode.drawingSize.minX);                                              // calculate new size
            double yRange = (VisuGCode.drawingSize.maxY - VisuGCode.drawingSize.minY);

            if (Properties.Settings.Default.machineLimitsFix)
            {
                double offset = (double)Properties.Settings.Default.machineLimitsRangeX / 40;       // view size
                minx   = (double)Properties.Settings.Default.machineLimitsHomeX - grbl.posWCO.X - offset;
                miny   = (double)Properties.Settings.Default.machineLimitsHomeY - grbl.posWCO.Y - offset;
                xRange = (double)Properties.Settings.Default.machineLimitsRangeX + 2 * offset;
                yRange = (double)Properties.Settings.Default.machineLimitsRangeY + 2 * offset;
            }
            double ratioVisu = xRange / yRange;
            double ratioPic  = Convert.ToDouble(pictureBox1.Width) / pictureBox1.Height;
            double maxposY   = yRange;

            if (ratioVisu > ratioPic)
            {
                maxposY = xRange * pictureBox1.Height / pictureBox1.Width;
            }

            double relposX = (picAbsPos.X - minx) / xRange;
//            double relposY = (yRange - picAbsPos.Y + miny) / yRange;
            double relposY = (maxposY - picAbsPos.Y + miny) / yRange;

            if (ratioVisu > ratioPic)
            {
                relposY = relposY * ratioPic / ratioVisu;
            }
            else
            {
                relposX = relposX * ratioVisu / ratioPic;
            }

            xyPoint picOffset = new xyPoint();

            picOffset.X = mouseLocation.X - (relposX * zoomFactor * pictureBox1.Width);
            picOffset.Y = mouseLocation.Y - (relposY * zoomFactor * pictureBox1.Height);
            return(picOffset);
        }
        private void ZoomScroll(Point location, int zoomIn)
        {
            if (showPicBoxBgImage || posIsMoving)              // don't zoom if background image is shown
            {
                return;
            }

            if (zoomIn > 0)
            {
                if (zoomFactor < 1025)
                {
                    pBoxTransform.Reset();
                    zoomTranslation = new xyPoint(location.X, location.Y) * zoomFactor + zoomTranslationOld;// + (moveTranslation * zoomFactor);
                    pBoxTransform.Translate((float)-zoomTranslation.X, (float)-zoomTranslation.Y);
                    zoomFactor *= scrollZoomFactor;
                    pBoxTransform.Scale(zoomFactor, zoomFactor);
                }
            }
            else if (zoomIn < 0)
            {
                if (zoomFactor > 0.1)
                {
                    pBoxTransform.Reset();
                    zoomFactor     *= 1 / scrollZoomFactor;
                    zoomTranslation = new xyPoint(location.X, location.Y) * -zoomFactor + zoomTranslationOld;
                    pBoxTransform.Translate((float)-zoomTranslation.X, (float)-zoomTranslation.Y);
                    pBoxTransform.Scale(zoomFactor, zoomFactor);
                }
            }
            zoomTranslationOld = zoomTranslation;

            if (zoomFactor == 1)
            {
                pBoxTransform.Reset(); zoomFactor = 1;
                zoomTranslation    = new xyPoint(0, 0);
                zoomTranslationOld = new xyPoint(0, 0);
            }

            pictureBox1.Invalidate();
        }
        // find closest coordinate in GCode and mark
        private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {   // MessageBox.Show(picAbsPosX + "  " + picAbsPosY);
            pictureBox1.Focus();
            moveTranslationOld = new xyPoint(e.X, e.Y);
            allowZoom          = false;
            if (e.Button == MouseButtons.Left)
            {
                if ((fCTBCode.LinesCount > 2) && !posIsMoving)
                {
                    int line = VisuGCode.setPosMarkerNearBy(picAbsPos);
                    posMoveStart = picAbsPos;
                    posMoveTmp   = posMoveStart;
                    posMoveEnd   = posMoveStart;

                    moveToMarkedPositionToolStripMenuItem.ToolTipText = "Work X: " + grbl.posMarker.X.ToString() + "   Y: " + grbl.posMarker.Y.ToString();

                    fCTBCodeClickedLineNow = line;
                    fCTBCodeMarkLine();
                    fCTBBookmark.DoVisible();
                    findFigureMarkSelection(Color.OrangeRed);
                    posIsMoving = false;
                }
            }
        }
Esempio n. 6
0
        private void ZoomScroll(Point location, int zoomIn)
        {
            if (showPicBoxBgImage || posIsMoving)              // don't zoom if background image is shown
            {
                return;
            }

            if (zoomIn > 0)
            {
                if (zoomFactor < 800)
                {
                    zoomFactor *= scrollZoomFactor;
                    xyPoint locationO = getPicBoxOffset(location);
                    pBoxTransform.Reset();
                    pBoxTransform.Translate((float)locationO.X, (float)locationO.Y);
                    pBoxTransform.Scale(zoomFactor, zoomFactor);
                }
            }
            else if (zoomIn < 0)
            {
                if (zoomFactor > 0.1)
                {
                    zoomFactor *= 1 / scrollZoomFactor;
                    xyPoint locationO = getPicBoxOffset(location);
                    pBoxTransform.Reset();
                    pBoxTransform.Translate((float)locationO.X, (float)locationO.Y);
                    pBoxTransform.Scale(zoomFactor, zoomFactor);
                }
            }
            if (Math.Round(zoomFactor, 2) == 1.00)
            {
                pBoxTransform.Reset(); zoomFactor = 1;
            }

            pictureBox1.Invalidate();
        }
Esempio n. 7
0
        public void setDimensionArc(xyPoint oldPos, xyPoint newPos, double i, double j, bool isG2)
        {
            ArcProperties arcMove;

            arcMove = gcodeMath.getArcMoveProperties(oldPos, newPos, i, j, isG2);

            float x1     = (float)(arcMove.center.X - arcMove.radius);
            float x2     = (float)(arcMove.center.X + arcMove.radius);
            float y1     = (float)(arcMove.center.Y - arcMove.radius);
            float y2     = (float)(arcMove.center.Y + arcMove.radius);
            float r2     = 2 * (float)arcMove.radius;
            float aStart = (float)(arcMove.angleStart * 180 / Math.PI);
            float aDiff  = (float)(arcMove.angleDiff * 180 / Math.PI);

            if (gcodeMath.isEqual(oldPos, newPos))
            {
                setDimensionXY(x1, y1);
                setDimensionXY(x2, y2);
            }
            else
            {
                setDimensionCircle(arcMove.center.X, arcMove.center.Y, arcMove.radius, aStart, aDiff);        // calculate new dimensions
            }
        }
Esempio n. 8
0
 public static ArcProperties getArcMoveProperties(xyPoint pOld, xyPoint pNew, xyPoint center, bool isG2)
 {
     return(getArcMoveProperties(pOld, pNew, pOld.X - center.X, pOld.Y - center.Y, isG2));
 }
Esempio n. 9
0
 public static double distancePointToPoint(xyPoint a, xyPoint b)
 {
     return(Math.Sqrt(((a.X - b.X) * (a.X - b.X)) + ((a.Y - b.Y) * (a.Y - b.Y))));
 }
Esempio n. 10
0
 public static bool isEqual(xyPoint a, xyPoint b)
 {
     return((Math.Abs(a.X - b.X) < precision) && (Math.Abs(a.Y - b.Y) < precision));
 }
Esempio n. 11
0
        /// <summary>
        /// Process entities
        /// </summary>
        private static void processEntities(DXFEntity entity, double offsetX = 0, double offsetY = 0)
        {
            int    index = 0;
            double x, y, x2 = 0, y2 = 0, bulge;

            if (dxfComments)
            {
                gcode.Comment(gcodeString[gcodeStringIndex], "Entity: " + entity.GetType().ToString());
                gcode.Comment(gcodeString[gcodeStringIndex], "Color:  " + entity.ColorNumber.ToString());
            }

            if (entity.GetType() == typeof(DXFPointEntity))
            {
                DXFPointEntity point = (DXFPointEntity)entity;
                x = (float)point.Location.X + (float)offsetX;
                y = (float)point.Location.Y + (float)offsetY;
                gcodeStartPath(x, y, "Start Point");
                gcodeStopPath();
            }

            #region DXFLWPolyline
            else if (entity.GetType() == typeof(DXFLWPolyLine))
            {
                DXFLWPolyLine lp = (DXFLWPolyLine)entity;
                index = 0; bulge = 0;
                DXFLWPolyLine.Element coordinate;
                bool roundcorner = false;
                for (int i = 0; i < lp.VertexCount; i++)
                {
                    coordinate = lp.Elements[i];
                    bulge      = coordinate.Bulge;
                    x          = (double)coordinate.Vertex.X + (double)offsetX;
                    y          = (double)coordinate.Vertex.Y + (double)offsetY;
                    if (i == 0)
                    {
                        gcodeStartPath(x, y, "Start LWPolyLine");
                        isReduceOk = true;
                    }
                    else
                    {
                        if (!roundcorner)
                        {
                            gcodeMoveTo(x, y, "");
                        }
                        if (bulge != 0)
                        {
                            if (i < (lp.VertexCount - 1))
                            {
                                AddRoundCorner(lp.Elements[i], lp.Elements[i + 1]);
                            }
                            else
                            {
                                AddRoundCorner(lp.Elements[i], lp.Elements[0]);
                            }
                            roundcorner = true;
                        }
                        else
                        {
                            roundcorner = false;
                        }
                    }
                    x2 = x; y2 = y;
                }
                if (lp.Flags > 0)
                {
                    gcodeMoveTo((float)lp.Elements[0].Vertex.X, (float)lp.Elements[0].Vertex.Y, "End LWPolyLine");
                }
                gcodeStopPath();
            }
            #endregion
            #region DXFPolyline
            else if (entity.GetType() == typeof(DXFPolyLine))
            {
                DXFPolyLine lp = (DXFPolyLine)entity;
                index = 0;
                foreach (DXFVertex coordinate in lp.Children)
                {
                    if (coordinate.GetType() == typeof(DXFVertex))
                    {
                        if (coordinate.Location.X != null && coordinate.Location.Y != null)
                        {
                            x = (float)coordinate.Location.X + (float)offsetX;
                            y = (float)coordinate.Location.Y + (float)offsetY;
                            if (index == 0)
                            {
                                gcodeStartPath(x, y, "Start PolyLine");
                            }
                            else
                            {
                                gcodeMoveTo(x, y, "");
                            }
                            index++;
                        }
                    }
                }
                gcodeStopPath();
            }
            #endregion
            #region DXFLine
            else if (entity.GetType() == typeof(DXFLine))
            {
                DXFLine line = (DXFLine)entity;
                x          = (float)line.Start.X + (float)offsetX;
                y          = (float)line.Start.Y + (float)offsetY;
                x2         = (float)line.End.X + (float)offsetX;
                y2         = (float)line.End.Y + (float)offsetY;
                isReduceOk = false;
                gcodeStartPath(x, y, "Start Line");
                gcodeMoveTo(x2, y2, "");
                gcodeStopPath();
            }
            #endregion
            #region DXFSpline
            else if (entity.GetType() == typeof(DXFSpline))
            {
                DXFSpline spline = (DXFSpline)entity;
                index = 0;
                double cx0, cy0, cx1, cy1, cx2, cy2, cx3, cy3, cxMirror, cyMirror, lastX, lastY;
                lastX = (double)spline.ControlPoints[0].X + offsetX;
                lastY = (double)spline.ControlPoints[0].Y + offsetY;
                string cmt = "Start Spline " + spline.KnotValues.Count.ToString() + " " + spline.ControlPoints.Count.ToString() + " " + spline.FitPoints.Count.ToString();
                gcodeStartPath(lastX, lastY, cmt);
                isReduceOk = true;

                for (int rep = 0; rep < spline.ControlPointCount; rep += 4)
                {
                    cx0       = (double)spline.ControlPoints[rep].X + offsetX; cy0 = (double)spline.ControlPoints[rep].Y + offsetY;
                    cx1       = (double)spline.ControlPoints[rep + 1].X + offsetX; cy1 = (double)spline.ControlPoints[rep + 1].Y + offsetY;
                    cx2       = (double)spline.ControlPoints[rep + 2].X + offsetX; cy2 = (double)spline.ControlPoints[rep + 2].Y + offsetY;
                    cx3       = (double)spline.ControlPoints[rep + 3].X + offsetX; cy3 = (double)spline.ControlPoints[rep + 3].Y + offsetY;
                    points    = new System.Windows.Point[4];
                    points[0] = new System.Windows.Point(cx0, cy0); //(qpx1, qpy1);
                    points[1] = new System.Windows.Point(cx1, cy1); //(qpx1, qpy1);
                    points[2] = new System.Windows.Point(cx2, cy2); //(qpx2, qpy2);
                    points[3] = new System.Windows.Point(cx3, cy3);
                    cxMirror  = cx3 - (cx2 - cx3); cyMirror = cy3 - (cy2 - cy3);
                    lastX     = cx3; lastY = cy3;
                    var b = GetBezierApproximation(points, dxfBezierAccuracy);
                    for (int i = 1; i < b.Points.Count; i++)
                    {
                        gcodeMoveTo((float)b.Points[i].X, (float)b.Points[i].Y, "");
                    }
                }
                gcodeStopPath();
            }
            #endregion
            #region DXFCircle
            else if (entity.GetType() == typeof(DXFCircle))
            {
                DXFCircle circle = (DXFCircle)entity;
                x = (float)circle.Center.X + (float)offsetX;
                y = (float)circle.Center.Y + (float)offsetY;
                gcodeStartPath(x + circle.Radius, y, "Start Circle");
                gcode.Arc(gcodeString[gcodeStringIndex], 2, (float)x + (float)circle.Radius, (float)y, -(float)circle.Radius, 0, "");
                gcodeStopPath();
            }
            #endregion

            else if (entity.GetType() == typeof(DXFEllipse))
            {
                DXFEllipse circle = (DXFEllipse)entity;
                gcode.Comment(gcodeString[gcodeStringIndex], "Ellipse: " + circle.ColorNumber.ToString());
            }
            #region DXFArc
            else if (entity.GetType() == typeof(DXFArc))
            {
                DXFArc arc = (DXFArc)entity;

                double X          = (double)arc.Center.X + offsetX;
                double Y          = (double)arc.Center.Y + offsetY;
                double R          = arc.Radius;
                double startAngle = arc.StartAngle;
                double endAngle   = arc.EndAngle;
                if (startAngle > endAngle)
                {
                    endAngle += 360;
                }
                double stepwidth = (double)Properties.Settings.Default.importGCSegment;
                float  StepAngle = (float)(Math.Asin(stepwidth / R) * 180 / Math.PI);// Settings.Default.page11arcMaxLengLine);
                double currAngle = startAngle;
                index = 0;
                while (currAngle < endAngle)
                {
                    double angle = currAngle * Math.PI / 180;
                    double rx    = (double)(X + R * Math.Cos(angle));
                    double ry    = (double)(Y + R * Math.Sin(angle));
                    if (index == 0)
                    {
                        gcodeStartPath(rx, ry, "Start Arc");
                        isReduceOk = true;
                    }
                    else
                    {
                        gcodeMoveTo(rx, ry, "");
                    }
                    currAngle += StepAngle;
                    if (currAngle > endAngle)
                    {
                        double angle2 = endAngle * Math.PI / 180;
                        double rx2    = (double)(X + R * Math.Cos(angle2));
                        double ry2    = (double)(Y + R * Math.Sin(angle2));

                        if (index == 0)
                        {
                            gcodeStartPath(rx2, ry2, "Start Arc");
                        }
                        else
                        {
                            gcodeMoveTo(rx2, ry2, "");
                        }
                    }
                    index++;
                }
                gcodeStopPath();
            }
            #endregion
            #region DXFMText
            else if (entity.GetType() == typeof(DXFMText))
            {   // https://www.autodesk.com/techpubs/autocad/acad2000/dxf/mtext_dxf_06.htm
                DXFMText txt    = (DXFMText)entity;
                xyPoint  origin = new xyPoint(0, 0);
                GCodeFromFont.reset();

                foreach (var entry in txt.Entries)
                {
                    if (entry.GroupCode == 1)
                    {
                        GCodeFromFont.gcText = entry.Value.ToString();
                    }
                    else if (entry.GroupCode == 40)
                    {
                        GCodeFromFont.gcHeight = Convert.ToDouble(entry.Value);
                    }                                                                                          // gcode.Comment(gcodeString[gcodeStringIndex], "Height "+entry.Value); }
                    else if (entry.GroupCode == 41)
                    {
                        GCodeFromFont.gcWidth = Convert.ToDouble(entry.Value);
                    }                                                                                        // gcode.Comment(gcodeString[gcodeStringIndex], "Width "+entry.Value); }
                    else if (entry.GroupCode == 71)
                    {
                        GCodeFromFont.gcAttachPoint = Convert.ToInt16(entry.Value);
                    }                                                                                             // gcode.Comment(gcodeString[gcodeStringIndex], "Origin " + entry.Value); }
                    else if (entry.GroupCode == 10)
                    {
                        GCodeFromFont.gcOffX = Convert.ToDouble(entry.Value);
                    }
                    else if (entry.GroupCode == 20)
                    {
                        GCodeFromFont.gcOffY = Convert.ToDouble(entry.Value);
                    }
                    else if (entry.GroupCode == 50)
                    {
                        GCodeFromFont.gcAngle = Convert.ToDouble(entry.Value);
                    }                                                                                        // gcode.Comment(gcodeString[gcodeStringIndex], "Angle " + entry.Value); }
                    else if (entry.GroupCode == 44)
                    {
                        GCodeFromFont.gcSpacing = Convert.ToDouble(entry.Value);
                    }
                    else if (entry.GroupCode == 7)
                    {
                        GCodeFromFont.gcFontName = entry.Value.ToString();
                    }
                }
                GCodeFromFont.getCode(gcodeString[gcodeStringIndex]);
            }
            #endregion
            else
            {
                gcode.Comment(gcodeString[gcodeStringIndex], "Unknown: " + entity.GetType().ToString());
            }
        }
Esempio n. 12
0
        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            double minx   = VisuGCode.drawingSize.minX;                // extend dimensions
            double maxx   = VisuGCode.drawingSize.maxX;
            double miny   = VisuGCode.drawingSize.minY;
            double maxy   = VisuGCode.drawingSize.maxY;
            double xRange = (maxx - minx);                                              // calculate new size
            double yRange = (maxy - miny);

            if (Properties.Settings.Default.machineLimitsFix)
            {
                double offset = (double)Properties.Settings.Default.machineLimitsRangeX / 40;       // view size
                minx   = (double)Properties.Settings.Default.machineLimitsHomeX - grbl.posWCO.X - offset;
                miny   = (double)Properties.Settings.Default.machineLimitsHomeY - grbl.posWCO.Y - offset;
                xRange = (double)Properties.Settings.Default.machineLimitsRangeX + 2 * offset;
                yRange = (double)Properties.Settings.Default.machineLimitsRangeY + 2 * offset;
            }

            double picScaling = Math.Min(pictureBox1.Width / (xRange), pictureBox1.Height / (yRange));               // calculate scaling px/unit

            if ((picScaling > 0.001) && (picScaling < 10000))
            {
                double offsetX = 0; // pBoxTransform.OffsetX;
                double offsetY = 0; // pBoxTransform.OffsetY;
                try { offsetX = pBoxTransform.OffsetX; offsetY = pBoxTransform.OffsetY; } catch { } // pBoxTransform.Dispose  too early
                double relposX   = (Convert.ToDouble(pictureBox1.PointToClient(MousePosition).X) - offsetX) / Convert.ToDouble(pictureBox1.Width) / Convert.ToDouble(zoomFactor);
                double relposY   = (Convert.ToDouble(pictureBox1.PointToClient(MousePosition).Y) - offsetY) / Convert.ToDouble(pictureBox1.Height) / Convert.ToDouble(zoomFactor);
                double ratioVisu = xRange / yRange;
                double ratioPic  = Convert.ToDouble(pictureBox1.Width) / pictureBox1.Height;

                double maxposY = yRange;
                if (ratioVisu > ratioPic)
                {
                    relposY = relposY * ratioVisu / ratioPic;
                    maxposY = xRange * pictureBox1.Height / pictureBox1.Width;
                }
                else
                {
                    relposX = relposX * ratioPic / ratioVisu;
                }

                picAbsPos.X = relposX * xRange + minx;
//                picAbsPos.Y = yRange - relposY * yRange + miny;
                picAbsPos.Y = maxposY - relposY * yRange + miny;

                if (posIsMoving)
                {
                    posMoveEnd = picAbsPos;
                }

/* Label position */
                int offX = +5, offY = -10;
                if (pictureBox1.PointToClient(MousePosition).X > (pictureBox1.Width / 2))
                {
                    offX = -75;
                }
                if (pictureBox1.PointToClient(MousePosition).Y > (pictureBox1.Height / 2))
                {
                    offY = -30;
                }

                Point stringpos = new Point(pictureBox1.PointToClient(MousePosition).X + offX, pictureBox1.PointToClient(MousePosition).Y + offY);

                pBoxOrig = e.Graphics.Transform;
                try { e.Graphics.Transform = pBoxTransform; } catch { }
                e.Graphics.ScaleTransform((float)picScaling, (float)-picScaling);           // apply scaling (flip Y)
                //      e.Graphics.TranslateTransform((float)-minx, (float)(-yRange - miny));       // apply offset
                e.Graphics.TranslateTransform((float)-minx, (float)(-maxposY - miny));      // apply offset

                try
                {
                    if (showPaths)          // only show graphics path if something is loaded
                    {
                        if (!showPicBoxBgImage)
                        {
                            onPaint_drawToolPath(e.Graphics);   // draw real path if background image is not shown
                        }
                        e.Graphics.DrawPath(penTool, VisuGCode.pathTool);
                        e.Graphics.DrawPath(penMarker, VisuGCode.pathMarker);

                        e.Graphics.Transform = pBoxOrig;
                        if (Properties.Settings.Default.machineLimitsShow)
                        {
                            e.Graphics.FillRectangle(brushBackground, new Rectangle(stringpos.X, stringpos.Y - 2, 75, 34));
                            e.Graphics.FillRectangle(brushBackground, new Rectangle(18, 3, 140, 50));
                            if (VisuGCode.selectedFigureInfo.Length > 0)
                            {
                                e.Graphics.FillRectangle(brushBackground, new Rectangle(148, 3, 160, 50));
                            }
                        }
                        if (Properties.Settings.Default.gui2DInfoShow)
                        {
                            string unit = (Properties.Settings.Default.importUnitmm) ? "mm" : "Inch";
                            e.Graphics.DrawString(String.Format("Work-Pos:\r\nX:{0,7:0.000}\r\nY:{1,7:0.000}", picAbsPos.X, picAbsPos.Y), new Font("Lucida Console", 8), Brushes.Black, stringpos);
                            if (simuEnabled)
                            {
                                e.Graphics.DrawString(String.Format("Zooming   : {0,2:0.00}%\r\nRuler Unit: {1}\r\nMarker-Pos:\r\n X:{2,7:0.000}\r\n Y:{3,7:0.000}\r\n Z:{4,7:0.000}\r\n a:{5,7:0.000}°", 100 * zoomFactor, unit,
                                                                    grbl.posMarker.X, grbl.posMarker.Y, VisuGCode.Simulation.getZ(), 180 * grbl.posMarkerAngle / Math.PI), new Font("Lucida Console", 7), Brushes.Black, new Point(20, 5));
                            }
                            else
                            {
                                e.Graphics.DrawString(String.Format("Zooming   : {0,2:0.00}%\r\nRuler Unit: {1}\r\nMarker-Pos:\r\n X:{2,7:0.000}\r\n Y:{3,7:0.000}", 100 * zoomFactor, unit,
                                                                    grbl.posMarker.X, grbl.posMarker.Y), new Font("Lucida Console", 7), Brushes.Black, new Point(20, 5));
                            }

                            if (VisuGCode.selectedFigureInfo.Length > 0)
                            {
                                e.Graphics.DrawString(VisuGCode.selectedFigureInfo, new Font("Lucida Console", 7), Brushes.Black, new Point(150, 5));
                            }
                        }
                    }
                }
                catch { }
            }
        }
Esempio n. 13
0
        private void pictureBox1_Paint(object sender, PaintEventArgs e)
        {
            double minx   = GCodeVisuAndTransform.drawingSize.minX;                // extend dimensions
            double maxx   = GCodeVisuAndTransform.drawingSize.maxX;
            double miny   = GCodeVisuAndTransform.drawingSize.minY;
            double maxy   = GCodeVisuAndTransform.drawingSize.maxY;
            double xRange = (maxx - minx);                                              // calculate new size
            double yRange = (maxy - miny);

            if (Properties.Settings.Default.machineLimitsFix)
            {
                RectangleF tmp;
                float      offset = (float)Properties.Settings.Default.machineLimitsRangeX / 40; // view size
                tmp    = GCodeVisuAndTransform.pathMachineLimit.GetBounds();
                minx   = (float)Properties.Settings.Default.machineLimitsHomeX - (float)grbl.posWCO.X - offset;
                miny   = (float)Properties.Settings.Default.machineLimitsHomeY - (float)grbl.posWCO.Y - offset;
                xRange = (float)Properties.Settings.Default.machineLimitsRangeX + 2 * offset;
                yRange = (float)Properties.Settings.Default.machineLimitsRangeY + 2 * offset;
            }

            double picScaling = Math.Min(pictureBox1.Width / (xRange), pictureBox1.Height / (yRange));               // calculate scaling px/unit
            string unit       = (Properties.Settings.Default.importUnitmm) ? "mm" : "Inch";

            if ((picScaling > 0.001) && (picScaling < 10000))
            {
                //            double relposX = zoomOffsetX +  (Convert.ToDouble(pictureBox1.PointToClient(MousePosition).X - zoomTranslationOld.X ) / pictureBox1.Width) / zoomFactor;
                //            double relposY = zoomOffsetY +  (Convert.ToDouble(pictureBox1.PointToClient(MousePosition).Y - zoomTranslationOld.Y ) / pictureBox1.Height) / zoomFactor;
                double relposX   = (Convert.ToDouble(pictureBox1.PointToClient(MousePosition).X - pBoxTransform.OffsetX) / pictureBox1.Width) / zoomFactor;
                double relposY   = (Convert.ToDouble(pictureBox1.PointToClient(MousePosition).Y - pBoxTransform.OffsetY) / pictureBox1.Height) / zoomFactor;
                double ratioVisu = xRange / yRange;
                double ratioPic  = Convert.ToDouble(pictureBox1.Width) / pictureBox1.Height;
                if (ratioVisu > ratioPic)
                {
                    relposY = relposY * ratioVisu / ratioPic;
                }
                else
                {
                    relposX = relposX * ratioPic / ratioVisu;
                }

                picAbsPos.X = relposX * xRange + minx;
                picAbsPos.Y = yRange - relposY * yRange + miny;
                posMoveEnd  = picAbsPos;
                int offX = +5;

                if (pictureBox1.PointToClient(MousePosition).X > (pictureBox1.Width - 100))
                {
                    offX = -75;
                }

                Point stringpos = new Point(pictureBox1.PointToClient(MousePosition).X + offX, pictureBox1.PointToClient(MousePosition).Y - 10);

                pBoxOrig             = e.Graphics.Transform;
                e.Graphics.Transform = pBoxTransform;
                e.Graphics.ScaleTransform((float)picScaling, (float)-picScaling);     // apply scaling (flip Y)
                e.Graphics.TranslateTransform((float)-minx, (float)(-yRange - miny)); // apply offset

                if (showPaths)                                                        // only show graphics path if something is loaded
                {
                    if (!showPicBoxBgImage)
                    {
                        onPaint_drawToolPath(e.Graphics);   // draw real path if background image is not shown
                    }
                    e.Graphics.DrawPath(penMarker, GCodeVisuAndTransform.pathMarker);
                    e.Graphics.DrawPath(penTool, GCodeVisuAndTransform.pathTool);

                    e.Graphics.Transform = pBoxOrig;
                    if (Properties.Settings.Default.machineLimitsShow)
                    {
                        e.Graphics.FillRectangle(brushBackground, new Rectangle(stringpos.X, stringpos.Y - 2, 75, 34));
                        e.Graphics.FillRectangle(brushBackground, new Rectangle(18, 3, 140, 50));
                    }
                    if (Properties.Settings.Default.gui2DInfoShow)
                    {
                        e.Graphics.DrawString(String.Format("Work-Pos:\r\nX:{0,7:0.000}\r\nY:{1,7:0.000}", picAbsPos.X, picAbsPos.Y), new Font("Lucida Console", 8), Brushes.Black, stringpos);
                        e.Graphics.DrawString(String.Format("Zooming   : {0,2:0.00}%\r\nRuler Unit: {1}\r\nMarker-Pos:\r\n X:{2,7:0.000}\r\n Y:{3,7:0.000}", 100 * zoomFactor, unit,
                                                            grbl.posMarker.X, grbl.posMarker.Y), new Font("Lucida Console", 7), Brushes.Black, new Point(20, 5));
                        if (visuGCode.selectedFigureInfo.Length > 0)
                        {
                            e.Graphics.DrawString(visuGCode.selectedFigureInfo, new Font("Lucida Console", 7), Brushes.Black, new Point(150, 5));
                        }
                    }
                }
            }
        }
Esempio n. 14
0
        public static string transformGCodeRadiusCorrection(double radius)
        {
            Logger.Debug("Radius correction r: {0}", radius);
#if (debuginfo)
            log.clear();
            log.Add("### GCodeVisu radius correction ###");
#endif
            if (gcodeList == null)
            {
                return("");
            }

            if (lastFigureNumber > 0)
            {
                pathBackground  = (GraphicsPath)pathMarkSelection.Clone();
                origWCOLandMark = (xyPoint)grbl.posWCO;
            }
            else
            {
                pathBackground  = (GraphicsPath)pathPenDown.Clone();
                origWCOLandMark = (xyPoint)grbl.posWCO;
            }

            xyPoint[] offset = new xyPoint[4];
            int       i, figureStart, figure2nd, prev, act, next;
            int       counter = 0, isFirst = 0;
            bool      figureProcessed = false;
            bool      closeFigure     = false;
            bool      endFigure       = false;

            figure2nd = figureStart = prev = act = next = 0;
            int offType = 0;

            for (i = 1; i < gcodeList.Count; i++)
            {
                if ((i == (gcodeList.Count - 1)) || ((lastFigureNumber > 0) && (gcodeList[i].figureNumber != lastFigureNumber))) // if wrong selection, nothing to do
                {
                    if (figureProcessed)                                                                                         // correct last point
                    {
                        figureProcessed = false;
                        goto ProcessesPath;
                    }
                    continue;
                }

                if (gcodeList[i].ismachineCoordG53)     // machine coordinates, do not change
                {
                    continue;
                }

                if (!xyMove(gcodeList[i]))              // no xy moves, nothing to do - except G0 Z
                {
                    continue;
                }

                while ((gcodeList[i].codeLine == gcodeList[i + 1].codeLine) && (i < gcodeList.Count))  // remove double lines (lff font)
                {
                    gcodeList.RemoveAt(i + 1);
                }

                while (sameXYPos(gcodeList[i], gcodeList[i + 1]) && (i < (gcodeList.Count - 1)))  // remove double coordinates
                {
                    gcodeList.RemoveAt(i + 1);
                }

#if (debuginfo)
                log.Add("----- " + i.ToString() + " -----");
#endif
                if (gcodeList[i].motionMode > 1)
                {
                    double tmpR       = Math.Sqrt((double)gcodeList[i].i * (double)gcodeList[i].i + (double)gcodeList[i].j * (double)gcodeList[i].j);
                    bool   remove     = false;
                    double abs_radius = Math.Abs(radius);
                    if (gcodeList[i].motionMode == 2)
                    {
                        if ((radius < 0) && (tmpR < abs_radius))
                        {
                            remove = true;
                        }
                    }
                    if (gcodeList[i].motionMode == 3)
                    {
                        if ((radius > 0) && (tmpR < abs_radius))
                        {
                            remove = true;
                        }
                    }
                    if (remove)
                    {
                        gcodeList[i].i          = null; gcodeList[i].j = null;
                        gcodeList[i].motionMode = 1;
#if (debuginfo)
                        log.Add("Radius too small, do G1 " + gcodeList[act].codeLine + " ##############################");
#endif
                    }
                }
                figureProcessed = true;                 // must stay before jump label
                next            = i;
                endFigure       = false;

ProcessesPath:
                //               gcodeList[i].info += " "+i.ToString()+" "+ figureProcessed.ToString()+" "+lastFigureNumber.ToString();
                if (counter == 0)
                {
                    figureStart = prev = act = next;
                }                                                                          // preset indices

                if ((gcodeList[prev].motionMode == 0) && (gcodeList[act].motionMode >= 1)) // find start of figure
                {
                    figureStart = prev; figure2nd = act; isFirst = 0;
                }                                                                          //gcodeList[prev].info += " #start "; }

                if ((gcodeList[act].motionMode >= 1) && (gcodeList[next].motionMode == 0)) // find end of figure
                {
                    endFigure = true; figureProcessed = false;
                }                                             // gcodeList[act].info += " #end ";            }

                closeFigure = false;
                if (act != prev)
                {
                    xyArcPoint p1 = fillPointData(prev, prev);
                    xyArcPoint p2 = fillPointData(prev, act);

                    if ((gcodeList[act].actualPos.X == gcodeList[figureStart].actualPos.X) && (gcodeList[act].actualPos.Y == gcodeList[figureStart].actualPos.Y))
                    {
                        next = figure2nd; closeFigure = true;
                    }                                        //                    gcodeList[act].info += " closefig "; }

#if (debuginfo)
                    log.Add(gcodeList[act].codeLine);
#endif
                    offType = createOffsetedPath((isFirst++ == 0), (endFigure && !closeFigure), figureStart, prev, act, next, radius, ref offset);
#if (debuginfo)
                    log.Add(string.Format(" typ {0} {1} {2} {3} {4} {5} ", offType, endFigure, figureStart, prev, act, next));
#endif
                    if (closeFigure)// && !endFigure)
                    {
#if (debuginfo)
                        log.Add(string.Format(" close Figure {0:0.00} {1:0.00}  ", offset[2].X, offset[2].Y));
#endif
                        gcodeList[figureStart].x = offset[2].X; gcodeList[figureStart].y = offset[2].Y; // close figure
                        if (gcodeList[figure2nd].motionMode > 1)                                        // act
                        {
                            bool isFullCircle = ((p1.X == p2.X) && (p1.Y == p2.Y));
                            if (!isFullCircle)
                            {
                                xyArcPoint p3 = fillPointData(prev, act);     //fillPointData(act, next);
                                gcodeList[figure2nd].i = p3.CX - offset[2].X;
                                gcodeList[figure2nd].j = p3.CY - offset[2].Y; // offset radius
#if (debuginfo)
                                log.Add(string.Format(" correct Arc center of f2nd {0} origX {1:0.00} origY {2:0.00}  ", figure2nd, p3.CX, p3.CY));
#endif
                            }
                        }
                    }
                    next = i;         // restore next
                    if (offType >= 1) // arc or line was inserted to connect points
                    {
                        act++; next++; counter++; i++;
                    }                                       // inc. counters
                }

                prev = act; act = next; counter++;

                if (endFigure)
                {
                    prev = act; figureStart = act = i;
                }                                         // preset indices

                if (closeFigure)
                {
                    isFirst = 0;
                }
            }
            return(createGCodeProg());
        }
Esempio n. 15
0
        /// <summary>
        /// mirror gcode
        /// </summary>
        public static string transformGCodeMirror(translate shiftToZero = translate.MirrorX)
        {
            Logger.Debug("Mirror {0}", shiftToZero);
#if (debuginfo)
            log.Add("   GCodeVisu transform Mirror");
#endif
            if (gcodeList == null)
            {
                return("");
            }

            xyPoint centerOfFigure = xyzSize.getCenter();
            if (lastFigureNumber > 0)
            {
                centerOfFigure = getCenterOfMarkedFigure();
            }

            oldLine.resetAll(grbl.posWork);         // reset coordinates and parser modes
            clearDrawingnPath();                    // reset path, dimensions

            foreach (gcodeByLine gcline in gcodeList)
            {
                if ((lastFigureNumber > 0) && (gcline.figureNumber != lastFigureNumber))
                {
                    continue;
                }

                if (!gcline.ismachineCoordG53)
                {
                    // switch circle direction
                    if ((shiftToZero == translate.MirrorX) || (shiftToZero == translate.MirrorY))           // mirror xy
                    {
                        if (gcline.motionMode == 2)
                        {
                            gcline.motionMode = 3;
                        }
                        else if (gcline.motionMode == 3)
                        {
                            gcline.motionMode = 2;
                        }
                    }
                    if (shiftToZero == translate.MirrorX)           // mirror x
                    {
                        if (gcline.x != null)
                        {
                            //                            if (gcline.isdistanceModeG90)
                            //                                gcline.x = oldmaxx - gcline.x;
                            //                            else
                            gcline.x = -gcline.x + 2 * centerOfFigure.X;
                        }
                        gcline.i = -gcline.i;
                    }
                    if (shiftToZero == translate.MirrorY)           // mirror y
                    {
                        if (gcline.y != null)
                        {
                            //                            if (gcline.isdistanceModeG90)
                            //                                gcline.y = oldmaxy - gcline.y;
                            //                            else
                            gcline.y = -gcline.y + 2 * centerOfFigure.Y;
                        }
                        gcline.j = -gcline.j;
                    }
                    if (shiftToZero == translate.MirrorRotary)           // mirror rotary
                    {
                        string rotary = Properties.Settings.Default.ctrl4thName;
                        if ((rotary == "A") && (gcline.a != null))
                        {
                            gcline.a = -gcline.a;
                        }
                        else if ((rotary == "B") && (gcline.b != null))
                        {
                            gcline.b = -gcline.b;
                        }
                        else if ((rotary == "C") && (gcline.c != null))
                        {
                            gcline.c = -gcline.c;
                        }
                    }

                    calcAbsPosition(gcline, oldLine);
                    oldLine = new gcodeByLine(gcline);   // get copy of newLine
                }
            }
            return(createGCodeProg());
        }
Esempio n. 16
0
      public double distance;          // distance to specific point

      public coordByLine(int line, int figure, xyPoint p)
      {
          lineNumber = line; figureNumber = figure; actualPos = p; distance = -1;
      }
Esempio n. 17
0
 public coordByLine(int line, int figure, xyPoint p, double dist)
 {
     lineNumber = line; figureNumber = figure; actualPos = p; distance = dist;
 }
Esempio n. 18
0
 public static void MoveToSimple(xyPoint coordxy, string cmt, bool rapid = false)
 {
     MoveToSimple(new Point(coordxy.X, coordxy.Y), cmt, rapid);
 }
        private void pictureBoxVideo_Paint(object sender, PaintEventArgs e)
        {
            double diff = cameraPosTop - cameraPosBot;

            if (diff == 0)
            {
                diff = 1;
            }
            double m             = (cameraScalingTop - cameraScalingBot) / diff;
            double n             = cameraScalingTop - m * cameraPosTop;
            float  actualScaling = (float)Math.Abs(grbl.posMachine.Z * m + n);

            if (actualScaling < 1)
            {
                actualScaling = 5;
            }

            int gap   = 5;
            int chlen = 200;

            e.Graphics.DrawLine(pen1, new System.Drawing.Point(xmid - chlen, ymid), new System.Drawing.Point(xmid - gap, ymid));
            e.Graphics.DrawLine(pen1, new System.Drawing.Point(xmid + gap, ymid), new System.Drawing.Point(xmid + chlen, ymid));
            e.Graphics.DrawLine(pen1, new System.Drawing.Point(xmid, ymid - chlen), new System.Drawing.Point(xmid, ymid - gap));
            e.Graphics.DrawLine(pen1, new System.Drawing.Point(xmid, ymid + gap), new System.Drawing.Point(xmid, ymid + chlen));

            realPosition.X = 2 * (Convert.ToDouble(pictureBoxVideo.PointToClient(MousePosition).X) / pictureBoxVideo.Size.Width - 0.5) * actualScaling / cameraZoom;
            realPosition.Y = -2 * (Convert.ToDouble(pictureBoxVideo.PointToClient(MousePosition).Y) / pictureBoxVideo.Size.Height - 0.5) * actualScaling * ratio / cameraZoom;
            int stringposY = -40;

            if (realPosition.Y > 0)
            {
                stringposY = 10;
            }
            System.Drawing.Point stringpos = new System.Drawing.Point(pictureBoxVideo.PointToClient(MousePosition).X - 60, pictureBoxVideo.PointToClient(MousePosition).Y + stringposY);
            if (teachingTop)
            {
                radius = (int)(cameraTeachRadiusTop * cameraZoom * xmid / actualScaling);
                e.Graphics.DrawEllipse(pen1, new Rectangle(xmid - radius, ymid - radius, 2 * radius, 2 * radius));
                string txt = "Next click will teach scaling\r\n of camera view to " + cameraTeachRadiusTop.ToString();
                showLabel(txt, stringpos, e.Graphics);
            }
            else if (teachingBot)
            {
                radius = (int)(cameraTeachRadiusBot * cameraZoom * xmid / actualScaling);
                e.Graphics.DrawEllipse(pen1, new Rectangle(xmid - radius, ymid - radius, 2 * radius, 2 * radius));
                string txt = "Next click will teach scaling\r\n of camera view to " + cameraTeachRadiusBot.ToString();
                showLabel(txt, stringpos, e.Graphics);
            }
            else if (measureAngle)
            {
                measureAngleStop = (xyPoint)pictureBoxVideo.PointToClient(MousePosition);
                e.Graphics.DrawLine(pen1, measureAngleStart.ToPoint(), measureAngleStop.ToPoint());
                angle = (float)measureAngleStart.AngleTo(measureAngleStop);
                string txt = String.Format("Angle: {0:0.00}", angle);
                showLabel(txt, stringpos, e.Graphics);
            }
            else
            {
                xyPoint absolute = (xyPoint)grbl.posWork + realPosition;
                string  txt      = String.Format("Relative {0:0.00} ; {1:0.00}\r\nAbsolute {2:0.00} ; {3:0.00}", realPosition.X, realPosition.Y, absolute.X, absolute.Y);
                showLabel(txt, stringpos, e.Graphics);
            }

/*            if (teachTP1)
 *          {
 *              angle = (float)measureAngleStart.AngleTo(measureAngleStop);
 *              e.Graphics.DrawString(String.Format("Angle: {0:0.00}", angle), new Font("Microsoft Sans Serif", 8), brushText, stringpos);
 *          }*/
            float scale = (float)(xmid / actualScaling * cameraZoom);

            e.Graphics.ScaleTransform(scale, -scale);
            float offX = (float)(xmid / scale - grbl.posWork.X);
            float offY = (float)(ymid / scale + grbl.posWork.Y);

            e.Graphics.TranslateTransform(offX, -offY);       // apply offset
            // show drawing from MainForm (static members of class GCodeVisualization)
            if (showOverlay)
            {
                e.Graphics.DrawPath(penRuler, VisuGCode.pathRuler);
                e.Graphics.DrawPath(penMarker, VisuGCode.pathMarker);
                e.Graphics.DrawPath(penDown, VisuGCode.pathPenDown);
                e.Graphics.DrawPath(penUp, VisuGCode.pathPenUp);
                //           e.Graphics.DrawEllipse(penTeach, new Rectangle((int)actualPosMarker.X-2, (int)actualPosMarker.Y - 2, (int)actualPosMarker.X + 2, (int)actualPosMarker.Y + 2));
            }
        }
Esempio n. 20
0
 public void setPosMarker(xyPoint tmp)// double x, double y)
 {
     actualPosMarker = tmp;
 }
Esempio n. 21
0
      public void calcDistance(xyPoint tmp)
      {
          xyPoint delta = new xyPoint(tmp - (xyPoint)actualPos);

          distance = Math.Sqrt(delta.X * delta.X + delta.Y * delta.Y);
      }
Esempio n. 22
0
 public xyPoint(xyPoint tmp)
 {
     X = tmp.X; Y = tmp.Y;
 }
Esempio n. 23
0
 public static double getAlpha(xyPoint pOld, xyPoint pNew)
 {
     return(getAlpha(pOld.X, pOld.Y, pNew.X, pNew.Y));
 }
Esempio n. 24
0
 public xyzPoint(xyPoint xy, double z, double a = 0)
 {
     X = xy.X; Y = xy.Y; Z = z; A = a; B = 0; C = 0;
 }
Esempio n. 25
0
            public static int Next()
            {
                if (isIntermediate)
                {
                    isIntermediate = calcIntermediatePos();
                }
                if (!isIntermediate)
                {
                    if (!getNextPos())                      //  finish simu if nextPos = false
                    {
                        grbl.posMarker      = (xyPoint)codeNext.actualPos;
                        grbl.posMarkerAngle = codeNext.alpha;
                        createMarkerPath(false, (xyPoint)codeNext.actualPos);
                        return(-1);
                    }
                    if (remainingStep <= 0)
                    {
                        remainingStep += stepWidth;
                    }
                    remainingStep -= distance;

                    if (remainingStep == 0)                 // just next full pos
                    {
                        grbl.posMarker      = (xyPoint)codeNext.actualPos;
                        grbl.posMarkerAngle = codeNext.alpha;
                        createMarkerPath(false, (xyPoint)codeNext.actualPos);
                        posXY = grbl.posMarker;
                        posA  = grbl.posMarkerAngle;
                        return(codeNext.lineNumber);
                    }
                    else if (remainingStep > 0)             // move too short, get next gcode
                    {
                        while (remainingStep > 0)
                        {
                            if (!getNextPos())              //  finish simu if nextPos = false //  calc distance & remaining steps
                            {
                                grbl.posMarker      = (xyPoint)codeNext.actualPos;
                                grbl.posMarkerAngle = codeNext.alpha;
                                createMarkerPath(false, (xyPoint)codeNext.actualPos);
                                return(-codeNext.lineNumber);
                            }
                            remainingStep -= distance;
                        }
                        if (remainingStep == 0)             // just next full pos
                        {
                            grbl.posMarker      = (xyPoint)codeNext.actualPos;
                            grbl.posMarkerAngle = codeNext.alpha;
                            createMarkerPath(false, (xyPoint)codeNext.actualPos);
                            posXY = grbl.posMarker;
                            posA  = grbl.posMarkerAngle;
                            return(codeNext.lineNumber);
                        }
                    }
                    // remainingStep < 0 calc intermediate steps
                    posXY          = (xyPoint)codeLast.actualPos;
                    posAngle       = codeLast.alpha;
                    posZ           = codeLast.actualPos.Z;
                    posA           = codeLast.alpha;
                    diff.XY        = ((xyPoint)codeLast.actualPos).DistanceTo((xyPoint)codeNext.actualPos);
                    diff.Z         = Math.Abs(codeNext.actualPos.Z - codeLast.actualPos.Z);
                    diff.A         = Math.Abs(codeNext.alpha - codeLast.alpha);
                    isIntermediate = true;
//                    Logger.Trace(" astart {0} aend {1}", 180*arcMove.angleStart/Math.PI, 180*arcMove.angleEnd/Math.PI);
                    calcIntermediatePos();
                    remainingStep = stepWidth;
                }
                grbl.posMarker      = posXY;
                grbl.posMarkerAngle = posA;  // posAngle;
                createMarkerPath(false, posXY);
                return(codeNext.lineNumber);
            }
Esempio n. 26
0
        /// <summary>
        /// Process entities
        /// </summary>
        private static void processEntities(DXFEntity entity, double offsetX = 0, double offsetY = 0, bool updateColor = true)
        {
            int    index = 0;
            double x, y;//, x2 = 0, y2 = 0, bulge;

            if (updateColor)
            {
                dxfColorID       = entity.ColorNumber;
                Plotter.PathName = "Layer:" + entity.LayerName;
            }

            Plotter.PathDashArray = new double[0];                  // default no dashes
            if ((entity.LineType == null) || (entity.LineType == "ByLayer"))
            {
                if (layerLType.ContainsKey(entity.LayerName))        // check if layer name is known
                {
                    string dashType = layerLType[entity.LayerName];  // get name of pattern
                    if (lineTypes.ContainsKey(dashType))             // check if pattern name is known
                    {
                        Plotter.PathDashArray = lineTypes[dashType]; // apply pattern
                    }
                }
            }
            else
            {
                if (lineTypes.ContainsKey(entity.LineType))             // check if pattern name is known
                {
                    Plotter.PathDashArray = lineTypes[entity.LineType]; // apply pattern
                }
            }

            if (dxfColorID > 255)
            {
                if (layerColor.ContainsKey(entity.LayerName))
                {
                    dxfColorID = layerColor[entity.LayerName];
                }
            }

            if (dxfColorID < 0)
            {
                dxfColorID = 0;
            }
            if (dxfColorID > 255)
            {
                dxfColorID = 7;
            }
            if (Properties.Settings.Default.importDXFSwitchWhite && (dxfColorID == 7))
            {
                dxfColorID = 0;
            }

            dxfColorHex       = getColorFromID(dxfColorID);
            Plotter.PathColor = dxfColorHex;

            if (dxfUseColorIndex)
            {
                toolNr = dxfColorID + 1;      // avoid ID=0 to start tool-table with index 1
            }
            else
            {
                toolNr = toolTable.getToolNr(dxfColorHex, 0);
                //Logger.Trace("toolNr = {0}",toolNr);
            }

            Plotter.SetGroup(toolNr);       // set index if grouping and tool

            if (dxfColorIDold != dxfColorID)
            {
                Plotter.PenUp("");

                toolToUse = toolNr;
                if (Properties.Settings.Default.importGCToolTableUse && Properties.Settings.Default.importGCToolDefNrUse)
                {
                    toolToUse = (int)Properties.Settings.Default.importGCToolDefNr;
                }

                Plotter.PathToolNr = toolToUse;

                if (!groupObjects)
                {
                    if (dxfUseColorIndex)
                    {
                        Plotter.ToolChange(toolToUse, dxfColorID.ToString());   // add tool change commands (if enabled) and set XYFeed etc.
                    }
                    else
                    {
                        Plotter.ToolChange(toolToUse, dxfColorHex);
                    }
                }
            }
            dxfColorIDold = dxfColorID;

            Logger.Trace("  Entity: {0}", entity.GetType().ToString());

            if (entity.GetType() == typeof(DXFPointEntity))
            {
                DXFPointEntity point = (DXFPointEntity)entity;
                x = (float)point.Location.X + (float)offsetX;
                y = (float)point.Location.Y + (float)offsetY;
                if (!nodesOnly)
                {
                    dxfStartPath(x, y, "Start Point");
                    dxfStopPath();
                }
                else
                {
                    gcodeDotOnly(x, y, "Start Point");
                }
                Logger.Trace("    Point: {0};{1} ", x, y);
            }

            #region DXFLWPolyline
            else if (entity.GetType() == typeof(DXFLWPolyLine))
            {
                DXFLWPolyLine lp = (DXFLWPolyLine)entity;
                index = 0;
                double bulge = 0;
                DXFLWPolyLine.Element coordinate;
                bool roundcorner = false;
                x = 0; y = 0;
                for (int i = 0; i < lp.VertexCount; i++)
                {
                    coordinate = lp.Elements[i];
                    bulge      = coordinate.Bulge;
                    //            x2 = x; y2 = y;
                    x = (double)coordinate.Vertex.X + (double)offsetX;
                    y = (double)coordinate.Vertex.Y + (double)offsetY;
                    //                  Logger.Trace("    Vertex: {0};{1} ", x, y);

                    if (i == 0)
                    {
                        if (!nodesOnly)
                        {
                            dxfStartPath(x, y, "Start LWPolyLine - Nr pts " + lp.VertexCount.ToString());
                            Plotter.IsPathReduceOk = true;
                        }
                        else
                        {
                            gcodeDotOnly(x, y, "Start LWPolyLine");
                        }
                    }

                    if ((!roundcorner))
                    {
                        dxfMoveTo(x, y, "");
                    }
                    if (bulge != 0)
                    {
                        if (i < (lp.VertexCount - 1))
                        {
                            AddRoundCorner(lp.Elements[i], lp.Elements[i + 1]);
                        }
                        else
                        if (lp.Flags == DXFLWPolyLine.FlagsEnum.closed)
                        {
                            AddRoundCorner(lp.Elements[i], lp.Elements[0]);
                        }
                        roundcorner = true;
                    }
                    else
                    {
                        roundcorner = false;
                    }
                }
                if ((lp.Flags > 0))// && (x2 != x) && (y2 != y))   // only move if prev pos is differnent
                {
                    dxfMoveTo((float)(lp.Elements[0].Vertex.X + offsetX), (float)(lp.Elements[0].Vertex.Y + offsetY), "End LWPolyLine " + lp.Flags.ToString());
                }
                dxfStopPath();
            }
            #endregion
            #region DXFPolyline
            else if (entity.GetType() == typeof(DXFPolyLine))
            {
                DXFPolyLine lp = (DXFPolyLine)entity;
                index = 0;
                foreach (DXFVertex coordinate in lp.Children)
                {
                    if (coordinate.GetType() == typeof(DXFVertex))
                    {
                        if (coordinate.Location.X != null && coordinate.Location.Y != null)
                        {
                            x = (float)coordinate.Location.X + (float)offsetX;
                            y = (float)coordinate.Location.Y + (float)offsetY;
                            //                      Logger.Trace("    Vertex: {0};{1} ", x, y);
                            if (!nodesOnly)
                            {
                                if (index == 0)
                                {
                                    dxfStartPath(x, y, "Start PolyLine");
                                }
                                else
                                {
                                    dxfMoveTo(x, y, "");
                                }
                            }
                            else
                            {
                                gcodeDotOnly(x, y, "PolyLine");
                            }
                            index++;
                        }
                    }
                }
                dxfStopPath();
            }
            #endregion
            #region DXFLine
            else if (entity.GetType() == typeof(DXFLine))
            {
                DXFLine line = (DXFLine)entity;
                x = (double)line.Start.X + offsetX;
                y = (double)line.Start.Y + offsetY;
                double x2 = (double)line.End.X + offsetX;
                double y2 = (double)line.End.Y + offsetY;
                Plotter.IsPathReduceOk = false;
                if (!nodesOnly)
                {
                    dxfStartPath(x, y, "Start Line");
                    dxfMoveTo(x2, y2, "");
                }
                else
                {
                    gcodeDotOnly(x, y, "Start Line");
                    gcodeDotOnly(x2, y2, "End Line");
                }
                dxfStopPath();
                Logger.Trace("    From: {0};{1}  To: {2};{3}", x, y, x2, y2);
            }
            #endregion
            #region DXFSpline
            else if (entity.GetType() == typeof(DXFSpline))
            {   // from Inkscape DXF import - modified
                // https://gitlab.com/inkscape/extensions/blob/master/dxf_input.py#L106
                DXFSpline spline = (DXFSpline)entity;
                index = 0;

                Point  offset = new Point(offsetX, offsetY);
                double lastX  = (double)spline.ControlPoints[0].X + offsetX;
                double lastY  = (double)spline.ControlPoints[0].Y + offsetY;

                string cmt = "Start Spline " + spline.KnotValues.Count.ToString() + " " + spline.ControlPoints.Count.ToString() + " " + spline.FitPoints.Count.ToString();
                Plotter.IsPathReduceOk = true;

                int knots = spline.KnotCount;
                int ctrls = spline.ControlPointCount;
                Logger.Trace("    Spline  ControlPointCnt: {0} KnotsCount: {1}", ctrls, knots);

                if ((ctrls > 3) && (knots == ctrls + 4))    //  # cubic
                {
                    if (ctrls > 4)
                    {
                        for (int i = (knots - 5); i > 3; i--)
                        {
                            if ((spline.KnotValues[i] != spline.KnotValues[i - 1]) && (spline.KnotValues[i] != spline.KnotValues[i + 1]))
                            {
                                double   a0  = (spline.KnotValues[i] - spline.KnotValues[i - 2]) / (spline.KnotValues[i + 1] - spline.KnotValues[i - 2]);
                                double   a1  = (spline.KnotValues[i] - spline.KnotValues[i - 1]) / (spline.KnotValues[i + 2] - spline.KnotValues[i - 1]);
                                DXFPoint tmp = new DXFPoint();
                                tmp.X = (double)((1.0 - a1) * spline.ControlPoints[i - 2].X + a1 * spline.ControlPoints[i - 1].X);
                                tmp.Y = (double)((1.0 - a1) * spline.ControlPoints[i - 2].Y + a1 * spline.ControlPoints[i - 1].Y);
                                spline.ControlPoints.Insert(i - 1, tmp);
                                spline.ControlPoints[i - 2].X = (1.0 - a0) * spline.ControlPoints[i - 3].X + a0 * spline.ControlPoints[i - 2].X;
                                spline.ControlPoints[i - 2].Y = (1.0 - a0) * spline.ControlPoints[i - 3].Y + a0 * spline.ControlPoints[i - 2].Y;
                                spline.KnotValues.Insert(i, spline.KnotValues[i]);
                            }
                        }
                        knots = spline.KnotValues.Count;
                        for (int i = (knots - 6); i > 3; i -= 2)
                        {
                            if ((spline.KnotValues[i] != spline.KnotValues[i - 2]) && (spline.KnotValues[i - 1] != spline.KnotValues[i + 1]) && (spline.KnotValues[i - 2] != spline.KnotValues[i]))
                            {
                                double   a1  = (spline.KnotValues[i] - spline.KnotValues[i - 1]) / (spline.KnotValues[i + 2] - spline.KnotValues[i - 1]);
                                DXFPoint tmp = new DXFPoint();
                                tmp.X = (double)((1.0 - a1) * spline.ControlPoints[i - 2].X + a1 * spline.ControlPoints[i - 1].X);
                                tmp.Y = (double)((1.0 - a1) * spline.ControlPoints[i - 2].Y + a1 * spline.ControlPoints[i - 1].Y);
                                spline.ControlPoints.Insert(i - 1, tmp);
                            }
                        }
                    }
                    ctrls = spline.ControlPoints.Count;
                    dxfStartPath(lastX, lastY, cmt);
                    for (int i = 0; i < Math.Floor((ctrls - 1) / 3d); i++)     // for i in range(0, (ctrls - 1) // 3):
                    {
                        if (!nodesOnly)
                        {
                            importMath.calcCubicBezier(new Point(lastX, lastY), toPoint(spline.ControlPoints[3 * i + 1], offset), toPoint(spline.ControlPoints[3 * i + 2], offset), toPoint(spline.ControlPoints[3 * i + 3], offset), dxfMoveTo, "C");
                        }
                        else
                        {
                            gcodeDotOnly(lastX, lastY, "");
                            gcodeDotOnly(toPoint(spline.ControlPoints[3 * i + 3], offset), "");
                        }
                        lastX = (float)(spline.ControlPoints[3 * i + 3].X + offsetX);
                        lastY = (float)(spline.ControlPoints[3 * i + 3].Y + offsetY);
                        //  path += ' C %f,%f %f,%f %f,%f' % (vals[groups['10']][3 * i + 1], vals[groups['20']][3 * i + 1], vals[groups['10']][3 * i + 2], vals[groups['20']][3 * i + 2], vals[groups['10']][3 * i + 3], vals[groups['20']][3 * i + 3])
                    }
                    dxfStopPath();
                }
                if ((ctrls == 3) && (knots == 6)) //  # quadratic
                {                                 //  path = 'M %f,%f Q %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], vals[groups['10']][1], vals[groups['20']][1], vals[groups['10']][2], vals[groups['20']][2])
                    if (!nodesOnly)
                    {
                        dxfStartPath(lastX, lastY, cmt);
                        importMath.calcQuadraticBezier(toPoint(spline.ControlPoints[0], offset), toPoint(spline.ControlPoints[1], offset), toPoint(spline.ControlPoints[2], offset), dxfMoveTo, "Q");
                    }
                    else
                    {
                        gcodeDotOnly(lastX, lastY, "");
                        gcodeDotOnly(toPoint(spline.ControlPoints[2], offset), "");
                    }
                    dxfStopPath();
                }
                if ((ctrls == 5) && (knots == 8)) //  # spliced quadratic
                {                                 //  path = 'M %f,%f Q %f,%f %f,%f Q %f,%f %f,%f' % (vals[groups['10']][0], vals[groups['20']][0], vals[groups['10']][1], vals[groups['20']][1], vals[groups['10']][2], vals[groups['20']][2], vals[groups['10']][3], vals[groups['20']][3], vals[groups['10']][4], vals[groups['20']][4])
                    if (!nodesOnly)
                    {
                        dxfStartPath(lastX, lastY, cmt);
                        importMath.calcQuadraticBezier(toPoint(spline.ControlPoints[0], offset), toPoint(spline.ControlPoints[1], offset), toPoint(spline.ControlPoints[2], offset), dxfMoveTo, "SQ");
                        importMath.calcQuadraticBezier(toPoint(spline.ControlPoints[3], offset), toPoint(spline.ControlPoints[4], offset), toPoint(spline.ControlPoints[5], offset), dxfMoveTo, "SQ");
                    }
                    else
                    {
                        gcodeDotOnly(lastX, lastY, "");
                        gcodeDotOnly(toPoint(spline.ControlPoints[2], offset), "");
                        gcodeDotOnly(toPoint(spline.ControlPoints[5], offset), "");
                    }
                    dxfStopPath();
                }
            }
            #endregion
            #region DXFCircle
            else if (entity.GetType() == typeof(DXFCircle))
            {
                DXFCircle circle = (DXFCircle)entity;
                x = (float)circle.Center.X + (float)offsetX;
                y = (float)circle.Center.Y + (float)offsetY;
                dxfStartPath(x + circle.Radius, y, "Start Circle");
                Plotter.Arc(2, (float)x + (float)circle.Radius, (float)y, -(float)circle.Radius, 0, "");
                dxfStopPath();
                Logger.Trace("    Center: {0};{1}  R: {2}", x, y, circle.Radius);
            }
            #endregion
            #region DXFEllipse
            else if (entity.GetType() == typeof(DXFEllipse))
            {   // from Inkscape DXF import - modified
                // https://gitlab.com/inkscape/extensions/blob/master/dxf_input.py#L341
                DXFEllipse ellipse = (DXFEllipse)entity;
                float      xc      = (float)ellipse.Center.X + (float)offsetX;
                float      yc      = (float)ellipse.Center.Y + (float)offsetY;
                float      xm      = (float)ellipse.MainAxis.X;
                float      ym      = (float)ellipse.MainAxis.Y;
                float      w       = (float)ellipse.AxisRatio;
                double     a2      = -ellipse.StartParam;
                double     a1      = -ellipse.EndParam;

                float  rm   = (float)Math.Sqrt(xm * xm + ym * ym);
                double a    = Math.Atan2(-ym, xm);
                float  diff = (float)((a2 - a1 + 2 * Math.PI) % (2 * Math.PI));

                if ((Math.Abs(diff) > 0.0001) && (Math.Abs(diff - 2 * Math.PI) > 0.0001))
                {
                    int large = 0;
                    if (diff > Math.PI)
                    {
                        large = 1;
                    }
                    float xt = rm * (float)Math.Cos(a1);
                    float yt = w * rm * (float)Math.Sin(a1);
                    float x1 = (float)(xt * Math.Cos(a) - yt * Math.Sin(a));
                    float y1 = (float)(xt * Math.Sin(a) + yt * Math.Cos(a));
                    xt = rm * (float)Math.Cos(a2);
                    yt = w * rm * (float)Math.Sin(a2);
                    float x2 = (float)(xt * Math.Cos(a) - yt * Math.Sin(a));
                    float y2 = (float)(xt * Math.Sin(a) + yt * Math.Cos(a));
                    dxfStartPath(xc + x1, yc - y1, "Start Ellipse 1");
                    importMath.calcArc(xc + x1, yc - y1, rm, w * rm, (float)(-180.0 * a / Math.PI), large, 0, (xc + x2), (yc - y2), dxfMoveTo);
                    //  path = 'M %f,%f A %f,%f %f %d 0 %f,%f' % (xc + x1, yc - y1, rm, w* rm, -180.0 * a / math.pi, large, xc + x2, yc - y2)
                }
                else
                {
                    dxfStartPath(xc + xm, yc + ym, "Start Ellipse 2");
                    importMath.calcArc(xc + xm, yc + ym, rm, w * rm, (float)(-180.0 * a / Math.PI), 1, 0, xc - xm, yc - ym, dxfMoveTo);
                    importMath.calcArc(xc - xm, yc - ym, rm, w * rm, (float)(-180.0 * a / Math.PI), 1, 0, xc + xm, yc + ym, dxfMoveTo);
                    //    path = 'M %f,%f A %f,%f %f 1 0 %f,%f %f,%f %f 1 0 %f,%f z' % (xc + xm, yc - ym, rm, w* rm, -180.0 * a / math.pi, xc - xm, yc + ym, rm, w* rm, -180.0 * a / math.pi, xc + xm, yc - ym)
                }
                dxfStopPath();
                Logger.Trace("    Center: {0};{1}  R1: {2} R2: {3} Start: {4} End: {5}", xc, yc, rm, w * rm, ellipse.StartParam, ellipse.EndParam);
            }
            #endregion
            #region DXFArc
            else if (entity.GetType() == typeof(DXFArc))
            {
                DXFArc arc = (DXFArc)entity;

                double X          = (double)arc.Center.X + offsetX;
                double Y          = (double)arc.Center.Y + offsetY;
                double R          = arc.Radius;
                double startAngle = arc.StartAngle;
                double endAngle   = arc.EndAngle;
                if (startAngle > endAngle)
                {
                    endAngle += 360;
                }
                double stepwidth = (double)Properties.Settings.Default.importGCSegment; // from setup-GCode modification-Avoid G2/3 commands...
                float  StepAngle = (float)(Math.Asin(stepwidth / R) * 180 / Math.PI);
                double currAngle = startAngle;
                index = 0;
                if (!nodesOnly)
                {
                    while (currAngle < endAngle)
                    {
                        double angle = currAngle * Math.PI / 180;
                        double rx    = (double)(X + R * Math.Cos(angle));
                        double ry    = (double)(Y + R * Math.Sin(angle));

                        if (index == 0)
                        {
                            dxfStartPath(rx, ry, "Start Arc");
                            Plotter.IsPathReduceOk = true;
                        }
                        else
                        {
                            dxfMoveTo(rx, ry, "");
                        }
                        currAngle += StepAngle;
                        if (currAngle > endAngle)
                        {
                            double angle2 = endAngle * Math.PI / 180;
                            double rx2    = (double)(X + R * Math.Cos(angle2));
                            double ry2    = (double)(Y + R * Math.Sin(angle2));

                            if (index == 0)
                            {
                                dxfStartPath(rx2, ry2, "Start Arc");
                            }
                            else
                            {
                                dxfMoveTo(rx2, ry2, "");
                            }
                        }
                        index++;
                    }
                    dxfStopPath();
                    Logger.Trace("    Center: {0};{1}  R: {2}", X, Y, R);
                }
            }
            #endregion
            #region DXFMText
            else if (entity.GetType() == typeof(DXFMText))
            {   // https://www.autodesk.com/techpubs/autocad/acad2000/dxf/mtext_dxf_06.htm
                DXFMText txt    = (DXFMText)entity;
                xyPoint  origin = new xyPoint(0, 0);
                GCodeFromFont.reset();

                foreach (var entry in txt.Entries)
                {
                    if (entry.GroupCode == 1)
                    {
                        GCodeFromFont.gcText = entry.Value.ToString();
                    }
                    else if (entry.GroupCode == 40)
                    {
                        GCodeFromFont.gcHeight = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 41)
                    {
                        GCodeFromFont.gcWidth = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 71)
                    {
                        GCodeFromFont.gcAttachPoint = Convert.ToInt16(entry.Value);
                    }
                    else if (entry.GroupCode == 10)
                    {
                        GCodeFromFont.gcOffX = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat) + offsetX;
                    }
                    else if (entry.GroupCode == 20)
                    {
                        GCodeFromFont.gcOffY = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat) + offsetY;
                    }
                    else if (entry.GroupCode == 50)
                    {
                        GCodeFromFont.gcAngle = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 44)
                    {
                        GCodeFromFont.gcSpacing = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 7)
                    {
                        GCodeFromFont.gcFontName = entry.Value.ToString();
                    }
                }
                string tmp = string.Format("Id=\"{0}\" Color=\"#{1}\" ToolNr=\"{2}\"", dxfColorID, dxfColorHex, toolToUse);
                Plotter.InsertText(tmp);
                Plotter.IsPathFigureEnd = true;
                Logger.Trace("    Text: {0}", GCodeFromFont.gcText);
            }
            #endregion
            else
            {
                Plotter.Comment("Unknown: " + entity.GetType().ToString());
            }
        }
Esempio n. 27
0
    {                       // http://www.hinterseher.de/Diplomarbeit/GeometrischeFunktionen.html
        // get two lines and calc offsetted points
        public static int getPointOffsets(ref xyPoint[] offset, xyArcPoint P0, xyArcPoint P1, xyArcPoint P2, double distance, bool isEnd)
        {
            xyPoint[] S1off = new xyPoint[2];
            xyPoint[] S2off = new xyPoint[2];

            double a0 = 0, a1 = 0, a2 = 0, a3 = 0, adelta;
            double newRadius1 = distance;
            double newRadius2 = distance;

            if (P1.mode <= 1)   // is a line
            {
                a1 = getAlphaLine(P0, P1);
                a0 = a1;
                calcOffsetLine(ref S1off, P0, P1, a1 + Math.PI / 2, distance); // offset by 90°
            }
            else
            {
                a0 = getAlphaCenterToPoint(P1, P0);    // from center to start
                a1 = getAlphaCenterToPoint(P1, P1);    // from center to end

                double usea0 = a0, usea1 = a1;
                a0 -= Math.PI / 2; a1 -= Math.PI / 2;   // tangente

                if (P1.mode == 3)
                {
                    usea0 += Math.PI; usea1 += Math.PI; // add 180°
                    a0    += Math.PI; a1 += Math.PI;    // tangente reverse
                }

                S1off[0]   = calcOffsetPoint(P0, usea0, distance); // extend radius
                S1off[1]   = calcOffsetPoint(P1, usea1, distance); // extend radius
                newRadius1 = Math.Sqrt((P1.CX - S1off[0].X) * (P1.CX - S1off[0].X) + (P1.CY - S1off[0].Y) * (P1.CY - S1off[0].Y));
            }
            offset[0] = S1off[0];
            offset[1] = S1off[1];

#if (debuginfo)
            log.Add(string.Format(" getPointOffsets P0-P1: P1mode: {0} S1offX {1:0.000} S1offX {2:0.000} S1offX {3:0.000} S1offX {4:0.000}", P1.mode, S1off[0].X, S1off[0].Y, S1off[1].X, S1off[1].Y));
#endif

            if (P2.mode <= 1)   // is a line
            {
                a2 = getAlphaLine(P1, P2);
                a3 = a2;
                calcOffsetLine(ref S2off, P1, P2, a2 + Math.PI / 2, distance); // offset by 90°
            }
            else
            {
                a2 = getAlphaCenterToPoint(P2, P1);   // from center to start
                a3 = getAlphaCenterToPoint(P2, P2);   // from center to end
                double usea2 = a2, usea3 = a3;
                a2 -= Math.PI / 2; a3 -= Math.PI / 2; // tangente

                if (P2.mode == 3)
                {
                    usea2 += Math.PI; usea3 += Math.PI;  // add 180°
                    a2    += Math.PI; a3 += Math.PI;     // tangente reverse
                }

                S2off[0]   = calcOffsetPoint(P1, usea2, distance); // extend radius
                S2off[1]   = calcOffsetPoint(P2, usea3, distance); // extend radius
                newRadius2 = Math.Sqrt((P2.CX - S2off[0].X) * (P2.CX - S2off[0].X) + (P2.CY - S2off[0].Y) * (P2.CY - S2off[0].Y));
            }
            offset[2] = S2off[0];
            offset[3] = S2off[1];
#if (debuginfo)
            log.Add(string.Format(" getPointOffsets P1-P2: P2mode: {0} S1offX {1:0.000} S1offX {2:0.000} S1offX {3:0.000} S1offX {4:0.000}", P2.mode, S2off[0].X, S2off[0].Y, S2off[1].X, S2off[1].Y));
#endif
            if ((P1.mode == P2.mode) && (P1.X == P2.X) && (P1.Y == P2.Y))
            {
                a2 = a0; a3 = a1;
            }

            // compare angle of both lines P0-P1 and P1-P2
            adelta = a2 - a1;
            double dist = offset[1].DistanceTo(offset[2]);

#if (debuginfo)
            log.Add(string.Format(" getPointOffsets Angles: a1 {0:0.000} a2 {1:0.000} delta {2:0.000}", (a1 * 180 / Math.PI), (a2 * 180 / Math.PI), (adelta * 180 / Math.PI)));
#endif
            if (adelta >= (Math.PI))
            {
                adelta -= 2 * Math.PI;
            }
            if (adelta <= -(Math.PI))
            {
                adelta += 2 * Math.PI;
            }

#if (debuginfo)
            log.Add(string.Format(" getPointOffsets adelta corrected {0:0.000}", (adelta * 180 / Math.PI)));
            log.Add(string.Format(" getPointOffsets offset [0]x{0:0.000} [0]y{1:0.000} [1]x{2:0.000} [1]y{3:0.000} [2]x{4:0.000} [2]y{5:0.000}", offset[0].X, offset[0].Y, offset[1].X, offset[1].Y, offset[2].X, offset[2].Y));
#endif
            if (isEnd || (Math.Abs(adelta) <= 0.2) || (dist < 0.2))
            {
                return(0);           // S1-angle == S2-angle, no correction needed
            }
            if (Math.Abs(Math.Abs(adelta) - Math.PI) <= 0.2)
            {
                return(1);           // 180°
            }
            if ((adelta > 0) && (distance < 0))
            {
                return(1);           // connect lines with additional arc
            }
            if ((adelta < 0) && (distance > 0))
            {
                return(1);           // connect lines with additional arc
            }
#if (debuginfo)
            log.Add(string.Format(" getPointOffsets Find intersection {0} {1}", P1.mode, P2.mode));
#endif

            bool result = false;
            // find common intersection
            if ((P1.mode <= 1) && (P2.mode <= 1)) // line to line
            {                                     // https://www.java-forum.org/thema/algorithmus-fuer-pruefung-auf-ueberschneidende-linien.117102/
                double d = (S1off[1].X - S1off[0].X) * (S2off[0].Y - S2off[1].Y) - (S2off[0].X - S2off[1].X) * (S1off[1].Y - S1off[0].Y);
                if (d == 0)
                {
                    offset[2] = offset[1] = offset[3];
                }
                else
                {
                    double m = ((S2off[0].X - S1off[0].X) * (S2off[0].Y - S2off[1].Y) - (S2off[0].X - S2off[1].X) * (S2off[0].Y - S1off[0].Y)) / d;
                    double n = ((S1off[1].X - S1off[0].X) * (S2off[0].X - S1off[0].X) - (S2off[0].Y - S1off[0].Y) * (S1off[1].Y - S1off[0].Y)) / d;
                    offset[1].X = S1off[0].X + m * (S1off[1].X - S1off[0].X);
                    offset[1].Y = S1off[0].Y + m * (S1off[1].Y - S1off[0].Y);
                    offset[2]   = offset[1];
                }
            }
            else if ((P1.mode <= 1) && (P2.mode >= 2))    // 1st line then arc
            {
                result = calcIntersectionLineArc(ref offset, S1off, P2, newRadius2);
            }
            else if ((P1.mode >= 2) && (P2.mode <= 1))      // 1st arc then line
            {
                xyPoint tmp = S2off[0];
                S2off[0] = S2off[1]; S2off[1] = tmp; // switch points, p[1] should be connection to arc
                result   = calcIntersectionLineArc(ref offset, S2off, P1, newRadius1);
            }
            else
            {   // 1st arc 2nd arc, transfer one arc to line to use available function calcIntersectionLineArc
                // http://www2.math.uni-wuppertal.de/~volkert/Das%20Apollonische%20Beruehrproblem,%202007.pdf
                double dy = P2.CY - P1.CY;
                double dx = P2.CX - P1.CX;
                if (dy == 0)        // center points of arcs on same y -> chordale = vertical line
                {
                    double a  = (newRadius2 * newRadius2 - newRadius1 * newRadius1 - dx * dx) / (-2 * dx);
                    double px = P1.CX + a;  // vertical line
                    S1off[0].X = S1off[1].X = px;
                    S1off[0].Y = -P1.Y;
                    S1off[1].Y = P1.Y;
                    result     = calcIntersectionLineArc(ref offset, S1off, P2, newRadius2);
                }
                else if (dx == 0)   // center points of arcs on same x -> chordale = horizontal line
                {
                    double a  = (newRadius2 * newRadius2 - newRadius1 * newRadius1 - dy * dy) / (-2 * dy);
                    double py = P1.CY + a;  // horizontal line
                    S1off[0].Y = S1off[1].Y = py;
                    S1off[0].X = -P1.X;
                    S1off[1].X = P1.X;
                    result     = calcIntersectionLineArc(ref offset, S1off, P2, newRadius2);
                }
                else
                {
                    double  c     = Math.Sqrt(dx * dx + dy * dy);
                    double  a     = (newRadius2 * newRadius2 - newRadius1 * newRadius1 - c * c) / (-2 * c);
                    double  m     = dy / dx;
                    double  angle = getAlphaCenterToCenter(P1, P2);
                    xyPoint aP    = new xyPoint();
                    aP     = calcOffsetPoint(new xyPoint(P1.CX, P1.CY), angle, a);
                    angle += Math.PI / 2;

                    S1off[0] = calcOffsetPoint(aP, angle, newRadius1);  // create line from point
                    S1off[1] = calcOffsetPoint(aP, angle, -newRadius1); // create line from point
                    double d0 = S1off[0].DistanceTo((xyPoint)P1);
                    double d1 = S1off[1].DistanceTo((xyPoint)P1);

                    if (d1 > d0)                                            // index 1 should be closer to final pos
                    {
                        S1off[1] = calcOffsetPoint(aP, angle, newRadius1);  // create line from point
                        S1off[0] = calcOffsetPoint(aP, angle, -newRadius1); // create line from point
                    }
                    result = calcIntersectionLineArc(ref offset, S1off, P2, newRadius2);
                }

                if ((double.IsNaN(offset[1].X)) || double.IsNaN(offset[1].Y))
                {
                    offset[1].X = 0; offset[1].Y = 0;
                    offset[2]   = offset[1];
                }
            }
            if (result == true) // intersection successful
            {
                return(-1);
            }
            else
            {
                return(-2);
            }
        }
Esempio n. 28
0
        /// <summary>
        /// Process entities
        /// </summary>
        private static void processEntities(DXFEntity entity, double offsetX = 0, double offsetY = 0, bool updateColor = true)
        {
            int    index = 0;
            double x, y, x2 = 0, y2 = 0, bulge;

            if (updateColor)
            {
                dxfColorID       = entity.ColorNumber;
                Plotter.PathName = "Layer:" + entity.LayerName;
            }

            Plotter.PathDashArray = new double[0];                  // default no dashes
            if (entity.LineType == "ByLayer")
            {
                if (layerLType.ContainsKey(entity.LayerName))        // check if layer name is known
                {
                    string dashType = layerLType[entity.LayerName];  // get name of pattern
                    if (lineTypes.ContainsKey(dashType))             // check if pattern name is known
                    {
                        Plotter.PathDashArray = lineTypes[dashType]; // apply pattern
                    }
                }
            }
            else
            {
                if (lineTypes.ContainsKey(entity.LineType))             // check if pattern name is known
                {
                    Plotter.PathDashArray = lineTypes[entity.LineType]; // apply pattern
                }
            }

            if (dxfColorID > 255)
            {
                if (layerColor.ContainsKey(entity.LayerName))
                {
                    dxfColorID = layerColor[entity.LayerName];
                }
            }

            if (dxfColorID < 0)
            {
                dxfColorID = 0;
            }
            if (dxfColorID > 255)
            {
                dxfColorID = 7;
            }
            if (Properties.Settings.Default.importDXFSwitchWhite && (dxfColorID == 7))
            {
                dxfColorID = 0;
            }

            dxfColorHex       = getColorFromID(dxfColorID);
            Plotter.PathColor = dxfColorHex;

            if (dxfUseColorIndex)
            {
                toolNr = dxfColorID + 1;      // avoid ID=0 to start tool-table with index 1
            }
            else
            {
                toolNr = toolTable.getToolNr(dxfColorHex, 0);
                //Logger.Trace("toolNr = {0}",toolNr);
            }

            Plotter.SetGroup(toolNr);       // set index if grouping and tool

            if (dxfColorIDold != dxfColorID)
            {
                Plotter.PenUp("");

                toolToUse = toolNr;
                if (Properties.Settings.Default.importGCToolTableUse && Properties.Settings.Default.importGCToolDefNrUse)
                {
                    toolToUse = (int)Properties.Settings.Default.importGCToolDefNr;
                }

                Plotter.PathToolNr = toolToUse;

                if (!groupObjects)
                {
                    if (dxfUseColorIndex)
                    {
                        Plotter.ToolChange(toolToUse, dxfColorID.ToString());   // add tool change commands (if enabled) and set XYFeed etc.
                    }
                    else
                    {
                        Plotter.ToolChange(toolToUse, dxfColorHex);
                    }
                }
            }
            dxfColorIDold = dxfColorID;

            if (entity.GetType() == typeof(DXFPointEntity))
            {
                DXFPointEntity point = (DXFPointEntity)entity;
                x = (float)point.Location.X + (float)offsetX;
                y = (float)point.Location.Y + (float)offsetY;
                if (!nodesOnly)
                {
                    dxfStartPath(x, y, "Start Point");
                    dxfStopPath();
                }
                else
                {
                    gcodeDotOnly(x, y, "Start Point");
                }
            }

            #region DXFLWPolyline
            else if (entity.GetType() == typeof(DXFLWPolyLine))
            {
                DXFLWPolyLine lp = (DXFLWPolyLine)entity;
                index = 0; bulge = 0;
                DXFLWPolyLine.Element coordinate;
                bool roundcorner = false;
                x = 0; y = 0;
                for (int i = 0; i < lp.VertexCount; i++)
                {
                    coordinate = lp.Elements[i];
                    bulge      = coordinate.Bulge;
                    x2         = x; y2 = y;
                    x          = (double)coordinate.Vertex.X + (double)offsetX;
                    y          = (double)coordinate.Vertex.Y + (double)offsetY;
                    if (i == 0)
                    {
                        if (!nodesOnly)
                        {
                            dxfStartPath(x, y, "Start LWPolyLine - Nr pts " + lp.VertexCount.ToString());
                            Plotter.IsPathReduceOk = true;
                        }
                        else
                        {
                            gcodeDotOnly(x, y, "Start LWPolyLine");
                        }
                    }

                    if ((!roundcorner))
                    {
                        dxfMoveTo(x, y, "");
                    }
                    if (bulge != 0)
                    {
                        if (i < (lp.VertexCount - 1))
                        {
                            AddRoundCorner(lp.Elements[i], lp.Elements[i + 1]);
                        }
                        else
                        if (lp.Flags == DXFLWPolyLine.FlagsEnum.closed)
                        {
                            AddRoundCorner(lp.Elements[i], lp.Elements[0]);
                        }
                        roundcorner = true;
                    }
                    else
                    {
                        roundcorner = false;
                    }
                }
                if ((lp.Flags > 0))// && (x2 != x) && (y2 != y))   // only move if prev pos is differnent
                {
                    dxfMoveTo((float)(lp.Elements[0].Vertex.X + offsetX), (float)(lp.Elements[0].Vertex.Y + offsetY), "End LWPolyLine " + lp.Flags.ToString());
                }
                dxfStopPath();
            }
            #endregion
            #region DXFPolyline
            else if (entity.GetType() == typeof(DXFPolyLine))
            {
                DXFPolyLine lp = (DXFPolyLine)entity;
                index = 0;
                foreach (DXFVertex coordinate in lp.Children)
                {
                    if (coordinate.GetType() == typeof(DXFVertex))
                    {
                        if (coordinate.Location.X != null && coordinate.Location.Y != null)
                        {
                            x = (float)coordinate.Location.X + (float)offsetX;
                            y = (float)coordinate.Location.Y + (float)offsetY;
                            if (!nodesOnly)
                            {
                                if (index == 0)
                                {
                                    dxfStartPath(x, y, "Start PolyLine");
                                }
                                else
                                {
                                    dxfMoveTo(x, y, "");
                                }
                            }
                            else
                            {
                                gcodeDotOnly(x, y, "PolyLine");
                            }
                            index++;
                        }
                    }
                }
                dxfStopPath();
            }
            #endregion
            #region DXFLine
            else if (entity.GetType() == typeof(DXFLine))
            {
                DXFLine line = (DXFLine)entity;
                x  = (float)line.Start.X + (float)offsetX;
                y  = (float)line.Start.Y + (float)offsetY;
                x2 = (float)line.End.X + (float)offsetX;
                y2 = (float)line.End.Y + (float)offsetY;
                Plotter.IsPathReduceOk = false;
                if (!nodesOnly)
                {
                    dxfStartPath(x, y, "Start Line");
                    dxfMoveTo(x2, y2, "");
                }
                else
                {
                    gcodeDotOnly(x, y, "Start Line");
                    gcodeDotOnly(x2, y2, "End Line");
                }
                dxfStopPath();
            }
            #endregion
            #region DXFSpline
            else if (entity.GetType() == typeof(DXFSpline))
            {
                DXFSpline spline = (DXFSpline)entity;
                index = 0;
                double cx0, cy0, cx1, cy1, cx2, cy2, cx3, cy3, cxMirror, cyMirror, lastX, lastY;
                lastX = (double)spline.ControlPoints[0].X + offsetX;
                lastY = (double)spline.ControlPoints[0].Y + offsetY;
                string cmt = "Start Spline " + spline.KnotValues.Count.ToString() + " " + spline.ControlPoints.Count.ToString() + " " + spline.FitPoints.Count.ToString();
                dxfStartPath(lastX, lastY, cmt);
                Plotter.IsPathReduceOk = true;

                for (int rep = 0; rep < spline.ControlPointCount; rep += 4)
                {
                    cx0       = (double)spline.ControlPoints[rep].X + offsetX; cy0 = (double)spline.ControlPoints[rep].Y + offsetY;
                    cx1       = (double)spline.ControlPoints[rep + 1].X + offsetX; cy1 = (double)spline.ControlPoints[rep + 1].Y + offsetY;
                    cx2       = (double)spline.ControlPoints[rep + 2].X + offsetX; cy2 = (double)spline.ControlPoints[rep + 2].Y + offsetY;
                    cx3       = (double)spline.ControlPoints[rep + 3].X + offsetX; cy3 = (double)spline.ControlPoints[rep + 3].Y + offsetY;
                    points    = new System.Windows.Point[4];
                    points[0] = new System.Windows.Point(cx0, cy0); //(qpx1, qpy1);
                    points[1] = new System.Windows.Point(cx1, cy1); //(qpx1, qpy1);
                    points[2] = new System.Windows.Point(cx2, cy2); //(qpx2, qpy2);
                    points[3] = new System.Windows.Point(cx3, cy3);
                    cxMirror  = cx3 - (cx2 - cx3); cyMirror = cy3 - (cy2 - cy3);
                    lastX     = cx3; lastY = cy3;
                    var b = GetBezierApproximation(points, dxfBezierAccuracy);
                    if (!nodesOnly)
                    {
                        for (int i = 1; i < b.Points.Count; i++)
                        {
                            dxfMoveTo((float)b.Points[i].X, (float)b.Points[i].Y, "");
                        }
                    }
                    else
                    {
                        gcodeDotOnly(cx3, cy3, "Bezier");
                    }
                }
                dxfStopPath();
            }
            #endregion
            #region DXFCircle
            else if (entity.GetType() == typeof(DXFCircle))
            {
                DXFCircle circle = (DXFCircle)entity;
                x = (float)circle.Center.X + (float)offsetX;
                y = (float)circle.Center.Y + (float)offsetY;
                dxfStartPath(x + circle.Radius, y, "Start Circle");
                Plotter.Arc(2, (float)x + (float)circle.Radius, (float)y, -(float)circle.Radius, 0, "");
                dxfStopPath();
            }
            #endregion

            else if (entity.GetType() == typeof(DXFEllipse))
            {
                DXFEllipse circle = (DXFEllipse)entity;
                Plotter.Comment("Ellipse: " + circle.ColorNumber.ToString());
            }
            #region DXFArc
            else if (entity.GetType() == typeof(DXFArc))
            {
                DXFArc arc = (DXFArc)entity;

                double X          = (double)arc.Center.X + offsetX;
                double Y          = (double)arc.Center.Y + offsetY;
                double R          = arc.Radius;
                double startAngle = arc.StartAngle;
                double endAngle   = arc.EndAngle;
                if (startAngle > endAngle)
                {
                    endAngle += 360;
                }
                double stepwidth = (double)Properties.Settings.Default.importGCSegment;
                float  StepAngle = (float)(Math.Asin(stepwidth / R) * 180 / Math.PI);// Settings.Default.page11arcMaxLengLine);
                double currAngle = startAngle;
                index = 0;
                if (!nodesOnly)
                {
                    while (currAngle < endAngle)
                    {
                        double angle = currAngle * Math.PI / 180;
                        double rx    = (double)(X + R * Math.Cos(angle));
                        double ry    = (double)(Y + R * Math.Sin(angle));

                        if (index == 0)
                        {
                            dxfStartPath(rx, ry, "Start Arc");
                            Plotter.IsPathReduceOk = true;
                        }
                        else
                        {
                            dxfMoveTo(rx, ry, "");
                        }
                        currAngle += StepAngle;
                        if (currAngle > endAngle)
                        {
                            double angle2 = endAngle * Math.PI / 180;
                            double rx2    = (double)(X + R * Math.Cos(angle2));
                            double ry2    = (double)(Y + R * Math.Sin(angle2));

                            if (index == 0)
                            {
                                dxfStartPath(rx2, ry2, "Start Arc");
                            }
                            else
                            {
                                dxfMoveTo(rx2, ry2, "");
                            }
                        }
                        index++;
                    }
                    dxfStopPath();
                }
            }
            #endregion
            #region DXFMText
            else if (entity.GetType() == typeof(DXFMText))
            {   // https://www.autodesk.com/techpubs/autocad/acad2000/dxf/mtext_dxf_06.htm
                DXFMText txt    = (DXFMText)entity;
                xyPoint  origin = new xyPoint(0, 0);
                GCodeFromFont.reset();

                foreach (var entry in txt.Entries)
                {
                    if (entry.GroupCode == 1)
                    {
                        GCodeFromFont.gcText = entry.Value.ToString();
                    }
                    else if (entry.GroupCode == 40)
                    {
                        GCodeFromFont.gcHeight = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 41)
                    {
                        GCodeFromFont.gcWidth = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 71)
                    {
                        GCodeFromFont.gcAttachPoint = Convert.ToInt16(entry.Value);
                    }
                    else if (entry.GroupCode == 10)
                    {
                        GCodeFromFont.gcOffX = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat) + offsetX;
                    }
                    else if (entry.GroupCode == 20)
                    {
                        GCodeFromFont.gcOffY = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat) + offsetY;
                    }
                    else if (entry.GroupCode == 50)
                    {
                        GCodeFromFont.gcAngle = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 44)
                    {
                        GCodeFromFont.gcSpacing = double.Parse(entry.Value, CultureInfo.InvariantCulture.NumberFormat);
                    }
                    else if (entry.GroupCode == 7)
                    {
                        GCodeFromFont.gcFontName = entry.Value.ToString();
                    }
                }
                string tmp = string.Format("Id=\"{0}\" Color=\"#{1}\" ToolNr=\"{2}\"", dxfColorID, dxfColorHex, toolToUse);
                Plotter.InsertText(tmp);
                Plotter.IsPathFigureEnd = true;
            }
            #endregion
            else
            {
                Plotter.Comment("Unknown: " + entity.GetType().ToString());
            }
        }
Esempio n. 29
0
 public xyArcPoint(xyPoint tmp)
 {
     X = tmp.X; Y = tmp.Y; CX = 0; CY = 0; mode = 0;
 }
Esempio n. 30
0
        private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {
            if (logDetailed)
            {
                Logger.Trace("pictureBox1_MouseDown e.x:{0} y:{1}  absPos-x:{2:0.00} y:{3:0.00}", e.X, e.Y, picAbsPos.X, picAbsPos.Y);
            }
            pictureBox1.Focus();
            moveTranslationOld = new xyPoint(e.X, e.Y);
            allowZoom          = false;
            if (e.Button == MouseButtons.Left)
            {
                if ((fCTBCode.LinesCount > 2) && !posIsMoving)
                {
                    int line = 0;
                    posMoveStart = picAbsPos;
                    posMoveTmp   = posMoveStart;
                    posMoveEnd   = posMoveStart;

                    int fold = foldLevel;
                    if (!expandGCode)
                    {
                        fold = 0;
                    }

                    if (manualEdit)
                    {
                        newCodeEnd();
                    }
                    if (Panel.ModifierKeys == Keys.Alt)
                    {
                        line = VisuGCode.setPosMarkerNearBy(picAbsPos, false);           // find line with coord nearby, mark / unmark figure
                        fCTBCodeClickedLineNow = line;
                        findFigureMarkSelection(xmlMarkerType.Line, line, (fold > 0));   // collapse=true
                    }
                    else if (Panel.ModifierKeys == Keys.Control)
                    {
                        line = VisuGCode.setPosMarkerNearBy(picAbsPos, false);           // find line with coord nearby, mark / unmark figure
                        fCTBCodeClickedLineNow = line;
                        findFigureMarkSelection(xmlMarkerType.Group, line, (fold > 0));
                    }
                    else if (Panel.ModifierKeys == Keys.Shift)
                    {
                        line = VisuGCode.setPosMarkerNearBy(picAbsPos, false);           // find line with coord nearby, mark / unmark figure
                        fCTBCodeClickedLineNow = line;
                        findFigureMarkSelection(xmlMarkerType.Tile, line, (fold > 0));
                    }
                    else
                    {
                        line = VisuGCode.setPosMarkerNearBy(picAbsPos);                 // find line with coord nearby, mark / unmark figure
                        fCTBCodeClickedLineNow = line;
                        findFigureMarkSelection(xmlMarkerType.Figure, line, (fold > 0));
                    }

                    cmsPicBoxMoveToMarkedPosition.ToolTipText = "Work X: " + grbl.posMarker.X.ToString() + "   Y: " + grbl.posMarker.Y.ToString();
                    enableBlockCommands(VisuGCode.getHighlightStatus() > 0);
                    if (VisuGCode.codeBlocksAvailable())
                    {
                        statusStripSet(1, Localization.getString("statusStripeClickKeys2"), Color.LightGreen);
                    }
                    posIsMoving = false;
                }
            }
        }