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 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 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 <https://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 <reporter.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,
                                         REPORTER*             aReporter = nullptr )
            : CADSTAR_PCB_ARCHIVE_PARSER( aFilename )
    {
        m_reporter                = aReporter;
        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>> LoadFpLibrary();

    std::vector<FOOTPRINT*> GetLoadedLibraryFootpints() const;
 
private:
    void reportError( const wxString& aMsg ) const
    {
        if( m_reporter )
            m_reporter->Report( aMsg, RPT_SEVERITY_ERROR );
    }
 
    void reportWarning( const wxString& aMsg ) const
    {
        if( m_reporter )
            m_reporter->Report( aMsg, RPT_SEVERITY_WARNING );
    }
 
    void reportInfo( const wxString& aMsg ) const
    {
        if( m_reporter )
            m_reporter->Report( aMsg, RPT_SEVERITY_INFO );
    }
 
    REPORTER*                        m_reporter;            
    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 aDefaultRouteWidth,
                        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, LINE_STYLE aLineStyle, 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, LINE_STYLE aLineStyle,
                                      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 );
    LINE_STYLE getLineStyle( 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 );

    VECTOR2I applyPadShape( PAD* aPad, PCB_LAYER_ID aPadLayer, const CADSTAR_PAD_SHAPE& aShape );
 
    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_