drop old, unused and error prone dxf2svg extension

(bzr r12075)

1 files changed, 0 insertions, 996 deletions

diff --git a/src/extension/dxf2svg/entities.cpp b/src/extension/dxf2svg/entities.cpp
deleted file mode 100644
index 4e2f83ee7..000000000
--- a/src/extension/dxf2svg/entities.cpp
+++ /dev/null
@@ -1,996 +0,0 @@
-/*
- * Class for interpereting the entities found in a DXF file
- *
- * Author:
- *   Matt Squires <squiresm@colorado.edu>
- *
- * Copyright (C) 2005 Matt Squires
- *
- * Released under GNU GPL and LGPL, read the file 'GPL.txt' and 'LGPL.txt' for details
- */
-
-
-#include"entities.h"
-#include<iostream>
-#include<math.h>
-
-int detmine_entity(char* value){
-    // Common Elements as far as I am concerend
-    if ( strncmp(value,"POLYLINE",8) == 0 ) return 0;    
-    if ( strncmp(value,"ARC",3) == 0 ) return 1;    
-    if ( strncmp(value,"CIRCLE",6) == 0 ) return 2;
-    if ( strncmp(value,"LINE",4) == 0 ) return 3;
-    if ( strncmp(value,"SPLINE",6) == 0 ) return 4;
-    if ( strncmp(value,"XLINE",5) == 0 ) return 5;
-    if ( strncmp(value,"RAY",3) == 0 ) return 6;
-    if ( strncmp(value,"DIMENSION",9) == 0 ) return 7;
-    if ( strncmp(value,"ELLIPSE",7) == 0 ) return 8;
-    if ( strncmp(value,"INSERT",6) == 0 ) return 9;
-    if ( strncmp(value,"VERTEX",6) == 0 ) return 10;
-    if ( strncmp(value,"TEXT",4) == 0 ) return 11;
-    
-    // Less Common eletities as far as I am concerend
-    if ( strncmp(value,"3DSOLID",7) == 0 ) return 12;
-    if ( strncmp(value,"ACAD_PROXY_ENTITY",17) == 0 ) return 13;    
-    if ( strncmp(value,"ARCALIGNEDTEXT",14) == 0 ) return 14;
-    if ( strncmp(value,"ATTDEF",6) == 0 ) return 15;
-    if ( strncmp(value,"ATTRIB",6) == 0 ) return 16;
-    if ( strncmp(value,"BODY",4) == 0 ) return 17;
-    if ( strncmp(value,"HATCH",5) == 0 ) return 18;
-    if ( strncmp(value,"IMAGE",5) == 0 ) return 19;
-    if ( strncmp(value,"LEADER",6) == 0 ) return 20;
-    if ( strncmp(value,"LWPOLYLINE",10) == 0 ) return 21;
-    if ( strncmp(value,"MLINE",5) == 0 ) return 22;
-    if ( strncmp(value,"MTEXT",5) == 0 ) return 23;
-    if ( strncmp(value,"OLEFRAME",8) == 0 ) return 24;
-    if ( strncmp(value,"POINT",5) == 0 ) return 25;    
-    if ( strncmp(value,"REGION",6) == 0 ) return 26;
-    if ( strncmp(value,"RTEXT",5) == 0 ) return 27;
-    if ( strncmp(value,"SEQEND",6) == 0 ) return 28;
-    if ( strncmp(value,"SHAPE",5) == 0 ) return 29;
-    if ( strncmp(value,"SOLID",5) == 0 ) return 30;    
-    if ( strncmp(value,"3DFACE",6) == 0 ) return 31;
-    if ( strncmp(value,"TOLERANCE",9) == 0 ) return 32;
-    if ( strncmp(value,"TRACE",5) == 0 ) return 33;
-    if ( strncmp(value,"VIEWPORT",8) == 0 ) return 34;
-    if ( strncmp(value,"WIPEOUT",7) == 0 ) return 35;
-    else return -1;
-}
-
-
-void entity::basic_entity( std::vector< dxfpair > info){
-    // Extract all of the typical entity information (e.g. layer name, positions)
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 6:
-                strcpy( string," "); // Clear the string out
-                info[i].value_char(string);
-                strcpy(linetype,string);
-                break;
-            case 8:
-                strcpy( string," ");  // Clear the string out
-                info[i].value_char(string);
-                strcpy(layer,string);
-                break;
-            case 10:
-                info[i].value_char(string);
-                x = atof(string);
-                if ( x < min_x ){
-                    min_x = x;
-                }
-                if ( x > max_x ){
-                    max_x = x;
-                }                
-                break;
-            case 20:
-                info[i].value_char(string);
-                y = atof(string);
-                if ( y < min_y ){
-                    min_y = y;
-                }
-                if ( y > max_y ){
-                    max_y = y;
-                }
-                break;
-            case 30:
-                info[i].value_char(string);
-                z = atof(string);
-                break;
-        }
-    }
-    
-}
-
-void entity::entity_display(){
-    std::cout << "\tlayer = " << layer << "\n\tlinetype = " << linetype << "\n\tx = " << x << "\ty = " << y << "\tz = " << z << std::flush;
-}
-
-double entity::ret_x(){
-    return x;
-}
-
-double entity::ret_y(){
-    return y;
-}
-
-double entity::ret_z(){
-    return z;
-}
-
-
-char* entity::ret_layer_name(char* string){
-    return( strcpy(string,layer) );
-}
-
-char* entity::ret_ltype_name(char* string){
-    return( strcpy(string,linetype) );
-}
-
-double entity::ret_min_x(){
-    return min_x;
-}
-
-double entity::ret_max_x(){
-    return max_x;
-}
-
-double entity::ret_min_y(){
-    return min_y;
-}
-
-double entity::ret_max_y(){
-    return max_y;
-}
-
-void entity::test_coord(double x, double y){
-    if ( x < min_x ){
-        min_x = x;
-    }
-    if ( x > max_x ){
-        max_x = x;
-    }
-    if ( y < min_y ){
-        min_y = y;
-    }
-    if ( y > max_y ){
-        max_y = y;
-    }
-}
-
-
-void entity::reset_extents(){
-    min_x = -1e20;
-    max_x = 1e20;
-    min_y = -1e20;
-    max_y = 1e20;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// VERTEX
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-vertex::vertex( std::vector< dxfpair > info){
-    // Get the vertex information
-    
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 42:
-                info[i].value_char(string);
-                bulge = atof(string);
-                break;
-        }
-    }    
-}
-
-double vertex::ret_bulge(){
-    return bulge;
-}
-
-void vertex::display(){
-    std::cout << "VERTEX\n";
-    std::cout << "\tx = " << x << "\ty = " << y << "\tz = " << z << "\tbulge = " << bulge << std::flush;
-}
-
-
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// POLYLINE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-// The polyline is handled a little differently compared to the other entities because a POLYLINE is built from a bunch of VERTEX entities
-polyline::polyline( std::vector< std::vector< dxfpair > > sections ){
-    buldge = 0;
-    pline_flag = 0;
-    reset_extents();
-    // get the polyline information
-    basic_entity( sections[0] );
-    points.clear();
-    static char string[10000];
-    for (int i = 0; i < sections[0].size(); i++){
-        switch( sections[0][i].group_code ){
-            case 70:
-                sections[0][i].value_char(string);
-                pline_flag = atoi(string);
-                break;
-            case 40:
-                sections[0][i].value_char(string);
-                start_width = atoi(string);
-                break;
-            case 41:
-                sections[0][i].value_char(string);
-                end_width = atoi(string);
-                break;
-            case 75:
-                sections[0][i].value_char(string);
-                curves_flag = atoi(string);
-                break;
-        }
-    }
-    curves_flag = 0;
-    
-    // Now add the VERTEX entities to the POLYLINE
-    for (int i = 1; i < sections.size(); i++){
-        points.push_back( vertex( sections[i] ) );
-    }
-}
-
-
-std::vector< vertex > polyline::ret_points(){
-    return points;
-}
-
-double polyline::bulge(int point){
-    return points[point].ret_bulge();
-}
-
-double polyline::bulge_r(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    return r;
-}
-
-double polyline::bulge_start_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1))
-    {
-        return 0;
-    }
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    if (dx > 0)
-    {
-        sb *= -1; // Correct for different point ordering and bulge direction
-    }
-    
-    // Now calculate the angle 
-    double theta = asin(points[point].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-double polyline::bulge_end_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1))
-    {
-        return 0;
-    }
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    // Now calculate the angle 
-    double theta = asin(points[point+1].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-bool polyline::is_closed(){
-    // pline-flag holds info about closed pline in the 1 bit.  The info is bit wise encoded so use bit wise operators
-    return bool(pline_flag&1);
-}
-
-void polyline::display(){
-    std::cout << "POLYLINE\n";
-    entity_display();
-    std::cout << std::endl;
-    for (int i = 0; i < points.size(); i++){
-        points[i].display();
-        std::cout << std::endl;
-    }
-    std::cout << std::endl;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// LWPOLYLINE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-// The lwpolyline is different than the polyline because there are no vertex entities.  Use the same basic process as the polyline but parse it out differently
-lwpolyline::lwpolyline( std::vector< dxfpair > section ){
-    
-    // First break up the data into the same format that is used by the polyline entity
-    std::vector< std::vector< dxfpair > > sections;
-    std::vector< dxfpair > first;
-    std::vector< dxfpair > others;
-    
-    sections.clear();
-    first.clear();
-    others.clear();
-    
-    int gc;  // make a shorter name for group_code;
-    
-    int vertex_part;
-    int already_found = 0;
-    
-    for (int i = 0; i < section.size(); i++){
-        gc = section[i].group_code;
-        // Encode bitwise information to keep track of what has been found
-        vertex_part = 0;
-        if (gc == 10 ) vertex_part += 1;
-        if (gc == 20 ) vertex_part += 2;
-        if (gc == 30 ) vertex_part += 4;
-        if (gc == 40 ) vertex_part += 8;
-        if (gc == 41 ) vertex_part += 16;
-        if (gc == 42 ) vertex_part += 32;
-        //std::cout << "\n\nvertex_part = " << vertex_part << std::endl << "already_found = " << already_found << std::endl << "(vertex_part&already_found) = " << (vertex_part&already_found) << std::endl;
-        if ( vertex_part == 0 ){
-            // If header stuff has been found save it under first.
-            // I.E. in a polyline the first set of information is linetype and layer, all of what should be in here
-            first.push_back( section[i] );            
-        }
-        else if ( (vertex_part&already_found) == 0 ){
-            // Now work on what would be the vertex information
-            // New information is still being found so keep saving it
-            others.push_back( section[i] );    
-            //std::cout << "add to others" << std::endl;
-            already_found += vertex_part;  // Keep track of what has been found            
-        }
-        else{
-            sections.push_back( others );
-            //std::cout << "sections.size() = " << sections.size() << std::endl;
-            // Now clear the information out and start over
-            others.clear();
-            others.push_back( section[i] );
-            already_found = vertex_part;            
-        }
-    }
-    
-    // Now put on the last data that was found 
-    if (!others.empty()){
-        sections.push_back(others);
-    }
-    
-    reset_extents();
-    basic_entity( first );
-    points.clear();
-    static char string[10000];
-    buldge = 0;
-    pline_flag = 0;
-    curves_flag = 0;
-    for (int i = 0; i < first.size(); i++){
-        switch( sections[0][i].group_code ){
-            case 70:
-                first[i].value_char(string);
-                pline_flag = atoi(string);
-                break;
-            case 40:
-                first[i].value_char(string);
-                start_width = atoi(string);
-                break;
-            case 41:
-                first[i].value_char(string);
-                end_width = atoi(string);
-                break;
-            case 75:
-                first[i].value_char(string);
-                curves_flag = atoi(string);
-                break;
-        }
-    }
-    // Now add the VERTEX entities to the POLYLINE
-    for (int i = 0; i < sections.size(); i++){
-        points.push_back( vertex( sections[i] ) );
-    }
-}
-
-
-
-std::vector< vertex > lwpolyline::ret_points(){
-    return points;
-}
-
-
-double lwpolyline::bulge(int point){
-    return points[point].ret_bulge();
-}
-
-double lwpolyline::bulge_r(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    return r;
-}
-
-double lwpolyline::bulge_start_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    // Now calculate the angle 
-    double theta = asin(points[point].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-double lwpolyline::bulge_end_angle(int point){
-    // Make sure we are not exceeding the bounds of the points vector
-    if (point >= (points.size()-1)) return 0;
-    
-    double dx = points[point+1].ret_x() - points[point].ret_x();
-    double dy = points[point+1].ret_y() - points[point].ret_y();
-    double bulge = points[point].ret_bulge();
-    double l = sqrt(dx*dx + dy*dy);
-    double r = fabs(l*(bulge*bulge+1)/bulge/4);
-    
-    // Now calculate the angle 
-    double theta = asin(points[point+1].ret_x()/r);
-    if (dy < 0) theta = 6.2831853 - theta;  // The angle is greater than pi so fix this because max(asin) = pi
-    
-    return theta;    
-}
-
-bool lwpolyline::is_closed(){
-    // pline-flag holds info about closed pline in the 1 bit.  The info is bit wise encoded so use bit wise operators
-    return bool(pline_flag&1);
-}
-
-void lwpolyline::display(){
-    std::cout << "lwpolyline\n";
-    entity_display();
-    std::cout << std::endl;
-    for (int i = 0; i < points.size(); i++){
-        points[i].display();
-        std::cout << std::endl;
-    }
-    std::cout << std::endl;
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// ARC
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-arc::arc( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 40:
-                info[i].value_char(string);
-                radius = atof(string);
-                test_coord(x+radius,y+radius);
-                test_coord(x-radius,y-radius);
-                break;
-            case 50:
-                info[i].value_char(string);
-                start_angle = atof(string);
-                break;
-            case 51:
-                info[i].value_char(string);
-                end_angle = atof(string);
-                break;
-            default:
-                break;
-        }
-    }
-}
-
-double arc::ret_radius(){
-    return radius;
-}
-
-
-double arc::ret_srt_ang(){
-    return start_angle;
-}
-
-
-double arc::ret_end_ang(){
-    return end_angle;
-}
-
-
-void arc::display(){
-    std::cout << "ARC\n";
-    entity_display();
-    std::cout << "\n\tradius = " << radius << "\tstart_angle = " << start_angle << "end_angle = " << end_angle << std::flush;
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// CIRCLE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-circle::circle( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 40:
-                info[i].value_char(string);
-                radius = atof(string);
-                test_coord(x+radius,y+radius);
-                test_coord(x-radius,y-radius);
-                break;
-        }
-    }
-}
-
-void circle::display(){
-    std::cout << "CIRCLE\n";
-    entity_display();
-    std::cout << "\n\tradius = " << radius << std::flush;
-}
-
-
-double circle::ret_radius(){
-    return radius;
-}
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// LINE
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-
-line::line( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 11:
-                info[i].value_char(string);
-                xf = atof(string);
-                break;
-            case 21:
-                info[i].value_char(string);
-                yf = atof(string);
-                break;
-            case 31:
-                info[i].value_char(string);
-                zf = atof(string);
-                break;
-        }
-    }
-    test_coord(xf,yf);
-        
-}
-
-void line::display(){
-    std::cout << "LINE\n";
-    entity_display();
-    std::cout << "\n\txf = " << xf << "\tyf = " << yf << "\tzf = " << zf << std::flush;
-}
-
-
-double line::ret_xf(){
-    return xf;
-}
-
-double line::ret_yf(){
-    return yf;
-}
-
-double line::ret_zf(){
-    return zf;
-}
-
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// TEXT
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-text::text( std::vector< dxfpair > info){
-    
-    reset_extents();
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 1:
-                info[i].value_char(dxf_text); // directly copy the text into a string
-                break;
-            case 40:
-                info[i].value_char(string);
-                text_height = atof(string);
-                break;
-            case 50:
-                info[i].value_char(string);
-                text_rotation = atof(string);
-                break;
-        }
-    }
-}
-
-char * text::ret_text(char *string){
-    return( strcpy(string,dxf_text) );
-}
-
-double text::ret_txt_ht(){
-    return text_height;
-}
-
-double text::ret_txt_rot(){
-    return text_rotation;
-}
-
-void text::display(){
-    char tmp[10000];
-    std::cout << "TEXT\n";
-    entity_display();
-    std::cout << "\ndxf_text = " << ret_text(tmp) << std::flush;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// INSERT
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-insert::insert( std::vector< dxfpair > info){
-    ret_x_sf = 0;
-    ret_y_sf = 0;
-    ret_z_sf = 0;
-    ret_rotation = 0;
-    
-    basic_entity( info );
-    static char string[10000];
-    for (int i = 0; i < info.size(); i++){
-        switch( info[i].group_code ){
-            case 2:
-                info[i].value_char(block_name); // directly copy the text into a string
-                break;
-            case 41:
-                info[i].value_char(string);
-                x_scale_factor = atof(string);
-                break;
-            case 42:
-                info[i].value_char(string);
-                y_scale_factor = atof(string);
-                break;
-            case 43:
-                info[i].value_char(string);
-                z_scale_factor = atof(string);
-                break;
-            case 50:
-                info[i].value_char(string);
-                rotation = atof(string);
-                break;
-        }
-    }
-}
-
-
-char * insert::name(char *string){
-    return( strcpy(string,block_name) );
-}
-
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// entities
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    
-
-
-entities::entities(std::vector< std::vector< dxfpair > > sections){
-    // Read the main information about the entities section and then put it in the enetites class
-    int value;
-    char string[10000];
-    std::vector< dxfpair > single_line;
-    std::vector< std::vector< dxfpair > > pline;
-    pline.clear();
-    single_line.clear();
-    
-    for(int i = 0; i < sections.size(); i++){
-        sections[i][0].value_char(string);
-        value = detmine_entity(string);
-        switch( value ){
-            case 0:
-                // Get everything from the start of the polyline designation to an SEQEND value
-                pline.clear();  // First clear out the pline information
-                do{
-                    pline.push_back( sections[i] );
-                    sections[++i][0].value_char(string);
-                }while( strncmp(string,"SEQEND",6) != 0 );
-                ents_polyline.push_back( polyline( pline ) );
-                break;
-            
-            case 1:
-                // ARC
-                ents_arc.push_back( arc( sections[i] ) );
-                break;
-                
-            case 2:
-                // CIRCLE
-                ents_circle.push_back( circle( sections[i] ) );
-                break;
-                
-            case 3:
-                // LINE
-                ents_line.push_back( line( sections[i] ) );
-                break;
-            case 11:
-                // TEXT
-                ents_text.push_back( text( sections[i] ) );
-                break;
-            case 21:
-                // LWPOLYLINE
-                ents_lwpolyline.push_back( lwpolyline( sections[i] ) );
-            case 9:
-                // INSERT
-                ents_insert.push_back( insert( sections[i] ) );
-            
-            //default:
-                // Nothing here
-        }
-        
-    }
-    
-}
-
-
-// Maybe all of this could be turned into fewer function by using templates, but no time right now.  MBS
-
-std::vector< polyline > entities::ret_plines(){
-    std::vector< polyline > pls;
-    pls.clear();
-    for(int i = 0; i < ents_polyline.size();i++){
-        pls.push_back( ents_polyline[i] );
-    }
-    return pls;
-}
-
-std::vector< lwpolyline > entities::ret_lwplines(){
-    std::vector< lwpolyline > lwpls;
-    lwpls.clear();
-    for(int i = 0; i < ents_lwpolyline.size();i++){
-        lwpls.push_back( ents_lwpolyline[i] );
-    }
-    return lwpls;
-}
-
-
-std::vector< arc > entities::ret_arcs(){
-    std::vector< arc > a;
-    a.clear();
-    for(int i = 0; i < ents_arc.size();i++){
-        a.push_back( ents_arc[i] );
-    }
-    return a;
-}
-
-std::vector< circle > entities::ret_circles(){
-    std::vector< circle > circs;
-    circs.clear();
-    for(int i = 0; i < ents_circle.size();i++){
-        circs.push_back( ents_circle[i] );
-    }
-    return circs;
-}
-
-
-std::vector< line > entities::ret_lines(){
-    std::vector< line > lns;
-    lns.clear();
-    for(int i = 0; i < ents_line.size();i++){
-        lns.push_back( ents_line[i] );
-    }
-    return lns;
-}
-
-
-std::vector< text > entities::ret_texts(){
-    std::vector< text > txts;
-    txts.clear();
-    for(int i = 0; i < ents_text.size();i++){
-        txts.push_back( ents_text[i] );
-    }
-    return txts;
-}
-
-
-std::vector< insert > entities::ret_inserts(){
-    std::vector< insert > ins;
-    ins.clear();
-    for(int i = 0; i < ents_insert.size();i++){
-        ins.push_back( ents_insert[i] );
-    }
-    return ins;
-}
-
-
-
-// Overload the return function to depend on the layer
-std::vector< polyline > entities::ret_plines(char * layer){
-    char temp[10000];
-    std::vector< polyline > pls;
-    pls.clear();
-    
-    for(int i = 0; i < ents_polyline.size();i++){
-        if ( strcmp( layer,ents_polyline[i].ret_layer_name(temp) ) == 0 ){
-            pls.push_back( ents_polyline[i] );
-        }
-    }
-    return pls;
-}
-
-
-std::vector< lwpolyline > entities::ret_lwplines(char * layer){
-    char temp[10000];
-    std::vector< lwpolyline > lwpls;
-    lwpls.clear();
-    
-    for(int i = 0; i < ents_lwpolyline.size();i++){
-        if ( strcmp( layer,ents_lwpolyline[i].ret_layer_name(temp) ) == 0 ){
-            lwpls.push_back( ents_lwpolyline[i] );
-        }
-    }
-    return lwpls;
-}
-
-
-std::vector< circle > entities::ret_circles(char * layer){
-    char temp[10000];
-    std::vector< circle > circs;
-    circs.clear();
-    
-    for(int i = 0; i < ents_circle.size();i++){
-        if ( strcmp( layer,ents_circle[i].ret_layer_name(temp) ) == 0 ){
-            circs.push_back( ents_circle[i] );
-        }
-    }
-    return circs;
-}
-
-
-std::vector< line > entities::ret_lines(char * layer){
-    char temp[10000];
-    std::vector< line > lns;
-    lns.clear();
-    
-    for(int i = 0; i < ents_line.size();i++){
-        if ( strcmp( layer,ents_line[i].ret_layer_name(temp) ) == 0 ){
-            lns.push_back( ents_line[i] );
-        }
-    }
-    return lns;
-}
-
-
-std::vector< text > entities::ret_texts(char * layer){
-    char temp[10000];
-    std::vector< text > txts;
-    txts.clear();
-    
-    for(int i = 0; i < ents_text.size();i++){
-        if ( strcmp( layer,ents_text[i].ret_layer_name(temp) ) == 0 ){
-            txts.push_back( ents_text[i] );
-        }
-    }
-    return txts;
-}
-
-
-/*std::vector< ellipse > entities::ret_ellipses(char * layer){
-    char temp[10000];
-    std::vector< polyline > pls;
-    pls.clear();
-    
-    for(int i = 0; i < ents_polyline.size();i++){
-        if ( strcmp( layer,ents_polyline[i].ret_layer_name(temp) ) == 0 ){
-            pls.push_back( ents_polyline[i] );
-        }
-    }
-    return pls;
-}*/
-
-
-std::vector< arc > entities::ret_arcs(char * layer){
-    char temp[10000];
-    std::vector< arc > a;
-    a.clear();
-    
-    for(int i = 0; i < ents_arc.size();i++){
-        if ( strcmp( layer,ents_arc[i].ret_layer_name(temp) ) == 0 ){
-            a.push_back( ents_arc[i] );
-        }
-    }
-    return a;
-}
-
-
-std::vector< insert > entities::ret_inserts(char * layer){
-    char temp[10000];
-    std::vector< insert > ins;
-    ins.clear();
-    
-    for(int i = 0; i < ents_insert.size();i++){
-        if ( strcmp( layer,ents_insert[i].ret_layer_name(temp) ) == 0 ){
-            ins.push_back( ents_insert[i] );
-        }
-    }
-    return ins;
-}
-
-
-
-
-void entities::display_all(){
-    for (int i = 0; i < ents_polyline.size(); i++){
-        ents_polyline[i].display();
-    }
-    std::cout << std::endl;
-    for (int i = 0; i < ents_lwpolyline.size(); i++){
-        ents_lwpolyline[i].display();
-    }
-    std::cout << std::endl;
-    for (int i = 0; i < ents_circle.size(); i++){
-        ents_circle[i].display();
-    }
-    std::cout << std::endl;
-    for (int i = 0; i < ents_text.size(); i++){
-        ents_text[i].display();
-    }
-}
-
-