Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
3a45ee0cdThis file is pinned to the selected release. Download the original to open it in your design tool.
// dxf.cpp
// Copyright (c) 2009, Dan Heeks
// This program is released under the BSD license. See the file COPYING for details.
#include "dxf.h"
using namespace std;
static const double Pi = 3.14159265358979323846264338327950288419716939937511;
CDxfWrite::CDxfWrite(const char* filepath)
{
// start the file
m_fail = false;
m_ofs = new wofstream(filepath, ios::out);
if(!(*m_ofs)){
m_fail = true;
return;
}
m_ofs->imbue(std::locale("C"));
// start
(*m_ofs) << 0 << endl;
(*m_ofs) << "SECTION" << endl;
(*m_ofs) << 2 << endl;
(*m_ofs) << "ENTITIES" << endl;
}
CDxfWrite::~CDxfWrite()
{
// end
(*m_ofs) << 0 << endl;
(*m_ofs) << "ENDSEC" << endl;
(*m_ofs) << 0 << endl;
(*m_ofs) << "EOF";
delete m_ofs;
}
void CDxfWrite::WriteExtrusion(double thickness, const double* extru)
{
if (thickness == 0.0)return;
if (extru == NULL)return;
(*m_ofs) << 39 << endl; // thickness
(*m_ofs) << thickness << endl;
(*m_ofs) << 210 << endl; // extrusion_vector
(*m_ofs) << extru[0] << endl;
(*m_ofs) << 220 << endl; // extrusion_vector
(*m_ofs) << extru[1] << endl;
(*m_ofs) << 230 << endl; // extrusion_vector
(*m_ofs) << extru[2] << endl;
}
void CDxfWrite::WriteLine(const double* s, const double* e, const char* layer_name, double thickness, const double* extru)
{
(*m_ofs) << 0 << endl;
(*m_ofs) << "LINE" << endl;
(*m_ofs) << 8 << endl; // Group code for layer name
(*m_ofs) << layer_name << endl; // Layer number
(*m_ofs) << 10 << endl; // Start point of line
(*m_ofs) << s[0] << endl; // X in WCS coordinates
(*m_ofs) << 20 << endl;
(*m_ofs) << s[1] << endl; // Y in WCS coordinates
(*m_ofs) << 30 << endl;
(*m_ofs) << s[2] << endl; // Z in WCS coordinates
(*m_ofs) << 11 << endl; // End point of line
(*m_ofs) << e[0] << endl; // X in WCS coordinates
(*m_ofs) << 21 << endl;
(*m_ofs) << e[1] << endl; // Y in WCS coordinates
(*m_ofs) << 31 << endl;
(*m_ofs) << e[2] << endl; // Z in WCS coordinates
WriteExtrusion(thickness, extru);
}
void CDxfWrite::WritePoint(const double* s, const char* layer_name)
{
(*m_ofs) << 0 << endl;
(*m_ofs) << "POINT" << endl;
(*m_ofs) << 8 << endl; // Group code for layer name
(*m_ofs) << layer_name << endl; // Layer number
(*m_ofs) << 10 << endl; // Start point of line
(*m_ofs) << s[0] << endl; // X in WCS coordinates
(*m_ofs) << 20 << endl;
(*m_ofs) << s[1] << endl; // Y in WCS coordinates
(*m_ofs) << 30 << endl;
(*m_ofs) << s[2] << endl; // Z in WCS coordinates
}
void CDxfWrite::WriteArc(const double* s, const double* e, const double* c, bool dir, const char* layer_name, double thickness, const double* extru)
{
double ax = s[0] - c[0];
double ay = s[1] - c[1];
double bx = e[0] - c[0];
double by = e[1] - c[1];
double start_angle = atan2(ay, ax) * 180/Pi;
double end_angle = atan2(by, bx) * 180/Pi;
double radius = sqrt(ax*ax + ay*ay);
if(!dir){
double temp = start_angle;
start_angle = end_angle;
end_angle = temp;
}
(*m_ofs) << 0 << endl;
(*m_ofs) << "ARC" << endl;
(*m_ofs) << 8 << endl; // Group code for layer name
(*m_ofs) << layer_name << endl; // Layer number
(*m_ofs) << 10 << endl; // Centre X
(*m_ofs) << c[0] << endl; // X in WCS coordinates
(*m_ofs) << 20 << endl;
(*m_ofs) << c[1] << endl; // Y in WCS coordinates
(*m_ofs) << 30 << endl;
(*m_ofs) << c[2] << endl; // Z in WCS coordinates
(*m_ofs) << 40 << endl; //
(*m_ofs) << radius << endl; // Radius
(*m_ofs) << 50 << endl;
(*m_ofs) << start_angle << endl; // Start angle
(*m_ofs) << 51 << endl;
(*m_ofs) << end_angle << endl; // End angle
WriteExtrusion(thickness, extru);
}
void CDxfWrite::WriteCircle(const double* c, double radius, const char* layer_name, double thickness, const double* extru)
{
(*m_ofs) << 0 << endl;
(*m_ofs) << "CIRCLE" << endl;
(*m_ofs) << 8 << endl; // Group code for layer name
(*m_ofs) << layer_name << endl; // Layer number
(*m_ofs) << 10 << endl; // Centre X
(*m_ofs) << c[0] << endl; // X in WCS coordinates
(*m_ofs) << 20 << endl;
(*m_ofs) << c[1] << endl; // Y in WCS coordinates
(*m_ofs) << 30 << endl;
(*m_ofs) << c[2] << endl; // Z in WCS coordinates
(*m_ofs) << 40 << endl; //
(*m_ofs) << radius << endl; // Radius
WriteExtrusion(thickness, extru);
}
void CDxfWrite::WriteEllipse(const double* c, double major_radius, double minor_radius, double rotation, double start_angle, double end_angle, bool dir, const char* layer_name, double thickness, const double* extru)
{
double m[3];
m[2]=0;
m[0] = major_radius * sin(rotation);
m[1] = major_radius * cos(rotation);
double ratio = minor_radius/major_radius;
if(!dir){
double temp = start_angle;
start_angle = end_angle;
end_angle = temp;
}
(*m_ofs) << 0 << endl;
(*m_ofs) << "ELLIPSE" << endl;
(*m_ofs) << 8 << endl; // Group code for layer name
(*m_ofs) << layer_name << endl; // Layer number
(*m_ofs) << 10 << endl; // Centre X
(*m_ofs) << c[0] << endl; // X in WCS coordinates
(*m_ofs) << 20 << endl;
(*m_ofs) << c[1] << endl; // Y in WCS coordinates
(*m_ofs) << 30 << endl;
(*m_ofs) << c[2] << endl; // Z in WCS coordinates
(*m_ofs) << 40 << endl; //
(*m_ofs) << ratio << endl; // Ratio
(*m_ofs) << 11 << endl; //
(*m_ofs) << m[0] << endl; // Major X
(*m_ofs) << 21 << endl;
(*m_ofs) << m[1] << endl; // Major Y
(*m_ofs) << 31 << endl;
(*m_ofs) << m[2] << endl; // Major Z
(*m_ofs) << 41 << endl;
(*m_ofs) << start_angle << endl; // Start angle
(*m_ofs) << 42 << endl;
(*m_ofs) << end_angle << endl; // End angle
WriteExtrusion(thickness, extru);
}
CDxfRead::CDxfRead(const char* filepath)
{
// start the file
memset( m_unused_line, '\0', sizeof(m_unused_line) );
m_fail = false;
m_aci = 0;
m_eUnits = eMillimeters;
m_measurement_inch = false;
strcpy(m_layer_name, "0"); // Default layer name
m_ignore_errors = true;
#ifdef STORE_LINE_NUMBERS
m_line_number = 0;
#endif
m_ifs = new ifstream(filepath);
if(!(*m_ifs)){
m_fail = true;
printf("DXF file didn't load\n");
return;
}
m_ifs->imbue(std::locale("C"));
}
CDxfRead::~CDxfRead()
{
delete m_ifs;
}
double CDxfRead::mm( double value ) const
{
if(m_measurement_inch)
{
value *= 0.0393700787401575;
}
switch(m_eUnits)
{
case eUnspecified: return(value * 1.0); // We don't know any better.
case eInches: return(value * 25.4);
case eFeet: return(value * 25.4 * 12);
case eMiles: return(value * 1609344.0);
case eMillimeters: return(value * 1.0);
case eCentimeters: return(value * 10.0);
case eMeters: return(value * 1000.0);
case eKilometers: return(value * 1000000.0);
case eMicroinches: return(value * 25.4 / 1000.0);
case eMils: return(value * 25.4 / 1000.0);
case eYards: return(value * 3 * 12 * 25.4);
case eAngstroms: return(value * 0.0000001);
case eNanometers: return(value * 0.000001);
case eMicrons: return(value * 0.001);
case eDecimeters: return(value * 100.0);
case eDekameters: return(value * 10000.0);
case eHectometers: return(value * 100000.0);
case eGigameters: return(value * 1000000000000.0);
case eAstronomicalUnits: return(value * 149597870690000.0);
case eLightYears: return(value * 9454254955500000000.0);
case eParsecs: return(value * 30856774879000000000.0);
default: return(value * 1.0); // We don't know any better.
} // End switch
} // End mm() method
bool CDxfRead::ReadLine()
{
double s[3] = {0, 0, 0};
double e[3] = {0, 0, 0};
bool hidden = false;
ResetExtrusionAndThickness();
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadLine() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with line
DerefACI();
OnReadLine(s, e, hidden);
hidden = false;
return true;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 6: // line style name follows
get_line();
if(m_str[0] == 'h' || m_str[0] == 'H')hidden = true;
break;
case 10:
// start x
get_line();
ss.str(m_str); ss >> s[0]; s[0] = mm(s[0]); if(ss.fail()) return false;
break;
case 20:
// start y
get_line();
ss.str(m_str); ss >> s[1]; s[1] = mm(s[1]); if(ss.fail()) return false;
break;
case 30:
// start z
get_line();
ss.str(m_str); ss >> s[2]; s[2] = mm(s[2]); if(ss.fail()) return false;
break;
case 11:
// end x
get_line();
ss.str(m_str); ss >> e[0]; e[0] = mm(e[0]); if(ss.fail()) return false;
break;
case 21:
// end y
get_line();
ss.str(m_str); ss >> e[1]; e[1] = mm(e[1]); if(ss.fail()) return false;
break;
case 31:
// end z
get_line();
ss.str(m_str); ss >> e[2]; e[2] = mm(e[2]); if(ss.fail()) return false;
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
case 100:
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
try {
DerefACI();
OnReadLine(s, e, false);
}
catch(...)
{
if (! IgnoreErrors()) throw; // Re-throw the exception.
}
return false;
}
bool CDxfRead::ReadPoint()
{
double s[3] = {0, 0, 0};
ResetExtrusionAndThickness();
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadPoint() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with line
DerefACI();
OnReadPoint(s);
return true;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// start x
get_line();
ss.str(m_str); ss >> s[0]; s[0] = mm(s[0]); if(ss.fail()) return false;
break;
case 20:
// start y
get_line();
ss.str(m_str); ss >> s[1]; s[1] = mm(s[1]); if(ss.fail()) return false;
break;
case 30:
// start z
get_line();
ss.str(m_str); ss >> s[2]; s[2] = mm(s[2]); if(ss.fail()) return false;
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
try {
DerefACI();
OnReadPoint(s);
}
catch(...)
{
if (! IgnoreErrors()) throw; // Re-throw the exception.
}
return false;
}
bool CDxfRead::ReadArc()
{
double start_angle = 0.0;// in degrees
double end_angle = 0.0;
double radius = 0.0;
double c[3]; // centre
bool hidden = false;
ResetExtrusionAndThickness();
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadArc() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with arc
DerefACI();
OnReadArc(start_angle, end_angle, radius, c, hidden);
hidden = false;
return true;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 6: // line style name follows
get_line();
if(m_str[0] == 'h' || m_str[0] == 'H')hidden = true;
break;
case 10:
// centre x
get_line();
ss.str(m_str); ss >> c[0]; c[0] = mm(c[0]); if(ss.fail()) return false;
break;
case 20:
// centre y
get_line();
ss.str(m_str); ss >> c[1]; c[1] = mm(c[1]); if(ss.fail()) return false;
break;
case 30:
// centre z
get_line();
ss.str(m_str); ss >> c[2]; c[2] = mm(c[2]); if(ss.fail()) return false;
break;
case 40:
// radius
get_line();
ss.str(m_str); ss >> radius; radius = mm(radius); if(ss.fail()) return false;
break;
case 50:
// start angle
get_line();
ss.str(m_str); ss >> start_angle; if(ss.fail()) return false;
break;
case 51:
// end angle
get_line();
ss.str(m_str); ss >> end_angle; if(ss.fail()) return false;
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
DerefACI();
OnReadArc(start_angle, end_angle, radius, c, false);
return false;
}
bool CDxfRead::ReadSpline()
{
struct SplineData sd;
sd.norm[0] = 0;
sd.norm[1] = 0;
sd.norm[2] = 1;
sd.degree = 0;
sd.knots = 0;
sd.flag = 0;
sd.control_points = 0;
sd.fit_points = 0;
double temp_double;
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadSpline() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with Spline
DerefACI();
OnReadSpline(sd);
return true;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 210:
// normal x
get_line();
ss.str(m_str); ss >> sd.norm[0]; if(ss.fail()) return false;
break;
case 220:
// normal y
get_line();
ss.str(m_str); ss >> sd.norm[1]; if(ss.fail()) return false;
break;
case 230:
// normal z
get_line();
ss.str(m_str); ss >> sd.norm[2]; if(ss.fail()) return false;
break;
case 70:
// flag
get_line();
ss.str(m_str); ss >> sd.flag; if(ss.fail()) return false;
break;
case 71:
// degree
get_line();
ss.str(m_str); ss >> sd.degree; if(ss.fail()) return false;
break;
case 72:
// knots
get_line();
ss.str(m_str); ss >> sd.knots; if(ss.fail()) return false;
break;
case 73:
// control points
get_line();
ss.str(m_str); ss >> sd.control_points; if(ss.fail()) return false;
break;
case 74:
// fit points
get_line();
ss.str(m_str); ss >> sd.fit_points; if(ss.fail()) return false;
break;
case 12:
// starttan x
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.starttanx.push_back(temp_double);
break;
case 22:
// starttan y
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.starttany.push_back(temp_double);
break;
case 32:
// starttan z
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.starttanz.push_back(temp_double);
break;
case 13:
// endtan x
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.endtanx.push_back(temp_double);
break;
case 23:
// endtan y
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.endtany.push_back(temp_double);
break;
case 33:
// endtan z
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.endtanz.push_back(temp_double);
break;
case 40:
// knot
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.knot.push_back(temp_double);
break;
case 41:
// weight
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.weight.push_back(temp_double);
break;
case 10:
// control x
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.controlx.push_back(temp_double);
break;
case 20:
// control y
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.controly.push_back(temp_double);
break;
case 30:
// control z
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.controlz.push_back(temp_double);
break;
case 11:
// fit x
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.fitx.push_back(temp_double);
break;
case 21:
// fit y
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.fity.push_back(temp_double);
break;
case 31:
// fit z
get_line();
ss.str(m_str); ss >> temp_double; temp_double = mm(temp_double); if(ss.fail()) return false;
sd.fitz.push_back(temp_double);
break;
case 42:
case 43:
case 44:
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
DerefACI();
OnReadSpline(sd);
return false;
}
bool CDxfRead::ReadCircle()
{
double radius = 0.0;
double c[3]; // centre
bool hidden = false;
ResetExtrusionAndThickness();
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadCircle() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with Circle
DerefACI();
OnReadCircle(c, radius, hidden);
hidden = false;
return true;
case 6: // line style name follows
get_line();
if(m_str[0] == 'h' || m_str[0] == 'H')hidden = true;
break;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// centre x
get_line();
ss.str(m_str); ss >> c[0]; c[0] = mm(c[0]); if(ss.fail()) return false;
break;
case 20:
// centre y
get_line();
ss.str(m_str); ss >> c[1]; c[1] = mm(c[1]); if(ss.fail()) return false;
break;
case 30:
// centre z
get_line();
ss.str(m_str); ss >> c[2]; c[2] = mm(c[2]); if(ss.fail()) return false;
break;
case 40:
// radius
get_line();
ss.str(m_str); ss >> radius; radius = mm(radius); if(ss.fail()) return false;
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
DerefACI();
OnReadCircle(c, radius, false);
return false;
}
bool CDxfRead::ReadText()
{
double c[3]; // coordinate
double height = 0.03082;
int hj = 0;
int vj = 0;
double scale_x = 1.0;
ResetExtrusionAndThickness();
memset( c, 0, sizeof(c) );
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadText() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
return false;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// centre x
get_line();
ss.str(m_str); ss >> c[0]; c[0] = mm(c[0]); if(ss.fail()) return false;
break;
case 20:
// centre y
get_line();
ss.str(m_str); ss >> c[1]; c[1] = mm(c[1]); if(ss.fail()) return false;
break;
case 30:
// centre z
get_line();
ss.str(m_str); ss >> c[2]; c[2] = mm(c[2]); if(ss.fail()) return false;
break;
case 40:
// text height
get_line();
ss.str(m_str); ss >> height; height = mm(height); if(ss.fail()) return false;
break;
case 41:
// text relative x scale
get_line();
ss.str(m_str); ss >> scale_x; if(ss.fail()) return false;
break;
case 1:
// text
get_line();
DerefACI();
OnReadText(c, height * 25.4 / 72.0, m_str, hj, vj);
return(true);
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 72:
// horizontal justification
get_line();
ss.str(m_str); ss >> hj; if(ss.fail()) return false;
break;
case 73:
// horizontal justification
get_line();
ss.str(m_str); ss >> vj; if(ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadMText()
{
double c[3]; // coordinate
double height = 0.03082;
int hj = 0;
int vj = 0;
ResetExtrusionAndThickness();
memset( c, 0, sizeof(c) );
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadText() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
return false;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// centre x
get_line();
ss.str(m_str); ss >> c[0]; c[0] = mm(c[0]); if(ss.fail()) return false;
break;
case 20:
// centre y
get_line();
ss.str(m_str); ss >> c[1]; c[1] = mm(c[1]); if(ss.fail()) return false;
break;
case 30:
// centre z
get_line();
ss.str(m_str); ss >> c[2]; c[2] = mm(c[2]); if(ss.fail()) return false;
break;
case 40:
case 43:
// text height
get_line();
ss.str(m_str); ss >> height; height = mm(height); if(ss.fail()) return false;
break;
case 1:
// text
get_line();
DerefACI();
OnReadText(c, height * 25.4 / 72.0, m_str, hj, vj);
return(true);
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 71:
//Attachment point:
//1 = Top left; 2 = Top center; 3 = Top right;
//4 = Middle left; 5 = Middle center; 6 = Middle right
//7 = Bottom left; 8 = Bottom center; 9 = Bottom right
get_line();
ss.str(m_str); ss >> hj; if(ss.fail()) return false;
switch(hj)
{
case 1:
hj = 0;
vj = 3;
break;
case 2:
hj = 1;
vj = 3;
break;
case 3:
hj = 2;
vj = 3;
break;
case 4:
hj = 0;
vj = 2;
break;
case 5:
hj = 1;
vj = 2;
break;
case 6:
hj = 2;
vj = 2;
break;
case 7:
hj = 0;
vj = 1;
break;
case 8:
hj = 1;
vj = 1;
break;
case 9:
hj = 2;
vj = 1;
break;
}
break;
case 72:
// drawing direction
get_line(); // to do
//ss.str(m_str); ss >> vj; if(ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadRText()
{
double c[3]; // coordinate
double height = 0.03082;
int hj = 0;
int vj = 0;
ResetExtrusionAndThickness();
memset(c, 0, sizeof(c));
while (!((*m_ifs).eof()))
{
get_line();
int n;
if (sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadText() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch (n){
case 0:
return false;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// centre x
get_line();
ss.str(m_str); ss >> c[0]; c[0] = mm(c[0]); if (ss.fail()) return false;
break;
case 20:
// centre y
get_line();
ss.str(m_str); ss >> c[1]; c[1] = mm(c[1]); if (ss.fail()) return false;
break;
case 30:
// centre z
get_line();
ss.str(m_str); ss >> c[2]; c[2] = mm(c[2]); if (ss.fail()) return false;
break;
case 40:
case 43:
// text height
get_line();
ss.str(m_str); ss >> height; height = mm(height); if (ss.fail()) return false;
break;
case 1:
// text
get_line();
DerefACI();
OnReadText(c, height * 25.4 / 72.0, m_str, hj, vj);
return(true);
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if (ss.fail()) return false;
break;
case 71:
//Attachment point:
//1 = Top left; 2 = Top center; 3 = Top right;
//4 = Middle left; 5 = Middle center; 6 = Middle right
//7 = Bottom left; 8 = Bottom center; 9 = Bottom right
get_line();
ss.str(m_str); ss >> hj; if (ss.fail()) return false;
switch (hj)
{
case 1:
hj = 0;
vj = 3;
break;
case 2:
hj = 1;
vj = 3;
break;
case 3:
hj = 2;
vj = 3;
break;
case 4:
hj = 0;
vj = 2;
break;
case 5:
hj = 1;
vj = 2;
break;
case 6:
hj = 2;
vj = 2;
break;
case 7:
hj = 0;
vj = 1;
break;
case 8:
hj = 1;
vj = 1;
break;
case 9:
hj = 2;
vj = 1;
break;
}
break;
case 72:
// drawing direction
get_line(); // to do
//ss.str(m_str); ss >> vj; if(ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadEllipse()
{
double c[3]; // centre
double m[3]; //major axis point
double ratio=0; //ratio of major to minor axis
double start=0; //start of arc
double end=0; // end of arc
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadEllipse() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with Ellipse
DerefACI();
OnReadEllipse(c, m, ratio, start, end);
return true;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// centre x
get_line();
ss.str(m_str); ss >> c[0]; c[0] = mm(c[0]); if(ss.fail()) return false;
break;
case 20:
// centre y
get_line();
ss.str(m_str); ss >> c[1]; c[1] = mm(c[1]); if(ss.fail()) return false;
break;
case 30:
// centre z
get_line();
ss.str(m_str); ss >> c[2]; c[2] = mm(c[2]); if(ss.fail()) return false;
break;
case 11:
// major x
get_line();
ss.str(m_str); ss >> m[0]; m[0] = mm(m[0]); if(ss.fail()) return false;
break;
case 21:
// major y
get_line();
ss.str(m_str); ss >> m[1]; m[1] = mm(m[1]); if(ss.fail()) return false;
break;
case 31:
// major z
get_line();
ss.str(m_str); ss >> m[2]; m[2] = mm(m[2]); if(ss.fail()) return false;
break;
case 40:
// ratio
get_line();
ss.str(m_str); ss >> ratio; if(ss.fail()) return false;
break;
case 41:
// start
get_line();
ss.str(m_str); ss >> start; if(ss.fail()) return false;
break;
case 42:
// end
get_line();
ss.str(m_str); ss >> end; if(ss.fail()) return false;
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 100:
case 210:
case 220:
case 230:
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
DerefACI();
OnReadEllipse(c, m, ratio, start, end);
return false;
}
static bool poly_prev_found = false;
static double poly_prev_x;
static double poly_prev_y;
static double poly_prev_z;
static double poly_prev_bulge_found;
static double poly_prev_bulge;
static bool poly_first_found = false;
static double poly_first_x;
static double poly_first_y;
static double poly_first_z;
static std::list<CPolyLinePoint> poly_line_points;
static bool poly_mirrored = false;
static void AddPolyLinePoint(CDxfRead* dxf_read, CPolyLinePoint& p)
{
try {
if(poly_prev_found)
{
bool arc_done = false;
if(poly_prev_bulge_found)
{
double cot = 0.5 * ((1.0 / poly_prev_bulge) - poly_prev_bulge);
double cx = ((poly_prev_x + p.x) - ((p.y - poly_prev_y) * cot)) / 2.0;
double cy = ((poly_prev_y + p.y) + ((p.x - poly_prev_x) * cot)) / 2.0;
double ps[3] = {poly_prev_x, poly_prev_y, poly_prev_z};
double pe[3] = {p.x, p.y, p.z};
double pc[3] = {cx, cy, (poly_prev_z + p.z)/2.0};
if(poly_mirrored)
{
ps[0] = -ps[0];
pe[0] = -pe[0];
pc[0] = -pc[0];
}
bool dir = (poly_prev_bulge >= 0);
if(poly_mirrored)dir = !dir;
dxf_read->OnReadArc(ps, pe, pc, dir, false);
arc_done = true;
}
if(!arc_done)
{
double s[3] = {poly_prev_x, poly_prev_y, poly_prev_z};
double e[3] = {p.x, p.y, p.z};
if(poly_mirrored)
{
s[0] = -s[0];
e[0] = -e[0];
}
dxf_read->OnReadLine(s, e, false);
}
}
poly_prev_found = true;
poly_prev_x = p.x;
poly_prev_y = p.y;
poly_prev_z = p.z;
if(!poly_first_found)
{
poly_first_x = p.x;
poly_first_y = p.y;
poly_first_z = p.z;
poly_first_found = true;
}
poly_prev_bulge_found = p.bulge_found;
poly_prev_bulge = p.bulge;
}
catch(...)
{
if (! dxf_read->IgnoreErrors()) throw; // Re-throw it.
}
}
void CDxfRead::AddPolyLinePoints(bool mirrored, bool closed)
{
poly_mirrored = mirrored;
for(std::list<CPolyLinePoint>::iterator It = poly_line_points.begin(); It != poly_line_points.end(); It++)
{
CPolyLinePoint &p = *It;
AddPolyLinePoint(this, p);
}
if (closed && (poly_line_points.size() > 0))
{
// repeat the first point
AddPolyLinePoint(this, poly_line_points.front());
}
poly_line_points.clear();
}
void CDxfRead::ResetExtrusionAndThickness()
{
m_thickness = 0.0;
m_extrusion_vector[0] = 0.0;
m_extrusion_vector[1] = 0.0;
m_extrusion_vector[2] = 1.0;
}
bool CDxfRead::ReadExtrusionOrThickness(int n)
{
std::istringstream ss;
ss.imbue(std::locale("C"));
switch (n)
{
case 39:
// thickness
get_line();
ss.str(m_str); ss >> m_thickness; m_thickness = mm(m_thickness); if (ss.fail()) return false;
break;
case 210:
// extrusion_vector
get_line();
ss.str(m_str); ss >> m_extrusion_vector[0]; if (ss.fail()) return false;
break;
case 220:
// extrusion_vector
get_line();
ss.str(m_str); ss >> m_extrusion_vector[1]; if (ss.fail()) return false;
break;
case 230:
// extrusion_vector
get_line();
ss.str(m_str); ss >> m_extrusion_vector[2]; if (ss.fail()) return false;
break;
}
return true;
}
void CDxfRead::StorePolyLinePoint(double x, double y, double z, bool bulge_found, double bulge)
{
poly_line_points.push_back(CPolyLinePoint(x, y, z, bulge_found, bulge));
}
static void PolyLineStart()
{
poly_prev_found = false;
poly_first_found = false;
}
bool CDxfRead::ReadLwPolyLine()
{
PolyLineStart();
bool x_found = false;
bool y_found = false;
double x = 0.0;
double y = 0.0;
double z = 0.0;
bool bulge_found = false;
double bulge = 0.0;
bool closed = false;
int flags;
bool next_item_found = false;
bool mirrored = false;
while(!((*m_ifs).eof()) && !next_item_found)
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadLwPolyLine() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found
DerefACI();
if(x_found && y_found){
// add point
StorePolyLinePoint(x, y, z, bulge_found, bulge);
bulge_found = false;
x_found = false;
y_found = false;
}
next_item_found = true;
break;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// x
get_line();
if(x_found && y_found){
// add point
StorePolyLinePoint(x, y, z, bulge_found, bulge);
bulge_found = false;
x_found = false;
y_found = false;
}
ss.str(m_str); ss >> x; x = mm(x); if(ss.fail()) return false;
x_found = true;
break;
case 20:
// y
get_line();
ss.str(m_str); ss >> y; y = mm(y); if(ss.fail()) return false;
y_found = true;
break;
case 230:
// z extrusion direction
get_line();
ss.str(m_str); ss >> z; if(ss.fail()) return false;
mirrored = (z < 0);
break;
case 42:
// bulge
get_line();
ss.str(m_str); ss >> bulge; if(ss.fail()) return false;
bulge_found = true;
break;
case 70:
// flags
get_line();
if(sscanf(m_str, "%d", &flags) != 1)return false;
closed = ((flags & 1) != 0);
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
default:
// skip the next line
get_line();
break;
}
}
if(next_item_found)
{
AddPolyLinePoints(mirrored, closed);
return true;
}
return false;
}
bool CDxfRead::ReadVertex(double *pVertex, bool *bulge_found, double *bulge)
{
bool x_found = false;
bool y_found = false;
double x = 0.0;
double y = 0.0;
double z = 0.0;
*bulge = 0.0;
*bulge_found = false;
pVertex[0] = 0.0;
pVertex[1] = 0.0;
pVertex[2] = 0.0;
while(!(*m_ifs).eof()) {
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1) {
printf("CDxfRead::ReadVertex() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
DerefACI();
put_line(m_str); // read one line too many. put it back.
return(x_found && y_found);
break;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// x
get_line();
ss.str(m_str); ss >> x; pVertex[0] = mm(x); if(ss.fail()) return false;
x_found = true;
break;
case 20:
// y
get_line();
ss.str(m_str); ss >> y; pVertex[1] = mm(y); if(ss.fail()) return false;
y_found = true;
break;
case 30:
// z
get_line();
ss.str(m_str); ss >> z; pVertex[2] = mm(z); if(ss.fail()) return false;
break;
case 42:
get_line();
*bulge_found = true;
ss.str(m_str); ss >> *bulge; if(ss.fail()) return false;
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadPolyLine()
{
PolyLineStart();
ResetExtrusionAndThickness();
bool closed = false;
int flags;
bool first_vertex_section_found = false;
double first_vertex[3];
bool bulge_found;
double bulge;
while(!(*m_ifs).eof())
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadPolyLine() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found
DerefACI();
get_line();
if (! strcmp(m_str,"VERTEX"))
{
double vertex[3];
if (CDxfRead::ReadVertex(vertex, &bulge_found, &bulge))
{
if(!first_vertex_section_found) {
first_vertex_section_found = true;
memcpy(first_vertex, vertex, 3*sizeof(double));
}
StorePolyLinePoint(vertex[0], vertex[1], vertex[2], bulge_found, bulge);
break;
}
}
if (! strcmp(m_str,"SEQEND"))
{
AddPolyLinePoints(false, closed);
return true;
}
break;
case 70:
// flags
get_line();
if(sscanf(m_str, "%d", &flags) != 1)return false;
closed = ((flags & 1) != 0);
break;
case 62:
// color index
get_line();
ss.str(m_str); ss >> m_aci; if(ss.fail()) return false;
break;
case 39:
case 210:
case 220:
case 230:
if (!ReadExtrusionOrThickness(n))
return false;
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
struct three_doubles
{
double x[3];
};
bool CDxfRead::ReadLeader()
{
double vertex_coordinates[3] = {0, 0, 0};
double horizontal_direction[3] = {1, 0, 0};
double insertion_offset[3] = { 0, 0, 0 };
double placement_offset[3] = { 0, 0, 0 };
double normal_vector[3] = { 0, 0, 1 };
int leader_creation_flag = 3;
int arrowhead_flag = 1;
int leader_path_type = 0;
int hookline_direction_flag = 1;
int hookline_flag = 0;
double text_annotation_height = 0.3;
double text_annotation_width = 0.3;
bool next_item_found = false;
std::list<three_doubles> vertices;
while(!((*m_ifs).eof()) && !next_item_found)
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadLeader() Failed to read integer from '%s'\n", m_str);
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish with Leader
DerefACI();
next_item_found = true;
break;
case 8: // Layer name follows
get_line();
strcpy(m_layer_name, m_str);
break;
case 10:
// x
get_line();
ss.str(m_str); ss >> vertex_coordinates[0]; vertex_coordinates[0] = mm(vertex_coordinates[0]); if(ss.fail()) return false;
break;
case 20:
// y
get_line();
ss.str(m_str); ss >> vertex_coordinates[1]; vertex_coordinates[1] = mm(vertex_coordinates[1]); if(ss.fail()) return false;
break;
case 30:
// z
get_line();
ss.str(m_str); ss >> vertex_coordinates[2]; vertex_coordinates[2] = mm(vertex_coordinates[2]); if(ss.fail()) return false;
three_doubles td;
for(int i = 0; i<3; i++)td.x[i] = vertex_coordinates[i];
vertices.push_back(td);
break;
case 71:
get_line();
ss.str(m_str); ss >> arrowhead_flag; if (ss.fail()) return false;
break;
case 72:
get_line();
ss.str(m_str); ss >> leader_path_type; if (ss.fail()) return false;
break;
case 73:
get_line();
ss.str(m_str); ss >> leader_creation_flag; if (ss.fail()) return false;
break;
case 74:
get_line();
ss.str(m_str); ss >> hookline_direction_flag; if (ss.fail()) return false;
break;
case 75:
get_line();
ss.str(m_str); ss >> hookline_flag; if (ss.fail()) return false;
break;
case 40:
get_line();
ss.str(m_str); ss >> text_annotation_height; if (ss.fail()) return false;
break;
case 41:
get_line();
ss.str(m_str); ss >> text_annotation_width; if (ss.fail()) return false;
break;
case 211:
// x
get_line();
ss.str(m_str); ss >> horizontal_direction[0]; if (ss.fail()) return false;
break;
case 221:
// y
get_line();
ss.str(m_str); ss >> horizontal_direction[1]; if (ss.fail()) return false;
break;
case 231:
// z
get_line();
ss.str(m_str); ss >> horizontal_direction[2]; if (ss.fail()) return false;
break;
case 212:
// x
get_line();
ss.str(m_str); ss >> insertion_offset[0]; if (ss.fail()) return false;
break;
case 222:
// y
get_line();
ss.str(m_str); ss >> insertion_offset[1]; if (ss.fail()) return false;
break;
case 232:
// z
get_line();
ss.str(m_str); ss >> insertion_offset[2]; if (ss.fail()) return false;
break;
case 213:
// x
get_line();
ss.str(m_str); ss >> placement_offset[0]; if (ss.fail()) return false;
break;
case 223:
// y
get_line();
ss.str(m_str); ss >> placement_offset[1]; if (ss.fail()) return false;
break;
case 233:
// z
get_line();
ss.str(m_str); ss >> placement_offset[2]; if (ss.fail()) return false;
break;
case 210:
// x
get_line();
ss.str(m_str); ss >> normal_vector[0]; if (ss.fail()) return false;
break;
case 220:
// y
get_line();
ss.str(m_str); ss >> normal_vector[1]; if (ss.fail()) return false;
break;
case 230:
// z
get_line();
ss.str(m_str); ss >> normal_vector[2]; if (ss.fail()) return false;
break;
case 100:
// skip the next line
get_line();
break;
case 340:
// Hard reference to associated annotation (mtext, tolerance, or insert entity)
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
double leftward_direction[3] = {-horizontal_direction[1] * 0.25, horizontal_direction[0] * 0.25, 0};
for(std::list<three_doubles>::iterator It = vertices.begin(); It != vertices.end(); It++)
{
three_doubles &td = *It;
{
// just draw a triangle with 3 lines; HeeksCAD doesn't really support leaders
double v1[3] = {td.x[0], td.x[1], td.x[2]};
double v2[3], v3[3];
for(int i = 0; i<3; i++)
{
v2[i] = v1[i] + horizontal_direction[i] + leftward_direction[i];
v3[i] = v1[i] + horizontal_direction[i] - leftward_direction[i];
}
OnReadLine(v1, v2, false);
OnReadLine(v2, v3, false);
OnReadLine(v3, v1, false);
}
}
return next_item_found;
}
bool CDxfRead::ReadMLine()
{
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadMLine() Failed to read integer from '%s'\n", m_str );
return false;
}
switch(n){
case 0:
DerefACI();
return true;
default:
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadXLine()
{
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadXLine() Failed to read integer from '%s'\n", m_str );
return false;
}
switch(n){
case 0:
DerefACI();
return true;
default:
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadDimension()
{
double def_point[3] = {0, 0, 0};
double mid[3] = {0, 0, 0};
double p1[3] = {0, 0, 0};
double p2[3] = {0, 0, 0};
double p3[3] = {0, 0, 0};
double p4[3] = {0, 0, 0};
double p5[3] = {0, 0, 0};
int dimension_type = 0;
double angle = 0;
double angle2 = 0;
double angle3 = 0;
double radius_leader_length = 0;
std::string str;
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadDimension() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0:
// next item found, so finish
DerefACI();
OnReadDimension(dimension_type, angle, angle2, angle3, radius_leader_length, def_point, mid, p1, p2, p3, p4, p5);
return true;
case 3:
// style name
get_line();
//ss.str(m_str); ss >> str; if(ss.fail()) return false;
break;
case 70:
// dimension type
get_line();
ss.str(m_str); ss >> dimension_type; if(ss.fail()) return false;
break;
case 50:
// angle
get_line();
ss.str(m_str); ss >> angle; if(ss.fail()) return false;
break;
case 51:
// angle2
get_line();
ss.str(m_str); ss >> angle2; if(ss.fail()) return false;
break;
case 52:
// angle3
get_line();
ss.str(m_str); ss >> angle3; if(ss.fail()) return false;
break;
case 40:
// radius leader length
get_line();
ss.str(m_str); ss >> radius_leader_length; if(ss.fail()) return false;
break;
case 10:
// x
get_line();
ss.str(m_str); ss >> def_point[0]; def_point[0] = mm(def_point[0]); if(ss.fail()) return false;
break;
case 20:
// y
get_line();
ss.str(m_str); ss >> def_point[1]; def_point[1] = mm(def_point[1]); if(ss.fail()) return false;
break;
case 30:
// z
get_line();
ss.str(m_str); ss >> def_point[2]; def_point[2] = mm(def_point[2]); if(ss.fail()) return false;
break;
case 11:
// x
get_line();
ss.str(m_str); ss >> mid[0]; mid[0] = mm(mid[0]); if(ss.fail()) return false;
break;
case 21:
// y
get_line();
ss.str(m_str); ss >> mid[1]; mid[1] = mm(mid[1]); if(ss.fail()) return false;
break;
case 31:
// z
get_line();
ss.str(m_str); ss >> mid[2]; mid[2] = mm(mid[2]); if(ss.fail()) return false;
break;
case 12:
// x
get_line();
ss.str(m_str); ss >> p1[0]; p1[0] = mm(p1[0]); if(ss.fail()) return false;
break;
case 22:
// y
get_line();
ss.str(m_str); ss >> p1[1]; p1[1] = mm(p1[1]); if(ss.fail()) return false;
break;
case 32:
// z
get_line();
ss.str(m_str); ss >> p1[2]; p1[2] = mm(p1[2]); if(ss.fail()) return false;
break;
case 13:
// x
get_line();
ss.str(m_str); ss >> p2[0]; p2[0] = mm(p2[0]); if(ss.fail()) return false;
break;
case 23:
// y
get_line();
ss.str(m_str); ss >> p2[1]; p2[1] = mm(p2[1]); if(ss.fail()) return false;
break;
case 33:
// z
get_line();
ss.str(m_str); ss >> p2[2]; p2[2] = mm(p2[2]); if(ss.fail()) return false;
break;
case 14:
// x
get_line();
ss.str(m_str); ss >> p3[0]; p3[0] = mm(p3[0]); if(ss.fail()) return false;
break;
case 24:
// y
get_line();
ss.str(m_str); ss >> p3[1]; p3[1] = mm(p3[1]); if(ss.fail()) return false;
break;
case 34:
// z
get_line();
ss.str(m_str); ss >> p3[2]; p3[2] = mm(p3[2]); if(ss.fail()) return false;
break;
case 15:
// x
get_line();
ss.str(m_str); ss >> p4[0]; p4[0] = mm(p4[0]); if(ss.fail()) return false;
break;
case 25:
// y
get_line();
ss.str(m_str); ss >> p4[1]; p4[1] = mm(p4[1]); if(ss.fail()) return false;
break;
case 35:
// z
get_line();
ss.str(m_str); ss >> p4[2]; p4[2] = mm(p4[2]); if(ss.fail()) return false;
break;
case 16:
// x
get_line();
ss.str(m_str); ss >> p5[0]; p5[0] = mm(p5[0]); if(ss.fail()) return false;
break;
case 26:
// y
get_line();
ss.str(m_str); ss >> p5[1]; p5[1] = mm(p5[1]); if(ss.fail()) return false;
break;
case 36:
// z
get_line();
ss.str(m_str); ss >> p5[2]; p5[2] = mm(p5[2]); if(ss.fail()) return false;
break;
case 53:
case 100:
case 210:
case 220:
case 230:
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
void CDxfRead::OnReadArc(double start_angle, double end_angle, double radius, const double* c, bool hidden){
double s[3], e[3], temp[3] ;
if (m_extrusion_vector[2]>0.0)
{
temp[0] =c[0];
temp[1] =c[1];
temp[2] =c[2];
s[0] = c[0] + radius * cos(start_angle * Pi/180);
s[1] = c[1] + radius * sin(start_angle * Pi/180);
s[2] = c[2];
e[0] = c[0] + radius * cos(end_angle * Pi/180);
e[1] = c[1] + radius * sin(end_angle * Pi/180);
e[2] = c[2];
}
else
{
temp[0] =-c[0];
temp[1] =c[1];
temp[2] =c[2];
e[0] = -(c[0] + radius * cos(start_angle * Pi/180));
e[1] = (c[1] + radius * sin(start_angle * Pi/180));
e[2] = c[2];
s[0] = -(c[0] + radius * cos(end_angle * Pi/180));
s[1] = (c[1] + radius * sin(end_angle * Pi/180));
s[2] = c[2];
}
OnReadArc(s, e, temp, true, hidden);
}
void CDxfRead::OnReadCircle(const double* c, double radius, bool hidden){
double s[3], c2[3];
double start_angle = 0;
s[0] = c[0] + radius * cos(start_angle * Pi/180);
s[1] = c[1] + radius * sin(start_angle * Pi/180);
s[2] = c[2];
for (int i = 0; i < 3; i++)c2[i] = c[i];
if (m_extrusion_vector[2] < 0)
{
c2[0] = -c2[0];
s[0] = -s[0];
}
OnReadCircle(s, c2, false, hidden); //false to change direction because otherwise the arc length is zero
}
void CDxfRead::OnReadEllipse(const double* c, const double* m, double ratio, double start_angle, double end_angle){
double major_radius = sqrt(m[0]*m[0] + m[1]*m[1] + m[2]*m[2]);
double minor_radius = major_radius * ratio;
//Since we only support 2d stuff, we can calculate the rotation from the major axis x and y value only,
//since z is zero, major_radius is the vector length
double rotation = atan2(m[1]/major_radius,m[0]/major_radius);
OnReadEllipse(c, major_radius, minor_radius, rotation, start_angle, end_angle, true);
}
void CDxfRead::get_line()
{
if (m_unused_line[0] != '\0')
{
strcpy(m_str, m_unused_line);
memset( m_unused_line, '\0', sizeof(m_unused_line));
return;
}
m_ifs->getline(m_str, 1024);
char str[1024];
int len = strlen(m_str);
int j = 0;
bool non_white_found = false;
for(int i = 0; i<len; i++){
if(non_white_found || (m_str[i] != ' ' && m_str[i] != '\t')){
#if wxUSE_UNICODE
if(m_str[i] != '\r')
#endif
{
str[j] = m_str[i]; j++;
}
non_white_found = true;
}
}
str[j] = 0;
strcpy(m_str, str);
#ifdef STORE_LINE_NUMBERS
m_line_number++;
#endif
}
void CDxfRead::put_line(const char *value)
{
strcpy( m_unused_line, value );
}
bool CDxfRead::ReadUCS()
{
double e[3] = {0, 0, 0};
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadUCS() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 9: // next item found, so finish
OnReadUCS(e);
return true;
case 10:
// x
get_line();
ss.str(m_str); ss >> e[0]; e[0] = mm(e[0]); if(ss.fail()) return false;
break;
case 20:
// y
get_line();
ss.str(m_str); ss >> e[1]; e[1] = mm(e[1]); if(ss.fail()) return false;
break;
case 30:
// z
get_line();
ss.str(m_str); ss >> e[2]; e[2] = mm(e[2]); if(ss.fail()) return false;
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadUnits()
{
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadUnits() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 9: // next item found, so finish
return true;
case 70:
// x
get_line();
if(sscanf(m_str, "%d", &n) == 1)
{
m_eUnits = eDxfUnits_t( n );
}
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadLayer()
{
std::string layername;
int aci = -1;
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadLayer() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0: // next item found, so finish with line
if (layername.empty())
{
printf("CDxfRead::ReadLayer() - no layer name\n");
return false;
}
m_layer_aci[layername] = aci;
return true;
case 2: // Layer name follows
get_line();
layername = m_str;
break;
case 62:
// layer color ; if negative, layer is off
get_line();
if(sscanf(m_str, "%d", &aci) != 1)return false;
break;
case 6: // linetype name
case 70: // layer flags
case 100:
case 290:
case 370:
case 390:
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadSection()
{
get_line();
get_line();
strcpy(m_section_name, m_str);
get_line();
while(!((*m_ifs).eof()))
{
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadSection() Failed to read integer from '%s'\n", m_str );
return false;
}
switch(n){
case 0: // next item found, so finish with section
return true;
case 9: // header variable
get_line();
if (!strcmp( m_str, "$INSUNITS" )){
if (!ReadUnits())
{
printf("CDxfRead::DoRead() Failed to read block\n");
return false;
}
continue;
} // End if - then
if (!strcmp( m_str, "$MEASUREMENT" )){
get_line();
get_line();
int n = 1;
if(sscanf(m_str, "%d", &n) == 1)
{
if(n == 0)m_measurement_inch = true;
}
break;
} // End if - then
if (!strcmp( m_str, "$UCSORG" )){
if(!ReadUCS())return false;
continue;
} // End if - then
break;
default:
// skip the next line
get_line();
break;
}
get_line();
}
return false;
}
bool CDxfRead::ReadBlock()
{
std::string blockname;
double e[3] = {0, 0, 0};
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadBlock() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0: // next item found, so finish with line
if (blockname.empty())
{
printf("CDxfRead::ReadBlock() - no block name\n");
return false;
}
OnReadBlock(blockname.c_str(), e);
return true;
case 2: // Block name follows
case 3: // Block name follows
get_line();
blockname = m_str;
break;
case 10:
// base point x
get_line();
ss.str(m_str); ss >> e[0]; e[0] = mm(e[0]); if(ss.fail()) return false;
break;
case 20:
// base point y
get_line();
ss.str(m_str); ss >> e[1]; e[1] = mm(e[1]); if(ss.fail()) return false;
break;
case 30:
// base point z
get_line();
ss.str(m_str); ss >> e[2]; e[2] = mm(e[2]); if(ss.fail()) return false;
break;
case 5: // handle
case 8: // layer name
case 70: // layer flags
case 100: // subclass marker
case 102: // start of app defined group, or end of app defined group
case 1: // xref path name
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadInsert()
{
std::string blockname;
double e[3] = {0, 0, 0};
double rotation_angle = 0.0;
// to do, scale, rotation etc.
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadInsert() Failed to read integer from '%s'\n", m_str );
return false;
}
std::istringstream ss;
ss.imbue(std::locale("C"));
switch(n){
case 0: // next item found, so finish with line
if (blockname.empty())
{
printf("CDxfRead::ReadInsert() - no block name\n");
return false;
}
OnReadInsert(blockname.c_str(), e, rotation_angle);
return true;
case 2: // Block name follows
get_line();
blockname = m_str;
break;
case 10:
// insert point x
get_line();
ss.str(m_str); ss >> e[0]; e[0] = mm(e[0]); if(ss.fail()) return false;
break;
case 20:
// insert point y
get_line();
ss.str(m_str); ss >> e[1]; e[1] = mm(e[1]); if(ss.fail()) return false;
break;
case 30:
// insert point z
get_line();
ss.str(m_str); ss >> e[2]; e[2] = mm(e[2]); if(ss.fail()) return false;
break;
case 50:
// rotation angle
get_line();
ss.str(m_str); ss >> rotation_angle; if(ss.fail()) return false;
break;
case 100: // subclass marker
case 70: // layer flags
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
bool CDxfRead::ReadEndBlock()
{
std::string blockname;
while(!((*m_ifs).eof()))
{
get_line();
int n;
if(sscanf(m_str, "%d", &n) != 1)
{
printf("CDxfRead::ReadEndBlock() Failed to read integer from '%s'\n", m_str );
return false;
}
switch(n){
case 0: // next item found, so finish with line
OnReadEndBlock();
return true;
case 2: // Block name follows
case 3: // Block name follows
get_line();
blockname = m_str;
break;
case 5: // handle
case 100: // subclass marker
case 102: // start of app defined group, or end of app defined group
// skip the next line
get_line();
break;
default:
// skip the next line
get_line();
break;
}
}
return false;
}
enum DxfVariable
{
DxfVariableOther,
DxfVariableUCSORG,
};
void CDxfRead::DoRead(const bool ignore_errors /* = false */ )
{
m_ignore_errors = ignore_errors;
if(m_fail)return;
get_line();
while(!((*m_ifs).eof()))
{
if(!strcmp(m_str, "0"))
{
m_thickness = 0.0;
get_line();
if (!strcmp( m_str, "SECTION" )){
if(!ReadSection())
{
printf("CDxfRead::DoRead() Failed to read block\n");
return;
}
continue;
} // End if - then
if (!strcmp( m_str, "BLOCK" )){
if(!ReadBlock())
{
printf("CDxfRead::DoRead() Failed to read block\n");
return;
}
continue;
} // End if - then
if (!strcmp( m_str, "ENDBLK" )){
if(!ReadEndBlock())
{
printf("CDxfRead::DoRead() Failed to read end block\n");
return;
}
continue;
} // End if - then
if (!strcmp( m_str, "INSERT" )){
if(!ReadInsert())
{
printf("CDxfRead::DoRead() Failed to read insert\n");
return;
}
continue;
} // End if - then
else if (!strcmp( m_str, "TABLE" )){
get_line();
get_line();
}
else if (!strcmp( m_str, "LAYER" )){
if(!ReadLayer())
{
printf("CDxfRead::DoRead() Failed to read layer\n");
return;
}
continue; }
else if (!strcmp( m_str, "ENDSEC" )){
strcpy(m_section_name, "");
} // End if - then
else if(!strcmp(m_str, "LINE")){
if(!ReadLine())
{
printf("CDxfRead::DoRead() Failed to read line\n");
return;
}
continue;
}
else if(!strcmp(m_str, "ARC")){
if(!ReadArc())
{
printf("CDxfRead::DoRead() Failed to read arc\n");
return;
}
continue;
}
else if(!strcmp(m_str, "CIRCLE")){
if(!ReadCircle())
{
printf("CDxfRead::DoRead() Failed to read circle\n");
return;
}
continue;
}
else if(!strcmp(m_str, "TEXT")){
if(!ReadText())
{
printf("CDxfRead::DoRead() Failed to read text\n");
return;
}
continue;
}
else if (!strcmp(m_str, "MTEXT")){
if (!ReadMText())
{
printf("CDxfRead::DoRead() Failed to read mtext\n");
return;
}
continue;
}
else if (!strcmp(m_str, "RTEXT")){
if (!ReadRText())
{
printf("CDxfRead::DoRead() Failed to read rtext\n");
return;
}
continue;
}
else if (!strcmp(m_str, "ELLIPSE")){
if(!ReadEllipse())
{
printf("CDxfRead::DoRead() Failed to read ellipse\n");
return;
}
continue;
}
else if(!strcmp(m_str, "SPLINE")){
if(!ReadSpline())
{
printf("CDxfRead::DoRead() Failed to read spline\n");
return;
}
continue;
}
else if (!strcmp(m_str, "LWPOLYLINE")) {
if(!ReadLwPolyLine())
{
printf("CDxfRead::DoRead() Failed to read LW Polyline\n");
return;
}
continue;
}
else if (!strcmp(m_str, "POLYLINE")) {
if(!ReadPolyLine())
{
printf("CDxfRead::DoRead() Failed to read Polyline\n");
return;
}
continue;
}
else if (!strcmp(m_str, "POINT")) {
if(!ReadPoint())
{
printf("CDxfRead::DoRead() Failed to read Point\n");
return;
}
continue;
}
else if (!strcmp(m_str, "LEADER")) {
if(!ReadLeader())
{
printf("CDxfRead::DoRead() Failed to read Leader\n");
return;
}
continue;
}
else if (!strcmp(m_str, "MLINE")) {
if(!ReadMLine())
{
printf("CDxfRead::DoRead() Failed to read MLine\n");
return;
}
continue;
}
else if (!strcmp(m_str, "XLINE")) {
if(!ReadXLine())
{
printf("CDxfRead::DoRead() Failed to read XLine\n");
return;
}
continue;
}
else if (!strcmp(m_str, "DIMENSION")) {
if(!ReadDimension())
{
printf("CDxfRead::DoRead() Failed to read Dimension\n");
return;
}
continue;
}
}
get_line();
}
AddGraphics();
}
void CDxfRead::DerefACI()
{
if (m_aci == 256) // if color = layer color, replace by color from layer
{
m_aci = m_layer_aci[std::string(m_layer_name)];
}
}
std::string CDxfRead::LayerName() const
{
std::string result;
if (strlen(m_section_name) > 0)
{
result.append(m_section_name);
}
if (strlen(m_layer_name) > 0)
{
result.append(" ");
result.append(m_layer_name);
}
return(result);
}