pads_layer_mapper.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "pads_layer_mapper.h"
 
#include <algorithm>
#include <cctype>
 
#include <io/pads/pads_common.h>
 
#include <wx/string.h>
 
 
PADS_LAYER_MAPPER::PADS_LAYER_MAPPER() :
    m_copperLayerCount( 2 )
{
    // Keys are normalized to lower case; ParseLayerName lower-cases before lookup.
    m_layerNameMap["silkscreen top"] = PADS_LAYER_TYPE::SILKSCREEN_TOP;
    m_layerNameMap["silk top"] = PADS_LAYER_TYPE::SILKSCREEN_TOP;
    m_layerNameMap["sst"] = PADS_LAYER_TYPE::SILKSCREEN_TOP;
    m_layerNameMap["top silk"] = PADS_LAYER_TYPE::SILKSCREEN_TOP;
    m_layerNameMap["top overlay"] = PADS_LAYER_TYPE::SILKSCREEN_TOP;
 
    m_layerNameMap["silkscreen bottom"] = PADS_LAYER_TYPE::SILKSCREEN_BOTTOM;
    m_layerNameMap["silk bottom"] = PADS_LAYER_TYPE::SILKSCREEN_BOTTOM;
    m_layerNameMap["ssb"] = PADS_LAYER_TYPE::SILKSCREEN_BOTTOM;
    m_layerNameMap["bottom silk"] = PADS_LAYER_TYPE::SILKSCREEN_BOTTOM;
    m_layerNameMap["bottom overlay"] = PADS_LAYER_TYPE::SILKSCREEN_BOTTOM;
 
    m_layerNameMap["solder mask top"] = PADS_LAYER_TYPE::SOLDERMASK_TOP;
    m_layerNameMap["soldermask top"] = PADS_LAYER_TYPE::SOLDERMASK_TOP;
    m_layerNameMap["smt"] = PADS_LAYER_TYPE::SOLDERMASK_TOP;
    m_layerNameMap["top mask"] = PADS_LAYER_TYPE::SOLDERMASK_TOP;
    m_layerNameMap["top solder mask"] = PADS_LAYER_TYPE::SOLDERMASK_TOP;
 
    m_layerNameMap["solder mask bottom"] = PADS_LAYER_TYPE::SOLDERMASK_BOTTOM;
    m_layerNameMap["soldermask bottom"] = PADS_LAYER_TYPE::SOLDERMASK_BOTTOM;
    m_layerNameMap["smb"] = PADS_LAYER_TYPE::SOLDERMASK_BOTTOM;
    m_layerNameMap["bottom mask"] = PADS_LAYER_TYPE::SOLDERMASK_BOTTOM;
    m_layerNameMap["bottom solder mask"] = PADS_LAYER_TYPE::SOLDERMASK_BOTTOM;
 
    m_layerNameMap["paste top"] = PADS_LAYER_TYPE::PASTE_TOP;
    m_layerNameMap["paste mask top"] = PADS_LAYER_TYPE::PASTE_TOP;
    m_layerNameMap["solder paste top"] = PADS_LAYER_TYPE::PASTE_TOP;
    m_layerNameMap["top paste"] = PADS_LAYER_TYPE::PASTE_TOP;
 
    m_layerNameMap["paste bottom"] = PADS_LAYER_TYPE::PASTE_BOTTOM;
    m_layerNameMap["paste mask bottom"] = PADS_LAYER_TYPE::PASTE_BOTTOM;
    m_layerNameMap["solder paste bottom"] = PADS_LAYER_TYPE::PASTE_BOTTOM;
    m_layerNameMap["bottom paste"] = PADS_LAYER_TYPE::PASTE_BOTTOM;
 
    m_layerNameMap["assembly top"] = PADS_LAYER_TYPE::ASSEMBLY_TOP;
    m_layerNameMap["assembly drawing top"] = PADS_LAYER_TYPE::ASSEMBLY_TOP;
    m_layerNameMap["top assembly"] = PADS_LAYER_TYPE::ASSEMBLY_TOP;
    m_layerNameMap["assy top"] = PADS_LAYER_TYPE::ASSEMBLY_TOP;
    m_layerNameMap["component outline top"] = PADS_LAYER_TYPE::ASSEMBLY_TOP;
 
    m_layerNameMap["assembly bottom"] = PADS_LAYER_TYPE::ASSEMBLY_BOTTOM;
    m_layerNameMap["assembly drawing bottom"] = PADS_LAYER_TYPE::ASSEMBLY_BOTTOM;
    m_layerNameMap["bottom assembly"] = PADS_LAYER_TYPE::ASSEMBLY_BOTTOM;
    m_layerNameMap["assy bottom"] = PADS_LAYER_TYPE::ASSEMBLY_BOTTOM;
    m_layerNameMap["component outline bottom"] = PADS_LAYER_TYPE::ASSEMBLY_BOTTOM;
 
    m_layerNameMap["board outline"] = PADS_LAYER_TYPE::BOARD_OUTLINE;
    m_layerNameMap["board"] = PADS_LAYER_TYPE::BOARD_OUTLINE;
    m_layerNameMap["outline"] = PADS_LAYER_TYPE::BOARD_OUTLINE;
    m_layerNameMap["board geometry"] = PADS_LAYER_TYPE::BOARD_OUTLINE;
 
    m_layerNameMap["top copper"] = PADS_LAYER_TYPE::COPPER_TOP;
    m_layerNameMap["top layer"] = PADS_LAYER_TYPE::COPPER_TOP;
    m_layerNameMap["top cu"] = PADS_LAYER_TYPE::COPPER_TOP;
 
    m_layerNameMap["bottom copper"] = PADS_LAYER_TYPE::COPPER_BOTTOM;
    m_layerNameMap["bottom layer"] = PADS_LAYER_TYPE::COPPER_BOTTOM;
    m_layerNameMap["bottom cu"] = PADS_LAYER_TYPE::COPPER_BOTTOM;
    m_layerNameMap["bot copper"] = PADS_LAYER_TYPE::COPPER_BOTTOM;
    m_layerNameMap["bot layer"] = PADS_LAYER_TYPE::COPPER_BOTTOM;
    m_layerNameMap["bot cu"] = PADS_LAYER_TYPE::COPPER_BOTTOM;
 
    m_layerNameMap["documentation"] = PADS_LAYER_TYPE::DOCUMENTATION;
    m_layerNameMap["doc"] = PADS_LAYER_TYPE::DOCUMENTATION;
    m_layerNameMap["drill drawing"] = PADS_LAYER_TYPE::DRILL_DRAWING;
}
 
 
void PADS_LAYER_MAPPER::SetCopperLayerCount( int aLayerCount )
{
    if( aLayerCount < 1 )
        aLayerCount = 1;
 
    m_copperLayerCount = aLayerCount;
}
 
 
std::string PADS_LAYER_MAPPER::normalizeLayerName( const std::string& aName ) const
{
    std::string normalized;
    normalized.reserve( aName.size() );
 
    for( char c : aName )
    {
        normalized += static_cast<char>( std::tolower( static_cast<unsigned char>( c ) ) );
    }
 
    return normalized;
}
 
 
PADS_LAYER_TYPE PADS_LAYER_MAPPER::GetLayerType( int aPadsLayer ) const
{
    if( aPadsLayer == LAYER_PAD_STACK_TOP )
        return PADS_LAYER_TYPE::COPPER_TOP;
 
    if( aPadsLayer == LAYER_PAD_STACK_BOTTOM )
        return PADS_LAYER_TYPE::COPPER_BOTTOM;
 
    if( aPadsLayer == LAYER_PAD_STACK_INNER )
        return PADS_LAYER_TYPE::COPPER_INNER;
 
    // Copper layers: 1 = Top, m_copperLayerCount = Bottom, 2 to N-1 = Inner
    if( aPadsLayer == 1 )
        return PADS_LAYER_TYPE::COPPER_TOP;
 
    if( aPadsLayer == m_copperLayerCount && m_copperLayerCount > 1 )
        return PADS_LAYER_TYPE::COPPER_BOTTOM;
 
    if( aPadsLayer > 1 && aPadsLayer < m_copperLayerCount )
        return PADS_LAYER_TYPE::COPPER_INNER;
 
    if( aPadsLayer == LAYER_DRILL_DRAWING )
        return PADS_LAYER_TYPE::DRILL_DRAWING;
 
    if( aPadsLayer == LAYER_DIMENSIONS || aPadsLayer == LAYER_PLACEMENT_OUTLINE )
        return PADS_LAYER_TYPE::DOCUMENTATION;
 
    if( aPadsLayer == LAYER_ASSEMBLY_TOP )
        return PADS_LAYER_TYPE::ASSEMBLY_TOP;
 
    if( aPadsLayer == LAYER_ASSEMBLY_BOTTOM )
        return PADS_LAYER_TYPE::ASSEMBLY_BOTTOM;
 
    if( aPadsLayer == LAYER_SOLDERMASK_TOP )
        return PADS_LAYER_TYPE::SOLDERMASK_TOP;
 
    if( aPadsLayer == LAYER_SILKSCREEN_TOP )
        return PADS_LAYER_TYPE::SILKSCREEN_TOP;
 
    if( aPadsLayer == LAYER_SILKSCREEN_BOTTOM )
        return PADS_LAYER_TYPE::SILKSCREEN_BOTTOM;
 
    if( aPadsLayer == LAYER_SOLDERMASK_BOTTOM )
        return PADS_LAYER_TYPE::SOLDERMASK_BOTTOM;
 
    if( aPadsLayer == LAYER_PASTE_TOP )
        return PADS_LAYER_TYPE::PASTE_TOP;
 
    if( aPadsLayer == LAYER_PASTE_BOTTOM )
        return PADS_LAYER_TYPE::PASTE_BOTTOM;
 
    return PADS_LAYER_TYPE::UNKNOWN;
}
 
 
PADS_LAYER_TYPE PADS_LAYER_MAPPER::ParseLayerName( const std::string& aLayerName ) const
{
    std::string normalized = normalizeLayerName( aLayerName );
 
    auto it = m_layerNameMap.find( normalized );
 
    if( it != m_layerNameMap.end() )
        return it->second;
 
    // Match the whole name, or an ordinal prefix for the numbered inner layers. A substring is not
    // evidence of copper: "Top Notes", "Topology" and "Bot Assy Text" all contain one, and an
    // unknown layer becomes documentation rather than silkscreen on F_Cu.
    if( normalized == "top" || normalized == "layer 1" || normalized == "1" )
        return PADS_LAYER_TYPE::COPPER_TOP;
 
    if( normalized == "bottom" || normalized == "bot" )
        return PADS_LAYER_TYPE::COPPER_BOTTOM;
 
    // An inner layer is the ordinal word alone or followed by its number. Requiring the boundary
    // keeps "Internally Routed" and "Middle East Notes" out.
    auto isOrdinalWord = []( const std::string& aName, const std::string& aWord )
    {
        if( !aName.starts_with( aWord ) )
            return false;
 
        if( aName.size() == aWord.size() )
            return true;
 
        char next = aName[aWord.size()];
 
        return next == ' ' || next == '_' || next == '-'
               || std::isdigit( static_cast<unsigned char>( next ) ) != 0;
    };
 
    if( isOrdinalWord( normalized, "internal" ) || isOrdinalWord( normalized, "inner" )
        || isOrdinalWord( normalized, "mid" ) )
    {
        return PADS_LAYER_TYPE::COPPER_INNER;
    }
 
    return PADS_LAYER_TYPE::UNKNOWN;
}
 
 
PCB_LAYER_ID PADS_LAYER_MAPPER::mapInnerCopperLayer( int aPadsLayer ) const
{
    // PADS inner layers run 2..(count-1); KiCad In*_Cu IDs are spaced by 2.
    int innerIndex = aPadsLayer - 2;
 
    if( innerIndex < 0 )
        innerIndex = 0;
 
    if( innerIndex >= 30 )
        innerIndex = 29;
 
    return static_cast<PCB_LAYER_ID>( In1_Cu + innerIndex * 2 );
}
 
 
PCB_LAYER_ID PADS_LAYER_MAPPER::GetAutoMapLayer( int aPadsLayer, PADS_LAYER_TYPE aType ) const
{
    if( aType == PADS_LAYER_TYPE::UNKNOWN )
        aType = GetLayerType( aPadsLayer );
 
    switch( aType )
    {
    case PADS_LAYER_TYPE::COPPER_TOP:
        return F_Cu;
 
    case PADS_LAYER_TYPE::COPPER_BOTTOM:
        return B_Cu;
 
    case PADS_LAYER_TYPE::COPPER_INNER:
        return mapInnerCopperLayer( aPadsLayer );
 
    case PADS_LAYER_TYPE::SILKSCREEN_TOP:
        return F_SilkS;
 
    case PADS_LAYER_TYPE::SILKSCREEN_BOTTOM:
        return B_SilkS;
 
    case PADS_LAYER_TYPE::SOLDERMASK_TOP:
        return F_Mask;
 
    case PADS_LAYER_TYPE::SOLDERMASK_BOTTOM:
        return B_Mask;
 
    case PADS_LAYER_TYPE::PASTE_TOP:
        return F_Paste;
 
    case PADS_LAYER_TYPE::PASTE_BOTTOM:
        return B_Paste;
 
    case PADS_LAYER_TYPE::ASSEMBLY_TOP:
        return F_Fab;
 
    case PADS_LAYER_TYPE::ASSEMBLY_BOTTOM:
        return B_Fab;
 
    case PADS_LAYER_TYPE::BOARD_OUTLINE:
        return Edge_Cuts;
 
    case PADS_LAYER_TYPE::DOCUMENTATION:
        return Cmts_User;
 
    case PADS_LAYER_TYPE::DRILL_DRAWING:
        return Dwgs_User;
 
    case PADS_LAYER_TYPE::UNKNOWN:
    default:
        return UNDEFINED_LAYER;
    }
}
 
 
LSET PADS_LAYER_MAPPER::GetPermittedLayers( PADS_LAYER_TYPE aType ) const
{
    switch( aType )
    {
    case PADS_LAYER_TYPE::COPPER_TOP:
    case PADS_LAYER_TYPE::COPPER_BOTTOM:
    case PADS_LAYER_TYPE::COPPER_INNER:
        return LSET::AllCuMask();
 
    case PADS_LAYER_TYPE::SILKSCREEN_TOP:
    case PADS_LAYER_TYPE::SILKSCREEN_BOTTOM:
        return LSET( { F_SilkS, B_SilkS } );
 
    case PADS_LAYER_TYPE::SOLDERMASK_TOP:
    case PADS_LAYER_TYPE::SOLDERMASK_BOTTOM:
        return LSET( { F_Mask, B_Mask } );
 
    case PADS_LAYER_TYPE::PASTE_TOP:
    case PADS_LAYER_TYPE::PASTE_BOTTOM:
        return LSET( { F_Paste, B_Paste } );
 
    case PADS_LAYER_TYPE::ASSEMBLY_TOP:
    case PADS_LAYER_TYPE::ASSEMBLY_BOTTOM:
        return LSET( { F_Fab, B_Fab, F_CrtYd, B_CrtYd } );
 
    case PADS_LAYER_TYPE::BOARD_OUTLINE:
        return LSET( { Edge_Cuts } );
 
    case PADS_LAYER_TYPE::DOCUMENTATION:
        return LSET::AllNonCuMask();
 
    case PADS_LAYER_TYPE::DRILL_DRAWING:
        return LSET( { Dwgs_User, F_Fab, B_Fab, Cmts_User } );
 
    case PADS_LAYER_TYPE::UNKNOWN:
    default:
        return LSET::AllLayersMask();
    }
}
 
 
std::vector<INPUT_LAYER_DESC> PADS_LAYER_MAPPER::BuildInputLayerDescriptions(
        const std::vector<PADS_LAYER_INFO>& aLayerInfos ) const
{
    std::vector<INPUT_LAYER_DESC> descs;
    descs.reserve( aLayerInfos.size() );
 
    for( const PADS_LAYER_INFO& info : aLayerInfos )
    {
        INPUT_LAYER_DESC desc;
 
        desc.Name = PADS_COMMON::ConvertText( info.name );
        desc.PermittedLayers = GetPermittedLayers( info.type );
        desc.AutoMapLayer = GetAutoMapLayer( info.padsLayerNum, info.type );
        desc.Required = info.required;
 
        descs.push_back( desc );
    }
 
    return descs;
}
 
 
void PADS_LAYER_MAPPER::AddLayerNameMapping( const std::string& aName, PADS_LAYER_TYPE aType )
{
    std::string normalized = normalizeLayerName( aName );
    m_layerNameMap[normalized] = aType;
}
 
 
std::string PADS_LAYER_MAPPER::LayerTypeToString( PADS_LAYER_TYPE aType )
{
    switch( aType )
    {
    case PADS_LAYER_TYPE::COPPER_TOP:        return "Copper Top";
    case PADS_LAYER_TYPE::COPPER_BOTTOM:     return "Copper Bottom";
    case PADS_LAYER_TYPE::COPPER_INNER:      return "Copper Inner";
    case PADS_LAYER_TYPE::SILKSCREEN_TOP:    return "Silkscreen Top";
    case PADS_LAYER_TYPE::SILKSCREEN_BOTTOM: return "Silkscreen Bottom";
    case PADS_LAYER_TYPE::SOLDERMASK_TOP:    return "Solder Mask Top";
    case PADS_LAYER_TYPE::SOLDERMASK_BOTTOM: return "Solder Mask Bottom";
    case PADS_LAYER_TYPE::PASTE_TOP:         return "Paste Top";
    case PADS_LAYER_TYPE::PASTE_BOTTOM:      return "Paste Bottom";
    case PADS_LAYER_TYPE::ASSEMBLY_TOP:      return "Assembly Top";
    case PADS_LAYER_TYPE::ASSEMBLY_BOTTOM:   return "Assembly Bottom";
    case PADS_LAYER_TYPE::DOCUMENTATION:     return "Documentation";
    case PADS_LAYER_TYPE::BOARD_OUTLINE:     return "Board Outline";
    case PADS_LAYER_TYPE::DRILL_DRAWING:     return "Drill Drawing";
    case PADS_LAYER_TYPE::UNKNOWN:
    default:                                 return "Unknown";
    }
}