KiCad PCB EDA Suite
Loading...
Searching...
No Matches
altium_parser_pcb.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2020 Thomas Pointhuber <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25#include <map>
26#include <unordered_map>
27
28#include <ki_exception.h>
29#include <math/util.h>
30
31#include <wx/log.h>
32
33#include "altium_parser_pcb.h"
36
37
38ALTIUM_LAYER altium_layer_from_name( const wxString& aName )
39{
40 static const std::unordered_map<std::string, ALTIUM_LAYER> hash_map = {
41 { "TOP", ALTIUM_LAYER::TOP_LAYER },
42 { "MID1", ALTIUM_LAYER::MID_LAYER_1 },
43 { "MID2", ALTIUM_LAYER::MID_LAYER_2 },
44 { "MID3", ALTIUM_LAYER::MID_LAYER_3 },
45 { "MID4", ALTIUM_LAYER::MID_LAYER_4 },
46 { "MID5", ALTIUM_LAYER::MID_LAYER_5 },
47 { "MID6", ALTIUM_LAYER::MID_LAYER_6 },
48 { "MID7", ALTIUM_LAYER::MID_LAYER_7 },
49 { "MID8", ALTIUM_LAYER::MID_LAYER_8 },
50 { "MID9", ALTIUM_LAYER::MID_LAYER_9 },
51 { "MID10", ALTIUM_LAYER::MID_LAYER_10 },
52 { "MID11", ALTIUM_LAYER::MID_LAYER_11 },
53 { "MID12", ALTIUM_LAYER::MID_LAYER_12 },
54 { "MID13", ALTIUM_LAYER::MID_LAYER_13 },
55 { "MID14", ALTIUM_LAYER::MID_LAYER_14 },
56 { "MID15", ALTIUM_LAYER::MID_LAYER_15 },
57 { "MID16", ALTIUM_LAYER::MID_LAYER_16 },
58 { "MID17", ALTIUM_LAYER::MID_LAYER_17 },
59 { "MID18", ALTIUM_LAYER::MID_LAYER_18 },
60 { "MID19", ALTIUM_LAYER::MID_LAYER_19 },
61 { "MID20", ALTIUM_LAYER::MID_LAYER_20 },
62 { "MID21", ALTIUM_LAYER::MID_LAYER_21 },
63 { "MID22", ALTIUM_LAYER::MID_LAYER_22 },
64 { "MID23", ALTIUM_LAYER::MID_LAYER_23 },
65 { "MID24", ALTIUM_LAYER::MID_LAYER_24 },
66 { "MID25", ALTIUM_LAYER::MID_LAYER_25 },
67 { "MID26", ALTIUM_LAYER::MID_LAYER_26 },
68 { "MID27", ALTIUM_LAYER::MID_LAYER_27 },
69 { "MID28", ALTIUM_LAYER::MID_LAYER_28 },
70 { "MID29", ALTIUM_LAYER::MID_LAYER_29 },
71 { "MID30", ALTIUM_LAYER::MID_LAYER_30 },
72 { "BOTTOM", ALTIUM_LAYER::BOTTOM_LAYER },
73
74 { "TOPOVERLAY", ALTIUM_LAYER::TOP_OVERLAY },
75 { "BOTTOMOVERLAY", ALTIUM_LAYER::BOTTOM_OVERLAY },
76 { "TOPPASTE", ALTIUM_LAYER::TOP_PASTE },
77 { "BOTTOMPASTE", ALTIUM_LAYER::BOTTOM_PASTE },
78 { "TOPSOLDER", ALTIUM_LAYER::TOP_SOLDER },
79 { "BOTTOMSOLDER", ALTIUM_LAYER::BOTTOM_SOLDER },
80
97
98 { "DRILLGUIDE", ALTIUM_LAYER::DRILL_GUIDE },
99 { "KEEPOUT", ALTIUM_LAYER::KEEP_OUT_LAYER },
100
101 { "MECHANICAL1", ALTIUM_LAYER::MECHANICAL_1 },
102 { "MECHANICAL2", ALTIUM_LAYER::MECHANICAL_2 },
103 { "MECHANICAL3", ALTIUM_LAYER::MECHANICAL_3 },
104 { "MECHANICAL4", ALTIUM_LAYER::MECHANICAL_4 },
105 { "MECHANICAL5", ALTIUM_LAYER::MECHANICAL_5 },
106 { "MECHANICAL6", ALTIUM_LAYER::MECHANICAL_6 },
107 { "MECHANICAL7", ALTIUM_LAYER::MECHANICAL_7 },
108 { "MECHANICAL8", ALTIUM_LAYER::MECHANICAL_8 },
109 { "MECHANICAL9", ALTIUM_LAYER::MECHANICAL_9 },
110 { "MECHANICAL10", ALTIUM_LAYER::MECHANICAL_10 },
111 { "MECHANICAL11", ALTIUM_LAYER::MECHANICAL_11 },
112 { "MECHANICAL12", ALTIUM_LAYER::MECHANICAL_12 },
113 { "MECHANICAL13", ALTIUM_LAYER::MECHANICAL_13 },
114 { "MECHANICAL14", ALTIUM_LAYER::MECHANICAL_14 },
115 { "MECHANICAL15", ALTIUM_LAYER::MECHANICAL_15 },
116 { "MECHANICAL16", ALTIUM_LAYER::MECHANICAL_16 },
117
118 { "DRILLDRAWING", ALTIUM_LAYER::DRILL_DRAWING },
119 { "MULTILAYER", ALTIUM_LAYER::MULTI_LAYER },
120
121 // FIXME: the following mapping is just a guess
122 { "CONNECTIONS", ALTIUM_LAYER::CONNECTIONS },
123 { "BACKGROUND", ALTIUM_LAYER::BACKGROUND },
124 { "DRCERRORMARKERS", ALTIUM_LAYER::DRC_ERROR_MARKERS },
125 { "SELECTIONS", ALTIUM_LAYER::SELECTIONS },
126 { "VISIBLEGRID1", ALTIUM_LAYER::VISIBLE_GRID_1 },
127 { "VISIBLEGRID2", ALTIUM_LAYER::VISIBLE_GRID_2 },
128 { "PADHOLES", ALTIUM_LAYER::PAD_HOLES },
129 { "VIAHOLES", ALTIUM_LAYER::VIA_HOLES },
130 };
131
132 auto it = hash_map.find( std::string( aName.c_str() ) );
133
134 if( it == hash_map.end() )
135 {
136 wxLogError( _( "Unknown mapping of the Altium layer '%s'." ), aName );
138 }
139 else
140 {
141 return it->second;
142 }
143}
144
145void altium_parse_polygons( std::map<wxString, wxString>& aProps,
146 std::vector<ALTIUM_VERTICE>& aVertices )
147{
148 for( size_t i = 0; i < std::numeric_limits<size_t>::max(); i++ )
149 {
150 const wxString si = std::to_string( i );
151
152 const wxString vxi = wxT( "VX" ) + si;
153 const wxString vyi = wxT( "VY" ) + si;
154
155 if( aProps.find( vxi ) == aProps.end() || aProps.find( vyi ) == aProps.end() )
156 break; // it doesn't seem like we know beforehand how many vertices are inside a polygon
157
158 const bool isRound = ALTIUM_PROPS_UTILS::ReadInt( aProps, wxT( "KIND" ) + si, 0 ) != 0;
159 const int32_t radius = ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, wxT( "R" ) + si, wxT( "0mil" ) );
160 const double sa = ALTIUM_PROPS_UTILS::ReadDouble( aProps, wxT( "SA" ) + si, 0. );
161 const double ea = ALTIUM_PROPS_UTILS::ReadDouble( aProps, wxT( "EA" ) + si, 0. );
162 const VECTOR2I vp = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, vxi, wxT( "0mil" ) ),
163 -ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, vyi, wxT( "0mil" ) ) );
164 const VECTOR2I cp = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, wxT( "CX" ) + si, wxT( "0mil" ) ),
165 -ALTIUM_PROPS_UTILS::ReadKicadUnit( aProps, wxT( "CY" ) + si, wxT( "0mil" ) ) );
166
167 aVertices.emplace_back( isRound, radius, sa, ea, vp, cp );
168 }
169}
170
171
172static ALTIUM_MODE ReadAltiumModeFromProperties( const std::map<wxString, wxString>& aProps,
173 wxString aKey )
174{
175 wxString mode = ALTIUM_PROPS_UTILS::ReadString( aProps, aKey, wxT( "" ) );
176
177 if( mode == wxT( "None" ) )
178 return ALTIUM_MODE::NONE;
179 else if( mode == wxT( "Rule" ) )
180 return ALTIUM_MODE::RULE;
181 else if( mode == wxT( "Manual" ) )
182 return ALTIUM_MODE::MANUAL;
183
184 wxLogError( _( "Unknown Mode string: '%s'." ), mode );
186}
187
188
189static ALTIUM_RECORD ReadAltiumRecordFromProperties( const std::map<wxString, wxString>& aProps,
190 wxString aKey )
191{
192 wxString record = ALTIUM_PROPS_UTILS::ReadString( aProps, aKey, wxT( "" ) );
193
194 if( record == wxT( "Arc" ) )
195 return ALTIUM_RECORD::ARC;
196 else if( record == wxT( "Pad" ) )
197 return ALTIUM_RECORD::PAD;
198 else if( record == wxT( "Via" ) )
199 return ALTIUM_RECORD::VIA;
200 else if( record == wxT( "Track" ) )
202 else if( record == wxT( "Text" ) )
203 return ALTIUM_RECORD::TEXT;
204 else if( record == wxT( "Fill" ) )
205 return ALTIUM_RECORD::FILL;
206 else if( record == wxT( "Region" ) ) // correct?
208 else if( record == wxT( "Model" ) )
210
211 wxLogError( _( "Unknown Record name string: '%s'." ), record );
213}
214
215
218 const std::map<wxString, wxString>& aProps, wxString aKey )
219{
220 wxString parsedType = ALTIUM_PROPS_UTILS::ReadString( aProps, aKey, wxT( "" ) );
221
222 if( parsedType == wxT( "Mask" ) )
224
225 wxLogError( _( "Unknown Extended Primitive Information type: '%s'." ), parsedType );
227}
228
229
238static void ExpectSubrecordLengthAtLeast( const std::string& aStreamType,
239 const std::string& aSubrecordName, size_t aExpectedLength,
240 size_t aActualLength )
241{
242 if( aActualLength < aExpectedLength )
243 {
244 THROW_IO_ERROR( wxString::Format( "%s stream %s has length %d, "
245 "which is unexpected (expected at least %d)",
246 aStreamType, aSubrecordName, aActualLength,
247 aExpectedLength ) );
248 }
249}
250
251
253{
254 const std::map<wxString, wxString> props = aReader.ReadProperties();
255
256 if( props.empty() )
257 THROW_IO_ERROR( wxT( "ExtendedPrimitiveInformation stream has no properties!" ) );
258
259 primitiveIndex = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "PRIMITIVEINDEX" ), -1 );
260 primitiveObjectId = ReadAltiumRecordFromProperties( props, wxT( "PRIMITIVEOBJECTID" ) );
262
263 pastemaskexpansionmode = ReadAltiumModeFromProperties( props, wxT( "PASTEMASKEXPANSIONMODE" ) );
265 props, wxT( "PASTEMASKEXPANSION_MANUAL" ), wxT( "0mil" ) );
267 ReadAltiumModeFromProperties( props, wxT( "SOLDERMASKEXPANSIONMODE" ) );
269 props, wxT( "SOLDERMASKEXPANSION_MANUAL" ), wxT( "0mil" ) );
270}
271
272
274{
275 std::map<wxString, wxString> props = aReader.ReadProperties();
276
277 if( props.empty() )
278 THROW_IO_ERROR( wxT( "Board6 stream has no properties!" ) );
279
280 sheetpos = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETX" ), wxT( "0mil" ) ),
281 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETY" ), wxT( "0mil" ) ) );
282 sheetsize = wxSize( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETWIDTH" ), wxT( "0mil" ) ),
283 ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "SHEETHEIGHT" ), wxT( "0mil" ) ) );
284
285 layercount = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "LAYERSETSCOUNT" ), 1 ) + 1;
286
287 for( size_t i = 1; i < std::numeric_limits<size_t>::max(); i++ )
288 {
289 const wxString layeri = wxT( "LAYER" ) + wxString( std::to_string( i ) );
290 const wxString layername = layeri + wxT( "NAME" );
291
292 auto layernameit = props.find( layername );
293
294 if( layernameit == props.end() )
295 break; // it doesn't seem like we know beforehand how many vertices are inside a polygon
296
298
299 l.name = ALTIUM_PROPS_UTILS::ReadString( props, layername, wxT( "" ) );
300 wxString originalName = l.name;
301 int ii = 2;
302
303 // Ensure that layer names are unique in KiCad
304 while( !layerNames.insert( l.name ).second )
305 l.name = wxString::Format( wxT( "%s %d" ), originalName, ii++ );
306
307 l.nextId = ALTIUM_PROPS_UTILS::ReadInt( props, layeri + wxT( "NEXT" ), 0 );
308 l.prevId = ALTIUM_PROPS_UTILS::ReadInt( props, layeri + wxT( "PREV" ), 0 );
309 l.copperthick = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, layeri + wxT( "COPTHICK" ), wxT( "1.4mil" ) );
310
311 l.dielectricconst = ALTIUM_PROPS_UTILS::ReadDouble( props, layeri + wxT( "DIELCONST" ), 0. );
312 l.dielectricthick = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, layeri + wxT( "DIELHEIGHT" ), wxT( "60mil" ) );
313 l.dielectricmaterial = ALTIUM_PROPS_UTILS::ReadString( props, layeri + wxT( "DIELMATERIAL" ), wxT( "FR-4" ) );
314
315 stackup.push_back( l );
316 }
317
319
320 if( aReader.HasParsingError() )
321 THROW_IO_ERROR( wxT( "Board6 stream was not parsed correctly!" ) );
322}
323
325{
326 std::map<wxString, wxString> properties = aReader.ReadProperties();
327
328 if( properties.empty() )
329 THROW_IO_ERROR( wxT( "Classes6 stream has no properties!" ) );
330
331 name = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "NAME" ), wxT( "" ) );
332 uniqueid = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "UNIQUEID" ), wxT( "" ) );
333 kind = static_cast<ALTIUM_CLASS_KIND>( ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "KIND" ), -1 ) );
334
335 for( size_t i = 0; i < std::numeric_limits<size_t>::max(); i++ )
336 {
337 auto mit = properties.find( wxT( "M" ) + wxString( std::to_string( i ) ) );
338
339 if( mit == properties.end() )
340 break; // it doesn't seem like we know beforehand how many components are in the netclass
341
342 names.push_back( mit->second );
343 }
344
345 if( aReader.HasParsingError() )
346 THROW_IO_ERROR( wxT( "Classes6 stream was not parsed correctly" ) );
347}
348
350{
351 std::map<wxString, wxString> props = aReader.ReadProperties();
352
353 if( props.empty() )
354 THROW_IO_ERROR( wxT( "Components6 stream has no props" ) );
355
356 layer = altium_layer_from_name( ALTIUM_PROPS_UTILS::ReadString( props, wxT( "LAYER" ), wxT( "" ) ) );
357 position = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "X" ), wxT( "0mil" ) ),
358 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "Y" ), wxT( "0mil" ) ) );
359 rotation = ALTIUM_PROPS_UTILS::ReadDouble( props, wxT( "ROTATION" ), 0. );
360 locked = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "LOCKED" ), false );
361 nameon = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "NAMEON" ), true );
362 commenton = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "COMMENTON" ), false );
363 sourcedesignator = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SOURCEDESIGNATOR" ), wxT( "" ) );
364
366 ALTIUM_PROPS_UTILS::ReadUnicodeString( props, wxT( "SOURCEFOOTPRINTLIBRARY" ), wxT( "" ) );
367 pattern = ALTIUM_PROPS_UTILS::ReadUnicodeString( props, wxT( "PATTERN" ), wxT( "" ) );
368
369 sourcecomponentlibrary = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SOURCECOMPONENTLIBRARY" ), wxT( "" ) );
370 sourcelibreference = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SOURCELIBREFERENCE" ), wxT( "" ) );
371
373 ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "NAMEAUTOPOSITION" ), 0 ) );
375 ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "COMMENTAUTOPOSITION" ), 0 ) );
376
377 if( aReader.HasParsingError() )
378 THROW_IO_ERROR( wxT( "Components6 stream was not parsed correctly" ) );
379}
380
382{
383 aReader.Skip( 2 );
384
385 std::map<wxString, wxString> props = aReader.ReadProperties();
386
387 if( props.empty() )
388 THROW_IO_ERROR( wxT( "Dimensions6 stream has no props" ) );
389
390 layer = altium_layer_from_name( ALTIUM_PROPS_UTILS::ReadString( props, wxT( "LAYER" ), wxT( "" ) ) );
391 kind = static_cast<ALTIUM_DIMENSION_KIND>( ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "DIMENSIONKIND" ), 0 ) );
392
393 textformat = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTFORMAT" ), wxT( "" ) );
394 textprefix = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTPREFIX" ), wxT( "" ) );
395 textsuffix = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTSUFFIX" ), wxT( "" ) );
396
397 height = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "HEIGHT" ), wxT( "0mil" ) );
398 angle = ALTIUM_PROPS_UTILS::ReadDouble( props, wxT( "ANGLE" ), 0. );
399
400 linewidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "LINEWIDTH" ), wxT( "10mil" ) );
401 textheight = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "TEXTHEIGHT" ), wxT( "10mil" ) );
402 textlinewidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "TEXTLINEWIDTH" ), wxT( "6mil" ) );
403 textprecision = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "TEXTPRECISION" ), 2 );
404 textbold = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "TEXTLINEWIDTH" ), false );
405 textitalic = ALTIUM_PROPS_UTILS::ReadBool( props, wxT( "ITALIC" ), false );
406 textgap = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "TEXTGAP" ), wxT( "10mil" ) );
407
408 arrowsize = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "ARROWSIZE" ), wxT( "60mil" ) );
409
410 wxString text_position_raw = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTPOSITION" ), wxT( "" ) );
411
412 xy1 = VECTOR2I( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "X1" ), wxT( "0mil" ) ),
413 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "Y1" ), wxT( "0mil" ) ) );
414
415 int refcount = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "REFERENCES_COUNT" ), 0 );
416
417 for( int i = 0; i < refcount; i++ )
418 {
419 const std::string refi = "REFERENCE" + std::to_string( i ) + "POINT";
420 const wxString ref( refi );
421 referencePoint.emplace_back( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, ref + wxT( "X" ), wxT( "0mil" ) ),
422 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, ref + wxT( "Y" ), wxT( "0mil" ) ) );
423 }
424
425 for( size_t i = 1; i < std::numeric_limits<size_t>::max(); i++ )
426 {
427 const std::string texti = "TEXT" + std::to_string( i );
428 const std::string textix = texti + "X";
429 const std::string textiy = texti + "Y";
430
431 if( props.find( textix ) == props.end() || props.find( textiy ) == props.end() )
432 break; // it doesn't seem like we know beforehand how many vertices are inside a polygon
433
434 textPoint.emplace_back( ALTIUM_PROPS_UTILS::ReadKicadUnit( props, textix, wxT( "0mil" ) ),
435 -ALTIUM_PROPS_UTILS::ReadKicadUnit( props, textiy, wxT( "0mil" ) ) );
436 }
437
438 wxString dimensionunit = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "TEXTDIMENSIONUNIT" ), wxT( "Millimeters" ) );
439
440 if( dimensionunit == wxT( "Inches" ) ) textunit = ALTIUM_UNIT::INCHES;
441 else if( dimensionunit == wxT( "Mils" ) ) textunit = ALTIUM_UNIT::MILS;
442 else if( dimensionunit == wxT( "Millimeters" ) ) textunit = ALTIUM_UNIT::MILLIMETERS;
443 else if( dimensionunit == wxT( "Centimeters" ) ) textunit = ALTIUM_UNIT::CENTIMETER;
444 else textunit = ALTIUM_UNIT::UNKNOWN;
445
446 if( aReader.HasParsingError() )
447 THROW_IO_ERROR( wxT( "Dimensions6 stream was not parsed correctly" ) );
448}
449
451{
452 std::map<wxString, wxString> properties = aReader.ReadProperties();
453
454 if( properties.empty() )
455 THROW_IO_ERROR( wxT( "Model stream has no properties!" ) );
456
457 name = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "NAME" ), wxT( "" ) );
458 id = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "ID" ), wxT( "" ) );
459 isEmbedded = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "EMBED" ), false );
460
461 rotation.x = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "ROTX" ), 0. );
462 rotation.y = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "ROTY" ), 0. );
463 rotation.z = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "ROTZ" ), 0. );
464
465 z_offset = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "DZ" ), 0. );
466 checksum = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "CHECKSUM" ), 0 );
467
468 if( aReader.HasParsingError() )
469 THROW_IO_ERROR( wxT( "Model stream was not parsed correctly" ) );
470}
471
473{
474 std::map<wxString, wxString> properties = aReader.ReadProperties();
475
476 if( properties.empty() )
477 THROW_IO_ERROR( wxT( "Nets6 stream has no properties" ) );
478
479 name = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "NAME" ), wxT( "" ) );
480
481 if( aReader.HasParsingError() )
482 THROW_IO_ERROR( wxT( "Nets6 stream was not parsed correctly" ) );
483}
484
486{
487 std::map<wxString, wxString> properties = aReader.ReadProperties();
488
489 if( properties.empty() )
490 THROW_IO_ERROR( wxT( "Polygons6 stream has no properties" ) );
491
492 layer = altium_layer_from_name( ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "LAYER" ), wxT( "" ) ) );
493 net = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "NET" ), ALTIUM_NET_UNCONNECTED );
494 locked = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "LOCKED" ), false );
495
496 // TODO: kind
497
498 gridsize = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "GRIDSIZE" ), wxT( "0mil" ) );
499 trackwidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "TRACKWIDTH" ), wxT( "0mil" ) );
500 minprimlength = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MINPRIMLENGTH" ), wxT( "0mil" ) );
501 useoctagons = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "USEOCTAGONS" ), false );
502
503 pourindex = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "POURINDEX" ), 0 );
504
505 wxString hatchstyleraw = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "HATCHSTYLE" ), wxT( "" ) );
506
507 if( hatchstyleraw == wxT( "Solid" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::SOLID;
508 else if( hatchstyleraw == wxT( "45Degree" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::DEGREE_45;
509 else if( hatchstyleraw == wxT( "90Degree" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::DEGREE_90;
510 else if( hatchstyleraw == wxT( "Horizontal" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::HORIZONTAL;
511 else if( hatchstyleraw == wxT( "Vertical" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::VERTICAL;
512 else if( hatchstyleraw == wxT( "None" ) ) hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::NONE;
513 else hatchstyle = ALTIUM_POLYGON_HATCHSTYLE::UNKNOWN;
514
515 altium_parse_polygons( properties, vertices );
516
517 if( aReader.HasParsingError() )
518 THROW_IO_ERROR( wxT( "Polygons6 stream was not parsed correctly" ) );
519}
520
522{
523 aReader.Skip( 2 );
524
525 std::map<wxString, wxString> props = aReader.ReadProperties();
526
527 if( props.empty() )
528 THROW_IO_ERROR( wxT( "Rules6 stream has no props" ) );
529
530 name = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "NAME" ), wxT( "" ) );
531 priority = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "PRIORITY" ), 1 );
532
533 scope1expr = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SCOPE1EXPRESSION" ), wxT( "" ) );
534 scope2expr = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "SCOPE2EXPRESSION" ), wxT( "" ) );
535
536 wxString rulekind = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "RULEKIND" ), wxT( "" ) );
537 if( rulekind == wxT( "Clearance" ) )
538 {
539 kind = ALTIUM_RULE_KIND::CLEARANCE;
540 clearanceGap = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "GAP" ), wxT( "10mil" ) );
541 }
542 else if( rulekind == wxT( "DiffPairsRouting" ) )
543 {
544 kind = ALTIUM_RULE_KIND::DIFF_PAIR_ROUTINGS;
545 }
546 else if( rulekind == wxT( "Height" ) )
547 {
548 kind = ALTIUM_RULE_KIND::HEIGHT;
549 }
550 else if( rulekind == wxT( "HoleSize" ) )
551 {
552 kind = ALTIUM_RULE_KIND::HOLE_SIZE;
553 minLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINLIMIT" ), wxT( "1mil" ) );
554 maxLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXLIMIT" ), wxT( "150mil" ) );
555 }
556 else if( rulekind == wxT( "HoleToHoleClearance" ) )
557 {
558 kind = ALTIUM_RULE_KIND::HOLE_TO_HOLE_CLEARANCE;
559 clearanceGap = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "GAP" ), wxT( "10mil" ) );
560 }
561 else if( rulekind == wxT( "RoutingVias" ) )
562 {
563 kind = ALTIUM_RULE_KIND::ROUTING_VIAS;
564 width = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "WIDTH" ), wxT( "20mil" ) );
565 minWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINWIDTH" ), wxT( "20mil" ) );
566 maxWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXWIDTH" ), wxT( "50mil" ) );
567 holeWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "HOLEWIDTH" ), wxT( "10mil" ) );
568 minHoleWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINHOLEWIDTH" ), wxT( "10mil" ) );
569 maxHoleWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXHOLEWIDTH" ), wxT( "28mil" ) );
570 }
571 else if( rulekind == wxT( "Width" ) )
572 {
573 kind = ALTIUM_RULE_KIND::WIDTH;
574 minLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MINLIMIT" ), wxT( "6mil" ) );
575 maxLimit = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "MAXLIMIT" ), wxT( "40mil" ) );
576 preferredWidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "PREFERREDWIDTH" ), wxT( "6mil" ) );
577}
578 else if( rulekind == wxT( "PasteMaskExpansion" ) )
579 {
580 kind = ALTIUM_RULE_KIND::PASTE_MASK_EXPANSION;
581 pastemaskExpansion = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "EXPANSION" ), wxT( "0" ) );
582 }
583 else if( rulekind == wxT( "SolderMaskExpansion" ) )
584 {
585 kind = ALTIUM_RULE_KIND::SOLDER_MASK_EXPANSION;
586 soldermaskExpansion = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "EXPANSION" ), wxT( "4mil" ) );
587 }
588 else if( rulekind == wxT( "PlaneClearance" ) )
589 {
590 kind = ALTIUM_RULE_KIND::PLANE_CLEARANCE;
591 planeclearanceClearance = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "CLEARANCE" ), wxT( "10mil" ) );
592 }
593 else if( rulekind == wxT( "PolygonConnect" ) )
594 {
595 kind = ALTIUM_RULE_KIND::POLYGON_CONNECT;
596 polygonconnectAirgapwidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "AIRGAPWIDTH" ), wxT( "10mil" ) );
597 polygonconnectReliefconductorwidth = ALTIUM_PROPS_UTILS::ReadKicadUnit( props, wxT( "RELIEFCONDUCTORWIDTH" ), wxT( "10mil" ) );
598 polygonconnectReliefentries = ALTIUM_PROPS_UTILS::ReadInt( props, wxT( "RELIEFENTRIES" ), 4 );
599
600 wxString style = ALTIUM_PROPS_UTILS::ReadString( props, wxT( "CONNECTSTYLE" ), wxT( "" ) );
601
602 if( style == wxT( "Direct" ) ) polygonconnectStyle = ALTIUM_CONNECT_STYLE::DIRECT;
603 else if( style == wxT( "Relief" ) ) polygonconnectStyle = ALTIUM_CONNECT_STYLE::RELIEF;
604 else if( style == wxT( "NoConnect" ) ) polygonconnectStyle = ALTIUM_CONNECT_STYLE::NONE;
605 else polygonconnectStyle = ALTIUM_CONNECT_STYLE::UNKNOWN;
606 }
607 else
608 {
609 kind = ALTIUM_RULE_KIND::UNKNOWN;
610 }
611
612 if( aReader.HasParsingError() )
613 THROW_IO_ERROR( wxT( "Rules6 stream was not parsed correctly" ) );
614}
615
617{
618 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
619 if( recordtype != ALTIUM_RECORD::ARC )
620 {
621 THROW_IO_ERROR( wxT( "Arcs6 stream has invalid recordtype" ) );
622 }
623
624 // Subrecord 1
626
627 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
628
629 uint8_t flags1 = aReader.Read<uint8_t>();
630 is_locked = ( flags1 & 0x04 ) == 0;
631 is_polygonoutline = ( flags1 & 0x02 ) != 0;
632
633 uint8_t flags2 = aReader.Read<uint8_t>();
634 is_keepout = flags2 == 2;
635
636 net = aReader.Read<uint16_t>();
637 polygon = aReader.Read<uint16_t>();
638 component = aReader.Read<uint16_t>();
639 aReader.Skip( 4 );
640 center = aReader.ReadVector2IPos();
641 radius = aReader.ReadKicadUnit();
642 startangle = aReader.Read<double>();
643 endangle = aReader.Read<double>();
644 width = aReader.ReadKicadUnit();
645 subpolyindex = aReader.Read<uint16_t>();
646
647 if( aReader.GetRemainingSubrecordBytes() >= 10 )
648 {
649 aReader.Skip( 9 );
650 keepoutrestrictions = aReader.Read<uint8_t>();
651 }
652 else
653 {
654 keepoutrestrictions = is_keepout ? 0x1F : 0;
655 }
656
657 aReader.SkipSubrecord();
658
659 if( aReader.HasParsingError() )
660 {
661 THROW_IO_ERROR( wxT( "Arcs6 stream was not parsed correctly" ) );
662 }
663}
664
666{
667 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
668
669 if( recordtype != ALTIUM_RECORD::MODEL )
670 THROW_IO_ERROR( wxT( "ComponentsBodies6 stream has invalid recordtype" ) );
671
673
674 aReader.Skip( 7 );
675 component = aReader.Read<uint16_t>();
676 aReader.Skip( 9 );
677
678 std::map<wxString, wxString> properties = aReader.ReadProperties();
679
680 if( properties.empty() )
681 THROW_IO_ERROR( wxT( "ComponentsBodies6 stream has no properties" ) );
682
683 modelName = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "MODEL.NAME" ), wxT( "" ) );
684 modelId = ALTIUM_PROPS_UTILS::ReadString( properties, wxT( "MODELID" ), wxT( "" ) );
685 modelIsEmbedded = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "MODEL.EMBED" ), false );
686
687 modelPosition.x = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MODEL.2D.X" ), wxT( "0mil" ) );
688 modelPosition.y = -ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MODEL.2D.Y" ), wxT( "0mil" ) );
689 modelPosition.z = ALTIUM_PROPS_UTILS::ReadKicadUnit( properties, wxT( "MODEL.3D.DZ" ), wxT( "0mil" ) );
690
691 modelRotation.x = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.3D.ROTX" ), 0. );
692 modelRotation.y = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.3D.ROTY" ), 0. );
693 modelRotation.z = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.3D.ROTZ" ), 0. );
694
695 rotation = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "MODEL.2D.ROTATION" ), 0. );
696
697 body_opacity_3d = ALTIUM_PROPS_UTILS::ReadDouble( properties, wxT( "BODYOPACITY3D" ), 1. );
698
699 aReader.SkipSubrecord();
700
701 if( aReader.HasParsingError() )
702 THROW_IO_ERROR( wxT( "Components6 stream was not parsed correctly" ) );
703}
704
706{
707 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
708
709 if( recordtype != ALTIUM_RECORD::PAD )
710 THROW_IO_ERROR( wxT( "Pads6 stream has invalid recordtype" ) );
711
712 // Subrecord 1
713 size_t subrecord1 = aReader.ReadAndSetSubrecordLength();
714
715 if( subrecord1 == 0 )
716 THROW_IO_ERROR( wxT( "Pads6 stream has no subrecord1 data" ) );
717
718 name = aReader.ReadWxString();
719
720 if( aReader.GetRemainingSubrecordBytes() != 0 )
721 THROW_IO_ERROR( wxT( "Pads6 stream has invalid subrecord1 length" ) );
722
723 aReader.SkipSubrecord();
724
725 // Subrecord 2
727 aReader.SkipSubrecord();
728
729 // Subrecord 3
731 aReader.SkipSubrecord();
732
733 // Subrecord 4
735 aReader.SkipSubrecord();
736
737 // Subrecord 5
738 size_t subrecord5 = aReader.ReadAndSetSubrecordLength();
739
740 ExpectSubrecordLengthAtLeast( "Pads6", "subrecord5", 110, subrecord5 );
741
742 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
743 tolayer = ALTIUM_LAYER::UNKNOWN;
744 fromlayer = ALTIUM_LAYER::UNKNOWN;
745
746 uint8_t flags1 = aReader.Read<uint8_t>();
747 is_test_fab_top = ( flags1 & 0x80 ) != 0;
748 is_tent_bottom = ( flags1 & 0x40 ) != 0;
749 is_tent_top = ( flags1 & 0x20 ) != 0;
750 is_locked = ( flags1 & 0x04 ) == 0;
751
752 uint8_t flags2 = aReader.Read<uint8_t>();
753 is_test_fab_bottom = ( flags2 & 0x01 ) != 0;
754
755 net = aReader.Read<uint16_t>();
756 aReader.Skip( 2 );
757 component = aReader.Read<uint16_t>();
758 aReader.Skip( 4 ); // to 13
759
760 position = aReader.ReadVector2IPos();
761 topsize = aReader.ReadVector2ISize();
762 midsize = aReader.ReadVector2ISize();
763 botsize = aReader.ReadVector2ISize();
764 holesize = aReader.ReadKicadUnit(); // to 49
765
766 topshape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
767 midshape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
768 botshape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
769
770 direction = aReader.Read<double>();
771 plated = aReader.Read<uint8_t>() != 0;
772 aReader.Skip( 1 );
773 padmode = static_cast<ALTIUM_PAD_MODE>( aReader.Read<uint8_t>() );
774 aReader.Skip( 23 );
777 aReader.Skip( 7 );
778 pastemaskexpansionmode = static_cast<ALTIUM_MODE>( aReader.Read<uint8_t>() );
779 soldermaskexpansionmode = static_cast<ALTIUM_MODE>( aReader.Read<uint8_t>() );
780 aReader.Skip( 3 ); // to 106
781
782 if( subrecord5 == 110 )
783 {
784 // Don't know exactly what this is, but it's always been 0 in the files with
785 // 110-byte subrecord5.
786 // e.g. https://gitlab.com/kicad/code/kicad/-/issues/16514
787 const uint32_t unknown = aReader.ReadKicadUnit(); // to 110
788
789 if( unknown != 0 )
790 {
791 THROW_IO_ERROR( wxString::Format( "Pads6 stream subrecord5 + 106 has value %d, "
792 "which is unexpected",
793 unknown ) );
794 }
795 holerotation = 0;
796 }
797 else
798 {
799 // More than 110, need at least 114
800 ExpectSubrecordLengthAtLeast( "Pads6", "subrecord5", 114, subrecord5 );
801 holerotation = aReader.Read<double>(); // to 114
802 }
803
804 if( subrecord5 >= 120 )
805 {
806 tolayer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
807 aReader.Skip( 2 );
808 fromlayer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
809 //aReader.skip( 2 );
810 }
811 else if( subrecord5 == 171 )
812 {
813 }
814
815 aReader.SkipSubrecord();
816
817 // Subrecord 6
818 size_t subrecord6 = aReader.ReadAndSetSubrecordLength();
819 // Known lengths: 596, 628, 651
820 // 596 is the number of bytes read in this code-block
821 if( subrecord6 >= 596 )
822 { // TODO: detect type from something else than the size?
823 sizeAndShape = std::make_unique<APAD6_SIZE_AND_SHAPE>();
824
825 for( wxSize& size : sizeAndShape->inner_size )
826 size.x = aReader.ReadKicadUnitX();
827
828 for( wxSize& size : sizeAndShape->inner_size )
829 size.y = aReader.ReadKicadUnitY();
830
831 for( ALTIUM_PAD_SHAPE& shape : sizeAndShape->inner_shape )
832 shape = static_cast<ALTIUM_PAD_SHAPE>( aReader.Read<uint8_t>() );
833
834 aReader.Skip( 1 );
835
836 sizeAndShape->holeshape = static_cast<ALTIUM_PAD_HOLE_SHAPE>( aReader.Read<uint8_t>() );
837 sizeAndShape->slotsize = aReader.ReadKicadUnit();
838 sizeAndShape->slotrotation = aReader.Read<double>();
839
840 for( VECTOR2I& pt : sizeAndShape->holeoffset )
841 pt.x = aReader.ReadKicadUnitX();
842
843 for( VECTOR2I& pt : sizeAndShape->holeoffset )
844 pt.y = aReader.ReadKicadUnitY();
845
846 aReader.Skip( 1 );
847
848 for( ALTIUM_PAD_SHAPE_ALT& shape : sizeAndShape->alt_shape )
849 shape = static_cast<ALTIUM_PAD_SHAPE_ALT>( aReader.Read<uint8_t>() );
850
851 for( uint8_t& radius : sizeAndShape->cornerradius )
852 radius = aReader.Read<uint8_t>();
853 }
854 else if( subrecord6 != 0 )
855 {
856 wxLogError( _( "Pads6 stream has unexpected length for subrecord 6: %d." ), subrecord6 );
857 }
858
859 aReader.SkipSubrecord();
860
861 if( aReader.HasParsingError() )
862 THROW_IO_ERROR( wxT( "Pads6 stream was not parsed correctly" ) );
863}
864
866{
867 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
868
869 if( recordtype != ALTIUM_RECORD::VIA )
870 THROW_IO_ERROR( wxT( "Vias6 stream has invalid recordtype" ) );
871
872 // Subrecord 1
873 size_t subrecord1 = aReader.ReadAndSetSubrecordLength();
874
875 aReader.Skip( 1 );
876 uint8_t flags1 = aReader.Read<uint8_t>();
877 is_test_fab_top = ( flags1 & 0x80 ) != 0;
878 is_tent_bottom = ( flags1 & 0x40 ) != 0;
879 is_tent_top = ( flags1 & 0x20 ) != 0;
880 is_locked = ( flags1 & 0x04 ) == 0;
881
882 uint8_t flags2 = aReader.Read<uint8_t>();
883 is_test_fab_bottom = ( flags2 & 0x01 ) != 0;
884
885 net = aReader.Read<uint16_t>();
886 aReader.Skip( 8 );
887 position = aReader.ReadVector2IPos();
888 diameter = aReader.ReadKicadUnit();
889 holesize = aReader.ReadKicadUnit();
890
891 layer_start = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
892 layer_end = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
893
894 if( subrecord1 <= 74 )
895 {
896 viamode = ALTIUM_PAD_MODE::SIMPLE;
897 }
898 else
899 {
900 uint8_t temp_byte = aReader.Read<uint8_t>(); // Unknown.
901
903 thermal_relief_conductorcount = aReader.Read<uint8_t>();
904 aReader.Skip( 1 ); // Unknown.
905
907
908 aReader.ReadKicadUnit(); // Unknown. 20mil?
909 aReader.ReadKicadUnit(); // Unknown. 20mil?
910
911 aReader.Skip( 4 );
913 aReader.Skip( 8 );
914
915 temp_byte = aReader.Read<uint8_t>();
916 soldermask_expansion_manual = temp_byte & 0x02;
917
918 aReader.Skip( 7 );
919
920 viamode = static_cast<ALTIUM_PAD_MODE>( aReader.Read<uint8_t>() );
921
922 for( int ii = 0; ii < 32; ++ii )
923 {
924 diameter_by_layer[ii] = aReader.ReadKicadUnit();
925 }
926 }
927
928 if( subrecord1 >= 246 )
929 {
930 aReader.Skip( 38 );
931 soldermask_expansion_linked = aReader.Read<uint8_t>() & 0x01;
933 }
934
935 if( subrecord1 >= 307 )
936 {
937 aReader.Skip( 45 );
938
939 pos_tolerance = aReader.ReadKicadUnit();
940 neg_tolerance = aReader.ReadKicadUnit();
941 }
942
943 aReader.SkipSubrecord();
944
945 if( aReader.HasParsingError() )
946 THROW_IO_ERROR( wxT( "Vias6 stream was not parsed correctly" ) );
947}
948
950{
951 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
952
953 if( recordtype != ALTIUM_RECORD::TRACK )
954 THROW_IO_ERROR( wxT( "Tracks6 stream has invalid recordtype" ) );
955
956 // Subrecord 1
958
959 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
960
961 uint8_t flags1 = aReader.Read<uint8_t>();
962 is_locked = ( flags1 & 0x04 ) == 0;
963 is_polygonoutline = ( flags1 & 0x02 ) != 0;
964
965 uint8_t flags2 = aReader.Read<uint8_t>();
966 is_keepout = flags2 == 2;
967
968 net = aReader.Read<uint16_t>();
969 polygon = aReader.Read<uint16_t>();
970 component = aReader.Read<uint16_t>();
971 aReader.Skip( 4 );
972 start = aReader.ReadVector2IPos();
973 end = aReader.ReadVector2IPos();
974 width = aReader.ReadKicadUnit();
975 subpolyindex = aReader.Read<uint16_t>();
976
977 if( aReader.GetRemainingSubrecordBytes() >= 11 )
978 {
979 aReader.Skip( 10 );
980 keepoutrestrictions = aReader.Read<uint8_t>();
981 }
982 else
983 {
984 keepoutrestrictions = is_keepout ? 0x1F : 0;
985 }
986
987 aReader.SkipSubrecord();
988
989 if( aReader.HasParsingError() )
990 THROW_IO_ERROR( wxT( "Tracks6 stream was not parsed correctly" ) );
991}
992
993ATEXT6::ATEXT6( ALTIUM_BINARY_PARSER& aReader, std::map<uint32_t, wxString>& aStringTable )
994{
995 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
996
997 if( recordtype != ALTIUM_RECORD::TEXT )
998 THROW_IO_ERROR( wxT( "Texts6 stream has invalid recordtype" ) );
999
1000 // Subrecord 1 - Properties
1001 size_t subrecord1 = aReader.ReadAndSetSubrecordLength();
1002
1003 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
1004 aReader.Skip( 6 );
1005 component = aReader.Read<uint16_t>();
1006 aReader.Skip( 4 );
1007 position = aReader.ReadVector2IPos();
1008 height = aReader.ReadKicadUnit();
1009 strokefonttype = static_cast<STROKE_FONT_TYPE>( aReader.Read<uint16_t>() );
1010 // TODO: The Serif font type doesn't match well with KiCad, we should replace it with a better match
1011
1012 rotation = aReader.Read<double>();
1013 isMirrored = aReader.Read<uint8_t>() != 0;
1014 strokewidth = aReader.ReadKicadUnit();
1015
1016 if( subrecord1 < 123 )
1017 {
1018 fonttype = ALTIUM_TEXT_TYPE::STROKE;
1019 aReader.SkipSubrecord();
1020 return;
1021 }
1022
1023 isComment = aReader.Read<uint8_t>() != 0;
1024 isDesignator = aReader.Read<uint8_t>() != 0;
1025 aReader.Skip( 1 );
1026 fonttype = static_cast<ALTIUM_TEXT_TYPE>( aReader.Read<uint8_t>() );
1027 isBold = aReader.Read<uint8_t>() != 0;
1028 isItalic = aReader.Read<uint8_t>() != 0;
1029
1030 char fontData[64] = { 0 };
1031 aReader.ReadBytes( fontData, sizeof( fontData ) );
1032 fontname = wxString( fontData, wxMBConvUTF16LE(), sizeof( fontData ) ).BeforeFirst( '\0' );
1033
1034 char tmpbyte = aReader.Read<uint8_t>();
1035 isInverted = !!tmpbyte;
1036 margin_border_width = aReader.ReadKicadUnit(); // "Margin Border"
1037 widestring_index = aReader.Read<uint32_t>();
1038 aReader.Skip( 4 );
1039
1040 // An inverted rect in Altium is like a text box with the text inverted.
1041 isInvertedRect = aReader.Read<uint8_t>() != 0;
1042
1045 textbox_rect_justification = static_cast<ALTIUM_TEXT_POSITION>( aReader.Read<uint8_t>() );
1046 text_offset_width = aReader.ReadKicadUnit(); // "Text Offset"
1047
1048 int remaining = aReader.GetRemainingSubrecordBytes();
1049
1050 if( remaining >= 103 )
1051 {
1052 aReader.Skip( 24 ); // Unknown data
1053 aReader.Skip( 64 ); // 2nd font name
1054 aReader.Skip( 5 ); // Unknown flags
1055
1056 // "Frame" text type flag
1057 isFrame = aReader.Read<uint8_t>() != 0;
1058
1059 // Use "Offset" border value instead of "Margin"
1060 isOffsetBorder = aReader.Read<uint8_t>() != 0;
1061
1062 aReader.Skip( 8 ); // Unknown data
1063 }
1064 else
1065 {
1067 isOffsetBorder = false;
1068 }
1069
1070 if( remaining >= 115 )
1071 {
1072 // textbox_rect_justification will be wrong (5) when this flag is unset,
1073 // in that case, we should always use the left bottom justification.
1074 isJustificationValid = aReader.Read<uint8_t>() != 0;
1075
1076 aReader.Skip( 3 ); // Unknown data
1077 aReader.Skip( 8 ); // Unknown data
1078 }
1079 else
1080 {
1081 isJustificationValid = false;
1082 }
1083
1084 aReader.SkipSubrecord();
1085
1086 // Subrecord 2 - Legacy 8bit string, max 255 chars, unknown codepage
1087 aReader.ReadAndSetSubrecordLength();
1088
1089 auto entry = aStringTable.find( widestring_index );
1090
1091 if( entry != aStringTable.end() )
1092 text = entry->second;
1093 else
1094 text = aReader.ReadWxString();
1095
1096 // Normalize Windows line endings
1097 text.Replace( wxT( "\r\n" ), wxT( "\n" ) );
1098
1099 aReader.SkipSubrecord();
1100
1101 // Altium only supports inverting truetype fonts
1102 if( fonttype != ALTIUM_TEXT_TYPE::TRUETYPE )
1103 {
1104 isInverted = false;
1105 isInvertedRect = false;
1106 }
1107
1108 if( aReader.HasParsingError() )
1109 THROW_IO_ERROR( wxT( "Texts6 stream was not parsed correctly" ) );
1110}
1111
1113{
1114 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
1115
1116 if( recordtype != ALTIUM_RECORD::FILL )
1117 THROW_IO_ERROR( wxT( "Fills6 stream has invalid recordtype" ) );
1118
1119 // Subrecord 1
1120 aReader.ReadAndSetSubrecordLength();
1121
1122 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
1123
1124 uint8_t flags1 = aReader.Read<uint8_t>();
1125 is_locked = ( flags1 & 0x04 ) == 0;
1126
1127 uint8_t flags2 = aReader.Read<uint8_t>();
1128 is_keepout = flags2 == 2;
1129
1130 net = aReader.Read<uint16_t>();
1131 aReader.Skip( 2 );
1132 component = aReader.Read<uint16_t>();
1133 aReader.Skip( 4 );
1134 pos1 = aReader.ReadVector2IPos();
1135 pos2 = aReader.ReadVector2IPos();
1136 rotation = aReader.Read<double>();
1137
1138 if( aReader.GetRemainingSubrecordBytes() >= 10 )
1139 {
1140 aReader.Skip( 9 );
1141 keepoutrestrictions = aReader.Read<uint8_t>();
1142 }
1143 else
1144 {
1145 keepoutrestrictions = is_keepout ? 0x1F : 0;
1146 }
1147
1148 aReader.SkipSubrecord();
1149
1150 if( aReader.HasParsingError() )
1151 THROW_IO_ERROR( wxT( "Fills6 stream was not parsed correctly" ) );
1152}
1153
1154AREGION6::AREGION6( ALTIUM_BINARY_PARSER& aReader, bool aExtendedVertices )
1155{
1156 ALTIUM_RECORD recordtype = static_cast<ALTIUM_RECORD>( aReader.Read<uint8_t>() );
1157
1158 if( recordtype != ALTIUM_RECORD::REGION )
1159 THROW_IO_ERROR( wxT( "Regions6 stream has invalid recordtype" ) );
1160
1161 // Subrecord 1
1162 aReader.ReadAndSetSubrecordLength();
1163
1164 layer = static_cast<ALTIUM_LAYER>( aReader.Read<uint8_t>() );
1165
1166 uint8_t flags1 = aReader.Read<uint8_t>();
1167 is_locked = ( flags1 & 0x04 ) == 0;
1168
1169 uint8_t flags2 = aReader.Read<uint8_t>();
1170 is_keepout = flags2 == 2;
1171
1172 net = aReader.Read<uint16_t>();
1173 polygon = aReader.Read<uint16_t>();
1174 component = aReader.Read<uint16_t>();
1175 aReader.Skip( 5 );
1176 holecount = aReader.Read<uint16_t>();
1177 aReader.Skip( 2 );
1178
1179 std::map<wxString, wxString> properties = aReader.ReadProperties();
1180
1181 if( properties.empty() )
1182 THROW_IO_ERROR( wxT( "Regions6 stream has empty properties" ) );
1183
1184 int pkind = ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "KIND" ), 0 );
1185 bool is_cutout = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "ISBOARDCUTOUT" ), false );
1186
1187 is_shapebased = ALTIUM_PROPS_UTILS::ReadBool( properties, wxT( "ISSHAPEBASED" ), false );
1188 keepoutrestrictions = static_cast<uint8_t>(
1189 ALTIUM_PROPS_UTILS::ReadInt( properties, wxT( "KEEPOUTRESTRIC" ), 0x1F ) );
1190
1191 // TODO: this can differ from the other subpolyindex?!
1192 // Note: "the other subpolyindex" is "polygon"
1193 subpolyindex = static_cast<uint16_t>(
1194 ALTIUM_PROPS_UTILS::ReadInt( properties, "SUBPOLYINDEX", ALTIUM_POLYGON_NONE ) );
1195
1196 switch( pkind )
1197 {
1198 case 0:
1199 if( is_cutout )
1200 {
1201 kind = ALTIUM_REGION_KIND::BOARD_CUTOUT;
1202 }
1203 else
1204 {
1205 kind = ALTIUM_REGION_KIND::COPPER;
1206 }
1207 break;
1208 case 1:
1209 kind = ALTIUM_REGION_KIND::POLYGON_CUTOUT;
1210 break;
1211 case 2:
1212 kind = ALTIUM_REGION_KIND::DASHED_OUTLINE;
1213 break;
1214 case 3:
1215 kind = ALTIUM_REGION_KIND::UNKNOWN_3; // TODO: what kind is this?
1216 break;
1217 case 4:
1218 kind = ALTIUM_REGION_KIND::CAVITY_DEFINITION;
1219 break;
1220 default:
1221 kind = ALTIUM_REGION_KIND::UNKNOWN;
1222 break;
1223 }
1224
1225 uint32_t num_outline_vertices = aReader.Read<uint32_t>();
1226
1227 if( aExtendedVertices )
1228 num_outline_vertices++; // Has a closing vertex
1229
1230 for( uint32_t i = 0; i < num_outline_vertices; i++ )
1231 {
1232 if( aExtendedVertices )
1233 {
1234 bool isRound = aReader.Read<uint8_t>() != 0;
1235 VECTOR2I position = aReader.ReadVector2IPos();
1236 VECTOR2I center = aReader.ReadVector2IPos();
1237 int32_t radius = aReader.ReadKicadUnit();
1238 double angle1 = aReader.Read<double>();
1239 double angle2 = aReader.Read<double>();
1240 outline.emplace_back( isRound, radius, angle1, angle2, position, center );
1241 }
1242 else
1243 {
1244 // For some regions the coordinates are stored as double and not as int32_t
1245 int32_t x = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( aReader.Read<double>() );
1246 int32_t y = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( -aReader.Read<double>() );
1247 outline.emplace_back( VECTOR2I( x, y ) );
1248 }
1249 }
1250
1251 holes.resize( holecount );
1252 for( uint16_t k = 0; k < holecount; k++ )
1253 {
1254 uint32_t num_hole_vertices = aReader.Read<uint32_t>();
1255 holes.at( k ).reserve( num_hole_vertices );
1256
1257 for( uint32_t i = 0; i < num_hole_vertices; i++ )
1258 {
1259 int32_t x = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( aReader.Read<double>() );
1260 int32_t y = ALTIUM_PROPS_UTILS::ConvertToKicadUnit( -aReader.Read<double>() );
1261 holes.at( k ).emplace_back( VECTOR2I( x, y ) );
1262 }
1263 }
1264
1265 aReader.SkipSubrecord();
1266
1267 if( aReader.HasParsingError() )
1268 THROW_IO_ERROR( wxT( "Regions6 stream was not parsed correctly" ) );
1269}
void altium_parse_polygons(std::map< wxString, wxString > &aProps, std::vector< ALTIUM_VERTICE > &aVertices)
static void ExpectSubrecordLengthAtLeast(const std::string &aStreamType, const std::string &aSubrecordName, size_t aExpectedLength, size_t aActualLength)
Throw an IO_ERROR if the actual length is less than the expected length.
ALTIUM_LAYER altium_layer_from_name(const wxString &aName)
static AEXTENDED_PRIMITIVE_INFORMATION_TYPE ReadAltiumExtendedPrimitiveInformationTypeFromProperties(const std::map< wxString, wxString > &aProps, wxString aKey)
static ALTIUM_MODE ReadAltiumModeFromProperties(const std::map< wxString, wxString > &aProps, wxString aKey)
static ALTIUM_RECORD ReadAltiumRecordFromProperties(const std::map< wxString, wxString > &aProps, wxString aKey)
ALTIUM_PAD_SHAPE_ALT
ALTIUM_TEXT_POSITION
ALTIUM_PAD_MODE
ALTIUM_TEXT_TYPE
ALTIUM_PAD_SHAPE
ALTIUM_DIMENSION_KIND
ALTIUM_PAD_HOLE_SHAPE
const uint16_t ALTIUM_NET_UNCONNECTED
ALTIUM_CLASS_KIND
ALTIUM_MODE
const uint16_t ALTIUM_POLYGON_NONE
ALTIUM_LAYER
AEXTENDED_PRIMITIVE_INFORMATION_TYPE
ALTIUM_RECORD
void Skip(size_t aLength)
size_t GetRemainingSubrecordBytes() const
std::map< wxString, wxString > ReadProperties(std::function< std::map< wxString, wxString >(const std::string &)> handleBinaryData=[](const std::string &) { return std::map< wxString, wxString >();})
int ReadBytes(char *aOut, size_t aSize)
static int ReadInt(const std::map< wxString, wxString > &aProps, const wxString &aKey, int aDefault)
static int32_t ReadKicadUnit(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
static bool ReadBool(const std::map< wxString, wxString > &aProps, const wxString &aKey, bool aDefault)
static wxString ReadUnicodeString(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
static wxString ReadString(const std::map< wxString, wxString > &aProps, const wxString &aKey, const wxString &aDefault)
static double ReadDouble(const std::map< wxString, wxString > &aProps, const wxString &aKey, double aDefault)
static int32_t ConvertToKicadUnit(const double aValue)
T y
Definition: vector3.h:64
T z
Definition: vector3.h:65
T x
Definition: vector3.h:63
#define _(s)
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:39
double startangle
uint16_t component
bool is_keepout
uint32_t width
ALTIUM_LAYER layer
AARC6(ALTIUM_BINARY_PARSER &aReader)
uint8_t keepoutrestrictions
uint16_t polygon
VECTOR2I center
uint32_t radius
uint16_t net
bool is_locked
bool is_polygonoutline
double endangle
uint16_t subpolyindex
VECTOR2I sheetpos
std::set< wxString > layerNames
wxSize sheetsize
ABOARD6(ALTIUM_BINARY_PARSER &aReader)
std::vector< ABOARD6_LAYER_STACKUP > stackup
std::vector< ALTIUM_VERTICE > board_vertices
wxString uniqueid
std::vector< wxString > names
ALTIUM_CLASS_KIND kind
wxString name
ACLASS6(ALTIUM_BINARY_PARSER &aReader)
ALTIUM_TEXT_POSITION commentautoposition
ALTIUM_TEXT_POSITION nameautoposition
ACOMPONENT6(ALTIUM_BINARY_PARSER &aReader)
wxString sourcefootprintlibrary
ALTIUM_LAYER layer
wxString sourcelibreference
wxString sourcedesignator
wxString sourcecomponentlibrary
ACOMPONENTBODY6(ALTIUM_BINARY_PARSER &aReader)
int32_t textprecision
ALTIUM_UNIT textunit
wxString textsuffix
uint32_t textlinewidth
wxString textformat
ALTIUM_LAYER layer
std::vector< VECTOR2I > textPoint
wxString textprefix
uint32_t linewidth
ALTIUM_DIMENSION_KIND kind
uint32_t textheight
ADIMENSION6(ALTIUM_BINARY_PARSER &aReader)
std::vector< VECTOR2I > referencePoint
AEXTENDED_PRIMITIVE_INFORMATION_TYPE type
AEXTENDED_PRIMITIVE_INFORMATION(ALTIUM_BINARY_PARSER &aReader)
VECTOR2I pos2
ALTIUM_LAYER layer
uint16_t net
VECTOR2I pos1
double rotation
uint8_t keepoutrestrictions
AFILL6(ALTIUM_BINARY_PARSER &aReader)
uint16_t component
double z_offset
int32_t checksum
wxString name
VECTOR3D rotation
AMODEL(ALTIUM_BINARY_PARSER &aReader)
ANET6(ALTIUM_BINARY_PARSER &aReader)
wxString name
double holerotation
int32_t soldermaskexpansionmanual
uint16_t net
ALTIUM_LAYER layer
APAD6(ALTIUM_BINARY_PARSER &aReader)
std::unique_ptr< APAD6_SIZE_AND_SHAPE > sizeAndShape
ALTIUM_LAYER tolayer
ALTIUM_PAD_SHAPE topshape
ALTIUM_PAD_MODE padmode
ALTIUM_MODE pastemaskexpansionmode
uint32_t holesize
double direction
ALTIUM_MODE soldermaskexpansionmode
wxString name
bool is_test_fab_bottom
bool is_tent_bottom
VECTOR2I botsize
ALTIUM_PAD_SHAPE botshape
uint16_t component
VECTOR2I midsize
ALTIUM_PAD_SHAPE midshape
int32_t pastemaskexpansionmanual
bool is_tent_top
ALTIUM_LAYER fromlayer
VECTOR2I position
bool is_locked
VECTOR2I topsize
bool is_test_fab_top
int32_t minprimlength
std::vector< ALTIUM_VERTICE > vertices
APOLYGON6(ALTIUM_BINARY_PARSER &aReader)
ALTIUM_POLYGON_HATCHSTYLE hatchstyle
int32_t pourindex
int32_t trackwidth
ALTIUM_LAYER layer
int32_t gridsize
uint8_t keepoutrestrictions
ALTIUM_LAYER layer
AREGION6(ALTIUM_BINARY_PARSER &aReader, bool aExtendedVertices)
uint16_t holecount
std::vector< ALTIUM_VERTICE > outline
uint16_t subpolyindex
std::vector< std::vector< ALTIUM_VERTICE > > holes
uint16_t component
uint16_t net
uint16_t polygon
ALTIUM_REGION_KIND kind
ALTIUM_RULE_KIND kind
ALTIUM_CONNECT_STYLE polygonconnectStyle
wxString scope1expr
int preferredWidth
wxString name
int planeclearanceClearance
int32_t polygonconnectReliefconductorwidth
int pastemaskExpansion
wxString scope2expr
int soldermaskExpansion
ARULE6(ALTIUM_BINARY_PARSER &aReader)
int32_t polygonconnectAirgapwidth
int polygonconnectReliefentries
uint32_t text_offset_width
uint32_t textbox_rect_height
uint16_t component
ALTIUM_TEXT_POSITION textbox_rect_justification
bool isInvertedRect
wxString text
uint32_t widestring_index
uint32_t textbox_rect_width
double rotation
uint32_t margin_border_width
uint32_t height
wxString fontname
bool isJustificationValid
ALTIUM_LAYER layer
VECTOR2I position
ALTIUM_TEXT_TYPE fonttype
STROKE_FONT_TYPE strokefonttype
bool isDesignator
bool isOffsetBorder
ATEXT6(ALTIUM_BINARY_PARSER &aReader, std::map< uint32_t, wxString > &aStringTable)
uint32_t strokewidth
VECTOR2I end
ATRACK6(ALTIUM_BINARY_PARSER &aReader)
uint32_t width
bool is_polygonoutline
uint16_t net
uint16_t polygon
uint16_t subpolyindex
uint8_t keepoutrestrictions
VECTOR2I start
ALTIUM_LAYER layer
uint16_t component
bool soldermask_expansion_linked
uint32_t thermal_relief_conductorcount
uint32_t diameter
uint32_t neg_tolerance
uint16_t net
VECTOR2I position
int32_t thermal_relief_airgap
bool is_locked
bool is_tent_top
bool is_test_fab_top
int32_t soldermask_expansion_front
uint32_t pos_tolerance
bool is_tent_bottom
bool is_test_fab_bottom
bool soldermask_expansion_manual
ALTIUM_PAD_MODE viamode
AVIA6(ALTIUM_BINARY_PARSER &aReader)
uint32_t thermal_relief_conductorwidth
int32_t soldermask_expansion_back
uint32_t diameter_by_layer[32]
ALTIUM_LAYER layer_start
ALTIUM_LAYER layer_end
uint32_t holesize
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695