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 (C) 1992-2023 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
};
 
// size of a single line of text from a gerber file.
// warning: some files can have *very long* lines, so the buffer must be large.
#define GERBER_BUFZ 1000000
 
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 )
 {
 m_messagesList.Add( 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
 
 D_CODE* m_Aperture_List[TOOLS_MAX_COUNT];
 
 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