47#include <compoundfilereader.h>
54#include <wx/docview.h>
56#include <wx/mstream.h>
57#include <wx/wfstream.h>
58#include <wx/zstream.h>
60#include <magic_enum.hpp>
82 THROW_IO_ERROR( wxString::Format( wxT(
"Component creator tries to access component id %u "
83 "of %u existing components" ),
92 const std::vector<ALTIUM_VERTICE>& aVertices )
101 double startradiant =
DEG2RAD( vertex.startangle );
102 double endradiant =
DEG2RAD( vertex.endangle );
104 -
KiROUND( std::sin( startradiant ) * vertex.radius ) );
107 -
KiROUND( std::sin( endradiant ) * vertex.radius ) );
109 VECTOR2I arcStart = vertex.center + arcStartOffset;
110 VECTOR2I arcEnd = vertex.center + arcEndOffset;
115 if( arcStart.
Distance( vertex.position )
116 < arcEnd.
Distance( vertex.position ) )
143 aLine.
Append( vertex.position );
153 auto override =
m_layermap.find( aAltiumLayer );
157 return override->second;
160 switch( aAltiumLayer )
164 case ALTIUM_LAYER::TOP_LAYER:
return F_Cu;
165 case ALTIUM_LAYER::MID_LAYER_1:
return In1_Cu;
166 case ALTIUM_LAYER::MID_LAYER_2:
return In2_Cu;
167 case ALTIUM_LAYER::MID_LAYER_3:
return In3_Cu;
168 case ALTIUM_LAYER::MID_LAYER_4:
return In4_Cu;
169 case ALTIUM_LAYER::MID_LAYER_5:
return In5_Cu;
170 case ALTIUM_LAYER::MID_LAYER_6:
return In6_Cu;
171 case ALTIUM_LAYER::MID_LAYER_7:
return In7_Cu;
172 case ALTIUM_LAYER::MID_LAYER_8:
return In8_Cu;
173 case ALTIUM_LAYER::MID_LAYER_9:
return In9_Cu;
174 case ALTIUM_LAYER::MID_LAYER_10:
return In10_Cu;
175 case ALTIUM_LAYER::MID_LAYER_11:
return In11_Cu;
176 case ALTIUM_LAYER::MID_LAYER_12:
return In12_Cu;
177 case ALTIUM_LAYER::MID_LAYER_13:
return In13_Cu;
178 case ALTIUM_LAYER::MID_LAYER_14:
return In14_Cu;
179 case ALTIUM_LAYER::MID_LAYER_15:
return In15_Cu;
180 case ALTIUM_LAYER::MID_LAYER_16:
return In16_Cu;
181 case ALTIUM_LAYER::MID_LAYER_17:
return In17_Cu;
182 case ALTIUM_LAYER::MID_LAYER_18:
return In18_Cu;
183 case ALTIUM_LAYER::MID_LAYER_19:
return In19_Cu;
184 case ALTIUM_LAYER::MID_LAYER_20:
return In20_Cu;
185 case ALTIUM_LAYER::MID_LAYER_21:
return In21_Cu;
186 case ALTIUM_LAYER::MID_LAYER_22:
return In22_Cu;
187 case ALTIUM_LAYER::MID_LAYER_23:
return In23_Cu;
188 case ALTIUM_LAYER::MID_LAYER_24:
return In24_Cu;
189 case ALTIUM_LAYER::MID_LAYER_25:
return In25_Cu;
190 case ALTIUM_LAYER::MID_LAYER_26:
return In26_Cu;
191 case ALTIUM_LAYER::MID_LAYER_27:
return In27_Cu;
192 case ALTIUM_LAYER::MID_LAYER_28:
return In28_Cu;
193 case ALTIUM_LAYER::MID_LAYER_29:
return In29_Cu;
194 case ALTIUM_LAYER::MID_LAYER_30:
return In30_Cu;
195 case ALTIUM_LAYER::BOTTOM_LAYER:
return B_Cu;
197 case ALTIUM_LAYER::TOP_OVERLAY:
return F_SilkS;
198 case ALTIUM_LAYER::BOTTOM_OVERLAY:
return B_SilkS;
199 case ALTIUM_LAYER::TOP_PASTE:
return F_Paste;
200 case ALTIUM_LAYER::BOTTOM_PASTE:
return B_Paste;
201 case ALTIUM_LAYER::TOP_SOLDER:
return F_Mask;
202 case ALTIUM_LAYER::BOTTOM_SOLDER:
return B_Mask;
221 case ALTIUM_LAYER::DRILL_GUIDE:
return Dwgs_User;
222 case ALTIUM_LAYER::KEEP_OUT_LAYER:
return Margin;
224 case ALTIUM_LAYER::MECHANICAL_1:
return User_1;
225 case ALTIUM_LAYER::MECHANICAL_2:
return User_2;
226 case ALTIUM_LAYER::MECHANICAL_3:
return User_3;
227 case ALTIUM_LAYER::MECHANICAL_4:
return User_4;
228 case ALTIUM_LAYER::MECHANICAL_5:
return User_5;
229 case ALTIUM_LAYER::MECHANICAL_6:
return User_6;
230 case ALTIUM_LAYER::MECHANICAL_7:
return User_7;
231 case ALTIUM_LAYER::MECHANICAL_8:
return User_8;
232 case ALTIUM_LAYER::MECHANICAL_9:
return User_9;
233 case ALTIUM_LAYER::MECHANICAL_10:
return Dwgs_User;
234 case ALTIUM_LAYER::MECHANICAL_11:
return Eco2_User;
235 case ALTIUM_LAYER::MECHANICAL_12:
return F_Fab;
236 case ALTIUM_LAYER::MECHANICAL_13:
return B_Fab;
241 case ALTIUM_LAYER::DRILL_DRAWING:
return Dwgs_User;
259 static std::set<ALTIUM_LAYER> altiumLayersWithWarning;
261 if( aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER || aAltiumLayer == ALTIUM_LAYER::KEEP_OUT_LAYER )
264 std::vector<PCB_LAYER_ID> layers;
265 layers.reserve( layerCount );
270 layers.emplace_back( layer );
281 wxString layerName = it !=
m_layerNames.end() ? it->second : wxString::Format( wxT(
"(%d)" ),
282 (
int) aAltiumLayer );
284 if(
m_reporter && altiumLayersWithWarning.insert( aAltiumLayer ).second )
287 _(
"Altium layer %s has no KiCad equivalent. It has been moved to KiCad "
301 const wxString& aLibrary,
const wxString& aFootprintName )
321 const unsigned PROGRESS_DELTA = 250;
339 const std::map<ALTIUM_PCB_DIR, std::string>& aFileMapping )
342 const std::vector<std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>> parserOrder = {
343 {
true, ALTIUM_PCB_DIR::FILE_HEADER,
348 {
true, ALTIUM_PCB_DIR::BOARD6,
353 {
false, ALTIUM_PCB_DIR::EXTENDPRIMITIVEINFORMATION,
358 {
true, ALTIUM_PCB_DIR::COMPONENTS6,
363 {
false, ALTIUM_PCB_DIR::MODELS,
366 std::vector<std::string> dir{ aFileMapping.at( ALTIUM_PCB_DIR::MODELS ) };
369 {
true, ALTIUM_PCB_DIR::COMPONENTBODIES6,
374 {
true, ALTIUM_PCB_DIR::NETS6,
379 {
true, ALTIUM_PCB_DIR::CLASSES6,
384 {
true, ALTIUM_PCB_DIR::RULES6,
389 {
true, ALTIUM_PCB_DIR::DIMENSIONS6,
394 {
true, ALTIUM_PCB_DIR::POLYGONS6,
399 {
true, ALTIUM_PCB_DIR::ARCS6,
404 {
true, ALTIUM_PCB_DIR::PADS6,
409 {
true, ALTIUM_PCB_DIR::VIAS6,
414 {
true, ALTIUM_PCB_DIR::TRACKS6,
419 {
false, ALTIUM_PCB_DIR::WIDESTRINGS6,
424 {
true, ALTIUM_PCB_DIR::TEXTS6,
429 {
true, ALTIUM_PCB_DIR::FILLS6,
434 {
false, ALTIUM_PCB_DIR::BOARDREGIONS,
439 {
true, ALTIUM_PCB_DIR::SHAPEBASEDREGIONS6,
444 {
true, ALTIUM_PCB_DIR::REGIONS6,
454 for(
const std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>& cur : parserOrder )
459 std::tie( isRequired,
directory, fp ) = cur;
461 if(
directory == ALTIUM_PCB_DIR::FILE_HEADER )
464 const auto& mappedDirectory = aFileMapping.find(
directory );
466 if( mappedDirectory == aFileMapping.end() )
469 const std::vector<std::string> mappedFile{ mappedDirectory->second,
"Header" };
470 const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.
FindStream( mappedFile );
472 if( file ==
nullptr )
476 uint32_t numOfRecords = reader.
Read<uint32_t>();
506 const auto& boardDirectory = aFileMapping.find( ALTIUM_PCB_DIR::BOARD6 );
508 if( boardDirectory != aFileMapping.end() )
510 std::vector<std::string> mappedFile{ boardDirectory->second,
"Data" };
512 const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.
FindStream( mappedFile );
517 "This file does not appear to be in a valid PCB Binary Version 6.0 format. In "
519 "make sure to save as \"PCB Binary Files (*.PcbDoc)\"." ) );
524 for(
const std::tuple<bool, ALTIUM_PCB_DIR, PARSE_FUNCTION_POINTER_fp>& cur : parserOrder )
529 std::tie( isRequired,
directory, fp ) = cur;
531 const auto& mappedDirectory = aFileMapping.find(
directory );
533 if( mappedDirectory == aFileMapping.end() )
535 wxASSERT_MSG( !isRequired, wxString::Format( wxT(
"Altium Directory of kind %d was "
536 "expected, but no mapping is "
537 "present in the code" ),
542 std::vector<std::string> mappedFile{ mappedDirectory->second };
544 if(
directory != ALTIUM_PCB_DIR::FILE_HEADER )
545 mappedFile.emplace_back(
"Data" );
547 const CFB::COMPOUND_FILE_ENTRY* file = altiumPcbFile.
FindStream( mappedFile );
549 if( file !=
nullptr )
551 fp( altiumPcbFile, file );
553 else if( isRequired )
557 m_reporter->
Report( wxString::Format(
_(
"File not found: '%s' for directory '%s'." ),
572 if( zone->GetAssignedPriority() == 1000 )
583 zone->SetAssignedPriority( priority >= 0 ? priority : 0 );
587 for( std::pair<const ALTIUM_LAYER, ZONE*>& zone :
m_outer_plane )
588 zone.second->SetAssignedPriority( 0 );
598 if( !zone->HasFilledPolysForLayer( layer ) )
620 if( shape->
GetShape() != SHAPE_T::ARC && shape->
GetShape() != SHAPE_T::CIRCLE )
639 if( arc->
GetCenter() == dim->GetPosition() )
648 VECTOR2I radialLine = dim->GetEnd() - dim->GetStart();
653 radialLine = radialLine.
Resize( std::max( radius, 2 ) );
654 dim->SetEnd( dim->GetStart() + (
VECTOR2I) radialLine );
655 dim->SetLeaderLength( totalLength - radius );
665 int desired_x = ( w - bbbox.
GetWidth() ) / 2;
666 int desired_y = ( h - bbbox.
GetHeight() ) / 2;
668 VECTOR2I movementVector( desired_x - bbbox.
GetX(), desired_y - bbbox.
GetY() );
680 const wxString& aFootprintName )
682 std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>(
m_board );
700 std::tuple<wxString, const CFB::COMPOUND_FILE_ENTRY*> ret =
703 wxString fpDirName = std::get<0>( ret );
704 const CFB::COMPOUND_FILE_ENTRY* footprintStream = std::get<1>( ret );
706 if( fpDirName.IsEmpty() )
709 wxString::Format(
_(
"Footprint directory not found: '%s'." ), aFootprintName ) );
712 const std::vector<std::string> streamName{ fpDirName.ToStdString(),
"Data" };
713 const CFB::COMPOUND_FILE_ENTRY* footprintData = altiumLibFile.
FindStream( footprintStream, {
"Data" } );
715 if( footprintData ==
nullptr )
728 footprint->SetFPID( fpID );
730 const std::vector<std::string> parametersStreamName{ fpDirName.ToStdString(),
732 const CFB::COMPOUND_FILE_ENTRY* parametersData =
733 altiumLibFile.
FindStream( footprintStream, {
"Parameters" } );
735 if( parametersData !=
nullptr )
738 std::map<wxString, wxString> parameterProperties = parametersReader.
ReadProperties();
740 wxT(
"DESCRIPTION" ), wxT(
"" ) );
741 footprint->SetLibDescription( description );
752 footprint->SetLibDescription( wxT(
"" ) );
755 const std::vector<std::string> extendedPrimitiveInformationStreamName{
756 "ExtendedPrimitiveInformation",
"Data"
758 const CFB::COMPOUND_FILE_ENTRY* extendedPrimitiveInformationData =
759 altiumLibFile.
FindStream( footprintStream, extendedPrimitiveInformationStreamName );
761 if( extendedPrimitiveInformationData !=
nullptr )
764 footprint->SetReference( wxT(
"REF**" ) );
765 footprint->SetValue( aFootprintName );
766 footprint->Reference().SetVisible(
true );
767 footprint->Value().SetVisible(
true );
772 for(
PCB_FIELD* field : footprint->Fields() )
774 field->SetTextSize( defaultTextSize );
775 field->SetTextThickness( defaultTextThickness );
784 case ALTIUM_RECORD::ARC:
790 case ALTIUM_RECORD::PAD:
796 case ALTIUM_RECORD::VIA:
802 case ALTIUM_RECORD::TRACK:
808 case ALTIUM_RECORD::TEXT:
814 case ALTIUM_RECORD::FILL:
820 case ALTIUM_RECORD::REGION:
826 case ALTIUM_RECORD::MODEL:
833 THROW_IO_ERROR( wxString::Format(
_(
"Record of unknown type: '%d'." ), recordtype ) );
839 for(
bool changes =
true; changes; )
844 [&changes](
PAD* aPad1,
PAD* aPad2 )
846 if( !( aPad1->GetNumber().IsEmpty() ^ aPad2->GetNumber().IsEmpty() ) )
849 for( PCB_LAYER_ID layer : aPad1->GetLayerSet().Seq() )
851 std::shared_ptr<SHAPE> shape1 = aPad1->GetEffectiveShape( layer );
852 std::shared_ptr<SHAPE> shape2 = aPad2->GetEffectiveShape( layer );
854 if( shape1->Collide( shape2.get() ) )
856 if( aPad1->GetNumber().IsEmpty() )
857 aPad1->SetNumber( aPad2->GetNumber() );
859 aPad2->SetNumber( aPad1->GetNumber() );
868 footprint->AutoPositionFields();
870 if( parser.HasParsingError() )
872 THROW_IO_ERROR( wxString::Format( wxT(
"%s stream was not parsed correctly" ),
876 if( parser.GetRemainingBytes() != 0 )
878 THROW_IO_ERROR( wxString::Format( wxT(
"%s stream is not fully parsed" ),
882 return footprint.release();
893 THROW_IO_ERROR( wxString::Format( wxT(
"Netcode with id %d does not exist. Only %d nets "
905 const auto rules =
m_rules.find( aKind );
910 for(
const ARULE6& rule : rules->second )
912 if( rule.
name == aName )
921 const auto rules =
m_rules.find( aKind );
926 for(
const ARULE6& rule : rules->second )
936 const CFB::COMPOUND_FILE_ENTRY* aEntry )
954 const CFB::COMPOUND_FILE_ENTRY* aEntry )
971 THROW_IO_ERROR( wxT(
"ExtendedPrimitiveInformation stream is not fully parsed" ) );
976 const CFB::COMPOUND_FILE_ENTRY* aEntry )
993 size_t layercount = 0;
994 size_t layerid =
static_cast<size_t>( ALTIUM_LAYER::TOP_LAYER );
996 while( layerid < elem.
stackup.size() && layerid != 0 )
998 layerid = elem.
stackup[ layerid - 1 ].nextId;
1002 size_t kicadLayercount = ( layercount % 2 == 0 ) ? layercount : layercount + 1;
1012 auto it = stackup.
GetList().begin();
1020 for(
size_t altiumLayerId =
static_cast<size_t>( ALTIUM_LAYER::TOP_LAYER );
1021 altiumLayerId < elem.
stackup.size() && altiumLayerId != 0;
1022 altiumLayerId = elem.
stackup[altiumLayerId - 1].nextId )
1028 if( layer.
nextId == 0 && layercount != kicadLayercount )
1033 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1035 ( *it )->SetThickness( 0 );
1040 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1042 ( *it )->SetThickness( 0, 0 );
1043 ( *it )->SetThicknessLocked(
true, 0 );
1051 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1065 if( klayer ==
B_Cu )
1068 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected id while parsing last stackup layer" ) );
1078 THROW_IO_ERROR( wxT(
"Board6 stream, unexpected item while parsing stackup" ) );
1092 for(
size_t altiumLayerId =
static_cast<size_t>( ALTIUM_LAYER::TOP_OVERLAY );
1093 altiumLayerId <= static_cast<size_t>( ALTIUM_LAYER::BOTTOM_SOLDER ); altiumLayerId++ )
1104 for(
size_t altiumLayerId =
static_cast<size_t>( ALTIUM_LAYER::MECHANICAL_1 );
1105 altiumLayerId <= static_cast<size_t>( ALTIUM_LAYER::MECHANICAL_16 ); altiumLayerId++ )
1126 if( aStackup.size() == 0 )
1129 std::vector<INPUT_LAYER_DESC> inputLayers;
1130 std::map<wxString, ALTIUM_LAYER> altiumLayerNameMap;
1137 [&](
size_t ii ) ->
size_t
1142 if( layer_num < ALTIUM_LAYER::BOTTOM_LAYER )
1143 return curLayer.
nextId - 1;
1148 for(
size_t ii = 0; ii < aStackup.size(); ii =
next( ii ) )
1150 curLayer = aStackup[ii];
1154 && !( layer_num >= ALTIUM_LAYER::TOP_OVERLAY
1155 && layer_num <= ALTIUM_LAYER::BOTTOM_SOLDER )
1156 && !( layer_num >= ALTIUM_LAYER::MECHANICAL_1
1157 && layer_num <= ALTIUM_LAYER::MECHANICAL_16 ) )
1159 if( layer_num < ALTIUM_LAYER::BOTTOM_LAYER )
1173 inputLayers.push_back( iLdesc );
1174 altiumLayerNameMap.insert( { curLayer.
name, layer_num } );
1178 if( inputLayers.size() == 0 )
1185 for( std::pair<wxString, PCB_LAYER_ID> layerPair : reMappedLayers )
1187 if( layerPair.second == PCB_LAYER_ID::UNDEFINED_LAYER )
1189 wxFAIL_MSG( wxT(
"Unexpected Layer ID" ) );
1193 ALTIUM_LAYER altiumID = altiumLayerNameMap.at( layerPair.first );
1194 m_layermap.insert_or_assign( altiumID, layerPair.second );
1195 enabledLayers |=
LSET( { layerPair.second } );
1209 LINE_STYLE::SOLID );
1216 int nextShape = lineChain.
NextShape( i );
1217 bool isLastShape = nextShape < 0;
1219 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::ARC );
1221 shape->SetStroke( stroke );
1225 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1231 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1233 shape->SetStroke( stroke );
1235 shape->SetStart( seg.
A );
1236 shape->SetEnd( seg.
B );
1238 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1245 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1257 if( elem.
kind == ALTIUM_CLASS_KIND::NET_CLASS )
1259 std::shared_ptr<NETCLASS> nc = std::make_shared<NETCLASS>( elem.
name );
1261 for(
const wxString&
name : elem.
names )
1264 name, nc->GetName() );
1274 msg.Printf(
_(
"More than one Altium netclass with name '%s' found. "
1275 "Only the first one will be imported." ), elem.
name );
1294 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1301 uint16_t componentId = 0;
1308 std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>(
m_board );
1312 footprint->SetFPID( fpID );
1314 footprint->SetPosition( elem.
position );
1315 footprint->SetOrientationDegrees( elem.
rotation );
1321 if( reference.find_first_not_of(
"0123456789" ) == wxString::npos )
1322 reference.Prepend( wxT(
"UNK" ) );
1324 footprint->SetReference( reference );
1326 footprint->SetLocked( elem.
locked );
1327 footprint->Reference().SetVisible( elem.
nameon );
1328 footprint->Value().SetVisible( elem.
commenton );
1329 footprint->SetLayer( elem.
layer == ALTIUM_LAYER::TOP_LAYER ?
F_Cu :
B_Cu );
1332 m_board->
Add( footprint.release(), ADD_MODE::APPEND );
1338 THROW_IO_ERROR( wxT(
"Components6 stream is not fully parsed" ) );
1345 while( Angle < aMin )
1348 while( Angle >= aMax )
1371 m_reporter->
Report( wxString::Format( wxT(
"Model %s not found for footprint %s" ),
1384 if( file->
name.IsEmpty() )
1385 file->
name = model->first.name;
1388 std::vector<char> decompressedData;
1389 wxMemoryInputStream compressedStream( model->second.data(), model->second.size() );
1390 wxZlibInputStream zlibStream( compressedStream );
1394 decompressedData.resize( model->second.size() * 6 );
1397 while( !zlibStream.Eof() )
1399 zlibStream.Read( decompressedData.data() + offset, decompressedData.size() - offset );
1400 size_t bytesRead = zlibStream.LastRead();
1405 offset += bytesRead;
1407 if( offset >= decompressedData.size() )
1408 decompressedData.resize( 2 * decompressedData.size() );
1411 decompressedData.resize( offset );
1432 orientation = -orientation;
1444 aFootprint->
Models().push_back( modelSettings );
1449 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1466 THROW_IO_ERROR( wxString::Format( wxT(
"ComponentsBodies6 stream tries to access "
1467 "component id %d of %zu existing components" ),
1482 msg.Printf( wxT(
"ComponentsBodies6 stream tries to access model id %s which does "
1483 "not exist" ), elem.
modelId );
1496 wxMemoryInputStream compressedStream( modelData.
m_data.data(), modelData.
m_data.size() );
1497 wxZlibInputStream zlibStream( compressedStream );
1498 wxMemoryOutputStream decompressedStream;
1500 zlibStream.Read( decompressedStream );
1523 orientation = -orientation;
1536 footprint->
Models().push_back( modelSettings );
1540 THROW_IO_ERROR( wxT(
"ComponentsBodies6 stream is not fully parsed" ) );
1547 THROW_IO_ERROR( wxT(
"Incorrect number of reference points for linear dimension object" ) );
1556 _(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1557 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer ),
1570 dimension->SetLayer( klayer );
1571 dimension->SetStart( referencePoint0 );
1573 if( referencePoint0 != aElem.
xy1 )
1586 SEG segm1( referencePoint0, referencePoint0 + directionNormalVector );
1587 SEG segm2( referencePoint1, referencePoint1 + direction );
1591 THROW_IO_ERROR( wxT(
"Invalid dimension. This should never happen." ) );
1593 dimension->SetEnd( *intersection );
1597 if( ( direction.
x > 0 || direction.
y < 0 ) != ( aElem.
angle >= 180.0 ) )
1600 dimension->SetHeight( height );
1604 dimension->SetEnd( referencePoint1 );
1607 dimension->SetLineThickness( aElem.
linewidth );
1609 dimension->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
1613 wxRegEx units( wxS(
"(mm)|(in)|(mils)|(thou)|(')|(\")" ), wxRE_ADVANCED );
1616 dimension->SetUnitsFormat( DIM_UNITS_FORMAT::BARE_SUFFIX );
1625 dimension->Text().SetBold( aElem.
textbold );
1628 dimension->SetTextThickness( dimension->GetTextThickness() *
BOLD_FACTOR );
1633 case ALTIUM_UNIT::INCHES:
1634 dimension->SetUnits( EDA_UNITS::INCHES );
1636 case ALTIUM_UNIT::MILS:
1637 dimension->SetUnits( EDA_UNITS::MILS );
1639 case ALTIUM_UNIT::MILLIMETERS:
1640 case ALTIUM_UNIT::CENTIMETER:
1641 dimension->SetUnits( EDA_UNITS::MILLIMETRES );
1647 m_board->
Add( dimension.release(), ADD_MODE::APPEND );
1654 THROW_IO_ERROR( wxT(
"Not enough reference points for radial dimension object" ) );
1663 _(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1664 "It has been moved to KiCad layer Eco1_User." ),
1674 std::unique_ptr<PCB_DIM_RADIAL> dimension = std::make_unique<PCB_DIM_RADIAL>(
m_board );
1677 dimension->SetLayer( klayer );
1678 dimension->SetStart( referencePoint0 );
1679 dimension->SetEnd( aElem.
xy1 );
1680 dimension->SetLineThickness( aElem.
linewidth );
1681 dimension->SetKeepTextAligned(
false );
1686 dimension->SetUnitsFormat( aElem.
textsuffix.IsEmpty() ? DIM_UNITS_FORMAT::NO_SUFFIX
1687 : DIM_UNITS_FORMAT::BARE_SUFFIX );
1691 case ALTIUM_UNIT::INCHES:
1692 dimension->SetUnits( EDA_UNITS::INCHES );
1694 case ALTIUM_UNIT::MILS:
1695 dimension->SetUnits( EDA_UNITS::MILS );
1697 case ALTIUM_UNIT::MILLIMETERS:
1698 case ALTIUM_UNIT::CENTIMETER:
1699 dimension->SetUnits( EDA_UNITS::MILLIMETRES );
1709 m_reporter->
Report( wxT(
"No text position present for leader dimension object" ),
1716 dimension->SetTextPos( aElem.
textPoint.at( 0 ) );
1722 dimension->SetBold( aElem.
textbold );
1725 dimension->SetTextThickness( dimension->GetTextThickness() *
BOLD_FACTOR );
1733 int yAdjust = dimension->GetTextBox().GetCenter().y - dimension->GetTextPos().y;
1734 dimension->SetTextPos( dimension->GetTextPos() +
VECTOR2I( 0, yAdjust + aElem.
textgap ) );
1738 m_board->
Add( dimension.release(), ADD_MODE::APPEND );
1751 msg.Printf(
_(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1752 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
1767 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1769 shape->SetLayer( klayer );
1771 shape->SetStart( last );
1775 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1783 if( dirVec.
x != 0 || dirVec.
y != 0 )
1791 std::unique_ptr<PCB_SHAPE> shape1 =
1792 std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1794 shape1->SetLayer( klayer );
1796 shape1->SetStart( referencePoint0 );
1797 shape1->SetEnd( referencePoint0 + arrVec );
1799 m_board->
Add( shape1.release(), ADD_MODE::APPEND );
1805 std::unique_ptr<PCB_SHAPE> shape2 =
1806 std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1808 shape2->SetLayer( klayer );
1810 shape2->SetStart( referencePoint0 );
1811 shape2->SetEnd( referencePoint0 + arrVec );
1813 m_board->
Add( shape2.release(), ADD_MODE::APPEND );
1823 m_reporter->
Report( wxT(
"No text position present for leader dimension object" ),
1830 std::unique_ptr<PCB_TEXT>
text = std::make_unique<PCB_TEXT>(
m_board );
1834 text->SetLayer( klayer );
1853 msg.Printf(
_(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1854 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
1863 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
1865 shape->SetLayer( klayer );
1870 m_board->
Add( shape.release(), ADD_MODE::APPEND );
1884 msg.Printf(
_(
"Dimension found on an Altium layer (%d) with no KiCad equivalent. "
1885 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
1895 std::unique_ptr<PCB_DIM_CENTER> dimension = std::make_unique<PCB_DIM_CENTER>(
m_board );
1897 dimension->SetLayer( klayer );
1898 dimension->SetLineThickness( aElem.
linewidth );
1899 dimension->SetStart( aElem.
xy1 );
1900 dimension->SetEnd( aElem.
xy1 + vec );
1902 m_board->
Add( dimension.release(), ADD_MODE::APPEND );
1907 const CFB::COMPOUND_FILE_ENTRY* aEntry )
1921 case ALTIUM_DIMENSION_KIND::LINEAR:
1924 case ALTIUM_DIMENSION_KIND::ANGULAR:
1928 wxString::Format(
_(
"Ignored Angular dimension (not yet supported)." ) ),
1932 case ALTIUM_DIMENSION_KIND::RADIAL:
1935 case ALTIUM_DIMENSION_KIND::LEADER:
1938 case ALTIUM_DIMENSION_KIND::DATUM:
1942 wxString::Format(
_(
"Ignored Datum dimension (not yet supported)." ) ),
1947 case ALTIUM_DIMENSION_KIND::BASELINE:
1951 wxString::Format(
_(
"Ignored Baseline dimension (not yet supported)." ) ),
1955 case ALTIUM_DIMENSION_KIND::CENTER:
1958 case ALTIUM_DIMENSION_KIND::LINEAR_DIAMETER:
1962 wxString::Format(
_(
"Ignored Linear dimension (not yet supported)." ) ),
1966 case ALTIUM_DIMENSION_KIND::RADIAL_DIAMETER:
1970 wxString::Format(
_(
"Ignored Radial dimension (not yet supported)." ) ),
1978 msg.Printf(
_(
"Ignored dimension of kind %d (not yet supported)." ), elem.
kind );
1986 THROW_IO_ERROR( wxT(
"Dimensions6 stream is not fully parsed" ) );
1991 const CFB::COMPOUND_FILE_ENTRY* aEntry,
1992 const std::vector<std::string>& aRootDir )
2003 wxString invalidChars = wxFileName::GetForbiddenChars();
2010 std::vector<std::string> stepPath = aRootDir;
2011 stepPath.emplace_back( std::to_string( idx ) );
2013 bool validName = !elem.
name.IsEmpty() && elem.
name.IsAscii() &&
2014 wxString::npos == elem.
name.find_first_of( invalidChars );
2015 wxString storageName = !validName ? wxString::Format( wxT(
"model_%d" ), idx )
2020 const CFB::COMPOUND_FILE_ENTRY* stepEntry = aAltiumPcbFile.
FindStream( stepPath );
2022 if( stepEntry ==
nullptr )
2027 msg.Printf(
_(
"File not found: '%s'. 3D-model not imported." ),
2035 size_t stepSize =
static_cast<size_t>( stepEntry->size );
2036 std::vector<char> stepContent( stepSize );
2044 std::move( stepContent ) ) ) );
2053 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2065 ANET6 elem( reader );
2079 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2112 if( elem.
hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::SOLID )
2122 msg.Printf(
_(
"Polygon outline count is %d, expected 1." ), outline.
OutlineCount() );
2130 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(
m_board);
2134 zone->SetPosition( elem.
vertices.at( 0 ).position );
2135 zone->SetLocked( elem.
locked );
2137 zone->Outline()->AddOutline( outline.
Outline( 0 ) );
2145 const ARULE6* zoneClearanceRule =
GetRule( ALTIUM_RULE_KIND::CLEARANCE,
2146 wxT(
"PolygonClearance" ) );
2147 int planeLayers = 0;
2148 int signalLayers = 0;
2162 if( planeLayers > 0 && planeClearanceRule )
2165 if( signalLayers > 0 && zoneClearanceRule )
2166 clearance = std::max( clearance, zoneClearanceRule->
clearanceGap );
2169 zone->SetLocalClearance( clearance );
2173 if( polygonConnectRule !=
nullptr )
2177 case ALTIUM_CONNECT_STYLE::DIRECT:
2178 zone->SetPadConnection( ZONE_CONNECTION::FULL );
2181 case ALTIUM_CONNECT_STYLE::NONE:
2182 zone->SetPadConnection( ZONE_CONNECTION::NONE );
2186 case ALTIUM_CONNECT_STYLE::RELIEF:
2187 zone->SetPadConnection( ZONE_CONNECTION::THERMAL );
2192 zone->SetThermalReliefSpokeWidth(
2203 zone->SetAssignedPriority( 1 );
2208 || zone->GetBoundingBox().Contains( outer_plane->second->GetBoundingBox() ) )
2214 if( elem.
hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::SOLID
2215 && elem.
hatchstyle != ALTIUM_POLYGON_HATCHSTYLE::UNKNOWN )
2217 zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
2220 if( elem.
hatchstyle == ALTIUM_POLYGON_HATCHSTYLE::NONE )
2223 const BOX2I& bbox = zone->GetBoundingBox();
2231 if( elem.
hatchstyle == ALTIUM_POLYGON_HATCHSTYLE::DEGREE_45 )
2232 zone->SetHatchOrientation(
ANGLE_45 );
2235 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
2238 m_board->
Add( zone.release(), ADD_MODE::APPEND );
2246 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2264 std::sort( val.second.begin(), val.second.end(),
2267 return lhs.priority < rhs.priority;
2280 if( trackWidthRule )
2286 if( routingViasRule )
2297 if( holeToHoleRule )
2303 if( soldermaskRule )
2314 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2330 THROW_IO_ERROR( wxT(
"BoardRegions stream is not fully parsed" ) );
2334 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2342 for(
int primitiveIndex = 0; reader.
GetRemainingBytes() >= 4; primitiveIndex++ )
2348 || elem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2361 THROW_IO_ERROR(
"ShapeBasedRegions6 stream is not fully parsed" );
2367 if( aElem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2371 else if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT || aElem.
is_keepout )
2385 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(
m_board );
2387 zone->SetIsRuleArea(
true );
2393 else if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT )
2395 zone->SetDoNotAllowCopperPour(
true );
2396 zone->SetDoNotAllowVias(
false );
2397 zone->SetDoNotAllowTracks(
false );
2398 zone->SetDoNotAllowPads(
false );
2399 zone->SetDoNotAllowFootprints(
false );
2402 zone->SetPosition( aElem.
outline.at( 0 ).position );
2403 zone->Outline()->AddOutline( linechain );
2407 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
2410 m_board->
Add( zone.release(), ADD_MODE::APPEND );
2412 else if( aElem.
kind == ALTIUM_REGION_KIND::DASHED_OUTLINE )
2421 msg.Printf(
_(
"Dashed outline found on an Altium layer (%d) with no KiCad equivalent. "
2422 "It has been moved to KiCad layer Eco1_User." ), aElem.
layer );
2441 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::POLY );
2443 shape->SetPolyShape( linechain );
2444 shape->SetFilled(
false );
2445 shape->SetLayer( klayer );
2448 m_board->
Add( shape.release(), ADD_MODE::APPEND );
2450 else if( aElem.
kind == ALTIUM_REGION_KIND::COPPER )
2458 else if( aElem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2467 msg.Printf(
_(
"Ignored polygon shape of kind %d (not yet supported)." ), aElem.
kind );
2476 const int aPrimitiveIndex )
2478 if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT || aElem.
is_keepout )
2492 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( aFootprint );
2494 zone->SetIsRuleArea(
true );
2500 else if( aElem.
kind == ALTIUM_REGION_KIND::POLYGON_CUTOUT )
2502 zone->SetDoNotAllowCopperPour(
true );
2503 zone->SetDoNotAllowVias(
false );
2504 zone->SetDoNotAllowTracks(
false );
2505 zone->SetDoNotAllowPads(
false );
2506 zone->SetDoNotAllowFootprints(
false );
2509 zone->SetPosition( aElem.
outline.at( 0 ).position );
2510 zone->Outline()->AddOutline( linechain );
2514 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
2517 aFootprint->
Add( zone.release(), ADD_MODE::APPEND );
2519 else if( aElem.
kind == ALTIUM_REGION_KIND::COPPER )
2530 else if( aElem.
kind == ALTIUM_REGION_KIND::DASHED_OUTLINE
2531 || aElem.
kind == ALTIUM_REGION_KIND::BOARD_CUTOUT )
2544 msg.Printf(
_(
"Loading library '%s':\n"
2545 "Footprint %s contains a dashed outline on Altium layer (%d) with "
2546 "no KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
2558 msg.Printf(
_(
"Footprint %s contains a dashed outline on Altium layer (%d) with "
2559 "no KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
2581 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::POLY );
2583 shape->SetPolyShape( linechain );
2584 shape->SetFilled(
false );
2585 shape->SetLayer( klayer );
2587 if( aElem.
kind == ALTIUM_REGION_KIND::DASHED_OUTLINE )
2592 aFootprint->
Add( shape.release(), ADD_MODE::APPEND );
2601 msg.Printf(
_(
"Error loading library '%s':\n"
2602 "Footprint %s contains polygon shape of kind %d (not yet supported)." ),
2614 msg.Printf(
_(
"Footprint %s contains polygon shape of kind %d (not yet supported)." ),
2642 for(
const std::vector<ALTIUM_VERTICE>& hole : aElem.
holes )
2650 polySet.
AddHole( hole_linechain );
2653 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::POLY );
2655 shape->SetPolyShape( polySet );
2656 shape->SetFilled(
true );
2657 shape->SetLayer( aLayer );
2665 m_board->
Add( shape.release(), ADD_MODE::APPEND );
2672 const int aPrimitiveIndex )
2689 for(
const std::vector<ALTIUM_VERTICE>& hole : aElem.
holes )
2697 polySet.
AddHole( hole_linechain );
2700 if( aLayer ==
F_Cu || aLayer ==
B_Cu )
2703 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
2706 padLayers.
set( aLayer );
2708 pad->SetAttribute( PAD_ATTRIB::SMD );
2717 pad->SetPosition( anchorPos );
2720 shapePolys.
Move( -anchorPos );
2724 auto it = map.find( aPrimitiveIndex );
2726 if( it != map.end() )
2730 if(
info.pastemaskexpansionmode == ALTIUM_MODE::MANUAL )
2732 pad->SetLocalSolderPasteMargin(
2733 info.pastemaskexpansionmanual ?
info.pastemaskexpansionmanual : 1 );
2736 if(
info.soldermaskexpansionmode == ALTIUM_MODE::MANUAL )
2738 pad->SetLocalSolderMaskMargin(
2739 info.soldermaskexpansionmanual ?
info.soldermaskexpansionmanual : 1 );
2742 if(
info.pastemaskexpansionmode != ALTIUM_MODE::NONE )
2745 if(
info.soldermaskexpansionmode != ALTIUM_MODE::NONE )
2749 pad->SetLayerSet( padLayers );
2751 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
2755 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::POLY );
2757 shape->SetPolyShape( polySet );
2758 shape->SetFilled(
true );
2759 shape->SetLayer( aLayer );
2762 aFootprint->
Add( shape.release(), ADD_MODE::APPEND );
2768 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2784 THROW_IO_ERROR( wxString::Format(
"Region stream tries to access polygon id %d "
2785 "of %d existing polygons.",
2792 if( zone ==
nullptr )
2814 for(
const std::vector<ALTIUM_VERTICE>& hole : elem.
holes )
2821 hole_linechain.
Append( hole.at( 0 ).position );
2823 fill.
AddHole( hole_linechain );
2843 const CFB::COMPOUND_FILE_ENTRY* aEntry )
2850 for(
int primitiveIndex = 0; reader.
GetRemainingBytes() >= 4; primitiveIndex++ )
2853 AARC6 elem( reader );
2875 aShape->
SetShape( SHAPE_T::CIRCLE );
2904 THROW_IO_ERROR( wxString::Format(
"Tracks stream tries to access polygon id %u "
2905 "of %zu existing polygons.",
2911 if( zone ==
nullptr )
2959 for(
const auto& layerExpansionMask :
2962 int width = aElem.
width + ( layerExpansionMask.second * 2 );
2966 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>(
m_board );
2969 arc->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
2970 arc->SetLayer( layerExpansionMask.first );
2972 m_board->
Add( arc.release(), ADD_MODE::APPEND );
2979 const int aPrimitiveIndex,
const bool aIsBoardImport )
2983 wxFAIL_MSG( wxString::Format(
"Altium: Unexpected footprint Arc with polygon id %d",
3016 for(
const auto& layerExpansionMask :
3019 int width = aElem.
width + ( layerExpansionMask.second * 2 );
3023 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( aFootprint );
3026 arc->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
3027 arc->SetLayer( layerExpansionMask.first );
3029 aFootprint->
Add( arc.release(), ADD_MODE::APPEND );
3050 PCB_SHAPE shape(
nullptr, SHAPE_T::ARC );
3059 std::unique_ptr<PCB_ARC> arc = std::make_unique<PCB_ARC>(
m_board, &shapeArc );
3061 arc->SetWidth( aElem.
width );
3062 arc->SetLayer( aLayer );
3065 m_board->
Add( arc.release(), ADD_MODE::APPEND );
3070 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>(
m_board);
3074 arc->SetLayer( aLayer );
3076 m_board->
Add( arc.release(), ADD_MODE::APPEND );
3084 std::unique_ptr<PCB_SHAPE> arc = std::make_unique<PCB_SHAPE>( aFootprint );
3088 arc->SetLayer( aLayer );
3090 aFootprint->
Add( arc.release(), ADD_MODE::APPEND );
3095 const CFB::COMPOUND_FILE_ENTRY* aEntry )
3105 APAD6 elem( reader );
3127 && aElem.
layer != ALTIUM_LAYER::MULTI_LAYER )
3134 std::unique_ptr<FOOTPRINT> footprint = std::make_unique<FOOTPRINT>(
m_board );
3135 footprint->SetPosition( aElem.
position );
3139 m_board->
Add( footprint.release(), ADD_MODE::APPEND );
3146 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
3148 pad->SetNumber(
"" );
3154 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3156 pad->SetAttribute( PAD_ATTRIB::PTH );
3159 pad->SetLayerSet(
LSET().AllCuMask() );
3161 if( aElem.
viamode == ALTIUM_PAD_MODE::SIMPLE )
3165 else if( aElem.
viamode == ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM )
3186 pad->Padstack().FrontOuterLayers().has_solder_mask =
true;
3190 pad->Padstack().FrontOuterLayers().has_solder_mask =
false;
3196 pad->Padstack().BackOuterLayers().has_solder_mask =
true;
3200 pad->Padstack().BackOuterLayers().has_solder_mask =
false;
3205 pad->SetLocked(
true );
3214 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
3222 && aElem.
layer != ALTIUM_LAYER::MULTI_LAYER )
3235 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
3246 pad->SetAttribute( PAD_ATTRIB::SMD );
3250 if( aElem.
layer != ALTIUM_LAYER::MULTI_LAYER )
3258 msg.Printf(
_(
"Error loading library '%s':\n"
3259 "Footprint %s pad %s is not marked as multilayer, but is a TH pad." ),
3271 msg.Printf(
_(
"Footprint %s pad %s is not marked as multilayer, but is a TH pad." ),
3279 pad->SetAttribute( aElem.
plated ? PAD_ATTRIB::PTH : PAD_ATTRIB::NPTH );
3283 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3290 case ALTIUM_PAD_HOLE_SHAPE::ROUND:
3291 wxFAIL_MSG( wxT(
"Round holes are handled before the switch" ) );
3294 case ALTIUM_PAD_HOLE_SHAPE::SQUARE:
3300 msg.Printf(
_(
"Loading library '%s':\n"
3301 "Footprint %s pad %s has a square hole (not yet supported)." ),
3313 msg.Printf(
_(
"Footprint %s pad %s has a square hole (not yet supported)." ),
3320 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3326 case ALTIUM_PAD_HOLE_SHAPE::SLOT:
3328 pad->SetDrillShape( PAD_DRILL_SHAPE::OBLONG );
3348 msg.Printf(
_(
"Loading library '%s':\n"
3349 "Footprint %s pad %s has a hole-rotation of %f degrees. "
3350 "KiCad only supports 90 degree rotations." ),
3363 msg.Printf(
_(
"Footprint %s pad %s has a hole-rotation of %f degrees. "
3364 "KiCad only supports 90 degree rotations." ),
3377 case ALTIUM_PAD_HOLE_SHAPE::UNKNOWN:
3383 msg.Printf(
_(
"Error loading library '%s':\n"
3384 "Footprint %s pad %s uses a hole of unknown kind %d." ),
3397 msg.Printf(
_(
"Footprint %s pad %s uses a hole of unknown kind %d." ),
3405 pad->SetDrillShape( PAD_DRILL_SHAPE::CIRCLE );
3417 auto setCopperGeometry =
3426 case ALTIUM_PAD_SHAPE::RECT:
3427 ps.
SetShape( PAD_SHAPE::RECTANGLE, aLayer );
3430 case ALTIUM_PAD_SHAPE::CIRCLE:
3432 && aElem.
sizeAndShape->alt_shape[altLayer] == ALTIUM_PAD_SHAPE_ALT::ROUNDRECT )
3434 ps.
SetShape( PAD_SHAPE::ROUNDRECT, aLayer );
3435 double ratio = aElem.
sizeAndShape->cornerradius[altLayer] / 200.;
3440 ps.
SetShape( PAD_SHAPE::CIRCLE, aLayer );
3444 ps.
SetShape( PAD_SHAPE::OVAL, aLayer );
3449 case ALTIUM_PAD_SHAPE::OCTAGONAL:
3450 ps.
SetShape( PAD_SHAPE::CHAMFERED_RECT, aLayer );
3455 case ALTIUM_PAD_SHAPE::UNKNOWN:
3462 msg.Printf(
_(
"Error loading library '%s':\n"
3463 "Footprint %s pad %s uses an unknown pad-shape." ),
3475 msg.Printf(
_(
"Footprint %s pad %s uses an unknown pad-shape." ),
3487 case ALTIUM_PAD_MODE::SIMPLE:
3492 case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
3499 case ALTIUM_PAD_MODE::FULL_STACK:
3512 setCopperGeometry( layer, aElem.
sizeAndShape->inner_shape[i],
3522 if(
pad->GetAttribute() == PAD_ATTRIB::NPTH &&
pad->HasHole() )
3526 : PAD_SHAPE::OVAL );
3530 switch( aElem.
layer )
3532 case ALTIUM_LAYER::TOP_LAYER:
3537 case ALTIUM_LAYER::BOTTOM_LAYER:
3542 case ALTIUM_LAYER::MULTI_LAYER:
3548 pad->SetLayer( klayer );
3549 pad->SetLayerSet(
LSET( { klayer } ) );
3560 pad->SetLayerSet(
pad->GetLayerSet().reset(
F_Mask ) );
3563 pad->SetLayerSet(
pad->GetLayerSet().reset(
B_Mask ) );
3565 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
3578 msg.Printf(
_(
"Non-copper pad %s found on an Altium layer (%d) with no KiCad "
3579 "equivalent. It has been moved to KiCad layer Eco1_User." ),
3587 std::unique_ptr<PCB_SHAPE>
pad = std::make_unique<PCB_SHAPE>(
m_board );
3606 msg.Printf(
_(
"Loading library '%s':\n"
3607 "Footprint %s non-copper pad %s found on an Altium layer (%d) with no "
3608 "KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
3621 msg.Printf(
_(
"Footprint %s non-copper pad %s found on an Altium layer (%d) with no "
3622 "KiCad equivalent. It has been moved to KiCad layer Eco1_User." ),
3633 std::unique_ptr<PCB_SHAPE>
pad = std::make_unique<PCB_SHAPE>( aFootprint );
3637 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
3649 msg.Printf(
_(
"Non-copper pad %s is connected to a net, which is not supported." ),
3660 msg.Printf(
_(
"Non-copper pad %s has a hole, which is not supported." ), aElem.
name );
3665 if( aElem.
padmode != ALTIUM_PAD_MODE::SIMPLE )
3670 msg.Printf(
_(
"Non-copper pad %s has a complex pad stack (not yet supported)." ),
3678 case ALTIUM_PAD_SHAPE::RECT:
3697 case ALTIUM_PAD_SHAPE::CIRCLE:
3699 && aElem.
sizeAndShape->alt_shape[0] == ALTIUM_PAD_SHAPE_ALT::ROUNDRECT )
3702 int cornerradius = aElem.
sizeAndShape->cornerradius[0];
3703 int offset = ( std::min( aElem.
topsize.
x, aElem.
topsize.
y ) * cornerradius ) / 200;
3708 if( cornerradius < 100 )
3710 int offsetX = aElem.
topsize.
x / 2 - offset;
3711 int offsetY = aElem.
topsize.
y / 2 - offset;
3725 aShape->
SetShape( SHAPE_T::CIRCLE );
3734 aShape->
SetShape( SHAPE_T::SEGMENT );
3742 aShape->
SetShape( SHAPE_T::SEGMENT );
3754 aShape->
SetShape( SHAPE_T::CIRCLE );
3764 aShape->
SetShape( SHAPE_T::SEGMENT );
3767 LINE_STYLE::SOLID ) );
3787 case ALTIUM_PAD_SHAPE::OCTAGONAL:
3804 aShape->
SetPolyPoints( { p11 - chamferX, p11 - chamferY, p12 + chamferY, p12 - chamferX,
3805 p22 + chamferX, p22 + chamferY, p21 - chamferY, p21 + chamferX } );
3812 case ALTIUM_PAD_SHAPE::UNKNOWN:
3817 msg.Printf(
_(
"Non-copper pad %s uses an unknown pad-shape." ), aElem.
name );
3827 const CFB::COMPOUND_FILE_ENTRY* aEntry )
3837 AVIA6 elem( reader );
3839 std::unique_ptr<PCB_VIA>
via = std::make_unique<PCB_VIA>(
m_board );
3846 bool start_layer_outside = elem.
layer_start == ALTIUM_LAYER::TOP_LAYER
3847 || elem.
layer_start == ALTIUM_LAYER::BOTTOM_LAYER;
3848 bool end_layer_outside = elem.
layer_end == ALTIUM_LAYER::TOP_LAYER
3849 || elem.
layer_end == ALTIUM_LAYER::BOTTOM_LAYER;
3851 if( start_layer_outside && end_layer_outside )
3853 via->SetViaType( VIATYPE::THROUGH );
3855 else if( ( !start_layer_outside ) || ( !end_layer_outside ) )
3857 via->SetViaType( VIATYPE::BLIND_BURIED );
3863 via->SetViaType( VIATYPE::MICROVIA );
3874 msg.Printf(
_(
"Via from layer %d to %d uses a non-copper layer, which is not "
3885 via->SetLayerPair( start_klayer, end_klayer );
3890 case ALTIUM_PAD_MODE::SIMPLE:
3894 case ALTIUM_PAD_MODE::TOP_MIDDLE_BOTTOM:
3901 case ALTIUM_PAD_MODE::FULL_STACK:
3908 wxCHECK2_MSG( altiumLayer < 32,
break,
3909 "Altium importer expects 32 or fewer copper layers" );
3920 via->SetFrontTentingMode( elem.
is_tent_top ? TENTING_MODE::TENTED
3921 : TENTING_MODE::NOT_TENTED );
3923 : TENTING_MODE::NOT_TENTED );
3934 const CFB::COMPOUND_FILE_ENTRY* aEntry )
3941 for(
int primitiveIndex = 0; reader.
GetRemainingBytes() >= 4; primitiveIndex++ )
3972 msg.Printf( wxT(
"ATRACK6 stream tries to access polygon id %u "
3973 "of %u existing polygons; skipping it" ),
3974 static_cast<unsigned>( aElem.
polygon ),
3975 static_cast<unsigned>(
m_polygons.size() ) );
3984 if( zone ==
nullptr )
4000 PCB_SHAPE shape(
nullptr, SHAPE_T::SEGMENT );
4018 PCB_SHAPE shape(
nullptr, SHAPE_T::SEGMENT );
4032 ALTIUM_RECORD::TRACK, aPrimitiveIndex, aElem.
layer ) )
4034 int width = aElem.
width + ( layerExpansionMask.second * 2 );
4037 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
4039 seg->SetStart( aElem.
start );
4040 seg->SetEnd( aElem.
end );
4041 seg->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
4042 seg->SetLayer( layerExpansionMask.first );
4044 m_board->
Add( seg.release(), ADD_MODE::APPEND );
4051 const int aPrimitiveIndex,
4052 const bool aIsBoardImport )
4056 wxFAIL_MSG( wxString::Format(
"Altium: Unexpected footprint Track with polygon id %u",
4065 PCB_SHAPE shape(
nullptr, SHAPE_T::SEGMENT );
4090 ALTIUM_RECORD::TRACK, aPrimitiveIndex, aElem.
layer ) )
4092 int width = aElem.
width + ( layerExpansionMask.second * 2 );
4095 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::SEGMENT );
4097 seg->SetStart( aElem.
start );
4098 seg->SetEnd( aElem.
end );
4099 seg->SetStroke(
STROKE_PARAMS( width, LINE_STYLE::SOLID ) );
4100 seg->SetLayer( layerExpansionMask.first );
4102 aFootprint->
Add( seg.release(), ADD_MODE::APPEND );
4112 std::unique_ptr<PCB_TRACK> track = std::make_unique<PCB_TRACK>(
m_board );
4114 track->SetStart( aElem.
start );
4115 track->SetEnd( aElem.
end );
4116 track->SetWidth( aElem.
width );
4117 track->SetLayer( aLayer );
4120 m_board->
Add( track.release(), ADD_MODE::APPEND );
4124 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::SEGMENT );
4126 seg->SetStart( aElem.
start );
4127 seg->SetEnd( aElem.
end );
4129 seg->SetLayer( aLayer );
4131 m_board->
Add( seg.release(), ADD_MODE::APPEND );
4139 std::unique_ptr<PCB_SHAPE> seg = std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::SEGMENT );
4141 seg->SetStart( aElem.
start );
4142 seg->SetEnd( aElem.
end );
4144 seg->SetLayer( aLayer );
4146 aFootprint->
Add( seg.release(), ADD_MODE::APPEND );
4151 const CFB::COMPOUND_FILE_ENTRY* aEntry )
4161 THROW_IO_ERROR( wxT(
"WideStrings6 stream is not fully parsed" ) );
4165 const CFB::COMPOUND_FILE_ENTRY* aEntry )
4195 if( aElem.
fonttype == ALTIUM_TEXT_TYPE::BARCODE )
4200 msg.Printf(
_(
"Ignored barcode on Altium layer %d (not yet supported)." ),
4215 if( aElem.
fonttype == ALTIUM_TEXT_TYPE::BARCODE )
4222 msg.Printf(
_(
"Error loading library '%s':\n"
4223 "Footprint %s contains barcode on Altium layer %d (not yet supported)." ),
4235 msg.Printf(
_(
"Footprint %s contains barcode on Altium layer %d (not yet supported)." ),
4252 std::unique_ptr<PCB_TEXTBOX> pcbTextbox = std::make_unique<PCB_TEXTBOX>(
m_board );
4253 std::unique_ptr<PCB_TEXT> pcbText = std::make_unique<PCB_TEXT>(
m_board );
4257 static const std::map<wxString, wxString> variableMap = {
4258 {
"LAYER_NAME",
"LAYER" },
4259 {
"PRINT_DATE",
"CURRENT_DATE"},
4269 item = pcbTextbox.get();
4270 text = pcbTextbox.get();
4281 text->SetText( kicadText );
4286 m_board->
Add( pcbTextbox.release(), ADD_MODE::APPEND );
4288 m_board->
Add( pcbText.release(), ADD_MODE::APPEND );
4295 std::unique_ptr<PCB_TEXTBOX> fpTextbox = std::make_unique<PCB_TEXTBOX>( aFootprint );
4296 std::unique_ptr<PCB_TEXT> fpText = std::make_unique<PCB_TEXT>( aFootprint );
4313 item = &aFootprint->
Value();
4315 field = &aFootprint->
Value();
4319 item = fpText.get();
4320 text = fpText.get();
4324 static const std::map<wxString, wxString> variableMap = {
4325 {
"DESIGNATOR",
"REFERENCE" },
4326 {
"COMMENT",
"VALUE" },
4327 {
"VALUE",
"ALTIUM_VALUE" },
4328 {
"LAYER_NAME",
"LAYER" },
4329 {
"PRINT_DATE",
"CURRENT_DATE"},
4334 item = fpTextbox.get();
4335 text = fpTextbox.get();
4348 text->SetText( kicadText );
4349 text->SetKeepUpright(
false );
4356 aFootprint->
Add( fpTextbox.release(), ADD_MODE::APPEND );
4358 aFootprint->
Add( fpText.release(), ADD_MODE::APPEND );
4386 kicadMargin =
VECTOR2I( charWidth * 0.933, charHeight * 0.67 );
4388 kicadMargin =
VECTOR2I( charWidth * 0.808, charHeight * 0.844 );
4391 + kicadMargin * 2 - margin * 2 );
4393 kposition = kposition - kicadMargin + margin;
4409 : ALTIUM_TEXT_POSITION::LEFT_BOTTOM;
4411 switch( justification )
4413 case ALTIUM_TEXT_POSITION::LEFT_TOP:
4414 case ALTIUM_TEXT_POSITION::LEFT_CENTER:
4415 case ALTIUM_TEXT_POSITION::LEFT_BOTTOM:
4419 case ALTIUM_TEXT_POSITION::CENTER_TOP:
4420 case ALTIUM_TEXT_POSITION::CENTER_CENTER:
4421 case ALTIUM_TEXT_POSITION::CENTER_BOTTOM:
4425 case ALTIUM_TEXT_POSITION::RIGHT_TOP:
4426 case ALTIUM_TEXT_POSITION::RIGHT_CENTER:
4427 case ALTIUM_TEXT_POSITION::RIGHT_BOTTOM:
4435 msg.Printf(
_(
"Unknown textbox justification %d, aText %s" ), justification,
4455 int rectHeight = aElem.
height;
4458 rectWidth = -rectWidth;
4462 : ALTIUM_TEXT_POSITION::LEFT_BOTTOM;
4464 switch( justification )
4466 case ALTIUM_TEXT_POSITION::LEFT_TOP:
4470 kposition.
y -= rectHeight;
4472 case ALTIUM_TEXT_POSITION::LEFT_CENTER:
4476 kposition.
y -= rectHeight / 2;
4478 case ALTIUM_TEXT_POSITION::LEFT_BOTTOM:
4482 case ALTIUM_TEXT_POSITION::CENTER_TOP:
4486 kposition.
x += rectWidth / 2;
4487 kposition.
y -= rectHeight;
4489 case ALTIUM_TEXT_POSITION::CENTER_CENTER:
4493 kposition.
x += rectWidth / 2;
4494 kposition.
y -= rectHeight / 2;
4496 case ALTIUM_TEXT_POSITION::CENTER_BOTTOM:
4500 kposition.
x += rectWidth / 2;
4502 case ALTIUM_TEXT_POSITION::RIGHT_TOP:
4506 kposition.
x += rectWidth;
4507 kposition.
y -= rectHeight;
4509 case ALTIUM_TEXT_POSITION::RIGHT_CENTER:
4513 kposition.
x += rectWidth;
4514 kposition.
y -= rectHeight / 2;
4516 case ALTIUM_TEXT_POSITION::RIGHT_BOTTOM:
4520 kposition.
x += rectWidth;
4565 if( aElem.
fonttype == ALTIUM_TEXT_TYPE::TRUETYPE )
4573 if( font->
GetName().Contains( wxS(
"Arial" ) ) )
4588 const CFB::COMPOUND_FILE_ENTRY* aEntry )
4621 PCB_SHAPE shape(
nullptr, SHAPE_T::RECTANGLE );
4646 const bool aIsBoardImport )
4649 || aElem.
layer == ALTIUM_LAYER::KEEP_OUT_LAYER )
4652 PCB_SHAPE shape(
nullptr, SHAPE_T::RECTANGLE );
4686 std::unique_ptr<PCB_SHAPE> fill = std::make_unique<PCB_SHAPE>(
m_board, SHAPE_T::RECTANGLE );
4688 fill->SetFilled(
true );
4689 fill->SetLayer( aLayer );
4692 fill->SetStart( aElem.
pos1 );
4693 fill->SetEnd( aElem.
pos2 );
4708 m_board->
Add( fill.release(), ADD_MODE::APPEND );
4715 if( aLayer ==
F_Cu || aLayer ==
B_Cu )
4717 std::unique_ptr<PAD>
pad = std::make_unique<PAD>( aFootprint );
4720 padLayers.
set( aLayer );
4722 pad->SetAttribute( PAD_ATTRIB::SMD );
4735 std::swap( width, height );
4738 pad->SetPosition( aElem.
pos1 / 2 + aElem.
pos2 / 2 );
4750 pad->SetPosition( anchorPos );
4761 aElem.
pos1.
y / 2 + aElem.
pos2.
y / 2 - anchorPos.
y );
4763 pad->AddPrimitivePoly(
F_Cu, shapePolys, 0,
true );
4767 pad->SetLayerSet( padLayers );
4769 aFootprint->
Add(
pad.release(), ADD_MODE::APPEND );
4773 std::unique_ptr<PCB_SHAPE> fill =
4774 std::make_unique<PCB_SHAPE>( aFootprint, SHAPE_T::RECTANGLE );
4776 fill->SetFilled(
true );
4777 fill->SetLayer( aLayer );
4780 fill->SetStart( aElem.
pos1 );
4781 fill->SetEnd( aElem.
pos2 );
4790 aFootprint->
Add( fill.release(), ADD_MODE::APPEND );
4800 layerSet.
set( klayer );
4808 bool keepoutRestrictionVia = ( aKeepoutRestrictions & 0x01 ) != 0;
4809 bool keepoutRestrictionTrack = ( aKeepoutRestrictions & 0x02 ) != 0;
4810 bool keepoutRestrictionCopper = ( aKeepoutRestrictions & 0x04 ) != 0;
4811 bool keepoutRestrictionSMDPad = ( aKeepoutRestrictions & 0x08 ) != 0;
4812 bool keepoutRestrictionTHPad = ( aKeepoutRestrictions & 0x10 ) != 0;
4824 const uint8_t aKeepoutRestrictions )
4826 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>(
m_board );
4828 zone->SetIsRuleArea(
true );
4835 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
4838 m_board->
Add( zone.release(), ADD_MODE::APPEND );
4845 const uint8_t aKeepoutRestrictions )
4847 std::unique_ptr<ZONE> zone = std::make_unique<ZONE>( aFootprint );
4849 zone->SetIsRuleArea(
true );
4856 zone->SetBorderDisplayStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_EDGE,
4860 aFootprint->
Add( zone.release(), ADD_MODE::APPEND );
4873 if( elems.first == elems.second )
4876 std::vector<std::pair<PCB_LAYER_ID, int>> layerExpansionPairs;
4878 for(
auto it = elems.first; it != elems.second; ++it )
4882 if( pInf.
type == AEXTENDED_PRIMITIVE_INFORMATION_TYPE::MASK )
4888 if( aAltiumLayer == ALTIUM_LAYER::TOP_LAYER
4889 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4894 if( aAltiumLayer == ALTIUM_LAYER::BOTTOM_LAYER
4895 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4903 if( aAltiumLayer == ALTIUM_LAYER::TOP_LAYER
4904 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4909 if( aAltiumLayer == ALTIUM_LAYER::BOTTOM_LAYER
4910 || aAltiumLayer == ALTIUM_LAYER::MULTI_LAYER )
4918 return layerExpansionPairs;
std::string FormatPath(const std::vector< std::string > &aVectorPath)
Helper for debug logging (vector -> string)
const uint16_t ALTIUM_NET_UNCONNECTED
const uint16_t ALTIUM_POLYGON_NONE
const uint16_t ALTIUM_POLYGON_BOARD
const int ALTIUM_COMPONENT_NONE
LIB_ID AltiumToKiCadLibID(const wxString &aLibName, const wxString &aLibReference)
wxString AltiumPcbSpecialStringsToKiCadStrings(const wxString &aString, const std::map< wxString, wxString > &aOverrides)
void HelperShapeLineChainFromAltiumVertices(SHAPE_LINE_CHAIN &aLine, const std::vector< ALTIUM_VERTICE > &aVertices)
double normalizeAngleDegrees(double Angle, double aMin, double aMax)
Normalize angle to be aMin < angle <= aMax angle is in degrees.
constexpr double BOLD_FACTOR
bool IsAltiumLayerCopper(ALTIUM_LAYER aLayer)
bool IsAltiumLayerAPlane(ALTIUM_LAYER aLayer)
std::function< void(const ALTIUM_PCB_COMPOUND_FILE &, const CFB::COMPOUND_FILE_ENTRY *)> PARSE_FUNCTION_POINTER_fp
constexpr int ARC_HIGH_DEF
constexpr EDA_IU_SCALE pcbIUScale
LAYER_T
The allowed types of layers, same as Specctra DSN spec.
@ BS_ITEM_TYPE_DIELECTRIC
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
size_t GetRemainingBytes() const
std::map< uint32_t, wxString > ReadWideStringTable()
size_t ReadAndSetSubrecordLength()
std::map< wxString, wxString > ReadProperties(std::function< std::map< wxString, wxString >(const std::string &)> handleBinaryData=[](const std::string &) { return std::map< wxString, wxString >();})
const CFB::CompoundFileReader & GetCompoundFileReader() const
const CFB::COMPOUND_FILE_ENTRY * FindStream(const std::vector< std::string > &aStreamPath) const
const std::pair< AMODEL, std::vector< char > > * GetLibModel(const wxString &aModelID) const
std::tuple< wxString, const CFB::COMPOUND_FILE_ENTRY * > FindLibFootprintDirName(const wxString &aFpUnicodeName)
PROGRESS_REPORTER * m_progressReporter
optional; may be nullptr
void ParseClasses6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::vector< PCB_DIM_RADIAL * > m_radialDimensions
void ConvertArcs6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const AARC6 &aElem, PCB_LAYER_ID aLayer)
void ConvertTracks6ToBoardItem(const ATRACK6 &aElem, const int aPrimitiveIndex)
void ConvertTracks6ToFootprintItem(FOOTPRINT *aFootprint, const ATRACK6 &aElem, const int aPrimitiveIndex, const bool aIsBoardImport)
int m_highest_pour_index
Altium stores pour order across all layers.
void ConvertTexts6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const ATEXT6 &aElem, PCB_LAYER_ID aLayer)
std::map< ALTIUM_LAYER, PCB_LAYER_ID > m_layermap
void ConvertShapeBasedRegions6ToBoardItemOnLayer(const AREGION6 &aElem, PCB_LAYER_ID aLayer)
void ParseVias6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperParseDimensions6Leader(const ADIMENSION6 &aElem)
wxString m_footprintName
for footprint library loading error reporting
std::vector< FOOTPRINT * > m_components
void ParseShapeBasedRegions6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
const ARULE6 * GetRuleDefault(ALTIUM_RULE_KIND aKind) const
void HelperParsePad6NonCopper(const APAD6 &aElem, PCB_LAYER_ID aLayer, PCB_SHAPE *aShape)
void ParseRegions6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::vector< PCB_LAYER_ID > GetKicadLayersToIterate(ALTIUM_LAYER aAltiumLayer) const
void ConvertShapeBasedRegions6ToFootprintItem(FOOTPRINT *aFootprint, const AREGION6 &aElem, const int aPrimitiveIndex)
void HelperPcpShapeAsFootprintKeepoutRegion(FOOTPRINT *aFootprint, const PCB_SHAPE &aShape, const ALTIUM_LAYER aAltiumLayer, const uint8_t aKeepoutRestrictions)
void ConvertArcs6ToBoardItem(const AARC6 &aElem, const int aPrimitiveIndex)
void ConvertShapeBasedRegions6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const AREGION6 &aElem, PCB_LAYER_ID aLayer, const int aPrimitiveIndex)
std::map< ALTIUM_LAYER, ZONE * > m_outer_plane
std::vector< int > m_altiumToKicadNetcodes
unsigned m_totalCount
for progress reporting
void ParseComponents6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperPcpShapeAsBoardKeepoutRegion(const PCB_SHAPE &aShape, const ALTIUM_LAYER aAltiumLayer, const uint8_t aKeepoutRestrictions)
std::map< wxString, ALTIUM_EMBEDDED_MODEL_DATA > m_EmbeddedModels
void ConvertFills6ToBoardItemOnLayer(const AFILL6 &aElem, PCB_LAYER_ID aLayer)
std::vector< std::pair< PCB_LAYER_ID, int > > HelperGetSolderAndPasteMaskExpansions(const ALTIUM_RECORD aType, const int aPrimitiveIndex, const ALTIUM_LAYER aAltiumLayer)
void ConvertComponentBody6ToFootprintItem(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, FOOTPRINT *aFootprint, const ACOMPONENTBODY6 &aElem)
void HelperSetTextAlignmentAndPos(const ATEXT6 &aElem, EDA_TEXT *aEdaText)
void ParseBoard6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertFills6ToFootprintItem(FOOTPRINT *aFootprint, const AFILL6 &aElem, const bool aIsBoardImport)
void ParseExtendedPrimitiveInformationData(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ParseFileHeader(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertShapeBasedRegions6ToBoardItem(const AREGION6 &aElem)
void HelperCreateBoardOutline(const std::vector< ALTIUM_VERTICE > &aVertices)
std::map< ALTIUM_RULE_KIND, std::vector< ARULE6 > > m_rules
void ConvertVias6ToFootprintItem(FOOTPRINT *aFootprint, const AVIA6 &aElem)
void ParseRules6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperSetZoneKeepoutRestrictions(ZONE &aZone, const uint8_t aKeepoutRestrictions)
void HelperParseDimensions6Linear(const ADIMENSION6 &aElem)
void ParseTracks6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::map< uint32_t, wxString > m_unicodeStrings
void ConvertTexts6ToBoardItem(const ATEXT6 &aElem)
void HelperParseDimensions6Center(const ADIMENSION6 &aElem)
void HelperParseDimensions6Radial(const ADIMENSION6 &aElem)
void ParseBoardRegionsData(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ParseArcs6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertTexts6ToBoardItemOnLayer(const ATEXT6 &aElem, PCB_LAYER_ID aLayer)
void ConvertPads6ToFootprintItemOnCopper(FOOTPRINT *aFootprint, const APAD6 &aElem)
FOOTPRINT * ParseFootprint(ALTIUM_PCB_COMPOUND_FILE &altiumLibFile, const wxString &aFootprintName)
REPORTER * m_reporter
optional; may be nullptr
int GetNetCode(uint16_t aId) const
void ConvertTexts6ToEdaTextSettings(const ATEXT6 &aElem, EDA_TEXT &aEdaText)
wxString m_library
for footprint library loading error reporting
void ConvertPads6ToFootprintItemOnNonCopper(FOOTPRINT *aFootprint, const APAD6 &aElem)
void ConvertTexts6ToFootprintItem(FOOTPRINT *aFootprint, const ATEXT6 &aElem)
unsigned m_lastProgressCount
void ParseFills6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertArcs6ToFootprintItem(FOOTPRINT *aFootprint, const AARC6 &aElem, const int aPrimitiveIndex, const bool aIsBoardImport)
void HelperParseDimensions6Datum(const ADIMENSION6 &aElem)
void ConvertPads6ToBoardItem(const APAD6 &aElem)
void ConvertFills6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const AFILL6 &aElem, PCB_LAYER_ID aLayer)
void ParseWideStrings6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void remapUnsureLayers(std::vector< ABOARD6_LAYER_STACKUP > &aStackup)
std::vector< ZONE * > m_polygons
void ParsePads6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertArcs6ToPcbShape(const AARC6 &aElem, PCB_SHAPE *aShape)
void ConvertTracks6ToBoardItemOnLayer(const ATRACK6 &aElem, PCB_LAYER_ID aLayer)
void ConvertFills6ToBoardItem(const AFILL6 &aElem)
FOOTPRINT * HelperGetFootprint(uint16_t aComponent) const
LAYER_MAPPING_HANDLER m_layerMappingHandler
void ParsePolygons6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
PCB_LAYER_ID GetKicadLayer(ALTIUM_LAYER aAltiumLayer) const
void ParseComponentsBodies6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertTracks6ToFootprintItemOnLayer(FOOTPRINT *aFootprint, const ATRACK6 &aElem, PCB_LAYER_ID aLayer)
void Parse(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const std::map< ALTIUM_PCB_DIR, std::string > &aFileMapping)
ALTIUM_PCB(BOARD *aBoard, PROGRESS_REPORTER *aProgressReporter, LAYER_MAPPING_HANDLER &aLayerMappingHandler, REPORTER *aReporter=nullptr, const wxString &aLibrary=wxEmptyString, const wxString &aFootprintName=wxEmptyString)
void ConvertArcs6ToBoardItemOnLayer(const AARC6 &aElem, PCB_LAYER_ID aLayer)
void ParseTexts6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
std::map< ALTIUM_RECORD, std::multimap< int, const AEXTENDED_PRIMITIVE_INFORMATION > > m_extendedPrimitiveInformationMaps
void ParseModelsData(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry, const std::vector< std::string > &aRootDir)
std::map< ALTIUM_LAYER, wxString > m_layerNames
void ConvertPads6ToBoardItemOnNonCopper(const APAD6 &aElem)
void HelperSetTextboxAlignmentAndPos(const ATEXT6 &aElem, PCB_TEXTBOX *aPcbTextbox)
void ParseNets6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void ConvertPads6ToFootprintItem(FOOTPRINT *aFootprint, const APAD6 &aElem)
const ARULE6 * GetRule(ALTIUM_RULE_KIND aKind, const wxString &aName) const
void ParseDimensions6Data(const ALTIUM_PCB_COMPOUND_FILE &aAltiumPcbFile, const CFB::COMPOUND_FILE_ENTRY *aEntry)
void HelperSetZoneLayers(ZONE &aZone, const ALTIUM_LAYER aAltiumLayer)
static wxString ReadString(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
BASE_SET & set(size_t pos)
Container for design settings for a BOARD object.
std::shared_ptr< NET_SETTINGS > m_NetSettings
void SetGridOrigin(const VECTOR2I &aOrigin)
const VECTOR2I & GetGridOrigin()
const VECTOR2I & GetAuxOrigin()
void SetAuxOrigin(const VECTOR2I &aOrigin)
int m_SolderMaskExpansion
BOARD_STACKUP & GetStackupDescriptor()
int GetLineThickness(PCB_LAYER_ID aLayer) const
Return the default graphic segment thickness from the layer class for the given layer.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual void SetIsKnockout(bool aKnockout)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Set the layer this item is on.
Manage layers needed to make a physical board.
void RemoveAll()
Delete all items in list and clear the list.
const std::vector< BOARD_STACKUP_ITEM * > & GetList() const
void BuildDefaultStackupList(const BOARD_DESIGN_SETTINGS *aSettings, int aActiveCopperLayersCount=0)
Create a default stackup, according to the current BOARD_DESIGN_SETTINGS settings.
Information pertinent to a Pcbnew printed circuit board.
LSET GetEnabledLayers() const
A proxy function that calls the corresponding function in m_BoardSettings.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
const BOX2I GetBoardEdgesBoundingBox() const
Return the board bounding box calculated using exclusively the board edges (graphics on Edge....
void SetEnabledLayers(LSET aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings.
const PAGE_INFO & GetPageSettings() const
bool IsLayerEnabled(PCB_LAYER_ID aLayer) const
A proxy function that calls the correspondent function in m_BoardSettings tests whether a given layer...
LAYER_T GetLayerType(PCB_LAYER_ID aLayer) const
Return the type of the copper layer given by aLayer.
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Changes the name of the layer given by aLayer.
void Move(const VECTOR2I &aMoveVector) override
Move this object.
int GetCopperLayerCount() const
const TRACKS & Tracks() const
void SetVisibleLayers(LSET aLayerMask)
A proxy function that calls the correspondent function in m_BoardSettings changes the bit-mask of vis...
bool m_LegacyNetclassesLoaded
True if netclasses were loaded from the file.
void SetCopperLayerCount(int aCount)
bool SetLayerType(PCB_LAYER_ID aLayer, LAYER_T aLayerType)
Change the type of the layer given by aLayer.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
const DRAWINGS & Drawings() const
constexpr coord_type GetY() const
constexpr size_type GetWidth() const
constexpr coord_type GetX() const
constexpr size_type GetHeight() const
bool IsHorizontal() const
bool IsCardinal90() const
EDA_ANGLE GetArcAngle() const
void SetCenter(const VECTOR2I &aCenter)
void SetFilled(bool aFlag)
void SetStart(const VECTOR2I &aStart)
const VECTOR2I & GetStart() const
Return the starting point of the graphic.
void SetShape(SHAPE_T aShape)
void SetEnd(const VECTOR2I &aEnd)
void SetArcAngleAndEnd(const EDA_ANGLE &aAngle, bool aCheckNegativeAngle=false)
Set the end point from the angle center and start.
void SetPolyPoints(const std::vector< VECTOR2I > &aPoints)
A mix-in class (via multiple inheritance) that handles texts such as labels, parts,...
int GetTextHeight() const
void SetTextSize(VECTOR2I aNewSize, bool aEnforceMinTextSize=true)
void SetTextPos(const VECTOR2I &aPoint)
KIFONT::FONT * GetFont() const
void SetMirrored(bool isMirrored)
void SetVertJustify(GR_TEXT_V_ALIGN_T aType)
void SetBoldFlag(bool aBold)
Set only the italic flag, without changing the font.
void SetTextThickness(int aWidth)
The TextThickness is that set by the user.
GR_TEXT_V_ALIGN_T GetVertJustify() const
virtual void SetTextAngle(const EDA_ANGLE &aAngle)
void SetItalic(bool aItalic)
Set the text to be italic - this will also update the font if needed.
void SetFont(KIFONT::FONT *aFont)
void SetHorizJustify(GR_TEXT_H_ALIGN_T aType)
wxString GetEmbeddedFileLink(const EMBEDDED_FILE &aFile) const
Returns the link for an embedded file.
EMBEDDED_FILE * AddFile(const wxFileName &aName, bool aOverwrite)
Loads a file from disk and adds it to the collection.
static RETURN_CODE CompressAndEncode(EMBEDDED_FILE &aFile)
Takes data from the #decompressedData buffer and compresses it using ZSTD into the #compressedEncoded...
VECTOR3D m_Offset
3D model offset (mm)
VECTOR3D m_Rotation
3D model rotation (degrees)
wxString m_Filename
The 3D shape filename in 3D library.
FONT is an abstract base class for both outline and stroke fonts.
static FONT * GetFont(const wxString &aFontName=wxEmptyString, bool aBold=false, bool aItalic=false, const std::vector< wxString > *aEmbeddedFiles=nullptr, bool aForDrawingSheet=false)
virtual bool IsStroke() const
const wxString & GetName() const
virtual bool IsOutline() const
LAYER_RANGE_ITERATOR begin() const
A logical library item identifier and consists of various portions much like a URI.
LSET is a set of PCB_LAYER_IDs.
static LSET AllBoardTechMask()
Return a mask holding board technical layers (no CU layer) on both side.
static LSET UserDefinedLayers()
Return a mask with all of the allowable user defined layers.
Handle the data for a net.
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
A PADSTACK defines the characteristics of a single or multi-layer pad, in the IPC sense of the word.
void SetRoundRectRadiusRatio(double aRatio, PCB_LAYER_ID aLayer)
void SetChamferRatio(double aRatio, PCB_LAYER_ID aLayer)
void SetShape(PAD_SHAPE aShape, PCB_LAYER_ID aLayer)
void SetChamferPositions(int aPositions, PCB_LAYER_ID aLayer)
@ NORMAL
Shape is the same on all layers.
@ CUSTOM
Shapes can be defined on arbitrary layers.
@ FRONT_INNER_BACK
Up to three shapes can be defined (F_Cu, inner copper layers, B_Cu)
void SetSize(const VECTOR2I &aSize, PCB_LAYER_ID aLayer)
static constexpr PCB_LAYER_ID ALL_LAYERS
! Temporary layer identifier to identify code that is not padstack-aware
static constexpr PCB_LAYER_ID INNER_LAYERS
! The layer identifier to use for "inner layers" on top/inner/bottom padstacks
static LSET PTHMask()
layer set for a through hole pad
static LSET UnplatedHoleMask()
layer set for a mechanical unplated through hole pad
static LSET SMDMask()
layer set for a SMD pad on Front layer
int GetHeightIU(double aIUScale) const
Gets the page height in IU.
int GetWidthIU(double aIUScale) const
Gets the page width in IU.
virtual VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
A radial dimension indicates either the radius or diameter of an arc or circle.
VECTOR2I GetCenter() const override
This defaults to the center of the bounding box if not overridden.
void Rotate(const VECTOR2I &aRotCentre, const EDA_ANGLE &aAngle) override
Rotate this object.
void SetPosition(const VECTOR2I &aPos) override
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
void SetStroke(const STROKE_PARAMS &aStroke) override
VECTOR2I GetPosition() const override
void SetBorderEnabled(bool enabled)
void SetMarginTop(int aTop)
void SetMarginLeft(int aLeft)
void SetMarginBottom(int aBottom)
void SetTextAngle(const EDA_ANGLE &aAngle) override
void SetMarginRight(int aRight)
A progress reporter interface for use in multi-threaded environments.
virtual bool KeepRefreshing(bool aWait=false)=0
Update the UI (if any).
virtual void Report(const wxString &aMessage)=0
Display aMessage in the progress bar dialog.
virtual void SetCurrentProgress(double aProgress)=0
Set the progress value to aProgress (0..1).
A pure virtual class used to derive REPORTER objects from.
virtual REPORTER & Report(const wxString &aText, SEVERITY aSeverity=RPT_SEVERITY_UNDEFINED)=0
Report a string with a given severity.
OPT_VECTOR2I Intersect(const SEG &aSeg, bool aIgnoreEndpoints=false, bool aLines=false) const
Compute intersection point of segment (this) with segment aSeg.
const VECTOR2I & GetArcMid() const
const VECTOR2I & GetP1() const
const VECTOR2I & GetP0() const
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
const SHAPE_ARC & Arc(size_t aArc) const
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
int PointCount() const
Return the number of points (vertices) in this line chain.
ssize_t ArcIndex(size_t aSegment) const
Return the arc index for the given segment index.
SEG Segment(int aIndex) const
Return a copy of the aIndex-th segment in the line chain.
int NextShape(int aPointIndex) const
Return the vertex index of the next shape in the chain, or -1 if aPointIndex is the last shape.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
bool IsArcStart(size_t aIndex) const
Represent a set of closed polygons.
void Rotate(const EDA_ANGLE &aAngle, const VECTOR2I &aCenter={ 0, 0 }) override
Rotate all vertices by a given angle.
void Fracture(POLYGON_MODE aFastMode)
Convert a set of polygons with holes to a single outline with "slits"/"fractures" connecting the oute...
int AddOutline(const SHAPE_LINE_CHAIN &aOutline)
Adds a new outline to the set and returns its index.
void BooleanAdd(const SHAPE_POLY_SET &b, POLYGON_MODE aFastMode)
Perform boolean polyset union For aFastMode meaning, see function booleanOp.
void Inflate(int aAmount, CORNER_STRATEGY aCornerStrategy, int aMaxError, bool aSimplify=false)
Perform outline inflation/deflation.
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)
int AddHole(const SHAPE_LINE_CHAIN &aHole, int aOutline=-1)
Adds a new hole to the given outline (default: last) and returns its index.
SHAPE_LINE_CHAIN & Outline(int aIndex)
Return the reference to aIndex-th outline in the set.
int NewOutline()
Creates a new empty polygon in the set and returns its index.
int OutlineCount() const
Return the number of outlines in the set.
void Move(const VECTOR2I &aVector) override
Simple container to manage line stroke parameters.
double Distance(const VECTOR2< extended_type > &aVector) const
Compute the distance between two vectors.
T EuclideanNorm() const
Compute the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2).
VECTOR2< T > Resize(T aNewLength) const
Return a vector of the same direction, but length specified in aNewLength.
Handle a list of polygons defining a copper zone.
void SetNeedRefill(bool aNeedRefill)
void SetDoNotAllowPads(bool aEnable)
void SetDoNotAllowCopperPour(bool aEnable)
SHAPE_POLY_SET * GetFill(PCB_LAYER_ID aLayer)
void SetDoNotAllowTracks(bool aEnable)
void SetFilledPolysList(PCB_LAYER_ID aLayer, const SHAPE_POLY_SET &aPolysList)
Set the list of filled polygons.
void SetIsFilled(bool isFilled)
bool HasFilledPolysForLayer(PCB_LAYER_ID aLayer) const
void SetLayerSet(const LSET &aLayerSet) override
void SetDoNotAllowVias(bool aEnable)
void SetDoNotAllowFootprints(bool aEnable)
static int GetDefaultHatchPitch()
static constexpr EDA_ANGLE ANGLE_90
static constexpr EDA_ANGLE ANGLE_45
#define THROW_IO_ERROR(msg)
bool IsCopperLayer(int aLayerId)
Tests whether a layer is a copper layer.
size_t CopperLayerToOrdinal(PCB_LAYER_ID aLayer)
! Converts KiCad copper layer enum to an ordinal between the front and back layers
PCB_LAYER_ID
A quick note on layer IDs:
void for_all_pairs(_InputIterator __first, _InputIterator __last, _Function __f)
Apply a function to every possible pair of elements of a sequence.
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
std::function< std::map< wxString, PCB_LAYER_ID >(const std::vector< INPUT_LAYER_DESC > &)> LAYER_MAPPING_HANDLER
Pointer to a function that takes a map of source and KiCad layers and returns a re-mapped version.
std::optional< VECTOR2I > OPT_VECTOR2I
wxString NotSpecifiedPrm()
uint8_t keepoutrestrictions
wxString dielectricmaterial
std::vector< ABOARD6_LAYER_STACKUP > stackup
std::vector< ALTIUM_VERTICE > board_vertices
std::vector< wxString > names
wxString sourcefootprintlibrary
wxString sourcedesignator
std::vector< VECTOR2I > textPoint
ALTIUM_DIMENSION_KIND kind
std::vector< VECTOR2I > referencePoint
uint8_t keepoutrestrictions
std::vector< char > m_data
int32_t soldermaskexpansionmanual
std::unique_ptr< APAD6_SIZE_AND_SHAPE > sizeAndShape
ALTIUM_PAD_SHAPE topshape
ALTIUM_MODE pastemaskexpansionmode
ALTIUM_MODE soldermaskexpansionmode
ALTIUM_PAD_SHAPE botshape
ALTIUM_PAD_SHAPE midshape
int32_t pastemaskexpansionmanual
std::vector< ALTIUM_VERTICE > vertices
ALTIUM_POLYGON_HATCHSTYLE hatchstyle
uint8_t keepoutrestrictions
std::vector< ALTIUM_VERTICE > outline
std::vector< std::vector< ALTIUM_VERTICE > > holes
ALTIUM_CONNECT_STYLE polygonconnectStyle
int planeclearanceClearance
int32_t polygonconnectReliefconductorwidth
int32_t polygonconnectAirgapwidth
uint32_t text_offset_width
uint32_t textbox_rect_height
ALTIUM_TEXT_POSITION textbox_rect_justification
uint32_t textbox_rect_width
uint32_t margin_border_width
bool isJustificationValid
ALTIUM_TEXT_TYPE fonttype
uint8_t keepoutrestrictions
int32_t soldermask_expansion_front
bool soldermask_expansion_manual
int32_t soldermask_expansion_back
uint32_t diameter_by_layer[32]
constexpr double IUTomm(int iu) const
constexpr int mmToIU(double mm) const
std::vector< char > decompressedData
void RotatePoint(int *pX, int *pY, const EDA_ANGLE &aAngle)
Calculate the new point of coord coord pX, pY, for a rotation center 0, 0.
double DEG2RAD(double deg)
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
@ PCB_DIM_ALIGNED_T
class PCB_DIM_ALIGNED, a linear dimension (graphic item)
@ PCB_ARC_T
class PCB_ARC, an arc track segment on a copper layer
VECTOR2< int32_t > VECTOR2I