dxf_import_plugin.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 1992-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef DXF2BRD_ITEMS_H
#define DXF2BRD_ITEMS_H
 
#include "graphics_import_plugin.h"
#include "graphics_importer_buffer.h"
 
#include <dl_creationadapter.h>
#include <dl_dxf.h>
#include <math/vector3.h>
#include <math/matrix3x3.h>
#include <wildcards_and_files_ext.h>
 
#include <list>
 
class BOARD;
class BOARD_ITEM;
 
struct SPLINE_CTRL_POINT
{
 double m_x;
 double m_y;
 double m_weight;
 
 SPLINE_CTRL_POINT( double a_x, double a_y, double a_weight )
 : m_x( a_x ), m_y( a_y ), m_weight( a_weight )
 {}
};
 
class DXF2BRD_ENTITY_DATA
{
public:
 DXF2BRD_ENTITY_DATA() { Clear(); };
 
 // Reset the entity parameters
 void Clear()
 {
 m_EntityType = DL_UNKNOWN;
 m_EntityParseStatus = 0;
 m_EntityFlag = 0;
 m_SplineDegree = 1;
 m_SplineKnotsCount = 0;
 m_SplineControlCount = 0;
 m_SplineFitCount = 0;
 m_SplineTangentStartX = 0.0;
 m_SplineTangentStartY = 0.0;
 m_SplineTangentEndX = 0.0;
 m_SplineTangentEndY = 0.0;
 m_BulgeVertex = 0.0;
 m_SplineKnotsList.clear();
 m_SplineControlPointList.clear();
 m_SplineFitPointList.clear();
 }
 
 int m_EntityType; // the DXF type of entity
 int m_EntityParseStatus; // Inside a entity: status of parsing:
 // 0 = no entity
 // 1 = first item of entity
 // 2 = entity in progress
 int m_EntityFlag; // a info flag to parse entities
 
 VECTOR2D m_LastCoordinate; // the last vertex coordinate read (unit = mm)
 VECTOR2D m_PolylineStart; // The first point of the polyline entity, when reading a
 // polyline (unit = mm)
 double m_BulgeVertex; // the last vertex bulge value read
 
 // for spline parsing: parameters
 unsigned int m_SplineDegree;
 unsigned int m_SplineKnotsCount;
 unsigned int m_SplineControlCount;
 unsigned int m_SplineFitCount;
 double m_SplineTangentStartX; // tangent dir X for the start point
 double m_SplineTangentStartY; // tangent dir Y for the start point
 double m_SplineTangentEndX; // tangent dir X for the end point
 double m_SplineTangentEndY; // tangent dir Y for the end point
 
 // for spline parsing: buffers to store control points, fit points and knot
 std::vector<double> m_SplineKnotsList; // knots list, code 40
 // control points list coordinates, code 10, 20 & 30 (only X and Y cood and Weight)
 std::vector<SPLINE_CTRL_POINT> m_SplineControlPointList;
 // fit points list, code 11, 21 & 31 (only X and Y cood)
 std::vector<VECTOR2D> m_SplineFitPointList;
};
 
// Magic constants as defined by dxf specification for line weight
#define DXF_IMPORT_LINEWEIGHT_BY_LAYER -1
#define DXF_IMPORT_LINEWEIGHT_BY_BLOCK -2
#define DXF_IMPORT_LINEWEIGHT_BY_LW_DEFAULT -3
 
class DXF_IMPORT_LAYER
{
public:
 wxString m_layerName;
 int m_lineWeight;
 
 DXF_IMPORT_LAYER( const wxString& aName, int aLineWeight )
 {
 m_layerName = aName;
 m_lineWeight = aLineWeight;
 }
};
 
class DXF_IMPORT_BLOCK
{
public:
 wxString m_name;
 double m_baseX, m_baseY;
 
 GRAPHICS_IMPORTER_BUFFER m_buffer;
 
 DXF_IMPORT_BLOCK( const wxString& aName, double aX, double aY )
 {
 m_name = aName;
 m_baseX = aX;
 m_baseY = aY;
 }
};
 
class DXF_IMPORT_STYLE
{
public:
 wxString m_name;
 double m_textHeight;
 double m_widthFactor;
 bool m_bold;
 bool m_italic;
 
 DXF_IMPORT_STYLE( const wxString& aName, double aTextHeight, double aWidthFactor, bool aBold,
 bool aItalic )
 {
 m_name = aName;
 m_textHeight = aTextHeight;
 m_widthFactor = aWidthFactor;
 m_bold = aBold;
 m_italic = aItalic;
 }
};
 
 
enum class DXF_IMPORT_UNITS
{
 DEFAULT = 0,
 INCHES = 1,
 FEET = 2,
 MILLIMETERS = 4,
 CENTIMETERS = 5,
 METERS = 6,
 MICROINCHES = 8,
 MILS = 9,
 YARDS = 10,
 ANGSTROMS = 11,
 NANOMETERS = 12,
 MICRONS = 13,
 DECIMETERS = 14,
 DECAMETERS = 15,
 HECTOMETERS = 16,
 GIGAMETERS = 17,
 ASTRONOMICAL = 18,
 LIGHTYEARS = 19,
 PARSECS = 20
};
 
 
#if 0 //defined(DEBUG)
// For dxf import debug:
#define ON_UNSUPPORTED( error_msg ) wxLogMessage( wxT( error_msg ) )
#else
#define ON_UNSUPPORTED( error_msg )
#endif
 
class DXF_IMPORT_PLUGIN : public GRAPHICS_IMPORT_PLUGIN, public DL_CreationAdapter
{
public:
 DXF_IMPORT_PLUGIN();
 ~DXF_IMPORT_PLUGIN();
 
 const wxString GetName() const override
 {
 return "AutoCAD DXF";
 }
 
 const std::vector<std::string> GetFileExtensions() const override
 {
 static std::vector<std::string> exts = { "dxf" };
 return exts;
 }
 
 bool Load( const wxString& aFileName ) override;
 bool Import() override;
 
 double GetImageWidth() const override;
 double GetImageHeight() const override;
 
 void updateImageLimits( const VECTOR2D& aPoint );
 
 virtual void SetImporter( GRAPHICS_IMPORTER* aImporter ) override;
 
 void ImportAsFootprintGraphic( bool aImportAsFootprintGraphic )
 {
 m_importAsFPShapes = aImportAsFootprintGraphic;
 }
 
 void SetUnit( DXF_IMPORT_UNITS aUnit )
 {
 m_currentUnit = aUnit;
 }
 
 void SetDefaultLineWidthMM( double aWidth )
 {
 m_defaultThickness = aWidth;
 }
 
 void SetLineWidthMM( double aWidth ) override { SetDefaultLineWidthMM( aWidth ); }
 
 void SetOffset( double aOffsetX, double aOffsetY )
 {
 m_xOffset = aOffsetX;
 m_yOffset = aOffsetY;
 }
 
 void SetBrdLayer( int aBrdLayer ) { m_brdLayer = aBrdLayer; }
 
 bool ImportDxfFile( const wxString& aFile );
 
 const wxString& GetMessages() const override
 {
 return m_messages;
 }
 
private:
 // report message to keep trace of not supported dxf entities:
 void reportMsg( const wxString& aMessage );
 
 // coordinate conversions from dxf file to mm
 double mapX( double aDxfCoordX );
 double mapY( double aDxfCoordY );
 double mapDim( double aDxfValue );
 double lineWeightToWidth( int lw, DXF_IMPORT_LAYER* aLayer );
 double getCurrentUnitScale();
 
 MATRIX3x3D getArbitraryAxis( DL_Extrusion* aData );
 
 VECTOR3D wcsToOcs( const MATRIX3x3D& arbitraryAxis, VECTOR3D point );
 
 VECTOR3D ocsToWcs( const MATRIX3x3D& arbitraryAxis, VECTOR3D point );
 
 DXF_IMPORT_LAYER* getImportLayer( const std::string& aLayerName );
 
 DXF_IMPORT_BLOCK* getImportBlock( const std::string& aBlockName );
 
 DXF_IMPORT_STYLE* getImportStyle( const std::string& aStyleName );
 
 // Functions to aid in the creation of a Polyline.
 void insertLine( const VECTOR2D& aSegStart, const VECTOR2D& aSegEnd, double aWidth );
 void insertArc( const VECTOR2D& aSegStart, const VECTOR2D& aSegEnd,
 double aBulge, double aWidth );
 
 // Add a dxf spline (stored in m_curr_entity) to the board, after conversion to segments.
 void insertSpline( double aWidth );
 
 // Methods from DL_CreationAdapter:
 // They are something like"call back" functions,
 // called when the corresponding object is read in dxf file
 
 virtual void setVariableString( const std::string& key, const std::string& value,
 int code ) override;
 
 virtual void setVariableInt( const std::string& key, int value, int code ) override;
 
 virtual void setVariableDouble( const std::string& key, double value, int code ) override {}
 
 virtual void addLayer( const DL_LayerData& aData ) override;
 virtual void addLine( const DL_LineData& aData ) override;
 virtual void addLinetype( const DL_LinetypeData& data ) override;
 
 virtual void addBlock( const DL_BlockData& ) override;
 virtual void endBlock() override;
 virtual void addTextStyle( const DL_StyleData& aData ) override;
 virtual void addPoint( const DL_PointData& aData ) override;
 
 virtual void addCircle( const DL_CircleData& aData ) override;
 virtual void addArc( const DL_ArcData& aData ) override;
 void addEllipse( const DL_EllipseData& aData ) override;
 //virtual void addLWPolyline( const DRW_LWPolyline& aData ) override;
 virtual void addText( const DL_TextData& aData ) override;
 virtual void addPolyline( const DL_PolylineData& aData ) override;
 
 /* Inserts blocks where specified by insert data */
 virtual void addInsert( const DL_InsertData& aData ) override;
 
 virtual void addVertex( const DL_VertexData& aData ) override;
 virtual void addMText( const DL_MTextData& aData) override;
 
 virtual void endEntity() override;
 
 virtual void addSpline( const DL_SplineData& aData ) override;
 
 virtual void addControlPoint( const DL_ControlPointData& aData ) override;
 
 virtual void addFitPoint( const DL_FitPointData& aData ) override;
 
 virtual void addKnot( const DL_KnotData& aData ) override;
 
 // Not yet handled DXF entities:
 virtual void addXLine( const DL_XLineData& ) override { ON_UNSUPPORTED( "addXLine" ); }
 
 virtual void addRay( const DL_RayData& ) override { ON_UNSUPPORTED( "addRay" ); }
 
 virtual void addArcAlignedText( const DL_ArcAlignedTextData& ) override
 { ON_UNSUPPORTED( "addArcAlignedText" ); }
 
 virtual void addAttribute( const DL_AttributeData& ) override
 { ON_UNSUPPORTED( "addAttribute" ); }
 
 virtual void addDimAlign( const DL_DimensionData&,
 const DL_DimAlignedData& ) override { ON_UNSUPPORTED( "addDimAlign" ); }
 virtual void addDimLinear( const DL_DimensionData&,
 const DL_DimLinearData& ) override { ON_UNSUPPORTED( "addDimLinear" ); }
 virtual void addDimRadial( const DL_DimensionData&,
 const DL_DimRadialData& ) override { ON_UNSUPPORTED( "addDimRadial" ); }
 virtual void addDimDiametric( const DL_DimensionData&,
 const DL_DimDiametricData& ) override { ON_UNSUPPORTED( "addDimDiametric" ); }
 virtual void addDimAngular( const DL_DimensionData&,
 const DL_DimAngular2LData& ) override { ON_UNSUPPORTED( "addDimAngular" ); }
 virtual void addDimAngular3P( const DL_DimensionData&,
 const DL_DimAngular3PData& ) override { ON_UNSUPPORTED( "addDimAngular3P" ); }
 virtual void addDimOrdinate( const DL_DimensionData&,
 const DL_DimOrdinateData& ) override { ON_UNSUPPORTED( "addDimOrdinate" ); }
 
 virtual void addLeader( const DL_LeaderData& ) override
 { ON_UNSUPPORTED( "addLeader" ); }
 
 virtual void addLeaderVertex( const DL_LeaderVertexData& ) override
 { ON_UNSUPPORTED( "addLeaderVertex" ); }
 
 virtual void addHatch( const DL_HatchData& ) override { ON_UNSUPPORTED( "addHatch" ); }
 
 virtual void addTrace( const DL_TraceData& ) override { ON_UNSUPPORTED( "addTrace" ); }
 virtual void add3dFace( const DL_3dFaceData& ) override { ON_UNSUPPORTED( "add3dFace" ); }
 
 virtual void addSolid( const DL_SolidData& ) override { ON_UNSUPPORTED( "addSolid" ); }
 
 virtual void addImage( const DL_ImageData& ) override { ON_UNSUPPORTED( "addImage" ); }
 virtual void linkImage( const DL_ImageDefData& ) override {}
 
 virtual void addHatchLoop( const DL_HatchLoopData& ) override
 {
 ON_UNSUPPORTED( "addHatchLoop" );
 }
 
 virtual void addHatchEdge( const DL_HatchEdgeData& ) override
 {
 ON_UNSUPPORTED( "addHatchEdge" );
 }
 
 virtual void addXRecord( const std::string& ) override { ON_UNSUPPORTED( "addXRecord" ); }
 
 virtual void addXRecordString( int, const std::string& ) override
 {
 ON_UNSUPPORTED( "addXRecordString" );
 }
 
 virtual void addXRecordReal( int, double ) override { ON_UNSUPPORTED( "addXRecordReal" ); }
 virtual void addXRecordInt( int, int ) override { ON_UNSUPPORTED( "addXRecordInt" ); }
 virtual void addXRecordBool( int, bool ) override { ON_UNSUPPORTED( "addXRecordBool" ); }
 
 virtual void addXDataApp( const std::string& ) override { ON_UNSUPPORTED( "addXDataApp" ); }
 virtual void addXDataString( int, const std::string& ) override
 {
 ON_UNSUPPORTED( "addXDataString" );
 }
 
 virtual void addXDataReal( int, double ) override { ON_UNSUPPORTED( "addXDataReal" ); }
 virtual void addXDataInt( int, int ) override { ON_UNSUPPORTED( "addXDataInt" ); }
 
 static wxString toDxfString( const wxString& aStr );
 
 static wxString toNativeString( const wxString& aData );
 
 void writeLine();
 void writeMtext();
 
private:
 double m_xOffset; // X coord offset for conversion (in mm)
 double m_yOffset; // Y coord offset for conversion (in mm)
 double m_defaultThickness; // default line thickness for conversion (in mm)
 int m_brdLayer; // The board layer to place imported DXF items
 int m_version; // the dxf version, not used here
 std::string m_codePage; // The code page, not used here
 bool m_importAsFPShapes; // Use footprint items instead of board items when true.
 // true when the items are imported in the footprint editor
 wxString m_messages; // messages generated during dxf file parsing.
 // Each message ends by '\n'
 DXF2BRD_ENTITY_DATA m_curr_entity; // the current entity parameters when parsing a DXF entity
 
 double m_minX, m_maxX; // handles image size in mm
 double m_minY, m_maxY; // handles image size in mm
 
 DXF_IMPORT_UNITS m_currentUnit; // current unit during import
 int m_importCoordinatePrecision; // current precision for linear units (points)
 int m_importAnglePrecision; // current precision for angles
 
 GRAPHICS_IMPORTER_BUFFER m_internalImporter;
 
 // List of layers as we import, used just to grab props for objects.
 std::vector<std::unique_ptr<DXF_IMPORT_LAYER>> m_layers;
 std::vector<std::unique_ptr<DXF_IMPORT_BLOCK>> m_blocks; // List of blocks as we import
 std::vector<std::unique_ptr<DXF_IMPORT_STYLE>> m_styles; // List of blocks as we import
 DXF_IMPORT_BLOCK* m_currentBlock;
};
 
#endif // DXF2BRD_ITEMS_H