cadstar_pcb_archive_loader.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2020-2021 Roberto Fernandez Bautista <[email protected]>
 * Copyright (C) 2020-2022 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 3 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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef CADSTAR_PCB_ARCHIVE_LOADER_H_
#define CADSTAR_PCB_ARCHIVE_LOADER_H_
 
#include <cadstar_pcb_archive_parser.h>
#include <pcb_io_cadstar_archive.h>
#include <board.h>
#include <footprint.h>
 
#include <memory>
#include <set>
 
class BOARD;
class BOARD_STACKUP_ITEM;
class PCB_DIMENSION_BASE;
 
class CADSTAR_PCB_ARCHIVE_LOADER : public CADSTAR_PCB_ARCHIVE_PARSER
{
public:
 explicit CADSTAR_PCB_ARCHIVE_LOADER( wxString aFilename,
 LAYER_MAPPING_HANDLER aLayerMappingHandler,
 bool aLogLayerWarnings,
 PROGRESS_REPORTER* aProgressReporter )
 : CADSTAR_PCB_ARCHIVE_PARSER( aFilename )
 {
 m_layerMappingHandler = aLayerMappingHandler;
 m_logLayerWarnings = aLogLayerWarnings;
 m_board = nullptr;
 m_project = nullptr;
 m_designCenter.x = 0;
 m_designCenter.y = 0;
 m_doneCopperWarning = false;
 m_doneSpacingClassWarning = false;
 m_doneNetClassWarning = false;
 m_doneTearDropWarning = false;
 m_numNets = 0;
 m_numCopperLayers = 0 ;
 m_progressReporter = aProgressReporter;
 }
 
 
 ~CADSTAR_PCB_ARCHIVE_LOADER()
 {
 for( std::pair<SYMDEF_ID, FOOTPRINT*> libItem : m_libraryMap )
 {
 FOOTPRINT* footprint = libItem.second;
 
 if( footprint )
 delete footprint;
 }
 }
 
 void Load( BOARD* aBoard, PROJECT* aProject );
 
 
 std::vector<std::unique_ptr<FOOTPRINT>> LoadLibrary();
 
 std::vector<FOOTPRINT*> GetLoadedLibraryFootpints() const;
 
private:
 LAYER_MAPPING_HANDLER m_layerMappingHandler; 
 bool m_logLayerWarnings; 
 BOARD* m_board;
 PROJECT* m_project;
 std::map<LAYER_ID, PCB_LAYER_ID> m_layermap; 
 std::map<SYMDEF_ID, FOOTPRINT*> m_libraryMap; 
 std::map<GROUP_ID, PCB_GROUP*> m_groupMap; 
 std::map<COMPONENT_ID, FOOTPRINT*> m_componentMap; 
 
 using ASSOCIATED_COPPER_PADS = std::map<PAD_ID, std::vector<PAD_ID>>;
 
 std::map<SYMDEF_ID, ASSOCIATED_COPPER_PADS> m_librarycopperpads;
 
 std::map<NET_ID, NETINFO_ITEM*> m_netMap; 
 std::map<std::tuple<ROUTECODE_ID, NETCLASS_ID, SPACING_CLASS_ID>, std::shared_ptr<NETCLASS>>
 m_netClassMap; 
 std::map<TEMPLATE_ID, ZONE*> m_zonesMap; 
 std::vector<LAYER_ID> m_powerPlaneLayers; 
 VECTOR2I m_designCenter; 
 std::set<HATCHCODE_ID> m_hatchcodesTested; 
 std::set<PADCODE_ID> m_padcodesTested; 
 bool m_doneCopperWarning; 
 bool m_doneSpacingClassWarning; 
 bool m_doneNetClassWarning; 
 bool m_doneTearDropWarning;
 int m_numNets; 
 int m_numCopperLayers; 
 
 
 // Functions for loading individual elements:
 void loadBoardStackup();
 void remapUnsureLayers(); 
 void loadDesignRules();
 void loadComponentLibrary();
 void loadGroups();
 void loadBoards();
 void loadFigures();
 void loadTexts();
 void loadDimensions();
 void loadAreas();
 void loadComponents();
 void loadDocumentationSymbols();
 void loadTemplates();
 void loadCoppers();
 void loadNets();
 void loadTextVariables();
 
 // Helper functions for element loading:
 void logBoardStackupWarning( const wxString& aCadstarLayerName,
 const PCB_LAYER_ID& aKiCadLayer );
 void logBoardStackupMessage( const wxString& aCadstarLayerName,
 const PCB_LAYER_ID& aKiCadLayer );
 void initStackupItem( const LAYER& aCadstarLayer, BOARD_STACKUP_ITEM* aKiCadItem,
 int aDielectricSublayer );
 void loadLibraryFigures( const SYMDEF_PCB& aComponent, FOOTPRINT* aFootprint );
 void loadLibraryCoppers( const SYMDEF_PCB& aComponent, FOOTPRINT* aFootprint );
 void loadLibraryAreas( const SYMDEF_PCB& aComponent, FOOTPRINT* aFootprint );
 void loadLibraryPads( const SYMDEF_PCB& aComponent, FOOTPRINT* aFootprint );
 void loadComponentAttributes( const COMPONENT& aComponent, FOOTPRINT* aFootprint );
 void loadNetTracks( const NET_ID& aCadstarNetID, const NET_PCB::ROUTE& aCadstarRoute,
 long aStartWidth = std::numeric_limits<long>::max(),
 long aEndWidth = std::numeric_limits<long>::max() );
 
 int loadNetVia( const NET_ID& aCadstarNetID, const NET_PCB::VIA& aCadstarVia );
 void checkAndLogHatchCode( const HATCHCODE_ID& aCadstarHatchcodeID );
 void applyDimensionSettings( const DIMENSION& aCadstarDim, PCB_DIMENSION_BASE* aKiCadDim );
 
 
 bool calculateZonePriorities( PCB_LAYER_ID& aLayer );
 
 //Helper functions for drawing /loading objects onto screen:
 
 void drawCadstarText( const TEXT& aCadstarText, BOARD_ITEM_CONTAINER* aContainer,
 const GROUP_ID& aCadstarGroupID = wxEmptyString,
 const LAYER_ID& aCadstarLayerOverride = wxEmptyString,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0, double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 void drawCadstarShape( const SHAPE& aCadstarShape, const PCB_LAYER_ID& aKiCadLayer,
 int aLineThickness, const wxString& aShapeName,
 BOARD_ITEM_CONTAINER* aContainer,
 const GROUP_ID& aCadstarGroupID = wxEmptyString,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0, double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 void drawCadstarCutoutsAsShapes( const std::vector<CUTOUT>& aCutouts,
 const PCB_LAYER_ID& aKiCadLayer, int aLineThickness,
 BOARD_ITEM_CONTAINER* aContainer,
 const GROUP_ID& aCadstarGroupID = wxEmptyString,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0,
 double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 void drawCadstarVerticesAsShapes( const std::vector<VERTEX>& aCadstarVertices,
 const PCB_LAYER_ID& aKiCadLayer, int aLineThickness,
 BOARD_ITEM_CONTAINER* aContainer,
 const GROUP_ID& aCadstarGroupID = wxEmptyString,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0, double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 std::vector<PCB_SHAPE*> getShapesFromVertices( const std::vector<VERTEX>& aCadstarVertices,
 BOARD_ITEM_CONTAINER* aContainer = nullptr,
 const GROUP_ID& aCadstarGroupID = wxEmptyString,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0,
 double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 PCB_SHAPE* getShapeFromVertex( const POINT& aCadstarStartPoint,
 const VERTEX& aCadstarVertex,
 BOARD_ITEM_CONTAINER* aContainer = nullptr,
 const GROUP_ID& aCadstarGroupID = wxEmptyString,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0, double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 ZONE* getZoneFromCadstarShape( const SHAPE& aCadstarShape, const int& aLineThickness,
 BOARD_ITEM_CONTAINER* aParentContainer );
 
 SHAPE_POLY_SET getPolySetFromCadstarShape( const SHAPE& aCadstarShape, int aLineThickness = -1,
 BOARD_ITEM_CONTAINER* aContainer = nullptr,
 const VECTOR2I& aMoveVector = { 0, 0 },
 double aRotationAngle = 0.0,
 double aScalingFactor = 1.0,
 const VECTOR2I& aTransformCentre = { 0, 0 },
 bool aMirrorInvert = false );
 
 SHAPE_LINE_CHAIN getLineChainFromShapes( const std::vector<PCB_SHAPE*>& aShapes );
 
 std::vector<PCB_TRACK*> makeTracksFromShapes( const std::vector<PCB_SHAPE*>& aShapes,
 BOARD_ITEM_CONTAINER* aParentContainer,
 NETINFO_ITEM* aNet = nullptr,
 PCB_LAYER_ID aLayerOverride = UNDEFINED_LAYER,
 int aWidthOverride = -1 );
 
 void addAttribute( const ATTRIBUTE_LOCATION& aCadstarAttrLoc,
 const ATTRIBUTE_ID& aCadstarAttributeID, FOOTPRINT* aFootprint,
 const wxString& aAttributeValue );
 
 void applyRouteOffset( VECTOR2I* aPointToOffset, const VECTOR2I& aRefPoint,
 const long& aOffsetAmount );
 
 void applyTextCode( EDA_TEXT* aKiCadText, const TEXTCODE_ID& aCadstarTextCodeID );
 
 //Helper Functions for obtaining CADSTAR elements in the parsed structures
 int getLineThickness( const LINECODE_ID& aCadstarLineCodeID );
 COPPERCODE getCopperCode( const COPPERCODE_ID& aCadstaCopperCodeID );
 HATCHCODE getHatchCode( const HATCHCODE_ID& aCadstarHatchcodeID );
 LAYERPAIR getLayerPair( const LAYERPAIR_ID& aCadstarLayerPairID );
 PADCODE getPadCode( const PADCODE_ID& aCadstarPadCodeID );
 PART getPart( const PART_ID& aCadstarPartID );
 ROUTECODE getRouteCode( const ROUTECODE_ID& aCadstarRouteCodeID );
 TEXTCODE getTextCode( const TEXTCODE_ID& aCadstarTextCodeID );
 VIACODE getViaCode( const VIACODE_ID& aCadstarViaCodeID );
 wxString getAttributeName( const ATTRIBUTE_ID& aCadstarAttributeID );
 wxString getAttributeValue( const ATTRIBUTE_ID& aCadstarAttributeID,
 const std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE>& aCadstarAttributeMap );
 LAYER_TYPE getLayerType( const LAYER_ID aCadstarLayerID );
 
 // Helper Functions for obtaining individual elements as KiCad elements:
 EDA_ANGLE getHatchCodeAngle( const HATCHCODE_ID& aCadstarHatchcodeID );
 PAD* getKiCadPad( const COMPONENT_PAD& aCadstarPad, FOOTPRINT* aParent );
 PAD*& getPadReference( FOOTPRINT* aFootprint, const PAD_ID aCadstarPadID );
 FOOTPRINT* getFootprintFromCadstarID( const COMPONENT_ID& aCadstarComponentID );
 int getKiCadHatchCodeThickness( const HATCHCODE_ID& aCadstarHatchcodeID );
 int getKiCadHatchCodeGap( const HATCHCODE_ID& aCadstarHatchcodeID );
 PCB_GROUP* getKiCadGroup( const GROUP_ID& aCadstarGroupID );
 
 VECTOR2I getKiCadPoint( const VECTOR2I& aCadstarPoint );
 
 int getKiCadLength( long long aCadstarLength )
 {
 return aCadstarLength * KiCadUnitMultiplier;
 }
 
 double getAngleTenthDegree( const long long& aCadstarAngle )
 {
 // CADSTAR v6 (which outputted Format Version 8) and earlier versions used 1/10 degree
 // as the unit for angles/orientations. It is assumed that CADSTAR version 7 (i.e. Format
 // Version 9 and later) is the version that introduced 1/1000 degree for angles.
 if( Header.Format.Version > 8 )
 {
 return (double) aCadstarAngle / 100.0;
 }
 else
 {
 return (double) aCadstarAngle;
 }
 }
 
 EDA_ANGLE getAngle( const long long& aCadstarAngle )
 {
 // CADSTAR v6 (which outputted Format Version 8) and earlier versions used 1/10 degree
 // as the unit for angles/orientations. It is assumed that CADSTAR version 7 (i.e. Format
 // Version 9 and later) is the version that introduced 1/1000 degree for angles.
 if( Header.Format.Version > 8 )
 {
 return EDA_ANGLE( aCadstarAngle / 1000.0, DEGREES_T );
 }
 else
 {
 return EDA_ANGLE( (int) aCadstarAngle, TENTHS_OF_A_DEGREE_T );
 }
 }
 
 double getAngleDegrees( const long long& aCadstarAngle )
 {
 return getAngleTenthDegree( aCadstarAngle ) / 10.0;
 }
 
 NETINFO_ITEM* getKiCadNet( const NET_ID& aCadstarNetID );
 
 PCB_LAYER_ID getKiCadCopperLayerID( unsigned int aLayerNum, bool aDetectMaxLayer = true );
 
 bool isLayerSet( const LAYER_ID& aCadstarLayerID );
 
 PCB_LAYER_ID getKiCadLayer( const LAYER_ID& aCadstarLayerID );
 
 LSET getKiCadLayerSet( const LAYER_ID& aCadstarLayerID );
 
 
 bool isFootprint( BOARD_ITEM_CONTAINER* aContainer )
 {
 return aContainer && aContainer->Type() == PCB_FOOTPRINT_T;
 }
 
 
 void addToGroup( const GROUP_ID& aCadstarGroupID, BOARD_ITEM* aKiCadItem );
 
 GROUP_ID createUniqueGroupID( const wxString& aName );
};
 
 
#endif // CADSTAR_PCB_ARCHIVE_LOADER_H_