diptrace_pcb_parser.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.
 *
 * 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 DIPTRACE_PCB_PARSER_H_
#define DIPTRACE_PCB_PARSER_H_
 
#include <io/diptrace/diptrace_binary_reader.h>
#include <math/vector2d.h>
 
#include <map>
#include <unordered_map>
#include <vector>
 
class BOARD;
class FOOTPRINT;
class NETINFO_ITEM;
class PAD;
class PCB_SHAPE;
class PCB_TEXT;
enum PCB_LAYER_ID : int;
 
namespace DIPTRACE
{
 
// ---------------------------------------------------------------------------
// Intermediate data structures for parsed DipTrace content
// ---------------------------------------------------------------------------
 
struct DT_VERTEX
{
    int     x = 0;         
    int     y = 0;         
    uint8_t arc = 0;       
};
 
struct DT_LAYER
{
    uint8_t  flag = 0;
    int      index = 0;
    uint32_t color = 0;    
    wxString name;
    int      type = 0;     
    int      planeNetIndex = -1; 
    int      fieldD = 0;   
};
 
struct DT_VIA_STYLE
{
    wxString name;
    int      outerDiameter = 0;
    int      drillDiameter = 0;
    int      layer1 = -1;
    int      layer2 = -1;
};
 
struct DT_DESIGN_RULE
{
    wxString name;
    int      clearance = 0;
    int      trackWidth = 0;
};
 
struct DT_PAD
{
    int      index = 0;        
    int      netIndex = -1;    
    int      x = 0;            
    int      y = 0;            
    wxString number;           
    wxString label;            
    int      width = 0;        
    int      height = 0;       
    int      drillWidth = 0;   
    int      drillHeight = 0;  
    int      style = 1;        
    uint8_t  mountType = 0;    
    uint8_t  orientClass = 0;  

    std::vector<std::pair<int, int>> polygonVertices;
};
 
 
struct DT_MOUNT_HOLE
{
    int x = 0;              
    int y = 0;              
    int outerDiameter = 0;  
    int drillDiameter = 0;  
};
 
enum DT_SHAPE_TYPE
{
    DT_SHAPE_EMPTY      = 0,
    DT_SHAPE_LINE       = 1,
    DT_SHAPE_RECT       = 2,
    DT_SHAPE_CIRCLE     = 3,
    DT_SHAPE_ARC        = 6,
    DT_SHAPE_FILLOBROUND = 700, 
    DT_SHAPE_END        = -1
};
 
struct DT_FP_SHAPE
{
    int type = DT_SHAPE_EMPTY;   
    int x1 = 0;                  
    int y1 = 0;                  
    int x2 = 0;                  
    int y2 = 0;                  
    int midX = 0;                
    int midY = 0;                
    int width = 0;               
    int layer = 0;               
};
 
struct DT_COMPONENT
{
    wxString libraryPath;
    int      positionX = 0;    
    int      positionY = 0;    
    int      placementQuarterTurns = 0; 
    bool     hasPlacementQuarterTurns = false;
    double   placementAngleDeg = 0.0;  
    bool     hasPlacementAngle = false;
    int      rotation = 0;     
    int      fieldC = 0;       
    int      fieldD = 0;       
    wxString patternName;
    wxString displayName;
    wxString refdes;
    wxString value;
    int      layer = 0;        
    int      bboxWidth = 0;    
    int      bboxHeight = 0;   
    int      padWidthHint = 0;   
    int      padHeightHint = 0;  
    int      drillWidthHint = 0; 
    int      drillHeightHint = 0;
    int      fieldA = 0;       
    int      fieldF = 0;       
    bool     isStandaloneVia = false; 
    std::vector<uint8_t>    flags;
    std::vector<DT_PAD>     pads;
    std::vector<DT_MOUNT_HOLE> holes;
    std::vector<DT_FP_SHAPE> shapes;  
    size_t boundaryOffset = 0;         
    size_t stringStartOffset = 0;      
    size_t regionEndOffset = 0;        
    size_t headerEndOffset = 0;        
    size_t padRegionEnd = 0;           
 
    // Text positioning from the 37-byte component tail
    int  refdesYOffset = 0;    
    int  valueYOffset = 0;     
    bool refdesVisible = true; 
    bool valueVisible = true;  
    bool hasTailData = false;  
};
 
struct DT_TEXT_OBJECT
{
    wxString text;
    wxString fontName;
    int      lineWidth = 0;    
    int      layer = 0;
    int      x1 = 0;
    int      y1 = 0;
    int      x2 = 0;
    int      y2 = 0;
    uint32_t color = 0;        
};
 
struct DT_PAD_REF
{
    int componentIndex = -1;   
    int padIndex = -1;         
};
 
struct DT_NET
{
    int      index = 0;        
    wxString name;             
    int      traceWidth = 0;   
    int      defaultViaOuterDiam = 0;  
    int      defaultViaDrillDiam = 0;  
    std::vector<DT_PAD_REF> padRefs;   
};
 
struct DT_TRACK_NODE
{
    int  x = 0;               
    int  y = 0;               
    int  layer = 0;           
    int  width = 0;           
    uint8_t routeFlag = 0;    
    int  routeMode = 0;       
    bool hasVia = false;      
    int  viaOuterDiam = 0;    
    int  viaDrillDiam = 0;    
    int  viaStyleIdx = -1;    
};
 
struct DT_TRACK_CHAIN
{
    int                        netIndex = -1;  
    std::vector<DT_TRACK_NODE> nodes;          
};
 
struct DT_ZONE_CACHED_FILL_RECORD
{
    int field0 = 0; 
    int field1 = 0; 
    int field2 = 0; 
    int field3 = 0; 
    int field4 = 0; 
    int field5 = 0; 
};
 
struct DT_ZONE
{
    int netIndex = -1;     
    int layer = 0;         
    int priority = 0;      
    uint8_t fillMode = 0;  
    uint8_t rawFlag2 = 0;  
    uint8_t connectionMode = 0; 
    int separator = 0;     
    int clearance = 0;     
    int minWidth = 0;      
    int minimumArea = 0;   
    int spokeMode = -1;    
    int lineSpacing = 0;   
    int spokeWidth = 0;    
    int regionsCounted = 0; 
    int cachedFillByteLen = 0; 
    int cachedFillRecordCount = 0; 
    int boardClearance = 0; 
    int zoneId = -1;       
    int smdSpokeMode = -1; 
    int smdSpokeWidth = 0; 
    uint8_t viaDirect = 0; 
    uint8_t smdSeparate = 0; 
    uint8_t islandRegion = 0; 
    uint8_t islandInternal = 0; 
    uint8_t islandConnection = 0; 
    uint8_t ratlineMode = 0; 
    uint8_t regionsDone = 0; 
    std::vector<DT_ZONE_CACHED_FILL_RECORD> cachedFillRecords; 
    std::vector<std::pair<int, int>> outline;  
};
 
 
// ---------------------------------------------------------------------------
// Main parser class
// ---------------------------------------------------------------------------

class PCB_PARSER
{
public:
    PCB_PARSER( const wxString& aFileName, BOARD* aBoard );
    ~PCB_PARSER();

    void Parse();

    int ScanLocatorUseCount() const
    {
        return m_componentLocatorScans + m_padLocatorScans + m_shapeLocatorScans
               + m_mountHoleLocatorScans + m_sectionLocatorScans;
    }
 
    int ComponentLocatorScans() const { return m_componentLocatorScans; }
    int PadLocatorScans() const { return m_padLocatorScans; }
    int ShapeLocatorScans() const { return m_shapeLocatorScans; }
    int MountHoleLocatorScans() const { return m_mountHoleLocatorScans; }
    int SectionLocatorScans() const { return m_sectionLocatorScans; }

    wxString GenerateDesignRules() const;
 
private:
    // --- Section parsers ---
    void ParseMagic();
    void ParseBoardProperties();
    void ParseOutline();
    void ParsePostOutline();
    void ParseLayers();
    void ParseFontStyle();
    void ParsePatternNameGroups( int aGroupCount );
    void ParsePatternStyleGroups( int aGroupCount );
    void ParseImplicitPatternStyleGroup();
    void ParseDesignRules();
    void FindAndParseComponents();

    void ApplyPlacementAngles();
 
    void ParsePostComponentSections();

    std::vector<std::pair<size_t, size_t>> FieldWalkComponentBoundaries( size_t aUpperBound );
 
    // --- Component parsing helpers ---
    bool ParseSingleComponent( size_t aBoundaryOffset, size_t aUpperBound,
                               DT_COMPONENT& aComp );

    static bool ClassifyStandaloneVia( const DT_COMPONENT& aComp );

    void FindPadsInRegion( DT_COMPONENT& aComp, size_t aRegionStart, size_t aRegionEnd );

    void FindMountHolesInRegion( DT_COMPONENT& aComp, size_t aRegionStart, size_t aRegionEnd );

    void FindShapesInRegion( DT_COMPONENT& aComp, size_t aRegionStart, size_t aRegionEnd );

    void FindShapesInFontBlocks( DT_COMPONENT& aComp, size_t aRegionStart, size_t aRegionEnd );

    void FindShapesInChainedBlocks( DT_COMPONENT& aComp, size_t aRegionStart, size_t aRegionEnd );

    void ParseComponentTail( DT_COMPONENT& aComp, size_t aRegionEnd );
 
    // --- Net and routing parsing ---
    void FindAndParseNets( size_t aSearchStart, size_t aSearchEnd );
    void ParseNetRouting( DT_NET& aNet );
    void InferPadNetsFromRoutingRefs();
 
    // --- Zone parsing ---
    void FindAndParseZones( size_t aSearchStart, size_t aSearchEnd );
 
    // --- Board object creation ---
    void ApplyBoardSettings();
    void CreateBoardOutline();
    void CreateFootprint( const DT_COMPONENT& aComp );
    void CreateStandaloneVias();
    void CreateTextObject( const DT_TEXT_OBJECT& aText );
    void CreateNets();
    void CreateTracksAndVias();
    void CreateZones();

    void CreatePlaneZones();

    NETINFO_ITEM* ResolveNetByIndex( int aDipTraceNetIndex ) const;
    const DT_NET* ResolveDipTraceNetByIndex( int aDipTraceNetIndex ) const;
 
    // --- Text object parsing ---
    void FindAndParseTextObjects( size_t aSearchStart, size_t aSearchEnd );
    void ParseTextRecords( int aCount );
 
    // --- Utility ---

    PCB_LAYER_ID MapLayer( int aDipTraceLayer ) const;
    PCB_LAYER_ID MapCopperLayer( int aDipTraceLayer ) const;

    static int ToKiCadCoord( int aDipTraceCoord );

    static double ToKiCadAngleDeg( int aDipTraceAngle );

    void SkipInterRulesetTransition();

    static bool TryReadStringAt( const uint8_t* aData, size_t aDataSize,
                                 size_t aPos, int aVersion,
                                 wxString& aOut, size_t& aNewPos );

    static std::vector<size_t> FindAllBoundaries( const uint8_t* aData, size_t aDataSize,
                                                  const uint8_t* aPattern, size_t aPatternLen,
                                                  size_t aStart, size_t aEnd );
 
    // --- Data ---
    BINARY_READER           m_reader;
    BOARD*                  m_board;
    int                     m_version;
    bool                    m_hasInlineVersion;
    bool                    m_hasLegacyMagicLayout;
 
    // Parsed intermediate data
    std::vector<DT_VERTEX>      m_outline;
    std::vector<DT_LAYER>       m_layers;
    std::vector<DT_VIA_STYLE>   m_viaStyles;
    std::vector<DT_DESIGN_RULE> m_designRules;
    std::vector<DT_COMPONENT>   m_components;
    std::vector<DT_TEXT_OBJECT>  m_textObjects;
    std::vector<DT_NET>         m_nets;
    std::vector<DT_TRACK_CHAIN> m_trackChains;
    std::vector<DT_ZONE>        m_zones;
    std::unordered_map<int, int> m_copperLayerOrdinalById;
    std::unordered_map<int, std::vector<VECTOR2I>> m_routingAnchorsByNet;
    bool m_routingAnchorCacheBuilt = false;
 
    // Link table between DipTrace net indices and created KiCad nets.
    std::unordered_map<int, NETINFO_ITEM*> m_kicadNetByDipTraceIndex;
    std::unordered_map<int, const DT_NET*> m_dipTraceNetByIndex;
 
    // Board properties
    int m_bboxXMin = 0;
    int m_bboxYMin = 0;
    int m_bboxXMax = 0;
    int m_bboxYMax = 0;
 
    // Section tracking
    int    m_ruleNameCount = 0;
    size_t m_postLayersOffset = 0;
    size_t m_postDesignRulesOffset = 0;
    size_t m_componentUpperBound = 0;
 
    // Determinism instrumentation. Each counter records how many objects/sections of its
    // category were located by byte-pattern scanning rather than a field-derived offset.
    // The determinism work drives every category to zero, one at a time, while keeping the
    // scanners as recovery fallbacks. See ScanLocatorUseCount().
    int m_componentLocatorScans = 0;
    int m_padLocatorScans = 0;
    int m_shapeLocatorScans = 0;
    int m_mountHoleLocatorScans = 0;
    int m_sectionLocatorScans = 0;
};
 
}  // namespace DIPTRACE
 
#endif    // DIPTRACE_PCB_PARSER_H_