dxf.cpp

// 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;
#ifdef __WXMSW__
	m_ofs = new ofstream(filepath, ios::out);
#else
	m_ofs = new ofstream(filepath, ios::out);
#endif
	if(!(*m_ofs)){
		m_fail = true;
		return;
	}
	m_ofs->imbue(std::locale("C"));
	m_ofs->precision(12);

	// 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, void(*percent_callback)(int))
{
	// 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;
	m_line_number = 0;
	m_number_of_lines = 0;
	m_current_percent = -1;
	m_percent_callback = percent_callback;

	// count the number of lines
	{
		m_number_of_lines = 0;
		m_ifs = new ifstream(filepath);
		if (!(*m_ifs)){
			m_fail = true;
			printf("DXF file didn't load\n");
			return;
		}
		char str[1024];
		while (m_ifs->getline(str, 1024))
			m_number_of_lines++;
		m_ifs->clear();
		m_ifs->seekg(0);
		printf("number of lines = %d\n", m_number_of_lines);
	}

	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;
}

static bool no_more_splines_please = 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);

	m_line_number++;

	if ((int)((double)m_line_number * 100 / m_number_of_lines) > m_current_percent)
	{
		m_current_percent++;
		// write current percent
		if (m_percent_callback)
		{
			(*m_percent_callback)(m_current_percent);
		}
	}
}

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);
}