44#include <wx/filename.h>
45#include <wx/wfstream.h>
47#include <wx/strconv.h>
48#include <wx/fontenc.h>
89 uint16_t v =
static_cast<uint16_t
>(
m_pos[0] )
90 | (
static_cast<uint16_t
>(
m_pos[1] ) << 8 );
125 uint32_t v =
static_cast<uint32_t
>(
m_pos[0] )
126 | (
static_cast<uint32_t
>(
m_pos[1] ) << 8 )
127 | (
static_cast<uint32_t
>(
m_pos[2] ) << 16 )
128 | (
static_cast<uint32_t
>(
m_pos[3] ) << 24 );
144 std::memcpy( &v, &bits,
sizeof( v ) );
154 uint64_t bits =
static_cast<uint64_t
>(
m_pos[0] )
155 | (
static_cast<uint64_t
>(
m_pos[1] ) << 8 )
156 | (
static_cast<uint64_t
>(
m_pos[2] ) << 16 )
157 | (
static_cast<uint64_t
>(
m_pos[3] ) << 24 )
158 | (
static_cast<uint64_t
>(
m_pos[4] ) << 32 )
159 | (
static_cast<uint64_t
>(
m_pos[5] ) << 40 )
160 | (
static_cast<uint64_t
>(
m_pos[6] ) << 48 )
161 | (
static_cast<uint64_t
>(
m_pos[7] ) << 56 );
165 std::memcpy( &v, &bits,
sizeof( v ) );
175 return static_cast<float>(
readInt32() );
177 return static_cast<float>(
readInt16() );
184 size_t len = std::min( rawLen, aMaxLen );
189 std::string s(
reinterpret_cast<const char*
>(
m_pos ), len );
205 std::string s(
reinterpret_cast<const char*
>(
m_pos ), len );
222 const uint8_t* seekTo =
m_pos + aBytes;
245 if( numBoards == 0 || numBoards > 100 )
255 for( uint32_t b = 0; b <
m_fileData.boards.size(); b++ )
265 boardData.
objects.resize( numObjects );
267 for( uint32_t i = 0; i < numObjects; i++ )
272 uint32_t numConnections = 0;
281 for( uint32_t c = 0; c < numConnections; c++ )
286 for( uint32_t i = 0; i < connCount; i++ )
302 data.
name = wxFileNameFromPath( aFileName ).BeforeLast(
'.' );
316 wxFFileInputStream stream( aFileName );
321 size_t fileSize = stream.GetLength();
324 THROW_IO_ERRORF(
_(
"File '%s' is too small to be a Sprint Layout file" ), aFileName );
327 stream.Read(
m_buffer.data(), fileSize );
329 if( stream.LastRead() != fileSize )
342 if(
m_fileData.version > 6 || magic1 != 0x33 || magic2 != 0xAA || magic3 != 0xFF )
361 for(
int i = 0; i < 7; i++ )
430 aBoard.
objects.resize( numObjects );
432 for( uint32_t i = 0; i < numObjects; i++ )
444 aObj.
groups.resize( groupCount );
446 for( uint32_t i = 0; i < groupCount; i++ )
458 for( uint32_t i = 0; i < pointCount; i++ )
464 if( pt.
x == 0.0f || std::isnormal( pt.
x ) )
466 aObj.
points.emplace_back( pt );
578 if(
m_fileData.version >= 2 && !aIsTextChild )
613 THROW_IO_ERROR(
_(
"Too many text children in Sprint Layout object" ) );
617 for( uint32_t i = 0; i < childCount; i++ )
663 switch( aSprintLayer )
672 default:
return F_Cu;
678 switch( aSprintLayer )
687 default:
return F_Cu;
701 nm =
static_cast<double>( aValue ) * 100.0;
703 nm =
static_cast<double>( aValue ) * 10000.0;
705 nm = std::clamp( nm,
static_cast<double>( -
pcbIUScale.mmToIU( 500 ) ),
706 static_cast<double>(
pcbIUScale.mmToIU( 500 ) ) );
721 static wxCSConv convCP1251( wxFONTENCODING_CP1251 );
722 static wxCSConv convCP1252( wxFONTENCODING_CP1252 );
725 return wxEmptyString;
727 wxString ret = wxString::FromUTF8( aStr );
729 if( ret.empty() && convCP1251.IsOk() && convCP1252.IsOk() )
732 size_t extNonGermanCount = 0;
734 for(
unsigned char c : aStr )
756 if( extNonGermanCount > 0 )
757 ret = wxString( aStr.c_str(), convCP1251 );
759 ret = wxString( aStr.c_str(), convCP1252 );
773 case F_Cu:
return aGroundPlane[0] != 0;
774 case B_Cu:
return aGroundPlane[2] != 0;
775 case In1_Cu:
return aGroundPlane[4] != 0;
776 case In2_Cu:
return aGroundPlane[5] != 0;
777 default:
return false;
784 case F_Cu:
return aGroundPlane[0] != 0;
785 case B_Cu:
return aGroundPlane[1] != 0;
786 default:
return false;
840 BOARD* board = &aBoard;
844 bool hasInnerLayers =
false;
850 hasInnerLayers =
true;
862 const wxString gndPlaneNetName(
"GND_PLANE" );
863 std::map<int, PCB_LAYER_ID> groundPlaneMap;
864 LSET groundPlaneLayerSet;
884 for(
const auto& [
index, layer] : groundPlaneMap )
887 groundPlaneLayerSet.
set( layer );
890 if( groundPlaneLayerSet.any() )
906 zone->
SetNet( gndPlaneNet );
916 std::map<uint16_t, FOOTPRINT*> componentMap;
917 std::vector<std::vector<VECTOR2I>> outlineSegments;
919 auto getOrCreateComponentFootprint =
922 if( aObj.component_id == 0 )
925 auto it = componentMap.find( aObj.component_id );
927 if( it != componentMap.end() )
938 fp->
SetReference( wxString::Format( wxS(
"U%d" ), aObj.component_id ) );
941 fd->SetVisible(
false );
946 if( !aObj.component.comment.empty() )
952 else if( !aObj.identifier.empty() )
957 if( !aObj.component.package.empty() )
966 componentMap[aObj.component_id] = fp;
975 getOrCreateComponentFootprint( obj );
978 std::map<uint32_t, std::set<BOARD_ITEM*>> gidToItems;
985 if(
FOOTPRINT* fp = getOrCreateComponentFootprint( obj ) )
1028 BOX2I fpBbox = fp->GetBoundingHull().BBox();
1031 fp->SetPosition(
anchor );
1035 fp->MoveAnchorPosition( anchorShift );
1039 for(
const auto& [componentId, fp] : componentMap )
1041 wxString fpKey = wxString::Format( wxS(
"SprintLayout_%s" ), fp->GetReference() );
1044 aFootprintMap[fpKey] = std::unique_ptr<FOOTPRINT>( fpCopy );
1058 fp->Move( centerOffset );
1061 zone->Move( centerOffset );
1064 item->Move( centerOffset );
1078 std::unique_ptr<FOOTPRINT> fp = std::make_unique<FOOTPRINT>(
nullptr );
1082 fp->SetFPID(
LIB_ID( wxEmptyString, fpName ) );
1083 fp->SetReference( wxT(
"REF**" ) );
1084 fp->SetValue( fpName );
1085 fp->Reference().SetVisible(
true );
1086 fp->Value().SetVisible(
true );
1088 std::vector<std::vector<VECTOR2I>> outlineSegments;
1089 uint8_t groundPlane[7] = {};
1090 std::map<uint32_t, std::set<BOARD_ITEM*>> gidToItems;
1101 processPad( container, obj, groundPlane,
nullptr, gidToItems );
1105 processSegment( container, obj, outlineSegments, groundPlane,
nullptr, gidToItems );
1109 processLine( container, obj, outlineSegments, groundPlane,
nullptr, gidToItems );
1113 processPoly( container, obj, outlineSegments, groundPlane,
nullptr, gidToItems );
1117 processCircle( container, obj, outlineSegments, groundPlane,
nullptr, gidToItems );
1133 fp->AutoPositionFields();
1136 BOX2I bbox = fp->GetBoundingHull().BBox();
1139 std::unique_ptr<PCB_SHAPE> shape = std::make_unique<PCB_SHAPE>( fp.get(),
SHAPE_T::RECTANGLE );
1143 shape->SetEnd( bbox.
GetEnd() );
1152 const uint8_t aGroundPlane[7],
NETINFO_ITEM* aGndPlaneNet,
1153 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1155 BOARD* board = aContainer ? aContainer->
GetBoard() :
nullptr;
1157 bool standaloneFp =
false;
1162 standaloneFp =
true;
1167 aContainer->
Add( fp );
1181 if( !aObj.
points.empty() )
1183 double cx = 0, cy = 0;
1191 cx /=
static_cast<double>( aObj.
points.size() );
1192 cy /=
static_cast<double>( aObj.
points.size() );
1193 ptsCenter =
sprintToKicadPos(
static_cast<float>( cx ),
static_cast<float>( cy ) );
1195 std::vector<VECTOR2I> pts;
1200 if( pts.size() == 2 )
1202 ptsAngle =
EDA_ANGLE( pts[1] - pts[0] );
1207 else if( pts.size() == 4 )
1209 ptsAngle =
EDA_ANGLE( pts[1] - pts[0] );
1211 else if( pts.size() == 8 )
1213 ptsAngle =
EDA_ANGLE( pts[2] - pts[1] );
1217 wxFAIL_MSG( wxString::Format(
"Unknown pad type %d shape %d with %zu points",
int( aObj.
type ),
1221 ptsAngle = ptsAngle.
Round( 2 );
1243 if( padLayer ==
F_Cu )
1245 else if( padLayer ==
B_Cu )
1248 pad->SetLayerSet(
LSET( { padLayer } ) );
1254 VECTOR2I padSize( outerDia, outerDia );
1255 VECTOR2I drillSize( drillDia, drillDia );
1276 pad->SetDrillSize( drillSize );
1308 pad->SetPosition( padPos );
1309 pad->Rotate( padPos, -ptsAngle );
1315 if( padLayer ==
F_Cu )
1317 else if( padLayer ==
B_Cu )
1320 pad->SetLayerSet(
LSET( { padLayer } ) );
1333 if( !aObj.
points.empty() )
1337 pad->SetPosition( padPos );
1338 pad->Rotate( padPos, -ptsAngle );
1344 pad->Padstack().FrontOuterLayers().has_solder_mask =
false;
1345 pad->Padstack().BackOuterLayers().has_solder_mask =
false;
1352 pad->SetLocalClearance( std::optional<int>(
clearance ) );
1353 pad->SetLocalThermalGapOverride( std::optional<int>(
clearance ) );
1359 int spokeWidth = aObj.
rotation * 10000 / 2;
1360 pad->SetLocalThermalSpokeWidthOverride( spokeWidth );
1364 uint32_t spokeMask =
static_cast<uint32_t
>( aObj.
start_angle );
1366 if( spokeMask != 0 )
1370 if( spokeMask & 0x55555555 )
1372 else if( spokeMask & 0xAAAAAAAA )
1394 if( aGroundPlane[0] )
1396 else if( aGroundPlane[2] )
1398 else if( aGroundPlane[4] )
1400 else if( aGroundPlane[5] )
1407 pad->SetNumber( wxString::Format( wxS(
"%d" ),
static_cast<int>( fp->
Pads().size() + 1 ) ) );
1414 fd->SetTextPos(
pad->GetPosition() );
1426 std::vector<std::vector<VECTOR2I>>& aOutlineSegments,
1427 const uint8_t aGroundPlane[7],
NETINFO_ITEM* aGndPlaneNet,
1428 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1430 if( aObj.
points.size() < 2 )
1433 BOARD* board = aContainer ? aContainer->
GetBoard() :
nullptr;
1438 std::vector<VECTOR2I> segment;
1443 aOutlineSegments.push_back( std::move( segment ) );
1452 for(
size_t i = 0; i + 1 < aObj.
points.size(); i++ )
1467 aContainer->
Add( shape );
1474 std::vector<std::vector<VECTOR2I>>& aOutlineSegments,
1475 const uint8_t aGroundPlane[7],
NETINFO_ITEM* aGndPlaneNet,
1476 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1482 std::vector<VECTOR2I> seg;
1485 aOutlineSegments.push_back( std::move( seg ) );
1504 aContainer->
Add( shape );
1510 std::vector<std::vector<VECTOR2I>>& aOutlineSegments,
1511 const uint8_t aGroundPlane[7],
NETINFO_ITEM* aGndPlaneNet,
1512 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1514 if( aObj.
points.size() < 2 )
1517 BOARD* board = aContainer ? aContainer->
GetBoard() :
nullptr;
1522 std::vector<VECTOR2I> points;
1527 points.push_back( points[0] );
1529 aOutlineSegments.push_back( std::move( points ) );
1534 bool isCutout = ( aObj.
keepout != 0 );
1554 ZONE* zone =
new ZONE( aContainer );
1564 aContainer->
Add( zone );
1567 else if( aObj.
points.size() >= 3 )
1581 aContainer->
Add( shape );
1588 std::vector<std::vector<VECTOR2I>>& aOutlineSegments,
1589 const uint8_t aGroundPlane[7],
NETINFO_ITEM* aGndPlaneNet,
1590 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1592 BOARD* board = aContainer ? aContainer->
GetBoard() :
nullptr;
1602 bool isFullCircle =
true;
1603 double startAngleDeg = 0, endAngleDeg = 0;
1614 if( startAngleDeg > 1000 || startAngleDeg < -1000 || endAngleDeg > 1000 || endAngleDeg < -1000 )
1616 startAngleDeg /= 1000;
1617 endAngleDeg /= 1000;
1622 isFullCircle = ( startAngleDeg == 0 && endAngleDeg == 0 )
1623 || ( endAngleDeg - startAngleDeg >= 360 )
1624 || ( startAngleDeg == endAngleDeg );
1631 std::vector<VECTOR2I> segment;
1635 for(
int i = 0; i <= 24; i++ )
1637 double angle = (
static_cast<double>( i ) / 24.0 ) * 2.0 *
M_PI;
1638 int px =
center.x +
static_cast<int>( std::cos( angle ) * kiRadius );
1639 int py =
center.y -
static_cast<int>( std::sin( angle ) * kiRadius );
1640 segment.emplace_back( px, py );
1645 int32_t sa = startAngleDeg * 1000;
1646 int32_t ea = endAngleDeg * 1000;
1651 for( int32_t a = sa; a <= ea; a += 15000 )
1653 double rad = (
static_cast<double>( a ) / 1000.0 ) *
M_PI / 180.0;
1654 int px =
center.x +
static_cast<int>( std::cos( rad ) * kiRadius );
1655 int py =
center.y -
static_cast<int>( std::sin( rad ) * kiRadius );
1656 segment.emplace_back( px, py );
1659 double endRad = (
static_cast<double>( ea ) / 1000.0 ) *
M_PI / 180.0;
1660 int epx =
center.x +
static_cast<int>( std::cos( endRad ) * kiRadius );
1661 int epy =
center.y -
static_cast<int>( std::sin( endRad ) * kiRadius );
1662 segment.emplace_back( epx, epy );
1665 aOutlineSegments.push_back( std::move( segment ) );
1685 double startRad = startAngleDeg *
M_PI / 180.0;
1686 int sx =
center.x +
static_cast<int>( std::cos( startRad ) * kiRadius );
1687 int sy =
center.y -
static_cast<int>( std::sin( startRad ) * kiRadius );
1690 double newEndAngle = endAngleDeg;
1692 if( newEndAngle < startAngleDeg )
1696 double arcAngle = startAngleDeg - newEndAngle;
1706 aContainer->
Add( shape );
1712 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1738 if( aObj.
text.empty() )
1755 double cx = 0, cy = 0;
1756 size_t ptsCount = 0;
1782 cx /=
static_cast<double>( ptsCount );
1783 cy /=
static_cast<double>( ptsCount );
1784 ptsCenter =
sprintToKicadPos(
static_cast<float>( cx ),
static_cast<float>( cy ) );
1788 text->SetLayer( layer );
1792 text->SetKeepUpright(
false );
1802 double widthScale = 0.8 + 0.2 * aObj.
line_width;
1803 text->SetTextSize(
VECTOR2I( height * widthScale, height ) );
1805 double thicknessScale = 0.06 + 0.05 * aObj.
inner;
1806 int thickness = height * thicknessScale;
1808 if( thickness <= 0 )
1809 thickness = std::max( 1, height / 8 );
1811 text->SetTextThickness( thickness );
1823 text->SetTextThickness( height / 8 );
1827 text->SetTextPos( untransformedPos );
1833 text->SetTextPos( newCenter );
1845 if( mirrorH ^ mirrorV )
1847 text->SetMirrored(
true );
1849 rotation = -rotation;
1865 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1867 for( uint32_t gid : aObj.
groups )
1868 aGidToItems[gid].insert( aItem );
1873 std::map<uint32_t, std::set<BOARD_ITEM*>>& aGidToItems )
1875 std::map<uint32_t, PCB_GROUP*> gidGroupMap;
1876 std::vector<uint32_t> gidAscBySize;
1878 for(
const auto& [gid,
_] : aGidToItems )
1882 gidGroupMap[gid] =
group;
1883 gidAscBySize.push_back( gid );
1891 std::sort( gidAscBySize.begin(), gidAscBySize.end(),
1892 [&]( uint32_t gidA, uint32_t gidB )
1894 size_t sa = aGidToItems.at( gidA ).size();
1895 size_t sb = aGidToItems.at( gidB ).size();
1903 for( uint32_t gid : gidAscBySize )
1911 if( itemGroup != grp )
1917 if( item->GetParent() == grp->
GetParent() )
1930 static const int PROXIMITY_DELTA = 100;
1940 for(
size_t iterations = 0; iterations < aOutlineSegments.size(); iterations++ )
1942 bool joined =
false;
1944 for( std::vector<VECTOR2I>& lineChain : aOutlineSegments )
1946 if( lineChain.size() < 2 )
1949 for( std::vector<VECTOR2I>& other : aOutlineSegments )
1951 if( &lineChain == &other || other.empty() )
1954 bool frontMatch = closeEnough( lineChain.back(), other.front(), PROXIMITY_DELTA );
1955 bool backMatch = !frontMatch && closeEnough( lineChain.back(), other.back(), PROXIMITY_DELTA );
1959 std::reverse( other.begin(), other.end() );
1966 if( lineChain.back() == other.front() )
1967 lineChain.insert( lineChain.end(), other.begin() + 1, other.end() );
1969 lineChain.insert( lineChain.end(), other.begin(), other.end() );
1981 bool hasOutline =
false;
1984 std::set<SEG> edges;
1986 for(
const std::vector<VECTOR2I>& seg : aOutlineSegments )
1988 if( seg.size() < 2 )
1993 for(
size_t i = 0; i + 1 < seg.size(); i++ )
1995 SEG edge( seg[i], seg[i + 1] );
1997 if( !edges.insert( std::min( edge, edge.
Reversed() ) ).second )
2005 shape->
SetEnd( seg[i + 1] );
2006 aBoard->
Add( shape );
2016 if( w > 0 && h > 0 )
2025 for(
int i = 0; i < 4; i++ )
2032 shape->
SetEnd( corners[( i + 1 ) % 4] );
2033 aBoard->
Add( shape );
static std::optional< VECTOR2D > normalized(const VECTOR2D &aVec)
constexpr EDA_IU_SCALE pcbIUScale
#define DEFAULT_COURTYARD_WIDTH
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
BASE_SET & set(size_t pos)
virtual void SetNet(NETINFO_ITEM *aNetInfo)
Set a NET_INFO object for the item.
Abstract interface for BOARD_ITEMs capable of storing other items inside.
virtual void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false)=0
Adds an item to the container.
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
virtual const BOARD * GetBoard() const
Return the BOARD in which this BOARD_ITEM resides, or NULL if none.
BOARD_ITEM_CONTAINER * GetParent() const
Information pertinent to a Pcbnew printed circuit board.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
NETINFO_ITEM * FindOrAddNet(const wxString &aNetName, int aNetCode=-1, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false)
Return the net with the given name, adding it to the board if there is none.
const PAGE_INFO & GetPageSettings() const
const ZONES & Zones() const
const FOOTPRINTS & Footprints() const
void SetCopperLayerCount(int aCount)
BOX2I ComputeBoundingBox(bool aBoardEdgesOnly=false, bool aPhysicalLayersOnly=false) const
Calculate the bounding box containing all board items (or board edge segments).
const DRAWINGS & Drawings() const
constexpr BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
constexpr const Vec GetEnd() const
constexpr size_type GetWidth() const
constexpr const Vec GetCenter() const
constexpr size_type GetHeight() const
constexpr const Vec & GetOrigin() const
EDA_ANGLE Round(int digits) const
void AddItem(EDA_ITEM *aItem)
Add item to group.
virtual void SetParent(EDA_ITEM *aParent)
virtual void SetFilled(bool aFlag)
virtual void SetVisible(bool aVisible)
virtual void SetText(const wxString &aText)
A logical library item identifier and consists of various portions much like a URI.
LSET is a set of PCB_LAYER_IDs.
Handle the data for a net.
static constexpr PCB_LAYER_ID TEMP_ALL_LAYERS
! Temporary layer identifier to identify code that is not padstack-aware
static LSET PTHMask()
layer set for a through hole pad
const VECTOR2D GetSizeIU(double aIUScale) const
Gets the page size in internal units.
A set of BOARD_ITEMs (i.e., without duplicates).
void SetCenter(const VECTOR2I &aCenter) override
void SetWidth(int aWidth) override
void SetArcAngleAndEnd(const EDA_ANGLE &aAngle, bool aCheckNegativeAngle=false)
void SetShape(SHAPE_T aShape) override
void SetEnd(const VECTOR2I &aEnd) override
void SetPolyShape(const SHAPE_POLY_SET &aShape) override
void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
void SetStart(const VECTOR2I &aStart) override
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
void SetClosed(bool aClosed)
Mark the line chain as closed (i.e.
void Append(int aX, int aY, bool aAllowDuplication=false)
Append a new point at the end of the line chain.
Represent a set of closed polygons.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
void processPoly(BOARD_ITEM_CONTAINER *aContainer, const SPRINT_LAYOUT::OBJECT &aObj, std::vector< std::vector< VECTOR2I > > &aOutlineSegments, const uint8_t aGroundPlane[7], NETINFO_ITEM *aGndPlaneNet, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
std::unique_ptr< FOOTPRINT > CreateFootprint()
void parsePoints(SPRINT_LAYOUT::OBJECT &aObj)
wxString convertString(const std::string &aStr) const
void processCircle(BOARD_ITEM_CONTAINER *aContainer, const SPRINT_LAYOUT::OBJECT &aObj, std::vector< std::vector< VECTOR2I > > &aOutlineSegments, const uint8_t aGroundPlane[7], NETINFO_ITEM *aGndPlaneNet, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
SPRINT_LAYOUT::FILE_DATA m_fileData
bool CreateBoard(BOARD &aBoard, std::map< wxString, std::unique_ptr< FOOTPRINT > > &aFootprintMap, size_t aBoardIndex=0)
PCB_LAYER_ID mapLayer(uint8_t aSprintLayer) const
void parseFileStart(const wxString &aFileName)
std::string readFixedString(size_t aMaxLen)
void processItemGroups(BOARD_ITEM *aItem, const SPRINT_LAYOUT::OBJECT &aObj, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
NETINFO_ITEM * resolveItemNet(BOARD *aBoard, const SPRINT_LAYOUT::OBJECT &aObj, PCB_LAYER_ID aLayer, const uint8_t aGroundPlane[7], NETINFO_ITEM *aGndPlaneNet) const
void processSegment(BOARD_ITEM_CONTAINER *aContainer, const SPRINT_LAYOUT::OBJECT &aObj, std::vector< std::vector< VECTOR2I > > &aOutlineSegments, const uint8_t aGroundPlane[7], NETINFO_ITEM *aGndPlaneNet, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
void buildOutline(BOARD *aBoard, std::vector< std::vector< VECTOR2I > > &aOutlineSegments, const SPRINT_LAYOUT::BOARD_DATA &aBoardData)
void processText(BOARD_ITEM_CONTAINER *aContainer, const SPRINT_LAYOUT::OBJECT &aObj, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
void parseGroups(SPRINT_LAYOUT::OBJECT &aObj)
void resolveGroups(BOARD_ITEM_CONTAINER *aContainer, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
void parseObject(SPRINT_LAYOUT::OBJECT &aObject, bool aIsTextChild=false)
void parseBoardHeader(SPRINT_LAYOUT::BOARD_DATA &aBoard)
void processPad(BOARD_ITEM_CONTAINER *aContainer, const SPRINT_LAYOUT::OBJECT &aObj, const uint8_t aGroundPlane[7], NETINFO_ITEM *aGndPlaneNet, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
VECTOR2I sprintToKicadPos(float aX, float aY) const
int sprintToKicadCoord(float aValue) const
void parseObjectsList(SPRINT_LAYOUT::BOARD_DATA &aBoard)
bool ParseMacroFile(const wxString &aFileName)
std::vector< uint8_t > m_buffer
bool layerHasGroundPlane(PCB_LAYER_ID aLayer, const uint8_t aGroundPlane[7]) const
std::string readVarString()
void processLine(BOARD_ITEM_CONTAINER *aContainer, const SPRINT_LAYOUT::OBJECT &aObj, std::vector< std::vector< VECTOR2I > > &aOutlineSegments, const uint8_t aGroundPlane[7], NETINFO_ITEM *aGndPlaneNet, std::map< uint32_t, std::set< BOARD_ITEM * > > &aGidToItems)
bool ParseBoard(const wxString &aFileName)
Handle a list of polygons defining a copper zone.
void SetDoNotAllowPads(bool aEnable)
void SetLocalClearance(std::optional< int > aClearance)
void AddPolygon(std::vector< VECTOR2I > &aPolygon)
Add a polygon to the zone outline.
void SetBorderDisplayStyle(ZONE_BORDER_DISPLAY_STYLE aBorderHatchStyle, int aBorderHatchPitch, bool aRebuildBorderHatch)
Set all hatch parameters for the zone.
void SetThermalReliefSpokeWidth(int aThermalReliefSpokeWidth)
virtual void SetLayer(PCB_LAYER_ID aLayer) override
Set the layer this item is on.
void SetIsRuleArea(bool aEnable)
void SetDoNotAllowTracks(bool aEnable)
void SetLayerSet(const LSET &aLayerSet) override
void SetDoNotAllowVias(bool aEnable)
void SetNet(NETINFO_ITEM *aNetInfo) override
Override that drops aNetInfo when this zone is in copper-thieving fill mode.
void SetThermalReliefGap(int aThermalReliefGap)
void SetDoNotAllowFootprints(bool aEnable)
void SetDoNotAllowZoneFills(bool aEnable)
void SetAssignedPriority(unsigned aPriority)
void SetZoneName(const wxString &aName)
void SetIslandRemovalMode(ISLAND_REMOVAL_MODE aRemove)
static int GetDefaultHatchPitch()
static constexpr EDA_ANGLE ANGLE_90
static constexpr EDA_ANGLE ANGLE_45
static constexpr EDA_ANGLE ANGLE_180
@ RECTANGLE
Use RECTANGLE instead of RECT to avoid collision in a Windows header.
#define THROW_IO_ERROR(msg)
macro which captures the "call site" values of FILE_, __FUNCTION & LINE
#define THROW_IO_ERRORF(msg,...)
bool IsBackLayer(PCB_LAYER_ID aLayerId)
Layer classification: check if it's a back layer.
bool IsCopperLayer(int aLayerId)
Test whether a layer is a copper layer.
PCB_LAYER_ID
A quick note on layer IDs:
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
@ SMD
Smd pad, appears on the solder paste layer (default)
@ PTH
Plated through hole pad.
Class to handle a set of BOARD_ITEMs.
static constexpr uint32_t MAX_CHILDREN
static constexpr uint32_t MAX_GROUPS
static constexpr uint32_t MAX_OBJECTS
static constexpr uint32_t MAX_POINTS
std::vector< OBJECT > objects
std::vector< POINT > points
std::vector< OBJECT > text_children
std::vector< uint32_t > groups
@ DESCRIPTION
Field Description of part, i.e. "1/4W 1% Metal Film Resistor".
GR_TEXT_H_ALIGN_T
This is API surface mapped to common.types.HorizontalAlignment.
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.
VECTOR2< int32_t > VECTOR2I
VECTOR2< double > VECTOR2D
@ THERMAL
Use thermal relief for pads.
@ NONE
Pads are not covered.
@ FULL
pads are covered by copper