gerber_file_image.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2010-2019 Jean-Pierre Charras  jp.charras at wanadoo.fr
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#ifndef GERBER_FILE_IMAGE_H
#define GERBER_FILE_IMAGE_H
 
#include <vector>
#include <set>
 
#include <dcode.h>
#include <gerber_draw_item.h>
#include <am_primitive.h>
#include <aperture_macro.h>
#include <gbr_netlist_metadata.h>
 
typedef std::vector<GERBER_DRAW_ITEM*> GERBER_DRAW_ITEMS;
 
class GERBVIEW_FRAME;
class D_CODE;
 
/* Gerber files have different parameters to define units and how items must be plotted.
 * some are for the entire file, and other can change along a file.
 * In Gerber world:
 * an image is the entire gerber file and its "global" parameters
 * a layer (that is very different from a board layer) is just a sub set of a file that
 * have specific parameters
 * if a Image parameter is set more than once, only the last value is used
 * Some parameters can change along a file and are not layer specific: they are stored
 * in GERBER_ITEM items, when instanced.
 *
 * In GerbView, to handle these parameters, there are 2 classes:
 * GERBER_FILE_IMAGE : the main class containing most of parameters and data to plot a
 * graphic layer
 * Some of them can change along the file
 * There is one GERBER_FILE_IMAGE per file and one graphic layer per file or GERBER_FILE_IMAGE
 * GerbView does not read and merge 2 gerber file in one graphic layer:
 * I believe this is not possible due to the constraints in Image parameters.
 * GERBER_LAYER : containing the subset of parameters that is layer specific
 * A GERBER_FILE_IMAGE must include one GERBER_LAYER to define all parameters to plot a file.
 * But a GERBER_FILE_IMAGE can use more than one GERBER_LAYER.
 */
 
class GERBER_FILE_IMAGE;
class X2_ATTRIBUTE;
class X2_ATTRIBUTE_FILEFUNCTION;
 
// For arcs, coordinates need 3 info: start point, end point and center or radius
// In Excellon files it can be a A## value (radius) or I#J# center coordinates (like in gerber)
// We need to know the last read type when reading a list of routing coordinates
enum LAST_EXTRA_ARC_DATA_TYPE
{
    ARC_INFO_TYPE_NONE,
    ARC_INFO_TYPE_CENTER,   // last info is a IJ command: arc center is given
    ARC_INFO_TYPE_RADIUS,   // last info is a A command: arc radius is given
};
 
class GERBER_LAYER
{
public:
    GERBER_LAYER();
    ~GERBER_LAYER();
 
private:
    void ResetDefaultValues();
    friend class GERBER_FILE_IMAGE;
 
public:
   // These parameters are layer specific:
    wxString    m_LayerName;            // Layer name, from LN <name>* command
    bool        m_LayerNegative;        // true = Negative Layer: command LP
    wxRealPoint m_StepForRepeat;        // X and Y offsets for Step and Repeat command
    int         m_XRepeatCount;         // The repeat count on X axis
    int         m_YRepeatCount;         // The repeat count on Y axis
    bool        m_StepForRepeatMetric;  // false = Inches, true = metric
                                        // needed here because repeated
                                        // gerber items can have coordinates
                                        // in different units than step parameters
                                        // and the actual coordinates calculation must handle this
};
 
// Currently, the Gerber file is parsed line by line.
// This is most of time OK
// GERBER_BUFZ is the max size of a single line of text from a gerber file.
// But warning: in rare cases some files can have *very long* lines,
// so the buffer must be very large.
// I saw a file using only one line of 1,400,000 chars
#define GERBER_BUFZ 5000000

class GERBER_FILE_IMAGE : public EDA_ITEM
{
public:
    GERBER_FILE_IMAGE( int layer );
    virtual ~GERBER_FILE_IMAGE();
 
    wxString GetClass() const override
    {
        return wxT( "GERBER_FILE_IMAGE" );
    }

    static bool TestFileIsRS274( const wxString& aFullFileName );

    bool LoadGerberFile( const wxString& aFullFileName );
 
    const wxArrayString& GetMessages() const { return m_messagesList; }

    int GetDcodesCount();

    virtual void ResetDefaultValues();
 
    COLOR4D GetPositiveDrawColor() const { return m_PositiveDrawColor; }

    GERBER_DRAW_ITEMS& GetItems() { return m_drawings; }

    int GetItemsCount() { return m_drawings.size(); }

    void AddItemToList( GERBER_DRAW_ITEM* aItem )
    {
        m_drawings.push_back( aItem );
    }

    GERBER_DRAW_ITEM* GetLastItemInList() const
    {
        return m_drawings.back();
    }

    GERBER_LAYER& GetLayerParams()
    {
        return m_GBRLayerParams;
    }

    bool HasNegativeItems();

    void ClearMessageList()
    {
        m_messagesList.Clear();
    }

    void AddMessageToList( const wxString& aMessage );

    VECTOR2I ReadXYCoord( char*& aText, bool aExcellonMode = false );

    VECTOR2I ReadIJCoord( char*& Text );

    int CodeNumber( char*& aText );

    D_CODE* GetDCODEOrCreate( int aDCODE, bool aCreateIfNoExist = true );

    D_CODE* GetDCODE( int aDCODE ) const;

    APERTURE_MACRO* FindApertureMacro( const APERTURE_MACRO& aLookup );

    void StepAndRepeatItem( const GERBER_DRAW_ITEM& aItem );

    void DisplayImageInfo( GERBVIEW_FRAME* aMainFrame );

    void SetDrawOffetAndRotation( VECTOR2D aOffsetMM, EDA_ANGLE aRotation );

    void RemoveAttribute( X2_ATTRIBUTE& aAttribute );

    INSPECT_RESULT Visit( INSPECTOR inspector, void* testData,
                          const std::vector<KICAD_T>& aScanTypes ) override;
 
#if defined(DEBUG)
 
    void    Show( int nestLevel, std::ostream& os ) const override { ShowDummy( os ); }
 
#endif
 
private:
    char* GetNextLine( char *aBuff, unsigned int aBuffSize, char* aText, FILE* aFile );
 
    bool GetEndOfBlock( char* aBuff, unsigned int aBuffSize, char*& aText, FILE* aGerberFile );

    bool ReadRS274XCommand( char *aBuff, unsigned int aBuffSize, char*& aText );

    bool ExecuteRS274XCommand( int aCommand, char* aBuff, unsigned int aBuffSize, char*& aText );

    int ReadXCommandID( char*& text );

    bool ReadApertureMacro( char *aBuff, unsigned int aBuffSize, char*& text, FILE* gerber_file );
 
    // functions to execute G commands or D basic commands:
    bool Execute_G_Command( char*& text, int G_command );
    bool Execute_DCODE_Command( char*& text, int D_command );
 
public:
    bool               m_InUse;                
    COLOR4D            m_PositiveDrawColor;    
    wxString           m_FileName;             
    wxString           m_ImageName;            
 
    bool               m_IsX2_file;            
    X2_ATTRIBUTE_FILEFUNCTION* m_FileFunction; 
    wxString           m_MD5_value;            
    wxString           m_PartString;           
    int                m_GraphicLayer;         
    bool               m_ImageNegative;        
 
    bool               m_ImageJustifyXCenter;  
    bool               m_ImageJustifyYCenter;  
    VECTOR2I           m_ImageJustifyOffset;   
 
    bool               m_GerbMetric;           
    bool               m_Relative;             
    bool               m_NoTrailingZeros;      
    VECTOR2I           m_ImageOffset;          
    wxSize             m_FmtScale;             
    wxSize             m_FmtLen;               
 
    int                m_ImageRotation;        
    double             m_LocalRotation;        
 
    VECTOR2I           m_Offset;               
    VECTOR2I           m_Scale;                
    bool               m_SwapAxis;             
    bool               m_MirrorA;              
    bool               m_MirrorB;              
    int                m_Iterpolation;         
    int                m_Current_Tool;         
    int                m_Last_Pen_Command;     
    int                m_CommandState;         
    int                m_LineNum;              
    VECTOR2I           m_CurrentPos;           
    VECTOR2I           m_PreviousPos;          
    VECTOR2I           m_IJPos;                

    bool               m_LastCoordIsIJPos;

    int                m_ArcRadius;

    LAST_EXTRA_ARC_DATA_TYPE m_LastArcDataType;
    FILE*              m_Current_File;                   // Current file to read
 
    int                m_Selected_Tool;                  // For highlight: current selected Dcode

    bool               m_Has_DCode;
 
    // true = some DCodes in file are not defined (broken file or deprecated RS274D file).
    bool               m_Has_MissingDCode;
    bool               m_360Arc_enbl;                    // Enable 360 deg circular interpolation
 
    // Set to true when a circular interpolation command type is found. Mandatory before
    // drawing an arc.
    bool               m_AsArcG74G75Cmd;
 
    // Enable polygon mode (read coord as a polygon descr)
    bool               m_PolygonFillMode;
 
    // In polygon mode: 0 = first segm, 1 = next segm
    int                m_PolygonFillModeState;

    APERTURE_MACRO_SET m_aperture_macros;
 
    // the net attributes set by a %TO.CN, %TO.C and/or %TO.N add object attribute command.
    GBR_NETLIST_METADATA m_NetAttributeDict;
 
    // the aperture function set by a %TA.AperFunction, xxx (stores the xxx value).
    wxString            m_AperFunction;
 
    std::map<wxString, int> m_ComponentsList;            // list of components
    std::map<wxString, int> m_NetnamesList;              // list of net names

    std::map<int, D_CODE*> m_ApertureList;

    bool               m_Exposure;
 
    GERBER_LAYER       m_GBRLayerParams;                 // hold params for the current gerber layer
    GERBER_DRAW_ITEMS  m_drawings;                       // linked list of Gerber Items to draw

    VECTOR2I           m_DisplayOffset;
    EDA_ANGLE          m_DisplayRotation;
 
    // A large buffer to store one line
    static char m_LineBuffer[GERBER_BUFZ+1];
 
private:
    wxArrayString      m_messagesList;         // A list of messages created when reading a file

    int                m_hasNegativeItems;
};
 
#endif  // ifndef GERBER_FILE_IMAGE_H