import_fabmaster.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019-2021 KiCad Developers, see AUTHORS.txt for contributors.
 * Author: Seth Hillbrand <[email protected]>
 *
 * 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 PCBNEW_IMPORTERS_IMPORT_FABMASTER_H_
#define PCBNEW_IMPORTERS_IMPORT_FABMASTER_H_

#include <eda_text.h>
#include <geometry/shape_arc.h>
#include <hash_eda.h>
#include <pad_shapes.h>

#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <string>
#include <vector>

#include <wx/filename.h>

enum PCB_LAYER_ID : int;
class BOARD;
class PROGRESS_REPORTER;

class FABMASTER
{
public:

 using single_row = std::vector<std::string>;
 FABMASTER() :
 has_pads( false ),
 has_comps( false ),
 has_graphic( false ),
 has_nets( false ),
 has_pins( false ),
 m_progressReporter( nullptr ),
 m_doneCount( 0 ),
 m_lastProgressCount( 0 ),
 m_totalCount( 0 )

 {}

 bool Read( const std::string& aFile );

 bool Process();

 bool LoadBoard( BOARD* aBoard, PROGRESS_REPORTER* aProgressReporter );

private:

 wxFileName m_filename;

 enum section_type : int
 {
 UNKNOWN_EXTRACT,
 EXTRACT_PADSTACKS,
 EXTRACT_PAD_SHAPES,
 EXTRACT_FULL_LAYERS,
 EXTRACT_VIAS,
 FABMASTER_EXTRACT_PINS,
 EXTRACT_PINS,
 EXTRACT_TRACES,
 EXTRACT_GRAPHICS,
 EXTRACT_BASIC_LAYERS,
 EXTRACT_NETS,
 EXTRACT_REFDES
 };

 std::deque<single_row> rows;

 bool has_pads;
 bool has_comps;
 bool has_graphic;
 bool has_nets;
 bool has_pins;


 struct FM_PAD
 {
 std::string name;
 bool fixed;
 bool via;
 PAD_SHAPE shape;
 std::string custom_name;
 bool top;
 bool bottom;
 bool paste;
 bool mask;
 bool drill;
 bool plated;
 bool is_octogon;
 int drill_size_x;
 int drill_size_y;
 int width;
 int height;
 int mask_width;
 int mask_height;
 int paste_width;
 int paste_height;
 int x_offset;
 int y_offset;
 int antipad_size;

 struct HASH
 {
 std::size_t operator()( const FM_PAD& aPad ) const
 {
 return std::hash<std::string>{}( aPad.name );
 }
 };
 };

 std::unordered_map<std::string, FM_PAD> pads;

 enum COMPCLASS
 {
 COMPCLASS_NONE,
 COMPCLASS_IO,
 COMPCLASS_IC,
 COMPCLASS_DISCRETE
 };

 enum SYMTYPE
 {
 SYMTYPE_NONE,
 SYMTYPE_PACKAGE,
 SYMTYPE_MECH,
 SYMTYPE_FORMAT,
 SYMTYPE_DRAFTING
 };

 // A!NET_NAME!REFDES!PIN_NUMBER!PIN_NAME!PIN_GROUND!PIN_POWER!
 struct NETNAME
 {
 std::string name; 
 std::string refdes; 
 std::string pin_num; 
 std::string pin_name; 
 bool pin_gnd; 
 bool pin_pwr; 

 struct LESS
 {
 bool operator()(const NETNAME& lhs, const NETNAME& rhs) const
 {
 if( lhs.refdes == rhs.refdes )
 return lhs.pin_num < rhs.pin_num;

 return lhs.refdes < rhs.refdes;
 }
 };
 };

 std::map<std::pair<std::string, std::string>, NETNAME> pin_nets;
 std::set<std::string> netnames;

 struct CLASS
 {
 std::string name; 
 std::string subclass; 
 };


 enum GRAPHIC_SHAPE
 {
 GR_SHAPE_LINE,
 GR_SHAPE_TEXT,
 GR_SHAPE_RECTANGLE,
 GR_SHAPE_ARC,
 GR_SHAPE_CIRCLE 
 };

 enum GRAPHIC_TYPE
 {
 GR_TYPE_NONE,
 GR_TYPE_CONNECT,
 GR_TYPE_NOTCONNECT,
 GR_TYPE_SHAPE,
 GR_TYPE_POLYGON,
 GR_TYPE_VOID
 };

 struct GRAPHIC_ITEM
 {
 int  start_x; 
 int start_y; 
 int width; 
 std::string layer; 
 std::string symbol; 
 std::string refdes; 
 int seq; 
 int subseq; 
 GRAPHIC_TYPE type; 
 GRAPHIC_SHAPE shape; 


 struct SEQ_CMP
 {
 bool operator()(const std::unique_ptr<GRAPHIC_ITEM>& lhs,
 const std::unique_ptr<GRAPHIC_ITEM>& rhs) const
 {
 if( lhs->refdes != rhs->refdes )
 return lhs->refdes < rhs->refdes;

 if( lhs->layer != rhs->layer )
 return lhs->layer < rhs->layer;

 return lhs->seq < rhs->seq;
 }
 };
 };

 struct GRAPHIC_LINE : public GRAPHIC_ITEM
 {
 int end_x; 
 int end_y; 
 };

 struct GRAPHIC_ARC : public GRAPHIC_ITEM
 {
 int end_x; 
 int end_y; 
 int center_x; 
 int center_y; 
 int radius; 
 bool clockwise; 

 SHAPE_ARC result; 
 };

 struct GRAPHIC_RECTANGLE : public GRAPHIC_ITEM
 {
 int end_x; 
 int end_y; 
 bool fill; 
 };

 struct GRAPHIC_TEXT : public GRAPHIC_ITEM
 {
 double rotation; 
 bool mirror; 
 EDA_TEXT_HJUSTIFY_T orient; 
 // GRAPHIC_DATA_6 is
 // SIZE FONT HEIGHT WIDTH ITAL LINESPACE THICKNESS
 int height; 
 int thickness; 
 bool ital; 

 std::string text; 
 };

 using graphic_element = std::set<std::unique_ptr<GRAPHIC_ITEM>, GRAPHIC_ITEM::SEQ_CMP>;

 struct FABMASTER_LAYER
 {
 int id; 
 std::string name; 
 bool positive; 
 std::string use; 
 bool conductive; 
 double er; 
 double conductivity; 
 std::string material; 
 bool shield; 
 double thermal_cond; 
 double thickness; 
 int layerid; 
 bool disable; 

 struct BY_ID
 {
 bool operator()(const FABMASTER_LAYER* lhs, const FABMASTER_LAYER* rhs) const
 {
 return lhs->id < rhs->id;
 }
 };
 };

 std::map<std::string, FABMASTER_LAYER> layers;

 struct FABMASTER_PAD_SHAPE
 {
 std::string name; 
 std::string padstack; 
 std::string refdes; 
 std::string pinnum; 
 std::map<int, graphic_element> elements;

 struct HASH
 {
 std::size_t operator()( const std::unique_ptr<FABMASTER_PAD_SHAPE>& aPad ) const
 {
 return std::hash<std::string>{}( aPad->name );
 }
 };
 };

 std::unordered_map<std::string, FABMASTER_PAD_SHAPE> pad_shapes;

 // * A!SYM_TYPE!SYM_NAME!REFDES!SYM_X!SYM_Y!SYM_ROTATE!SYM_MIRROR!NET_NAME!CLASS!SUBCLASS!RECORD_TAG!
 // * GRAPHIC_DATA_NAME!GRAPHIC_DATA_NUMBER!GRAPHIC_DATA_1!GRAPHIC_DATA_2!GRAPHIC_DATA_3!GRAPHIC_DATA_4!
 // * GRAPHIC_DATA_5!GRAPHIC_DATA_6!GRAPHIC_DATA_7!GRAPHIC_DATA_8!GRAPHIC_DATA_9!GRAPHIC_DATA_10!COMP_DEVICE_TYPE!
 // * COMP_PACKAGE!COMP_PART_NUMBER!COMP_VALUE!CLIP_DRAWING!
 struct SYMBOL
 {
 int sym_id; 
 int seq_id; 
 int subseq_id; 
 std::string name; 
 std::string refdes; 
 int x; 
 int y; 
 std::map<int, graphic_element> elements;

 struct HASH
 {
 std::size_t operator()( const FABMASTER::SYMBOL& aSym ) const
 {
 return std::hash<std::string>{}( aSym.name );
 }
 };
 };

 // Temporary data structure to pass graphic data from file for processing
 struct GRAPHIC_DATA
 {
 std::string graphic_dataname;
 std::string graphic_datanum;
 std::string graphic_data1;
 std::string graphic_data2;
 std::string graphic_data3;
 std::string graphic_data4;
 std::string graphic_data5;
 std::string graphic_data6;
 std::string graphic_data7;
 std::string graphic_data8;
 std::string graphic_data9;
 std::string graphic_data10;
 };

 std::unordered_map<std::string, SYMBOL> symbols;


 // * A!GRAPHIC_DATA_NAME!GRAPHIC_DATA_NUMBER!RECORD_TAG!GRAPHIC_DATA_1!GRAPHIC_DATA_2!GRAPHIC_DATA_3!
 // * GRAPHIC_DATA_4!GRAPHIC_DATA_5!GRAPHIC_DATA_6!GRAPHIC_DATA_7!GRAPHIC_DATA_8!GRAPHIC_DATA_9!
 // * SUBCLASS!SYM_NAME!REFDES!

 struct GEOM_GRAPHIC
 {
 std::string subclass; 
 std::string name; 
 std::string refdes; 
 int id; 

 std::unique_ptr<graphic_element> elements;

 struct BY_ID
 {
 bool operator()(const GEOM_GRAPHIC& lhs, const GEOM_GRAPHIC& rhs) const
 {
 return lhs.id < rhs.id;
 }
 };
 };

 std::vector<GEOM_GRAPHIC> board_graphics;
 std::map<std::string, std::map<int, GEOM_GRAPHIC>> comp_graphics;


 // A!VIA_X!VIA_Y!PAD_STACK_NAME!NET_NAME!TEST_POINT!
 struct FM_VIA
 {
 int x; 
 int y; 
 std::string padstack; 
 std::string net; 
 bool test_point; 
 bool mirror; 
 };

 std::vector<std::unique_ptr<FM_VIA>> vias;

 // A!CLASS!SUBCLASS!GRAPHIC_DATA_NAME!GRAPHIC_DATA_NUMBER!RECORD_TAG!GRAPHIC_DATA_1!
 // GRAPHIC_DATA_2!GRAPHIC_DATA_3!GRAPHIC_DATA_4!GRAPHIC_DATA_5!GRAPHIC_DATA_6!GRAPHIC_DATA_7!
 // GRAPHIC_DATA_8!GRAPHIC_DATA_9!NET_NAME!
 struct TRACE
 {
 std::string lclass; 
 std::string layer; 
 std::string netname; 
 int id; 

 graphic_element segment; 

 struct BY_ID
 {
 bool operator()(const std::unique_ptr<TRACE>& lhs, const std::unique_ptr<TRACE>& rhs) const
 {
 return lhs->id < rhs->id;
 }
 };
 };

 std::set<std::unique_ptr<TRACE>, TRACE::BY_ID> traces;

 std::set<std::unique_ptr<TRACE>, TRACE::BY_ID> zones;

 std::set<std::unique_ptr<TRACE>, TRACE::BY_ID> polygons;

 std::set<std::unique_ptr<TRACE>, TRACE::BY_ID> refdes;


 // A!REFDES!COMP_CLASS!COMP_PART_NUMBER!COMP_HEIGHT!COMP_DEVICE_LABEL!COMP_INSERTION_CODE!SYM_TYPE!
 // SYM_NAME!SYM_MIRROR!SYM_ROTATE!SYM_X!SYM_Y!COMP_VALUE!COMP_TOL!COMP_VOLTAGE!
 struct COMPONENT
 {
 std::string refdes; 
 COMPCLASS cclass; 
 std::string pn; 
 std::string height; 
 std::string dev_label; 
 std::string insert_code; 
 SYMTYPE type; 
 std::string name; 
 bool mirror; 
 double rotate; 
 int x; 
 int y; 
 std::string value; 
 std::string tol; 
 std::string voltage; 

 struct HASH
 {
 std::size_t operator()( const FABMASTER::COMPONENT& aCmp ) const
 {
 return std::hash<std::string>{}( aCmp.refdes );
 }
 };

 };

 std::map<std::string, std::vector<std::unique_ptr<COMPONENT>>> components;


 // A!SYM_NAME!SYM_MIRROR!PIN_NAME!PIN_NUMBER!PIN_X!PIN_Y!PAD_STACK_NAME!REFDES!PIN_ROTATION!TEST_POINT!

 struct PIN
 {
 std::string name; 
 bool mirror; 
 std::string pin_name; 
 std::string pin_number; 
 int pin_x; 
 int pin_y; 
 std::string padstack; 
 std::string refdes; 
 double rotation; 

 struct BY_NUM
 {
 bool operator()(const std::unique_ptr<PIN>& lhs,
 const std::unique_ptr<PIN>& rhs) const
 {
 return lhs->pin_number < rhs->pin_number;
 }
 };
 };

 std::map<std::string, std::set<std::unique_ptr<PIN>, PIN::BY_NUM>> pins;

 std::map<std::string, PCB_LAYER_ID> layer_map;

 section_type detectType( size_t aOffset );

 void checkpoint();

 int execute_recordbuffer( int filetype );
 int getColFromName( size_t aRow, const std::string& aStr );
 SYMTYPE parseSymType( const std::string& aSymType );
 COMPCLASS parseCompClass( const std::string& aCompClass );

 double processScaleFactor( size_t aRow );
 size_t processPadStacks( size_t aRow );
 size_t processCustomPads( size_t aRow );
 size_t processGeometry( size_t aRow );
 size_t processVias( size_t aRow );
 size_t processTraces( size_t aRow );
 size_t processFootprints( size_t aRow );
 size_t processNets( size_t aRow );
 size_t processLayers( size_t aRow );
 size_t processSimpleLayers( size_t aRow );
 size_t processPadStackLayers( size_t aRow );
 size_t processSymbols( size_t aRow );
 size_t processPins( size_t aRow );

 GRAPHIC_ITEM* processGraphic( const GRAPHIC_DATA& aData, double aScale );
 GRAPHIC_ARC* processArc( const GRAPHIC_DATA& aData, double aScale );
 GRAPHIC_LINE* processLine( const GRAPHIC_DATA& aData, double aScale );
 GRAPHIC_TEXT* processText( const GRAPHIC_DATA& aData, double aScale );
 GRAPHIC_RECTANGLE* processRectangle( const GRAPHIC_DATA& aData, double aScale );

 PCB_LAYER_ID getLayer( const std::string& aLayerName );
 bool assignLayers();

 double readDouble( const std::string& aStr ) const;
 int readInt( const std::string& aStr ) const;

 bool orderZones( BOARD* aBoard );

 bool loadZones( BOARD* aBoard );
 bool loadOutline( BOARD* aBoard, const std::unique_ptr<TRACE>& aLine);
 bool loadNets( BOARD* aBoard );
 bool loadLayers( BOARD* aBoard );
 bool loadGraphics( BOARD* aBoard );
 bool loadVias( BOARD* aBoard );
 bool loadEtch( BOARD* aBoard, const std::unique_ptr<TRACE>& aLine);
 bool loadZone( BOARD* aBoard, const std::unique_ptr<FABMASTER::TRACE>& aLine);
 bool loadPolygon( BOARD* aBoard, const std::unique_ptr<FABMASTER::TRACE>& aLine);
 bool loadFootprints( BOARD* aBoard );

 SHAPE_POLY_SET loadShapePolySet( const graphic_element& aLine);

 PROGRESS_REPORTER* m_progressReporter; 
 unsigned m_doneCount;
 unsigned m_lastProgressCount;
 unsigned m_totalCount; 
};




#endif /* PCBNEW_IMPORTERS_IMPORT_FABMASTER_H_ */