altium_pcb.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019-2020 Thomas Pointhuber <[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 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/>.
 */
 
#include "altium_pcb.h"
#include "altium_parser_pcb.h"
#include <altium_pcb_compound_file.h>
#include <io/altium/altium_ascii_parser.h>
#include <io/altium/altium_binary_parser.h>
#include <io/altium/altium_parser_utils.h>
#include <io/altium/altium_props_utils.h>
#include <io/io_utils.h>
#include <io/altium/altium_project_variants.h>
 
#include <board.h>
#include <board_design_settings.h>
#include <board_design_settings_defaults.h>
#include <project/net_settings.h>
#include <footprint.h>
#include <layer_range.h>
#include <layer_utils.h>
#include <pcb_dimension.h>
#include <pad.h>
#include <pcb_shape.h>
#include <pcb_text.h>
#include <pcb_textbox.h>
#include <pcb_track.h>
#include <pcb_barcode.h>
#include <pcb_generator.h>
#include <generators_mgr.h>
#include <generators/pcb_tuning_pattern.h>
#include <router/pns_meander.h>
#include <geometry/shape_circle.h>
#include <geometry/shape_line_chain.h>
#include <core/profile.h>
#include <string_utils.h>
#include <tools/pad_tool.h>
#include <zone.h>
 
#include <board_stackup_manager/stackup_predefined_prms.h>
 
#include <cmath>
#include <set>
 
#include <advanced_config.h>
#include <compoundfilereader.h>
#include <convert_basic_shapes_to_polygon.h>
#include <font/outline_font.h>
#include <project.h>
#include <reporter.h>
#include <trigo.h>
#include <utf.h>
#include <wx/docview.h>
#include <wx/log.h>
#include <wx/mstream.h>
#include <wx/wfstream.h>
#include <wx/zstream.h>
#include <progress_reporter.h>
#include <magic_enum.hpp>
#include <thread_pool.h>
 
#include <limits>
#include <unordered_set>
 
 
constexpr double BOLD_FACTOR = 1.75;    // CSS font-weight-normal is 400; bold is 700
 
// Slots in an Altium padstack's per-layer arrays, which run top, mid 1 through 30, bottom
constexpr int ALTIUM_TOP_PADSTACK_IDX    = 0;
constexpr int ALTIUM_MID1_PADSTACK_IDX   = 1;
constexpr int ALTIUM_MID2_PADSTACK_IDX   = 2;
constexpr int ALTIUM_BOTTOM_PADSTACK_IDX = 31;
constexpr int ALTIUM_PADSTACK_IDX_COUNT  = 32;
 
 
bool IsAltiumLayerCopper( ALTIUM_LAYER aLayer )
{
    return ( aLayer >= ALTIUM_LAYER::TOP_LAYER && aLayer <= ALTIUM_LAYER::BOTTOM_LAYER )
           || aLayer == ALTIUM_LAYER::MULTI_LAYER; // TODO: add IsAltiumLayerAPlane?
}
 
 
bool IsAltiumLayerAPlane( ALTIUM_LAYER aLayer )
{
    return aLayer >= ALTIUM_LAYER::INTERNAL_PLANE_1 && aLayer <= ALTIUM_LAYER::INTERNAL_PLANE_16;
}
 
 
wxString AltiumUnnamedNetName( const BOARD& aBoard, int& aCounter )
{
    wxString name;
 
    do
    {
        name = wxString::Format( wxT( "__ALTIUM_UNNAMED_NET_%d" ), ++aCounter );
    } while( aBoard.FindNet( name ) );
 
    return name;
}
 
 
// Altium scope expressions are not case sensitive, so neither is the unrestricted scope
static bool IsAltiumScopeAll( const wxString& aExpr )
{
    return aExpr.IsSameAs( wxS( "All" ), false );
}
 
 
static bool GetAltiumNetclassScopeName( const ARULE6& aRule, wxString* aNetclassName )
{
    static const wxString prefix = wxT( "InNetClass('" );
 
    if( !IsAltiumScopeAll( aRule.scope2expr ) || !aRule.scope1expr.StartsWith( prefix )
        || !aRule.scope1expr.EndsWith( wxT( "')" ) ) )
    {
        return false;
    }
 
    *aNetclassName = aRule.scope1expr.Mid( prefix.Length(),
                                           aRule.scope1expr.Length() - prefix.Length() - 2 );
 
    return !aNetclassName->IsEmpty();
}
 
 
void ApplyAltiumNetclassRules( const std::map<ALTIUM_RULE_KIND, std::vector<ARULE6>>& aRulesByKind,
                               NET_SETTINGS& aNetSettings, std::vector<const ARULE6*>* aUnresolved )
{
    const std::map<wxString, std::shared_ptr<NETCLASS>>& netclasses = aNetSettings.GetNetclasses();
 
    for( const auto& [kind, rules] : aRulesByKind )
    {
        if( kind != ALTIUM_RULE_KIND::CLEARANCE && kind != ALTIUM_RULE_KIND::WIDTH
            && kind != ALTIUM_RULE_KIND::ROUTING_VIAS )
        {
            continue;
        }
 
        std::set<wxString> applied;
 
        for( const ARULE6& rule : rules )
        {
            wxString netclassName;
 
            if( !rule.enabled || !GetAltiumNetclassScopeName( rule, &netclassName ) )
                continue;
 
            auto it = netclasses.find( netclassName );
 
            if( it == netclasses.end() )
            {
                if( aUnresolved )
                    aUnresolved->push_back( &rule );
 
                continue;
            }
 
            // rules are sorted by ascending Altium priority, so the first match is the winner
            if( !applied.insert( netclassName ).second )
                continue;
 
            const std::shared_ptr<NETCLASS>& netclass = it->second;
 
            switch( kind )
            {
            case ALTIUM_RULE_KIND::CLEARANCE: netclass->SetClearance( rule.clearanceGap ); break;
 
            case ALTIUM_RULE_KIND::WIDTH: netclass->SetTrackWidth( rule.preferredWidth ); break;
 
            case ALTIUM_RULE_KIND::ROUTING_VIAS:
                netclass->SetViaDiameter( rule.width );
                netclass->SetViaDrill( rule.holeWidth );
                break;
 
            default: break;
            }
        }
    }
}
 
 
FOOTPRINT* ALTIUM_PCB::HelperGetFootprint( uint16_t aComponent ) const
{
    if( aComponent == ALTIUM_COMPONENT_NONE || m_components.size() <= aComponent )
    {
        THROW_IO_ERRORF( wxT( "Component creator tries to access component id %u of %u existing components" ),
                         (unsigned)aComponent, (unsigned)m_components.size() );
    }
 
    return m_components.at( aComponent );
}
 
 
std::shared_ptr<EMBEDDED_FILES::EMBEDDED_FILE>
ALTIUM_PCB::HelperEmbedModel( FOOTPRINT* aFootprint, const wxString& aModelName,
                              const std::vector<char>& aCompressedData, bool& aIsNew )
{
    EMBEDDED_FILES* embeddedFiles = aFootprint->GetEmbeddedFiles();
    const auto&     files = embeddedFiles->EmbeddedFileMap();
    auto            it = files.find( aModelName );
 
    aIsNew = it == files.end();
 
    // Several bodies of one component routinely share a model, and inflating it per body would
    // cost a full STEP decompression each time
    if( !aIsNew )
        return it->second;
 
    auto file = std::make_shared<EMBEDDED_FILES::EMBEDDED_FILE>();
    file->name = aModelName;
    file->type = EMBEDDED_FILES::EMBEDDED_FILE::FILE_TYPE::MODEL;
 
    wxMemoryInputStream compressedStream( aCompressedData.data(), aCompressedData.size() );
    wxZlibInputStream   zlibStream( compressedStream );
 
    // Altium compresses STEP at roughly 5:1, so guess high and double rather than reallocate
    // on every read
    file->decompressedData.resize( aCompressedData.size() * 6 );
    size_t offset = 0;
 
    while( !zlibStream.Eof() )
    {
        zlibStream.Read( file->decompressedData.data() + offset,
                         file->decompressedData.size() - offset );
 
        size_t bytesRead = zlibStream.LastRead();
 
        if( !bytesRead )
            break;
 
        offset += bytesRead;
 
        if( offset >= file->decompressedData.size() )
            file->decompressedData.resize( 2 * file->decompressedData.size() );
    }
 
    file->decompressedData.resize( offset );
 
    // The guess above overshoots by up to 6x and resize() keeps the capacity, which the board
    // would then hold for as long as it is open
    file->decompressedData.shrink_to_fit();
 
    embeddedFiles->AddFile( file );
 
    return file;
}
 
 
void HelperShapeLineChainFromAltiumVertices( SHAPE_LINE_CHAIN& aLine,
                                             const std::vector<ALTIUM_VERTICE>& aVertices )
{
    for( const ALTIUM_VERTICE& vertex : aVertices )
    {
        if( vertex.isRound )
        {
            EDA_ANGLE angle( vertex.endangle - vertex.startangle, DEGREES_T );
            angle.Normalize();
 
            double  startradiant   = DEG2RAD( vertex.startangle );
            double  endradiant     = DEG2RAD( vertex.endangle );
            VECTOR2I arcStartOffset = KiROUND( std::cos( startradiant ) * vertex.radius,
                                               -std::sin( startradiant ) * vertex.radius );
 
            VECTOR2I arcEndOffset = KiROUND( std::cos( endradiant ) * vertex.radius,
                                             -std::sin( endradiant ) * vertex.radius );
 
            VECTOR2I arcStart = vertex.center + arcStartOffset;
            VECTOR2I arcEnd   = vertex.center + arcEndOffset;
 
            bool isShort = arcStart.Distance( arcEnd ) < pcbIUScale.mmToIU( 0.001 )
                           || angle.AsDegrees() < 0.2;
 
            if( arcStart.Distance( vertex.position )
                    < arcEnd.Distance( vertex.position ) )
            {
                if( !isShort )
                {
                    aLine.Append( SHAPE_ARC( vertex.center, arcStart, -angle ) );
                }
                else
                {
                    aLine.Append( arcStart );
                    aLine.Append( arcEnd );
                }
            }
            else
            {
                if( !isShort )
                {
                    aLine.Append( SHAPE_ARC( vertex.center, arcEnd, angle ) );
                }
                else
                {
                    aLine.Append( arcEnd );
                    aLine.Append( arcStart );
                }
            }
        }
        else
        {
            aLine.Append( vertex.position );
        }
    }
 
    aLine.SetClosed( true );
}
 
 
PCB_LAYER_ID ALTIUM_PCB::GetKicadLayer( ALTIUM_LAYER aAltiumLayer ) const
{
    auto override = m_layermap.find( aAltiumLayer );
 
    if( override != m_layermap.end() )
    {
        return override->second;
    }
 
    if( aAltiumLayer >= ALTIUM_LAYER::V7_MECHANICAL_17 && aAltiumLayer <= ALTIUM_LAYER::V7_MECHANICAL_LAST )
    {
        // Layer "Mechanical 17" would correspond to altiumOrd 16
        int altiumOrd = static_cast<int>( aAltiumLayer ) - static_cast<int>( ALTIUM_LAYER::V7_MECHANICAL_1 );
 
        if( ( altiumOrd + 1 ) > MAX_USER_DEFINED_LAYERS )
            return UNDEFINED_LAYER;
 
        // Convert to KiCad User_* layers
        return static_cast<PCB_LAYER_ID>( static_cast<int>( User_1 ) + altiumOrd * 2 );
    }
 
    switch( aAltiumLayer )
    {
    case ALTIUM_LAYER::UNKNOWN:           return UNDEFINED_LAYER;
 
    case ALTIUM_LAYER::TOP_LAYER:         return F_Cu;
    case ALTIUM_LAYER::MID_LAYER_1:       return In1_Cu;
    case ALTIUM_LAYER::MID_LAYER_2:       return In2_Cu;
    case ALTIUM_LAYER::MID_LAYER_3:       return In3_Cu;
    case ALTIUM_LAYER::MID_LAYER_4:       return In4_Cu;
    case ALTIUM_LAYER::MID_LAYER_5:       return In5_Cu;
    case ALTIUM_LAYER::MID_LAYER_6:       return In6_Cu;
    case ALTIUM_LAYER::MID_LAYER_7:       return In7_Cu;
    case ALTIUM_LAYER::MID_LAYER_8:       return In8_Cu;
    case ALTIUM_LAYER::MID_LAYER_9:       return In9_Cu;
    case ALTIUM_LAYER::MID_LAYER_10:      return In10_Cu;
    case ALTIUM_LAYER::MID_LAYER_11:      return In11_Cu;
    case ALTIUM_LAYER::MID_LAYER_12:      return In12_Cu;
    case ALTIUM_LAYER::MID_LAYER_13:      return In13_Cu;
    case ALTIUM_LAYER::MID_LAYER_14:      return In14_Cu;
    case ALTIUM_LAYER::MID_LAYER_15:      return In15_Cu;
    case ALTIUM_LAYER::MID_LAYER_16:      return In16_Cu;
    case ALTIUM_LAYER::MID_LAYER_17:      return In17_Cu;
    case ALTIUM_LAYER::MID_LAYER_18:      return In18_Cu;
    case ALTIUM_LAYER::MID_LAYER_19:      return In19_Cu;
    case ALTIUM_LAYER::MID_LAYER_20:      return In20_Cu;
    case ALTIUM_LAYER::MID_LAYER_21:      return In21_Cu;
    case ALTIUM_LAYER::MID_LAYER_22:      return In22_Cu;
    case ALTIUM_LAYER::MID_LAYER_23:      return In23_Cu;
    case ALTIUM_LAYER::MID_LAYER_24:      return In24_Cu;
    case ALTIUM_LAYER::MID_LAYER_25:      return In25_Cu;
    case ALTIUM_LAYER::MID_LAYER_26:      return In26_Cu;
    case ALTIUM_LAYER::MID_LAYER_27:      return In27_Cu;
    case ALTIUM_LAYER::MID_LAYER_28:      return In28_Cu;
    case ALTIUM_LAYER::MID_LAYER_29:      return In29_Cu;
    case ALTIUM_LAYER::MID_LAYER_30:      return In30_Cu;
    case ALTIUM_LAYER::BOTTOM_LAYER:      return B_Cu;
 
    case ALTIUM_LAYER::TOP_OVERLAY:       return F_SilkS;
    case ALTIUM_LAYER::BOTTOM_OVERLAY:    return B_SilkS;
    case ALTIUM_LAYER::TOP_PASTE:         return F_Paste;
    case ALTIUM_LAYER::BOTTOM_PASTE:      return B_Paste;
    case ALTIUM_LAYER::TOP_SOLDER:        return F_Mask;
    case ALTIUM_LAYER::BOTTOM_SOLDER:     return B_Mask;
 
    case ALTIUM_LAYER::INTERNAL_PLANE_1:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_2:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_3:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_4:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_5:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_6:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_7:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_8:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_9:  return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_10: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_11: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_12: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_13: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_14: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_15: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::INTERNAL_PLANE_16: return UNDEFINED_LAYER;
 
    case ALTIUM_LAYER::DRILL_GUIDE:       return Dwgs_User;
    case ALTIUM_LAYER::KEEP_OUT_LAYER:    return Margin;
 
    case ALTIUM_LAYER::MECHANICAL_1:      return User_1;
    case ALTIUM_LAYER::MECHANICAL_2:      return User_2;
    case ALTIUM_LAYER::MECHANICAL_3:      return User_3;
    case ALTIUM_LAYER::MECHANICAL_4:      return User_4;
    case ALTIUM_LAYER::MECHANICAL_5:      return User_5;
    case ALTIUM_LAYER::MECHANICAL_6:      return User_6;
    case ALTIUM_LAYER::MECHANICAL_7:      return User_7;
    case ALTIUM_LAYER::MECHANICAL_8:      return User_8;
    case ALTIUM_LAYER::MECHANICAL_9:      return User_9;
    case ALTIUM_LAYER::MECHANICAL_10:     return User_10;
    case ALTIUM_LAYER::MECHANICAL_11:     return User_11;
    case ALTIUM_LAYER::MECHANICAL_12:     return User_12;
    case ALTIUM_LAYER::MECHANICAL_13:     return User_13;
    case ALTIUM_LAYER::MECHANICAL_14:     return User_14;
    case ALTIUM_LAYER::MECHANICAL_15:     return User_15;
    case ALTIUM_LAYER::MECHANICAL_16:     return User_16;
 
    case ALTIUM_LAYER::DRILL_DRAWING:     return Dwgs_User;
    case ALTIUM_LAYER::MULTI_LAYER:       return UNDEFINED_LAYER;
    case ALTIUM_LAYER::CONNECTIONS:       return UNDEFINED_LAYER;
    case ALTIUM_LAYER::BACKGROUND:        return UNDEFINED_LAYER;
    case ALTIUM_LAYER::DRC_ERROR_MARKERS: return UNDEFINED_LAYER;
    case ALTIUM_LAYER::SELECTIONS:        return UNDEFINED_LAYER;
    case ALTIUM_LAYER::VISIBLE_GRID_1:    return UNDEFINED_LAYER;
    case ALTIUM_LAYER::VISIBLE_GRID_2:    return UNDEFINED_LAYER;
    case ALTIUM_LAYER::PAD_HOLES:         return UNDEFINED_LAYER;
    case ALTIUM_LAYER::VIA_HOLES:         return UNDEFINED_LAYER;
 
    default:                              return UNDEFINED_LAYER;
    }
}
 
 
std::vector<PCB_LAYER_ID> ALTIUM_PCB::GetKicadLayersToIterate( ALTIUM_LAYER aAltiumLayer ) const
{
    if( aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER || aAltiumLayer == ALTIUM_LAYER::KEEP_OUT_LAYER )
    {
        int layerCount = m_board ? m_board->GetCopperLayerCount() : 32;
        std::vector<PCB_LAYER_ID> layers;
        layers.reserve( layerCount );
 
        for( PCB_LAYER_ID layer : LAYER_RANGE( F_Cu, B_Cu, layerCount ) )
        {
            if( !m_board || m_board->IsLayerEnabled( layer ) )
                layers.emplace_back( layer );
        }
 
        return layers;
    }
 
    PCB_LAYER_ID klayer = GetKicadLayer( aAltiumLayer );
 
    if( klayer == UNDEFINED_LAYER )
        return {};
 
    return { klayer };
}
 
 
ALTIUM_PCB::ALTIUM_PCB( BOARD* aBoard, PROGRESS_REPORTER* aProgressReporter,
                        LAYER_MAPPING_HANDLER& aHandler, REPORTER* aReporter,
                        const wxString& aLibrary, const wxString& aFootprintName )
{
    m_board = aBoard;
    m_progressReporter = aProgressReporter;
    m_layerMappingHandler = aHandler;
    m_reporter = aReporter;
    m_doneCount = 0;
    m_lastProgressCount = 0;
    m_totalCount = 0;
    m_highest_pour_index = 0;
    m_library = aLibrary;
    m_footprintName = aFootprintName;
}
 
ALTIUM_PCB::~ALTIUM_PCB()
{
}
 
void ALTIUM_PCB::checkpoint()
{
    const unsigned PROGRESS_DELTA = 250;
 
    if( m_progressReporter )
    {
        if( ++m_doneCount > m_lastProgressCount + PROGRESS_DELTA )
        {
            m_progressReporter->SetCurrentProgress( (double) m_doneCount / std::max( 1U, m_totalCount ) );
 
            if( !m_progressReporter->KeepRefreshing() )
                THROW_IO_CANCELLED();
 
            m_lastProgressCount = m_doneCount;
        }
    }
}
 
// A courtyard has to be one closed outline, so open pieces on the layer, such as a centre cross,
// are drawn on the fabrication layer of that side instead.
static void MoveOpenCourtyardItems( BOARD& aBoard )
{
    // Ends that the courtyard builder chains together count as meeting
    const int epsilon = pcbIUScale.mmToIU( 0.02 );
 
    for( FOOTPRINT* footprint : aBoard.Footprints() )
    {
        for( PCB_LAYER_ID courtyard : { F_CrtYd, B_CrtYd } )
        {
            std::vector<PCB_SHAPE*> pieces;
            std::vector<VECTOR2I>   nodes;
            std::vector<int>        degree;
 
            auto nodeAt =
                    [&]( const VECTOR2I& aPt )
                    {
                        for( size_t i = 0; i < nodes.size(); i++ )
                        {
                            if( ( nodes[i] - aPt ).EuclideanNorm() <= epsilon )
                                return static_cast<int>( i );
                        }
 
                        nodes.push_back( aPt );
                        degree.push_back( 0 );
                        return static_cast<int>( nodes.size() ) - 1;
                    };
 
            std::vector<std::pair<int, int>> ends;
 
            for( BOARD_ITEM* item : footprint->GraphicalItems() )
            {
                if( item->GetLayer() != courtyard || item->Type() != PCB_SHAPE_T )
                    continue;
 
                PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( item );
 
                if( shape->GetShape() != SHAPE_T::SEGMENT && shape->GetShape() != SHAPE_T::ARC )
                    continue;
 
                int a = nodeAt( shape->GetStart() );
                int b = nodeAt( shape->GetEnd() );
 
                // File coordinates drift by nanometres, so ends that nearly meet are made to meet
                if( shape->GetShape() == SHAPE_T::SEGMENT )
                {
                    const int snap = pcbIUScale.mmToIU( 0.001 );
 
                    if( ( nodes[a] - shape->GetStart() ).EuclideanNorm() <= snap )
                        shape->SetStart( nodes[a] );
 
                    if( ( nodes[b] - shape->GetEnd() ).EuclideanNorm() <= snap )
                        shape->SetEnd( nodes[b] );
                }
 
                degree[a]++;
                degree[b]++;
                pieces.push_back( shape );
                ends.emplace_back( a, b );
            }
 
            // An edge that hangs off the outline, directly or through other hanging edges, is open
            std::vector<bool> hanging( pieces.size(), false );
            std::vector<int>  open;
 
            for( size_t i = 0; i < nodes.size(); i++ )
            {
                if( degree[i] == 1 )
                    open.push_back( static_cast<int>( i ) );
            }
 
            while( !open.empty() )
            {
                const int node = open.back();
                open.pop_back();
 
                for( size_t i = 0; i < pieces.size(); i++ )
                {
                    if( hanging[i] || ( ends[i].first != node && ends[i].second != node ) )
                        continue;
 
                    hanging[i] = true;
                    degree[ends[i].first]--;
                    degree[ends[i].second]--;
 
                    const int far_idx = ends[i].first == node ? ends[i].second : ends[i].first;
 
                    if( degree[far_idx] == 1 )
                        open.push_back( far_idx );
                }
            }
 
            // More than the two lines of a centre mark and nothing closed is an open courtyard, which
            // stays on the layer for DRC to report
            const bool anyClosed =
                    std::any_of( hanging.begin(), hanging.end(), []( bool aHanging ) { return !aHanging; } );
 
            if( !anyClosed && pieces.size() > 2 )
                continue;
 
            for( size_t i = 0; i < pieces.size(); i++ )
            {
                if( hanging[i] )
                    pieces[i]->SetLayer( courtyard == F_CrtYd ? F_Fab : B_Fab );
            }
        }
    }
}
 
 
void ALTIUM_PCB::Parse( const ALTIUM_PCB_COMPOUND_FILE&              altiumPcbFile,
                        const std::map<ALTIUM_PCB_DIR, std::string>& aFileMapping,
                        const std::map<std::string, UTF8>*           aProperties )
{
    if( aProperties )
        MapSchematicNetNames( *aProperties );
 
    // this vector simply declares in which order which functions to call.
    const std::vector<std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>> parserOrder = {
        { true, ALTIUM_PCB_DIR::FILE_HEADER,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseFileHeader( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::BOARD6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseBoard6Data( aFile, fileHeader );
          } },
        { false, ALTIUM_PCB_DIR::EXTENDPRIMITIVEINFORMATION,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseExtendedPrimitiveInformationData( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::COMPONENTS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseComponents6Data( aFile, fileHeader );
          } },
        { false, ALTIUM_PCB_DIR::MODELS,
          [this, aFileMapping]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              std::vector<std::string> dir{ aFileMapping.at( ALTIUM_PCB_DIR::MODELS ) };
              this->ParseModelsData( aFile, fileHeader, dir );
          } },
        { true, ALTIUM_PCB_DIR::COMPONENTBODIES6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseComponentsBodies6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::NETS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseNets6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::CLASSES6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseClasses6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::RULES6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseRules6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::DIMENSIONS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseDimensions6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::POLYGONS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParsePolygons6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::ARCS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseArcs6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::PADS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParsePads6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::VIAS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseVias6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::TRACKS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseTracks6Data( aFile, fileHeader );
          } },
        { false, ALTIUM_PCB_DIR::SMARTUNIONS,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseSmartUnions6Data( aFile, fileHeader );
          } },
        { false, ALTIUM_PCB_DIR::UNIONNAMES,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseUnionNamesData( aFile, fileHeader );
          } },
        { false, ALTIUM_PCB_DIR::WIDESTRINGS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseWideStrings6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::TEXTS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseTexts6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::FILLS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseFills6Data( aFile, fileHeader );
          } },
        { false, ALTIUM_PCB_DIR::BOARDREGIONS,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseBoardRegionsData( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::SHAPEBASEDREGIONS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseShapeBasedRegions6Data( aFile, fileHeader );
          } },
        { true, ALTIUM_PCB_DIR::REGIONS6,
          [this]( const ALTIUM_PCB_COMPOUND_FILE& aFile, auto fileHeader )
          {
              this->ParseRegions6Data( aFile, fileHeader );
          } }
    };
 
    if( m_progressReporter != nullptr )
    {
        // Count number of records we will read for the progress reporter
        for( const std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>& cur : parserOrder )
        {
            bool                      isRequired;
            ALTIUM_PCB_DIR            directory;
            PARSE_FUNCTION_POINTER_fp fp;
            std::tie( isRequired, directory, fp ) = cur;
 
            if( directory == ALTIUM_PCB_DIR::FILE_HEADER )
                continue;
 
            const auto& mappedDirectory = aFileMapping.find( directory );
 
            if( mappedDirectory == aFileMapping.end() )
                continue;
 
            const std::vector<std::string>  mappedFile{ mappedDirectory->second, "Header" };
            const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.FindStream( mappedFile );
 
            if( file == nullptr )
                continue;
 
            ALTIUM_BINARY_PARSER reader( altiumPcbFile, file );
            uint32_t             numOfRecords = reader.Read<uint32_t>();
 
            if( reader.HasParsingError() )
            {
                if( m_reporter )
                {
                    m_reporter->Report( wxString::Format( _( "'%s' was not parsed correctly." ),
                                                          FormatPath( mappedFile ) ),
                                        RPT_SEVERITY_ERROR );
                }
 
                continue;
            }
 
            m_totalCount += numOfRecords;
 
            if( reader.GetRemainingBytes() != 0 )
            {
                if( m_reporter )
                {
                    m_reporter->Report( wxString::Format( _( "'%s' was not fully parsed." ),
                                                          FormatPath( mappedFile ) ),
                                        RPT_SEVERITY_ERROR );
                }
 
                continue;
            }
        }
    }
 
    const auto& boardDirectory = aFileMapping.find( ALTIUM_PCB_DIR::BOARD6 );
 
    if( boardDirectory != aFileMapping.end() )
    {
        std::vector<std::string> mappedFile{ boardDirectory->second, "Data" };
 
        const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.FindStream( mappedFile );
 
        if( !file )
        {
            THROW_IO_ERROR( _( "This file does not appear to be in a valid PCB Binary Version 6.0 format. In "
                               "Altium Designer, make sure to save as \"PCB Binary Files (*.PcbDoc)\"." ) );
        }
    }
 
    // Parse data in specified order
    for( const std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>& cur : parserOrder )
    {
        bool                      isRequired;
        ALTIUM_PCB_DIR            directory;
        PARSE_FUNCTION_POINTER_fp fp;
        std::tie( isRequired, directory, fp ) = cur;
 
        const auto& mappedDirectory = aFileMapping.find( directory );
 
        if( mappedDirectory == aFileMapping.end() )
        {
            wxASSERT_MSG( !isRequired, wxString::Format( wxT( "Altium Directory of kind %d was "
                                                              "expected, but no mapping is "
                                                              "present in the code" ),
                                                         directory ) );
            continue;
        }
 
        std::vector<std::string> mappedFile{ mappedDirectory->second };
 
        if( directory != ALTIUM_PCB_DIR::FILE_HEADER )
            mappedFile.emplace_back( "Data" );
 
        const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.FindStream( mappedFile );
 
        if( file != nullptr )
        {
            fp( altiumPcbFile, file );
        }
        else if( isRequired )
        {
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "File not found: '%s' for directory '%s'." ),
                                                      FormatPath( mappedFile ),
                                                      magic_enum::enum_name( directory ) ),
                                    RPT_SEVERITY_ERROR );
            }
        }
    }
 
    // Components6 is parsed before Pads6, so the mounting style can only be derived once every
    // pad has been attached to its footprint.
    HelperSetFootprintMountingStyles();
 
    // Copper that touches no pad returns to the board here, before the tuning patterns claim it
    HelperFoldComponentCopperIntoPads();
 
    // Rebuild interactive length-tuning meanders from the SmartUnions definitions now that all
    // copper that the unions reference has been created and added to the board.
    HelperCreateTuningPatterns();
 
    HelperSetFootprintStackups();
 
    // fixup zone priorities since Altium stores them in the opposite order
    for( ZONE* zone : m_polygons )
    {
        if( !zone )
            continue;
 
        // Altium "fills" - not poured in Altium
        if( zone->GetAssignedPriority() == 1000 )
        {
            // Unlikely, but you never know
            if( m_highest_pour_index >= 1000 )
                zone->SetAssignedPriority( m_highest_pour_index + 1 );
 
            continue;
        }
 
        int priority = m_highest_pour_index - zone->GetAssignedPriority();
 
        zone->SetAssignedPriority( priority >= 0 ? priority : 0 );
    }
 
    // change priority of outer zone to zero
    for( std::pair<const ALTIUM_LAYER, ZONE*>& zone : m_outer_plane )
        zone.second->SetAssignedPriority( 0 );
 
    // Simplify and fracture zone fills in case we constructed them from tracks (hatched fill)
    thread_pool&           tp = GetKiCadThreadPool();
    BS::multi_future<void> fractureFutures;
 
    for( ZONE* zone : m_polygons )
    {
        if( !zone )
            continue;
 
        for( PCB_LAYER_ID layer : zone->GetLayerSet() )
        {
            if( !zone->HasFilledPolysForLayer( layer ) )
                continue;
 
            // A hatched plane unions thousands of track outlines, so fills fracture concurrently
            fractureFutures.push_back( tp.submit_task(
                    [fill = zone->GetFilledPolysList( layer )]()
                    {
                        fill->Fracture();
                    } ) );
        }
    }
 
    // Wait for every task before rethrowing so none outlives the parse
    fractureFutures.wait();
    fractureFutures.get();
 
    HelperFinishBoardOutline();
 
    MoveOpenCourtyardItems( *m_board );
 
    // Altium doesn't appear to store either the dimension value nor the dimensioned object in
    // the dimension record.  (Yes, there is a REFERENCE0OBJECTID, but it doesn't point to the
    // dimensioned object.)  We attempt to plug this gap by finding a colocated arc or circle
    // and using its radius.  If there are more than one such arcs/circles, well, :shrug:.
    for( PCB_DIM_RADIAL* dim : m_radialDimensions )
    {
        int radius = 0;
 
        for( BOARD_ITEM* item : m_board->Drawings() )
        {
            if( item->Type() != PCB_SHAPE_T )
                continue;
 
            PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( item );
 
            if( shape->GetShape() != SHAPE_T::ARC && shape->GetShape() != SHAPE_T::CIRCLE )
                continue;
 
            if( shape->GetPosition() == dim->GetPosition() )
            {
                radius = shape->GetRadius();
                break;
            }
        }
 
        if( radius == 0 )
        {
            for( PCB_TRACK* track : m_board->Tracks() )
            {
                if( track->Type() != PCB_ARC_T )
                    continue;
 
                PCB_ARC* arc = static_cast<PCB_ARC*>( track );
 
                if( arc->GetCenter() == dim->GetPosition() )
                {
                    radius = arc->GetRadius();
                    break;
                }
            }
        }
 
        // Move the radius point onto the circumference
        VECTOR2I radialLine = dim->GetEnd() - dim->GetStart();
        int      totalLength = radialLine.EuclideanNorm();
 
        // Enforce a minimum on the radialLine else we won't have enough precision to get the
        // angle from it.
        radialLine = radialLine.Resize( std::max( radius, 2 ) );
        dim->SetEnd( dim->GetStart() + (VECTOR2I) radialLine );
        dim->SetLeaderLength( totalLength - radius );
        dim->Update();
    }
 
    // center board
    BOX2I bbbox = m_board->GetBoardEdgesBoundingBox();
 
    int w = m_board->GetPageSettings().GetWidthIU( pcbIUScale.IU_PER_MILS );
    int h = m_board->GetPageSettings().GetHeightIU( pcbIUScale.IU_PER_MILS );
 
    int desired_x = ( w - bbbox.GetWidth() ) / 2;
    int desired_y = ( h - bbbox.GetHeight() ) / 2;
 
    VECTOR2I movementVector( desired_x - bbbox.GetX(), desired_y - bbbox.GetY() );
    m_board->Move( movementVector );
 
    BOARD_DESIGN_SETTINGS& bds = m_board->GetDesignSettings();
    bds.SetAuxOrigin( bds.GetAuxOrigin() + movementVector );
    bds.SetGridOrigin( bds.GetGridOrigin() + movementVector );
 
    m_board->m_LegacyDesignSettingsLoaded = true;
    m_board->SetModified();
}
 
 
// CIRCLE/RECTANGLE bodies become the anchor as-is; others are demoted to a polygon primitive
// over a small circular anchor so their copper is not discarded
static void altiumMakePadLayerCustom( PAD* aPad, PCB_LAYER_ID aLayer, int aMaxError )
{
    PAD_SHAPE shape = aPad->GetShape( aLayer );
 
    if( shape == PAD_SHAPE::CIRCLE || shape == PAD_SHAPE::RECTANGLE )
    {
        aPad->SetAnchorPadShape( aLayer, shape );
        aPad->SetShape( aLayer, PAD_SHAPE::CUSTOM );
    }
    else if( shape != PAD_SHAPE::CUSTOM )
    {
        SHAPE_POLY_SET body;
        aPad->TransformShapeToPolygon( body, aLayer, 0, aMaxError, ERROR_INSIDE );
 
        int minExtent = std::min( aPad->GetSize( aLayer ).x, aPad->GetSize( aLayer ).y );
 
        aPad->SetAnchorPadShape( aLayer, PAD_SHAPE::CIRCLE );
        aPad->SetSize( aLayer, VECTOR2I( minExtent, minExtent ) );
        aPad->SetShape( aLayer, PAD_SHAPE::CUSTOM );
 
        PCB_SHAPE* bodyPrim = new PCB_SHAPE( nullptr, SHAPE_T::POLY );
        bodyPrim->SetFilled( true );
        bodyPrim->SetStroke( STROKE_PARAMS( 0, LINE_STYLE::SOLID ) );
        bodyPrim->SetPolyShape( body );
        bodyPrim->Move( -aPad->ShapePos( aLayer ) );
        bodyPrim->Rotate( VECTOR2I( 0, 0 ), -aPad->GetOrientation() );
        aPad->AddPrimitive( aLayer, bodyPrim );
    }
}
 
 
// Give every copper layer its own padstack entry, deep copying shared primitives, so one layer
// can change shape without the others; ALL_LAYERS aliases F_Cu so a NORMAL pad cannot be edited in place
static void altiumSplitPadstackPerLayer( PAD* aPad, const LSET& aBoardCopper )
{
    PADSTACK& padstack = aPad->Padstack();
 
    if( padstack.Mode() == PADSTACK::MODE::CUSTOM )
        return;
 
    // Entries for layers the board lacks would only collide with real ones when flipped
    const LSET copper = aPad->GetLayerSet() & aBoardCopper;
 
    std::map<PCB_LAYER_ID, PADSTACK::COPPER_LAYER_PROPS> props;
 
    for( PCB_LAYER_ID layer : copper )
    {
        PADSTACK::COPPER_LAYER_PROPS layerProps = padstack.CopperLayer( layer );
 
        for( std::shared_ptr<PCB_SHAPE>& prim : layerProps.custom_shapes )
            prim = std::shared_ptr<PCB_SHAPE>( static_cast<PCB_SHAPE*>( prim->Clone() ) );
 
        props[layer] = std::move( layerProps );
    }
 
    padstack.SetMode( PADSTACK::MODE::CUSTOM );
 
    for( auto& [layer, layerProps] : props )
        padstack.CopperLayer( layer ) = std::move( layerProps );
 
    aPad->SetDirty();
}
 
 
// Lets aLayer change shape alone with the fewest padstack entries; outer layers only need front/inner/back
static void altiumIsolatePadLayer( PAD* aPad, PCB_LAYER_ID aLayer, const LSET& aBoardCopper )
{
    if( ( aPad->GetLayerSet() & LSET::AllCuMask() ).count() < 2 )
        return;
 
    PADSTACK& padstack = aPad->Padstack();
 
    if( IsInnerCopperLayer( aLayer ) )
    {
        altiumSplitPadstackPerLayer( aPad, aBoardCopper );
    }
    else if( padstack.Mode() == PADSTACK::MODE::NORMAL )
    {
        padstack.SetMode( PADSTACK::MODE::FRONT_INNER_BACK );
 
        // Materialized from the shared F_Cu entry before aLayer changes
        padstack.CopperLayer( PADSTACK::INNER_LAYERS );
        padstack.CopperLayer( B_Cu );
        aPad->SetDirty();
    }
}
 
 
static LSET altiumStackupCopper( const LSET& aDrawnCopper, int aMinCopperLayers )
{
    return LSET::AllCuMask( std::max( aMinCopperLayers, LAYER_UTILS::MinimalCopperLayerCount( aDrawnCopper ) ) );
}
 
 
// Altium addresses each mid layer directly, while the default footprint stackup has one inner
// layer that hides deeper items and spreads an In1 keepout to every inner layer
static void altiumSetFootprintStackup( FOOTPRINT* aFootprint, const LSET& aDrawnCopper, int aMinCopperLayers )
{
    if( ( aDrawnCopper & LSET::InternalCuMask() ).none() )
        return;
 
    const LSET stackupCopper = altiumStackupCopper( aDrawnCopper, aMinCopperLayers );
 
    for( ZONE* zone : aFootprint->Zones() )
    {
        LSET layers = zone->GetLayerSet();
 
        if( ( layers & LSET::AllCuMask() ).count() > 1 )
            zone->SetLayerSet( layers & ( stackupCopper | ~LSET::AllCuMask() ) );
    }
 
    // Every drawn layer is in the stackup, so copper outside it is a multi-layer expansion copy
    std::vector<BOARD_ITEM*> outsideStackup;
 
    for( BOARD_ITEM* item : aFootprint->GraphicalItems() )
    {
        if( IsCopperLayer( item->GetLayer() ) && !stackupCopper.test( item->GetLayer() ) )
            outsideStackup.push_back( item );
    }
 
    for( BOARD_ITEM* item : outsideStackup )
    {
        aFootprint->Remove( item );
        delete item;
    }
 
    LSET userLayers = LAYER_UTILS::GetAllFootprintLayers( *aFootprint ) & LSET::UserDefinedLayersMask();
 
    aFootprint->SetStackupMode( FOOTPRINT_STACKUP::CUSTOM_LAYERS );
    aFootprint->SetStackupLayers( stackupCopper | userLayers );
}
 
 
std::unique_ptr<FOOTPRINT> ALTIUM_PCB::ParseFootprint( ALTIUM_PCB_COMPOUND_FILE& altiumLibFile,
                                                       const wxString&           aFootprintName )
{
    std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>( m_board );
 
    m_unicodeStrings.clear();
    m_extendedPrimitiveInformationMaps.clear();
 
    const std::vector<std::string>  libStreamName{ "Library", "Data" };
    const CFB::COMPOUND_FILE_ENTRY* libStream = altiumLibFile.FindStream( libStreamName );
 
    if( libStream == nullptr )
        THROW_IO_ERRORF( _( "File not found: '%s'." ), FormatPath( libStreamName ) );
 
    ALTIUM_BINARY_PARSER libParser( altiumLibFile, libStream );
    ALIBRARY      libData( libParser );
 
    HelperFillMechanicalLayerAssignments( libData.stackup );
 
    // TODO: WideStrings are stored as parameterMap in the case of footprints, not as binary
    //    std::string                     unicodeStringsStreamName = aFootprintName.ToStdString() + "\\WideStrings";
    //    const CFB::COMPOUND_FILE_ENTRY* unicodeStringsData = altiumLibFile.FindStream( unicodeStringsStreamName );
    //    if( unicodeStringsData != nullptr )
    //    {
    //        ParseWideStrings6Data( altiumLibFile, unicodeStringsData );
    //    }
 
    std::tuple<wxString, const CFB::COMPOUND_FILE_ENTRY*> ret =
            altiumLibFile.FindLibFootprintDirName( aFootprintName );
 
    wxString fpDirName = std::get<0>( ret );
    const CFB::COMPOUND_FILE_ENTRY* footprintStream = std::get<1>( ret );
 
    if( fpDirName.IsEmpty() )
        THROW_IO_ERRORF( _( "Footprint directory not found: '%s'." ), aFootprintName );
 
    const std::vector<std::string>  streamName{ fpDirName.ToStdString(), "Data" };
    const CFB::COMPOUND_FILE_ENTRY* footprintData = altiumLibFile.FindStream( footprintStream, { "Data" } );
 
    if( !footprintData )
        THROW_IO_ERRORF( _( "File not found: '%s'." ), FormatPath( streamName ) );
 
    ALTIUM_BINARY_PARSER parser( altiumLibFile, footprintData );
 
    parser.ReadAndSetSubrecordLength();
    //wxString footprintName = parser.ReadWxString(); // Not used (single-byte char set)
    parser.SkipSubrecord();
 
    LIB_ID fpID = AltiumToKiCadLibID( "", aFootprintName ); // TODO: library name
    footprint->SetFPID( fpID );
 
    const std::vector<std::string>  parametersStreamName{ fpDirName.ToStdString(), "Parameters" };
    const CFB::COMPOUND_FILE_ENTRY* parametersData = altiumLibFile.FindStream( footprintStream, { "Parameters" } );
 
    if( parametersData != nullptr )
    {
        ALTIUM_BINARY_PARSER         parametersReader( altiumLibFile, parametersData );
        std::map<wxString, wxString> parameterProperties = parametersReader.ReadProperties();
        wxString description = ALTIUM_PROPS_UTILS::ReadString( parameterProperties, wxT( "DESCRIPTION" ), wxT( "" ) );
        footprint->SetLibDescription( description );
    }
    else
    {
        if( m_reporter )
        {
            m_reporter->Report( wxString::Format( _( "File not found: '%s'." ), FormatPath( parametersStreamName ) ),
                                RPT_SEVERITY_ERROR );
        }
 
        footprint->SetLibDescription( wxT( "" ) );
    }
 
    const std::vector<std::string> extendedPrimitiveInformationStreamName{
        "ExtendedPrimitiveInformation", "Data"
    };
    const CFB::COMPOUND_FILE_ENTRY* extendedPrimitiveInformationData =
            altiumLibFile.FindStream( footprintStream, extendedPrimitiveInformationStreamName );
 
    if( extendedPrimitiveInformationData != nullptr )
        ParseExtendedPrimitiveInformationData( altiumLibFile, extendedPrimitiveInformationData );
 
    footprint->SetReference( wxT( "REF**" ) );
    footprint->SetValue( aFootprintName );
    footprint->Reference().SetVisible( true ); // TODO: extract visibility information
    footprint->Value().SetVisible( true );
 
    const VECTOR2I defaultTextSize( pcbIUScale.mmToIU( 1.0 ), pcbIUScale.mmToIU( 1.0 ) );
    const int      defaultTextThickness( pcbIUScale.mmToIU( 0.15 ) );
 
    for( PCB_FIELD* field : footprint->GetFields() )
    {
        field->SetTextSize( defaultTextSize );
        field->SetTextThickness( defaultTextThickness );
    }
 
    // Multi-layer records expand to every copper layer here, so only a record's own layer counts
    LSET drawnCopper;
 
    auto noteLayer =
            [&]( ALTIUM_LAYER aLayer )
            {
                PCB_LAYER_ID klayer = GetKicadLayer( aLayer );
 
                if( IsCopperLayer( klayer ) )
                    drawnCopper.set( klayer );
            };
 
    for( int primitiveIndex = 0; parser.GetRemainingBytes() >= 4; primitiveIndex++ )
    {
        ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( parser.Peek<uint8_t>() );
 
        switch( recordtype )
        {
        case ALTIUM_RECORD::ARC:
        {
            AARC6 arc( parser );
            noteLayer( arc.layer );
            ConvertArcs6ToFootprintItem( footprint.get(), arc, primitiveIndex, false );
            break;
        }
        case ALTIUM_RECORD::PAD:
        {
            APAD6 pad( parser );
            noteLayer( pad.layer );
            ConvertPads6ToFootprintItem( footprint.get(), pad );
            break;
        }
        case ALTIUM_RECORD::VIA:
        {
            AVIA6 via( parser );
            noteLayer( via.layer_start );
            noteLayer( via.layer_end );
            ConvertVias6ToFootprintItem( footprint.get(), via );
            break;
        }
        case ALTIUM_RECORD::TRACK:
        {
            ATRACK6 track( parser );
            noteLayer( track.layer );
            ConvertTracks6ToFootprintItem( footprint.get(), track, primitiveIndex, false );
            break;
        }
        case ALTIUM_RECORD::TEXT:
        {
            ATEXT6 text( parser, m_unicodeStrings );
            noteLayer( text.layer );
            ConvertTexts6ToFootprintItem( footprint.get(), text );
            break;
        }
        case ALTIUM_RECORD::FILL:
        {
            AFILL6 fill( parser );
            noteLayer( fill.layer );
            ConvertFills6ToFootprintItem( footprint.get(), fill, false );
            break;
        }
        case ALTIUM_RECORD::REGION:
        {
            AREGION6 region( parser, false );
            noteLayer( region.layer );
 
            if( region.kind == ALTIUM_REGION_KIND::COPPER && region.polygon == ALTIUM_POLYGON_NONE
                && !region.is_keepout )
            {
                ConvertShapeBasedRegions6ToFootprintCopper( footprint.get(), region, primitiveIndex,
                                                            ALTIUM_NET_UNCONNECTED );
            }
            else
            {
                ConvertShapeBasedRegions6ToFootprintItem( footprint.get(), region, primitiveIndex );
            }
 
            break;
        }
        case ALTIUM_RECORD::MODEL:
        {
            ACOMPONENTBODY6 componentBody( parser );
            ConvertComponentBody6ToFootprintItem( altiumLibFile, footprint.get(), componentBody );
            break;
        }
        default:
            THROW_IO_ERRORF( _( "Record of unknown type: '%d'." ), recordtype );
        }
    }
 
 
    // Altium splits a custom-shape pad into a numbered placeholder and an unnumbered region outline
    // fold the region whose outline contains the placeholder anchor; others pass through unchanged
    auto isRegionPad =
            []( PAD* aPad )
            {
                if( !aPad->GetNumber().IsEmpty() )
                    return false;
 
                for( PCB_LAYER_ID layer : { PADSTACK::ALL_LAYERS, F_Cu, B_Cu } )
                {
                    if( aPad->GetShape( layer ) == PAD_SHAPE::CUSTOM
                        && !aPad->GetPrimitives( layer ).empty() )
                    {
                        return true;
                    }
                }
 
                return false;
            };
 
    auto commonCopperLayer =
            []( PAD* aRegionPad, PAD* aNamedPad ) -> PCB_LAYER_ID
            {
                if( aRegionPad->IsOnLayer( F_Cu ) && aNamedPad->IsOnLayer( F_Cu ) )
                    return F_Cu;
 
                if( aRegionPad->IsOnLayer( B_Cu ) && aNamedPad->IsOnLayer( B_Cu ) )
                    return B_Cu;
 
                return PADSTACK::ALL_LAYERS;
            };
 
    const int  maxError = m_board ? m_board->GetDesignSettings().m_MaxError : ARC_HIGH_DEF;
    const LSET stackupCopper = altiumStackupCopper( drawnCopper, 2 );
 
    auto mergeRegionPadInto =
            [&]( PAD* aNamedPad, PAD* aRegionPad )
            {
                PCB_LAYER_ID layer = commonCopperLayer( aRegionPad, aNamedPad );
 
                // A NORMAL padstack shares one shape, so a through pad would grow on every layer
                altiumIsolatePadLayer( aNamedPad, layer, stackupCopper );
                altiumMakePadLayerCustom( aNamedPad, layer, maxError );
 
                // Region primitives are in the region pad's local frame; re-express in the named
                // pad's frame, undoing the orientation GetEffectivePolygon will later re-apply
                EDA_ANGLE namedAngle = aNamedPad->GetOrientation();
                VECTOR2I  anchorShift = aRegionPad->ShapePos( PADSTACK::ALL_LAYERS )
                                        - aNamedPad->ShapePos( layer );
 
                for( const std::shared_ptr<PCB_SHAPE>& src : aRegionPad->GetPrimitives( layer ) )
                {
                    PCB_SHAPE* copy = static_cast<PCB_SHAPE*>( src->Clone() );
 
                    copy->Rotate( VECTOR2I( 0, 0 ), aRegionPad->GetOrientation() );
                    copy->Move( anchorShift );
                    copy->Rotate( VECTOR2I( 0, 0 ), -namedAngle );
 
                    aNamedPad->AddPrimitive( layer, copy );
                }
 
                if( aRegionPad->GetLocalSolderMaskMargin().has_value()
                    && !aNamedPad->GetLocalSolderMaskMargin().has_value() )
                {
                    aNamedPad->SetLocalSolderMaskMargin(
                            aRegionPad->GetLocalSolderMaskMargin().value() );
                }
 
                if( aRegionPad->GetLocalSolderPasteMargin().has_value()
                    && !aNamedPad->GetLocalSolderPasteMargin().has_value() )
                {
                    aNamedPad->SetLocalSolderPasteMargin(
                            aRegionPad->GetLocalSolderPasteMargin().value() );
                }
 
                aNamedPad->SetLayerSet( aNamedPad->GetLayerSet() | aRegionPad->GetLayerSet() );
            };
 
    std::vector<PAD*> regionPads;
    std::vector<PAD*> namedPads;
 
    for( PAD* pad : footprint->Pads() )
    {
        if( isRegionPad( pad ) )
            regionPads.push_back( pad );
        else if( !pad->GetNumber().IsEmpty() )
            namedPads.push_back( pad );
    }
 
    // A placeholder pad owns at most one region outline; consume matched pads so a second region
    // never folds into a pad whose shape already grew from an earlier merge
    std::unordered_set<PAD*> consumedNamed;
 
    for( PAD* regionPad : regionPads )
    {
        PCB_LAYER_ID regionCu = regionPad->IsOnLayer( F_Cu )    ? F_Cu
                                : regionPad->IsOnLayer( B_Cu )  ? B_Cu
                                                                : PADSTACK::ALL_LAYERS;
 
        std::shared_ptr<SHAPE_POLY_SET> outline =
                regionPad->GetEffectivePolygon( regionCu, ERROR_INSIDE );
 
        if( !outline || outline->OutlineCount() == 0 )
            continue;
 
        // Claim the closest numbered pad sharing a copper layer whose anchor sits inside the outline
        // containment is the signal it's the Altium placeholder for this region, not an overlap
        PAD*    bestNamed = nullptr;
        int64_t bestDistSq = std::numeric_limits<int64_t>::max();
 
        for( PAD* namedPad : namedPads )
        {
            if( consumedNamed.count( namedPad ) )
                continue;
 
            if( commonCopperLayer( regionPad, namedPad ) == PADSTACK::ALL_LAYERS
                && !( namedPad->GetLayerSet() & regionPad->GetLayerSet() & LSET::AllCuMask() ).any() )
            {
                continue;
            }
 
            if( !outline->Contains( namedPad->GetPosition(), -1, 0 ) )
                continue;
 
            VECTOR2I delta = namedPad->GetPosition() - regionPad->GetPosition();
            int64_t  distSq = (int64_t) delta.x * delta.x + (int64_t) delta.y * delta.y;
 
            if( distSq < bestDistSq )
            {
                bestDistSq = distSq;
                bestNamed = namedPad;
            }
        }
 
        if( bestNamed )
        {
            mergeRegionPadInto( bestNamed, regionPad );
            consumedNamed.insert( bestNamed );
            footprint->Remove( regionPad );
            delete regionPad;
        }
    }
 
    std::set<PAD*> extensionPads;
 
    // Loop over this multiple times to catch pads that are jumpered to each other by multiple shapes
    for( bool changes = true; changes; )
    {
        changes = HelperFoldPendingCopper( stackupCopper, maxError, extensionPads );
 
        alg::for_all_pairs( footprint->Pads().begin(), footprint->Pads().end(),
                [&changes]( PAD* aPad1, PAD* aPad2 )
                {
                    if( !( aPad1->GetNumber().IsEmpty() ^ aPad2->GetNumber().IsEmpty() ) )
                        return;
 
                    // A pad answers for layers it lacks with its own shape, and masks carry no current
                    const LSET sharedCopper = aPad1->GetLayerSet() & aPad2->GetLayerSet() & LSET::AllCuMask();
 
                    for( PCB_LAYER_ID layer : sharedCopper )
                    {
                        std::shared_ptr<SHAPE> shape1 = aPad1->GetEffectiveShape( layer );
                        std::shared_ptr<SHAPE> shape2 = aPad2->GetEffectiveShape( layer );
 
                        if( shape1->Collide( shape2.get() ) )
                        {
                            if( aPad1->GetNumber().IsEmpty() )
                                aPad1->SetNumber( aPad2->GetNumber() );
                            else
                                aPad2->SetNumber( aPad1->GetNumber() );
 
                            changes = true;
                        }
                    }
                } );
    }
 
    HelperPlaceUnfoldedCopper();
 
    // Auto-position reference and value
    footprint->AutoPositionFields();
 
    // Altium has no mounting style to copy, so derive it from the pads using the same heuristic
    // as KiCad's footprint checker.  Unlike the board importer this can be done here, because a
    // library footprint's pads are converted inline above.
    footprint->SetAttributes( footprint->GetAttributes() | footprint->GetLikelyAttribute() );
 
    altiumSetFootprintStackup( footprint.get(), drawnCopper, 2 );
 
    if( parser.HasParsingError() )
        THROW_IO_ERRORF( wxT( "%s stream was not parsed correctly" ), FormatPath( streamName ) );
 
    if( parser.GetRemainingBytes() != 0 )
        THROW_IO_ERRORF( wxT( "%s stream is not fully parsed" ), FormatPath( streamName ) );
 
    return footprint;
}
 
int ALTIUM_PCB::GetNetCode( uint16_t aId ) const
{
    if( aId == ALTIUM_NET_UNCONNECTED )
    {
        return NETINFO_LIST::UNCONNECTED;
    }
    else if( aId >= m_altiumToKicadNetcodes.size() )
    {
        THROW_IO_ERRORF( wxT( "Netcode with id %d does not exist. Only %zu nets are known" ),
                         aId, m_altiumToKicadNetcodes.size() );
    }
    else
    {
        return m_altiumToKicadNetcodes[ aId ];
    }
}
 
const ARULE6* ALTIUM_PCB::GetRule( ALTIUM_RULE_KIND aKind, const wxString& aName ) const
{
    const auto rules = m_rules.find( aKind );
 
    if( rules == m_rules.end() )
        return nullptr;
 
    for( const ARULE6& rule : rules->second )
    {
        if( rule.enabled && rule.name == aName )
            return &rule;
    }
 
    return nullptr;
}
 
const ARULE6* ALTIUM_PCB::GetRuleDefault( ALTIUM_RULE_KIND aKind ) const
{
    const auto rules = m_rules.find( aKind );
 
    if( rules == m_rules.end() )
        return nullptr;
 
    for( const ARULE6& rule : rules->second )
    {
        if( rule.enabled && IsAltiumScopeAll( rule.scope1expr ) && IsAltiumScopeAll( rule.scope2expr ) )
            return &rule;
    }
 
    return nullptr;
}
 
 
const ARULE6* ALTIUM_PCB::GetRuleForPolygon( ALTIUM_RULE_KIND aKind ) const
{
    const auto rules = m_rules.find( aKind );
 
    if( rules == m_rules.end() )
        return nullptr;
 
    if( const ARULE6* match = selectAltiumPolygonRule( rules->second ) )
        return match;
 
    // Fall back to the default (All/All) rule
    return GetRuleDefault( aKind );
}
 
 
void ALTIUM_PCB::ParseFileHeader( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                  const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    reader.ReadAndSetSubrecordLength();
    wxString header = reader.ReadWxString();
 
    //std::cout << "HEADER: " << header << std::endl;  // tells me: PCB 5.0 Binary File
 
    //reader.SkipSubrecord();
 
    // TODO: does not seem to work all the time at the moment
    //if( reader.GetRemainingBytes() != 0 )
    //    THROW_IO_ERROR( "FileHeader stream is not fully parsed" );
}
 
 
void ALTIUM_PCB::ParseExtendedPrimitiveInformationData( const ALTIUM_PCB_COMPOUND_FILE& aAltiumPcbFile,
                                                        const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading extended primitive information data..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        AEXTENDED_PRIMITIVE_INFORMATION elem( reader );
 
        m_extendedPrimitiveInformationMaps[elem.primitiveObjectId].emplace( elem.primitiveIndex,
                                                                            std::move( elem ) );
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "ExtendedPrimitiveInformation stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ParseBoard6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                  const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading board data..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    checkpoint();
    ABOARD6 elem( reader );
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Board6 stream is not fully parsed" ) );
 
    m_board->GetDesignSettings().SetAuxOrigin( elem.origin );
    m_board->GetDesignSettings().SetGridOrigin( elem.origin );
 
    // read layercount from stackup, because LAYERSETSCOUNT is not always correct?!
    size_t layercount = 0;
    size_t layerid = static_cast<size_t>( ALTIUM_LAYER::TOP_LAYER );
 
    while( layerid < elem.stackup.size() && layerid != 0 )
    {
        layerid = elem.stackup[ layerid - 1 ].nextId;
        layercount++;
    }
 
    size_t kicadLayercount = ( layercount % 2 == 0 ) ? layercount : layercount + 1;
    m_board->SetCopperLayerCount( kicadLayercount );
 
    BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
    BOARD_STACKUP&         stackup        = designSettings.GetStackupDescriptor();
 
    // create board stackup
    stackup.RemoveAll(); // Just to be sure
    stackup.BuildDefaultStackupList( &designSettings, layercount );
 
    auto it = stackup.GetList().begin();
 
    // find first copper layer
    for( ; it != stackup.GetList().end() && ( *it )->GetType() != BS_ITEM_TYPE_COPPER; ++it )
        ;
 
    auto cuLayer = LAYER_RANGE( F_Cu, B_Cu, 32 ).begin();
 
    for( size_t altiumLayerId = static_cast<size_t>( ALTIUM_LAYER::TOP_LAYER );
            altiumLayerId < elem.stackup.size() && altiumLayerId != 0;
            altiumLayerId = elem.stackup[altiumLayerId - 1].nextId )
    {
        // array starts with 0, but stackup with 1
        ABOARD6_LAYER_STACKUP& layer = elem.stackup.at( altiumLayerId - 1 );
 
        // handle unused layer in case of odd layercount
        if( layer.nextId == 0 && layercount != kicadLayercount )
        {
            m_board->SetLayerName( ( *it )->GetBrdLayerId(), wxT( "[unused]" ) );
 
            if( ( *it )->GetType() != BS_ITEM_TYPE_COPPER )
                THROW_IO_ERROR( wxT( "Board6 stream, unexpected item while parsing stackup" ) );
 
            ( *it )->SetThickness( 0 );
 
            ++it;
 
            if( ( *it )->GetType() != BS_ITEM_TYPE_DIELECTRIC )
                THROW_IO_ERROR( wxT( "Board6 stream, unexpected item while parsing stackup" ) );
 
            ( *it )->SetThickness( 0, 0 );
            ( *it )->SetThicknessLocked( true, 0 );
            ++it;
        }
 
        m_layermap.insert( { static_cast<ALTIUM_LAYER>( altiumLayerId ), *cuLayer } );
        ++cuLayer;
 
        if( ( *it )->GetType() != BS_ITEM_TYPE_COPPER )
            THROW_IO_ERROR( wxT( "Board6 stream, unexpected item while parsing stackup" ) );
 
        ( *it )->SetThickness( layer.copperthick );
 
        ALTIUM_LAYER alayer = static_cast<ALTIUM_LAYER>( altiumLayerId );
        PCB_LAYER_ID klayer = ( *it )->GetBrdLayerId();
 
        m_board->SetLayerName( klayer, layer.name );
 
        if( layer.copperthick == 0 )
            m_board->SetLayerType( klayer, LAYER_T::LT_JUMPER ); // used for things like wirebonding
        else if( IsAltiumLayerAPlane( alayer ) )
            m_board->SetLayerType( klayer, LAYER_T::LT_POWER );
 
        if( klayer == B_Cu )
        {
            if( layer.nextId != 0 )
                THROW_IO_ERROR( wxT( "Board6 stream, unexpected id while parsing last stackup layer" ) );
 
            // overwrite entry from internal -> bottom
            m_layermap[alayer] = B_Cu;
            break;
        }
 
        ++it;
 
        if( ( *it )->GetType() != BS_ITEM_TYPE_DIELECTRIC )
            THROW_IO_ERROR( wxT( "Board6 stream, unexpected item while parsing stackup" ) );
 
        ( *it )->SetThickness( layer.dielectricthick, 0 );
        ( *it )->SetMaterial( layer.dielectricmaterial.empty() ? NotSpecifiedPrm()
                                                               : wxString( layer.dielectricmaterial ) );
        ( *it )->SetEpsilonR( layer.dielectricconst, 0 );
 
        if( layer.dielectriclosstangent > 0. )
            ( *it )->SetLossTangent( layer.dielectriclosstangent, 0 );
 
        ++it;
    }
 
    HelperShapeLineChainFromAltiumVertices( m_boardOutline, elem.board_vertices );
    HelperFillMechanicalLayerAssignments( elem.stackup );
    remapUnsureLayers( elem.stackup );
 
    // Set name of all non-cu layers
    for( const ABOARD6_LAYER_STACKUP& layer : elem.stackup )
    {
        ALTIUM_LAYER alayer = static_cast<ALTIUM_LAYER>( layer.layerId );
 
        if( ( alayer >= ALTIUM_LAYER::TOP_OVERLAY && alayer <= ALTIUM_LAYER::BOTTOM_SOLDER )
            || ( alayer >= ALTIUM_LAYER::MECHANICAL_1 && alayer <= ALTIUM_LAYER::MECHANICAL_16 )
            || ( alayer >= ALTIUM_LAYER::V7_MECHANICAL_17 && alayer <= ALTIUM_LAYER::V7_MECHANICAL_LAST ) )
        {
            PCB_LAYER_ID klayer = GetKicadLayer( alayer );
            m_board->SetLayerName( klayer, layer.name );
        }
    }
 
    if( elem.discardedVertices > 0 && m_reporter )
    {
        m_reporter->Report( wxString::Format( _( "Board outline has %d vertices outside the "
                                                 "coordinate range; they were dropped." ),
                                              elem.discardedVertices ),
                            RPT_SEVERITY_ERROR );
    }
 
    HelperBuildPadstackLayerIndex();
    m_board->GetDesignSettings().SetBoardThickness( stackup.BuildBoardThicknessFromStackup() );
    designSettings.m_HasStackup = true;
}
 
 
void ALTIUM_PCB::HelperBuildPadstackLayerIndex()
{
    m_padstackLayerIndex.clear();
 
    for( const auto& [altiumLayer, kicadLayer] : m_layermap )
    {
        if( altiumLayer < ALTIUM_LAYER::TOP_LAYER || altiumLayer > ALTIUM_LAYER::BOTTOM_LAYER )
            continue;
 
        if( IsCopperLayer( kicadLayer ) )
        {
            m_padstackLayerIndex[kicadLayer] = static_cast<int>( altiumLayer )
                                               - static_cast<int>( ALTIUM_LAYER::TOP_LAYER );
        }
    }
}
 
 
int ALTIUM_PCB::HelperGetPadstackLayerIndex( PCB_LAYER_ID aLayer ) const
{
    // Footprint libraries carry no stackup, so Altium's mid layer N is KiCad's In N
    if( m_padstackLayerIndex.empty() )
    {
        size_t ordinal = CopperLayerToOrdinal( aLayer );
 
        return ordinal < ALTIUM_PADSTACK_IDX_COUNT ? static_cast<int>( ordinal ) : -1;
    }
 
    auto it = m_padstackLayerIndex.find( aLayer );
 
    return it == m_padstackLayerIndex.end() ? -1 : it->second;
}
 
 
// Helper to detect if a layer name indicates a courtyard layer
static bool IsLayerNameCourtyard( const wxString& aName )
{
    wxString nameLower = aName.Lower();
    return nameLower.Contains( wxT( "courtyard" ) ) || nameLower.Contains( wxT( "court yard" ) )
           || nameLower.Contains( wxT( "crtyd" ) );
}
 
 
// Helper to detect if a layer name indicates an assembly layer
static bool IsLayerNameAssembly( const wxString& aName )
{
    wxString nameLower = aName.Lower();
    return nameLower.Contains( wxT( "assembly" ) ) || nameLower.Contains( wxT( "assy" ) );
}
 
 
// Helper to detect if a layer name indicates a top-side layer
static bool IsLayerNameTopSide( const wxString& aName )
{
    bool isTop = false;
 
    auto check = [&isTop]( bool aTopCond, bool aBotCond )
    {
        if( aTopCond && aBotCond )
            return false;
 
        if( !aTopCond && !aBotCond )
            return false;
 
        isTop = aTopCond;
        return true;
    };
 
    wxString lower = aName.Lower();
 
    if( check( lower.StartsWith( "top" ), lower.StartsWith( "bot" ) ) )
        return isTop;
 
    if( check( lower.EndsWith( "_t" ), lower.EndsWith( "_b" ) ) )
        return isTop;
 
    if( check( lower.EndsWith( ".t" ), lower.EndsWith( ".b" ) ) )
        return isTop;
 
    if( check( lower.Contains( "top" ), lower.Contains( "bot" ) ) )
        return isTop;
 
    return true; // Unknown
}
 
 
void ALTIUM_PCB::remapUnsureLayers( std::vector<ABOARD6_LAYER_STACKUP>& aStackup )
{
    LSET enabledLayers        = m_board->GetEnabledLayers();
    LSET validRemappingLayers = enabledLayers    | LSET::AllBoardTechMask() |
                                LSET::UserMask() | LSET::UserDefinedLayersMask();
 
    if( aStackup.size() == 0 )
        return;
 
    std::vector<INPUT_LAYER_DESC> inputLayers;
    std::map<wxString, ALTIUM_LAYER>  altiumLayerNameMap;
 
    ABOARD6_LAYER_STACKUP& curLayer = aStackup[0];
    ALTIUM_LAYER           layer_num;
    INPUT_LAYER_DESC       iLdesc;
 
    // Track which courtyard layers we've mapped to avoid duplicates
    bool frontCourtyardMapped = false;
    bool backCourtyardMapped = false;
 
    for( size_t ii = 0; ii < aStackup.size(); ii++ )
    {
        curLayer = aStackup[ii];
        layer_num = static_cast<ALTIUM_LAYER>( curLayer.layerId );
 
        // Skip UI-only layers and pseudo-layers that have no physical representation
        if( layer_num == ALTIUM_LAYER::MULTI_LAYER
            || layer_num == ALTIUM_LAYER::CONNECTIONS
            || layer_num == ALTIUM_LAYER::BACKGROUND
            || layer_num == ALTIUM_LAYER::DRC_ERROR_MARKERS
            || layer_num == ALTIUM_LAYER::SELECTIONS
            || layer_num == ALTIUM_LAYER::VISIBLE_GRID_1
            || layer_num == ALTIUM_LAYER::VISIBLE_GRID_2
            || layer_num == ALTIUM_LAYER::PAD_HOLES
            || layer_num == ALTIUM_LAYER::VIA_HOLES )
        {
            continue;
        }
 
        // Skip disabled mechanical layers (mapped to UNDEFINED_LAYER by
        // HelperFillMechanicalLayerAssignments)
        auto existingMapping = m_layermap.find( layer_num );
 
        if( existingMapping != m_layermap.end()
            && existingMapping->second == PCB_LAYER_ID::UNDEFINED_LAYER )
        {
            continue;
        }
 
        // Skip unused copper layers not present in the board's stackup. Used copper layers
        // were added to m_layermap during stackup parsing; any copper layer not in the map
        // is unused and should not appear in the dialog.
        if( ( ( layer_num >= ALTIUM_LAYER::TOP_LAYER && layer_num <= ALTIUM_LAYER::BOTTOM_LAYER )
              || IsAltiumLayerAPlane( layer_num ) )
            && existingMapping == m_layermap.end() )
        {
            continue;
        }
 
        // Use existing mapping as auto-match default if available
        if( existingMapping != m_layermap.end() )
        {
            iLdesc.AutoMapLayer = existingMapping->second;
        }
        // Check if the layer name indicates a courtyard layer
        else if( IsLayerNameCourtyard( curLayer.name ) )
        {
            bool isTopSide = IsLayerNameTopSide( curLayer.name );
 
            if( isTopSide && !frontCourtyardMapped )
            {
                iLdesc.AutoMapLayer = F_CrtYd;
                frontCourtyardMapped = true;
            }
            else if( !isTopSide && !backCourtyardMapped )
            {
                iLdesc.AutoMapLayer = B_CrtYd;
                backCourtyardMapped = true;
            }
            else if( !frontCourtyardMapped )
            {
                iLdesc.AutoMapLayer = F_CrtYd;
                frontCourtyardMapped = true;
            }
            else if( !backCourtyardMapped )
            {
                iLdesc.AutoMapLayer = B_CrtYd;
                backCourtyardMapped = true;
            }
            else
            {
                iLdesc.AutoMapLayer = GetKicadLayer( layer_num );
            }
        }
        // Check if the layer name indicates an assembly layer (map to Fab)
        else if( IsLayerNameAssembly( curLayer.name ) )
        {
            bool isTopSide = IsLayerNameTopSide( curLayer.name );
            iLdesc.AutoMapLayer = isTopSide ? F_Fab : B_Fab;
        }
        else
        {
            iLdesc.AutoMapLayer = GetKicadLayer( layer_num );
        }
 
        iLdesc.Name            = curLayer.name;
        iLdesc.PermittedLayers = validRemappingLayers;
        iLdesc.Required        = layer_num >= ALTIUM_LAYER::TOP_LAYER
                                 && layer_num <= ALTIUM_LAYER::BOTTOM_LAYER;
 
        inputLayers.push_back( iLdesc );
        altiumLayerNameMap.insert( { curLayer.name, layer_num } );
        m_layerNames.insert( { layer_num, curLayer.name } );
    }
 
    if( inputLayers.size() == 0 )
        return;
 
    // Callback:
    std::map<wxString, PCB_LAYER_ID> reMappedLayers = m_layerMappingHandler( inputLayers );
 
    for( std::pair<wxString, PCB_LAYER_ID> layerPair : reMappedLayers )
    {
        if( layerPair.second == PCB_LAYER_ID::UNDEFINED_LAYER )
        {
            // Layer mapping handler returned UNDEFINED_LAYER - skip this layer
            // This can happen for layers that don't have a KiCad equivalent
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Layer '%s' could not be mapped and "
                                                         "will be skipped." ),
                                                      layerPair.first ),
                                    RPT_SEVERITY_WARNING );
            }
 
            continue;
        }
 
        ALTIUM_LAYER altiumID     = altiumLayerNameMap.at( layerPair.first );
        m_layermap.insert_or_assign( altiumID, layerPair.second );
        enabledLayers |= LSET( { layerPair.second } );
    }
 
    // Explicitly mark unmatched dialog layers as UNDEFINED_LAYER so they are not imported
    // via the GetKicadLayer() hardcoded switch fallthrough
    for( const auto& [name, altLayer] : altiumLayerNameMap )
    {
        if( reMappedLayers.find( name ) == reMappedLayers.end()
            || reMappedLayers.at( name ) == PCB_LAYER_ID::UNDEFINED_LAYER )
        {
            m_layermap.insert_or_assign( altLayer, PCB_LAYER_ID::UNDEFINED_LAYER );
        }
    }
 
    m_board->SetEnabledLayers( enabledLayers );
    m_board->SetVisibleLayers( enabledLayers );
}
 
 
void ALTIUM_PCB::HelperFillMechanicalLayerAssignments( const std::vector<ABOARD6_LAYER_STACKUP>& aStackup )
{
    for( const ABOARD6_LAYER_STACKUP& layer : aStackup )
    {
        ALTIUM_LAYER alayer = static_cast<ALTIUM_LAYER>( layer.layerId );
 
        if( ( alayer >= ALTIUM_LAYER::MECHANICAL_1 && alayer <= ALTIUM_LAYER::MECHANICAL_16 )
            || ( alayer >= ALTIUM_LAYER::V7_MECHANICAL_17 && alayer <= ALTIUM_LAYER::V7_MECHANICAL_LAST ) )
        {
            if( !layer.mechenabled )
            {
                m_layermap.emplace( alayer, UNDEFINED_LAYER ); // Disabled layer, do not import
                continue;
            }
 
            PCB_LAYER_ID target = UNDEFINED_LAYER;
 
            switch( layer.mechkind )
            {
            case ALTIUM_MECHKIND::ASSEMBLY_TOP: target = F_Fab; break;
            case ALTIUM_MECHKIND::ASSEMBLY_BOT: target = B_Fab; break;
 
            case ALTIUM_MECHKIND::COURTYARD_TOP: target = F_CrtYd; break;
            case ALTIUM_MECHKIND::COURTYARD_BOT: target = B_CrtYd; break;
 
            case ALTIUM_MECHKIND::GLUE_POINTS_TOP: target = F_Adhes; break;
            case ALTIUM_MECHKIND::GLUE_POINTS_BOT: target = B_Adhes; break;
 
            case ALTIUM_MECHKIND::ASSEMBLY_NOTES: target = Cmts_User; break;
            case ALTIUM_MECHKIND::FAB_NOTES: target = Cmts_User; break;
 
            case ALTIUM_MECHKIND::DIMENSIONS: target = Dwgs_User; break;
 
            case ALTIUM_MECHKIND::DIMENSIONS_TOP: target = F_Fab; break;
            case ALTIUM_MECHKIND::DIMENSIONS_BOT: target = B_Fab; break;
 
            case ALTIUM_MECHKIND::VALUE_TOP: target = F_Fab; break;
            case ALTIUM_MECHKIND::VALUE_BOT: target = B_Fab; break;
 
            case ALTIUM_MECHKIND::DESIGNATOR_TOP: target = F_Fab; break;
            case ALTIUM_MECHKIND::DESIGNATOR_BOT: target = B_Fab; break;
 
            case ALTIUM_MECHKIND::COMPONENT_OUTLINE_TOP: target = F_Fab; break;
            case ALTIUM_MECHKIND::COMPONENT_OUTLINE_BOT: target = B_Fab; break;
 
            case ALTIUM_MECHKIND::COMPONENT_CENTER_TOP: target = F_Fab; break;
            case ALTIUM_MECHKIND::COMPONENT_CENTER_BOT: target = B_Fab; break;
 
            // The board's own outline is the edge, so a drawing of the board shape would repeat it
            case ALTIUM_MECHKIND::BOARD: target = m_boardOutline.PointCount() >= 3 ? Dwgs_User : Edge_Cuts; break;
            case ALTIUM_MECHKIND::BOARD_SHAPE: target = m_boardOutline.PointCount() >= 3 ? Dwgs_User : Edge_Cuts; break;
            case ALTIUM_MECHKIND::V_CUT: target = Edge_Cuts; break;
 
            default: break;
            }
 
            if( target != UNDEFINED_LAYER )
                m_layermap.emplace( alayer, target );
        }
    }
}
 
 
void ALTIUM_PCB::HelperCreateBoardOutline( const std::vector<ALTIUM_VERTICE>& aVertices )
{
    SHAPE_LINE_CHAIN lineChain;
    HelperShapeLineChainFromAltiumVertices( lineChain, aVertices );
 
    HelperCreateBoardOutline( lineChain );
}
 
 
namespace
{
struct OUTLINE_EDGE
{
    bool      isArc = false;
    SHAPE_ARC arc;
    SEG       seg;
};
 
 
std::vector<OUTLINE_EDGE> OutlineEdgesFromChain( const SHAPE_LINE_CHAIN& aChain )
{
    // vertices that differ by rounding leave edges DRC rejects as degenerate
    const int minEdge = pcbIUScale.mmToIU( 0.001 );
 
    std::vector<OUTLINE_EDGE> edges;
 
    for( int i = 0; i <= aChain.PointCount() && i != -1; i = aChain.NextShape( i ) )
    {
        if( aChain.IsArcStart( i ) )
        {
            edges.push_back( { true, aChain.Arc( aChain.ArcIndex( i ) ), SEG() } );
        }
        else if( aChain.Segment( i ).Length() > minEdge )
        {
            edges.push_back( { false, SHAPE_ARC(), aChain.Segment( i ) } );
        }
    }
 
    return edges;
}
 
 
// A short edge between two longer ones is a jog from rounding in the file. A jog that turns
// back on its neighbours overlaps them, so drop it and let the neighbouring lines meet.
void RemoveOutlineJogs( std::vector<OUTLINE_EDGE>& aEdges, int& aCount, int& aLargestMove )
{
    const int maxJog = pcbIUScale.mmToIU( 0.05 );
 
    // Direction an edge runs in where it starts or where it ends
    auto direction =
            []( const OUTLINE_EDGE& aEdge, bool aAtEnd ) -> VECTOR2I
            {
                if( !aEdge.isArc )
                    return aEdge.seg.B - aEdge.seg.A;
 
                const VECTOR2I radius = ( aAtEnd ? aEdge.arc.GetP1() : aEdge.arc.GetP0() ) - aEdge.arc.GetCenter();
 
                return aEdge.arc.IsClockwise() ? VECTOR2I( radius.y, -radius.x ) : VECTOR2I( -radius.y, radius.x );
            };
 
    for( bool changed = true; changed && aEdges.size() > 3; )
    {
        changed = false;
 
        for( size_t i = 0; i < aEdges.size(); i++ )
        {
            OUTLINE_EDGE& jog = aEdges[i];
            OUTLINE_EDGE& prev = aEdges[( i + aEdges.size() - 1 ) % aEdges.size()];
            OUTLINE_EDGE& next = aEdges[( i + 1 ) % aEdges.size()];
 
            if( jog.isArc || jog.seg.Length() > maxJog || ( prev.isArc && next.isArc ) )
                continue;
 
            if( ( !prev.isArc && prev.seg.Length() <= maxJog ) || ( !next.isArc && next.seg.Length() <= maxJog ) )
                continue;
 
            // Only a jog that doubles back on a neighbour overlaps it, a short chamfer is real geometry
            const VECTOR2I jogDirection = jog.seg.B - jog.seg.A;
 
            if( jogDirection.Dot( direction( prev, true ) ) >= 0 && jogDirection.Dot( direction( next, false ) ) >= 0 )
                continue;
 
            auto nearer = []( const SHAPE_ARC& aArc, const VECTOR2I& aPt )
            {
                return aArc.GetP0().Distance( aPt ) < aArc.GetP1().Distance( aPt ) ? aArc.GetP0() : aArc.GetP1();
            };
 
            VECTOR2I moved;
 
            if( prev.isArc )
            {
                moved = nearer( prev.arc, jog.seg.A );
                aLargestMove = std::max( aLargestMove, static_cast<int>( moved.Distance( next.seg.A ) ) );
                next.seg.A = moved;
            }
            else if( next.isArc )
            {
                moved = nearer( next.arc, jog.seg.B );
                aLargestMove = std::max( aLargestMove, static_cast<int>( moved.Distance( prev.seg.B ) ) );
                prev.seg.B = moved;
            }
            else
            {
                aLargestMove = std::max( aLargestMove, static_cast<int>( prev.seg.B.Distance( next.seg.A ) ) );
                next.seg.A = prev.seg.B;
            }
 
            aCount++;
 
            aEdges.erase( aEdges.begin() + i );
            changed = true;
            break;
        }
    }
}
 
 
void AddOutlineEdges( BOARD& aBoard, const std::vector<OUTLINE_EDGE>& aEdges )
{
    STROKE_PARAMS stroke( aBoard.GetDesignSettings().GetLineThickness( Edge_Cuts ), LINE_STYLE::SOLID );
 
    for( const OUTLINE_EDGE& edge : aEdges )
    {
        std::unique_ptr<PCB_SHAPE> shape;
 
        if( edge.isArc )
        {
            shape = std::make_unique<PCB_SHAPE>( &aBoard, SHAPE_T::ARC );
            shape->SetArcGeometry( edge.arc.GetP0(), edge.arc.GetArcMid(), edge.arc.GetP1() );
        }
        else
        {
            shape = std::make_unique<PCB_SHAPE>( &aBoard, SHAPE_T::SEGMENT );
            shape->SetStart( edge.seg.A );
            shape->SetEnd( edge.seg.B );
        }
 
        shape->SetStroke( stroke );
        shape->SetLayer( Edge_Cuts );
 
        aBoard.Add( shape.release(), ADD_MODE::APPEND );
    }
}
 
 
// How far along an edge a point on it lies, 0 at its start and 1 at its end
double FractionAlongEdge( const OUTLINE_EDGE& aEdge, const VECTOR2I& aPt )
{
    if( !aEdge.isArc )
    {
        VECTOR2D along = aEdge.seg.B - aEdge.seg.A;
        return VECTOR2D( aPt - aEdge.seg.A ).Dot( along ) / along.SquaredEuclideanNorm();
    }
 
    const VECTOR2I  centre = aEdge.arc.GetCenter();
    const EDA_ANGLE sweep = aEdge.arc.GetCentralAngle();
    EDA_ANGLE       turned = EDA_ANGLE( aPt - centre ) - EDA_ANGLE( aEdge.arc.GetP0() - centre );
 
    if( sweep.AsDegrees() < 0 )
        turned = -turned;
 
    turned.Normalize();
    return turned.AsDegrees() / std::abs( sweep.AsDegrees() );
}
 
 
VECTOR2I PointAlongEdge( const OUTLINE_EDGE& aEdge, double aFraction )
{
    if( aFraction <= 0 )
        return aEdge.isArc ? aEdge.arc.GetP0() : aEdge.seg.A;
 
    if( aFraction >= 1 )
        return aEdge.isArc ? aEdge.arc.GetP1() : aEdge.seg.B;
 
    if( !aEdge.isArc )
        return aEdge.seg.A + KiROUND( VECTOR2D( aEdge.seg.B - aEdge.seg.A ) * aFraction );
 
    VECTOR2I pt = aEdge.arc.GetP0();
    RotatePoint( pt, aEdge.arc.GetCenter(), -aEdge.arc.GetCentralAngle() * aFraction );
    return pt;
}
 
 
// An edge is part of the outline only where there is board on one side of it and none on the other
bool BoundsMaterial( const OUTLINE_EDGE& aEdge, double aFraction, const SHAPE_POLY_SET& aMaterial )
{
    const double probe = pcbIUScale.mmToIU( 0.05 );
    VECTOR2I     pt = PointAlongEdge( aEdge, aFraction );
    VECTOR2D     normal;
 
    if( aEdge.isArc )
        normal = VECTOR2D( pt - aEdge.arc.GetCenter() ).Resize( 1.0 );
    else
        normal = VECTOR2D( aEdge.seg.B - aEdge.seg.A ).Perpendicular().Resize( 1.0 );
 
    bool left = aMaterial.Contains( pt + KiROUND( normal * probe ) );
    bool right = aMaterial.Contains( pt - KiROUND( normal * probe ) );
 
    return left != right;
}
 
 
// The parts of the edges that lie inside, or outside, the region; a part on a cutter is kept only where it
// bounds aMaterial
std::vector<OUTLINE_EDGE> ClipOutlineEdges( const std::vector<OUTLINE_EDGE>&             aEdges,
                                            const std::vector<const SHAPE_LINE_CHAIN*>& aCutters,
                                            const SHAPE_POLY_SET& aRegion, bool aKeepInside,
                                            const SHAPE_POLY_SET* aMaterial )
{
    const int                 onCutter = pcbIUScale.mmToIU( 0.005 );
    std::vector<OUTLINE_EDGE> kept;
 
    for( const OUTLINE_EDGE& edge : aEdges )
    {
        // Distance to the lines of a cutter, since the inside of a closed chain is at distance zero
        auto nearCutter =
                [&]( const VECTOR2I& aPt )
                {
                    for( const SHAPE_LINE_CHAIN* cutter : aCutters )
                    {
                        if( cutter->SquaredDistance( aPt, true ) <= SEG::Square( onCutter ) )
                            return true;
                    }
 
                    return false;
                };
 
        SHAPE_LINE_CHAIN chain;
 
        if( edge.isArc )
        {
            chain.Append( edge.arc );
        }
        else
        {
            chain.Append( edge.seg.A );
            chain.Append( edge.seg.B );
        }
 
        std::vector<double> cuts = { 0.0, 1.0 };
 
        for( const SHAPE_LINE_CHAIN* cutter : aCutters )
        {
            std::vector<SHAPE_LINE_CHAIN::INTERSECTION> crossings;
            chain.Intersect( *cutter, crossings );
 
            for( const SHAPE_LINE_CHAIN::INTERSECTION& crossing : crossings )
                cuts.push_back( std::clamp( FractionAlongEdge( edge, crossing.p ), 0.0, 1.0 ) );
        }
 
        std::sort( cuts.begin(), cuts.end() );
 
        // A vertex both chains share is reported twice, and a zero-length piece has no side
        cuts.erase( std::unique( cuts.begin(), cuts.end(),
                                 [&]( double aLeft, double aRight )
                                 {
                                     return PointAlongEdge( edge, aLeft ) == PointAlongEdge( edge, aRight );
                                 } ),
                    cuts.end() );
 
        enum class SIDE { KEEP, DROP, UNSURE };
 
        auto subEdge =
                [&]( double aFrom, double aTo )
                {
                    if( aFrom <= 0.0 && aTo >= 1.0 )
                        return edge;
 
                    OUTLINE_EDGE piece = edge;
                    VECTOR2I     start = PointAlongEdge( edge, aFrom );
                    VECTOR2I     end = PointAlongEdge( edge, aTo );
 
                    if( edge.isArc )
                        piece.arc = SHAPE_ARC( start, PointAlongEdge( edge, ( aFrom + aTo ) / 2 ), end, 0 );
                    else
                        piece.seg = SEG( start, end );
 
                    return piece;
                };
 
        auto classify =
                [&]( size_t aPiece )
                {
                    OUTLINE_EDGE piece = subEdge( cuts[aPiece], cuts[aPiece + 1] );
                    VECTOR2I     mid = PointAlongEdge( edge, ( cuts[aPiece] + cuts[aPiece + 1] ) / 2 );
                    bool         keep = nearCutter( mid ) ? aMaterial && BoundsMaterial( piece, 0.5, *aMaterial )
                                                          : aRegion.Contains( mid ) == aKeepInside;
 
                    return keep ? SIDE::KEEP : SIDE::DROP;
                };
 
        auto span =
                [&]( size_t aFrom, size_t aTo )
                {
                    return PointAlongEdge( edge, cuts[aFrom] ).Distance( PointAlongEdge( edge, cuts[aTo] ) );
                };
 
        std::vector<SIDE> sides;
 
        // Pieces within the cutter tolerance cannot be classified reliably, so they are settled by run below
        for( size_t i = 0; i + 1 < cuts.size(); i++ )
            sides.push_back( span( i, i + 1 ) <= onCutter ? SIDE::UNSURE : classify( i ) );
 
        for( size_t i = 0; i < sides.size(); )
        {
            if( sides[i] != SIDE::UNSURE )
            {
                i++;
                continue;
            }
 
            size_t j = i;
 
            while( j < sides.size() && sides[j] == SIDE::UNSURE )
                j++;
 
            bool hasNeighbour = i > 0 || j < sides.size();
 
            // A short run joins a kept neighbour, while a long run of short pieces is still a real span
            if( hasNeighbour && span( i, j ) <= onCutter )
            {
                bool nextToKept = ( i > 0 && sides[i - 1] == SIDE::KEEP )
                                  || ( j < sides.size() && sides[j] == SIDE::KEEP );
 
                for( size_t k = i; k < j; k++ )
                    sides[k] = nextToKept ? SIDE::KEEP : SIDE::DROP;
            }
            else
            {
                for( size_t k = i; k < j; k++ )
                    sides[k] = classify( k );
            }
 
            i = j;
        }
 
        // Each kept run is one piece, as a shared edge meets its cutter at every cutter vertex
        for( size_t i = 0; i < sides.size(); )
        {
            if( sides[i] != SIDE::KEEP )
            {
                i++;
                continue;
            }
 
            size_t j = i;
 
            while( j < sides.size() && sides[j] == SIDE::KEEP )
                j++;
 
            kept.push_back( subEdge( cuts[i], cuts[j] ) );
            i = j;
        }
    }
 
    return kept;
}
} // namespace
 
 
void ALTIUM_PCB::HelperCreateBoardOutline( const SHAPE_LINE_CHAIN& aOutline )
{
    std::vector<OUTLINE_EDGE> edges = OutlineEdgesFromChain( aOutline );
 
    RemoveOutlineJogs( edges, m_outlineJogCount, m_outlineJogLargest );
    AddOutlineEdges( *m_board, edges );
}
 
 
void ALTIUM_PCB::HelperFinishBoardOutline()
{
    SHAPE_LINE_CHAIN board = m_boardOutline;
    board.SetClosed( true );
 
    std::vector<OUTLINE_EDGE> edges = OutlineEdgesFromChain( m_boardOutline );
    SHAPE_POLY_SET            region;
    bool                      merged = false;
 
    if( board.PointCount() >= 3 )
        region.AddOutline( board );
 
    std::vector<SHAPE_LINE_CHAIN> separate;
    std::vector<const SHAPE_LINE_CHAIN*> applied = { &board };
 
    // The cutouts must keep their addresses while they are referenced
    std::vector<SHAPE_LINE_CHAIN> cutouts = m_boardCutouts;
 
    for( SHAPE_LINE_CHAIN& cutout : cutouts )
    {
        cutout.SetClosed( true );
 
        std::vector<SHAPE_LINE_CHAIN::INTERSECTION> crossings;
 
        if( board.PointCount() < 3 || cutout.PointCount() < 3 || board.Intersect( cutout, crossings ) == 0 )
        {
            separate.push_back( cutout );
            continue;
        }
 
        // A cutout over the board edge reshapes the outline: keep the board edges outside it and the
        // cutout edges inside the board, cutting arcs and lines only where they cross
        SHAPE_POLY_SET cutArea;
        cutArea.AddOutline( cutout );
 
        // Boolean operations are not defined for arcs, and only the area is needed from the region
        SHAPE_POLY_SET material = region.CloneDropTriangulation();
        SHAPE_POLY_SET cutAreaFlat = cutArea.CloneDropTriangulation();
        material.ClearArcs();
        cutAreaFlat.ClearArcs();
        material.BooleanSubtract( cutAreaFlat );
 
        // The cutout is cut by the board and by every cutout already applied, as they all bound the material.
        // A shared edge is taken from the board side, and only where the cut leaves board on one side of it
        std::vector<OUTLINE_EDGE> kept = ClipOutlineEdges( edges, { &cutout }, cutArea, false, &material );
        std::vector<OUTLINE_EDGE> inside =
                ClipOutlineEdges( OutlineEdgesFromChain( cutout ), applied, region, true, nullptr );
 
        kept.insert( kept.end(), inside.begin(), inside.end() );
        edges = std::move( kept );
        region = std::move( material );
        applied.push_back( &cutout );
        merged = true;
    }
 
    if( merged )
    {
        AddOutlineEdges( *m_board, edges );
    }
    else
    {
        HelperCreateBoardOutline( m_boardOutline );
    }
 
    for( const SHAPE_LINE_CHAIN& cutout : separate )
        HelperCreateBoardOutline( cutout );
 
    m_boardOutline.Clear();
    m_boardCutouts.clear();
 
    if( m_outlineJogCount > 0 && m_reporter )
    {
        m_reporter->Report( wxString::Format( _( "%d tiny jogs in the board outline were removed; the largest "
                                                 "moved an outline end by %s." ),
                                              m_outlineJogCount,
                                              wxString::FromCDouble( pcbIUScale.IUTomm( m_outlineJogLargest ), 4 )
                                                      + wxS( " mm" ) ),
                            RPT_SEVERITY_WARNING );
    }
}
 
 
void ALTIUM_PCB::ParseClasses6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                    const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading netclasses..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ACLASS6 elem( reader );
 
        if( elem.kind == ALTIUM_CLASS_KIND::NET_CLASS )
        {
            std::shared_ptr<NETCLASS> nc = std::make_shared<NETCLASS>( elem.name, false );
 
            for( const wxString& name : elem.names )
            {
                m_board->GetDesignSettings().m_NetSettings->SetNetclassPatternAssignment( SchematicCasedNetName( name ),
                                                                                          nc->GetName() );
            }
 
            if( m_board->GetDesignSettings().m_NetSettings->HasNetclass( nc->GetName() ) )
            {
                // Name conflict, happens in some unknown circumstances
                // unique_ptr will delete nc on this code path
                if( m_reporter )
                {
                    wxString msg;
                    msg.Printf( _( "More than one Altium netclass with name '%s' found. "
                                   "Only the first one will be imported." ), elem.name );
                    m_reporter->Report( msg, RPT_SEVERITY_ERROR );
                }
            }
            else
            {
                m_board->GetDesignSettings().m_NetSettings->SetNetclass( nc->GetName(), nc );
            }
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Classes6 stream is not fully parsed" ) );
 
    // Now that all netclasses and pattern assignments are set up, resolve the pattern
    // assignments to direct netclass assignments on each net.
    HelperAssignNetclassesToNets();
 
    m_board->m_LegacyNetclassesLoaded = true;
}
 
 
void ALTIUM_PCB::HelperAssignNetclassesToNets()
{
    std::shared_ptr<NET_SETTINGS> netSettings = m_board->GetDesignSettings().m_NetSettings;
 
    netSettings->RecomputeEffectiveNetclasses();
 
    for( NETINFO_ITEM* net : m_board->GetNetInfo() )
    {
        if( net->GetNetCode() <= 0 )
            continue;
 
        if( std::shared_ptr<NETCLASS> netclass = netSettings->GetEffectiveNetClass( net->GetNetname() ) )
            net->SetNetClass( netclass );
    }
}
 
 
void ALTIUM_PCB::ParseComponents6Data( const ALTIUM_PCB_COMPOUND_FILE& aAltiumPcbFile,
                                       const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading components..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ACOMPONENT6 elem( reader );
 
        std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>( m_board );
 
        // Altium stores the footprint library information needed to find the footprint in the
        // source library in the sourcefootprintlibrary field.  Since Altium is a Windows-only
        // program, the path separator is always a backslash.  We need strip the extra path information
        // here to prevent overly-long LIB_IDs because KiCad doesn't store the full path to the
        // footprint library in the design file, only in a library table.
        wxFileName libName( elem.sourcefootprintlibrary, wxPATH_WIN );
 
        // The pattern field may also contain a path when Altium stores it with a full library path.
        // Extract just the footprint name portion to avoid creating invalid filenames.
        wxString fpName = elem.pattern;
 
        if( fpName.Contains( wxT( "\\" ) ) || fpName.Contains( wxT( "/" ) ) )
        {
            wxFileName fpPath( fpName, wxPATH_WIN );
            fpName = fpPath.GetFullName();
        }
 
        LIB_ID fpID = AltiumToKiCadLibID( libName.GetName(), fpName );
 
        footprint->SetFPID( fpID );
 
        footprint->SetPosition( elem.position );
        footprint->SetOrientationDegrees( elem.rotation );
 
        // KiCad netlisting requires parts to have non-digit + digit annotation.
        // If the reference begins with a number, we prepend 'UNK' (unknown) for the source designator
        wxString reference = elem.sourcedesignator;
 
        if( reference.find_first_not_of( "0123456789" ) == wxString::npos )
            reference.Prepend( wxT( "UNK" ) );
 
        footprint->SetReference( reference );
 
        KIID id = AltiumUniqueIdToKiid( elem.sourceUniqueID );
        KIID pathid( elem.sourceHierachicalPath );
        KIID_PATH path;
        path.push_back( pathid );
        path.push_back( id );
 
        footprint->SetPath( path );
        footprint->SetSheetname( elem.sourceHierachicalPath );
        footprint->SetSheetfile( elem.sourceHierachicalPath + wxT( ".kicad_sch" ));
 
        footprint->SetLocked( elem.locked );
        footprint->Reference().SetVisible( elem.nameon );
        footprint->Value().SetVisible( elem.commenton );
        footprint->SetLayer( elem.layer == ALTIUM_LAYER::TOP_LAYER ? F_Cu : B_Cu );
        footprint->SetHeight( elem.height );
 
        m_components.emplace_back( footprint.get() );
        m_board->Add( footprint.release(), ADD_MODE::APPEND );
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Components6 stream is not fully parsed" ) );
}
 

double normalizeAngleDegrees( double Angle, double aMin, double aMax )
{
    while( Angle < aMin )
        Angle += 360.0;
 
    while( Angle >= aMax )
        Angle -= 360.0;
 
    return Angle;
}
 
 
void ALTIUM_PCB::ConvertComponentBody6ToFootprintItem( const ALTIUM_PCB_COMPOUND_FILE& aAltiumPcbFile,
                                                       FOOTPRINT* aFootprint,
                                                       const ACOMPONENTBODY6& aElem )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading component 3D models..." ) );
 
    if( !aElem.modelIsEmbedded )
        return;
 
    auto model = aAltiumPcbFile.GetLibModel( aElem.modelId );
 
    if( !model )
    {
        if( m_reporter )
        {
            m_reporter->Report( wxString::Format( wxT( "Model %s not found for footprint %s" ),
                                                  aElem.modelId, aFootprint->GetReference() ),
                                RPT_SEVERITY_ERROR );
        }
 
        return;
    }
 
    wxString modelName = aElem.modelName.IsEmpty() ? model->first.name : aElem.modelName;
    bool     isNew = false;
 
    std::shared_ptr<EMBEDDED_FILES::EMBEDDED_FILE> file =
            HelperEmbedModel( aFootprint, modelName, model->second, isNew );
 
    if( isNew )
        EMBEDDED_FILES::CompressAndEncode( *file );
 
    FP_3DMODEL modelSettings;
 
    modelSettings.m_Filename = file->GetLink();
 
    modelSettings.m_Offset.x = pcbIUScale.IUTomm( (int) aElem.modelPosition.x );
    modelSettings.m_Offset.y = -pcbIUScale.IUTomm( (int) aElem.modelPosition.y );
    modelSettings.m_Offset.z = pcbIUScale.IUTomm( (int) aElem.modelPosition.z );
 
    EDA_ANGLE orientation = aFootprint->GetOrientation();
 
    if( aFootprint->IsFlipped() )
    {
        modelSettings.m_Offset.y = -modelSettings.m_Offset.y;
        orientation              = -orientation;
    }
 
    VECTOR3D modelRotation( aElem.modelRotation );
 
    if( ( aElem.body_projection == 1 ) != aFootprint->IsFlipped() )
    {
        modelRotation.x += 180;
        modelRotation.z = -modelRotation.z;
 
        modelSettings.m_Offset.z = -DEFAULT_BOARD_THICKNESS_MM - modelSettings.m_Offset.z;
    }
 
    RotatePoint( &modelSettings.m_Offset.x, &modelSettings.m_Offset.y, orientation );
 
    modelSettings.m_Rotation.x = normalizeAngleDegrees( -modelRotation.x, -180, 180 );
    modelSettings.m_Rotation.y = normalizeAngleDegrees( -modelRotation.y, -180, 180 );
    modelSettings.m_Rotation.z = normalizeAngleDegrees( -modelRotation.z + aElem.rotation
                                                                         + orientation.AsDegrees(),
                                                                           -180, 180 );
    modelSettings.m_Opacity = aElem.body_opacity_3d;
 
    aFootprint->Models().push_back( modelSettings );
}
 
 
void ALTIUM_PCB::ParseComponentsBodies6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                             const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading component 3D models..." ) );
 
    thread_pool&           tp = GetKiCadThreadPool();
    BS::multi_future<void> embeddedFutures;
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ACOMPONENTBODY6 elem( reader );
 
        static const bool skipComponentBodies = ADVANCED_CFG::GetCfg().m_ImportSkipComponentBodies;
 
        if( skipComponentBodies )
            continue;
 
        if( elem.component == ALTIUM_COMPONENT_NONE )
            continue; // TODO: we do not support components for the board yet
 
        if( m_components.size() <= elem.component )
        {
            THROW_IO_ERRORF( wxT( "ComponentsBodies6 stream tries to access component id %d of %zu existing "
                                  "components" ),
                             elem.component,
                             m_components.size() );
        }
 
        if( !elem.modelIsEmbedded )
            continue;
 
        auto modelTuple = m_EmbeddedModels.find( elem.modelId );
 
        if( modelTuple == m_EmbeddedModels.end() )
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( wxT( "ComponentsBodies6 stream tries to access model id %s which does "
                                 "not exist" ), elem.modelId );
                m_reporter->Report( msg, RPT_SEVERITY_ERROR );
            }
 
            continue;
        }
 
        const ALTIUM_EMBEDDED_MODEL_DATA& modelData = modelTuple->second;
        FOOTPRINT*                        footprint = m_components.at( elem.component );
        bool                              isNew = false;
 
        std::shared_ptr<EMBEDDED_FILES::EMBEDDED_FILE> file =
                HelperEmbedModel( footprint, modelData.m_modelname, modelData.m_data, isNew );
 
        if( isNew )
        {
            // The task has to own the payload too; a throw further down the stream skips the
            // wait below and multi_future abandons whatever is still running
            embeddedFutures.push_back( tp.submit_task(
                    [file]()
                    {
                        EMBEDDED_FILES::CompressAndEncode( *file );
                    } ) );
        }
 
        FP_3DMODEL modelSettings;
 
        modelSettings.m_Filename = file->GetLink();
        VECTOR2I fpPosition = footprint->GetPosition();
 
        modelSettings.m_Offset.x =
                pcbIUScale.IUTomm( KiROUND( elem.modelPosition.x - fpPosition.x ) );
        modelSettings.m_Offset.y =
                -pcbIUScale.IUTomm( KiROUND( elem.modelPosition.y - fpPosition.y ) );
        modelSettings.m_Offset.z = pcbIUScale.IUTomm( KiROUND( elem.modelPosition.z ) );
 
        EDA_ANGLE orientation = footprint->GetOrientation();
 
        if( footprint->IsFlipped() )
        {
            modelSettings.m_Offset.y = -modelSettings.m_Offset.y;
            orientation              = -orientation;
        }
 
        if( ( elem.body_projection == 1 ) != footprint->IsFlipped() )
        {
            elem.modelRotation.x += 180;
            elem.modelRotation.z = -elem.modelRotation.z;
 
            modelSettings.m_Offset.z =
                    -pcbIUScale.IUTomm( m_board->GetDesignSettings().GetBoardThickness() )
                    - modelSettings.m_Offset.z;
        }
 
        RotatePoint( &modelSettings.m_Offset.x, &modelSettings.m_Offset.y, orientation );
 
        modelSettings.m_Rotation.x = normalizeAngleDegrees( -elem.modelRotation.x, -180, 180 );
        modelSettings.m_Rotation.y = normalizeAngleDegrees( -elem.modelRotation.y, -180, 180 );
        modelSettings.m_Rotation.z = normalizeAngleDegrees( -elem.modelRotation.z + elem.rotation
                                                                                  + orientation.AsDegrees(),
                                                                                   -180, 180 );
 
        modelSettings.m_Opacity = elem.body_opacity_3d;
 
        footprint->Models().push_back( modelSettings );
    }
 
    embeddedFutures.wait();
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "ComponentsBodies6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::HelperParseDimensions6Linear( const ADIMENSION6& aElem )
{
    if( aElem.referencePoint.size() != 2 )
        THROW_IO_ERROR( wxT( "Incorrect number of reference points for linear dimension object" ) );
 
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( m_reporter )
        {
            m_reporter->Report( wxString::Format(
                    _( "Dimension found on an Altium layer (%d) with no KiCad equivalent. "
                           "It has been moved to KiCad layer Eco1_User." ), aElem.layer ),
                        RPT_SEVERITY_INFO );
        }
 
        klayer = Eco1_User;
    }
 
    VECTOR2I referencePoint0 = aElem.referencePoint.at( 0 );
    VECTOR2I referencePoint1 = aElem.referencePoint.at( 1 );
 
    std::unique_ptr<PCB_DIM_ALIGNED> dimension = std::make_unique<PCB_DIM_ALIGNED>( m_board, PCB_DIM_ALIGNED_T );
 
    dimension->SetPrecision( static_cast<DIM_PRECISION>( aElem.textprecision ) );
    dimension->SetLayer( klayer );
    dimension->SetStart( referencePoint0 );
 
    if( referencePoint0 != aElem.xy1 )
    {
        VECTOR2I     direction             = aElem.xy1 - referencePoint0;
        VECTOR2I     referenceDiff         = referencePoint1 - referencePoint0;
        VECTOR2I     directionNormalVector = direction.Perpendicular();
        SEG          segm1( referencePoint0, referencePoint0 + directionNormalVector );
        SEG          segm2( referencePoint1, referencePoint1 + direction );
        OPT_VECTOR2I intersection( segm1.Intersect( segm2, true, true ) );
 
        if( !intersection )
            THROW_IO_ERROR( wxT( "Invalid dimension.  This should never happen." ) );
 
        dimension->SetEnd( *intersection );
 
        int height = direction.EuclideanNorm();
 
        if( direction.Cross( referenceDiff ) > 0 )
            height = -height;
 
        dimension->SetHeight( height );
    }
    else
    {
        dimension->SetEnd( referencePoint1 );
    }
 
    dimension->SetLineThickness( aElem.linewidth );
 
    dimension->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
    dimension->SetPrefix( aElem.textprefix );
 
 
    int dist = ( dimension->GetEnd() - dimension->GetStart() ).EuclideanNorm();
 
    if( dist < 3 * dimension->GetArrowLength() )
        dimension->SetArrowDirection( DIM_ARROW_DIRECTION::INWARD );
 
    // Suffix normally (but not always) holds the units
    wxRegEx units( wxS( "(mm)|(in)|(mils)|(thou)|(')|(\")" ), wxRE_ADVANCED );
 
    if( units.Matches( aElem.textsuffix ) )
        dimension->SetUnitsFormat( DIM_UNITS_FORMAT::BARE_SUFFIX );
    else
        dimension->SetSuffix( aElem.textsuffix );
 
    dimension->SetTextThickness( aElem.textlinewidth );
    dimension->SetTextSize( VECTOR2I( aElem.textheight, aElem.textheight ) );
    dimension->SetItalic( aElem.textitalic );
 
#if 0  // we don't currently support bold; map to thicker text
    dimension->Text().SetBold( aElem.textbold );
#else
    if( aElem.textbold )
        dimension->SetTextThickness( dimension->GetTextThickness() * BOLD_FACTOR );
#endif
 
    switch( aElem.textunit )
    {
    case ALTIUM_UNIT::INCH: dimension->SetUnits( EDA_UNITS::INCH );   break;
    case ALTIUM_UNIT::MILS: dimension->SetUnits( EDA_UNITS::MILS ); break;
    case ALTIUM_UNIT::MM:   dimension->SetUnits( EDA_UNITS::MM );   break;
    case ALTIUM_UNIT::CM:   dimension->SetUnits( EDA_UNITS::MM );   break;
    default:                                                        break;
    }
 
    m_board->Add( dimension.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::HelperParseDimensions6Radial(const ADIMENSION6 &aElem)
{
    if( aElem.referencePoint.size() < 2 )
        THROW_IO_ERROR( wxT( "Not enough reference points for radial dimension object" ) );
 
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( m_reporter )
        {
            m_reporter->Report( wxString::Format(
                _( "Dimension found on an Altium layer (%d) with no KiCad equivalent. "
                   "It has been moved to KiCad layer Eco1_User." ),
                aElem.layer ), RPT_SEVERITY_INFO );
        }
 
        klayer = Eco1_User;
    }
 
    VECTOR2I referencePoint0 = aElem.referencePoint.at( 0 );
 
    std::unique_ptr<PCB_DIM_RADIAL> dimension = std::make_unique<PCB_DIM_RADIAL>( m_board );
 
    dimension->SetPrecision( static_cast<DIM_PRECISION>( aElem.textprecision ) );
    dimension->SetLayer( klayer );
    dimension->SetStart( referencePoint0 );
    dimension->SetEnd( aElem.xy1 );
    dimension->SetLineThickness( aElem.linewidth );
    dimension->SetKeepTextAligned( false );
 
    dimension->SetPrefix( aElem.textprefix );
 
    // Suffix normally holds the units
    dimension->SetUnitsFormat( aElem.textsuffix.IsEmpty() ? DIM_UNITS_FORMAT::NO_SUFFIX
                                                          : DIM_UNITS_FORMAT::BARE_SUFFIX );
 
    switch( aElem.textunit )
    {
    case ALTIUM_UNIT::INCH: dimension->SetUnits( EDA_UNITS::INCH );   break;
    case ALTIUM_UNIT::MILS: dimension->SetUnits( EDA_UNITS::MILS ); break;
    case ALTIUM_UNIT::MM:   dimension->SetUnits( EDA_UNITS::MM );   break;
    case ALTIUM_UNIT::CM:   dimension->SetUnits( EDA_UNITS::MM );   break;
    default:                                                        break;
    }
 
    if( aElem.textPoint.empty() )
    {
        if( m_reporter )
        {
            m_reporter->Report( wxT( "No text position present for leader dimension object" ),
                                RPT_SEVERITY_ERROR );
        }
 
        return;
    }
 
    dimension->SetTextPos( aElem.textPoint.at( 0 ) );
    dimension->SetTextThickness( aElem.textlinewidth );
    dimension->SetTextSize( VECTOR2I( aElem.textheight, aElem.textheight ) );
    dimension->SetItalic( aElem.textitalic );
 
#if 0  // we don't currently support bold; map to thicker text
    dimension->SetBold( aElem.textbold );
#else
    if( aElem.textbold )
        dimension->SetTextThickness( dimension->GetTextThickness() * BOLD_FACTOR );
#endif
 
    // It's unclear exactly how Altium figures it's text positioning, but this gets us reasonably
    // close.
    dimension->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
    dimension->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 
    int yAdjust = dimension->GetTextBox( nullptr ).GetCenter().y - dimension->GetTextPos().y;
    dimension->SetTextPos( dimension->GetTextPos() + VECTOR2I( 0, yAdjust + aElem.textgap ) );
    dimension->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 
    m_radialDimensions.push_back( dimension.get() );
    m_board->Add( dimension.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::HelperParseDimensions6Leader( const ADIMENSION6& aElem )
{
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Dimension found on an Altium layer (%d) with no KiCad equivalent. "
                          "It has been moved to KiCad layer Eco1_User." ), aElem.layer );
            m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        }
 
        klayer = Eco1_User;
    }
 
    if( !aElem.referencePoint.empty() )
    {
        VECTOR2I referencePoint0 = aElem.referencePoint.at( 0 );
 
        // line
        VECTOR2I last = referencePoint0;
        for( size_t i = 1; i < aElem.referencePoint.size(); i++ )
        {
            std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::SEGMENT );
 
            shape->SetLayer( klayer );
            shape->SetStroke( STROKE_PARAMS( aElem.linewidth, LINE_STYLE::SOLID ) );
            shape->SetStart( last );
            shape->SetEnd( aElem.referencePoint.at( i ) );
            last = aElem.referencePoint.at( i );
 
            m_board->Add( shape.release(), ADD_MODE::APPEND );
        }
 
        // arrow
        if( aElem.referencePoint.size() >= 2 )
        {
            VECTOR2I dirVec = aElem.referencePoint.at( 1 ) - referencePoint0;
 
            if( dirVec.x != 0 || dirVec.y != 0 )
            {
                double   scaling = (double) dirVec.EuclideanNorm() / aElem.arrowsize;
                VECTOR2I arrVec = KiROUND( dirVec.x / scaling, dirVec.y / scaling );
                RotatePoint( arrVec, EDA_ANGLE( 20.0, DEGREES_T ) );
 
                {
                    std::unique_ptr<PCB_SHAPE> shape1 = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::SEGMENT );
 
                    shape1->SetLayer( klayer );
                    shape1->SetStroke( STROKE_PARAMS( aElem.linewidth, LINE_STYLE::SOLID ) );
                    shape1->SetStart( referencePoint0 );
                    shape1->SetEnd( referencePoint0 + arrVec );
 
                    m_board->Add( shape1.release(), ADD_MODE::APPEND );
                }
 
                RotatePoint( arrVec, EDA_ANGLE( -40.0, DEGREES_T ) );
 
                {
                    std::unique_ptr<PCB_SHAPE> shape2 = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::SEGMENT );
 
                    shape2->SetLayer( klayer );
                    shape2->SetStroke( STROKE_PARAMS( aElem.linewidth, LINE_STYLE::SOLID ) );
                    shape2->SetStart( referencePoint0 );
                    shape2->SetEnd( referencePoint0 + arrVec );
 
                    m_board->Add( shape2.release(), ADD_MODE::APPEND );
                }
            }
        }
    }
 
    if( aElem.textPoint.empty() )
    {
        if( m_reporter )
        {
            m_reporter->Report( wxT( "No text position present for leader dimension object" ),
                                RPT_SEVERITY_ERROR );
        }
 
        return;
    }
 
    std::unique_ptr<PCB_TEXT> text = std::make_unique<PCB_TEXT>( m_board );
 
    text->SetText( aElem.textformat );
    text->SetPosition( aElem.textPoint.at( 0 ) );
    text->SetLayer( klayer );
    text->SetTextSize( VECTOR2I( aElem.textheight, aElem.textheight ) ); // TODO: parse text width
    text->SetTextThickness( aElem.textlinewidth );
    text->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
    text->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 
    m_board->Add( text.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::HelperParseDimensions6Datum( const ADIMENSION6& aElem )
{
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Dimension found on an Altium layer (%d) with no KiCad equivalent. "
                           "It has been moved to KiCad layer Eco1_User." ), aElem.layer );
            m_reporter->Report( msg, RPT_SEVERITY_INFO );
        }
 
        klayer = Eco1_User;
    }
 
    for( size_t i = 0; i < aElem.referencePoint.size(); i++ )
    {
        std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::SEGMENT );
 
        shape->SetLayer( klayer );
        shape->SetStroke( STROKE_PARAMS( aElem.linewidth, LINE_STYLE::SOLID ) );
        shape->SetStart( aElem.referencePoint.at( i ) );
        // shape->SetEnd( /* TODO: seems to be based on TEXTY */ );
 
        m_board->Add( shape.release(), ADD_MODE::APPEND );
    }
}
 
 
void ALTIUM_PCB::HelperParseDimensions6Center( const ADIMENSION6& aElem )
{
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Dimension found on an Altium layer (%d) with no KiCad equivalent. "
                           "It has been moved to KiCad layer Eco1_User." ), aElem.layer );
            m_reporter->Report( msg, RPT_SEVERITY_INFO );
        }
 
        klayer = Eco1_User;
    }
 
    VECTOR2I vec = VECTOR2I( 0, aElem.height / 2 );
    RotatePoint( vec, EDA_ANGLE( aElem.angle, DEGREES_T ) );
 
    std::unique_ptr<PCB_DIM_CENTER> dimension = std::make_unique<PCB_DIM_CENTER>( m_board );
 
    dimension->SetLayer( klayer );
    dimension->SetLineThickness( aElem.linewidth );
    dimension->SetStart( aElem.xy1 );
    dimension->SetEnd( aElem.xy1 + vec );
 
    m_board->Add( dimension.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ParseDimensions6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                       const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading dimension drawings..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ADIMENSION6 elem( reader );
 
        switch( elem.kind )
        {
        case ALTIUM_DIMENSION_KIND::LINEAR:
            HelperParseDimensions6Linear( elem );
            break;
        case ALTIUM_DIMENSION_KIND::ANGULAR:
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Ignored Angular dimension (not yet supported)." ) ),
                                    RPT_SEVERITY_INFO );
            }
            break;
        case ALTIUM_DIMENSION_KIND::RADIAL:
            HelperParseDimensions6Radial( elem );
            break;
        case ALTIUM_DIMENSION_KIND::LEADER:
            HelperParseDimensions6Leader( elem );
            break;
        case ALTIUM_DIMENSION_KIND::DATUM:
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Ignored Datum dimension (not yet supported)." ) ),
                                    RPT_SEVERITY_INFO );
            }
            // HelperParseDimensions6Datum( elem );
            break;
        case ALTIUM_DIMENSION_KIND::BASELINE:
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Ignored Baseline dimension (not yet supported)." ) ),
                                    RPT_SEVERITY_INFO );
            }
            break;
        case ALTIUM_DIMENSION_KIND::CENTER:
            HelperParseDimensions6Center( elem );
            break;
        case ALTIUM_DIMENSION_KIND::LINEAR_DIAMETER:
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Ignored Linear dimension (not yet supported)." ) ),
                                    RPT_SEVERITY_INFO );
            }
            break;
        case ALTIUM_DIMENSION_KIND::RADIAL_DIAMETER:
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Ignored Radial dimension (not yet supported)." ) ),
                                    RPT_SEVERITY_INFO );
            }
            break;
        default:
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "Ignored dimension of kind %d (not yet supported)." ), elem.kind );
                m_reporter->Report( msg, RPT_SEVERITY_INFO );
            }
            break;
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Dimensions6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ParseModelsData( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                  const CFB::COMPOUND_FILE_ENTRY* aEntry,
                                  const std::vector<std::string>& aRootDir )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading 3D models..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    if( reader.GetRemainingBytes() == 0 )
        return;
 
    int      idx = 0;
    wxString invalidChars = wxFileName::GetForbiddenChars();
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        AMODEL elem( reader );
 
        std::vector<std::string> stepPath = aRootDir;
        stepPath.emplace_back( std::to_string( idx ) );
 
        bool     validName = !elem.name.IsEmpty() && elem.name.IsAscii()
                                && wxString::npos == elem.name.find_first_of( invalidChars );
        wxString storageName = validName ? elem.name : wxString::Format( wxT( "model_%d" ), idx );
 
        idx++;
 
        const CFB::COMPOUND_FILE_ENTRY* stepEntry = aAltiumPcbFile.FindStream( stepPath );
 
        if( stepEntry == nullptr )
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "File not found: '%s'. 3D-model not imported." ), FormatPath( stepPath ) );
                m_reporter->Report( msg, RPT_SEVERITY_ERROR );
            }
 
            continue;
        }
 
        size_t            stepSize = static_cast<size_t>( stepEntry->size );
        std::vector<char> stepContent( stepSize );
 
        // read file into buffer
        aAltiumPcbFile.GetCompoundFileReader().ReadFile( stepEntry, 0, stepContent.data(),
                                                         stepSize );
 
        m_EmbeddedModels.insert( std::make_pair(
                elem.id, ALTIUM_EMBEDDED_MODEL_DATA( storageName, elem.rotation, elem.z_offset,
                                                     std::move( stepContent ) ) ) );
    }
 
    // Append _<index> to duplicate filenames
    std::map<wxString, std::vector<wxString>> nameIdMap;
 
    for( auto& [id, data] : m_EmbeddedModels )
        nameIdMap[data.m_modelname].push_back( id );
 
    for( auto& [name, ids] : nameIdMap )
    {
        for( size_t i = 1; i < ids.size(); i++ )
        {
            const wxString& id = ids[i];
 
            auto modelTuple = m_EmbeddedModels.find( id );
 
            if( modelTuple == m_EmbeddedModels.end() )
                continue;
 
            wxString modelName = modelTuple->second.m_modelname;
 
            if( modelName.Contains( "." ) )
            {
                wxString ext;
                wxString baseName = modelName.BeforeLast( '.', &ext );
 
                modelTuple->second.m_modelname = baseName + '_' + std::to_string( i ) + '.' + ext;
            }
            else
            {
                modelTuple->second.m_modelname = modelName + '_' + std::to_string( i );
            }
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Models stream is not fully parsed" ) );
}
 
 
static void altiumCollectSchematicNetNames( const wxString& aFileName, std::map<wxString, wxString>& aNames,
                                            std::set<wxString>& aAmbiguous )
{
    auto collect = [&]( const std::map<wxString, wxString>& aProps )
    {
        int      record = ALTIUM_PROPS_UTILS::ReadInt( aProps, wxT( "RECORD" ), 0 );
        wxString name;
 
        switch( record )
        {
        case 16: // sheet entry
        case 18: // port
            name = ALTIUM_PROPS_UTILS::ReadString( aProps, wxT( "NAME" ), wxT( "" ) );
            break;
 
        case 17: // power port
        case 25: // net label
            name = ALTIUM_PROPS_UTILS::ReadString( aProps, wxT( "TEXT" ), wxT( "" ) );
            break;
 
        default: return;
        }
 
        if( name.IsEmpty() )
            return;
 
        wxString key = name.Upper();
        auto     it = aNames.find( key );
 
        if( it == aNames.end() )
            aNames.emplace( key, name );
        else if( it->second != name )
            aAmbiguous.insert( key );
    };
 
    if( IO_UTILS::fileHasBinaryHeader( aFileName, IO_UTILS::COMPOUND_FILE_HEADER ) )
    {
        ALTIUM_COMPOUND_FILE            schFile( aFileName );
        const CFB::COMPOUND_FILE_ENTRY* header = schFile.FindStream( { "FileHeader" } );
 
        if( !header )
            return;
 
        ALTIUM_BINARY_PARSER reader( schFile, header );
 
        while( reader.GetRemainingBytes() > 0 )
            collect( reader.ReadProperties() );
    }
    else
    {
        ALTIUM_ASCII_PARSER reader( aFileName );
 
        while( reader.CanRead() )
            collect( reader.ReadProperties() );
    }
}
 
 
void ALTIUM_PCB::MapSchematicNetNames( const std::map<std::string, UTF8>& aProperties )
{
    std::set<wxString> ambiguous;
 
    for( int i = 0;; i++ )
    {
        auto it = aProperties.find( "sch" + std::to_string( i ) );
 
        if( it == aProperties.end() )
            break;
 
        try
        {
            altiumCollectSchematicNetNames( it->second.wx_str(), m_schematicNetNames, ambiguous );
        }
        catch( ... )
        {
            // an unreadable schematic must not break the board import
        }
    }
 
    for( const wxString& key : ambiguous )
        m_schematicNetNames.erase( key );
}
 
 
wxString ALTIUM_PCB::SchematicCasedNetName( const wxString& aNetName ) const
{
    auto it = m_schematicNetNames.find( aNetName.Upper() );
 
    if( it != m_schematicNetNames.end() )
        return it->second;
 
    return aNetName;
}
 
 
void ALTIUM_PCB::ParseNets6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                 const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading nets..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    wxASSERT( m_altiumToKicadNetcodes.empty() );
 
    int unnamedNetCount = 0;
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ANET6 elem( reader );
 
        wxString netName = SchematicCasedNetName( elem.name );
 
        if( netName.IsEmpty() )
        {
            netName = AltiumUnnamedNetName( *m_board, unnamedNetCount );
 
            if( m_reporter )
            {
                m_reporter->Report( wxString::Format( _( "Altium net %zu has no name; imported as '%s'." ),
                                                      m_altiumToKicadNetcodes.size(), netName ),
                                    RPT_SEVERITY_WARNING );
            }
        }
 
        NETINFO_ITEM* netInfo = new NETINFO_ITEM( m_board, netName, -1 );
        m_board->Add( netInfo, ADD_MODE::APPEND );
 
        // needs to be called after m_board->Add() as assign us the NetCode
        m_altiumToKicadNetcodes.push_back( netInfo->GetNetCode() );
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Nets6 stream is not fully parsed" ) );
}
 
void ALTIUM_PCB::ParsePolygons6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                     const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading polygons..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        APOLYGON6 elem( reader );
 
        if( elem.discardedVertices > 0 && m_reporter )
        {
            m_reporter->Report( wxString::Format( _( "Polygon on layer '%s' has %d vertices "
                                                     "outside the coordinate range; they were "
                                                     "dropped." ),
                                                  LayerName( GetKicadLayer( elem.layer ) ),
                                                  elem.discardedVertices ),
                                RPT_SEVERITY_ERROR );
        }
 
        SHAPE_LINE_CHAIN linechain;
        HelperShapeLineChainFromAltiumVertices( linechain, elem.vertices );
 
        if( linechain.PointCount() < 3 )
        {
            // We have found multiple Altium files with polygon records containing nothing but two
            // coincident vertices.  These polygons do not appear when opening the file in Altium.
            // https://gitlab.com/kicad/code/kicad/-/issues/8183
            // Also, polygons with less than 3 points are not supported in KiCad.
            //
            // wxLogError( _( "Polygon has only %d point extracted from %ld vertices. At least 2 "
            //                "points are required." ),
            //             linechain.PointCount(),
            //             elem.vertices.size() );
 
            m_polygons.emplace_back( nullptr );
            continue;
        }
 
        SHAPE_POLY_SET outline( linechain );
 
        if( elem.hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::SOLID )
        {
            // Altium "Hatched" or "None" polygon outlines have thickness, convert it to KiCad's representation.
            outline.Inflate( elem.trackwidth / 2, CORNER_STRATEGY::CHAMFER_ACUTE_CORNERS,
                             ARC_HIGH_DEF, true );
        }
 
        if( outline.OutlineCount() != 1 && m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Polygon outline count is %d, expected 1." ), outline.OutlineCount() );
 
            m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        }
 
        if( outline.OutlineCount() == 0 )
            continue;
 
        std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(m_board);
 
        // Be sure to set the zone layer before setting the net code
        // so that we know that this is a copper zone and so needs a valid net code.
        HelperSetZoneLayers( *zone, elem.layer );
        zone->SetNetCode( GetNetCode( elem.net ) );
        zone->SetPosition( elem.vertices.at( 0 ).position );
        zone->SetLocked( elem.locked );
        zone->SetAssignedPriority( elem.pourindex > 0 ? elem.pourindex : 0 );
        zone->Outline()->AddOutline( outline.Outline( 0 ) );
 
        if( elem.pourindex > m_highest_pour_index )
            m_highest_pour_index = elem.pourindex;
 
        const ARULE6* planeClearanceRule = GetRuleForPolygon( ALTIUM_RULE_KIND::PLANE_CLEARANCE );
        const ARULE6* zoneClearanceRule = GetRuleForPolygon( ALTIUM_RULE_KIND::CLEARANCE );
        int planeLayers = 0;
        int signalLayers = 0;
        int clearance = 0;
 
        for( PCB_LAYER_ID layer : zone->GetLayerSet() )
        {
            LAYER_T layerType = m_board->GetLayerType( layer );
 
            if( layerType == LT_POWER || layerType == LT_MIXED )
                planeLayers++;
 
            if( layerType == LT_SIGNAL || layerType == LT_MIXED )
                signalLayers++;
        }
 
        if( planeLayers > 0 && planeClearanceRule )
            clearance = std::max( clearance, planeClearanceRule->planeclearanceClearance );
 
        if( signalLayers > 0 && zoneClearanceRule )
            clearance = std::max( clearance, zoneClearanceRule->clearanceGap );
 
        if( clearance > 0 )
            zone->SetLocalClearance( clearance );
 
        const ARULE6* polygonConnectRule = GetRuleForPolygon( ALTIUM_RULE_KIND::POLYGON_CONNECT );
 
        if( polygonConnectRule != nullptr )
        {
            switch( polygonConnectRule->polygonconnectStyle )
            {
            case ALTIUM_CONNECT_STYLE::DIRECT:
                zone->SetPadConnection( ZONE_CONNECTION::FULL );
                break;
 
            case ALTIUM_CONNECT_STYLE::NONE:
                zone->SetPadConnection( ZONE_CONNECTION::NONE );
                break;
 
            default:
            case ALTIUM_CONNECT_STYLE::RELIEF:
                zone->SetPadConnection( ZONE_CONNECTION::THERMAL );
                break;
            }
 
            // TODO: correct variables?
            zone->SetThermalReliefSpokeWidth(
                    polygonConnectRule->polygonconnectReliefconductorwidth );
            zone->SetThermalReliefGap( polygonConnectRule->polygonconnectAirgapwidth );
 
            if( polygonConnectRule->polygonconnectReliefconductorwidth < zone->GetMinThickness() )
                zone->SetMinThickness( polygonConnectRule->polygonconnectReliefconductorwidth );
        }
 
        if( IsAltiumLayerAPlane( elem.layer ) )
        {
            // outer zone will be set to priority 0 later.
            zone->SetAssignedPriority( 1 );
 
            // check if this is the outer zone by simply comparing the BBOX
            const auto& outer_plane = m_outer_plane.find( elem.layer );
            if( outer_plane == m_outer_plane.end()
                    || zone->GetBoundingBox().Contains( outer_plane->second->GetBoundingBox() ) )
            {
                m_outer_plane[elem.layer] = zone.get();
            }
        }
 
        if( elem.hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::SOLID
                && elem.hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::UNKNOWN )
        {
            zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
            zone->SetHatchThickness( elem.trackwidth );
 
            if( elem.hatchstyle == ALTIUM_POLYGON_HATCHSTYLE::NONE )
            {
                // use a small hack to get us only an outline (hopefully)
                const BOX2I& bbox = zone->GetBoundingBox();
                zone->SetHatchGap( std::max( bbox.GetHeight(), bbox.GetWidth() ) );
            }
            else
            {
                zone->SetHatchGap( elem.gridsize - elem.trackwidth );
            }
 
            if( elem.hatchstyle == ALTIUM_POLYGON_HATCHSTYLE::DEGREE_45 )
                zone->SetHatchOrientation( ANGLE_45 );
        }
 
        zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
                                     ZONE::GetDefaultHatchPitch(), true );
 
        m_polygons.emplace_back( zone.get() );
        m_board->Add( zone.release(), ADD_MODE::APPEND );
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Polygons6 stream is not fully parsed" ) );
}
 
void ALTIUM_PCB::ParseRules6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                  const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading rules..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ARULE6 elem( reader );
 
        m_rules[elem.kind].emplace_back( elem );
    }
 
    // Sort by ARULE6::priority ascending. Altium priority 1 is the most specific, so the
    // first element after sorting is the highest-priority Altium rule.
    for( std::pair<const ALTIUM_RULE_KIND, std::vector<ARULE6>>& val : m_rules )
    {
        std::sort( val.second.begin(), val.second.end(),
                []( const ARULE6& lhs, const ARULE6& rhs )
                {
                    return lhs.priority < rhs.priority;
                } );
    }
 
    const ARULE6* clearanceRule = GetRuleDefault( ALTIUM_RULE_KIND::CLEARANCE );
    const ARULE6* trackWidthRule = GetRuleDefault( ALTIUM_RULE_KIND::WIDTH );
    const ARULE6* routingViasRule = GetRuleDefault( ALTIUM_RULE_KIND::ROUTING_VIAS );
    const ARULE6* holeSizeRule = GetRuleDefault( ALTIUM_RULE_KIND::HOLE_SIZE );
    const ARULE6* holeToHoleRule = GetRuleDefault( ALTIUM_RULE_KIND::HOLE_TO_HOLE_CLEARANCE );
    const ARULE6* boardOutlineRule = GetRuleDefault( ALTIUM_RULE_KIND::BOARD_OUTLINE_CLEARANCE );
 
    if( clearanceRule )
        m_board->GetDesignSettings().m_MinClearance = clearanceRule->clearanceGap;
 
    if( trackWidthRule )
    {
        m_board->GetDesignSettings().m_TrackMinWidth = trackWidthRule->minLimit;
        // TODO: construct a custom rule for preferredWidth and maxLimit values
    }
 
    if( routingViasRule )
    {
        m_board->GetDesignSettings().m_ViasMinSize = routingViasRule->minWidth;
        m_board->GetDesignSettings().m_MinThroughDrill = routingViasRule->minHoleWidth;
    }
 
    if( holeSizeRule )
    {
        // TODO: construct a custom rule for minLimit / maxLimit values
    }
 
    if( holeToHoleRule )
        m_board->GetDesignSettings().m_HoleToHoleMin = holeToHoleRule->clearanceGap;
 
    if( boardOutlineRule )
        m_board->GetDesignSettings().m_CopperEdgeClearance = boardOutlineRule->clearanceGap;
 
    const ARULE6* soldermaskRule = GetRuleDefault( ALTIUM_RULE_KIND::SOLDER_MASK_EXPANSION );
    const ARULE6* pastemaskRule = GetRuleDefault( ALTIUM_RULE_KIND::PASTE_MASK_EXPANSION );
 
    if( soldermaskRule )
        m_board->GetDesignSettings().m_SolderMaskExpansion = soldermaskRule->soldermaskExpansion;
 
    if( pastemaskRule )
        m_board->GetDesignSettings().m_SolderPasteMargin = pastemaskRule->pastemaskExpansion;
 
    std::shared_ptr<NET_SETTINGS> netSettings = m_board->GetDesignSettings().m_NetSettings;
    std::shared_ptr<NETCLASS>     defaultNetclass = netSettings->GetDefaultNetclass();
 
    if( clearanceRule )
        defaultNetclass->SetClearance( clearanceRule->clearanceGap );
 
    if( trackWidthRule )
        defaultNetclass->SetTrackWidth( trackWidthRule->preferredWidth );
 
    if( routingViasRule )
    {
        defaultNetclass->SetViaDiameter( routingViasRule->width );
        defaultNetclass->SetViaDrill( routingViasRule->holeWidth );
    }
 
    std::vector<const ARULE6*> unresolvedNetclassRules;
 
    ApplyAltiumNetclassRules( m_rules, *netSettings, &unresolvedNetclassRules );
 
    if( m_reporter )
    {
        for( const ARULE6* rule : unresolvedNetclassRules )
        {
            wxString netclassName;
            GetAltiumNetclassScopeName( *rule, &netclassName );
 
            m_reporter->Report( wxString::Format( _( "Altium rule '%s' applies to netclass '%s', which this "
                                                     "board does not define. Its constraint is not imported." ),
                                                  rule->name, netclassName ),
                                RPT_SEVERITY_INFO );
        }
    }
 
    // Composite netclasses cached the values we just changed
    HelperAssignNetclassesToNets();
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Rules6 stream is not fully parsed" ) );
}
 
void ALTIUM_PCB::ParseBoardRegionsData( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                        const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading board regions..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        AREGION6 elem( reader, false );
 
        // TODO: implement?
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "BoardRegions stream is not fully parsed" ) );
}
 
void ALTIUM_PCB::ParseShapeBasedRegions6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                              const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading polygons..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    /* TODO: use Header section of file */
    for( int primitiveIndex = 0; reader.GetRemainingBytes() >= 4; primitiveIndex++ )
    {
        checkpoint();
        AREGION6 elem( reader, true );
 
        if( elem.component == ALTIUM_COMPONENT_NONE
            || elem.kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
        {
            // TODO: implement all different types for footprints
            ConvertShapeBasedRegions6ToBoardItem( elem, primitiveIndex );
        }
        else if( elem.kind == ALTIUM_REGION_KIND::COPPER && elem.polygon == ALTIUM_POLYGON_NONE
                 && !elem.is_keepout && elem.net != ALTIUM_NET_UNCONNECTED )
        {
            ConvertShapeBasedRegions6ToFootprintCopper( HelperGetFootprint( elem.component ), elem, primitiveIndex,
                                                        elem.net );
        }
        else
        {
            FOOTPRINT* footprint = HelperGetFootprint( elem.component );
            ConvertShapeBasedRegions6ToFootprintItem( footprint, elem, primitiveIndex );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "ShapeBasedRegions6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertShapeBasedRegions6ToFootprintCopper( FOOTPRINT* aFootprint, const AREGION6& aElem,
                                                             const int aPrimitiveIndex, uint16_t aNet )
{
    for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
    {
        // Outer copper already becomes a region pad; inner copper would be left unconnected
        if( !IsInnerCopperLayer( klayer ) )
        {
            ConvertShapeBasedRegions6ToFootprintItemOnLayer( aFootprint, aElem, klayer, aPrimitiveIndex );
            continue;
        }
 
        SHAPE_LINE_CHAIN outline;
        HelperShapeLineChainFromAltiumVertices( outline, aElem.outline );
 
        if( outline.PointCount() < 3 )
            continue;
 
        SHAPE_POLY_SET polySet( outline );
 
        for( const std::vector<ALTIUM_VERTICE>& hole : aElem.holes )
        {
            SHAPE_LINE_CHAIN holeChain;
            HelperShapeLineChainFromAltiumVertices( holeChain, hole );
 
            if( holeChain.PointCount() >= 3 )
                polySet.AddHole( holeChain );
        }
 
        std::unique_ptr<PCB_SHAPE> region = std::make_unique<PCB_SHAPE>( nullptr, SHAPE_T::POLY );
 
        region->SetPolyShape( polySet );
        region->SetFilled( true );
        region->SetStroke( STROKE_PARAMS( 0 ) );
 
        HelperDeferComponentCopper( aFootprint, klayer, aNet, std::move( region ),
                                    [this, aFootprint, aElem, klayer, aPrimitiveIndex]()
                                    {
                                        ConvertShapeBasedRegions6ToFootprintItemOnLayer( aFootprint, aElem, klayer,
                                                                                         aPrimitiveIndex );
                                    } );
    }
}
 
 
void ALTIUM_PCB::ConvertShapeBasedRegions6ToBoardItem( const AREGION6& aElem, const int aPrimitiveIndex )
{
    if( aElem.kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
    {
        SHAPE_LINE_CHAIN cutout;
        HelperShapeLineChainFromAltiumVertices( cutout, aElem.outline );
        m_boardCutouts.push_back( std::move( cutout ) );
    }
    else if( aElem.kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT || aElem.is_keepout )
    {
        SHAPE_LINE_CHAIN linechain;
        HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
        if( linechain.PointCount() < 3 )
        {
            // We have found multiple Altium files with polygon records containing nothing but
            // two coincident vertices.  These polygons do not appear when opening the file in
            // Altium.  https://gitlab.com/kicad/code/kicad/-/issues/8183
            // Also, polygons with less than 3 points are not supported in KiCad.
            return;
        }
 
        // A polygon cutout only removes copper, a keepout carries its own mask
        uint8_t restrictions = aElem.is_keepout ? HelperGetKeepoutRestrictions( aElem.keepoutrestrictions, aElem.layer )
                                                : ALTIUM_KEEPOUT_COPPER;
 
        if( restrictions == 0 )
            return;
 
        std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( m_board );
 
        zone->SetIsRuleArea( true );
 
        HelperSetZoneKeepoutRestrictions( *zone, restrictions );
 
        zone->SetPosition( aElem.outline.at( 0 ).position );
        zone->Outline()->AddOutline( linechain );
 
        HelperSetZoneLayers( *zone, aElem.layer );
 
        zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
                                     ZONE::GetDefaultHatchPitch(), true );
 
        m_board->Add( zone.release(), ADD_MODE::APPEND );
    }
    else if( aElem.is_teardrop )
    {
        SHAPE_LINE_CHAIN linechain;
        HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
        if( linechain.PointCount() < 3 )
        {
            // Polygons with less than 3 points are not supported in KiCad.
            return;
        }
 
        std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( m_board );
 
        zone->SetPosition( aElem.outline.at( 0 ).position );
        zone->Outline()->AddOutline( linechain );
 
        HelperSetZoneLayers( *zone, aElem.layer );
        zone->SetNetCode( GetNetCode( aElem.net ) );
        zone->SetTeardropAreaType( TEARDROP_TYPE::TD_UNSPECIFIED );
        zone->SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE::INVISIBLE_BORDER );
 
        SHAPE_POLY_SET fill;
        fill.Append( linechain );
        fill.Fracture();
 
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            zone->SetFilledPolysList( klayer, fill );
 
        zone->SetIsFilled( true );
        zone->SetNeedRefill( false );
 
        m_board->Add( zone.release(), ADD_MODE::APPEND );
    }
    else if( aElem.kind == ALTIUM_REGION_KIND::DASHED_OUTLINE )
    {
        PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
        if( klayer == UNDEFINED_LAYER )
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "Dashed outline found on an Altium layer (%d) with no KiCad equivalent. "
                               "It has been moved to KiCad layer Eco1_User." ), aElem.layer );
                m_reporter->Report( msg, RPT_SEVERITY_ERROR );
            }
 
            klayer = Eco1_User;
        }
 
        SHAPE_LINE_CHAIN linechain;
        HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
        if( linechain.PointCount() < 3 )
        {
            // We have found multiple Altium files with polygon records containing nothing but
            // two coincident vertices. These polygons do not appear when opening the file in
            // Altium. https://gitlab.com/kicad/code/kicad/-/issues/8183
            // Also, polygons with less than 3 points are not supported in KiCad.
            return;
        }
 
        std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::POLY );
 
        shape->SetPolyShape( linechain );
        shape->SetFilled( false );
        shape->SetLayer( klayer );
        shape->SetStroke( STROKE_PARAMS( pcbIUScale.mmToIU( 0.1 ), LINE_STYLE::DASH ) );
 
        m_board->Add( shape.release(), ADD_MODE::APPEND );
    }
    else if( aElem.kind == ALTIUM_REGION_KIND::COPPER )
    {
        if( aElem.polygon == ALTIUM_POLYGON_NONE )
        {
            for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
                ConvertShapeBasedRegions6ToBoardItemOnLayer( aElem, klayer, aPrimitiveIndex );
        }
    }
    else
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Ignored polygon shape of kind %d (not yet supported)." ), aElem.kind );
            m_reporter->Report( msg, RPT_SEVERITY_ERROR );
        }
    }
}
 
 
void ALTIUM_PCB::ConvertShapeBasedRegions6ToFootprintItem( FOOTPRINT*      aFootprint,
                                                           const AREGION6& aElem,
                                                           const int       aPrimitiveIndex )
{
    if( aElem.kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT || aElem.is_keepout )
    {
        SHAPE_LINE_CHAIN linechain;
        HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
        if( linechain.PointCount() < 3 )
        {
            // We have found multiple Altium files with polygon records containing nothing but
            // two coincident vertices. These polygons do not appear when opening the file in
            // Altium. https://gitlab.com/kicad/code/kicad/-/issues/8183
            // Also, polygons with less than 3 points are not supported in KiCad.
            return;
        }
 
        // A polygon cutout only removes copper, a keepout carries its own mask
        uint8_t restrictions = aElem.is_keepout ? HelperGetKeepoutRestrictions( aElem.keepoutrestrictions, aElem.layer )
                                                : ALTIUM_KEEPOUT_COPPER;
 
        if( restrictions == 0 )
            return;
 
        std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( aFootprint );
 
        zone->SetIsRuleArea( true );
 
        HelperSetZoneKeepoutRestrictions( *zone, restrictions );
 
        zone->SetPosition( aElem.outline.at( 0 ).position );
        zone->Outline()->AddOutline( linechain );
 
        HelperFootprintZoneToLibFrame( *zone, *aFootprint );
 
        HelperSetZoneLayers( *zone, aElem.layer );
 
        zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
                                     ZONE::GetDefaultHatchPitch(), true );
 
        aFootprint->Add( zone.release(), ADD_MODE::APPEND );
    }
    else if( aElem.kind == ALTIUM_REGION_KIND::COPPER )
    {
        if( aElem.polygon == ALTIUM_POLYGON_NONE )
        {
            for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            {
                ConvertShapeBasedRegions6ToFootprintItemOnLayer( aFootprint, aElem, klayer,
                                                                 aPrimitiveIndex );
            }
        }
    }
    else if( aElem.kind == ALTIUM_REGION_KIND::DASHED_OUTLINE
             || aElem.kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
    {
        PCB_LAYER_ID klayer = aElem.kind == ALTIUM_REGION_KIND::BOARD_CUTOUT
                                      ? Edge_Cuts
                                      : GetKicadLayer( aElem.layer );
 
        if( klayer == UNDEFINED_LAYER )
        {
            if( !m_footprintName.IsEmpty() )
            {
                if( m_reporter )
                {
                    wxString msg;
                    msg.Printf( _( "Loading library '%s':\n"
                                 "Footprint %s contains a dashed outline on Altium layer (%d) with "
                                 "no KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
                              m_library,
                              m_footprintName,
                              aElem.layer );
                    m_reporter->Report( msg, RPT_SEVERITY_ERROR );
                }
            }
            else
            {
                if( m_reporter )
                {
                    wxString msg;
                    msg.Printf( _( "Footprint %s contains a dashed outline on Altium layer (%d) with "
                                 "no KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
                              aFootprint->GetReference(),
                              aElem.layer );
                    m_reporter->Report( msg, RPT_SEVERITY_ERROR );
                }
            }
 
            klayer = Eco1_User;
        }
 
        SHAPE_LINE_CHAIN linechain;
        HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
        if( linechain.PointCount() < 3 )
        {
            // We have found multiple Altium files with polygon records containing nothing but
            // two coincident vertices. These polygons do not appear when opening the file in
            // Altium. https://gitlab.com/kicad/code/kicad/-/issues/8183
            // Also, polygons with less than 3 points are not supported in KiCad.
            return;
        }
 
        std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::POLY );
 
        shape->SetPolyShape( linechain );
        shape->SetFilled( false );
        shape->SetLayer( klayer );
 
        if( aElem.kind == ALTIUM_REGION_KIND::DASHED_OUTLINE )
            shape->SetStroke( STROKE_PARAMS( pcbIUScale.mmToIU( 0.1 ), LINE_STYLE::DASH ) );
        else
            shape->SetStroke( STROKE_PARAMS( pcbIUScale.mmToIU( 0.1 ), LINE_STYLE::SOLID ) );
 
        aFootprint->Add( shape.release(), ADD_MODE::APPEND );
    }
    else
    {
        if( !m_footprintName.IsEmpty() )
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "Error loading library '%s':\n"
                           "Footprint %s contains polygon shape of kind %d (not yet supported)." ),
                        m_library,
                        m_footprintName,
                        aElem.kind );
                m_reporter->Report( msg, RPT_SEVERITY_ERROR );
            }
        }
        else
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "Footprint %s contains polygon shape of kind %d (not yet supported)." ),
                        aFootprint->GetReference(),
                        aElem.kind );
                m_reporter->Report( msg, RPT_SEVERITY_ERROR );
            }
        }
    }
}
 
 
void ALTIUM_PCB::ConvertShapeBasedRegions6ToBoardItemOnLayer( const AREGION6& aElem, PCB_LAYER_ID aLayer,
                                                              const int aPrimitiveIndex )
{
    SHAPE_LINE_CHAIN linechain;
    HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
    if( linechain.PointCount() < 3 )
    {
        // We have found multiple Altium files with polygon records containing nothing
        // but two coincident vertices. These polygons do not appear when opening the
        // file in Altium. https://gitlab.com/kicad/code/kicad/-/issues/8183
        // Also, polygons with less than 3 points are not supported in KiCad.
        return;
    }
 
    SHAPE_POLY_SET polySet;
    polySet.AddOutline( linechain );
 
    for( const std::vector<ALTIUM_VERTICE>& hole : aElem.holes )
    {
        SHAPE_LINE_CHAIN hole_linechain;
        HelperShapeLineChainFromAltiumVertices( hole_linechain, hole );
 
        if( hole_linechain.PointCount() < 3 )
            continue;
 
        polySet.AddHole( hole_linechain );
    }
 
    std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::POLY );
 
    shape->SetPolyShape( polySet );
    shape->SetFilled( true );
    shape->SetLayer( aLayer );
    shape->SetStroke( STROKE_PARAMS( 0 ) );
 
    if( IsCopperLayer( aLayer ) && aElem.net != ALTIUM_NET_UNCONNECTED )
    {
        shape->SetNetCode( GetNetCode( aElem.net ) );
    }
 
    m_board->Add( shape.release(), ADD_MODE::APPEND );
 
    // Guard skips dup mask shapes when a MULTI_LAYER region iterates every copper layer
    if( aLayer == F_Cu || aLayer == B_Cu )
    {
        for( const auto& layerExpansionMask :
             HelperGetSolderAndPasteMaskExpansions( ALTIUM_RECORD::REGION, aPrimitiveIndex, aElem.layer ) )
        {
            const PCB_LAYER_ID maskLayer = layerExpansionMask.first;
 
            if( ( ( maskLayer == F_Mask || maskLayer == F_Paste ) && aLayer != F_Cu )
                || ( ( maskLayer == B_Mask || maskLayer == B_Paste ) && aLayer != B_Cu ) )
            {
                continue;
            }
 
            int expansion = layerExpansionMask.second;
 
            SHAPE_POLY_SET expandedPolySet = polySet;
            expandedPolySet.Inflate( expansion, CORNER_STRATEGY::ROUND_ALL_CORNERS, ARC_HIGH_DEF );
 
            std::unique_ptr<PCB_SHAPE> maskShape = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::POLY );
 
            maskShape->SetPolyShape( expandedPolySet );
            maskShape->SetFilled( true );
            maskShape->SetLayer( maskLayer );
            maskShape->SetStroke( STROKE_PARAMS( 0 ) );
 
            m_board->Add( maskShape.release(), ADD_MODE::APPEND );
        }
    }
}
 
 
void ALTIUM_PCB::ConvertShapeBasedRegions6ToFootprintItemOnLayer( FOOTPRINT*      aFootprint,
                                                                  const AREGION6& aElem,
                                                                  PCB_LAYER_ID    aLayer,
                                                                  const int       aPrimitiveIndex )
{
    SHAPE_LINE_CHAIN linechain;
    HelperShapeLineChainFromAltiumVertices( linechain, aElem.outline );
 
    if( linechain.PointCount() < 3 )
    {
        // We have found multiple Altium files with polygon records containing nothing
        // but two coincident vertices. These polygons do not appear when opening the
        // file in Altium. https://gitlab.com/kicad/code/kicad/-/issues/8183
        // Also, polygons with less than 3 points are not supported in KiCad.
        return;
    }
 
    SHAPE_POLY_SET polySet;
    polySet.AddOutline( linechain );
 
    for( const std::vector<ALTIUM_VERTICE>& hole : aElem.holes )
    {
        SHAPE_LINE_CHAIN hole_linechain;
        HelperShapeLineChainFromAltiumVertices( hole_linechain, hole );
 
        if( hole_linechain.PointCount() < 3 )
            continue;
 
        polySet.AddHole( hole_linechain );
    }
 
    if( aLayer == F_Cu || aLayer == B_Cu )
    {
        std::unique_ptr<PAD> pad = std::make_unique<PAD>( aFootprint );
 
        LSET padLayers;
        padLayers.set( aLayer );
 
        pad->SetAttribute( PAD_ATTRIB::SMD );
        pad->SetPadstackMode( PADSTACK::MODE::NORMAL );
        pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CUSTOM );
        pad->SetThermalSpokeAngle( ANGLE_90 );
 
        int      anchorSize = 1;
        VECTOR2I anchorPos = linechain.CPoint( 0 );
 
        pad->SetAnchorPadShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );
        pad->SetSize( PADSTACK::ALL_LAYERS, { anchorSize, anchorSize } );
        pad->SetPosition( anchorPos );
        pad->SetNetCode( GetNetCode( aElem.net ) );
 
        // The primitives below are board-absolute, but a pad defaults to its footprint's angle
        pad->SetOrientation( ANGLE_0 );
 
        SHAPE_POLY_SET shapePolys = polySet;
        shapePolys.Move( -anchorPos );
        pad->AddPrimitivePoly( PADSTACK::ALL_LAYERS, shapePolys, 0, true );
 
        auto& map = m_extendedPrimitiveInformationMaps[ALTIUM_RECORD::REGION];
        auto  it = map.find( aPrimitiveIndex );
 
        if( it != map.end() )
        {
            const AEXTENDED_PRIMITIVE_INFORMATION& info = it->second;
 
            if( info.pastemaskexpansionmode == ALTIUM_MODE::MANUAL )
            {
                pad->SetLocalSolderPasteMargin( info.pastemaskexpansionmanual );
            }
 
            if( info.soldermaskexpansionmode == ALTIUM_MODE::MANUAL )
            {
                pad->SetLocalSolderMaskMargin( info.soldermaskexpansionmanual );
            }
 
            if( info.pastemaskexpansionmode != ALTIUM_MODE::NONE )
                padLayers.set( aLayer == F_Cu ? F_Paste : B_Paste );
 
            if( info.soldermaskexpansionmode != ALTIUM_MODE::NONE )
                padLayers.set( aLayer == F_Cu ? F_Mask : B_Mask );
        }
 
        pad->SetLayerSet( padLayers );
 
        aFootprint->Add( pad.release(), ADD_MODE::APPEND );
    }
    else
    {
        std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::POLY );
 
        shape->SetPolyShape( polySet );
        shape->SetFilled( true );
        shape->SetLayer( aLayer );
        shape->SetStroke( STROKE_PARAMS( 0 ) );
 
        aFootprint->Add( shape.release(), ADD_MODE::APPEND );
    }
}
 
 
void ALTIUM_PCB::ParseRegions6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                    const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading zone fills..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        AREGION6 elem( reader, false );
 
        if( elem.polygon != ALTIUM_POLYGON_NONE )
        {
            if( m_polygons.size() <= elem.polygon )
            {
                THROW_IO_ERRORF( wxT( "Region stream tries to access polygon id %d of %d existing polygons." ),
                                 elem.polygon, m_polygons.size() );
            }
 
            ZONE* zone = m_polygons.at( elem.polygon );
 
            if( zone == nullptr )
                continue; // we know the zone id, but because we do not know the layer we did not add it!
 
            PCB_LAYER_ID klayer = GetKicadLayer( elem.layer );
 
            if( klayer == UNDEFINED_LAYER )
                continue; // Just skip it for now. Users can fill it themselves.
 
            SHAPE_LINE_CHAIN linechain;
 
            for( const ALTIUM_VERTICE& vertice : elem.outline )
                linechain.Append( vertice.position );
 
            linechain.Append( elem.outline.at( 0 ).position );
            linechain.SetClosed( true );
 
            SHAPE_POLY_SET fill;
            fill.AddOutline( linechain );
 
            for( const std::vector<ALTIUM_VERTICE>& hole : elem.holes )
            {
                SHAPE_LINE_CHAIN hole_linechain;
 
                for( const ALTIUM_VERTICE& vertice : hole )
                    hole_linechain.Append( vertice.position );
 
                hole_linechain.Append( hole.at( 0 ).position );
                hole_linechain.SetClosed( true );
                fill.AddHole( hole_linechain );
            }
 
            if( zone->HasFilledPolysForLayer( klayer ) )
                fill.BooleanAdd( *zone->GetFill( klayer ) );
 
            fill.Fracture();
 
            zone->SetFilledPolysList( klayer, fill );
            zone->SetIsFilled( true );
            zone->SetNeedRefill( false );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Regions6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ParseArcs6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                 const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading arcs..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    for( int primitiveIndex = 0; reader.GetRemainingBytes() >= 4; primitiveIndex++ )
    {
        checkpoint();
        AARC6 elem( reader );
 
        if( elem.component == ALTIUM_COMPONENT_NONE )
        {
            ConvertArcs6ToBoardItem( elem, primitiveIndex );
        }
        else
        {
            FOOTPRINT* footprint = HelperGetFootprint( elem.component );
            ConvertArcs6ToFootprintItem( footprint, elem, primitiveIndex, true );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Arcs6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertArcs6ToPcbShape( const AARC6& aElem, PCB_SHAPE* aShape )
{
    if( aElem.startangle == 0. && aElem.endangle == 360. )
    {
        aShape->SetShape( SHAPE_T::CIRCLE );
 
        // TODO: other variants to define circle?
        aShape->SetStart( aElem.center );
        aShape->SetEnd( aElem.center - VECTOR2I( 0, aElem.radius ) );
    }
    else
    {
        aShape->SetShape( SHAPE_T::ARC );
 
        EDA_ANGLE includedAngle( aElem.endangle - aElem.startangle, DEGREES_T );
        EDA_ANGLE startAngle( aElem.endangle, DEGREES_T );
 
        VECTOR2I startOffset = VECTOR2I( KiROUND( startAngle.Cos() * aElem.radius ),
                                         -KiROUND( startAngle.Sin() * aElem.radius ) );
 
        aShape->SetCenter( aElem.center );
        aShape->SetStart( aElem.center + startOffset );
        aShape->SetArcAngleAndEnd( includedAngle.Normalize(), true );
    }
}
 
 
void ALTIUM_PCB::ConvertArcs6ToBoardItem( const AARC6& aElem, const int aPrimitiveIndex )
{
    if( aElem.polygon != ALTIUM_POLYGON_NONE && aElem.polygon != ALTIUM_POLYGON_BOARD )
    {
        if( m_polygons.size() <= aElem.polygon )
        {
            THROW_IO_ERRORF( wxT( "Tracks stream tries to access polygon id %u of %zu existing polygons." ),
                             aElem.polygon, m_polygons.size() );
        }
 
        ZONE* zone = m_polygons.at( aElem.polygon );
 
        if( zone == nullptr )
        {
            return; // we know the zone id, but because we do not know the layer we did not
                    // add it!
        }
 
        PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
        if( klayer == UNDEFINED_LAYER )
            return; // Just skip it for now. Users can fill it themselves.
 
        if( !zone->HasFilledPolysForLayer( klayer ) )
            return;
 
        SHAPE_POLY_SET* fill = zone->GetFill( klayer );
 
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr );
 
        ConvertArcs6ToPcbShape( aElem, &shape );
        shape.SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
        shape.EDA_SHAPE::TransformShapeToPolygon( *fill, 0, ARC_HIGH_DEF, ERROR_INSIDE );
        // Will be simplified and fractured later
 
        zone->SetIsFilled( true );
        zone->SetNeedRefill( false );
 
        return;
    }
 
    if( aElem.is_keepout || aElem.layer == ALTIUM_LAYER::KEEP_OUT_LAYER
        || IsAltiumLayerAPlane( aElem.layer ) )
    {
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr );
 
        ConvertArcs6ToPcbShape( aElem, &shape );
        shape.SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
        HelperPcpShapeAsBoardKeepoutRegion( shape, aElem.layer, aElem.keepoutrestrictions );
    }
    else
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            ConvertArcs6ToBoardItemOnLayer( aElem, klayer );
    }
 
    for( const auto& layerExpansionMask :
         HelperGetSolderAndPasteMaskExpansions( ALTIUM_RECORD::ARC, aPrimitiveIndex, aElem.layer ) )
    {
        int width = aElem.width + ( layerExpansionMask.second * 2 );
 
        if( width > 1 )
        {
            std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( m_board );
 
            ConvertArcs6ToPcbShape( aElem, arc.get() );
            arc->SetStroke( STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
            arc->SetLayer( layerExpansionMask.first );
 
            m_board->Add( arc.release(), ADD_MODE::APPEND );
        }
    }
}
 
 
void ALTIUM_PCB::ConvertArcs6ToFootprintItem( FOOTPRINT* aFootprint, const AARC6& aElem,
                                              const int aPrimitiveIndex, const bool aIsBoardImport )
{
    if( aElem.polygon != ALTIUM_POLYGON_NONE )
    {
        wxFAIL_MSG( wxString::Format( "Altium: Unexpected footprint Arc with polygon id %d",
                                      aElem.polygon ) );
        return;
    }
 
    if( aElem.is_keepout || aElem.layer == ALTIUM_LAYER::KEEP_OUT_LAYER
        || IsAltiumLayerAPlane( aElem.layer ) )
    {
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr );
 
        ConvertArcs6ToPcbShape( aElem, &shape );
        shape.SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
        HelperPcpShapeAsFootprintKeepoutRegion( aFootprint, shape, aElem.layer,
                                                aElem.keepoutrestrictions );
    }
    else
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
        {
            if( IsCopperLayer( klayer ) && ( !aIsBoardImport || aElem.net != ALTIUM_NET_UNCONNECTED ) )
            {
                // Footprint graphics are not connected, so copper waits to join a pad it touches
                std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( nullptr );
 
                ConvertArcs6ToPcbShape( aElem, arc.get() );
                arc->SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
                HelperDeferComponentCopper( aFootprint, klayer, aIsBoardImport ? aElem.net : ALTIUM_NET_UNCONNECTED,
                                            std::move( arc ),
                                            [this, aFootprint, aElem, klayer, aIsBoardImport]()
                                            {
                                                if( aIsBoardImport )
                                                    ConvertArcs6ToBoardItemOnLayer( aElem, klayer );
                                                else
                                                    ConvertArcs6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
                                            } );
            }
            else
            {
                ConvertArcs6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
            }
        }
    }
 
    for( const auto& layerExpansionMask :
         HelperGetSolderAndPasteMaskExpansions( ALTIUM_RECORD::ARC, aPrimitiveIndex, aElem.layer ) )
    {
        int width = aElem.width + ( layerExpansionMask.second * 2 );
 
        if( width > 1 )
        {
            std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( aFootprint );
 
            ConvertArcs6ToPcbShape( aElem, arc.get() );
            arc->SetStroke( STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
            arc->SetLayer( layerExpansionMask.first );
 
            aFootprint->Add( arc.release(), ADD_MODE::APPEND );
        }
    }
}
 
 
void ALTIUM_PCB::ConvertArcs6ToBoardItemOnLayer( const AARC6& aElem, PCB_LAYER_ID aLayer )
{
    if( IsCopperLayer( aLayer ) && aElem.net != ALTIUM_NET_UNCONNECTED )
    {
        double    sweepDegrees = aElem.endangle - aElem.startangle;
        EDA_ANGLE includedAngle( sweepDegrees, DEGREES_T );
        EDA_ANGLE startAngle( aElem.endangle, DEGREES_T );
 
        VECTOR2I startOffset = VECTOR2I( KiROUND( startAngle.Cos() * aElem.radius ),
                                         -KiROUND( startAngle.Sin() * aElem.radius ) );
 
        auto addArc = [&]( const VECTOR2I& aStart, const EDA_ANGLE& aAngle )
        {
            SHAPE_ARC                shapeArc( aElem.center, aStart, aAngle, aElem.width );
            std::unique_ptr<PCB_ARC> arc = std::make_unique<PCB_ARC>( m_board, &shapeArc );
 
            arc->SetWidth( aElem.width );
            arc->SetLayer( aLayer );
            arc->SetNetCode( GetNetCode( aElem.net ) );
 
            PCB_ARC* added = arc.release();
            m_board->Add( added, ADD_MODE::APPEND );
 
            if( aElem.unionindex != 0 )
                m_unionToBoardItems[static_cast<int>( aElem.unionindex )].push_back( added );
        };
 
        // PCB_ARC cannot represent a closed sweep, so emit the ring as two halves
        if( std::abs( sweepDegrees ) >= 359.999 )
        {
            EDA_ANGLE halfSweep( sweepDegrees < 0. ? -180. : 180., DEGREES_T );
 
            addArc( aElem.center + startOffset, halfSweep );
            addArc( aElem.center - startOffset, halfSweep );
            return;
        }
 
        includedAngle.Normalize();
 
        if( includedAngle.AsDegrees() >= 0.1 )
            addArc( aElem.center + startOffset, includedAngle );
    }
    else
    {
        std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>(m_board);
 
        ConvertArcs6ToPcbShape( aElem, arc.get() );
        arc->SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
        arc->SetLayer( aLayer );
 
        m_board->Add( arc.release(), ADD_MODE::APPEND );
    }
}
 
 
void ALTIUM_PCB::ConvertArcs6ToFootprintItemOnLayer( FOOTPRINT* aFootprint, const AARC6& aElem,
                                                     PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( aFootprint );
 
    ConvertArcs6ToPcbShape( aElem, arc.get() );
    arc->SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
    arc->SetLayer( aLayer );
 
    aFootprint->Add( arc.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ParsePads6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                 const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading pads..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        APAD6 elem( reader );
 
        if( elem.component == ALTIUM_COMPONENT_NONE )
        {
            ConvertPads6ToBoardItem( elem );
        }
        else
        {
            FOOTPRINT* footprint = HelperGetFootprint( elem.component );
            ConvertPads6ToFootprintItem( footprint, elem );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Pads6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertPads6ToBoardItem( const APAD6& aElem )
{
    // It is possible to place altium pads on non-copper layers -> we need to interpolate them using drawings!
    if( !IsAltiumLayerCopper( aElem.layer ) && !IsAltiumLayerAPlane( aElem.layer )
        && aElem.layer != ALTIUM_LAYER::MULTI_LAYER )
    {
        ConvertPads6ToBoardItemOnNonCopper( aElem );
    }
    else
    {
        // We cannot add a pad directly into the PCB
        std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>( m_board );
        footprint->SetPosition( aElem.position );
 
        // This wrapper exists only to carry a free-standing pad; it has no schematic symbol and
        // nothing to buy or place, so keep it out of the BOM and the placement files.
        footprint->SetAttributes( FP_BOARD_ONLY | FP_EXCLUDE_FROM_BOM | FP_EXCLUDE_FROM_POS_FILES );
 
        ConvertPads6ToFootprintItemOnCopper( footprint.get(), aElem );
 
        m_board->Add( footprint.release(), ADD_MODE::APPEND );
    }
}
 
 
PAD* ALTIUM_PCB::ConvertVias6ToFootprintItem( FOOTPRINT* aFootprint, const AVIA6& aElem )
{
    std::unique_ptr<PAD> pad = std::make_unique<PAD>( aFootprint );
 
    pad->SetNumber( "" );
    pad->SetNetCode( GetNetCode( aElem.net ) );
 
    pad->SetPosition( aElem.position );
    pad->SetDrillSize( VECTOR2I( aElem.holesize, aElem.holesize ) );
    pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
    pad->SetAttribute( PAD_ATTRIB::PTH );
 
    // Pads are always through holes in KiCad
    pad->SetLayerSet( LSET().AllCuMask() );
 
    if( aElem.viamode == ALTIUM_PAD_MODE::SIMPLE )
    {
        pad->Padstack().SetMode( PADSTACK::MODE::NORMAL );
        pad->SetSize( PADSTACK::ALL_LAYERS, VECTOR2I( aElem.diameter, aElem.diameter ) );
        pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );
    }
    else if( aElem.viamode == ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM )
    {
        pad->Padstack().SetMode( PADSTACK::MODE::FRONT_INNER_BACK );
 
        int top = aElem.diameter_by_layer[ALTIUM_TOP_PADSTACK_IDX];
        int mid = aElem.diameter_by_layer[ALTIUM_MID1_PADSTACK_IDX];
        int bot = aElem.diameter_by_layer[ALTIUM_BOTTOM_PADSTACK_IDX];
 
        pad->SetSize( F_Cu, VECTOR2I( top, top ) );
        pad->SetShape( F_Cu, PAD_SHAPE::CIRCLE );
 
        pad->SetSize( PADSTACK::INNER_LAYERS, VECTOR2I( mid, mid ) );
        pad->SetShape( PADSTACK::INNER_LAYERS, PAD_SHAPE::CIRCLE );
 
        pad->SetSize( B_Cu, VECTOR2I( bot, bot ) );
        pad->SetShape( B_Cu, PAD_SHAPE::CIRCLE );
    }
    else
    {
        pad->Padstack().SetMode( PADSTACK::MODE::CUSTOM );
 
        LSET cuLayers = LSET::AllCuMask();
 
        if( m_board )
            cuLayers &= m_board->GetEnabledLayers();
 
        for( PCB_LAYER_ID layer : cuLayers )
        {
            int altiumIdx = HelperGetPadstackLayerIndex( layer );
 
            // Internal planes carry no padstack entry; the via keeps its nominal land there
            int diameter = altiumIdx < 0 ? aElem.diameter : aElem.diameter_by_layer[altiumIdx];
 
            pad->SetSize( layer, VECTOR2I( diameter, diameter ) );
            pad->SetShape( layer, PAD_SHAPE::CIRCLE );
        }
    }
 
    // Same rule as a board via, so a via folded into its component keeps its mask opening
    bool tentTop = altiumViaSideIsTented( aElem.is_tent_top, aElem.soldermask_expansion_manual,
                                          aElem.soldermask_expansion_from_hole, aElem.holesize,
                                          aElem.soldermask_expansion_front, pad->GetSize( F_Cu ).x );
 
    bool tentBottom = altiumViaSideIsTented( aElem.is_tent_bottom, aElem.soldermask_expansion_manual,
                                             aElem.soldermask_expansion_from_hole, aElem.holesize,
                                             aElem.soldermask_expansion_back, pad->GetSize( B_Cu ).x );
 
    if( tentTop )
    {
        pad->Padstack().FrontOuterLayers().has_solder_mask = true;
    }
    else
    {
        pad->Padstack().FrontOuterLayers().has_solder_mask = false;
        pad->SetLayerSet( pad->GetLayerSet().set( F_Mask ) );
    }
 
    if( tentBottom )
    {
        pad->Padstack().BackOuterLayers().has_solder_mask = true;
    }
    else
    {
        pad->Padstack().BackOuterLayers().has_solder_mask = false;
        pad->SetLayerSet( pad->GetLayerSet().set( B_Mask ) );
    }
 
    if( aElem.is_locked )
        pad->SetLocked( true );
 
    if( aElem.soldermask_expansion_manual )
    {
        pad->Padstack().FrontOuterLayers().solder_mask_margin = aElem.soldermask_expansion_front;
        pad->Padstack().BackOuterLayers().solder_mask_margin = aElem.soldermask_expansion_back;
    }
 
    PAD* added = pad.release();
    aFootprint->Add( added, ADD_MODE::APPEND );
    return added;
}
 
 
void ALTIUM_PCB::ConvertPads6ToFootprintItem( FOOTPRINT* aFootprint, const APAD6& aElem )
{
    // It is possible to place altium pads on non-copper layers -> we need to interpolate them using drawings!
    if( !IsAltiumLayerCopper( aElem.layer ) && !IsAltiumLayerAPlane( aElem.layer )
        && aElem.layer != ALTIUM_LAYER::MULTI_LAYER )
    {
        ConvertPads6ToFootprintItemOnNonCopper( aFootprint, aElem );
    }
    else
    {
        ConvertPads6ToFootprintItemOnCopper( aFootprint, aElem );
    }
}
 
 
void ALTIUM_PCB::ConvertPads6ToFootprintItemOnCopper( FOOTPRINT* aFootprint, const APAD6& aElem )
{
    std::unique_ptr<PAD> pad = std::make_unique<PAD>( aFootprint );
 
    pad->SetNumber( aElem.name );
    pad->SetNetCode( GetNetCode( aElem.net ) );
 
    pad->SetPosition( aElem.position );
    pad->SetOrientationDegrees( aElem.direction );
    pad->SetThermalSpokeAngle( ANGLE_90 );
 
    if( aElem.holesize == 0 )
    {
        pad->SetAttribute( PAD_ATTRIB::SMD );
    }
    else
    {
        if( aElem.layer != ALTIUM_LAYER::MULTI_LAYER )
        {
            // TODO: I assume other values are possible as well?
            if( !m_footprintName.IsEmpty() )
            {
                if( m_reporter )
                {
                    wxString msg;
                    msg.Printf( _( "Error loading library '%s':\n"
                               "Footprint %s pad %s is not marked as multilayer, but is a TH pad." ),
                            m_library,
                            m_footprintName,
                            aElem.name );
                    m_reporter->Report( msg, RPT_SEVERITY_ERROR );
                }
            }
            else
            {
                if( m_reporter )
                {
                    wxString msg;
                    msg.Printf( _( "Footprint %s pad %s is not marked as multilayer, but is a TH pad." ),
                            aFootprint->GetReference(),
                            aElem.name );
                    m_reporter->Report( msg, RPT_SEVERITY_ERROR );
                }
            }
        }
 
        pad->SetAttribute( aElem.plated ? PAD_ATTRIB::PTH : PAD_ATTRIB::NPTH );
 
        if( !aElem.sizeAndShape || aElem.sizeAndShape->holeshape == ALTIUM_PAD_HOLE_SHAPE::ROUND )
        {
            pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
            pad->SetDrillSize( VECTOR2I( aElem.holesize, aElem.holesize ) );
        }
        else
        {
            switch( aElem.sizeAndShape->holeshape )
            {
            case ALTIUM_PAD_HOLE_SHAPE::ROUND:
                wxFAIL_MSG( wxT( "Round holes are handled before the switch" ) );
                break;
 
            case ALTIUM_PAD_HOLE_SHAPE::SQUARE:
                if( !m_footprintName.IsEmpty() )
                {
                    if( m_reporter )
                    {
                        wxString msg;
                        msg.Printf( _( "Loading library '%s':\n"
                                     "Footprint %s pad %s has a square hole (not yet supported)." ),
                                  m_library,
                                  m_footprintName,
                                  aElem.name );
                        m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                    }
                }
                else
                {
                    if( m_reporter )
                    {
                        wxString msg;
                        msg.Printf( _( "Footprint %s pad %s has a square hole (not yet supported)." ),
                                  aFootprint->GetReference(),
                                  aElem.name );
                        m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                    }
                }
 
                pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
                pad->SetDrillSize( VECTOR2I( aElem.holesize, aElem.holesize ) ); // Workaround
                // TODO: elem.sizeAndShape->slotsize was 0 in testfile. Either use holesize in
                //  this case or rect holes have a different id
                break;
 
            case ALTIUM_PAD_HOLE_SHAPE::SLOT:
            {
                pad->SetDrillShape( PAD_DRILL_SHAPE::OBLONG );
                bool slotRotationSupported;
                pad->SetDrillSize( altiumSlotDrillSize( aElem.holesize, aElem.sizeAndShape->slotsize,
                                                        aElem.sizeAndShape->slotrotation, slotRotationSupported ) );
 
                if( !slotRotationSupported )
                {
                    EDA_ANGLE slotRotation( aElem.sizeAndShape->slotrotation, DEGREES_T );
                    slotRotation.Normalize();
 
                    if( !m_footprintName.IsEmpty() )
                    {
                        if( m_reporter )
                        {
                            wxString msg;
                            msg.Printf( _( "Loading library '%s':\n"
                                         "Footprint %s pad %s has a hole-rotation of %d degrees. "
                                         "KiCad only supports 90 degree rotations." ),
                                      m_library,
                                      m_footprintName,
                                      aElem.name,
                                      KiROUND( slotRotation.AsDegrees() ) );
                            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                        }
                    }
                    else
                    {
                        if( m_reporter )
                        {
                            wxString msg;
                            msg.Printf( _( "Footprint %s pad %s has a hole-rotation of %d degrees. "
                                         "KiCad only supports 90 degree rotations." ),
                                      aFootprint->GetReference(),
                                      aElem.name,
                                      KiROUND( slotRotation.AsDegrees() ) );
                            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                        }
                    }
                }
 
                break;
            }
 
            default:
            case ALTIUM_PAD_HOLE_SHAPE::UNKNOWN:
                if( !m_footprintName.IsEmpty() )
                {
                    if( m_reporter )
                    {
                        wxString msg;
                        msg.Printf( _( "Error loading library '%s':\n"
                                   "Footprint %s pad %s uses a hole of unknown kind %d." ),
                                m_library,
                                m_footprintName,
                                aElem.name,
                                aElem.sizeAndShape->holeshape );
                        m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                    }
                }
                else
                {
                    if( m_reporter )
                    {
                        wxString msg;
                        msg.Printf( _( "Footprint %s pad %s uses a hole of unknown kind %d." ),
                                aFootprint->GetReference(),
                                aElem.name,
                                aElem.sizeAndShape->holeshape );
                        m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                    }
                }
 
                pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
                pad->SetDrillSize( VECTOR2I( aElem.holesize, aElem.holesize ) ); // Workaround
                break;
            }
        }
    }
 
    PADSTACK& ps = pad->Padstack();
 
    auto setCopperGeometry =
            [&]( PCB_LAYER_ID aLayer, int aAltiumIdx, ALTIUM_PAD_SHAPE aShape,
                 const VECTOR2I& aSize )
            {
                bool hasAltiumEntry = aElem.sizeAndShape && aAltiumIdx >= 0
                                      && aAltiumIdx < ALTIUM_PADSTACK_IDX_COUNT;
 
                ps.SetSize( aSize, aLayer );
 
                if( aElem.holesize != 0 && hasAltiumEntry )
                    ps.SetOffset( aElem.sizeAndShape->holeoffset[aAltiumIdx], aLayer );
 
                switch( aShape )
                {
                case ALTIUM_PAD_SHAPE::RECT:
                    ps.SetShape( PAD_SHAPE::RECTANGLE, aLayer );
                    break;
 
                case ALTIUM_PAD_SHAPE::CIRCLE:
                    if( hasAltiumEntry
                        && aElem.sizeAndShape->alt_shape[aAltiumIdx] == ALTIUM_PAD_SHAPE_ALT::ROUNDRECT )
                    {
                        ps.SetShape( PAD_SHAPE::ROUNDRECT, aLayer ); // 100 = round, 0 = rectangular
                        double ratio = aElem.sizeAndShape->cornerradius[aAltiumIdx] / 200.;
                        ps.SetRoundRectRadiusRatio( ratio, aLayer );
                    }
                    else if( aSize.x == aSize.y )
                    {
                        ps.SetShape( PAD_SHAPE::CIRCLE, aLayer );
                    }
                    else
                    {
                        ps.SetShape( PAD_SHAPE::OVAL, aLayer );
                    }
 
                    break;
 
                case ALTIUM_PAD_SHAPE::OCTAGONAL:
                    ps.SetShape( PAD_SHAPE::CHAMFERED_RECT, aLayer );
                    ps.SetChamferPositions( RECT_CHAMFER_ALL, aLayer );
                    ps.SetChamferRatio( 0.25, aLayer );
                    break;
 
                case ALTIUM_PAD_SHAPE::UNKNOWN:
                default:
                    if( !m_footprintName.IsEmpty() )
                    {
                        if( m_reporter )
                        {
                            wxString msg;
                            msg.Printf( _( "Error loading library '%s':\n"
                                           "Footprint %s pad %s uses an unknown pad shape." ),
                                        m_library,
                                        m_footprintName,
                                        aElem.name );
                            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                        }
                    }
                    else
                    {
                        if( m_reporter )
                        {
                            wxString msg;
                            msg.Printf( _( "Footprint %s pad %s uses an unknown pad shape." ),
                                        aFootprint->GetReference(),
                                        aElem.name );
                            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
                        }
                    }
                    break;
                }
            };
 
    switch( aElem.padmode )
    {
    case ALTIUM_PAD_MODE::SIMPLE:
        ps.SetMode( PADSTACK::MODE::NORMAL );
        setCopperGeometry( PADSTACK::ALL_LAYERS, ALTIUM_TOP_PADSTACK_IDX, aElem.topshape,
                           aElem.topsize );
        break;
 
    case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
        ps.SetMode( PADSTACK::MODE::FRONT_INNER_BACK );
        setCopperGeometry( F_Cu, ALTIUM_TOP_PADSTACK_IDX, aElem.topshape, aElem.topsize );
        setCopperGeometry( PADSTACK::INNER_LAYERS, ALTIUM_MID1_PADSTACK_IDX, aElem.midshape,
                           aElem.midsize );
        setCopperGeometry( B_Cu, ALTIUM_BOTTOM_PADSTACK_IDX, aElem.botshape, aElem.botsize );
        break;
 
    case ALTIUM_PAD_MODE::FULL_STACK:
    {
        ps.SetMode( PADSTACK::MODE::CUSTOM );
 
        setCopperGeometry( F_Cu, HelperGetPadstackLayerIndex( F_Cu ), aElem.topshape,
                           aElem.topsize );
        setCopperGeometry( B_Cu, HelperGetPadstackLayerIndex( B_Cu ), aElem.botshape,
                           aElem.botsize );
 
        LSET intLayers = aFootprint->BoardLayerSet() & LSET::InternalCuMask();
 
        for( PCB_LAYER_ID layer : intLayers )
        {
            int idx = HelperGetPadstackLayerIndex( layer );
            int inner = idx - ALTIUM_MID2_PADSTACK_IDX;
 
            // Mid layer 1 is carried in the record itself, and internal planes have no entry at
            // all, so both fall back to it
            if( !aElem.sizeAndShape || inner < 0
                || inner >= static_cast<int>( std::size( aElem.sizeAndShape->inner_size ) ) )
            {
                setCopperGeometry( layer, idx, aElem.midshape, aElem.midsize );
            }
            else
            {
                const APAD6_SIZE_AND_SHAPE& shape = *aElem.sizeAndShape;
 
                setCopperGeometry( layer, idx, shape.inner_shape[inner],
                                   VECTOR2I( shape.inner_size[inner].x,
                                             shape.inner_size[inner].y ) );
            }
        }
 
        break;
    }
    }
 
    switch( aElem.layer )
    {
    case ALTIUM_LAYER::TOP_LAYER:
        pad->SetLayer( F_Cu );
        pad->SetLayerSet( PAD::SMDMask() );
        break;
 
    case ALTIUM_LAYER::BOTTOM_LAYER:
        pad->SetLayer( B_Cu );
        pad->SetLayerSet( PAD::SMDMask().FlipStandardLayers() );
        break;
 
    case ALTIUM_LAYER::MULTI_LAYER:
        pad->SetLayerSet( aElem.plated ? PAD::PTHMask() : PAD::UnplatedHoleMask() );
        break;
 
    default:
        PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
        pad->SetLayer( klayer );
        pad->SetLayerSet( LSET( { klayer } ) );
        break;
    }
 
    if( aElem.pastemaskexpansionmode == ALTIUM_MODE::MANUAL )
        pad->SetLocalSolderPasteMargin( aElem.pastemaskexpansionmanual );
 
    if( aElem.soldermaskexpansionmode == ALTIUM_MODE::MANUAL )
        pad->SetLocalSolderMaskMargin( aElem.soldermaskexpansionmanual );
 
    if( aElem.is_tent_top )
        pad->SetLayerSet( pad->GetLayerSet().reset( F_Mask ) );
 
    if( aElem.is_tent_bottom )
        pad->SetLayerSet( pad->GetLayerSet().reset( B_Mask ) );
 
    pad->SetPadToDieLength( aElem.pad_to_die_length );
    pad->SetPadToDieDelay( aElem.pad_to_die_delay );
 
    aFootprint->Add( pad.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ConvertPads6ToBoardItemOnNonCopper( const APAD6& aElem )
{
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Non-copper pad %s found on an Altium layer (%d) with no KiCad "
                         "equivalent. It has been moved to KiCad layer Eco1_User." ),
                      aElem.name, aElem.layer );
            m_reporter->Report( msg, RPT_SEVERITY_INFO );
        }
 
        klayer = Eco1_User;
    }
 
    std::unique_ptr<PCB_SHAPE> pad = std::make_unique<PCB_SHAPE>( m_board );
 
    HelperParsePad6NonCopper( aElem, klayer, pad.get() );
 
    m_board->Add( pad.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ConvertPads6ToFootprintItemOnNonCopper( FOOTPRINT* aFootprint, const APAD6& aElem )
{
    PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
    if( klayer == UNDEFINED_LAYER )
    {
        if( !m_footprintName.IsEmpty() )
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "Loading library '%s':\n"
                             "Footprint %s non-copper pad %s found on an Altium layer (%d) with no "
                             "KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
                          m_library,
                          m_footprintName,
                          aElem.name,
                          aElem.layer );
                m_reporter->Report( msg, RPT_SEVERITY_INFO );
            }
        }
        else
        {
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( _( "Footprint %s non-copper pad %s found on an Altium layer (%d) with no "
                             "KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
                          aFootprint->GetReference(),
                          aElem.name,
                          aElem.layer );
                m_reporter->Report( msg, RPT_SEVERITY_INFO );
            }
        }
 
        klayer = Eco1_User;
    }
 
    std::unique_ptr<PCB_SHAPE> pad = std::make_unique<PCB_SHAPE>( aFootprint );
 
    HelperParsePad6NonCopper( aElem, klayer, pad.get() );
 
    aFootprint->Add( pad.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::HelperParsePad6NonCopper( const APAD6& aElem, PCB_LAYER_ID aLayer,
                                           PCB_SHAPE* aShape )
{
    if( aElem.net != ALTIUM_NET_UNCONNECTED )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Non-copper pad %s is connected to a net, which is not supported." ),
                    aElem.name );
            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
        }
    }
 
    if( aElem.holesize != 0 )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Non-copper pad %s has a hole, which is not supported." ), aElem.name );
            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
        }
    }
 
    if( aElem.padmode != ALTIUM_PAD_MODE::SIMPLE )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Non-copper pad %s has a complex pad stack (not yet supported)." ),
                        aElem.name );
            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
        }
    }
 
    switch( aElem.topshape )
    {
    case ALTIUM_PAD_SHAPE::RECT:
    {
        // filled rect
        aShape->SetShape( SHAPE_T::POLY );
        aShape->SetFilled( true );
        aShape->SetLayer( aLayer );
        aShape->SetStroke( STROKE_PARAMS( 0 ) );
 
        aShape->SetPolyPoints( { aElem.position + VECTOR2I( aElem.topsize.x / 2, aElem.topsize.y / 2 ),
                                 aElem.position + VECTOR2I( aElem.topsize.x / 2, -aElem.topsize.y / 2 ),
                                 aElem.position + VECTOR2I( -aElem.topsize.x / 2, -aElem.topsize.y / 2 ),
                                 aElem.position + VECTOR2I( -aElem.topsize.x / 2, aElem.topsize.y / 2 ) } );
 
        if( aElem.direction != 0 )
            aShape->Rotate( aElem.position, EDA_ANGLE( aElem.direction, DEGREES_T ) );
    }
    break;
 
    case ALTIUM_PAD_SHAPE::CIRCLE:
        if( aElem.sizeAndShape
                && aElem.sizeAndShape->alt_shape[0] == ALTIUM_PAD_SHAPE_ALT::ROUNDRECT )
        {
            // filled roundrect
            int cornerradius = aElem.sizeAndShape->cornerradius[0];
            int offset = ( std::min( aElem.topsize.x, aElem.topsize.y ) * cornerradius ) / 200;
 
            aShape->SetLayer( aLayer );
            aShape->SetStroke( STROKE_PARAMS( offset * 2, LINE_STYLE::SOLID ) );
 
            if( cornerradius < 100 )
            {
                int offsetX = aElem.topsize.x / 2 - offset;
                int offsetY = aElem.topsize.y / 2 - offset;
 
                VECTOR2I p11 = aElem.position + VECTOR2I( offsetX, offsetY );
                VECTOR2I p12 = aElem.position + VECTOR2I( offsetX, -offsetY );
                VECTOR2I p22 = aElem.position + VECTOR2I( -offsetX, -offsetY );
                VECTOR2I p21 = aElem.position + VECTOR2I( -offsetX, offsetY );
 
                aShape->SetShape( SHAPE_T::POLY );
                aShape->SetFilled( true );
                aShape->SetPolyPoints( { p11, p12, p22, p21 } );
            }
            else if( aElem.topsize.x == aElem.topsize.y )
            {
                // circle
                aShape->SetShape( SHAPE_T::CIRCLE );
                aShape->SetFilled( true );
                aShape->SetStart( aElem.position );
                aShape->SetEnd( aElem.position - VECTOR2I( 0, aElem.topsize.x / 4 ) );
                aShape->SetStroke( STROKE_PARAMS( aElem.topsize.x / 2, LINE_STYLE::SOLID ) );
            }
            else if( aElem.topsize.x < aElem.topsize.y )
            {
                // short vertical line
                aShape->SetShape( SHAPE_T::SEGMENT );
                VECTOR2I pointOffset( 0, ( aElem.topsize.y / 2 - aElem.topsize.x / 2 ) );
                aShape->SetStart( aElem.position + pointOffset );
                aShape->SetEnd( aElem.position - pointOffset );
            }
            else
            {
                // short horizontal line
                aShape->SetShape( SHAPE_T::SEGMENT );
                VECTOR2I pointOffset( ( aElem.topsize.x / 2 - aElem.topsize.y / 2 ), 0 );
                aShape->SetStart( aElem.position + pointOffset );
                aShape->SetEnd( aElem.position - pointOffset );
            }
 
            if( aElem.direction != 0 )
                aShape->Rotate( aElem.position, EDA_ANGLE( aElem.direction, DEGREES_T ) );
        }
        else if( aElem.topsize.x == aElem.topsize.y )
        {
            // filled circle
            aShape->SetShape( SHAPE_T::CIRCLE );
            aShape->SetFilled( true );
            aShape->SetLayer( aLayer );
            aShape->SetStart( aElem.position );
            aShape->SetEnd( aElem.position - VECTOR2I( 0, aElem.topsize.x / 4 ) );
            aShape->SetStroke( STROKE_PARAMS( aElem.topsize.x / 2, LINE_STYLE::SOLID ) );
        }
        else
        {
            // short line
            aShape->SetShape( SHAPE_T::SEGMENT );
            aShape->SetLayer( aLayer );
            aShape->SetStroke( STROKE_PARAMS( std::min( aElem.topsize.x, aElem.topsize.y ),
                                              LINE_STYLE::SOLID ) );
 
            if( aElem.topsize.x < aElem.topsize.y )
            {
                VECTOR2I offset( 0, ( aElem.topsize.y / 2 - aElem.topsize.x / 2 ) );
                aShape->SetStart( aElem.position + offset );
                aShape->SetEnd( aElem.position - offset );
            }
            else
            {
                VECTOR2I offset( ( aElem.topsize.x / 2 - aElem.topsize.y / 2 ), 0 );
                aShape->SetStart( aElem.position + offset );
                aShape->SetEnd( aElem.position - offset );
            }
 
            if( aElem.direction != 0 )
                aShape->Rotate( aElem.position, EDA_ANGLE( aElem.direction, DEGREES_T ) );
        }
        break;
 
    case ALTIUM_PAD_SHAPE::OCTAGONAL:
    {
        // filled octagon
        aShape->SetShape( SHAPE_T::POLY );
        aShape->SetFilled( true );
        aShape->SetLayer( aLayer );
        aShape->SetStroke( STROKE_PARAMS( 0 ) );
 
        VECTOR2I p11 = aElem.position + VECTOR2I( aElem.topsize.x / 2, aElem.topsize.y / 2 );
        VECTOR2I p12 = aElem.position + VECTOR2I( aElem.topsize.x / 2, -aElem.topsize.y / 2 );
        VECTOR2I p22 = aElem.position + VECTOR2I( -aElem.topsize.x / 2, -aElem.topsize.y / 2 );
        VECTOR2I p21 = aElem.position + VECTOR2I( -aElem.topsize.x / 2, aElem.topsize.y / 2 );
 
        int     chamfer = std::min( aElem.topsize.x, aElem.topsize.y ) / 4;
        VECTOR2I chamferX( chamfer, 0 );
        VECTOR2I chamferY( 0, chamfer );
 
        aShape->SetPolyPoints( { p11 - chamferX, p11 - chamferY, p12 + chamferY, p12 - chamferX,
                                 p22 + chamferX, p22 + chamferY, p21 - chamferY, p21 + chamferX } );
 
        if( aElem.direction != 0. )
            aShape->Rotate( aElem.position, EDA_ANGLE( aElem.direction, DEGREES_T ) );
    }
        break;
 
    case ALTIUM_PAD_SHAPE::UNKNOWN:
    default:
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Non-copper pad %s uses an unknown pad shape." ), aElem.name );
            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
        }
 
        break;
    }
}
 
 
void ALTIUM_PCB::ParseVias6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                 const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading vias..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        AVIA6 elem( reader );
 
        bool throughVia = ( elem.layer_start == ALTIUM_LAYER::TOP_LAYER
                            || elem.layer_start == ALTIUM_LAYER::BOTTOM_LAYER )
                          && ( elem.layer_end == ALTIUM_LAYER::TOP_LAYER
                               || elem.layer_end == ALTIUM_LAYER::BOTTOM_LAYER );
 
        // A footprint pad is always through-hole, so only a through via can join its component
        if( throughVia && elem.net != ALTIUM_NET_UNCONNECTED && elem.component != ALTIUM_COMPONENT_NONE
            && elem.component < m_components.size() && m_components[elem.component] )
        {
            m_pendingComponentVias.emplace_back( m_components[elem.component], elem );
        }
        else
        {
            ConvertVias6ToBoardItem( elem );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Vias6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertVias6ToBoardItem( const AVIA6& aElem )
{
    std::unique_ptr<PCB_VIA> via = std::make_unique<PCB_VIA>( m_board );
 
    via->SetPosition( aElem.position );
    via->SetDrill( aElem.holesize );
    via->SetNetCode( GetNetCode( aElem.net ) );
    via->SetLocked( aElem.is_locked );
 
    bool start_layer_outside = aElem.layer_start == ALTIUM_LAYER::TOP_LAYER
                               || aElem.layer_start == ALTIUM_LAYER::BOTTOM_LAYER;
    bool end_layer_outside = aElem.layer_end == ALTIUM_LAYER::TOP_LAYER
                             || aElem.layer_end == ALTIUM_LAYER::BOTTOM_LAYER;
 
    if( start_layer_outside && end_layer_outside )
    {
        via->SetViaType( VIATYPE::THROUGH );
    }
    else if( ( !start_layer_outside ) && ( !end_layer_outside ) )
    {
        via->SetViaType( VIATYPE::BURIED );
    }
    else
    {
        via->SetViaType( VIATYPE::BLIND );
    }
 
    // TODO: Altium has a specific flag for microvias, independent of start/end layer
#if 0
    if( something )
        via->SetViaType( VIATYPE::MICROVIA );
#endif
 
    PCB_LAYER_ID start_klayer = GetKicadLayer( aElem.layer_start );
    PCB_LAYER_ID end_klayer   = GetKicadLayer( aElem.layer_end );
 
    if( !IsCopperLayer( start_klayer ) || !IsCopperLayer( end_klayer ) )
    {
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Via from layer %d to %d uses a non-copper layer, which is not "
                           "supported." ),
                    aElem.layer_start,
                    aElem.layer_end );
            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
        }
 
        return; // just assume through-hole instead.
    }
 
    // we need VIATYPE set!
    via->SetLayerPair( start_klayer, end_klayer );
 
    switch( aElem.viamode )
    {
    default:
    case ALTIUM_PAD_MODE::SIMPLE:
        via->SetWidth( PADSTACK::ALL_LAYERS, aElem.diameter );
        break;
 
    case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
        via->Padstack().SetMode( PADSTACK::MODE::FRONT_INNER_BACK );
        via->SetWidth( F_Cu, aElem.diameter_by_layer[ALTIUM_TOP_PADSTACK_IDX] );
        via->SetWidth( PADSTACK::INNER_LAYERS, aElem.diameter_by_layer[ALTIUM_MID1_PADSTACK_IDX] );
        via->SetWidth( B_Cu, aElem.diameter_by_layer[ALTIUM_BOTTOM_PADSTACK_IDX] );
        break;
 
    case ALTIUM_PAD_MODE::FULL_STACK:
    {
        via->Padstack().SetMode( PADSTACK::MODE::CUSTOM );
 
        LSET cuLayers = m_board->GetEnabledLayers() & LSET::AllCuMask();
 
        for( PCB_LAYER_ID layer : cuLayers )
        {
            int altiumLayer = HelperGetPadstackLayerIndex( layer );
 
            // Internal planes carry no padstack entry; the via keeps its nominal land there
            via->SetWidth( layer, altiumLayer < 0 ? aElem.diameter
                                                  : aElem.diameter_by_layer[altiumLayer] );
        }
 
        break;
    }
    }
 
    // Altium can size the solder mask opening from the hole edge instead of the via land.
    // KiCad vias cannot represent a hole-referenced opening, so when the resulting opening
    // does not clear the via land the pad copper is covered and the via is effectively tented.
    bool tentTop = altiumViaSideIsTented( aElem.is_tent_top, aElem.soldermask_expansion_manual,
                                          aElem.soldermask_expansion_from_hole, aElem.holesize,
                                          aElem.soldermask_expansion_front,
                                          via->GetWidth( F_Cu ) );
 
    bool tentBottom = altiumViaSideIsTented( aElem.is_tent_bottom,
                                             aElem.soldermask_expansion_manual,
                                             aElem.soldermask_expansion_from_hole, aElem.holesize,
                                             aElem.soldermask_expansion_back,
                                             via->GetWidth( B_Cu ) );
 
    via->SetFrontTentingMode( tentTop ? TENTING_MODE::TENTED : TENTING_MODE::NOT_TENTED );
    via->SetBackTentingMode( tentBottom ? TENTING_MODE::TENTED : TENTING_MODE::NOT_TENTED );
 
    m_board->Add( via.release(), ADD_MODE::APPEND );
}
 
void ALTIUM_PCB::ParseTracks6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                   const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading tracks..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    for( int primitiveIndex = 0; reader.GetRemainingBytes() >= 4; primitiveIndex++ )
    {
        checkpoint();
        ATRACK6 elem( reader );
 
        if( elem.component == ALTIUM_COMPONENT_NONE )
        {
            ConvertTracks6ToBoardItem( elem, primitiveIndex );
        }
        else
        {
            FOOTPRINT* footprint = HelperGetFootprint( elem.component );
            ConvertTracks6ToFootprintItem( footprint, elem, primitiveIndex, true );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Tracks6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertTracks6ToBoardItem( const ATRACK6& aElem, const int aPrimitiveIndex )
{
    if( aElem.polygon != ALTIUM_POLYGON_NONE && aElem.polygon != ALTIUM_POLYGON_BOARD )
    {
        if( m_polygons.size() <= aElem.polygon )
        {
            // Can happen when reading old Altium files: just skip this item
            if( m_reporter )
            {
                wxString msg;
                msg.Printf( wxT( "ATRACK6 stream tries to access polygon id %u "
                                 "of %u existing polygons; skipping it" ),
                            static_cast<unsigned>( aElem.polygon ),
                            static_cast<unsigned>( m_polygons.size() ) );
                m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
            }
 
            return;
        }
 
        ZONE* zone = m_polygons.at( aElem.polygon );
 
        if( zone == nullptr )
        {
            return; // we know the zone id, but because we do not know the layer we did not
                    // add it!
        }
 
        PCB_LAYER_ID klayer = GetKicadLayer( aElem.layer );
 
        if( klayer == UNDEFINED_LAYER )
            return; // Just skip it for now. Users can fill it themselves.
 
        if( !zone->HasFilledPolysForLayer( klayer ) )
            return;
 
        SHAPE_POLY_SET* fill = zone->GetFill( klayer );
 
        PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
        shape.SetStart( aElem.start );
        shape.SetEnd( aElem.end );
        shape.SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
        shape.EDA_SHAPE::TransformShapeToPolygon( *fill, 0, ARC_HIGH_DEF, ERROR_INSIDE );
        // Will be simplified and fractured later
 
        zone->SetIsFilled( true );
        zone->SetNeedRefill( false );
 
        return;
    }
 
    if( aElem.is_keepout || aElem.layer == ALTIUM_LAYER::KEEP_OUT_LAYER
        || IsAltiumLayerAPlane( aElem.layer ) )
    {
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
        shape.SetStart( aElem.start );
        shape.SetEnd( aElem.end );
        shape.SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
        HelperPcpShapeAsBoardKeepoutRegion( shape, aElem.layer, aElem.keepoutrestrictions );
    }
    else
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            ConvertTracks6ToBoardItemOnLayer( aElem, klayer );
    }
 
    for( const auto& layerExpansionMask : HelperGetSolderAndPasteMaskExpansions( ALTIUM_RECORD::TRACK,
                                                                                 aPrimitiveIndex, aElem.layer ) )
    {
        int width = aElem.width + ( layerExpansionMask.second * 2 );
        if( width > 1 )
        {
            std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::SEGMENT );
 
            seg->SetStart( aElem.start );
            seg->SetEnd( aElem.end );
            seg->SetStroke( STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
            seg->SetLayer( layerExpansionMask.first );
 
            m_board->Add( seg.release(), ADD_MODE::APPEND );
        }
    }
}
 
 
void ALTIUM_PCB::ConvertTracks6ToFootprintItem( FOOTPRINT* aFootprint, const ATRACK6& aElem,
                                                const int  aPrimitiveIndex,
                                                const bool aIsBoardImport )
{
    if( aElem.polygon != ALTIUM_POLYGON_NONE )
    {
        wxFAIL_MSG( wxString::Format( wxT( "Altium: Unexpected footprint Track with polygon id %u" ),
                                      (unsigned)aElem.polygon ) );
        return;
    }
 
    if( aElem.is_keepout || aElem.layer == ALTIUM_LAYER::KEEP_OUT_LAYER
        || IsAltiumLayerAPlane( aElem.layer ) )
    {
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr, SHAPE_T::SEGMENT );
        shape.SetStart( aElem.start );
        shape.SetEnd( aElem.end );
        shape.SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
        HelperPcpShapeAsFootprintKeepoutRegion( aFootprint, shape, aElem.layer,
                                                aElem.keepoutrestrictions );
    }
    else
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
        {
            if( IsCopperLayer( klayer ) && ( !aIsBoardImport || aElem.net != ALTIUM_NET_UNCONNECTED ) )
            {
                // Footprint graphics are not connected, so copper waits to join a pad it touches
                std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( nullptr, SHAPE_T::SEGMENT );
 
                seg->SetStart( aElem.start );
                seg->SetEnd( aElem.end );
                seg->SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
 
                HelperDeferComponentCopper( aFootprint, klayer, aIsBoardImport ? aElem.net : ALTIUM_NET_UNCONNECTED,
                                            std::move( seg ),
                                            [this, aFootprint, aElem, klayer, aIsBoardImport]()
                                            {
                                                if( aIsBoardImport )
                                                    ConvertTracks6ToBoardItemOnLayer( aElem, klayer );
                                                else
                                                    ConvertTracks6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
                                            } );
            }
            else
            {
                ConvertTracks6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
            }
        }
    }
 
    for( const auto& layerExpansionMask : HelperGetSolderAndPasteMaskExpansions( ALTIUM_RECORD::TRACK,
                                                                                 aPrimitiveIndex, aElem.layer ) )
    {
        int width = aElem.width + ( layerExpansionMask.second * 2 );
        if( width > 1 )
        {
            std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::SEGMENT );
 
            seg->SetStart( aElem.start );
            seg->SetEnd( aElem.end );
            seg->SetStroke( STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
            seg->SetLayer( layerExpansionMask.first );
 
            aFootprint->Add( seg.release(), ADD_MODE::APPEND );
        }
    }
}
 
 
void ALTIUM_PCB::ConvertTracks6ToBoardItemOnLayer( const ATRACK6& aElem, PCB_LAYER_ID aLayer )
{
    if( IsCopperLayer( aLayer ) && aElem.net != ALTIUM_NET_UNCONNECTED )
    {
        std::unique_ptr<PCB_TRACK> track = std::make_unique<PCB_TRACK>( m_board );
 
        track->SetStart( aElem.start );
        track->SetEnd( aElem.end );
        track->SetWidth( aElem.width );
        track->SetLayer( aLayer );
        track->SetNetCode( GetNetCode( aElem.net ) );
 
        PCB_TRACK* added = track.release();
        m_board->Add( added, ADD_MODE::APPEND );
 
        if( aElem.unionindex != 0 )
            m_unionToBoardItems[static_cast<int>( aElem.unionindex )].push_back( added );
    }
    else
    {
        std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::SEGMENT );
 
        seg->SetStart( aElem.start );
        seg->SetEnd( aElem.end );
        seg->SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
        seg->SetLayer( aLayer );
 
        m_board->Add( seg.release(), ADD_MODE::APPEND );
    }
}
 
 
void ALTIUM_PCB::ConvertTracks6ToFootprintItemOnLayer( FOOTPRINT* aFootprint, const ATRACK6& aElem,
                                                       PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::SEGMENT );
 
    seg->SetStart( aElem.start );
    seg->SetEnd( aElem.end );
    seg->SetStroke( STROKE_PARAMS( aElem.width, LINE_STYLE::SOLID ) );
    seg->SetLayer( aLayer );
 
    aFootprint->Add( seg.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ParseWideStrings6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                        const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading unicode strings..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    m_unicodeStrings = reader.ReadWideStringTable();
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "WideStrings6 stream is not fully parsed" ) );
}
 
void ALTIUM_PCB::ParseSmartUnions6Data( const ALTIUM_PCB_COMPOUND_FILE&  aAltiumPcbFile,
                                        const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 )
    {
        checkpoint();
        ASMARTUNION6 elem( reader );
 
        if( elem.is_tuning && elem.unionindex != 0 )
            m_tuningUnions.emplace_back( std::move( elem ) );
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "SmartUnions6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ParseUnionNamesData( const ALTIUM_PCB_COMPOUND_FILE& aAltiumPcbFile,
                                      const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    // Discard the leading record count, otherwise the wide-string table desyncs by four bytes
    reader.Read<uint32_t>();
    m_unionNames = reader.ReadWideStringTable();
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "UnionNames stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::HelperCreateTuningPatterns()
{
    int created = 0;
 
    for( const ASMARTUNION6& tuning : m_tuningUnions )
    {
        auto itemsIt = m_unionToBoardItems.find( tuning.unionindex );
 
        // Altium commits the tuned copper as ordinary tracks and arcs.  Without those primitives
        // there is nothing to wrap, so drop the meander rather than fabricate geometry.
        if( itemsIt == m_unionToBoardItems.end() || itemsIt->second.empty() )
            continue;
 
        // Without a baseline the pattern can be neither re-tuned nor reset, so wrapping the copper
        // would only take it away from the user
        if( tuning.baseline.size() < 2
            || ( tuning.is_diffpair && tuning.baselinecoupled.size() < 2 ) )
        {
            continue;
        }
 
        const std::vector<BOARD_ITEM*>& items = itemsIt->second;
 
        LENGTH_TUNING_MODE mode = tuning.is_diffpair ? LENGTH_TUNING_MODE::DIFF_PAIR
                                                     : LENGTH_TUNING_MODE::SINGLE;
 
        SHAPE_LINE_CHAIN baseLine( tuning.baseline );
 
        PCB_LAYER_ID layer = items.front()->GetLayer();
 
        PCB_GENERATOR* generator = GENERATORS_MGR::Instance().CreateFromType( wxS( "tuning_pattern" ) );
 
        if( !generator )
            continue;
 
        std::unique_ptr<PCB_TUNING_PATTERN> pattern( static_cast<PCB_TUNING_PATTERN*>( generator ) );
        pattern->SetParent( m_board );
        pattern->SetLayer( layer );
        pattern->SetTuningMode( mode );
 
        // Preserve Altium's interactive union name so the meander keeps its designer-visible label.
        if( auto nameIt = m_unionNames.find( tuning.unionindex );
            nameIt != m_unionNames.end() && !nameIt->second.IsEmpty() )
        {
            pattern->SetName( nameIt->second );
        }
 
        pattern->SetMaxAmplitude( tuning.amplitude );
        pattern->SetMinAmplitude( tuning.minamplitude );
        pattern->SetSpacing( tuning.gap );
        pattern->SetSingleSided( tuning.singleside );
 
        // Altium "Style" selects mitered (chamfered) versus rounded corners.  The committed
        // copper carries the real geometry; this only governs a later interactive re-tune.
        pattern->SetRounded( tuning.style != 0 );
 
        if( tuning.mitterradiusratio > 0.0 )
        {
            int percent = KiROUND( tuning.mitterradiusratio * 100.0 );
            pattern->SetCornerRadiusPercentage( std::clamp( percent, 0, 100 ) );
        }
 
        int  netCode = -1;
        bool singleNet = true;
 
        for( BOARD_ITEM* item : items )
        {
            pattern->AddItem( item );
 
            if( BOARD_CONNECTED_ITEM* bci = dynamic_cast<BOARD_CONNECTED_ITEM*>( item ) )
            {
                if( netCode < 0 )
                    netCode = bci->GetNetCode();
                else if( netCode != bci->GetNetCode() )
                    singleNet = false;
            }
        }
 
        // SetNetCode reassigns the net of every member, so only apply it when the union is on a
        // single net.  Differential-pair meanders span two nets that must both be preserved.
        if( netCode >= 0 && singleNet )
        {
            pattern->SetNetCode( netCode );
        }
        else
        {
            // Name the pattern after the net at the baseline start, the one an edit snaps to
            const VECTOR2I& origin = baseLine.CPoint( 0 );
            SEG::ecoord     bestDist = std::numeric_limits<SEG::ecoord>::max();
            wxString        bestNet;
 
            for( BOARD_ITEM* item : items )
            {
                PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( item );
 
                if( !track )
                    continue;
 
                SEG::ecoord dist = SEG( track->GetStart(), track->GetEnd() ).SquaredDistance( origin );
 
                if( dist < bestDist )
                {
                    bestDist = dist;
                    bestNet = track->GetNetname();
                }
            }
 
            pattern->SetLastNetName( bestNet );
        }
 
        if( PCB_TRACK* track = dynamic_cast<PCB_TRACK*>( items.front() ) )
            pattern->SetWidth( track->GetWidth() );
 
        pattern->SetBaseLine( baseLine );
        pattern->SetPosition( baseLine.CPoint( 0 ) );
        pattern->SetEnd( baseLine.CLastPoint() );
 
        if( mode == LENGTH_TUNING_MODE::DIFF_PAIR )
        {
            SHAPE_LINE_CHAIN baseLineCoupled( tuning.baselinecoupled );
 
            pattern->SetBaseLineCoupled( baseLineCoupled );
 
            int centreToCentre = baseLine.Distance( baseLineCoupled.CPoint( 0 ), false );
 
            pattern->SetDiffPairGap( std::max( centreToCentre - pattern->GetWidth(), 0 ) );
        }
 
        m_board->Add( pattern.release(), ADD_MODE::INSERT );
        created++;
    }
 
    if( m_reporter && created > 0 )
    {
        m_reporter->Report( wxString::Format( _( "Imported %d length-tuning pattern(s)." ),
                                              created ),
                            RPT_SEVERITY_INFO );
    }
}
 
 
void ALTIUM_PCB::HelperSetFootprintStackups()
{
    for( FOOTPRINT* footprint : m_components )
    {
        if( !footprint )
            continue;
 
        LSET drawnCopper;
 
        // Board copper is bounded by the board, so single-layer items are the drawn layers
        footprint->RunOnChildren(
                [&]( BOARD_ITEM* aItem )
                {
                    LSET copper = aItem->GetLayerSet() & LSET::AllCuMask();
 
                    if( copper.count() == 1 )
                        drawnCopper |= copper;
                },
                RECURSE_MODE::RECURSE );
 
        // Inner copper folded into a pad is drawn on that layer alone
        for( PAD* pad : footprint->Pads() )
        {
            if( pad->Padstack().Mode() != PADSTACK::MODE::CUSTOM )
                continue;
 
            const LSET padInner = pad->GetLayerSet() & LSET::InternalCuMask();
 
            for( PCB_LAYER_ID layer : padInner )
            {
                if( !pad->GetPrimitives( layer ).empty() )
                    drawnCopper.set( layer );
            }
        }
 
        // A bottom-side footprint's inner items are mirrored through the board's stackup
        altiumSetFootprintStackup( footprint, drawnCopper, m_board->GetCopperLayerCount() );
    }
}
 
 
void ALTIUM_PCB::HelperDeferComponentCopper( FOOTPRINT* aFootprint, PCB_LAYER_ID aLayer, uint16_t aNet,
                                             std::unique_ptr<PCB_SHAPE> aShape, std::function<void()> aFallback )
{
    aShape->SetLayer( aLayer );
 
    m_pendingComponentCopper.push_back( { aFootprint, aLayer, GetNetCode( aNet ), std::move( aShape ),
                                          std::move( aFallback ) } );
}
 
 
static PAD* altiumFindTouchingPad( FOOTPRINT* aFootprint, PCB_LAYER_ID aLayer, int aNetCode, const SHAPE& aShape,
                                   const PAD* aExclude = nullptr )
{
    PAD* found = nullptr;
 
    for( PAD* pad : aFootprint->Pads() )
    {
        if( pad == aExclude || pad->GetNumber().IsEmpty() || pad->GetNetCode() != aNetCode
            || !pad->IsOnLayer( aLayer ) )
        {
            continue;
        }
 
        if( aShape.BBox().Intersects( pad->GetBoundingBox() )
            && aShape.Collide( pad->GetEffectiveShape( aLayer ).get() ) )
        {
            if( aNetCode > 0 )
                return pad;
 
            // Without a net, copper bridging two pad numbers has no single owner
            if( found && found->GetNumber() != pad->GetNumber() )
                return nullptr;
 
            found = pad;
        }
    }
 
    return found;
}
 
 
bool ALTIUM_PCB::HelperFoldPendingCopper( const LSET& aCopper, int aMaxError, std::set<PAD*>& aExtensionPads )
{
    // A custom outline is placed at ShapePos, so a pad offset must come out with the position
    auto toPadFrame =
            []( PCB_SHAPE* aShape, const PAD* aPad, PCB_LAYER_ID aLayer )
            {
                aShape->Move( -aPad->ShapePos( aLayer ) );
                aShape->Rotate( VECTOR2I( 0, 0 ), -aPad->GetOrientation() );
            };
 
    auto fold =
            [&]( PENDING_COMPONENT_COPPER& aPending, PAD* aPad )
            {
                PCB_LAYER_ID   layer = aPending.layer;
                SHAPE_POLY_SET uncovered;
                SHAPE_POLY_SET padCopper;
 
                aPending.shape->TransformShapeToPolygon( uncovered, layer, 0, aMaxError, ERROR_OUTSIDE );
                aPad->TransformShapeToPolygon( padCopper, layer, 0, aMaxError, ERROR_INSIDE );
                uncovered.BooleanSubtract( padCopper );
 
                // Copper already inside the pad would only add a redundant primitive or pad
                if( uncovered.IsEmpty() )
                {
                    aPending.shape.reset();
                    return;
                }
 
                if( IsInnerCopperLayer( layer ) )
                {
                    // Inner layers carry no mask or paste, so the pad itself can grow there
                    altiumIsolatePadLayer( aPad, layer, aCopper );
                    altiumMakePadLayerCustom( aPad, layer, aMaxError );
                    toPadFrame( aPending.shape.get(), aPad, layer );
                    aPad->AddPrimitive( layer, aPending.shape.release() );
                    return;
                }
 
                if( aExtensionPads.count( aPad ) )
                {
                    toPadFrame( aPending.shape.get(), aPad, layer );
                    aPad->AddPrimitive( PADSTACK::ALL_LAYERS, aPending.shape.release() );
                    aPad->SetDirty();
                    return;
                }
 
                // Growing the touched pad would open its mask over the copper, so a same-numbered
                // copper-only pad joins it instead
                SHAPE_POLY_SET outline;
                aPending.shape->TransformShapeToPolygon( outline, layer, 0, aMaxError, ERROR_INSIDE );
 
                std::unique_ptr<PAD> extension = std::make_unique<PAD>( aPending.footprint );
 
                VECTOR2I anchorPos = outline.Outline( 0 ).CPoint( 0 );
 
                extension->SetAttribute( PAD_ATTRIB::SMD );
                extension->SetPadstackMode( PADSTACK::MODE::NORMAL );
                extension->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CUSTOM );
                extension->SetAnchorPadShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );
                extension->SetSize( PADSTACK::ALL_LAYERS, { 1, 1 } );
                extension->SetPosition( anchorPos );
                extension->SetOrientation( ANGLE_0 );
                extension->SetThermalSpokeAngle( ANGLE_90 );
                extension->SetLayerSet( LSET{ layer } );
                extension->SetNumber( aPad->GetNumber() );
                extension->SetNetCode( aPad->GetNetCode() );
 
                // Zones met the original copper solidly, not through thermal spokes
                extension->SetLocalZoneConnection( ZONE_CONNECTION::FULL );
 
                toPadFrame( aPending.shape.get(), extension.get(), layer );
                extension->AddPrimitive( PADSTACK::ALL_LAYERS, aPending.shape.release() );
 
                aExtensionPads.insert( extension.get() );
                aPending.footprint->Add( extension.release(), ADD_MODE::APPEND );
            };
 
    bool changed = false;
 
    for( PENDING_COMPONENT_COPPER& pending : m_pendingComponentCopper )
    {
        // Copper outside the stackup is a multi-layer copy that the stackup step discards
        if( !pending.shape || !aCopper.test( pending.layer ) )
            continue;
 
        std::shared_ptr<SHAPE> shape = pending.shape->GetEffectiveShape( pending.layer );
 
        if( PAD* pad = altiumFindTouchingPad( pending.footprint, pending.layer, pending.netcode, *shape ) )
        {
            fold( pending, pad );
            changed = true;
        }
    }
 
    return changed;
}
 
 
void ALTIUM_PCB::HelperPlaceUnfoldedCopper()
{
    for( PENDING_COMPONENT_COPPER& pending : m_pendingComponentCopper )
    {
        if( pending.shape )
            pending.fallback();
    }
 
    m_pendingComponentCopper.clear();
}
 
 
void ALTIUM_PCB::HelperFoldComponentCopperIntoPads()
{
    const int  maxError = m_board->GetDesignSettings().m_MaxError;
    const LSET boardCopper = m_board->GetEnabledLayers() & LSET::AllCuMask();
 
    // Copper-only pads made here to carry a pad's number on an outer layer; they own no mask or
    // paste, so further copper can join them without widening an aperture
    std::set<PAD*> extensionPads;
 
    // Mirrors the land ConvertVias6ToBoardItem would give the via on each layer
    auto viaDiameterOn =
            [&]( const AVIA6& aVia, PCB_LAYER_ID aLayer ) -> uint32_t
            {
                switch( aVia.viamode )
                {
                case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
                    if( aLayer == F_Cu )
                        return aVia.diameter_by_layer[ALTIUM_TOP_PADSTACK_IDX];
 
                    if( aLayer == B_Cu )
                        return aVia.diameter_by_layer[ALTIUM_BOTTOM_PADSTACK_IDX];
 
                    return aVia.diameter_by_layer[ALTIUM_MID1_PADSTACK_IDX];
 
                case ALTIUM_PAD_MODE::FULL_STACK:
                {
                    int idx = HelperGetPadstackLayerIndex( aLayer );
                    return idx < 0 ? aVia.diameter : aVia.diameter_by_layer[idx];
                }
 
                default:
                    return aVia.diameter;
                }
            };
 
    // Repeat so copper reaching a pad only through other folded copper still joins it
    for( bool changed = true; changed; )
    {
        changed = HelperFoldPendingCopper( boardCopper, maxError, extensionPads );
 
        for( auto it = m_pendingComponentVias.begin(); it != m_pendingComponentVias.end(); )
        {
            auto& [footprint, via] = *it;
            PAD*  touched = nullptr;
 
            for( PCB_LAYER_ID layer : boardCopper )
            {
                SHAPE_CIRCLE land( via.position, static_cast<int>( viaDiameterOn( via, layer ) / 2 ) );
 
                touched = altiumFindTouchingPad( footprint, layer, GetNetCode( via.net ), land );
 
                if( touched )
                    break;
            }
 
            if( !touched )
            {
                ++it;
                continue;
            }
 
            PAD* viaPad = ConvertVias6ToFootprintItem( footprint, via );
            viaPad->SetNumber( touched->GetNumber() );
 
            // A via meets zones solidly, which a pad only does when told to
            viaPad->SetLocalZoneConnection( ZONE_CONNECTION::FULL );
 
            it = m_pendingComponentVias.erase( it );
            changed = true;
        }
 
        // Altium region pads arrive unnumbered and would lose their net on the next netlist update
        for( FOOTPRINT* footprint : m_components )
        {
            if( !footprint )
                continue;
 
            for( PAD* pad : footprint->Pads() )
            {
                if( !pad->GetNumber().IsEmpty() || pad->GetNetCode() <= 0 )
                    continue;
 
                const LSET padCopper = pad->GetLayerSet() & LSET::AllCuMask();
 
                for( PCB_LAYER_ID layer : padCopper )
                {
                    PAD* touched = altiumFindTouchingPad( footprint, layer, pad->GetNetCode(),
                                                          *pad->GetEffectiveShape( layer ), pad );
 
                    if( touched )
                    {
                        pad->SetNumber( touched->GetNumber() );
                        changed = true;
                        break;
                    }
                }
            }
        }
    }
 
    HelperPlaceUnfoldedCopper();
 
    for( const auto& [footprint, via] : m_pendingComponentVias )
        ConvertVias6ToBoardItem( via );
 
    m_pendingComponentVias.clear();
}
 
 
void ALTIUM_PCB::HelperSetFootprintMountingStyles()
{
    // Altium has no per-component mounting style to copy, so derive it from the pads the way
    // KiCad's own footprint checker does.  Using the same heuristic keeps the imported value in
    // agreement with FOOTPRINT_UTILS::CheckFootprintAttributes(), which would otherwise report every
    // footprint we just wrote as a type mismatch.
    //
    // Only m_components is walked, so importing into a board that already holds footprints
    // cannot rewrite them, and only a missing style is filled in.
    for( FOOTPRINT* footprint : m_components )
    {
        if( !footprint )
            continue;
 
        if( footprint->GetAttributes() & ( FP_SMD | FP_THROUGH_HOLE ) )
            continue;
 
        footprint->SetAttributes( footprint->GetAttributes() | footprint->GetLikelyAttribute() );
    }
}
 
 
void ALTIUM_PCB::ParseTexts6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                  const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading text..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        ATEXT6 elem( reader, m_unicodeStrings );
 
        if( elem.component == ALTIUM_COMPONENT_NONE )
        {
            ConvertTexts6ToBoardItem( elem );
        }
        else
        {
            FOOTPRINT* footprint = HelperGetFootprint( elem.component );
            ConvertTexts6ToFootprintItem( footprint, elem );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Texts6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertTexts6ToBoardItem( const ATEXT6& aElem )
{
    if( aElem.fonttype == ALTIUM_TEXT_TYPE::BARCODE )
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            ConvertBarcodes6ToBoardItemOnLayer( aElem, klayer );
 
        return;
    }
 
    for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
        ConvertTexts6ToBoardItemOnLayer( aElem, klayer );
}
 
 
void ALTIUM_PCB::ConvertTexts6ToFootprintItem( FOOTPRINT* aFootprint, const ATEXT6& aElem )
{
    if( aElem.fonttype == ALTIUM_TEXT_TYPE::BARCODE )
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            ConvertBarcodes6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
        return;
    }
 
    for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
        ConvertTexts6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
}
 
 
void ALTIUM_PCB::ConvertTexts6ToBoardItemOnLayer( const ATEXT6& aElem, PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_TEXTBOX> pcbTextbox = std::make_unique<PCB_TEXTBOX>( m_board );
    std::unique_ptr<PCB_TEXT>    pcbText = std::make_unique<PCB_TEXT>( m_board );
 
    bool isTextbox = aElem.isFrame && !aElem.isInverted; // Textbox knockout is not supported
 
    static const std::map<wxString, wxString> variableMap = {
        { "LAYER_NAME",              "LAYER"               },
        { "PRINT_DATE",              "CURRENT_DATE"        },
        { "PRINT_TIME",              "CURRENT_TIME_LOCALE" },
        { "PCB_FILE_NAME_NO_PATH",   "FILENAME"            },
    };
 
    wxString    kicadText = AltiumPcbSpecialStringsToKiCadStrings( aElem.text, variableMap, &m_specialStrings );
    BOARD_ITEM* item = pcbText.get();
    EDA_TEXT*   text = pcbText.get();
 
    if( isTextbox )
    {
        item = pcbTextbox.get();
        text = pcbTextbox.get();
    }
 
    text->SetText( kicadText );
 
    // Set the layer before the alignment helpers run.  HelperSetTextAlignmentAndPos measures the
    // text via GetTextBox(), which resolves layer-dependent special strings such as ${LAYER}.
    item->SetLayer( aLayer );
 
    ConvertTexts6ToEdaTextSettings( aElem, *text );
 
    if( isTextbox )
        HelperSetTextboxAlignmentAndPos( aElem, pcbTextbox.get() );
    else
        HelperSetTextAlignmentAndPos( aElem, text );
 
    item->SetIsKnockout( aElem.isInverted );
 
    if( isTextbox )
        m_board->Add( pcbTextbox.release(), ADD_MODE::APPEND );
    else
        m_board->Add( pcbText.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ConvertTexts6ToFootprintItemOnLayer( FOOTPRINT* aFootprint, const ATEXT6& aElem,
                                                      PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_TEXTBOX> fpTextbox = std::make_unique<PCB_TEXTBOX>( aFootprint );
    std::unique_ptr<PCB_TEXT> fpText = std::make_unique<PCB_TEXT>( aFootprint );
 
    BOARD_ITEM* item = fpText.get();
    EDA_TEXT*   text = fpText.get();
 
    // A framed designator or comment still sets its field, which cannot be a textbox
    bool isField = aElem.isDesignator || aElem.isComment;
    bool isTextbox = aElem.isFrame && !aElem.isInverted && !isField; // Textbox knockout is not supported
    bool toAdd = false;
 
    if( aElem.isDesignator )
    {
        item = &aFootprint->Reference(); // TODO: handle multiple layers
        text = &aFootprint->Reference();
    }
    else if( aElem.isComment )
    {
        item = &aFootprint->Value(); // TODO: handle multiple layers
        text = &aFootprint->Value();
    }
    else
    {
        item = fpText.get();
        text = fpText.get();
        toAdd = true;
    }
 
    static const std::map<wxString, wxString> variableMap = {
        { "DESIGNATOR", "REFERENCE" },
        { "COMMENT",    "VALUE" },
        { "VALUE",      "ALTIUM_VALUE" },
        { "LAYER_NAME",            "LAYER"               },
        { "PRINT_DATE",            "CURRENT_DATE"        },
        { "PRINT_TIME",            "CURRENT_TIME_LOCALE" },
        { "PCB_FILE_NAME_NO_PATH", "FILENAME"            },
    };
 
    if( isTextbox )
    {
        item = fpTextbox.get();
        text = fpTextbox.get();
    }
 
    wxString kicadText = AltiumPcbSpecialStringsToKiCadStrings( aElem.text, variableMap, &m_specialStrings );
 
    text->SetText( kicadText );
 
    // Set the layer before the alignment helpers run.  HelperSetTextAlignmentAndPos measures the
    // text via GetTextBox(), which resolves layer-dependent special strings such as ${LAYER}.
    item->SetLayer( aLayer );
 
    ConvertTexts6ToEdaTextSettings( aElem, *text );
 
    if( isTextbox )
        HelperSetTextboxAlignmentAndPos( aElem, fpTextbox.get() );
    else
        HelperSetTextAlignmentAndPos( aElem, text );
 
    text->SetKeepUpright( false );
    item->SetIsKnockout( aElem.isInverted );
 
    if( toAdd )
    {
        if( isTextbox )
            aFootprint->Add( fpTextbox.release(), ADD_MODE::APPEND );
        else
            aFootprint->Add( fpText.release(), ADD_MODE::APPEND );
    }
}
 
 
void ALTIUM_PCB::ConvertBarcodes6ToBoardItemOnLayer( const ATEXT6& aElem, PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_BARCODE> pcbBarcode = std::make_unique<PCB_BARCODE>( m_board );
 
    pcbBarcode->SetLayer( aLayer );
    pcbBarcode->SetPosition( aElem.position );
    pcbBarcode->SetWidth( aElem.textbox_rect_width );
    pcbBarcode->SetHeight( aElem.textbox_rect_height );
    pcbBarcode->SetMargin( aElem.barcode_margin );
    pcbBarcode->SetText( aElem.text );
 
    switch( aElem.barcode_type )
    {
    case ALTIUM_BARCODE_TYPE::CODE39: pcbBarcode->SetKind( BARCODE_T::CODE_39 ); break;
    case ALTIUM_BARCODE_TYPE::CODE128: pcbBarcode->SetKind( BARCODE_T::CODE_128 ); break;
    default: pcbBarcode->SetKind( BARCODE_T::CODE_39 ); break;
    }
 
    pcbBarcode->SetIsKnockout( aElem.barcode_inverted );
    pcbBarcode->AssembleBarcode();
 
    m_board->Add( pcbBarcode.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ConvertBarcodes6ToFootprintItemOnLayer( FOOTPRINT* aFootprint, const ATEXT6& aElem,
                                                         PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_BARCODE> fpBarcode = std::make_unique<PCB_BARCODE>( aFootprint );
 
    fpBarcode->SetLayer( aLayer );
    fpBarcode->SetPosition( aElem.position );
    fpBarcode->SetWidth( aElem.textbox_rect_width );
    fpBarcode->SetHeight( aElem.textbox_rect_height );
    fpBarcode->SetMargin( aElem.barcode_margin );
    fpBarcode->SetText( aElem.text );
 
    switch( aElem.barcode_type )
    {
    case ALTIUM_BARCODE_TYPE::CODE39: fpBarcode->SetKind( BARCODE_T::CODE_39 ); break;
    case ALTIUM_BARCODE_TYPE::CODE128: fpBarcode->SetKind( BARCODE_T::CODE_128 ); break;
    default: fpBarcode->SetKind( BARCODE_T::CODE_39 ); break;
    }
 
    fpBarcode->SetIsKnockout( aElem.barcode_inverted );
    fpBarcode->AssembleBarcode();
 
    aFootprint->Add( fpBarcode.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::HelperSetTextboxAlignmentAndPos( const ATEXT6& aElem, PCB_TEXTBOX* aTextbox )
{
    int margin = aElem.isOffsetBorder ? aElem.text_offset_width : aElem.margin_border_width;
 
    // Altium textboxes do not have borders
    aTextbox->SetBorderEnabled( false );
 
    // Calculate position
    VECTOR2I kposition = aElem.position;
 
    if( aElem.isMirrored )
        kposition.x -= aElem.textbox_rect_width;
 
    kposition.y -= aElem.textbox_rect_height;
 
#if 0
    // Compensate for KiCad's textbox margin
    int charWidth = aTextbox->GetTextWidth();
    int charHeight = aTextbox->GetTextHeight();
 
    VECTOR2I kicadMargin;
 
    if( !aTextbox->GetFont() || aTextbox->GetFont()->IsStroke() )
        kicadMargin = VECTOR2I( charWidth * 0.933, charHeight * 0.67 );
    else
        kicadMargin = VECTOR2I( charWidth * 0.808, charHeight * 0.844 );
 
    aTextbox->SetEnd( VECTOR2I( aElem.textbox_rect_width, aElem.textbox_rect_height )
                        + kicadMargin * 2 - margin * 2 );
 
    kposition = kposition - kicadMargin + margin;
#else
    aTextbox->SetMarginBottom( margin );
    aTextbox->SetMarginLeft( margin );
    aTextbox->SetMarginRight( margin );
    aTextbox->SetMarginTop( margin );
 
    aTextbox->SetEnd( VECTOR2I( aElem.textbox_rect_width, aElem.textbox_rect_height ) );
#endif
 
    RotatePoint( kposition, aElem.position, EDA_ANGLE( aElem.rotation, DEGREES_T ) );
 
    aTextbox->SetPosition( kposition );
 
    ALTIUM_TEXT_POSITION justification = aElem.isJustificationValid ? aElem.textbox_rect_justification
                                                                    : ALTIUM_TEXT_POSITION::LEFT_BOTTOM;
 
    switch( justification )
    {
    case ALTIUM_TEXT_POSITION::LEFT_TOP:
    case ALTIUM_TEXT_POSITION::LEFT_CENTER:
    case ALTIUM_TEXT_POSITION::LEFT_BOTTOM:
        aTextbox->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aTextbox->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
        break;
    case ALTIUM_TEXT_POSITION::CENTER_TOP:
    case ALTIUM_TEXT_POSITION::CENTER_CENTER:
    case ALTIUM_TEXT_POSITION::CENTER_BOTTOM:
        aTextbox->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aTextbox->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
        break;
    case ALTIUM_TEXT_POSITION::RIGHT_TOP:
    case ALTIUM_TEXT_POSITION::RIGHT_CENTER:
    case ALTIUM_TEXT_POSITION::RIGHT_BOTTOM:
        aTextbox->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
        aTextbox->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
        break;
    default:
        if( m_reporter )
        {
            wxString msg;
            msg.Printf( _( "Unknown textbox justification %d, aText %s" ), justification,
                        aElem.text );
            m_reporter->Report( msg, RPT_SEVERITY_DEBUG );
        }
 
        aTextbox->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aTextbox->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
        break;
    }
 
    aTextbox->SetTextAngle( EDA_ANGLE( aElem.rotation, DEGREES_T ) );
}
 
 
void ALTIUM_PCB::HelperSetTextAlignmentAndPos( const ATEXT6& aElem, EDA_TEXT* aText )
{
    VECTOR2I kposition = aElem.position;
 
    int margin = aElem.isOffsetBorder ? aElem.text_offset_width : aElem.margin_border_width;
    int rectWidth = aElem.textbox_rect_width - margin * 2;
    int rectHeight = aElem.height;
 
    // A frame justifies its text inside the margins of its own rectangle, not the glyph run
    if( aElem.isFrame )
    {
        kposition.x += aElem.isMirrored ? -margin : margin;
        kposition.y -= margin;
        rectHeight = static_cast<int>( aElem.textbox_rect_height ) - margin * 2;
    }
 
    // Altium auto-sizes the bounding box of a free string (non-frame text) from its own glyph
    // rasterizer, and stores a slightly different width for otherwise identical strings placed on
    // different layers (e.g. the copper and soldermask copies of the same label, which Altium may
    // also give different stroke widths).  Anchoring the KiCad text to that per-record width drives
    // the two copies apart.  Center the text on its bare glyph run instead, measured from the
    // already-populated EDA_TEXT with the pen inflation removed, so copies that share a glyph run
    // stay coincident regardless of stroke width.
    if( !aElem.isFrame )
    {
        rectWidth = aText->GetTextBox( nullptr ).GetWidth();
 
        if( KIFONT::FONT* font = aText->GetFont(); !font || font->IsStroke() )
            rectWidth -= 3 * aText->GetEffectiveTextPenWidth();
    }
 
    if( aElem.isMirrored )
        rectWidth = -rectWidth;
 
    ALTIUM_TEXT_POSITION justification = aElem.isJustificationValid ? aElem.textbox_rect_justification
                                                                    : ALTIUM_TEXT_POSITION::LEFT_BOTTOM;
 
    switch( justification )
    {
    case ALTIUM_TEXT_POSITION::LEFT_TOP:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 
        kposition.y -= rectHeight;
        break;
    case ALTIUM_TEXT_POSITION::LEFT_CENTER:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 
        kposition.y -= rectHeight / 2;
        break;
    case ALTIUM_TEXT_POSITION::LEFT_BOTTOM:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
        break;
    case ALTIUM_TEXT_POSITION::CENTER_TOP:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 
        kposition.x += rectWidth / 2;
        kposition.y -= rectHeight;
        break;
    case ALTIUM_TEXT_POSITION::CENTER_CENTER:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 
        kposition.x += rectWidth / 2;
        kposition.y -= rectHeight / 2;
        break;
    case ALTIUM_TEXT_POSITION::CENTER_BOTTOM:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 
        kposition.x += rectWidth / 2;
        break;
    case ALTIUM_TEXT_POSITION::RIGHT_TOP:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 
        kposition.x += rectWidth;
        kposition.y -= rectHeight;
        break;
    case ALTIUM_TEXT_POSITION::RIGHT_CENTER:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 
        kposition.x += rectWidth;
        kposition.y -= rectHeight / 2;
        break;
    case ALTIUM_TEXT_POSITION::RIGHT_BOTTOM:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 
        kposition.x += rectWidth;
        break;
    default:
        aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
        aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
        break;
    }
 
    int charWidth = aText->GetTextWidth();
    int charHeight = aText->GetTextHeight();
 
    // Correct for KiCad's baseline offset.
    // Text height and font must be set correctly before calling.
    if( !aText->GetFont() || aText->GetFont()->IsStroke() )
    {
        switch( aText->GetVertJustify() )
        {
        case GR_TEXT_V_ALIGN_TOP: kposition.y -= charHeight * 0.0407; break;
        case GR_TEXT_V_ALIGN_CENTER: kposition.y += charHeight * 0.0355; break;
        case GR_TEXT_V_ALIGN_BOTTOM: kposition.y += charHeight * 0.1225; break;
        default: break;
        }
    }
    else
    {
        switch( aText->GetVertJustify() )
        {
        case GR_TEXT_V_ALIGN_TOP: kposition.y -= charWidth * 0.016; break;
        case GR_TEXT_V_ALIGN_CENTER: kposition.y += charWidth * 0.085; break;
        case GR_TEXT_V_ALIGN_BOTTOM: kposition.y += charWidth * 0.17; break;
        default: break;
        }
    }
 
    RotatePoint( kposition, aElem.position, EDA_ANGLE( aElem.rotation, DEGREES_T ) );
 
    aText->SetTextPos( kposition );
    aText->SetTextAngle( EDA_ANGLE( aElem.rotation, DEGREES_T ) );
}
 
 
void ALTIUM_PCB::ConvertTexts6ToEdaTextSettings( const ATEXT6& aElem, EDA_TEXT& aEdaText )
{
    aEdaText.SetTextSize( VECTOR2I( aElem.height, aElem.height ) );
 
    if( aElem.fonttype == ALTIUM_TEXT_TYPE::TRUETYPE )
    {
        KIFONT::FONT* font = KIFONT::FONT::GetFont( aElem.fontname, aElem.isBold, aElem.isItalic );
        aEdaText.SetFont( font );
 
        if( font->IsOutline() )
        {
            // TODO: why is this required? Somehow, truetype size is calculated differently
            if( font->GetName().Contains( wxS( "Arial" ) ) )
                aEdaText.SetTextSize( VECTOR2I( aElem.height * 0.63, aElem.height * 0.63 ) );
            else
                aEdaText.SetTextSize( VECTOR2I( aElem.height * 0.5, aElem.height * 0.5 ) );
        }
    }
 
    aEdaText.SetTextThickness( aElem.strokewidth );
    aEdaText.SetBoldFlag( aElem.isBold );
 
    // The imported width is already bolded; store the base so the Bold flag doesn't double it.
    aEdaText.MigrateLegacyBoldStrokeWidth();
 
    aEdaText.SetItalic( aElem.isItalic );
    aEdaText.SetMirrored( aElem.isMirrored );
}
 
 
void ALTIUM_PCB::ParseFills6Data( const ALTIUM_PCB_COMPOUND_FILE&     aAltiumPcbFile,
                                  const CFB::COMPOUND_FILE_ENTRY* aEntry )
{
    if( m_progressReporter )
        m_progressReporter->Report( _( "Loading rectangles..." ) );
 
    ALTIUM_BINARY_PARSER reader( aAltiumPcbFile, aEntry );
 
    while( reader.GetRemainingBytes() >= 4 /* TODO: use Header section of file */ )
    {
        checkpoint();
        AFILL6 elem( reader );
 
        if( elem.component == ALTIUM_COMPONENT_NONE )
        {
            ConvertFills6ToBoardItem( elem );
        }
        else
        {
            FOOTPRINT* footprint = HelperGetFootprint( elem.component );
            ConvertFills6ToFootprintItem( footprint, elem, true );
        }
    }
 
    if( reader.GetRemainingBytes() != 0 )
        THROW_IO_ERROR( wxT( "Fills6 stream is not fully parsed" ) );
}
 
 
void ALTIUM_PCB::ConvertFills6ToBoardItem( const AFILL6& aElem )
{
    if( aElem.is_keepout || aElem.layer == ALTIUM_LAYER::KEEP_OUT_LAYER )
    {
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr, SHAPE_T::RECTANGLE );
 
        shape.SetStart( aElem.pos1 );
        shape.SetEnd( aElem.pos2 );
        shape.SetFilled( true );
        shape.SetStroke( STROKE_PARAMS( 0, LINE_STYLE::SOLID ) );
 
        if( aElem.rotation != 0. )
        {
            VECTOR2I center( aElem.pos1.x / 2 + aElem.pos2.x / 2,
                             aElem.pos1.y / 2 + aElem.pos2.y / 2 );
            shape.Rotate( center, EDA_ANGLE( aElem.rotation, DEGREES_T ) );
        }
 
        HelperPcpShapeAsBoardKeepoutRegion( shape, aElem.layer, aElem.keepoutrestrictions );
    }
    else
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            ConvertFills6ToBoardItemOnLayer( aElem, klayer );
    }
}
 
 
void ALTIUM_PCB::ConvertFills6ToFootprintItem( FOOTPRINT* aFootprint, const AFILL6& aElem,
                                               const bool aIsBoardImport )
{
    if( aElem.is_keepout
        || aElem.layer == ALTIUM_LAYER::KEEP_OUT_LAYER ) // TODO: what about plane layers?
    {
        // This is not the actual board item. We can use it to create the polygon for the region
        PCB_SHAPE shape( nullptr, SHAPE_T::RECTANGLE );
 
        shape.SetStart( aElem.pos1 );
        shape.SetEnd( aElem.pos2 );
        shape.SetFilled( true );
        shape.SetStroke( STROKE_PARAMS( 0, LINE_STYLE::SOLID ) );
 
        if( aElem.rotation != 0. )
        {
            VECTOR2I center( aElem.pos1.x / 2 + aElem.pos2.x / 2,
                             aElem.pos1.y / 2 + aElem.pos2.y / 2 );
            shape.Rotate( center, EDA_ANGLE( aElem.rotation, DEGREES_T ) );
        }
 
        HelperPcpShapeAsFootprintKeepoutRegion( aFootprint, shape, aElem.layer,
                                                aElem.keepoutrestrictions );
    }
    else if( IsAltiumLayerCopper( aElem.layer ) && ( !aIsBoardImport || aElem.net != ALTIUM_NET_UNCONNECTED ) )
    {
        // Footprint graphics are not connected, so copper waits to join a pad it touches
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
        {
            // An outer library fill already becomes a pad
            if( !aIsBoardImport && !IsInnerCopperLayer( klayer ) )
            {
                ConvertFills6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
                continue;
            }
 
            std::unique_ptr<PCB_SHAPE> fill = std::make_unique<PCB_SHAPE>( nullptr, SHAPE_T::RECTANGLE );
 
            ConvertFills6ToPcbShape( aElem, fill.get() );
 
            HelperDeferComponentCopper( aFootprint, klayer, aIsBoardImport ? aElem.net : ALTIUM_NET_UNCONNECTED,
                                        std::move( fill ),
                                        [this, aFootprint, aElem, klayer, aIsBoardImport]()
                                        {
                                            if( aIsBoardImport )
                                                ConvertFills6ToBoardItemOnLayer( aElem, klayer );
                                            else
                                                ConvertFills6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
                                        } );
        }
    }
    else
    {
        for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aElem.layer ) )
            ConvertFills6ToFootprintItemOnLayer( aFootprint, aElem, klayer );
    }
}
 
 
void ALTIUM_PCB::ConvertFills6ToPcbShape( const AFILL6& aElem, PCB_SHAPE* aShape )
{
    aShape->SetShape( SHAPE_T::RECTANGLE );
    aShape->SetFilled( true );
    aShape->SetStroke( STROKE_PARAMS( 0 ) );
 
    aShape->SetStart( aElem.pos1 );
    aShape->SetEnd( aElem.pos2 );
 
    if( aElem.rotation != 0. )
    {
        // TODO: Do we need SHAPE_T::POLY for non 90° rotations?
        VECTOR2I center( aElem.pos1.x / 2 + aElem.pos2.x / 2,
                         aElem.pos1.y / 2 + aElem.pos2.y / 2 );
        aShape->Rotate( center, EDA_ANGLE( aElem.rotation, DEGREES_T ) );
    }
}
 
 
void ALTIUM_PCB::ConvertFills6ToBoardItemOnLayer( const AFILL6& aElem, PCB_LAYER_ID aLayer )
{
    std::unique_ptr<PCB_SHAPE> fill = std::make_unique<PCB_SHAPE>( m_board, SHAPE_T::RECTANGLE );
 
    ConvertFills6ToPcbShape( aElem, fill.get() );
    fill->SetLayer( aLayer );
 
    if( IsCopperLayer( aLayer ) && aElem.net != ALTIUM_NET_UNCONNECTED )
    {
        fill->SetNetCode( GetNetCode( aElem.net ) );
    }
 
    m_board->Add( fill.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::ConvertFills6ToFootprintItemOnLayer( FOOTPRINT* aFootprint, const AFILL6& aElem,
                                                      PCB_LAYER_ID aLayer )
{
    if( aLayer == F_Cu || aLayer == B_Cu )
    {
        std::unique_ptr<PAD> pad = std::make_unique<PAD>( aFootprint );
 
        LSET padLayers;
        padLayers.set( aLayer );
 
        pad->SetAttribute( PAD_ATTRIB::SMD );
        EDA_ANGLE rotation( aElem.rotation, DEGREES_T );
 
        // Handle rotation multiples of 90 degrees
        if( rotation.IsCardinal() )
        {
            pad->SetPadstackMode( PADSTACK::MODE::NORMAL );
            pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::RECTANGLE );
 
            int width = std::abs( aElem.pos2.x - aElem.pos1.x );
            int height = std::abs( aElem.pos2.y - aElem.pos1.y );
 
            // Swap width and height for 90 or 270 degree rotations
            if( rotation.IsCardinal90() )
                std::swap( width, height );
 
            pad->SetSize( PADSTACK::ALL_LAYERS, { width, height } );
            pad->SetPosition( aElem.pos1 / 2 + aElem.pos2 / 2 );
        }
        else
        {
            pad->SetPadstackMode( PADSTACK::MODE::NORMAL );
            pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CUSTOM );
 
            int      anchorSize = std::min( std::abs( aElem.pos2.x - aElem.pos1.x ),
                                            std::abs( aElem.pos2.y - aElem.pos1.y ) );
            VECTOR2I anchorPos = aElem.pos1;
 
            pad->SetAnchorPadShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );
            pad->SetSize( PADSTACK::ALL_LAYERS, { anchorSize, anchorSize } );
            pad->SetPosition( anchorPos );
 
            SHAPE_POLY_SET shapePolys;
            shapePolys.NewOutline();
            shapePolys.Append( aElem.pos1.x - anchorPos.x, aElem.pos1.y - anchorPos.y );
            shapePolys.Append( aElem.pos2.x - anchorPos.x, aElem.pos1.y - anchorPos.y );
            shapePolys.Append( aElem.pos2.x - anchorPos.x, aElem.pos2.y - anchorPos.y );
            shapePolys.Append( aElem.pos1.x - anchorPos.x, aElem.pos2.y - anchorPos.y );
            shapePolys.Outline( 0 ).SetClosed( true );
 
            VECTOR2I center( aElem.pos1.x / 2 + aElem.pos2.x / 2 - anchorPos.x,
                             aElem.pos1.y / 2 + aElem.pos2.y / 2 - anchorPos.y );
            shapePolys.Rotate( EDA_ANGLE( aElem.rotation, DEGREES_T ), center );
            pad->AddPrimitivePoly( F_Cu, shapePolys, 0, true );
        }
 
        pad->SetThermalSpokeAngle( ANGLE_90 );
        pad->SetLayerSet( padLayers );
 
        aFootprint->Add( pad.release(), ADD_MODE::APPEND );
    }
    else
    {
        std::unique_ptr<PCB_SHAPE> fill = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::RECTANGLE );
 
        fill->SetFilled( true );
        fill->SetLayer( aLayer );
        fill->SetStroke( STROKE_PARAMS( 0 ) );
 
        fill->SetStart( aElem.pos1 );
        fill->SetEnd( aElem.pos2 );
 
        if( aElem.rotation != 0. )
        {
            VECTOR2I center( aElem.pos1.x / 2 + aElem.pos2.x / 2,
                             aElem.pos1.y / 2 + aElem.pos2.y / 2 );
            fill->Rotate( center, EDA_ANGLE( aElem.rotation, DEGREES_T ) );
        }
 
        aFootprint->Add( fill.release(), ADD_MODE::APPEND );
    }
}
 
 
void ALTIUM_PCB::HelperSetZoneLayers( ZONE& aZone, const ALTIUM_LAYER aAltiumLayer )
{
    LSET layerSet;
 
    for( PCB_LAYER_ID klayer : GetKicadLayersToIterate( aAltiumLayer ) )
        layerSet.set( klayer );
 
    aZone.SetLayerSet( layerSet );
}
 
 
void ALTIUM_PCB::HelperSetZoneKeepoutRestrictions( ZONE& aZone, const uint8_t aKeepoutRestrictions )
{
    bool keepoutRestrictionVia = ( aKeepoutRestrictions & ALTIUM_KEEPOUT_VIA ) != 0;
    bool keepoutRestrictionTrack = ( aKeepoutRestrictions & ALTIUM_KEEPOUT_TRACK ) != 0;
    bool keepoutRestrictionCopper = ( aKeepoutRestrictions & ALTIUM_KEEPOUT_COPPER ) != 0;
    bool keepoutRestrictionSMDPad = ( aKeepoutRestrictions & ALTIUM_KEEPOUT_SMD_PAD ) != 0;
    bool keepoutRestrictionTHPad = ( aKeepoutRestrictions & ALTIUM_KEEPOUT_TH_PAD ) != 0;
 
    aZone.SetDoNotAllowVias( keepoutRestrictionVia );
    aZone.SetDoNotAllowTracks( keepoutRestrictionTrack );
    aZone.SetDoNotAllowZoneFills( keepoutRestrictionCopper );
    aZone.SetDoNotAllowPads( keepoutRestrictionSMDPad && keepoutRestrictionTHPad );
    aZone.SetDoNotAllowFootprints( false );
}
 
 
uint8_t ALTIUM_PCB::HelperGetKeepoutRestrictions( const uint8_t aKeepoutRestrictions, const ALTIUM_LAYER aAltiumLayer )
{
    // An internal plane is negative, so every primitive drawn on one cuts copper out of it
    // whatever else the mask says
    if( IsAltiumLayerAPlane( aAltiumLayer ) )
        return static_cast<uint8_t>( aKeepoutRestrictions | ALTIUM_KEEPOUT_COPPER );
 
    if( aKeepoutRestrictions != 0 )
        return aKeepoutRestrictions;
 
    // Altium leaves the mask empty on the Keep-Out layer because the layer already means
    // "keep everything out"
    if( aAltiumLayer == ALTIUM_LAYER::KEEP_OUT_LAYER )
        return ALTIUM_KEEPOUT_ALL;
 
    if( m_reporter )
    {
        m_reporter->Report( _( "Ignored a keep-out area with no restrictions." ), RPT_SEVERITY_INFO );
    }
 
    return 0;
}
 
 
void ALTIUM_PCB::HelperFootprintZoneToLibFrame( ZONE& aZone, const FOOTPRINT& aFootprint )
{
    // A footprint zone stores its outline in the footprint's local frame and derives its board
    // position by applying the footprint transform.  The importer builds the outline in board
    // coordinates, so it must be re-based here or the zone drifts by the footprint offset when the
    // board is re-centered at the end of the import.
    const TRANSFORM_TRS& xform = aFootprint.GetTransform();
    SHAPE_POLY_SET&      poly = *aZone.Outline();
 
    for( auto it = poly.IterateWithHoles(); it; it++ )
        poly.SetVertex( it.GetIndex(), xform.InverseApply( *it ) );
}
 
 
void ALTIUM_PCB::HelperPcpShapeAsBoardKeepoutRegion( const PCB_SHAPE&   aShape,
                                                     const ALTIUM_LAYER aAltiumLayer,
                                                     const uint8_t      aKeepoutRestrictions )
{
    uint8_t restrictions = HelperGetKeepoutRestrictions( aKeepoutRestrictions, aAltiumLayer );
 
    if( restrictions == 0 )
        return;
 
    std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( m_board );
 
    zone->SetIsRuleArea( true );
 
    HelperSetZoneLayers( *zone, aAltiumLayer );
    HelperSetZoneKeepoutRestrictions( *zone, restrictions );
 
    aShape.EDA_SHAPE::TransformShapeToPolygon( *zone->Outline(), 0, ARC_HIGH_DEF, ERROR_INSIDE );
 
    zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
                                 ZONE::GetDefaultHatchPitch(), true );
 
    m_board->Add( zone.release(), ADD_MODE::APPEND );
}
 
 
void ALTIUM_PCB::HelperPcpShapeAsFootprintKeepoutRegion( FOOTPRINT*         aFootprint,
                                                         const PCB_SHAPE&   aShape,
                                                         const ALTIUM_LAYER aAltiumLayer,
                                                         const uint8_t      aKeepoutRestrictions )
{
    uint8_t restrictions = HelperGetKeepoutRestrictions( aKeepoutRestrictions, aAltiumLayer );
 
    if( restrictions == 0 )
        return;
 
    std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( aFootprint );
 
    zone->SetIsRuleArea( true );
 
    HelperSetZoneLayers( *zone, aAltiumLayer );
    HelperSetZoneKeepoutRestrictions( *zone, restrictions );
 
    aShape.EDA_SHAPE::TransformShapeToPolygon( *zone->Outline(), 0, ARC_HIGH_DEF, ERROR_INSIDE );
 
    HelperFootprintZoneToLibFrame( *zone, *aFootprint );
 
    zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
                                 ZONE::GetDefaultHatchPitch(), true );
 
    aFootprint->Add( zone.release(), ADD_MODE::APPEND );
}
 
 
std::vector<std::pair<PCB_LAYER_ID, int>> ALTIUM_PCB::HelperGetSolderAndPasteMaskExpansions(
        const ALTIUM_RECORD aType, const int aPrimitiveIndex, const ALTIUM_LAYER aAltiumLayer )
{
    if( m_extendedPrimitiveInformationMaps.count( aType ) == 0 )
        return {}; // there is nothing to parse
 
    auto elems = m_extendedPrimitiveInformationMaps[aType].equal_range( aPrimitiveIndex );
 
    if( elems.first == elems.second )
        return {}; // there is nothing to parse
 
    std::vector<std::pair<PCB_LAYER_ID, int>> layerExpansionPairs;
 
    for( auto it = elems.first; it != elems.second; ++it )
    {
        const AEXTENDED_PRIMITIVE_INFORMATION& pInf = it->second;
 
        if( pInf.type == AEXTENDED_PRIMITIVE_INFORMATION_TYPE::MASK )
        {
            if( pInf.soldermaskexpansionmode == ALTIUM_MODE::MANUAL
                || pInf.soldermaskexpansionmode == ALTIUM_MODE::RULE )
            {
                // TODO: what layers can lead to solder or paste mask usage? E.g. KEEP_OUT_LAYER and other top/bottom layers
                if( aAltiumLayer == ALTIUM_LAYER::TOP_LAYER
                    || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
                {
                    layerExpansionPairs.emplace_back( F_Mask, pInf.soldermaskexpansionmanual );
                }
 
                if( aAltiumLayer == ALTIUM_LAYER::BOTTOM_LAYER
                    || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
                {
                    layerExpansionPairs.emplace_back( B_Mask, pInf.soldermaskexpansionmanual );
                }
            }
            if( pInf.pastemaskexpansionmode == ALTIUM_MODE::MANUAL
                || pInf.pastemaskexpansionmode == ALTIUM_MODE::RULE )
            {
                if( aAltiumLayer == ALTIUM_LAYER::TOP_LAYER
                    || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
                {
                    layerExpansionPairs.emplace_back( F_Paste, pInf.pastemaskexpansionmanual );
                }
 
                if( aAltiumLayer == ALTIUM_LAYER::BOTTOM_LAYER
                    || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
                {
                    layerExpansionPairs.emplace_back( B_Paste, pInf.pastemaskexpansionmanual );
                }
            }
        }
    }
 
    return layerExpansionPairs;
}