orcad_converter.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * Based on the dsn2kicad reference implementation and on OrCAD file format
 * documentation from the OpenOrCadParser project (MIT licensed).
 *
 * 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 ORCAD_CONVERTER_H_
#define ORCAD_CONVERTER_H_
 
#include <cstdint>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include <wx/string.h>
 
#include <geometry/seg.h>
#include <math/box2.h>
#include <math/vector2d.h>
#include <gal/color4d.h>
#include <eda_shape.h>
#include <kiid.h>
 
#include <sch_io/orcad/orcad_records.h>
 
class LIB_SYMBOL;
class SCH_LINE;
class EDA_TEXT;
class PROGRESS_REPORTER;
class REPORTER;
class SCHEMATIC;
class SCH_ITEM;
class SCH_LABEL_BASE;
class SCH_LABEL;
class SCH_SCREEN;
class SCH_SHEET;
class SCH_SHEET_PIN;
class SCH_SHEET_PATH;
class SCH_SYMBOL;
class SCH_TEXT;
class wxMemoryBuffer;
 

inline constexpr int ORCAD_IU_PER_DBU = 2540;
 
KIGFX::COLOR4D OrcadColor( int aColorIndex );
int            OrcadLineWidthIu( int aWidth );
int            OrcadPageGraphicLineWidthIu( int aWidth );
LINE_STYLE     OrcadLineStyle( int aStyle );
std::pair<double, double> OrcadDashRatios( int aFormatVersionMajor );
FILL_T         OrcadFillType( int aFillStyle, int aHatchStyle );
int            OrcadHatchPitchIu( uint32_t aModifyTimestamp );
int            OrcadHatchLineWidthIu( uint32_t aModifyTimestamp );
std::vector<SEG> OrcadHatchLines( const EDA_SHAPE& aShape, int aHatchStyle, int aPitch );
int            OrcadTextBaselineOffset( int aTextSize );
int            OrcadDisplayType( const ORCAD_DISPLAY_PROP& aProp );
bool           OrcadDisplayPropVisible( const ORCAD_DISPLAY_PROP& aProp );
bool           OrcadDisplayPropShowsName( const ORCAD_DISPLAY_PROP& aProp );
bool           OrcadDisplayPropShowsValue( const ORCAD_DISPLAY_PROP& aProp );
int            OrcadDisplayFontId( const ORCAD_DISPLAY_PROP& aProp );
int            OrcadPageOrder( wxString& aName );
VECTOR2I       OrcadStretchedImageSize( int aWidth, int aHeight, int aBoxWidth, int aBoxHeight );
wxString       OrcadPinNameMarkup( const wxString& aName );
 
inline VECTOR2I OrcadDbuToIu( int aX, int aY )
{
    return VECTOR2I( aX * ORCAD_IU_PER_DBU, aY * ORCAD_IU_PER_DBU );
}
 

struct ORCAD_ORIENT_ENTRY
{
    int    angle;  
    char   mirror; 
    int8_t txSel;  
    int8_t tySel;  
    int8_t a;
    int8_t b;
    int8_t c;
    int8_t d;
};
 

inline constexpr ORCAD_ORIENT_ENTRY ORCAD_ORIENT_TABLE[8] = {
    { 0, 0, 0, 0, 1, 0, 0, 1 },    { 90, 0, 0, 1, 0, 1, -1, 0 },    { 180, 0, 1, 2, -1, 0, 0, -1 },
    { 270, 0, 2, 0, 0, -1, 1, 0 }, { 0, 'y', 1, 0, -1, 0, 0, 1 },   { 90, 'x', 0, 0, 0, 1, 1, 0 },
    { 0, 'x', 0, 2, 1, 0, 0, -1 }, { 270, 'x', 2, 1, 0, -1, -1, 0 }
};
 

inline int OrcadOrientOf( int aRotation, bool aMirror )
{
    return ( aRotation & 3 ) | ( aMirror ? 0x4 : 0 );
}
 
 
inline int OrcadOrientDim( int aSelector, int aWidth, int aHeight )
{
    return aSelector == 1 ? aWidth : aSelector == 2 ? aHeight : 0;
}
 

inline VECTOR2I OrcadOrientOffset( int aOrient, int aWidth, int aHeight )
{
    const ORCAD_ORIENT_ENTRY& e = ORCAD_ORIENT_TABLE[aOrient & 7];
    return VECTOR2I( OrcadOrientDim( e.txSel, aWidth, aHeight ), OrcadOrientDim( e.tySel, aWidth, aHeight ) );
}
 

inline VECTOR2I OrcadTransformPoint( int aOrient, int aWidth, int aHeight, int aBaseX, int aBaseY, int aPx, int aPy )
{
    const ORCAD_ORIENT_ENTRY& e = ORCAD_ORIENT_TABLE[aOrient & 7];
    VECTOR2I                  t = OrcadOrientOffset( aOrient, aWidth, aHeight );
 
    return VECTOR2I( aBaseX + t.x + e.a * aPx + e.b * aPy, aBaseY + t.y + e.c * aPx + e.d * aPy );
}
 
 
class ORCAD_CONVERTER
{
public:
    ORCAD_CONVERTER( ORCAD_DESIGN& aDesign, SCHEMATIC* aSchematic, REPORTER* aReporter,
                     PROGRESS_REPORTER* aProgressReporter = nullptr );

    ~ORCAD_CONVERTER();

    SCH_SHEET* Convert( SCH_SHEET* aRootSheet );

    std::vector<LIB_SYMBOL*> BuildSymbolLibrary();

    static constexpr const char* LIB_NICK = "orcad_import";
 
private:

    struct UNIT_INFO
    {
        std::string              letter; 
        const ORCAD_SYMBOL_DEF*  symbol = nullptr;
        std::vector<std::string> pinNumbers; 
        std::vector<bool>        pinNumberVisible; 
        std::vector<bool>        pinIgnore;  
        std::vector<int>         pinOffsets; 
        std::vector<bool>        explicitPinNets; 
 
        bool operator==( const UNIT_INFO& ) const = default;
    };

    struct LIB_ENTRY
    {
        std::string                 name;  
        std::vector<UNIT_INFO>      units; 
        bool                        isPower = false;
        std::string                 powerNet; 
        std::string                 refPrefix = "U";
        std::string                 footprint;
        std::unique_ptr<LIB_SYMBOL> kicadSymbol; 
    };

    struct OFFPAGE_NET
    {
        int         index = 0;
        std::string net;
        int         x = 0; 
        int         y = 0;
    };

    using PKG_KEY = std::tuple<std::string, std::string, int, std::string>;
 
    struct PLACED_PACKAGE_UNIT
    {
        SCH_SYMBOL*    symbol;
        const void*    scope;
        wxString       reference;
        const PKG_KEY* sourceUnit;
        UNIT_INFO      unit;
    };


    static constexpr int PIN_LEN_DBU = 10;

    static constexpr int MARGIN_L_DBU = 60;
    static constexpr int MARGIN_T_DBU = 60;
    static constexpr int MARGIN_R_DBU = 60;
    static constexpr int MARGIN_B_DBU = 100;


    void warn( const wxString& aMsg );

    void note( const wxString& aMsg );

    void prepareGlobalNetNames();

    std::string canonicalGlobalNetName( const std::string& aName ) const;
    std::string effectiveInterfaceNetName( const std::string& aName ) const;
    std::string occurrenceElectricalNetName( uint32_t aOccurrenceId, const std::string& aName ) const;
    bool        isPowerNetName( const std::string& aName ) const;
    bool        isOffpageNetName( const std::string& aName ) const;
 
 
    void prepareSymbols();

    ORCAD_SYMBOL_DEF synthesizeSymbol( const std::string&                               aPkgName,
                                       const std::vector<const ORCAD_PLACED_INSTANCE*>& aInstances ) const;

    std::string unitLetter( const ORCAD_PLACED_INSTANCE& aInst ) const;

    std::pair<const ORCAD_SYMBOL_DEF*, int> pickVariant( const ORCAD_PLACED_INSTANCE& aInst ) const;

    std::pair<std::string, int> libForInstance( const ORCAD_PLACED_INSTANCE& aInst,
                                              const PKG_KEY** aSourceUnit = nullptr );
    void finalizeNativePowerPackages();

    std::optional<uint32_t> occurrenceNetIdFor( const std::string* aName ) const;

    void finishConversion();

    std::string powerLibFor( const std::string& aSymbolName, const std::string& aNetName );
 
 
    LIB_SYMBOL* kicadSymbolFor( const std::string& aLibName );
 
 
    void addSymbolPrimitive( LIB_SYMBOL* aSymbol, const ORCAD_PRIMITIVE& aPrim, int aUnit, int aColor,
                             int aOffsetX = 0, int aOffsetY = 0 );

    void addSymbolArc( LIB_SYMBOL* aSymbol, const ORCAD_PRIMITIVE& aPrim, int aUnit, int aColor, int aOffsetX = 0,
                       int aOffsetY = 0 );
 
 
    void addSymbolPin( LIB_SYMBOL* aSymbol, const ORCAD_SYMBOL_PIN& aPin, const wxString& aNumber, int aUnit,
                       bool aPower, const std::string& aNameOverride, bool aNameVisible, bool aShowPinNumbers,
                       bool aNumberVisible, const BOX2I* aBodyBox, bool aHidden = false,
                       bool aExplicitNet = false );
 
 
    void placeInstance( ORCAD_RAW_PAGE& aPage, const ORCAD_PLACED_INSTANCE& aInst, SCH_SCREEN* aScreen,
                        const SCH_SHEET_PATH& aSheetPath );

    wxString resolveReference( const ORCAD_PLACED_INSTANCE& aInst ) const;
 
 
    void placePowerSymbol( ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst, const std::string& aNet,
                           SCH_SCREEN* aScreen, const SCH_SHEET_PATH& aSheetPath );
 
 
    void placeSymbolFields( SCH_SYMBOL* aSymbol, const ORCAD_PLACED_INSTANCE& aInst, const ORCAD_SYMBOL_DEF& aDef,
                            int aOrient, const std::string& aValue, const std::string& aFootprint );

    const ORCAD_PACKAGE* packageFor( const ORCAD_PLACED_INSTANCE& aInst ) const;

    std::map<std::string, std::string> effectiveProps( const ORCAD_PLACED_INSTANCE& aInst,
                                                       const ORCAD_SYMBOL_DEF&      aDef ) const;
 
 
    static int toKicadOrientation( int aOrient );
 
    void computeFontBaseline();
 
    int displayFontId( const ORCAD_DISPLAY_PROP& aProp ) const;
    bool displayUsesTemplateFont( const ORCAD_DISPLAY_PROP& aProp ) const;
    int wireAliasFontId( const ORCAD_ALIAS& aAlias ) const;
    int textBaselineOffset( int aTextSize, int aFontIdx, bool aTemplateFont = true ) const;

    int resolveFontIndex( int aFontIdx ) const;

    int fontHeightDbu( int aFontIdx, bool aTemplateFont = true ) const;
 
 
    int textSizeIU( int aFontIdx, bool aTemplateFont = true ) const;

    VECTOR2I textSize( int aFontIdx, bool aTemplateFont = true ) const;
 
    void applyFont( EDA_TEXT* aText, int aFontIdx, bool aTemplateFont = true ) const;
    void applyMultilineSpacing( SCH_TEXT* aText, int aFontIdx, bool aTemplateFont = true ) const;

    static std::string SymbolId( const std::string& aName );
 
 
    void convertPage( ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen, const SCH_SHEET_PATH& aSheetPath,
                      bool aContainerPage = false, bool aSharedFolderPage = false );
    void placeHierarchicalBlockFields( SCH_SHEET* aSheet, const ORCAD_DRAWN_INSTANCE& aBlock,
                                       const std::string& aChildFolder );
    void placeHierarchicalBlockPinFill( SCH_SCREEN* aScreen, SCH_SHEET_PIN* aPin );
    void appendNetIntent( SCH_SCREEN* aScreen, SCH_LABEL* aLabel, bool aExplicitName, uint32_t aNetId = 0 );
    void minimizeNetLabels();
    void finalizeNetNames();
    void recordNetNameMap();
    void convertUnreferencedPages();
 
    KIID deterministicUuid( const std::string& aRole, size_t aOrdinal ) const;
    void appendPageItem( SCH_SCREEN* aScreen, SCH_ITEM* aItem );
    void assignPageItemUuids( size_t aPageOrdinal );
 
 
    static wxString MakePageFileName( int aPageIndex, const std::string& aPageName );

    void applyPageSettings( ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );
    void placePageFrame( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    static BOX2I pageExtentDbu( const ORCAD_RAW_PAGE& aPage );

    static void offsetPage( ORCAD_RAW_PAGE& aPage, int aDx, int aDy );
 
 
    void applyTitleBlock( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    void buildNetLookup( const ORCAD_RAW_PAGE& aPage );

    std::string netAt( const ORCAD_RAW_PAGE& aPage, int aX, int aY ) const;
 
 
    std::string powerNet( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;

    VECTOR2I graphicPinPos( const ORCAD_GRAPHIC_INST& aInst ) const;

    VECTOR2I namedGraphicPinPos( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;

    VECTOR2I powerPinPos( const ORCAD_RAW_PAGE& aPage, const ORCAD_GRAPHIC_INST& aInst ) const;
 
    std::vector<int> placedStackedPinOffsets( const ORCAD_PLACED_INSTANCE& aInstance ) const;
    VECTOR2I placedPinElectricalPosition( const ORCAD_PLACED_INSTANCE& aInstance, size_t aPinIndex ) const;
    bool hasImplicitPowerPinName( const ORCAD_PLACED_INSTANCE& aInstance, size_t aPinIndex,
                                  const std::string& aNetName ) const;

    std::vector<OFFPAGE_NET> offpageNets( const ORCAD_RAW_PAGE& aPage ) const;

    std::vector<VECTOR2I> computeJunctions( const ORCAD_RAW_PAGE& aPage ) const;

    void placeJunctions( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );
 
 
    void placeWires( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen, bool aHierarchical,
                     bool aNestedHierarchy, bool aSharedFolderPage );

    void placeBusEntries( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    void placeGraphicDisplayText( const ORCAD_GRAPHIC_INST& aGraphic, const ORCAD_DISPLAY_PROP& aDisplay,
                                  const std::string& aText, SCH_SCREEN* aScreen );

    void placeOffpageConnectors( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen,
                                 const SCH_SHEET_PATH& aSheetPath, bool aHierarchical );
 
 
    void placePorts( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen, bool aHierarchical );
 
 
    void placeGraphics( const ORCAD_RAW_PAGE& aPage, SCH_SCREEN* aScreen );

    void placeBitmap( const ORCAD_PRIMITIVE& aPrim, SCH_SCREEN* aScreen, int aOrient = 0,
                      bool* aUsedEmbeddedEmf = nullptr );
 
    void placeDefinitionImages( const ORCAD_SYMBOL_DEF& aDefinition, int aBaseX, int aBaseY, int aOrient,
                                SCH_SCREEN* aScreen );
 
    void placeDefinitionVectors( const ORCAD_SYMBOL_DEF& aDefinition, int aBaseX, int aBaseY, int aOrient,
                                 SCH_SCREEN* aScreen, double aTextScaleX = 1.0, double aTextScaleY = 1.0,
                                 bool aUseGenericTextBaseline = false,
                                 const std::string& aTextFaceOverride = {} );

    static VECTOR2I snapToWire( int aX, int aY, const ORCAD_WIRE& aWire );

    static bool onSegment( int aX, int aY, const ORCAD_WIRE& aWire );
 
 
    static wxString SanitizeFileName( const std::string& aName );
 
private:
    ORCAD_DESIGN&      m_design;
    SCHEMATIC*         m_schematic;
    REPORTER*          m_reporter;
    PROGRESS_REPORTER* m_progressReporter;
    SCH_SHEET*         m_rootSheet;
 
    std::map<std::string, LIB_ENTRY>               m_libSymbols; 
    std::map<PKG_KEY, std::pair<std::string, int>> m_pkgToLib;
    std::map<PKG_KEY, std::pair<std::string, int>> m_preparedPkgToLib;
    std::map<std::string, std::vector<UNIT_INFO>> m_preparedLibUnits;
    std::vector<PLACED_PACKAGE_UNIT>             m_placedPackageUnits;
    std::set<std::string>                       m_nativePowerFamilies;
    std::map<std::string, std::string>             m_globalNetNames;
    std::map<std::string, std::string>             m_globalNetAliases;
    std::set<std::string>                          m_powerNetNames;
    std::set<std::string>                          m_offpageNetNames;
    std::set<std::string>                          m_connectedBlockInterfaceNames;
    std::map<std::string, size_t>                  m_occurrenceNetNameScopeCounts;
    std::map<std::string, size_t>                  m_occurrenceNetNameMinDepth;
    int                                            m_powerCount;      
    int                                            m_fontBaselineDbu; 
    size_t                                         m_pageOrdinal = 0;
    size_t                                         m_screenOrdinal = 1;
    SCH_SCREEN*                                    m_pageItemScreen = nullptr;
    std::vector<SCH_ITEM*>                         m_pageItems;

    const std::map<uint32_t, std::string>*                    m_currentOccRefs = nullptr;
    const std::map<uint32_t, std::string>*                    m_currentOccUnitRefs = nullptr;
    const std::map<uint32_t, std::map<std::string, std::string>>* m_currentOccProps = nullptr;
    const std::map<uint32_t, std::string>*                    m_currentOccNetNames = nullptr;
    std::string                                               m_currentFlatNetSuffix;
    bool                                                      m_scopeNamedFlatNets = false;
    bool                                                      m_scopeGeneratedFlatNets = false;
    std::map<std::string, std::string>                         m_currentUnconnectedInterfaceNetNames;
    std::map<std::string, std::string>                         m_currentInterfaceNetAliases;
    std::map<std::string, std::string>                         m_currentOccurrenceNetAliases;
    std::set<std::string>                                      m_currentConnectorInterfaceNetAliases;
    std::set<const ORCAD_PIN_INST*>                            m_currentImplicitPowerPins;
    std::map<std::string, std::map<std::string, std::string>> m_hierBusNamesByScreen;
 
    struct NET_LABEL_INTENT
    {
        SCH_SCREEN* screen;
        SCH_LABEL_BASE* label;
        bool explicitName;
    };
 
    struct INTERFACE_LABEL_SOURCE
    {
        SCH_SCREEN* screen;
        SCH_LABEL_BASE* label;
        std::vector<SCH_LINE*> wires;
    };
 
    void rememberInterfaceLabelSource( SCH_SCREEN* aScreen, SCH_LABEL_BASE* aLabel,
                                       const std::vector<SEG>& aSourceWires );
 
    std::vector<INTERFACE_LABEL_SOURCE> m_interfaceLabelSources;
    std::vector<NET_LABEL_INTENT> m_netLabelIntents;
    std::map<SCH_LABEL_BASE*, std::pair<SCH_SCREEN*, uint32_t>> m_labelSourceNets;
    std::map<SCH_SCREEN*, const ORCAD_RAW_PAGE*> m_sourcePages;
    std::map<std::pair<SCH_SCREEN*, uint32_t>, std::vector<SCH_ITEM*>> m_sourceNetItems;
    std::map<std::pair<SCH_SCREEN*, uint32_t>, std::set<std::string>> m_sourceNetNames;
    std::map<std::pair<SCH_SCREEN*, uint32_t>, std::string> m_sourceGeneratedNetNames;
    struct SOURCE_PIN_IDENTITY
    {
        wxString number;
        VECTOR2I position;
        std::optional<KIID> libraryPin;
        bool ignored = false;
    };
 
    std::map<SCH_SYMBOL*, std::vector<SOURCE_PIN_IDENTITY>> m_sourcePinIdentities;
    std::map<SCH_SYMBOL*, const ORCAD_PLACED_INSTANCE*> m_sourceInstances;
    std::map<SCH_SCREEN*, std::vector<wxString>> m_sourceOccurrences;
    std::map<std::tuple<SCH_SCREEN*, const ORCAD_PLACED_INSTANCE*, size_t>, std::pair<uint32_t, std::string>> m_wirelessNetNames;

    std::set<wxString> m_usedSheetNames;

    std::map<std::pair<int, int>, std::vector<const ORCAD_WIRE*>> m_wireEndpoints;
};
 
#endif // ORCAD_CONVERTER_H_