/*
 * 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();
    }
}


