Example #1
0
        static void Main(string[] args)
        {
            //GerberSplitter GS = new GerberSplitter();
            //GS.Split("G03*", new GerberLibrary.Core.Primitives.GerberNumberFormat());
            //GS.Split("%SRX1Y1I0.00000J1.76100*%", new GerberLibrary.Core.Primitives.GerberNumberFormat(),true);
            //Console.WriteLine("{0}", GS.Pairs.Count);
            Gerber.ShowProgress        = true;
            Gerber.DumpSanitizedOutput = true;
            Gerber.WriteSanitized      = true;

            if (args.Count() < 2)
            {
                Console.WriteLine("usage: ");
                Console.WriteLine("GerberCombiner <outputfile> <inputfile1> <inputfile2> <inputfileN> ");
                Console.WriteLine("<outputfile>: file to write - if the outputfile extension is .txt, all input files will be treated as excellon");
                Console.WriteLine("<inputfileN>: files to load");

                return;
            }
            for (int j = 1; j < args.Count(); j++)
            {
                if (File.Exists(args[j]) == false)
                {
                    Console.WriteLine("file not found! {0}", args[j]);
                    return;
                }
            }
            BoardSide  S;
            BoardLayer L;

            var FileType = Gerber.FindFileType(args[1]);

            Gerber.DetermineBoardSideAndLayer(args[1], out S, out L);

            for (int j = 2; j < args.Count(); j++)
            {
                var FileType2 = Gerber.FindFileType(args[1]);

                Gerber.DetermineBoardSideAndLayer(args[1], out S, out L);
                if (FileType2 != FileType)
                {
                    Console.WriteLine("Warning! Filetypes seem to be mismatched! First file ({0}) is a {1}, but {2} is a {3}", args[1], FileType, args[j], FileType2);
                }
            }

            if (FileType == BoardFileType.Drill)
            {
                List <string> ExcellonFiles = new List <string>();
                ExcellonFiles.AddRange(args.Skip(1));
                ExcellonFile.MergeAll(ExcellonFiles, args[0], new StandardConsoleLog());
            }
            else
            {
                List <string> GerberFiles = new List <string>();
                GerberFiles.AddRange(args.Skip(1));
                GerberMerger.MergeAll(GerberFiles, args[0], new StandardConsoleLog());
            }
            //  Console.WriteLine("Press any key to continue..");
            //  Console.ReadKey();
        }
Example #2
0
        private static void RotateFile(string filename, string outfile, string[] args)
        {
            double dx    = 0;
            double dy    = 0;
            double cx    = 0;
            double cy    = 0;
            double angle = 0;

            if (args.Count() > 2)
            {
                double.TryParse(args[2], out dx);
            }
            if (args.Count() > 3)
            {
                double.TryParse(args[3], out dy);
            }
            if (args.Count() > 4)
            {
                double.TryParse(args[4], out cx);
            }
            if (args.Count() > 5)
            {
                double.TryParse(args[5], out cy);
            }
            if (args.Count() > 6)
            {
                double.TryParse(args[6], out angle);
            }

            var T = Gerber.FindFileType(filename);

            if (T == BoardFileType.Drill)
            {
                ExcellonFile EF = new ExcellonFile();
                EF.Load(filename);
                EF.Write(outfile, dx, dy, cx, cy, angle);
            }
            else
            {
                BoardSide  Side;
                BoardLayer Layer;
                Gerber.DetermineBoardSideAndLayer(args[0], out Side, out Layer);

                GerberTransposer.Transform(filename, outfile, dx, dy, cx, cy, angle);

                var lines = PolyLineSet.SanitizeInputLines(System.IO.File.ReadAllLines(args[0]).ToList());
                System.IO.File.WriteAllLines(args[0] + "sanit.txt", lines);

                Gerber.SaveGerberFileToImage(outfile, outfile + "_render.png", 200, Color.Black, Color.White);
            }
        }
        public void WriteAntennaBoard(double width, double height, double mountholediameter, double cornerrounding, double mountholeclearance, double edgeclearance = 1.26, bool WriteCombinedImage = true, bool WriteImages = false)
        {
            int     polyid = 0;
            FontSet FS     = FontSet.Load("Font.xml");

            List <String> FilesGenerated = new List <string>();
            double        LabelHeight    = 1.2;
            //double PadWidth = 1.8;
            double DrillWidth = 1.0;

            string basename = String.Format("Generated_This_is_not_RocketScience_Antenna_{0}x{1}cm", width / 10.0f, height / 10.0f);

            try
            {
                Directory.CreateDirectory(basename);
            }
            catch (Exception)
            {
            }
            basename = Path.Combine(basename, String.Format("proto_{0}x{1}cm", width / 10.0f, height / 10.0f));
            string OutlineFile      = basename + ".gko";
            string SilkFileTop      = basename + ".gto";
            string SilkFileBottom   = basename + ".gbo";
            string SolderMaskBottom = basename + ".gbs";
            string SolderMaskTop    = basename + ".gts";
            string CopperBottom     = basename + ".gbl";
            string CopperTop        = basename + ".gtl";
            string DrillFile        = basename + ".txt";

            ExcellonFile EF = new ExcellonFile();

            ExcellonTool MountHoleDrill = new ExcellonTool();

            MountHoleDrill.Radius = mountholediameter / 2.0;


            PointD C1 = new PointD(mountholeclearance, mountholeclearance);
            PointD C2 = new PointD(width - mountholeclearance, mountholeclearance);
            PointD C3 = new PointD(width - mountholeclearance, height - mountholeclearance);
            PointD C4 = new PointD(mountholeclearance, height - mountholeclearance);

            MountHoleDrill.Drills.Add(C1);
            MountHoleDrill.Drills.Add(C2);
            MountHoleDrill.Drills.Add(C3);
            MountHoleDrill.Drills.Add(C4);

            EF.Tools[10] = MountHoleDrill;

            ViaDrill.Radius = 0.6 / 2.0;

            EF.Tools[11] = ViaDrill;


            ExcellonTool ProtoHoleDrill = new ExcellonTool();

            ProtoHoleDrill.Radius = DrillWidth / 2.0;

            PointD pC1 = new PointD(mountholeclearance, height / 2 - 2.54);
            PointD pC2 = new PointD(mountholeclearance, height / 2);
            PointD pC3 = new PointD(mountholeclearance, height / 2 + 2.54);

            ProtoHoleDrill.Drills.Add(pC1);
            ProtoHoleDrill.Drills.Add(pC2);
            ProtoHoleDrill.Drills.Add(pC3);

            MaskBottom.AddFlash(pC1, 1);
            MaskBottom.AddFlash(pC2, 1);
            MaskBottom.AddFlash(pC3, 1);
            MaskTop.AddFlash(pC1, 1);
            MaskTop.AddFlash(pC2, 1);
            MaskTop.AddFlash(pC3, 1);

            PolyLine PL = new PolyLine(polyid++);

            PL.Add(cornerrounding, 0);
            PL.Add(width - cornerrounding, 0);
            PL.ArcTo(new PointD(width, cornerrounding), new PointD(0, cornerrounding), InterpolationMode.CounterClockwise);
            PL.Add(width, height - cornerrounding);
            PL.ArcTo(new PointD(width - cornerrounding, height), new PointD(-cornerrounding, 0), InterpolationMode.CounterClockwise);
            PL.Add(cornerrounding, height);
            PL.ArcTo(new PointD(0, height - cornerrounding), new PointD(0, -cornerrounding), InterpolationMode.CounterClockwise);
            PL.Add(0, cornerrounding);
            PL.ArcTo(new PointD(cornerrounding, 0), new PointD(cornerrounding, 0), InterpolationMode.CounterClockwise);
            PL.Close();

            GAW.AddPolyLine(PL, 0);
            GAW.Write(OutlineFile);

            double AX  = C1.X + mountholeclearance;
            double AY  = C1.Y + mountholeclearance;
            double gap = 5;


            double W = width - AX * 2;
            double H = height - AY * 2 - gap;

            int rounds = 6;

            antennatracewidth = 0.3 / 2;

            double spacing = 0.8;

            for (int i = 0; i < rounds; i++)
            {
                double W2 = W - i * spacing * 2;
                double H2 = H - i * spacing * 2;

                double W3 = W - (i + 1) * spacing * 2;
                double H3 = H - (i + 1) * spacing * 2;

                double AX2 = AX + i * spacing;
                double AY2 = AY + i * spacing;

                double AX3 = AX + (i + 1) * spacing;
                double AY3 = AY + (i + 1) * spacing;

                PolyLine PL2 = new PolyLine(polyid++);

                PL2.Add(AX2, AY2 + H2 / 2);
                PL2.Add(AX2, AY2);
                PL2.Add(AX2 + W2, AY2);
                PL2.Add(AX2 + W2, AY2 + H2 / 2);
                AddAntennaTop(PL2);


                PolyLine PL3 = new PolyLine(polyid++);

                PL3.Add(AX2, AY2 + gap + H2 - (H2 / 2));
                PL3.Add(AX2, AY2 + gap + H2);
                PL3.Add(AX2 + W2, AY2 + gap + H2);
                PL3.Add(AX2 + W2, AY2 + gap + H2 - (H2 / 2));
                AddAntennaTop(PL3);
                double gs = 2;

                if (i % 2 == 1)
                {
                    if (i < rounds - 1)
                    {
                        PolyLine PL4 = new PolyLine(polyid++);
                        PL4.Add(AX2, AY2 + gap + H2 - (H2 / 2));
                        PL4.Add(AX2, AY2 + gap - gs + H2 - (H2 / 2));
                        PL4.Add(AX3, AY3 + gs + (H3 / 2));
                        PL4.Add(AX3, AY3 + (H3 / 2));
                        AddAntennaTop(PL4);

                        PolyLine PL5 = new PolyLine(polyid++);
                        PL5.Add(AX3, AY3 + gap + H3 - (H3 / 2));
                        PL5.Add(AX2, AY2 + (H2 / 2));
                        AddAntennaBottom(PL5);

                        AddAntennaVia(AX3, AY3 + gap + H3 - (H3 / 2));
                        AddAntennaVia(AX2, AY2 + (H2 / 2));
                    }
                    else
                    {
                        PolyLine PL4 = new PolyLine(polyid++);
                        PL4.Add(AX2, AY2 + gap + H2 - (H2 / 2));
                        PL4.Add(AX2, AY2 + (H2 / 2));
                        AddAntennaTop(PL4);

                        AddAntennaVia(AX2, AY2 + H2 / 2 + gap / 2);

                        PolyLine PL5 = new PolyLine(polyid++);
                        PL5.Add(AX2, AY2 + H2 / 2 + gap / 2);
                        PL5.Add(AX2, AY2 + H2 / 2 - gs);
                        PL5.Add(AX - spacing, AY2 + H2 / 2 - gs);
                        PL5.Add(AX - spacing, AY2 + H2 / 2 + gap / 2);

                        AddAntennaVia(AX - spacing, AY2 + H2 / 2 + gap / 2);

                        AddAntennaBottom(PL5);
                    }
                }
                else
                {
                    PolyLine PL4 = new PolyLine(polyid++);
                    PL4.Add(AX2 + W2, AY2 + gap + H2 - (H2 / 2));
                    PL4.Add(AX2 + W2, AY2 + gap - gs + H2 - (H2 / 2));
                    PL4.Add(AX3 + W3, AY3 + gs + (H3 / 2));
                    PL4.Add(AX3 + W3, AY3 + (H3 / 2));
                    AddAntennaTop(PL4);

                    PolyLine PL5 = new PolyLine(polyid++);
                    PL5.Add(AX3 + W3, AY3 + gap + H3 - (H3 / 2));
                    PL5.Add(AX2 + W2, AY2 + (H2 / 2));

                    AddAntennaBottom(PL5);

                    PolyLine PL6 = new PolyLine(polyid++);
                    PL6.Add(AX, AY + H / 2);
                    PL6.Add(pC1.X, pC1.Y);
                    AddAntennaTop(PL6);

                    PolyLine PL7 = new PolyLine(polyid++);
                    PL7.Add(AX, AY + H / 2 + gap);
                    PL7.Add(pC3.X, pC3.Y);
                    AddAntennaTop(PL7);

                    PolyLine PL8 = new PolyLine(polyid++);
                    PL8.Add(AX - spacing, AY2 + H2 / 2 + gap / 2);
                    PL8.Add(pC2.X, pC2.Y);
                    AddAntennaTop(PL8);


                    AddAntennaVia(AX3 + W3, AY3 + gap + H3 - (H3 / 2));
                    AddAntennaVia(AX2 + W2, AY2 + (H2 / 2));
                }
            }


            string R = "NFC antenna: " + AntennaLen.ToString("N2") + " mm";

            // MaskTop.DrawString(new PointD(width / 2, 5), FS, R, LabelHeight, 0.05, StringAlign.CenterCenter);
            // MaskBottom.DrawString(new PointD(width / 2, 5), FS, R, LabelHeight, 0.05, StringAlign.CenterCenter, true);
            SilkTop.DrawString(new PointD(width / 2, 5), FS, R, LabelHeight, 0.05, StringAlign.CenterCenter);
            SilkBottom.DrawString(new PointD(width / 2, 5), FS, R, LabelHeight, 0.05, StringAlign.CenterCenter, true);


            GAWTop.Write(CopperTop);

            GAWBottom.Write(CopperBottom);
            SilkBottom.Write(SilkFileBottom);
            SilkTop.Write(SilkFileTop);

            MaskTop.Write(SolderMaskTop);
            MaskBottom.Write(SolderMaskBottom);
            EF.Tools[12] = ProtoHoleDrill;
            EF.Write(DrillFile, 0, 0, 0, 0);

            FilesGenerated.Add(CopperBottom);
            FilesGenerated.Add(CopperTop);
            FilesGenerated.Add(OutlineFile);
            FilesGenerated.Add(DrillFile);
            FilesGenerated.Add(SilkFileBottom);
            FilesGenerated.Add(SilkFileTop);
            FilesGenerated.Add(SolderMaskBottom);
            FilesGenerated.Add(SolderMaskTop);


            if (WriteCombinedImage)
            {
                GerberImageCreator GIC = new GerberImageCreator();
                GIC.AddBoardsToSet(FilesGenerated);
                GIC.WriteImageFiles(basename + "_render", 200, false);
            }
            if (WriteImages)
            {
                Gerber.SaveGerberFileToImage(OutlineFile, OutlineFile + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(CopperBottom, CopperBottom + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(CopperTop, CopperTop + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(DrillFile, DrillFile + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(SilkFileTop, SilkFileTop + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(SilkFileBottom, SilkFileBottom + "_render.png", 1000, Color.Black, Color.White);
            }
        }
Example #4
0
        public ParsedGerber AddBoardToSet(ProgressLog log, MemoryStream MS, string _originalfilename, bool forcezerowidth = false, bool precombinepolygons = false, double drillscaler = 1.0)
        {
            Streams[_originalfilename] = MS;
            try
            {
                //   string[] filesplit = originalfilename.Split('.');
                //     string ext = filesplit[filesplit.Count() - 1].ToLower();

                var FileType = Gerber.FindFileTypeFromStream(new StreamReader(MS), _originalfilename);
                MS.Seek(0, SeekOrigin.Begin);

                if (FileType == BoardFileType.Unsupported)
                {
                    if (Gerber.ExtremelyVerbose)
                    {
                        Console.WriteLine("Warning: {1}: files with extension {0} are not supported!", Path.GetExtension(_originalfilename), Path.GetFileName(_originalfilename));
                    }
                    return(null);
                }


                ParsedGerber      PLS;
                GerberParserState State = new GerberParserState()
                {
                    PreCombinePolygons = precombinepolygons
                };

                if (FileType == BoardFileType.Drill)
                {
                    if (Gerber.ExtremelyVerbose)
                    {
                        Console.WriteLine("Log: Drill file: {0}", _originalfilename);
                    }
                    PLS = PolyLineSet.LoadExcellonDrillFileFromStream(log, new StreamReader(MS), _originalfilename, false, drillscaler);
                    MS.Seek(0, SeekOrigin.Begin);

                    ExcellonFile EF = new ExcellonFile();
                    EF.Load(log, new StreamReader(MS), drillscaler);
                    Excellons.Add(EF);
                }
                else
                {
                    if (Gerber.ExtremelyVerbose)
                    {
                        Console.WriteLine("Log: Gerber file: {0}", _originalfilename);
                    }
                    BoardSide  Side  = BoardSide.Unknown;
                    BoardLayer Layer = BoardLayer.Unknown;
                    Gerber.DetermineBoardSideAndLayer(_originalfilename, out Side, out Layer);
                    if (Layer == BoardLayer.Outline)
                    {
                        forcezerowidth     = true;
                        precombinepolygons = true;
                    }
                    State.PreCombinePolygons = precombinepolygons;

                    PLS = PolyLineSet.LoadGerberFileFromStream(log, new StreamReader(MS), _originalfilename, forcezerowidth, false, State);
                    MS.Seek(0, SeekOrigin.Begin);

                    PLS.Side  = State.Side;
                    PLS.Layer = State.Layer;
                    if (Layer == BoardLayer.Outline)
                    {
                        PLS.FixPolygonWindings();
                    }
                }

                PLS.CalcPathBounds();
                BoundingBox.AddBox(PLS.BoundingBox);

                Console.WriteLine("Progress: Loaded {0}: {1:N1} x {2:N1} mm", Path.GetFileName(_originalfilename), PLS.BoundingBox.BottomRight.X - PLS.BoundingBox.TopLeft.X, PLS.BoundingBox.BottomRight.Y - PLS.BoundingBox.TopLeft.Y);
                PLSs.Add(PLS);
                //     }
                //     catch (Exception)
                //    {
                //   }

                return(PLS);
            }
            catch (Exception E)
            {
                while (E != null)
                {
                    Console.WriteLine("Exception adding board: {0}", E.Message);
                    E = E.InnerException;
                }
            }
            return(null);
        }
        public static List <String> WriteProtoBoardFlowerStyle(double width, double height, double mountholediameter, double cornerrounding, double mountholeclearance, double edgeclearance = 1.26, bool WriteCombinedImage = true, bool WriteImages = false)
        {
            FontSet       FS             = FontSet.Load("Font.xml");
            int           polyid         = 0;
            List <String> FilesGenerated = new List <string>();
            double        LabelHeight    = 1.2;
            double        PadWidth       = 1.8;
            double        DrillWidth     = 1.0;

            string basename = String.Format("Generated_This_is_not_RocketScience_Flower_prototoboard_{0}x{1}cm", width / 10.0f, height / 10.0f);

            try
            {
                Directory.CreateDirectory(basename);
            }
            catch (Exception)
            {
            }
            basename = Path.Combine(basename, String.Format("proto_{0}x{1}cm", width / 10.0f, height / 10.0f));
            string OutlineFile      = basename + ".gko";
            string SilkFileTop      = basename + ".gto";
            string SilkFileBottom   = basename + ".gbo";
            string SolderMaskBottom = basename + ".gbs";
            string SolderMaskTop    = basename + ".gts";
            string CopperBottom     = basename + ".gbl";
            string CopperTop        = basename + ".gtl";
            string DrillFile        = basename + ".txt";


            int XE = (int)Math.Floor((width - Math.Max(edgeclearance, LabelHeight) * 2) / 2.54);
            int YE = (int)Math.Floor((height - Math.Max(edgeclearance, LabelHeight) * 2) / 2.54);

            PrepareGridSpace(XE, YE, true, true, 3, 2);

            string[][] Grid = new string[XE + 1][];
            for (int x = 0; x <= XE; x++)
            {
                Grid[x] = new string[YE + 1];
                for (int y = 0; y <= YE; y++)
                {
                    Grid[x][y] = GridSpaceType(x, y);
                    if (y == YE)
                    {
                        Grid[x][y] = "None";
                    }
                    if (x == XE)
                    {
                        Grid[x][y] = "None";
                    }
                }
            }

            double XO = (width / 2) - (XE / 2.0) * 2.54;
            double YO = (height / 2) - (YE / 2.0) * 2.54;

            Console.WriteLine("{0} rows and {1} columns", YE, XE);


            ExcellonFile EF = new ExcellonFile();
            PointD       C1 = new PointD(0, 0);
            PointD       C2 = new PointD(width, 0);
            PointD       C3 = new PointD(width, height);
            PointD       C4 = new PointD(0, height);

            if (mountholediameter > 0)
            {
                ExcellonTool MountHoleDrill = new ExcellonTool();
                MountHoleDrill.Radius = mountholediameter / 2.0;


                C1 = new PointD(mountholeclearance, mountholeclearance);
                C2 = new PointD(width - mountholeclearance, mountholeclearance);
                C3 = new PointD(width - mountholeclearance, height - mountholeclearance);
                C4 = new PointD(mountholeclearance, height - mountholeclearance);
                MountHoleDrill.Drills.Add(C1);
                MountHoleDrill.Drills.Add(C2);
                MountHoleDrill.Drills.Add(C3);
                MountHoleDrill.Drills.Add(C4);

                EF.Tools[10] = MountHoleDrill;
            }
            ExcellonTool ProtoHoleDrill = new ExcellonTool();

            ProtoHoleDrill.Radius = DrillWidth / 2.0;



            PolyLine PL = new PolyLine(polyid++);

            PL.Add(cornerrounding, 0);
            PL.Add(width - cornerrounding, 0);
            PL.ArcTo(new PointD(width, cornerrounding), new PointD(0, cornerrounding), InterpolationMode.CounterClockwise);
            PL.Add(width, height - cornerrounding);
            PL.ArcTo(new PointD(width - cornerrounding, height), new PointD(-cornerrounding, 0), InterpolationMode.CounterClockwise);
            PL.Add(cornerrounding, height);
            PL.ArcTo(new PointD(0, height - cornerrounding), new PointD(0, -cornerrounding), InterpolationMode.CounterClockwise);
            PL.Add(0, cornerrounding);
            PL.ArcTo(new PointD(cornerrounding, 0), new PointD(cornerrounding, 0), InterpolationMode.CounterClockwise);
            PL.Close();

            GerberArtWriter GAW = new GerberArtWriter();

            GAW.AddPolyLine(PL, 0);
            GAW.Write(OutlineFile);

            GerberArtWriter GAWTop    = new GerberArtWriter();
            GerberArtWriter GAWBottom = new GerberArtWriter();

            GerberArtWriter MaskTop    = new GerberArtWriter();
            GerberArtWriter MaskBottom = new GerberArtWriter();
            GerberArtWriter SilkTop    = new GerberArtWriter();
            GerberArtWriter SilkBottom = new GerberArtWriter();

            for (int x = 0; x < XE; x++)
            {
                double xc = XO + x * 2.54 + 2.54 / 2;
                for (int y = 0; y < YE; y++)
                {
                    double yc = YO + y * 2.54 + 2.54 / 2;

                    PointD P = new PointD(xc, yc);
                    if ((P - C1).Length() < edgeclearance + mountholediameter / 2 + 1.27)
                    {
                        Grid[x][y] = "None";
                    }
                    if ((P - C2).Length() < edgeclearance + mountholediameter / 2 + 1.27)
                    {
                        Grid[x][y] = "None";
                    }
                    if ((P - C3).Length() < edgeclearance + mountholediameter / 2 + 1.27)
                    {
                        Grid[x][y] = "None";
                    }
                    if ((P - C4).Length() < edgeclearance + mountholediameter / 2 + 1.27)
                    {
                        Grid[x][y] = "None";
                    }

                    if (Grid[x][y] != "None")
                    {
                        GAWTop.AddFlash(new PointD(xc, yc), DrillWidth * 1.3 / 2.0);
                        GAWBottom.AddFlash(new PointD(xc, yc), DrillWidth * 1.3 / 2.0);
                        MaskTop.AddFlash(new PointD(xc, yc), DrillWidth * 1.3 / 2.0);
                        MaskBottom.AddFlash(new PointD(xc, yc), DrillWidth * 1.3 / 2.0);
                        ProtoHoleDrill.Drills.Add(new PointD(xc, yc));
                    }
                }
            }

            //            SilkTop.DrawString(new PointD(5, 0), FS, "O0O", 5, 0.05, StringAlign.BottomCenter);
            //           SilkTop.DrawString(new PointD(20, 0), FS, "O0O", 5, 0.05, StringAlign.CenterCenter);
            //         SilkTop.DrawString(new PointD(40, 0), FS, "OMO", 5, 0.05, StringAlign.TopCenter);

            for (int x = 0; x < XE; x++)
            {
                double xc  = XO + x * 2.54 + 2.54 / 2;
                double yc  = YO + (0) * 2.54;
                double yc1 = YO + (YE) * 2.54 + 2.54;
                char   T   = (char)('A' + (char)((x) % 26));

                if (Grid[x][0] != "None")
                {
                    SilkTop.DrawString(new PointD(xc, yc), FS, T.ToString(), LabelHeight, 0.05, StringAlign.CenterCenter);
                    SilkBottom.DrawString(new PointD(xc, yc), FS, T.ToString(), LabelHeight, 0.05, StringAlign.CenterCenter, true);
                }

                if (Grid[x][YE - 1] != "None")
                {
                    SilkTop.DrawString(new PointD(xc, yc1), FS, T.ToString(), LabelHeight, 0.05, StringAlign.CenterCenter);
                    SilkBottom.DrawString(new PointD(xc, yc1), FS, T.ToString(), LabelHeight, 0.05, StringAlign.CenterCenter, true);
                }
            }
            for (int y = 0; y < YE; y++)
            {
                double xc  = XO + (0) * 2.54 - 2.54 / 2;
                double xc1 = XO + (XE + 1) * 2.54 - 2.54 / 2;
                double yc  = YO + (y) * 2.54 + 2.54;

                if (Grid[0][y] != "None")
                {
                    SilkTop.DrawString(new PointD(xc, yc), FS, (YE - y).ToString(), LabelHeight, 0.05, StringAlign.CenterCenter);
                    SilkBottom.DrawString(new PointD(xc, yc), FS, (YE - y).ToString(), LabelHeight, 0.05, StringAlign.CenterCenter, true);
                }

                if (Grid[XE - 1][y] != "None")
                {
                    SilkTop.DrawString(new PointD(xc1, yc), FS, (YE - y).ToString(), LabelHeight, 0.05, StringAlign.CenterCenter);
                    SilkBottom.DrawString(new PointD(xc1, yc), FS, (YE - y).ToString(), LabelHeight, 0.05, StringAlign.CenterCenter, true);
                }
            }

            PolyLine PL2 = new PolyLine(polyid++);
            double   rad = 0.6;

            for (int i = 0; i < 20; i++)
            {
                double P = i * Math.PI / 19.0;
                PL2.Add(Math.Sin(P) * rad, Math.Cos(P) * rad);
            }
            PL2.Close();
            PL2.Translate(-1.1, 0);


            for (int x = -1; x < XE + 1; x++)
            {
                for (int y = -1; y < YE + 1; y++)
                {
                    string s1 = "None";
                    if (y >= 0 && y < YE && x < XE)
                    {
                        s1 = Grid[x + 1][y];
                    }
                    string s2 = "None";
                    if (x >= 0 && x < XE && y < YE)
                    {
                        s2 = Grid[x][y + 1];
                    }
                    string s3 = "None";
                    if (x >= 0 && x < XE && y >= 0 && y < YE)
                    {
                        s3 = Grid[x][y];
                    }
                    double xc  = XO + x * 2.54 + 2.54 / 2;
                    double yc  = YO + y * 2.54 + 2.54 / 2;
                    double xc1 = XO + (x + 1) * 2.54 + 2.54 / 2;
                    double yc1 = YO + (y + 1) * 2.54 + 2.54 / 2;

                    if (s1 != "None" && s3 != "None")
                    {
                        PolyLine PLA = PL2.Copy();
                        PLA.Translate(xc1, yc);
                        PolyLine PLC = PL2.Copy();
                        PLC.RotateDegrees(180);
                        PLC.Translate(xc, yc);

                        GAWTop.AddPolygon(PLA);
                        MaskTop.AddPolygon(PLA);
                        GAWTop.AddPolygon(PLC);
                        MaskTop.AddPolygon(PLC);
                        GAWBottom.AddPolygon(PLA);
                        MaskBottom.AddPolygon(PLA);
                        GAWBottom.AddPolygon(PLC);
                        MaskBottom.AddPolygon(PLC);
                    }

                    if (s3 != "None" && s2 != "None")
                    {
                        PolyLine PLB = PL2.Copy();
                        PLB.RotateDegrees(90);
                        PLB.Translate(xc, yc1);
                        PolyLine PLD = PL2.Copy();
                        PLD.RotateDegrees(270);
                        PLD.Translate(xc, yc);

                        GAWTop.AddPolygon(PLB);
                        MaskTop.AddPolygon(PLB);
                        GAWTop.AddPolygon(PLD);
                        MaskTop.AddPolygon(PLD);
                        GAWBottom.AddPolygon(PLB);
                        MaskBottom.AddPolygon(PLB);
                        GAWBottom.AddPolygon(PLD);
                        MaskBottom.AddPolygon(PLD);
                        //       GAWTop.AddPolygon(PLD);
                        //     MaskTop.AddPolygon(PLD);
                    }
                }
            }

            GAWTop.Write(CopperTop);

            GAWBottom.Write(CopperBottom);
            SilkBottom.Write(SilkFileBottom);
            SilkTop.Write(SilkFileTop);

            MaskTop.Write(SolderMaskTop);
            MaskBottom.Write(SolderMaskBottom);
            EF.Tools[11] = ProtoHoleDrill;
            EF.Write(DrillFile, 0, 0, 0, 0);

            FilesGenerated.Add(CopperBottom);
            FilesGenerated.Add(CopperTop);
            FilesGenerated.Add(OutlineFile);
            FilesGenerated.Add(DrillFile);
            FilesGenerated.Add(SilkFileBottom);
            FilesGenerated.Add(SilkFileTop);
            FilesGenerated.Add(SolderMaskBottom);
            FilesGenerated.Add(SolderMaskTop);


            if (WriteCombinedImage)
            {
                GerberImageCreator GIC = new GerberImageCreator();
                GIC.AddBoardsToSet(FilesGenerated);
                GIC.WriteImageFiles(basename + "_render", 200, false);
            }
            if (WriteImages)
            {
                Gerber.SaveGerberFileToImage(OutlineFile, OutlineFile + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(CopperBottom, CopperBottom + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(CopperTop, CopperTop + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(DrillFile, DrillFile + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(SilkFileTop, SilkFileTop + "_render.png", 1000, Color.Black, Color.White);
                Gerber.SaveGerberFileToImage(SilkFileBottom, SilkFileBottom + "_render.png", 1000, Color.Black, Color.White);
            }

            return(FilesGenerated);
        }
        private void button1_Click(object sender, EventArgs e)
        {
            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                int    polyid     = 0;
                string fname      = System.IO.Path.GetFileName(saveFileDialog1.FileName);
                string fnamenoext = System.IO.Path.GetFileNameWithoutExtension(saveFileDialog1.FileName);
                string OutName    = "";
                if (fname.Length != fnamenoext.Length)
                {
                    int extlen = fname.Length - fnamenoext.Length;
                    OutName = saveFileDialog1.FileName.Substring(0, saveFileDialog1.FileName.Length - extlen);
                }
                else
                {
                    OutName = saveFileDialog1.FileName;
                }


                List <string> Files = new List <string>();

                double W  = (double)innerWidth.Value;
                double H  = (double)innerHeight.Value;
                double TE = (double)topEdge.Value;
                double LE = (double)leftEdge.Value;

                double OuterWidth  = W + LE * 2.0;
                double OuterHeight = H + TE * 2.0;
                double InnerWidth  = W;
                double InnerHeight = H;

                GerberArtWriter Outline       = new GerberArtWriter();
                GerberArtWriter TopSilk       = new GerberArtWriter();
                GerberArtWriter TopCopper     = new GerberArtWriter();
                GerberArtWriter TopSolderMask = new GerberArtWriter();

                GerberArtWriter BottomSilk       = new GerberArtWriter();
                GerberArtWriter BottomCopper     = new GerberArtWriter();
                GerberArtWriter BottomSolderMask = new GerberArtWriter();


                List <PointD> DrillHoles        = new List <PointD>();
                double        mountholediameter = (double)holeDiameter.Value;

                if (addHolesCheck.Checked)
                {
                    double side = LE / 2.0;
                    double top  = TE / 2.0;


                    DrillHoles.Add(new PointD(side, top));
                    DrillHoles.Add(new PointD(OuterWidth - side, top));
                    DrillHoles.Add(new PointD(OuterWidth - side, OuterHeight - top));
                    DrillHoles.Add(new PointD(side, OuterHeight - top));

                    ExcellonFile EF = new ExcellonFile();

                    ExcellonTool MountHoleDrill = new ExcellonTool();
                    MountHoleDrill.Radius = mountholediameter / 2.0;

                    foreach (var a in DrillHoles)
                    {
                        MountHoleDrill.Drills.Add(a);
                    }
                    EF.Tools[10] = MountHoleDrill;
                    EF.Write(OutName + ".txt", 0, 0, 0, 0);

                    Files.Add(OutName + ".txt");
                }

                // board outline
                PolyLine PL = new PolyLine(polyid++);
                PL.MakeRoundedRect(new PointD(0, 0), new PointD(OuterWidth, OuterHeight), (double)roundedOuterCorners.Value);
                Outline.AddPolyLine(PL, 0);
                PolyLine PL2 = new PolyLine(polyid++);

                PL2.MakeRoundedRect(new PointD(LE, TE), new PointD(InnerWidth + LE, InnerHeight + TE), (double)roundedInnerCorners.Value);
                Outline.AddPolyLine(PL2, 0);

                #region fiducials

                List <PointD> Fiducials = new List <PointD>();

                foreach (DataGridViewRow dataRow in fiducialsListData.Rows)
                {
                    PointD fiducialPoint = new PointD();

                    if (dataRow.Cells != null && dataRow.Cells["XCoordinate"].Value != null && dataRow.Cells["YCoordinate"].Value != null)
                    {
                        fiducialPoint.X = double.Parse(dataRow.Cells["XCoordinate"].Value.ToString());
                        fiducialPoint.Y = double.Parse(dataRow.Cells["YCoordinate"].Value.ToString());

                        if (string.Equals(dataRow.Cells["fiducialLayer"].Value.ToString(), "Top"))
                        {
                            TopCopper.AddFlash(fiducialPoint, double.Parse(dataRow.Cells["fiducialCopperDiameter"].Value.ToString()) / 2.0);
                            TopSolderMask.AddFlash(fiducialPoint, double.Parse(dataRow.Cells["fiducialSolderMaskDiam"].Value.ToString()) / 2.0);
                        }
                        else
                        {
                            BottomCopper.AddFlash(fiducialPoint, double.Parse(dataRow.Cells["fiducialCopperDiameter"].Value.ToString()) / 2.0);
                            BottomSolderMask.AddFlash(fiducialPoint, double.Parse(dataRow.Cells["fiducialSolderMaskDiam"].Value.ToString()) / 2.0);
                        }
                    }
                }

                #endregion

                string FrameTitle = FrameTitleBox.Text;

                if (FrameTitle.Length > 0)
                {
                    FontSet FS = FontSet.Load("Font.xml");
                    TopSilk.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - top", TE / 4.0, 0.1, StringAlign.CenterCenter);
                    TopCopper.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - top", TE / 4.0, 0.1, StringAlign.CenterCenter);
                    BottomSilk.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - bottom", TE / 4.0, 0.1, StringAlign.CenterCenter, true);
                    BottomCopper.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - bottom", TE / 4.0, 0.1, StringAlign.CenterCenter, true);
                }

                foreach (var a in DrillHoles)
                {
                    TopSolderMask.AddFlash(a, mountholediameter / 2.0 + 1.0);
                    BottomSolderMask.AddFlash(a, mountholediameter / 2.0 + 1.0);
                }

                Outline.Write(OutName + ".gko");
                TopSilk.Write(OutName + ".gto");
                TopCopper.Write(OutName + ".gtl");
                TopSolderMask.Write(OutName + ".gts");

                BottomSilk.Write(OutName + ".gbo");
                BottomCopper.Write(OutName + ".gbl");
                BottomSolderMask.Write(OutName + ".gbs");


                Files.Add(OutName + ".gko");
                Files.Add(OutName + ".gto");
                Files.Add(OutName + ".gtl");
                Files.Add(OutName + ".gts");
                Files.Add(OutName + ".gbo");
                Files.Add(OutName + ".gbl");
                Files.Add(OutName + ".gbs");
                GerberImageCreator GIC = new GerberImageCreator();
                GIC.AddBoardsToSet(Files, new StandardConsoleLog());

                GIC.WriteImageFiles(OutName, 50);
                // Gerber.SaveGerberFileToImage(OutName + ".gko", OutName + ".gko.png", 200, Color.Black, Color.White);
                // Gerber.SaveGerberFileToImage(OutName + ".gto", OutName + ".gto.png", 200, Color.Black, Color.White);
            }
        }
Example #7
0
        private void button1_Click(object sender, EventArgs e)
        {
            if (saveFileDialog1.ShowDialog() == DialogResult.OK)
            {
                string fname      = System.IO.Path.GetFileName(saveFileDialog1.FileName);
                string fnamenoext = System.IO.Path.GetFileNameWithoutExtension(saveFileDialog1.FileName);
                string OutName    = "";
                if (fname.Length != fnamenoext.Length)
                {
                    int extlen = fname.Length - fnamenoext.Length;
                    OutName = saveFileDialog1.FileName.Substring(0, saveFileDialog1.FileName.Length - extlen);
                }
                else
                {
                    OutName = saveFileDialog1.FileName;
                }



                List <string> Files = new List <string>();

                double W  = (double)innerWidth.Value;
                double H  = (double)innerHeight.Value;
                double TE = (double)topEdge.Value;
                double LE = (double)leftEdge.Value;

                double OuterWidth  = W + LE * 2.0;
                double OuterHeight = H + TE * 2.0;
                double InnerWidth  = W;
                double InnerHeight = H;

                GerberArtWriter Outline       = new GerberArtWriter();
                GerberArtWriter TopSilk       = new GerberArtWriter();
                GerberArtWriter TopCopper     = new GerberArtWriter();
                GerberArtWriter TopSolderMask = new GerberArtWriter();

                GerberArtWriter BottomSilk       = new GerberArtWriter();
                GerberArtWriter BottomCopper     = new GerberArtWriter();
                GerberArtWriter BottomSolderMask = new GerberArtWriter();


                List <PointD> DrillHoles        = new List <PointD>();
                double        mountholediameter = (double)holeDiameter.Value;

                if (addHolesCheck.Checked)
                {
                    double side = LE / 2.0;
                    double top  = TE / 2.0;


                    DrillHoles.Add(new PointD(side, top));
                    DrillHoles.Add(new PointD(OuterWidth - side, top));
                    DrillHoles.Add(new PointD(OuterWidth - side, OuterHeight - top));
                    DrillHoles.Add(new PointD(side, OuterHeight - top));


                    ExcellonFile EF = new ExcellonFile();

                    ExcellonTool MountHoleDrill = new ExcellonTool();
                    MountHoleDrill.Radius = mountholediameter / 2.0;

                    foreach (var a in DrillHoles)
                    {
                        MountHoleDrill.Drills.Add(a);
                    }
                    EF.Tools[10] = MountHoleDrill;
                    EF.Write(OutName + ".txt", 0, 0, 0, 0);

                    Files.Add(OutName + ".txt");
                }


                PolyLine PL = new PolyLine();
                PL.MakeRoundedRect(new PointD(0, 0), new PointD(OuterWidth, OuterHeight), (double)roundedOuterCorners.Value);
                Outline.AddPolyLine(PL, 0);
                PolyLine PL2 = new PolyLine();

                PL2.MakeRoundedRect(new PointD(LE, TE), new PointD(InnerWidth + LE, InnerHeight + TE), (double)roundedInnerCorners.Value);
                Outline.AddPolyLine(PL2, 0);

                if (fiducials.Checked)
                {
                    List <PointD> Fiducials = new List <PointD>();
                    Fiducials.Add(new PointD(LE * 2.0, TE / 2.0));
                    Fiducials.Add(new PointD(OuterWidth - LE * 2.0, TE / 2.0));
                    Fiducials.Add(new PointD(OuterWidth - LE * 2.0, OuterHeight - TE / 2.0));
                    Fiducials.Add(new PointD(LE * 2.0, OuterHeight - TE / 2.0));
                    Fiducials.Add(new PointD(OuterWidth / 2, TE / 2.0)); //generate extra non symetric fiducial
                    foreach (var A in Fiducials)
                    {
                        TopCopper.AddFlash(A, 1.0);
                        TopSolderMask.AddFlash(A, 3.0);
                    }
                }
                string FrameTitle = FrameTitleBox.Text;

                if (FrameTitle.Length > 0)
                {
                    FontSet FS = FontSet.Load("Font.xml");
                    TopSilk.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - top", TE / 4.0, 0.1, StringAlign.CenterCenter);
                    TopCopper.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - top", TE / 4.0, 0.1, StringAlign.CenterCenter);
                    BottomSilk.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - bottom", TE / 4.0, 0.1, StringAlign.CenterCenter, true);
                    BottomCopper.DrawString(new PointD(OuterWidth / 2.0, OuterHeight - TE / 4.0), FS, FrameTitle + " - bottom", TE / 4.0, 0.1, StringAlign.CenterCenter, true);
                }

                foreach (var a in DrillHoles)
                {
                    TopSolderMask.AddFlash(a, mountholediameter / 2.0 + 1.0);
                    BottomSolderMask.AddFlash(a, mountholediameter / 2.0 + 1.0);
                }

                Outline.Write(OutName + ".gko");
                TopSilk.Write(OutName + ".gto");
                TopCopper.Write(OutName + ".gtl");
                TopSolderMask.Write(OutName + ".gts");

                BottomSilk.Write(OutName + ".gbo");
                BottomCopper.Write(OutName + ".gbl");
                BottomSolderMask.Write(OutName + ".gbs");


                Files.Add(OutName + ".gko");
                Files.Add(OutName + ".gto");
                Files.Add(OutName + ".gtl");
                Files.Add(OutName + ".gts");
                Files.Add(OutName + ".gbo");
                Files.Add(OutName + ".gbl");
                Files.Add(OutName + ".gbs");
                GerberImageCreator GIC = new GerberImageCreator();
                GIC.AddBoardsToSet(Files);

                GIC.WriteImageFiles(OutName, 50);
                // Gerber.SaveGerberFileToImage(OutName + ".gko", OutName + ".gko.png", 200, Color.Black, Color.White);
                // Gerber.SaveGerberFileToImage(OutName + ".gto", OutName + ".gto.png", 200, Color.Black, Color.White);
            }
        }