KiCad PCB EDA Suite
DXF_IMPORT_PLUGIN Class Reference

This class import DXF ASCII files and convert basic entities to board entities. More...

#include <dxf_import_plugin.h>

Inheritance diagram for DXF_IMPORT_PLUGIN:
GRAPHICS_IMPORT_PLUGIN

Public Member Functions

 DXF_IMPORT_PLUGIN ()
 
 ~DXF_IMPORT_PLUGIN ()
 
const wxString GetName () const override
 Returns the plugin name. More...
 
const wxArrayString GetFileExtensions () const override
 Returns a string array of the file extensions handled by this plugin. More...
 
bool Load (const wxString &aFileName) override
 Loads file for import. More...
 
bool Import () override
 Actually imports the file. More...
 
double GetImageWidth () const override
 Return image width from original imported file. More...
 
double GetImageHeight () const override
 Return image height from original imported file. More...
 
void updateImageLimits (const VECTOR2D &aPoint)
 
void ImportAsFootprintGraphic (bool aImportAsFootprintGraphic)
 Allows the import DXF items converted to board graphic items or footprint graphic items. More...
 
void SetDefaultLineWidthMM (double aWidth)
 Set the default line width when importing dxf items like lines to Pcbnew. More...
 
void SetOffset (double aOffsetX, double aOffsetY)
 Set the coordinate offset between the imported dxf items and Pcbnew. More...
 
void SetBrdLayer (int aBrdLayer)
 Set the layer number to import dxf items. More...
 
bool ImportDxfFile (const wxString &aFile)
 Implementation of the method used for communicate with this filter. More...
 
const std::string & GetMessages () const override
 
void SetImporter (GRAPHICS_IMPORTER *aImporter)
 Sets the receiver of the imported shapes. More...
 
wxString GetWildcards () const
 Returns a list of wildcards that contains the file extensions handled by this plugin, separated with a coma. More...
 

Protected Attributes

GRAPHICS_IMPORTERm_importer
 

Importer used to create objects representing the imported shapes.

More...
 

Private Member Functions

void reportMsg (const char *aMessage)
 
double mapX (double aDxfCoordX)
 
double mapY (double aDxfCoordY)
 
double mapDim (double aDxfValue)
 
double mapWidth (double aDxfWidth)
 
void insertLine (const VECTOR2D &aSegStart, const VECTOR2D &aSegEnd, int aWidth)
 
void insertArc (const VECTOR2D &aSegStart, const VECTOR2D &aSegEnd, double aBulge, int aWidth)
 
void insertSpline (int aWidth)
 
virtual void setVariableString (const std::string &key, const std::string &value, int code) override
 Called for every string variable in the DXF file (e.g. More...
 
virtual void setVariableInt (const std::string &key, int value, int code) override
 Called for every int variable in the DXF file (e.g. More...
 
virtual void setVariableDouble (const std::string &key, double value, int code) override
 Called for every double variable in the DXF file (e.g. More...
 
virtual void addLayer (const DL_LayerData &aData) override
 
virtual void addLine (const DL_LineData &aData) override
 
virtual void addCircle (const DL_CircleData &aData) override
 
virtual void addArc (const DL_ArcData &aData) override
 
virtual void addText (const DL_TextData &aData) override
 
virtual void addPolyline (const DL_PolylineData &aData) override
 
virtual void addVertex (const DL_VertexData &aData) override
 Called for every polyline vertex. More...
 
virtual void addMText (const DL_MTextData &aData) override
 
virtual void addTextStyle (const DL_StyleData &aData) override
 
virtual void endEntity () override
 
virtual void addSpline (const DL_SplineData &aData) override
 Called for every spline. More...
 
virtual void addControlPoint (const DL_ControlPointData &aData) override
 Called for every spline control point. More...
 
virtual void addFitPoint (const DL_FitPointData &aData) override
 Called for every spline fit point. More...
 
virtual void addKnot (const DL_KnotData &aData) override
 Called for every spline knot value. More...
 
virtual void addDimAlign (const DL_DimensionData &, const DL_DimAlignedData &) override
 
virtual void addDimLinear (const DL_DimensionData &, const DL_DimLinearData &) override
 
virtual void addDimRadial (const DL_DimensionData &, const DL_DimRadialData &) override
 
virtual void addDimDiametric (const DL_DimensionData &, const DL_DimDiametricData &) override
 
virtual void addDimAngular (const DL_DimensionData &, const DL_DimAngularData &) override
 
virtual void addDimAngular3P (const DL_DimensionData &, const DL_DimAngular3PData &) override
 
virtual void addDimOrdinate (const DL_DimensionData &, const DL_DimOrdinateData &) override
 
virtual void addLeader (const DL_LeaderData &) override
 
virtual void addLeaderVertex (const DL_LeaderVertexData &) override
 
virtual void addHatch (const DL_HatchData &) override
 
virtual void addTrace (const DL_TraceData &) override
 
virtual void add3dFace (const DL_3dFaceData &) override
 
virtual void addSolid (const DL_SolidData &) override
 
virtual void addImage (const DL_ImageData &) override
 
virtual void linkImage (const DL_ImageDefData &) override
 
virtual void addHatchLoop (const DL_HatchLoopData &) override
 
virtual void addHatchEdge (const DL_HatchEdgeData &) override
 
void writeLine ()
 
void writeMtext ()
 

Static Private Member Functions

static wxString toDxfString (const wxString &aStr)
 Converts a native unicode string into a DXF encoded string. More...
 
static wxString toNativeString (const wxString &aData)
 Converts a DXF encoded string into a native Unicode string. More...
 

Private Attributes

double m_xOffset
 
double m_yOffset
 
double m_defaultThickness
 
double m_DXF2mm
 
int m_brdLayer
 
int m_version
 
std::string m_codePage
 
bool m_importAsfootprintGraphicItems
 
std::string m_messages
 
DXF2BRD_ENTITY_DATA m_curr_entity
 
double m_minX
 
double m_maxX
 
double m_minY
 
double m_maxY
 
GRAPHICS_IMPORTER_BUFFER m_internalImporter
 

Detailed Description

This class import DXF ASCII files and convert basic entities to board entities.

It depends on the dxflib library.

Definition at line 115 of file dxf_import_plugin.h.

Constructor & Destructor Documentation

DXF_IMPORT_PLUGIN::DXF_IMPORT_PLUGIN ( )

Definition at line 59 of file dxf_import_plugin.cpp.

References Dwgs_User, m_brdLayer, m_defaultThickness, m_DXF2mm, m_importAsfootprintGraphicItems, m_maxX, m_maxY, m_minX, m_minY, m_version, m_xOffset, m_yOffset, max, and min.

59  : DL_CreationAdapter()
60 {
61  m_xOffset = 0.0; // X coord offset for conversion (in mm)
62  m_yOffset = 0.0; // Y coord offset for conversion (in mm)
63  m_DXF2mm = 1.0; // The scale factor to convert DXF units to mm
64  m_version = 0; // the dxf version, not yet used
65  m_defaultThickness = 0.2; // default thickness (in mm)
66  m_brdLayer = Dwgs_User; // The default import layer
70 }
#define max(a, b)
Definition: auxiliary.h:86
#define min(a, b)
Definition: auxiliary.h:85
DXF_IMPORT_PLUGIN::~DXF_IMPORT_PLUGIN ( )

Definition at line 73 of file dxf_import_plugin.cpp.

74 {
75 }

Member Function Documentation

virtual void DXF_IMPORT_PLUGIN::add3dFace ( const DL_3dFaceData &  )
inlineoverrideprivatevirtual

Definition at line 307 of file dxf_import_plugin.h.

307 { reportMsg( "DL_3dFace not managed" ); }
void reportMsg(const char *aMessage)
void DXF_IMPORT_PLUGIN::addArc ( const DL_ArcData &  aData)
overrideprivatevirtual

Definition at line 314 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddArc(), PNS::angle(), DXF2ANGLEUI, m_internalImporter, mapDim(), mapWidth(), mapX(), mapY(), RAD2DECIDEG(), RotatePoint(), and updateImageLimits().

315 {
316  // Init arc centre:
317  VECTOR2D center( mapX( aData.cx ), mapY( aData.cy ) );
318 
319  // Init arc start point
320  double arcStartx = aData.radius;
321  double arcStarty = 0;
322 
323  // aData.anglex is in degrees. Our internal units are 0.1 degree
324  // so convert DXF angles to our units
325  #define DXF2ANGLEUI 10
326  double startangle = aData.angle1 * DXF2ANGLEUI;
327  double endangle = aData.angle2 * DXF2ANGLEUI;
328 
329  RotatePoint( &arcStartx, &arcStarty, -RAD2DECIDEG( startangle ) );
330  VECTOR2D arcStart( mapX( arcStartx + aData.cx ), mapY( arcStarty + aData.cy ) );
331 
332  // calculate arc angle (arcs are CCW, and should be < 0 in Pcbnew)
333  double angle = -( endangle - startangle );
334 
335  if( angle > 0.0 )
336  angle -= 3600.0;
337 
338  double lineWidth = mapWidth( attributes.getWidth() );
339  m_internalImporter.AddArc( center, arcStart, angle, lineWidth );
340 
341  VECTOR2D radiusDelta( mapDim( aData.radius ), mapDim( aData.radius ) );
342 
343  updateImageLimits( center + radiusDelta );
344  updateImageLimits( center - radiusDelta );
345 }
void AddArc(const VECTOR2D &aCenter, const VECTOR2D &aStart, double aAngle, double aWidth) override
Creates an object representing an arc.
double mapX(double aDxfCoordX)
double RAD2DECIDEG(double rad)
Definition: trigo.h:204
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:216
void updateImageLimits(const VECTOR2D &aPoint)
double mapDim(double aDxfValue)
double mapWidth(double aDxfWidth)
#define DXF2ANGLEUI
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
double mapY(double aDxfCoordY)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::addCircle ( const DL_CircleData &  aData)
overrideprivatevirtual

Definition at line 298 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddCircle(), m_internalImporter, mapDim(), mapWidth(), mapX(), mapY(), and updateImageLimits().

299 {
300  VECTOR2D center( mapX( aData.cx ), mapY( aData.cy ) );
301  double lineWidth = mapWidth( attributes.getWidth() );
302  m_internalImporter.AddCircle( center, mapDim( aData.radius ), lineWidth );
303 
304  VECTOR2D radiusDelta( mapDim( aData.radius ), mapDim( aData.radius ) );
305 
306  updateImageLimits( center + radiusDelta );
307  updateImageLimits( center - radiusDelta );
308 }
double mapX(double aDxfCoordX)
void updateImageLimits(const VECTOR2D &aPoint)
void AddCircle(const VECTOR2D &aCenter, double aRadius, double aWidth) override
Creates an object representing a circle.
double mapDim(double aDxfValue)
double mapWidth(double aDxfWidth)
double mapY(double aDxfCoordY)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::addControlPoint ( const DL_ControlPointData &  aData)
overrideprivatevirtual

Called for every spline control point.

Definition at line 179 of file dxf_import_plugin.cpp.

References m_curr_entity, and DXF2BRD_ENTITY_DATA::m_SplineControlPointList.

180 {
181  // Called for every spline control point, when reading a spline entity
182  m_curr_entity.m_SplineControlPointList.push_back( SPLINE_CTRL_POINT( aData.x , aData.y, aData.w ) );
183 }
DXF2BRD_ENTITY_DATA m_curr_entity
A helper class to store a spline control point (in X,Y plane only)
std::vector< SPLINE_CTRL_POINT > m_SplineControlPointList
virtual void DXF_IMPORT_PLUGIN::addDimAlign ( const DL_DimensionData &  ,
const DL_DimAlignedData &   
)
inlineoverrideprivatevirtual

Definition at line 287 of file dxf_import_plugin.h.

288  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addDimAngular ( const DL_DimensionData &  ,
const DL_DimAngularData &   
)
inlineoverrideprivatevirtual

Definition at line 295 of file dxf_import_plugin.h.

296  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addDimAngular3P ( const DL_DimensionData &  ,
const DL_DimAngular3PData &   
)
inlineoverrideprivatevirtual

Definition at line 297 of file dxf_import_plugin.h.

298  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addDimDiametric ( const DL_DimensionData &  ,
const DL_DimDiametricData &   
)
inlineoverrideprivatevirtual

Definition at line 293 of file dxf_import_plugin.h.

294  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addDimLinear ( const DL_DimensionData &  ,
const DL_DimLinearData &   
)
inlineoverrideprivatevirtual

Definition at line 289 of file dxf_import_plugin.h.

290  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addDimOrdinate ( const DL_DimensionData &  ,
const DL_DimOrdinateData &   
)
inlineoverrideprivatevirtual

Definition at line 299 of file dxf_import_plugin.h.

300  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addDimRadial ( const DL_DimensionData &  ,
const DL_DimRadialData &   
)
inlineoverrideprivatevirtual

Definition at line 291 of file dxf_import_plugin.h.

292  { reportMsg( "DL_Dimension not managed" ); }
void reportMsg(const char *aMessage)
void DXF_IMPORT_PLUGIN::addFitPoint ( const DL_FitPointData &  aData)
overrideprivatevirtual

Called for every spline fit point.

Definition at line 185 of file dxf_import_plugin.cpp.

References m_curr_entity, and DXF2BRD_ENTITY_DATA::m_SplineFitPointList.

186 {
187  // Called for every spline fit point, when reading a spline entity
188  // we store only the X,Y coord values in a VECTOR2D
189  m_curr_entity.m_SplineFitPointList.push_back( VECTOR2D( aData.x, aData.y ) );
190 }
DXF2BRD_ENTITY_DATA m_curr_entity
std::vector< VECTOR2D > m_SplineFitPointList
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual void DXF_IMPORT_PLUGIN::addHatch ( const DL_HatchData &  )
inlineoverrideprivatevirtual

Definition at line 304 of file dxf_import_plugin.h.

304 { reportMsg( "DL_Hatch not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addHatchEdge ( const DL_HatchEdgeData &  )
inlineoverrideprivatevirtual

Definition at line 313 of file dxf_import_plugin.h.

313 { reportMsg( "DL_HatchEdge not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addHatchLoop ( const DL_HatchLoopData &  )
inlineoverrideprivatevirtual

Definition at line 312 of file dxf_import_plugin.h.

312 { reportMsg( "DL_HatchLoop not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addImage ( const DL_ImageData &  )
inlineoverrideprivatevirtual

Definition at line 310 of file dxf_import_plugin.h.

310 { reportMsg( "DL_ImageDa not managed" ); }
void reportMsg(const char *aMessage)
void DXF_IMPORT_PLUGIN::addKnot ( const DL_KnotData &  aData)
overrideprivatevirtual

Called for every spline knot value.

Definition at line 193 of file dxf_import_plugin.cpp.

References m_curr_entity, and DXF2BRD_ENTITY_DATA::m_SplineKnotsList.

194 {
195  // Called for every spline knot value, when reading a spline entity
196  m_curr_entity.m_SplineKnotsList.push_back( aData.k );
197 }
DXF2BRD_ENTITY_DATA m_curr_entity
std::vector< double > m_SplineKnotsList
void DXF_IMPORT_PLUGIN::addLayer ( const DL_LayerData &  aData)
overrideprivatevirtual

Definition at line 200 of file dxf_import_plugin.cpp.

References name.

201 {
202  // Not yet useful in Pcbnew.
203 #if 0
204  wxString name = wxString::FromUTF8( aData.name.c_str() );
205  wxLogMessage( name );
206 #endif
207 }
const char * name
Definition: DXF_plotter.cpp:61
virtual void DXF_IMPORT_PLUGIN::addLeader ( const DL_LeaderData &  )
inlineoverrideprivatevirtual

Definition at line 301 of file dxf_import_plugin.h.

301 { reportMsg( "DL_Leader not managed" ); }
void reportMsg(const char *aMessage)
virtual void DXF_IMPORT_PLUGIN::addLeaderVertex ( const DL_LeaderVertexData &  )
inlineoverrideprivatevirtual

Definition at line 302 of file dxf_import_plugin.h.

302 { reportMsg( "DL_LeaderVertex not managed" ); }
void reportMsg(const char *aMessage)
void DXF_IMPORT_PLUGIN::addLine ( const DL_LineData &  aData)
overrideprivatevirtual

Definition at line 210 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddLine(), m_internalImporter, mapWidth(), mapX(), mapY(), and updateImageLimits().

211 {
212  VECTOR2D start( mapX( aData.x1 ), mapY( aData.y1 ) );
213  VECTOR2D end( mapX( aData.x2 ), mapY( aData.y2 ) );
214  double lineWidth = mapWidth( attributes.getWidth() );
215 
216  m_internalImporter.AddLine( start, end, lineWidth );
217 
218  updateImageLimits( start );
219  updateImageLimits( end );
220 }
void AddLine(const VECTOR2D &aStart, const VECTOR2D &aEnd, double aWidth) override
Creates an object representing a line segment.
double mapX(double aDxfCoordX)
void updateImageLimits(const VECTOR2D &aPoint)
double mapWidth(double aDxfWidth)
double mapY(double aDxfCoordY)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::addMText ( const DL_MTextData &  aData)
overrideprivatevirtual

Definition at line 484 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddText(), PNS::angle(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, m_internalImporter, mapDim(), mapX(), mapY(), toNativeString(), updateImageLimits(), VECTOR2< T >::x, and VECTOR2< T >::y.

485 {
486  wxString text = toNativeString( wxString::FromUTF8( aData.text.c_str() ) );
487  wxString attrib, tmp;
488 
489  double textHeight = mapDim( aData.height );
490  // The 0.9 factor gives a better height/width ratio with our font
491  double charWidth = textHeight * 0.9;
492  double textWidth = charWidth * text.length(); // Rough approximation
493  double textThickness = textHeight/8.0; // Use a reasonable line thickness for this text
494 
495  VECTOR2D bottomLeft(0.0, 0.0);
496  VECTOR2D bottomRight(0.0, 0.0);
497  VECTOR2D topLeft(0.0, 0.0);
498  VECTOR2D topRight(0.0, 0.0);
499 
500  /* Some texts start by '\' and have formating chars (font name, font option...)
501  * ending with ';'
502  * Here are some mtext formatting codes:
503  * Format code Purpose
504  * \0...\o Turns overline on and off
505  * \L...\l Turns underline on and off
506  * \~ Inserts a nonbreaking space
507  \\ Inserts a backslash
508  \\\{...\} Inserts an opening and closing brace
509  \\ \File name; Changes to the specified font file
510  \\ \Hvalue; Changes to the text height specified in drawing units
511  \\ \Hvaluex; Changes the text height to a multiple of the current text height
512  \\ \S...^...; Stacks the subsequent text at the \, #, or ^ symbol
513  \\ \Tvalue; Adjusts the space between characters, from.75 to 4 times
514  \\ \Qangle; Changes obliquing angle
515  \\ \Wvalue; Changes width factor to produce wide text
516  \\ \A Sets the alignment value; valid values: 0, 1, 2 (bottom, center, top) while( text.StartsWith( wxT("\\") ) )
517  */
518  while( text.StartsWith( wxT( "\\" ) ) )
519  {
520  attrib << text.BeforeFirst( ';' );
521  tmp = text.AfterFirst( ';' );
522  text = tmp;
523  }
524 
525  VECTOR2D textpos( mapX( aData.ipx ), mapY( aData.ipy ) );
526 
527  // Initialize text justifications:
530 
531  if( aData.attachmentPoint <= 3 )
532  {
533  vJustify = GR_TEXT_VJUSTIFY_TOP;
534 
535  bottomLeft.y = -textHeight;
536  bottomRight.y = -textHeight;
537  }
538  else if( aData.attachmentPoint <= 6 )
539  {
540  vJustify = GR_TEXT_VJUSTIFY_CENTER;
541 
542  bottomRight.y = -textHeight / 2.0;
543  bottomLeft.y = -textHeight / 2.0;
544  topLeft.y = textHeight / 2.0;
545  topRight.y = textHeight / 2.0;
546  }
547  else
548  {
549  vJustify = GR_TEXT_VJUSTIFY_BOTTOM;
550 
551  topLeft.y = textHeight;
552  topRight.y = textHeight;
553  }
554 
555  if( aData.attachmentPoint % 3 == 1 )
556  {
557  hJustify = GR_TEXT_HJUSTIFY_LEFT;
558 
559  bottomRight.x = textWidth;
560  topRight.x = textWidth;
561  }
562  else if( aData.attachmentPoint % 3 == 2 )
563  {
564  hJustify = GR_TEXT_HJUSTIFY_CENTER;
565 
566  bottomLeft.x = -textWidth / 2.0;
567  topLeft.x = -textWidth / 2.0;
568  bottomRight.x = textWidth / 2.0;
569  topRight.x = textWidth / 2.0;
570  }
571  else
572  {
573  hJustify = GR_TEXT_HJUSTIFY_RIGHT;
574 
575  bottomLeft.x = -textWidth;
576  topLeft.x = -textWidth;
577  }
578 
579 #if 0 // These setting have no mening in Pcbnew
580  if( data.alignH == 1 )
581  {
582  // Text is left to right;
583  }
584  else if( data.alignH == 3 )
585  {
586  // Text is top to bottom;
587  }
588  else
589  {
590  // use ByStyle;
591  }
592 
593  if( aData.alignV == 1 )
594  {
595  // use AtLeast;
596  }
597  else
598  {
599  // useExact;
600  }
601 #endif
602 
603  double angle = aData.angle * 10;
604  double angleInRads = angle / 10.0 * M_PI / 180.0;
605  double cosine = cos(angleInRads);
606  double sine = sin(angleInRads);
607 
608  m_internalImporter.AddText( textpos, text, textHeight, charWidth,
609  textThickness, angle, hJustify, vJustify );
610 
611  bottomLeft.x = bottomLeft.x * cosine - bottomLeft.y * sine;
612  bottomLeft.y = bottomLeft.x * sine + bottomLeft.y * cosine;
613 
614  bottomRight.x = bottomRight.x * cosine - bottomRight.y * sine;
615  bottomRight.y = bottomRight.x * sine + bottomRight.y * cosine;
616 
617  topLeft.x = topLeft.x * cosine - topLeft.y * sine;
618  topLeft.y = topLeft.x * sine + topLeft.y * cosine;
619 
620  topRight.x = topRight.x * cosine - topRight.y * sine;
621  topRight.y = topRight.x * sine + topRight.y * cosine;
622 
623  bottomLeft += textpos;
624  bottomRight += textpos;
625  topLeft += textpos;
626  topRight += textpos;
627 
628  updateImageLimits( bottomLeft );
629  updateImageLimits( bottomRight );
630  updateImageLimits( topLeft );
631  updateImageLimits( topRight );
632 
633 }
EDA_TEXT_HJUSTIFY_T
Definition: eda_text.h:62
double mapX(double aDxfCoordX)
void updateImageLimits(const VECTOR2D &aPoint)
static wxString toNativeString(const wxString &aData)
Converts a DXF encoded string into a native Unicode string.
double mapDim(double aDxfValue)
void AddText(const VECTOR2D &aOrigin, const wxString &aText, double aHeight, double aWidth, double aThickness, double aOrientation, EDA_TEXT_HJUSTIFY_T aHJustify, EDA_TEXT_VJUSTIFY_T aVJustify) override
Creates an object representing a text.
EDA_TEXT_VJUSTIFY_T
Definition: eda_text.h:69
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
double mapY(double aDxfCoordY)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::addPolyline ( const DL_PolylineData &  aData)
overrideprivatevirtual

Definition at line 223 of file dxf_import_plugin.cpp.

References DXF2BRD_ENTITY_DATA::Clear(), m_curr_entity, DXF2BRD_ENTITY_DATA::m_EntityFlag, DXF2BRD_ENTITY_DATA::m_EntityParseStatus, and DXF2BRD_ENTITY_DATA::m_EntityType.

224 {
225  // Convert DXF Polylines into a series of KiCad Lines and Arcs.
226  // A Polyline (as opposed to a LWPolyline) may be a 3D line or
227  // even a 3D Mesh. The only type of Polyline which is guaranteed
228  // to import correctly is a 2D Polyline in X and Y, which is what
229  // we assume of all Polylines. The width used is the width of the Polyline.
230  // per-vertex line widths, if present, are ignored.
233  m_curr_entity.m_EntityFlag = aData.flags;
234  m_curr_entity.m_EntityType = DL_ENTITY_POLYLINE;
235 }
DXF2BRD_ENTITY_DATA m_curr_entity
virtual void DXF_IMPORT_PLUGIN::addSolid ( const DL_SolidData &  )
inlineoverrideprivatevirtual

Definition at line 308 of file dxf_import_plugin.h.

308 { reportMsg( "DL_Solid not managed" ); }
void reportMsg(const char *aMessage)
void DXF_IMPORT_PLUGIN::addSpline ( const DL_SplineData &  aData)
overrideprivatevirtual

Called for every spline.

Definition at line 161 of file dxf_import_plugin.cpp.

References DXF2BRD_ENTITY_DATA::Clear(), m_curr_entity, DXF2BRD_ENTITY_DATA::m_EntityFlag, DXF2BRD_ENTITY_DATA::m_EntityParseStatus, DXF2BRD_ENTITY_DATA::m_EntityType, DXF2BRD_ENTITY_DATA::m_SplineControlCount, DXF2BRD_ENTITY_DATA::m_SplineDegree, DXF2BRD_ENTITY_DATA::m_SplineFitCount, DXF2BRD_ENTITY_DATA::m_SplineKnotsCount, DXF2BRD_ENTITY_DATA::m_SplineTangentEndX, DXF2BRD_ENTITY_DATA::m_SplineTangentEndY, DXF2BRD_ENTITY_DATA::m_SplineTangentStartX, and DXF2BRD_ENTITY_DATA::m_SplineTangentStartY.

162 {
163  // Called when starting reading a spline
166  m_curr_entity.m_EntityFlag = aData.flags;
167  m_curr_entity.m_EntityType = DL_ENTITY_SPLINE;
168  m_curr_entity.m_SplineDegree = aData.degree;
169  m_curr_entity.m_SplineTangentStartX = aData.tangentStartX;
170  m_curr_entity.m_SplineTangentStartY = aData.tangentStartY;
171  m_curr_entity.m_SplineTangentEndX = aData.tangentEndX;
172  m_curr_entity.m_SplineTangentEndY = aData.tangentEndY;
173  m_curr_entity.m_SplineKnotsCount = aData.nKnots;
174  m_curr_entity.m_SplineControlCount = aData.nControl;
175  m_curr_entity.m_SplineFitCount = aData.nFit;
176 }
DXF2BRD_ENTITY_DATA m_curr_entity
unsigned int m_SplineFitCount
unsigned int m_SplineControlCount
unsigned int m_SplineKnotsCount
unsigned int m_SplineDegree
void DXF_IMPORT_PLUGIN::addText ( const DL_TextData &  aData)
overrideprivatevirtual

Definition at line 348 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddText(), PNS::angle(), GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, m_internalImporter, mapDim(), mapX(), mapY(), toNativeString(), updateImageLimits(), VECTOR2< T >::x, and VECTOR2< T >::y.

349 {
350  VECTOR2D refPoint( mapX( aData.ipx ), mapY( aData.ipy ) );
351  VECTOR2D secPoint( mapX( aData.apx ), mapY( aData.apy ) );
352 
353  if( aData.vJustification != 0 || aData.hJustification != 0 || aData.hJustification == 4 )
354  {
355  if( aData.hJustification != 3 && aData.hJustification != 5 )
356  {
357  VECTOR2D tmp = secPoint;
358  secPoint = refPoint;
359  refPoint = tmp;
360  }
361  }
362 
363  wxString text = toNativeString( wxString::FromUTF8( aData.text.c_str() ) );
364 
365  double textHeight = mapDim( aData.height );
366  // The 0.9 factor gives a better height/width ratio with our font
367  double charWidth = textHeight * 0.9;
368  double textWidth = charWidth * text.length(); // Rough approximation
369  double textThickness = textHeight/8.0; // Use a reasonable line thickness for this text
370 
371  VECTOR2D bottomLeft(0.0, 0.0);
372  VECTOR2D bottomRight(0.0, 0.0);
373  VECTOR2D topLeft(0.0, 0.0);
374  VECTOR2D topRight(0.0, 0.0);
375 
378 
379  switch( aData.vJustification )
380  {
381  case 0: //DRW_Text::VBaseLine:
382  case 1: //DRW_Text::VBottom:
383  vJustify = GR_TEXT_VJUSTIFY_BOTTOM;
384 
385  topLeft.y = textHeight;
386  topRight.y = textHeight;
387  break;
388 
389  case 2: //DRW_Text::VMiddle:
390  vJustify = GR_TEXT_VJUSTIFY_CENTER;
391 
392  bottomRight.y = -textHeight / 2.0;
393  bottomLeft.y = -textHeight / 2.0;
394  topLeft.y = textHeight / 2.0;
395  topRight.y = textHeight / 2.0;
396  break;
397 
398  case 3: //DRW_Text::VTop:
399  vJustify = GR_TEXT_VJUSTIFY_TOP;
400 
401  bottomLeft.y = -textHeight;
402  bottomRight.y = -textHeight;
403  break;
404  }
405 
406  switch( aData.hJustification )
407  {
408  case 0: //DRW_Text::HLeft:
409  case 3: //DRW_Text::HAligned: // no equivalent options in text pcb.
410  case 5: //DRW_Text::HFit: // no equivalent options in text pcb.
411  hJustify = GR_TEXT_HJUSTIFY_LEFT;
412 
413  bottomRight.x = textWidth;
414  topRight.x = textWidth;
415  break;
416 
417  case 1: //DRW_Text::HCenter:
418  case 4: //DRW_Text::HMiddle: // no equivalent options in text pcb.
419  hJustify = GR_TEXT_HJUSTIFY_CENTER;
420 
421  bottomLeft.x = -textWidth / 2.0;
422  topLeft.x = -textWidth / 2.0;
423  bottomRight.x = textWidth / 2.0;
424  topRight.x = textWidth / 2.0;
425  break;
426 
427  case 2: //DRW_Text::HRight:
428  hJustify = GR_TEXT_HJUSTIFY_RIGHT;
429 
430  bottomLeft.x = -textWidth;
431  topLeft.x = -textWidth;
432  break;
433  }
434 
435 #if 0
436  wxString sty = wxString::FromUTF8( aData.style.c_str() );
437  sty = sty.ToLower();
438 
439  if( aData.textgen == 2 )
440  {
441  // Text dir = left to right;
442  } else if( aData.textgen == 4 )
443  {
444  // Text dir = top to bottom;
445  } else
446  {
447  }
448 #endif
449 
450  double angle = aData.angle * 10;
451  double angleInRads = angle / 10.0 * M_PI / 180.0;
452  double cosine = cos(angleInRads);
453  double sine = sin(angleInRads);
454 
455  m_internalImporter.AddText( refPoint, text, textHeight, charWidth, textThickness, angle,
456  hJustify, vJustify );
457 
458  // Calculate the boundary box and update the image limits:
459  bottomLeft.x = bottomLeft.x * cosine - bottomLeft.y * sine;
460  bottomLeft.y = bottomLeft.x * sine + bottomLeft.y * cosine;
461 
462  bottomRight.x = bottomRight.x * cosine - bottomRight.y * sine;
463  bottomRight.y = bottomRight.x * sine + bottomRight.y * cosine;
464 
465  topLeft.x = topLeft.x * cosine - topLeft.y * sine;
466  topLeft.y = topLeft.x * sine + topLeft.y * cosine;
467 
468  topRight.x = topRight.x * cosine - topRight.y * sine;
469  topRight.y = topRight.x * sine + topRight.y * cosine;
470 
471  bottomLeft += refPoint;
472  bottomRight += refPoint;
473  topLeft += refPoint;
474  topRight += refPoint;
475 
476  updateImageLimits( bottomLeft );
477  updateImageLimits( bottomRight );
478  updateImageLimits( topLeft );
479  updateImageLimits( topRight );
480 
481 }
EDA_TEXT_HJUSTIFY_T
Definition: eda_text.h:62
double mapX(double aDxfCoordX)
void updateImageLimits(const VECTOR2D &aPoint)
static wxString toNativeString(const wxString &aData)
Converts a DXF encoded string into a native Unicode string.
double mapDim(double aDxfValue)
void AddText(const VECTOR2D &aOrigin, const wxString &aText, double aHeight, double aWidth, double aThickness, double aOrientation, EDA_TEXT_HJUSTIFY_T aHJustify, EDA_TEXT_VJUSTIFY_T aVJustify) override
Creates an object representing a text.
EDA_TEXT_VJUSTIFY_T
Definition: eda_text.h:69
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
double mapY(double aDxfCoordY)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::addTextStyle ( const DL_StyleData &  aData)
overrideprivatevirtual

Definition at line 853 of file dxf_import_plugin.cpp.

854 {
855  // TODO
856 }
virtual void DXF_IMPORT_PLUGIN::addTrace ( const DL_TraceData &  )
inlineoverrideprivatevirtual

Definition at line 306 of file dxf_import_plugin.h.

306 { reportMsg( "DL_Trace not managed" ); }
void reportMsg(const char *aMessage)
void DXF_IMPORT_PLUGIN::addVertex ( const DL_VertexData &  aData)
overrideprivatevirtual

Called for every polyline vertex.

Definition at line 238 of file dxf_import_plugin.cpp.

References abs, insertArc(), insertLine(), DXF2BRD_ENTITY_DATA::m_BulgeVertex, m_curr_entity, m_DXF2mm, DXF2BRD_ENTITY_DATA::m_EntityParseStatus, DXF2BRD_ENTITY_DATA::m_LastCoordinate, DXF2BRD_ENTITY_DATA::m_PolylineStart, m_xOffset, m_yOffset, mapWidth(), MIN_BULGE, VECTOR2< T >::x, and VECTOR2< T >::y.

239 {
241  return; // Error
242 
243  double lineWidth = mapWidth( attributes.getWidth() );
244 
245  const DL_VertexData* vertex = &aData;
246 
247  if( m_curr_entity.m_EntityParseStatus == 1 ) // This is the first vertex of an entity
248  {
252  m_curr_entity.m_BulgeVertex = vertex->bulge;
254  return;
255  }
256 
257  VECTOR2D seg_end( m_xOffset + vertex->x * m_DXF2mm,
258  m_yOffset - vertex->y * m_DXF2mm );
259 
261  insertLine( m_curr_entity.m_LastCoordinate, seg_end, lineWidth );
262  else
264 
266  m_curr_entity.m_BulgeVertex = vertex->bulge;
267 }
DXF2BRD_ENTITY_DATA m_curr_entity
void insertArc(const VECTOR2D &aSegStart, const VECTOR2D &aSegEnd, double aBulge, int aWidth)
#define MIN_BULGE
#define abs(a)
Definition: auxiliary.h:84
double mapWidth(double aDxfWidth)
void insertLine(const VECTOR2D &aSegStart, const VECTOR2D &aSegEnd, int aWidth)
void DXF_IMPORT_PLUGIN::endEntity ( )
overrideprivatevirtual

Definition at line 270 of file dxf_import_plugin.cpp.

References abs, DXF2BRD_ENTITY_DATA::Clear(), insertArc(), insertLine(), insertSpline(), DXF2BRD_ENTITY_DATA::m_BulgeVertex, m_curr_entity, DXF2BRD_ENTITY_DATA::m_EntityFlag, DXF2BRD_ENTITY_DATA::m_EntityType, DXF2BRD_ENTITY_DATA::m_LastCoordinate, DXF2BRD_ENTITY_DATA::m_PolylineStart, mapWidth(), and MIN_BULGE.

271 {
272  if( m_curr_entity.m_EntityType == DL_ENTITY_POLYLINE ||
273  m_curr_entity.m_EntityType == DL_ENTITY_LWPOLYLINE )
274  {
275  // Polyline flags bit 0 indicates closed (1) or open (0) polyline
276  if( m_curr_entity.m_EntityFlag & 1 )
277  {
278  double lineWidth = mapWidth( attributes.getWidth() );
279 
282  else
284  m_curr_entity.m_BulgeVertex, lineWidth );
285  }
286  }
287 
288  if( m_curr_entity.m_EntityType == DL_ENTITY_SPLINE )
289  {
290  double lineWidth = mapWidth( attributes.getWidth() );
291  insertSpline( lineWidth );
292  }
293 
295 }
DXF2BRD_ENTITY_DATA m_curr_entity
void insertArc(const VECTOR2D &aSegStart, const VECTOR2D &aSegEnd, double aBulge, int aWidth)
#define MIN_BULGE
#define abs(a)
Definition: auxiliary.h:84
double mapWidth(double aDxfWidth)
void insertSpline(int aWidth)
void insertLine(const VECTOR2D &aSegStart, const VECTOR2D &aSegEnd, int aWidth)
const wxArrayString DXF_IMPORT_PLUGIN::GetFileExtensions ( ) const
inlineoverridevirtual

Returns a string array of the file extensions handled by this plugin.

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 146 of file dxf_import_plugin.h.

References Load().

147  {
148  wxArrayString list;
149  list.Add( "dxf" );
150  return list;
151  }
double DXF_IMPORT_PLUGIN::GetImageHeight ( ) const
overridevirtual

Return image height from original imported file.

Returns
Original Image height in mm.

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 99 of file dxf_import_plugin.cpp.

References m_maxY, and m_minY.

100 {
101  return m_maxY - m_minY;
102 }
double DXF_IMPORT_PLUGIN::GetImageWidth ( ) const
overridevirtual

Return image width from original imported file.

Returns
Original Image width in mm.

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 93 of file dxf_import_plugin.cpp.

References m_maxX, and m_minX.

94 {
95  return m_maxX - m_minX;
96 }
const std::string& DXF_IMPORT_PLUGIN::GetMessages ( ) const
inlineoverridevirtual
Returns
the list of messages in one string. Each message ends by '
'

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 214 of file dxf_import_plugin.h.

References DSN::mapX(), and DSN::mapY().

215  {
216  return m_messages;
217  }
const wxString DXF_IMPORT_PLUGIN::GetName ( ) const
inlineoverridevirtual

Returns the plugin name.

This string will be used as the description in the file dialog.

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 141 of file dxf_import_plugin.h.

142  {
143  return "AutoCAD DXF";
144  }
wxString GRAPHICS_IMPORT_PLUGIN::GetWildcards ( ) const
inlineinherited

Returns a list of wildcards that contains the file extensions handled by this plugin, separated with a coma.

Definition at line 66 of file graphics_import_plugin.h.

References GRAPHICS_IMPORT_PLUGIN::GetFileExtensions(), GRAPHICS_IMPORT_PLUGIN::GetImageHeight(), GRAPHICS_IMPORT_PLUGIN::GetImageWidth(), GRAPHICS_IMPORT_PLUGIN::GetMessages(), GRAPHICS_IMPORT_PLUGIN::Import(), and GRAPHICS_IMPORT_PLUGIN::Load().

67  {
68  wxString ret;
69  bool first = true;
70 
71  for( const auto& extension : GetFileExtensions() )
72  {
73  if( first )
74  first = false;
75  else
76  ret += ", ";
77 
78  ret += "*." + extension;
79  }
80 
81  return ret;
82  }
virtual const wxArrayString GetFileExtensions() const =0
Returns a string array of the file extensions handled by this plugin.
bool DXF_IMPORT_PLUGIN::Import ( )
overridevirtual

Actually imports the file.

It is necessary to have loaded the file beforehand.

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 84 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::ImportTo(), GRAPHICS_IMPORT_PLUGIN::m_importer, and m_internalImporter.

85 {
86  wxCHECK( m_importer, false );
88 
89  return true;
90 }
GRAPHICS_IMPORTER * m_importer
Importer used to create objects representing the imported shapes.
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void ImportTo(GRAPHICS_IMPORTER &aImporter)
void DXF_IMPORT_PLUGIN::ImportAsFootprintGraphic ( bool  aImportAsFootprintGraphic)
inline

Allows the import DXF items converted to board graphic items or footprint graphic items.

Parameters
aImportAsFootprintGraphic= true to import in a footprint, false to import on a board

Definition at line 166 of file dxf_import_plugin.h.

167  {
168  m_importAsfootprintGraphicItems = aImportAsFootprintGraphic;
169  }
bool DXF_IMPORT_PLUGIN::ImportDxfFile ( const wxString &  aFile)

Implementation of the method used for communicate with this filter.

Parameters
aFile= the full filename.

Definition at line 134 of file dxf_import_plugin.cpp.

References TO_UTF8.

Referenced by Load().

135 {
136  DL_Dxf dxf_reader;
137  std::string filename = TO_UTF8( aFile );
138 
139  // wxFopen takes care of unicode filenames across platforms
140  FILE* fp = wxFopen( aFile, "rt" );
141 
142  if( fp == nullptr )
143  return false;
144 
145  // Note the dxf reader takes care of switching to "C" locale before reading the file
146  // and will close the file after reading
147  bool success = dxf_reader.in( fp, this );
148 
149  return success;
150 }
#define TO_UTF8(wxstring)
Macro TO_UTF8 converts a wxString to a UTF8 encoded C string for all wxWidgets build modes...
Definition: macros.h:47
void DXF_IMPORT_PLUGIN::insertArc ( const VECTOR2D aSegStart,
const VECTOR2D aSegEnd,
double  aBulge,
int  aWidth 
)
private

Definition at line 871 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddArc(), PNS::angle(), m_internalImporter, RAD2DECIDEG(), SCALE_FACTOR, updateImageLimits(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by addVertex(), and endEntity().

873 {
874  VECTOR2D segment_startpoint( SCALE_FACTOR( aSegStart.x ), SCALE_FACTOR( aSegStart.y ) );
875  VECTOR2D segment_endpoint( SCALE_FACTOR( aSegEnd.x ), SCALE_FACTOR( aSegEnd.y ) );
876 
877  // ensure aBulge represents an angle from +/- ( 0 .. approx 359.8 deg )
878  if( aBulge < -2000.0 )
879  aBulge = -2000.0;
880  else if( aBulge > 2000.0 )
881  aBulge = 2000.0;
882 
883  double ang = 4.0 * atan( aBulge );
884 
885  // reflect the Y values to put everything in a RHCS
886  VECTOR2D sp( aSegStart.x, -aSegStart.y );
887  VECTOR2D ep( aSegEnd.x, -aSegEnd.y );
888  // angle from end->start
889  double offAng = atan2( ep.y - sp.y, ep.x - sp.x );
890  // length of subtended segment = 1/2 distance between the 2 points
891  double d = 0.5 * sqrt( (sp.x - ep.x) * (sp.x - ep.x) + (sp.y - ep.y) * (sp.y - ep.y) );
892  // midpoint of the subtended segment
893  double xm = ( sp.x + ep.x ) * 0.5;
894  double ym = ( sp.y + ep.y ) * 0.5;
895  double radius = d / sin( ang * 0.5 );
896 
897  if( radius < 0.0 )
898  radius = -radius;
899 
900  // calculate the height of the triangle with base d and hypotenuse r
901  double dh2 = radius * radius - d * d;
902 
903  // this should only ever happen due to rounding errors when r == d
904  if( dh2 < 0.0 )
905  dh2 = 0.0;
906 
907  double h = sqrt( dh2 );
908 
909  if( ang < 0.0 )
910  offAng -= M_PI_2;
911  else
912  offAng += M_PI_2;
913 
914  // for angles greater than 180 deg we need to flip the
915  // direction in which the arc center is found relative
916  // to the midpoint of the subtended segment.
917  if( ang < -M_PI )
918  offAng += M_PI;
919  else if( ang > M_PI )
920  offAng -= M_PI;
921 
922  // center point
923  double cx = h * cos( offAng ) + xm;
924  double cy = h * sin( offAng ) + ym;
925  VECTOR2D center( SCALE_FACTOR( cx ), SCALE_FACTOR( -cy ) );
926  VECTOR2D arc_start;
927  double angle = RAD2DECIDEG( ang );
928 
929  if( ang < 0.0 )
930  {
931  arc_start = VECTOR2D( SCALE_FACTOR( ep.x ), SCALE_FACTOR( -ep.y ) );
932  }
933  else
934  {
935  arc_start = VECTOR2D( SCALE_FACTOR( sp.x ), SCALE_FACTOR( -sp.y ) );
936  angle = -angle;
937  }
938 
939  m_internalImporter.AddArc( center, arc_start, angle, aWidth );
940 
941  VECTOR2D radiusDelta( SCALE_FACTOR( radius ), SCALE_FACTOR( radius ) );
942 
943  updateImageLimits( center + radiusDelta );
944  updateImageLimits( center - radiusDelta );
945  return;
946 }
void AddArc(const VECTOR2D &aCenter, const VECTOR2D &aStart, double aAngle, double aWidth) override
Creates an object representing an arc.
double RAD2DECIDEG(double rad)
Definition: trigo.h:204
void updateImageLimits(const VECTOR2D &aPoint)
#define SCALE_FACTOR(x)
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::insertLine ( const VECTOR2D aSegStart,
const VECTOR2D aSegEnd,
int  aWidth 
)
private

Definition at line 859 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddLine(), m_internalImporter, SCALE_FACTOR, updateImageLimits(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by addVertex(), and endEntity().

861 {
862  VECTOR2D origin( SCALE_FACTOR( aSegStart.x ), SCALE_FACTOR( aSegStart.y ) );
863  VECTOR2D end( SCALE_FACTOR( aSegEnd.x ), SCALE_FACTOR( aSegEnd.y ) );
864  m_internalImporter.AddLine( origin, end, aWidth );
865 
866  updateImageLimits( origin );
867  updateImageLimits( end );
868 }
void AddLine(const VECTOR2D &aStart, const VECTOR2D &aEnd, double aWidth) override
Creates an object representing a line segment.
void updateImageLimits(const VECTOR2D &aPoint)
#define SCALE_FACTOR(x)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
void DXF_IMPORT_PLUGIN::insertSpline ( int  aWidth)
private

Definition at line 951 of file dxf_import_plugin.cpp.

References GRAPHICS_IMPORTER_BUFFER::AddLine(), GRAPHICS_IMPORTER_BUFFER::AddSpline(), m_curr_entity, m_internalImporter, DXF2BRD_ENTITY_DATA::m_SplineControlPointList, DXF2BRD_ENTITY_DATA::m_SplineDegree, DXF2BRD_ENTITY_DATA::m_SplineFitPointList, DXF2BRD_ENTITY_DATA::m_SplineKnotsList, mapX(), mapY(), and updateImageLimits().

Referenced by endEntity().

952 {
953  #if 0 // Debug only
954  wxLogMessage("spl deg %d kn %d ctr %d fit %d",
959  #endif
960 
961  unsigned imax = m_curr_entity.m_SplineControlPointList.size();
962 
963  if( imax < 2 ) // malformed spline
964  return;
965 
966 #if 0 // set to 1 to approximate the spline by segments between 2 control points
967  VECTOR2D startpoint( mapX( m_curr_entity.m_SplineControlPointList[0].m_x ),
969 
970  for( unsigned int ii = 1; ii < imax; ++ii )
971  {
974 
975  if( startpoint != endpoint )
976  {
977  m_internalImporter.AddLine( startpoint, endpoint );
978 
979  updateImageLimits( startpoint );
980  updateImageLimits( endpoint );
981 
982  startpoint = endpoint;
983  }
984  }
985 #else // Use bezier curves, supported by pcbnew, to approximate the spline
986  tinyspline::BSpline dxfspline( m_curr_entity.m_SplineControlPointList.size(),
987  /* coord dim */ 2, m_curr_entity.m_SplineDegree );
988  std::vector<double> ctrlp;
989 
990  for( unsigned ii = 0; ii < imax; ++ii )
991  {
992  ctrlp.push_back( m_curr_entity.m_SplineControlPointList[ii].m_x );
993  ctrlp.push_back( m_curr_entity.m_SplineControlPointList[ii].m_y );
994  }
995 
996  dxfspline.setCtrlp( ctrlp );
997  dxfspline.setKnots( m_curr_entity.m_SplineKnotsList );
998  tinyspline::BSpline beziers( dxfspline.toBeziers() );
999 
1000  std::vector<double> coords = beziers.ctrlp();
1001 
1002  // Each Bezier curve uses 4 vertices (a start point, 2 control points and a end point).
1003  // So we can have more than one Bezier curve ( there are one curve each four vertices)
1004  for( unsigned ii = 0; ii < coords.size(); ii += 8 )
1005  {
1006  VECTOR2D start( mapX( coords[ii] ), mapY( coords[ii+1] ) );
1007  VECTOR2D bezierControl1( mapX( coords[ii+2] ), mapY( coords[ii+3] ) );
1008  VECTOR2D bezierControl2( mapX( coords[ii+4] ), mapY( coords[ii+5] ) );
1009  VECTOR2D end( mapX( coords[ii+6] ), mapY( coords[ii+7] ) );
1010  m_internalImporter.AddSpline( start, bezierControl1, bezierControl2, end , aWidth );
1011  }
1012 #endif
1013 }
DXF2BRD_ENTITY_DATA m_curr_entity
void AddLine(const VECTOR2D &aStart, const VECTOR2D &aEnd, double aWidth) override
Creates an object representing a line segment.
double mapX(double aDxfCoordX)
std::vector< VECTOR2D > m_SplineFitPointList
void updateImageLimits(const VECTOR2D &aPoint)
void AddSpline(const VECTOR2D &aStart, const VECTOR2D &BezierControl1, const VECTOR2D &BezierControl2, const VECTOR2D &aEnd, double aWidth) override
Creates an object representing an arc.
unsigned int m_SplineDegree
double mapY(double aDxfCoordY)
GRAPHICS_IMPORTER_BUFFER m_internalImporter
std::vector< double > m_SplineKnotsList
std::vector< SPLINE_CTRL_POINT > m_SplineControlPointList
virtual void DXF_IMPORT_PLUGIN::linkImage ( const DL_ImageDefData &  )
inlineoverrideprivatevirtual

Definition at line 311 of file dxf_import_plugin.h.

311 { reportMsg( "DL_ImageDef not managed" ); }
void reportMsg(const char *aMessage)
bool DXF_IMPORT_PLUGIN::Load ( const wxString &  aFileName)
overridevirtual

Loads file for import.

It is necessary to have the GRAPHICS_IMPORTER object set before.

Implements GRAPHICS_IMPORT_PLUGIN.

Definition at line 78 of file dxf_import_plugin.cpp.

References ImportDxfFile().

79 {
80  return ImportDxfFile( aFileName );
81 }
bool ImportDxfFile(const wxString &aFile)
Implementation of the method used for communicate with this filter.
double DXF_IMPORT_PLUGIN::mapDim ( double  aDxfValue)
private

Definition at line 117 of file dxf_import_plugin.cpp.

References m_DXF2mm, and SCALE_FACTOR.

Referenced by addArc(), addCircle(), addMText(), and addText().

118 {
119  return SCALE_FACTOR( aDxfValue * m_DXF2mm );
120 }
#define SCALE_FACTOR(x)
double DXF_IMPORT_PLUGIN::mapWidth ( double  aDxfWidth)
private

Definition at line 123 of file dxf_import_plugin.cpp.

References m_defaultThickness, m_DXF2mm, and SCALE_FACTOR.

Referenced by addArc(), addCircle(), addLine(), addVertex(), and endEntity().

124 {
125  // Always return the default line width
126 #if 0
127  // mapWidth returns the aDxfValue if aDxfWidth > 0 m_defaultThickness
128  if( aDxfWidth > 0.0 )
129  return SCALE_FACTOR( aDxfWidth * m_DXF2mm );
130 #endif
132 }
#define SCALE_FACTOR(x)
double DXF_IMPORT_PLUGIN::mapX ( double  aDxfCoordX)
private

Definition at line 105 of file dxf_import_plugin.cpp.

References m_DXF2mm, m_xOffset, and SCALE_FACTOR.

Referenced by addArc(), addCircle(), addLine(), addMText(), addText(), and insertSpline().

106 {
107  return SCALE_FACTOR( m_xOffset + ( aDxfCoordX * m_DXF2mm ) );
108 }
#define SCALE_FACTOR(x)
double DXF_IMPORT_PLUGIN::mapY ( double  aDxfCoordY)
private

Definition at line 111 of file dxf_import_plugin.cpp.

References m_DXF2mm, m_yOffset, and SCALE_FACTOR.

Referenced by addArc(), addCircle(), addLine(), addMText(), addText(), and insertSpline().

112 {
113  return SCALE_FACTOR( m_yOffset - ( aDxfCoordY * m_DXF2mm ) );
114 }
#define SCALE_FACTOR(x)
void DXF_IMPORT_PLUGIN::reportMsg ( const char *  aMessage)
private

Definition at line 153 of file dxf_import_plugin.cpp.

References m_messages.

154 {
155  // Add message to keep trace of not handled dxf entities
156  m_messages += aMessage;
157  m_messages += '\n';
158 }
void DXF_IMPORT_PLUGIN::SetBrdLayer ( int  aBrdLayer)
inline

Set the layer number to import dxf items.

the layer should be a techicanl layer, not a copper layer

Definition at line 201 of file dxf_import_plugin.h.

201 { m_brdLayer = aBrdLayer; }
void DXF_IMPORT_PLUGIN::SetDefaultLineWidthMM ( double  aWidth)
inline

Set the default line width when importing dxf items like lines to Pcbnew.

because dxf files have no line width explicit parameter, it will be most of time the line width of imported lines

Parameters
aWidth= line width in mm

Definition at line 178 of file dxf_import_plugin.h.

179  {
180  m_defaultThickness = aWidth;
181  }
void GRAPHICS_IMPORT_PLUGIN::SetImporter ( GRAPHICS_IMPORTER aImporter)
inlineinherited

Sets the receiver of the imported shapes.

Definition at line 45 of file graphics_import_plugin.h.

References GRAPHICS_IMPORT_PLUGIN::GetFileExtensions(), GRAPHICS_IMPORT_PLUGIN::GetName(), and GRAPHICS_IMPORT_PLUGIN::m_importer.

46  {
47  m_importer = aImporter;
48  }
GRAPHICS_IMPORTER * m_importer
Importer used to create objects representing the imported shapes.
void DXF_IMPORT_PLUGIN::SetOffset ( double  aOffsetX,
double  aOffsetY 
)
inline

Set the coordinate offset between the imported dxf items and Pcbnew.

because dxf files have the Y axis from bottom to top; aOffsetX = 0, and aOffsetY = - vertical page size to import a full page

Parameters
aOffsetX= the X offset in mm
aOffsetY= the Y offset in mm

Definition at line 191 of file dxf_import_plugin.h.

192  {
193  m_xOffset = aOffsetX;
194  m_yOffset = aOffsetY;
195  }
virtual void DXF_IMPORT_PLUGIN::setVariableDouble ( const std::string &  key,
double  value,
int  code 
)
inlineoverrideprivatevirtual

Called for every double variable in the DXF file (e.g.

"$DIMEXO").

Definition at line 257 of file dxf_import_plugin.h.

257 {}
void DXF_IMPORT_PLUGIN::setVariableInt ( const std::string &  key,
int  value,
int  code 
)
overrideprivatevirtual

Called for every int variable in the DXF file (e.g.

"$ACADMAINTVER").

Definition at line 636 of file dxf_import_plugin.cpp.

References m_codePage, and m_DXF2mm.

637 {
638  // Called for every int variable in the DXF file (e.g. "$INSUNITS").
639 
640  if( key == "$DWGCODEPAGE" )
641  {
642  m_codePage = value;
643  return;
644  }
645 
646  if( key == "$INSUNITS" ) // Drawing units
647  {
648  switch( value )
649  {
650  case 1: // inches
651  m_DXF2mm = 25.4;
652  break;
653 
654  case 2: // feet
655  m_DXF2mm = 304.8;
656  break;
657 
658  case 4: // mm
659  m_DXF2mm = 1.0;
660  break;
661 
662  case 5: // centimeters
663  m_DXF2mm = 10.0;
664  break;
665 
666  case 6: // meters
667  m_DXF2mm = 1000.0;
668  break;
669 
670  case 8: // microinches
671  m_DXF2mm = 2.54e-5;
672  break;
673 
674  case 9: // mils
675  m_DXF2mm = 0.0254;
676  break;
677 
678  case 10: // yards
679  m_DXF2mm = 914.4;
680  break;
681 
682  case 11: // Angstroms
683  m_DXF2mm = 1.0e-7;
684  break;
685 
686  case 12: // nanometers
687  m_DXF2mm = 1.0e-6;
688  break;
689 
690  case 13: // micrometers
691  m_DXF2mm = 1.0e-3;
692  break;
693 
694  case 14: // decimeters
695  m_DXF2mm = 100.0;
696  break;
697 
698  default:
699  // use the default of 1.0 for:
700  // 0: Unspecified Units
701  // 3: miles
702  // 7: kilometers
703  // 15: decameters
704  // 16: hectometers
705  // 17: gigameters
706  // 18: AU
707  // 19: lightyears
708  // 20: parsecs
709  m_DXF2mm = 1.0;
710  break;
711  }
712 
713  return;
714  }
715 }
void DXF_IMPORT_PLUGIN::setVariableString ( const std::string &  key,
const std::string &  value,
int  code 
)
overrideprivatevirtual

Called for every string variable in the DXF file (e.g.

"$ACADVER").

Definition at line 718 of file dxf_import_plugin.cpp.

720 {
721  // Called for every string variable in the DXF file (e.g. "$ACADVER").
722 }
wxString DXF_IMPORT_PLUGIN::toDxfString ( const wxString &  aStr)
staticprivate

Converts a native unicode string into a DXF encoded string.

DXF endoding includes the following special sequences:

  • %%c for a diameter sign
  • %%d for a degree sign
  • %%p for a plus/minus sign

Definition at line 725 of file dxf_import_plugin.cpp.

References i.

726 {
727  wxString res;
728  int j = 0;
729 
730  for( unsigned i = 0; i<aStr.length(); ++i )
731  {
732  int c = aStr[i];
733 
734  if( c > 175 || c < 11 )
735  {
736  res.append( aStr.Mid( j, i - j ) );
737  j = i;
738 
739  switch( c )
740  {
741  case 0x0A:
742  res += wxT( "\\P" );
743  break;
744 
745  // diameter:
746 #ifdef __WINDOWS_
747  // windows, as always, is special.
748  case 0x00D8:
749 #else
750  case 0x2205:
751 #endif
752  res += wxT( "%%C" );
753  break;
754 
755  // degree:
756  case 0x00B0:
757  res += wxT( "%%D" );
758  break;
759 
760  // plus/minus
761  case 0x00B1:
762  res += wxT( "%%P" );
763  break;
764 
765  default:
766  j--;
767  break;
768  }
769 
770  j++;
771  }
772  }
773 
774  res.append( aStr.Mid( j ) );
775  return res;
776 }
size_t i
Definition: json11.cpp:597
wxString DXF_IMPORT_PLUGIN::toNativeString ( const wxString &  aData)
staticprivate

Converts a DXF encoded string into a native Unicode string.

Definition at line 779 of file dxf_import_plugin.cpp.

References i.

Referenced by addMText(), and addText().

780 {
781  wxString res;
782 
783  // Ignore font tags:
784  int j = 0;
785 
786  for( unsigned i = 0; i < aData.length(); ++i )
787  {
788  if( aData[ i ] == 0x7B ) // is '{' ?
789  {
790  if( aData[ i + 1 ] == 0x5c && aData[ i + 2 ] == 0x66 ) // is "\f" ?
791  {
792  // found font tag, append parsed part
793  res.append( aData.Mid( j, i - j ) );
794 
795  // skip to ';'
796  for( unsigned k = i + 3; k < aData.length(); ++k )
797  {
798  if( aData[ k ] == 0x3B )
799  {
800  i = j = ++k;
801  break;
802  }
803  }
804 
805  // add to '}'
806  for( unsigned k = i; k < aData.length(); ++k )
807  {
808  if( aData[ k ] == 0x7D )
809  {
810  res.append( aData.Mid( i, k - i ) );
811  i = j = ++k;
812  break;
813  }
814  }
815  }
816  }
817  }
818 
819  res.append( aData.Mid( j ) );
820 
821 #if 1
822  wxRegEx regexp;
823  // Line feed:
824  regexp.Compile( wxT( "\\\\P" ) );
825  regexp.Replace( &res, wxT( "\n" ) );
826 
827  // Space:
828  regexp.Compile( wxT( "\\\\~" ) );
829  regexp.Replace( &res, wxT( " " ) );
830 
831  // diameter:
832  regexp.Compile( wxT( "%%[cC]" ) );
833 #ifdef __WINDOWS__
834  // windows, as always, is special.
835  regexp.Replace( &res, wxChar( 0xD8 ) );
836 #else
837  // Empty_set, diameter is 0x2300
838  regexp.Replace( &res, wxChar( 0x2205 ) );
839 #endif
840 
841  // degree:
842  regexp.Compile( wxT( "%%[dD]" ) );
843  regexp.Replace( &res, wxChar( 0x00B0 ) );
844  // plus/minus
845  regexp.Compile( wxT( "%%[pP]" ) );
846  regexp.Replace( &res, wxChar( 0x00B1 ) );
847 #endif
848 
849  return res;
850 }
size_t i
Definition: json11.cpp:597
void DXF_IMPORT_PLUGIN::updateImageLimits ( const VECTOR2D aPoint)

Definition at line 1016 of file dxf_import_plugin.cpp.

References m_maxX, m_maxY, m_minX, m_minY, max, min, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by addArc(), addCircle(), addLine(), addMText(), addText(), insertArc(), insertLine(), and insertSpline().

1017 {
1018  m_minX = std::min( aPoint.x, m_minX );
1019  m_maxX = std::max( aPoint.x, m_maxX );
1020 
1021  m_minY = std::min( aPoint.y, m_minY );
1022  m_maxY = std::max( aPoint.y, m_maxY );
1023 }
#define max(a, b)
Definition: auxiliary.h:86
#define min(a, b)
Definition: auxiliary.h:85
void DXF_IMPORT_PLUGIN::writeLine ( )
private
void DXF_IMPORT_PLUGIN::writeMtext ( )
private

Member Data Documentation

int DXF_IMPORT_PLUGIN::m_brdLayer
private

Definition at line 122 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN().

std::string DXF_IMPORT_PLUGIN::m_codePage
private

Definition at line 124 of file dxf_import_plugin.h.

Referenced by setVariableInt().

DXF2BRD_ENTITY_DATA DXF_IMPORT_PLUGIN::m_curr_entity
private
double DXF_IMPORT_PLUGIN::m_defaultThickness
private

Definition at line 120 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN(), and mapWidth().

double DXF_IMPORT_PLUGIN::m_DXF2mm
private
bool DXF_IMPORT_PLUGIN::m_importAsfootprintGraphicItems
private

Definition at line 125 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN().

GRAPHICS_IMPORTER* GRAPHICS_IMPORT_PLUGIN::m_importer
protectedinherited

Importer used to create objects representing the imported shapes.

Definition at line 122 of file graphics_import_plugin.h.

Referenced by SVG_IMPORT_PLUGIN::DrawLineSegments(), SVG_IMPORT_PLUGIN::DrawPolygon(), Import(), SVG_IMPORT_PLUGIN::Load(), and GRAPHICS_IMPORT_PLUGIN::SetImporter().

GRAPHICS_IMPORTER_BUFFER DXF_IMPORT_PLUGIN::m_internalImporter
private
double DXF_IMPORT_PLUGIN::m_maxX
private

Definition at line 131 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN(), GetImageWidth(), and updateImageLimits().

double DXF_IMPORT_PLUGIN::m_maxY
private

Definition at line 132 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN(), GetImageHeight(), and updateImageLimits().

std::string DXF_IMPORT_PLUGIN::m_messages
private

Definition at line 127 of file dxf_import_plugin.h.

Referenced by reportMsg().

double DXF_IMPORT_PLUGIN::m_minX
private

Definition at line 131 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN(), GetImageWidth(), and updateImageLimits().

double DXF_IMPORT_PLUGIN::m_minY
private

Definition at line 132 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN(), GetImageHeight(), and updateImageLimits().

int DXF_IMPORT_PLUGIN::m_version
private

Definition at line 123 of file dxf_import_plugin.h.

Referenced by DXF_IMPORT_PLUGIN().

double DXF_IMPORT_PLUGIN::m_xOffset
private

Definition at line 118 of file dxf_import_plugin.h.

Referenced by addVertex(), DXF_IMPORT_PLUGIN(), and mapX().

double DXF_IMPORT_PLUGIN::m_yOffset
private

Definition at line 119 of file dxf_import_plugin.h.

Referenced by addVertex(), DXF_IMPORT_PLUGIN(), and mapY().


The documentation for this class was generated from the following files: