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, see <https://www.gnu.org/licenses/>.
 */
 
#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; }

    const GERBER_DRAW_ITEMS& GetItems() const { return m_drawings; }

    int GetItemsCount() const { 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 );

    double CalculateCopperArea();

    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