Beispiel #1
0
        }                                                            // Excellon drill statistics for the layer.

        // Constructor
        public GerberImage(string fileTypeName)
        {
            ImageInfo      = new GerberImageInfo();
            ImageInfo.MinX = double.MaxValue;
            ImageInfo.MinY = double.MaxValue;
            ImageInfo.MaxX = double.MinValue;
            ImageInfo.MaxY = double.MinValue;
            if (string.IsNullOrEmpty(fileTypeName))
            {
                ImageInfo.FileTypeName = "Unknown";
            }

            else
            {
                ImageInfo.FileTypeName = fileTypeName;
            }

            // The individual file parsers will have to set this.
            ImageInfo.AttributeList     = null;
            ImageInfo.NumberOfAttribute = 0;
            apertureMacroList           = new Collection <ApertureMacro>();
            ApertureArray = new ApertureDefinition[Gerber.MaximumApertures];
            LevelList     = new List <GerberLevel>();
            NetStateList  = new List <GerberNetState>();
            Format        = new GerberFormat();
            gerberNetList = new Collection <GerberNet>();
            GerberStats   = new GerberFileStats();
            DrillStats    = new DrillFileStats();
            GerberNet gerberNet = new GerberNet();          // Create first gerberNet and fill in some initial values.

            gerberNet.Level    = new GerberLevel(this);     // Create our first level and fill with some default values.
            gerberNet.NetState = new GerberNetState(this);  // Create our first netState.
            gerberNet.Label    = String.Empty;
            GerberNetList.Add(gerberNet);
        }
Beispiel #2
0
        // Simplify the aperture macro.
        public static bool SimplifyApertureMacro(ApertureDefinition aperture, double scale)
        {
            const int extraStackSize     = 10;
            bool      success            = true;
            int       numberOfParameters = 0;
            bool      clearOperatorUsed  = false;

            double[]                localParameters = new double[Gerber.MaximumApertureParameters]; // Local copy of parameters.
            double[]                tmp             = { 0.0, 0.0 };
            int                     index           = 0;
            GerberApertureType      type            = GerberApertureType.None;
            SimplifiedApertureMacro macro;

            if (aperture == null || aperture.ApertureMacro == null)
            {
                throw new GerberApertureException("In SimplifyApertureMacro, aperture = null");
            }

            // Allocate stack for VM.
            MacroStack.InitializeStack(aperture.ApertureMacro.NufPushes + extraStackSize);

            // Make a copy of the parameter list that we can rewrite if necessary.
            localParameters = new double[Gerber.MaximumApertureParameters];
            foreach (double p in aperture.Parameters)
            {
                localParameters[index++] = p;
            }

            foreach (GerberInstruction instruction in aperture.ApertureMacro.InstructionList)
            {
                switch (instruction.Opcode)
                {
                case GerberOpcodes.NOP:
                    break;

                case GerberOpcodes.Push:
                    MacroStack.Push(instruction.Data.DoubleValue);
                    break;

                case GerberOpcodes.PushParameter:
                    MacroStack.Push(localParameters[instruction.Data.IntValue - 1]);
                    break;

                case GerberOpcodes.PopParameter:
                    MacroStack.Pop(ref tmp[0]);
                    localParameters[instruction.Data.IntValue - 1] = tmp[0];
                    break;

                case GerberOpcodes.Add:
                    MacroStack.Pop(ref tmp[0]);
                    MacroStack.Pop(ref tmp[1]);
                    MacroStack.Push(tmp[1] + tmp[0]);
                    break;

                case GerberOpcodes.Subtract:
                    MacroStack.Pop(ref tmp[0]);
                    MacroStack.Pop(ref tmp[1]);
                    MacroStack.Push(tmp[1] - tmp[0]);
                    break;

                case GerberOpcodes.Multiple:
                    MacroStack.Pop(ref tmp[0]);
                    MacroStack.Pop(ref tmp[1]);
                    MacroStack.Push(tmp[1] * tmp[0]);
                    break;

                case GerberOpcodes.Divide:
                    MacroStack.Pop(ref tmp[0]);
                    MacroStack.Pop(ref tmp[1]);
                    MacroStack.Push(tmp[1] / tmp[0]);
                    break;

                case GerberOpcodes.Primative:
                    // This handles the exposure thing in the aperture macro.
                    // The exposure is always the first element on stack independent
                    // of aperture macro.
                    switch (instruction.Data.IntValue)
                    {
                    case 1:
                        //Debug.Write("    Aperture macro circle [1] (");
                        type = GerberApertureType.MacroCircle;
                        numberOfParameters = 4;
                        break;

                    case 3:
                        break;          // EOF.

                    case 4:
                        //Debug.Write("    Aperture macro outline [4] (");
                        type = GerberApertureType.MacroOutline;
                        // Number of parameters are:
                        // Number of points defined in entry 1 of the stack + start point. Times two since it is both X and Y.
                        // Then three more; exposure, nuf points and rotation.
                        numberOfParameters = ((int)MacroStack.Values[1] + 1) * 2 + 3;
                        break;

                    case 5:
                        //Debug.Write("    Aperture macro polygon [5] (");
                        type = GerberApertureType.MacroPolygon;
                        numberOfParameters = 6;
                        break;

                    case 6:
                        //Debug.WriteLine("    Aperture macro moiré [6] (");
                        type = GerberApertureType.MacroMoire;
                        numberOfParameters = 9;
                        break;

                    case 7:
                        //Debug.Write("    Aperture macro thermal [7] (");
                        type = GerberApertureType.MacroThermal;
                        numberOfParameters = 6;
                        break;

                    case 2:
                    case 20:
                        //Debug.Write("    Aperture macro line 20/2 (");
                        type = GerberApertureType.MacroLine20;
                        numberOfParameters = 7;
                        break;

                    case 21:
                        //Debug.Write("    Aperture macro line 21 (");
                        type = GerberApertureType.MarcoLine21;
                        numberOfParameters = 6;
                        break;

                    case 22:
                        //Debug.Write("    Aperture macro line 22 (");
                        type = GerberApertureType.MacroLine22;
                        numberOfParameters = 6;
                        break;

                    default:
                        success = false;
                        break;
                    }

                    if (type != GerberApertureType.None)
                    {
                        if (numberOfParameters > Gerber.MaximumApertureParameters)
                        {
                            throw new GerberApertureException("Too many parameters for aperture macro;");
                            // GERB_COMPILE_ERROR("Number of parameters to aperture macro are more than gerbv is able to store\n");
                        }

                        // Create a new simplified aperture macro and start filling in the blanks.
                        macro = new SimplifiedApertureMacro();
                        macro.ApertureType = type;
                        index = 0;
                        for (int i = 0; i < numberOfParameters; i++)
                        {
                            macro.Parameters[i] = MacroStack.Values[i];
                        }

                        // Convert any mm values to inches.
                        switch (type)
                        {
                        case GerberApertureType.MacroCircle:
                            if (Math.Abs(macro.Parameters[0]) < 0.001)
                            {
                                clearOperatorUsed = true;
                            }

                            macro.Parameters[1] /= scale;
                            macro.Parameters[2] /= scale;
                            macro.Parameters[3] /= scale;
                            break;

                        case GerberApertureType.MacroOutline:
                            if (Math.Abs(macro.Parameters[0]) < 0.001)
                            {
                                clearOperatorUsed = true;
                            }

                            for (int i = 2; i < numberOfParameters - 1; i++)
                            {
                                macro.Parameters[i] /= scale;
                            }

                            break;

                        case GerberApertureType.MacroPolygon:
                            if (Math.Abs(macro.Parameters[0]) < 0.001)
                            {
                                clearOperatorUsed = true;
                            }

                            macro.Parameters[2] /= scale;
                            macro.Parameters[3] /= scale;
                            macro.Parameters[4] /= scale;
                            break;

                        case GerberApertureType.MacroMoire:
                            macro.Parameters[0] /= scale;
                            macro.Parameters[1] /= scale;
                            macro.Parameters[2] /= scale;
                            macro.Parameters[3] /= scale;
                            macro.Parameters[4] /= scale;
                            macro.Parameters[6] /= scale;
                            macro.Parameters[7] /= scale;
                            break;

                        case GerberApertureType.MacroThermal:
                            macro.Parameters[0] /= scale;
                            macro.Parameters[1] /= scale;
                            macro.Parameters[2] /= scale;
                            macro.Parameters[3] /= scale;
                            macro.Parameters[4] /= scale;
                            break;

                        case GerberApertureType.MacroLine20:
                            if (Math.Abs(macro.Parameters[0]) < 0.001)
                            {
                                clearOperatorUsed = true;
                            }

                            macro.Parameters[1] /= scale;
                            macro.Parameters[2] /= scale;
                            macro.Parameters[3] /= scale;
                            macro.Parameters[4] /= scale;
                            macro.Parameters[5] /= scale;
                            break;

                        case GerberApertureType.MarcoLine21:
                        case GerberApertureType.MacroLine22:
                            if (Math.Abs(macro.Parameters[0]) < 0.001)
                            {
                                clearOperatorUsed = true;
                            }

                            macro.Parameters[1] /= scale;
                            macro.Parameters[2] /= scale;
                            macro.Parameters[3] /= scale;
                            macro.Parameters[4] /= scale;
                            break;

                        default:
                            break;
                        }

                        aperture.SimplifiedMacroList.Add(macro);
                        //for (int i = 0; i < numberOfParameters; i++)
                        //    Debug.Write(String.Format("{0}, ", MacroStack.Values[i]));

                        //Debug.WriteLine(")");
                    }

                    // Here we reset the stack pointer. It's not generally
                    // correct to do this, but since I know how the compiler works
                    // I can do this. The correct way to do this should be to
                    // subtract number of used elements in each primitive operation.
                    MacroStack.Reset();
                    break;

                default:
                    break;
                }
            }

            // Store a flag to let the renderer know if it should expect any "clear" primatives.
            aperture.Parameters[0] = clearOperatorUsed ? 1.0f : 0.0f;
            return(success);
        }