pads_pcb_converter.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2026 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef PADS_PCB_CONVERTER_H_
#define PADS_PCB_CONVERTER_H_
 
#include <map>
#include <string>
#include <vector>
 
#include <math/vector2d.h>
#include <pcb_io/common/plugin_common_layer_mapping.h>
#include <io/pads/pads_unit_converter.h>
#include <zones.h>
 
#include "pads_layer_mapper.h"
#include "pads_parser.h"
 
class BOARD;
class REPORTER;
class SHAPE_ARC;
class SHAPE_LINE_CHAIN;
class ZONE;

class PADS_PCB_CONVERTER
{
public:
    PADS_PCB_CONVERTER( BOARD* aBoard, REPORTER* aReporter );
 
    BOARD* GetBoard() const { return m_board; }
 
    PADS_UNIT_CONVERTER& UnitConverter() { return m_unitConverter; }

    void SetScaleFactor( double aScaleFactor ) { m_scaleFactor = aScaleFactor; }
 
    double GetScaleFactor() const { return m_scaleFactor; }
 
    void SetOrigin( double aX, double aY );
 
    double GetOriginX() const { return m_originX; }
 
    double GetOriginY() const { return m_originY; }

    bool SetOriginFromOutlines( const std::vector<PADS_IO::POLYLINE>& aOutlines );
 
    int ScaleSize( double aVal ) const;
 
    int ScaleCoord( double aVal, bool aIsX ) const;
 
    VECTOR2I ScalePoint( double aX, double aY ) const;

    void SetupLayers( const std::vector<PADS_IO::LAYER_INFO>& aPadsLayers, int aPadsLayerCount,
                      const LAYER_MAPPING_HANDLER& aMappingHandler, bool aResolveUnknownTypeByName );
 
    const std::vector<PADS_LAYER_INFO>& GetLayerInfos() const { return m_layerInfos; }
 
    PCB_LAYER_ID GetMappedLayer( int aPadsLayer ) const;

    void BuildStackup( const std::vector<PADS_IO::LAYER_INFO>& aPadsLayers );
 
    void EnsureNet( const std::string& aNetName );

    void AppendArcPoints( SHAPE_LINE_CHAIN& aChain, const std::vector<PADS_IO::ARC_POINT>& aPts ) const;

    SHAPE_ARC MakeMidpointArc( const PADS_IO::ARC_POINT& aPrev, const PADS_IO::ARC_POINT& aCurr,
                               int aWidth ) const;
 
    void LoadTexts( const std::vector<PADS_IO::TEXT>& aTexts );
 
    void LoadKeepouts( const std::vector<PADS_IO::KEEPOUT>& aKeepouts );
 
    void LoadDimensions( const std::vector<PADS_IO::DIMENSION>& aDimensions );

    void ApplyPourSettings( ZONE* aZone, const PADS_IO::POUR& aPour, int aMaxPriority,
                            const PADS_IO::PARAMETERS& aParams );

    void WriteDiffPairRules( const wxString& aFileName,
                             const std::vector<PADS_IO::DIFF_PAIR_DEF>& aDiffPairs );
 
    void ReportStatistics();
 
private:
    BOARD*    m_board;
    REPORTER* m_reporter;
 
    PADS_UNIT_CONVERTER m_unitConverter;
    double              m_scaleFactor = 0.0;
    double              m_originX = 0.0;
    double              m_originY = 0.0;
 
    PADS_LAYER_MAPPER                m_layerMapper;
    std::vector<PADS_LAYER_INFO>     m_layerInfos;
    std::map<wxString, PCB_LAYER_ID> m_layerMap;
    int                              m_copperLayerCount = 2;
};
 
#endif // PADS_PCB_CONVERTER_H_