br_dxf/

lib.rs

pub mod text;

extern crate core;

use dxf::{Drawing};
use dxf::entities::EntityType;
use log::info;
use dxf::enums::AttachmentPoint;

pub struct Dxf {}

impl Dxf {
    pub fn load(path: &str) -> String {
        let drawing = match Drawing::load_file(path) {
            Ok(e) => e,
            Err(_) => {
                return "".to_string();
            }
        };
        let mut x = 0.0;
        let mut y = 0.0;

        for e in drawing.entities() {
            // let index = e.common.handle.0;
            match e.specific {
                EntityType::Circle(ref circle) => {
                    if x < circle.center.x {
                        x = circle.center.x;
                    }
                    if y < circle.center.y {
                        y = circle.center.y;
                    }


                    // return;
                    // info!("圆 半径: {}",circle.radius);
                    // info!("圆 直径: {}",circle.radius * 2.0);
                    // info!("圆 周长: {}",circle.radius * 2.0 * PI);
                    // info!("圆 面积: {}",circle.radius*circle.radius*PI);
                    // info!("圆 x: {} y: {} z: {}",circle.center.x,circle.center.y,circle.center.z);
                }
                EntityType::Line(ref line) => {
                    // info!("线{}: {:?}",index, line.p1.x);
                    // info!("线{}: {:?}",index, line.p2.x);
                    if x < line.p1.x {
                        x = line.p1.x;
                    }
                    if x < line.p2.x {
                        x = line.p2.x;
                    }
                    if y < line.p1.y {
                        y = line.p1.y;
                    }
                    if y < line.p2.y {
                        y = line.p2.y;
                    }
                }
                EntityType::ModelPoint(ref _model_point) => {
                    // info!("模型: {:?} {:?}",model_point.location.x,model_point.location.y);
                }
                EntityType::Text(ref _data) => {
                    // info!("文本: {:?}",data);
                }
                EntityType::LwPolyline(ref line) => {
                    for vertex in line.vertices.iter() {
                        if x < vertex.x {
                            x = vertex.x;
                        }
                        if y < vertex.y {
                            y = vertex.y;
                        }
                    }
                }
                EntityType::Arc(ref arc) => {
                    // 弧
                    if x < arc.center.x {
                        x = arc.center.x;
                    }
                    if y < arc.center.y {
                        y = arc.center.y;
                    }
                }
                EntityType::RadialDimension(ref _radial) => {}
                EntityType::RotatedDimension(ref radial) => {
                    // 线性标注尺寸
                    if x < radial.dimension_base.definition_point_1.x {
                        x = radial.dimension_base.definition_point_1.x;
                    }
                    if y < radial.dimension_base.definition_point_1.y {
                        y = radial.dimension_base.definition_point_1.y;
                    }

                    if x < radial.dimension_base.text_mid_point.x {
                        x = radial.dimension_base.text_mid_point.x;
                    }
                    if y < radial.dimension_base.text_mid_point.y {
                        y = radial.dimension_base.text_mid_point.y;
                    }
                }
                EntityType::MText(ref text) => {
                    // 多行文字
                    if x < text.insertion_point.x {
                        x = text.insertion_point.x;
                    }
                    if y < text.insertion_point.y {
                        y = text.insertion_point.y;
                    }
                }
                EntityType::DiameterDimension(ref diameter) => {
                    // 标注长度型尺寸
                    if x < diameter.dimension_base.text_mid_point.x {
                        x = diameter.dimension_base.text_mid_point.x;
                    }
                    if y < diameter.dimension_base.text_mid_point.y {
                        y = diameter.dimension_base.text_mid_point.y;
                    }
                }
                EntityType::Insert(ref data) => {
                    // 块
                    if x < data.location.x {
                        x = data.location.x;
                    }
                    if y < data.location.y {
                        y = data.location.y;
                    }
                }
                _ => {
                    info!("未知 {:?}",e.specific);
                }
            }
        }

        fn r(max_x: f64, x: f64) -> f64 {
            x / max_x * 100.0
        }

        let mut svg = vec![format!(r#"<svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg">"#)];

        for e in drawing.entities() {
            let index = e.common.handle.0;
            match e.specific {
                EntityType::Circle(ref circle) => {
                    let x_value = r(x, circle.center.x);
                    let y_value = r(y, circle.center.y);

                    let r_value = r([x, y].iter().copied().fold(f64::NAN, f64::max), circle.radius);
                    let text = format!(r#"<circle id="circle_{index}" cx="{x_value}%" cy="{y_value}%" r="{r_value}%" />"#);
                    svg.push(text);
                    // return;
                    // info!("圆 半径: {}",circle.radius);
                    // info!("圆 直径: {}",circle.radius * 2.0);
                    // info!("圆 周长: {}",circle.radius * 2.0 * PI);
                    // info!("圆 面积: {}",circle.radius*circle.radius*PI);
                    // info!("圆 x: {} y: {} z: {}",circle.center.x,circle.center.y,circle.center.z);
                }
                EntityType::Line(ref line) => {
                    let x1_value = r(x, line.p1.x);
                    let y1_value = r(y, line.p1.y);
                    let x2_value = r(x, line.p2.x);
                    let y2_value = r(y, line.p2.y);
                    let text = format!(r#"<line id="line_{index}" x1="{x1_value}%" y1="{y1_value}%" x2="{x2_value}%" y2="{y2_value}%" stroke="black" stroke-width="1" />"#);
                    svg.push(text);
                }
                EntityType::ModelPoint(ref _model_point) => {
                    // info!("模型: {:?} {:?}",model_point.location.x,model_point.location.y);
                }
                EntityType::Text(ref text) => {
                    info!("文本: {}",text.value);
                }
                EntityType::LwPolyline(ref line) => {
                    let mut points = vec![];
                    let mut xy = vec![];
                    for vertex in line.vertices.iter() {
                        if xy.is_empty() {
                            xy.push(r(x, vertex.x));
                            xy.push(r(y, vertex.y));
                            continue;
                        }
                        if xy.len() == 2 {
                            xy.push(r(x, vertex.x));
                            xy.push(r(y, vertex.y));
                            points.push(xy.clone());
                            xy.clear();
                            xy.push(r(x, vertex.x));
                            xy.push(r(y, vertex.y));
                            continue;
                        }
                    }
                    for point in points {
                        let text = format!(r#"<line id="polyline_line_{index}" x1="{}%" y1="{}%" x2="{}%" y2="{}%" stroke="black" stroke-width="1" />"#, point[0], point[1], point[2], point[3]);
                        svg.push(text);
                    }
                }
                EntityType::Insert(ref data) => {
                    // 块
                    println!("{:?}", data);
                }
                _ => {
                    // info!("未知 {:?}",e.specific);
                }
            }
        }
        svg.push("</svg>".to_string());
        svg.join("")
    }
    /// 按比例尺寸
    pub fn ratio(path: &str) -> String {
        let drawing = Drawing::load_file(path).unwrap();
        let mut x = 0.0;
        let mut y = 0.0;

        for e in drawing.entities() {
            let _index = e.common.handle.0;
            match e.specific {
                EntityType::Circle(ref circle) => {
                    if x < circle.center.x {
                        x = circle.center.x;
                    }
                    if y < circle.center.y {
                        y = circle.center.y;
                    }


                    // return;
                    // info!("圆 半径: {}",circle.radius);
                    // info!("圆 直径: {}",circle.radius * 2.0);
                    // info!("圆 周长: {}",circle.radius * 2.0 * PI);
                    // info!("圆 面积: {}",circle.radius*circle.radius*PI);
                    // info!("圆 x: {} y: {} z: {}",circle.center.x,circle.center.y,circle.center.z);
                }
                EntityType::Line(ref line) => {
                    // info!("线{}: {:?}",index, line.p1.x);
                    // info!("线{}: {:?}",index, line.p2.x);
                    if x < line.p1.x {
                        x = line.p1.x;
                    }
                    if x < line.p2.x {
                        x = line.p2.x;
                    }
                    if y < line.p1.y {
                        y = line.p1.y;
                    }
                    if y < line.p2.y {
                        y = line.p2.y;
                    }
                }
                EntityType::ModelPoint(ref _model_point) => {
                    // info!("模型: {:?} {:?}",model_point.location.x,model_point.location.y);
                }
                EntityType::Text(ref _text) => {
                    // info!("文本: {:?}",text);
                }
                EntityType::LwPolyline(ref line) => {
                    for vertex in line.vertices.iter() {
                        if x < vertex.x {
                            x = vertex.x;
                        }
                        if y < vertex.y {
                            y = vertex.y;
                        }
                    }
                }
                _ => {
                    info!("未知 {:?}",e.specific);
                }
            }
        }

        fn r(max_x: f64, x: f64) -> f64 {
            x / max_x * 100.0
        }

        let mut svg = vec![format!(r#"<svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg">"#)];

        for e in drawing.entities() {
            let index = e.common.handle.0;
            match e.specific {
                EntityType::Circle(ref circle) => {
                    let x_value = r(x, circle.center.x);
                    let y_value = r(y, circle.center.y);

                    let r_value = r([x, y].iter().copied().fold(f64::NAN, f64::max), circle.radius);
                    let text = format!(r#"<circle id="circle_{index}" cx="{x_value}%" cy="{y_value}%" r="{r_value}%" />"#);
                    svg.push(text);
                    // return;
                    // info!("圆 半径: {}",circle.radius);
                    // info!("圆 直径: {}",circle.radius * 2.0);
                    // info!("圆 周长: {}",circle.radius * 2.0 * PI);
                    // info!("圆 面积: {}",circle.radius*circle.radius*PI);
                    // info!("圆 x: {} y: {} z: {}",circle.center.x,circle.center.y,circle.center.z);
                }
                EntityType::Line(ref line) => {
                    let x1_value = r(x, line.p1.x);
                    let y1_value = r(y, line.p1.y);
                    let x2_value = r(x, line.p2.x);
                    let y2_value = r(y, line.p2.y);
                    let text = format!(r#"<line id="line_{index}" x1="{x1_value}%" y1="{y1_value}%" x2="{x2_value}%" y2="{y2_value}%" stroke="black" stroke-width="1" />"#);
                    svg.push(text);
                }
                EntityType::ModelPoint(ref _model_point) => {
                    // info!("模型: {:?} {:?}",model_point.location.x,model_point.location.y);
                }
                EntityType::Text(ref _text) => {
                    // info!("文本: {:?}",text);
                }
                EntityType::LwPolyline(ref line) => {
                    let mut points = vec![];
                    let mut xy = vec![];
                    for vertex in line.vertices.iter() {
                        if xy.is_empty() {
                            xy.push(r(x, vertex.x));
                            xy.push(r(y, vertex.y));
                            continue;
                        }
                        if xy.len() == 2 {
                            xy.push(r(x, vertex.x));
                            xy.push(r(y, vertex.y));
                            points.push(xy.clone());
                            xy.clear();
                            xy.push(r(x, vertex.x));
                            xy.push(r(y, vertex.y));
                            continue;
                        }
                    }
                    for point in points {
                        let text = format!(r#"<line id="polyline_line_{index}" x1="{}%" y1="{}%" x2="{}%" y2="{}%" stroke="black" stroke-width="1" />"#, point[0], point[1], point[2], point[3]);
                        svg.push(text);
                    }
                }
                _ => {
                    info!("未知 {:?}",e.specific);
                }
            }
        }
        svg.push("</svg>".to_string());
        svg.join("")
    }

    /// 正常尺寸
    pub fn size(path: &str, class_id: &str) -> String {
        let drawing = match Drawing::load_file(path) {
            Ok(e) => e,
            Err(_) => {
                return "".to_string();
            }
        };

        let mut x = 0.0;
        let mut y = 0.0;

        for e in drawing.entities() {
            match e.specific {
                EntityType::Circle(ref circle) => {
                    if x < circle.center.x {
                        x = circle.center.x;
                    }
                    if y < circle.center.y {
                        y = circle.center.y;
                    }


                    // return;
                    // info!("圆 半径: {}",circle.radius);
                    // info!("圆 直径: {}",circle.radius * 2.0);
                    // info!("圆 周长: {}",circle.radius * 2.0 * PI);
                    // info!("圆 面积: {}",circle.radius*circle.radius*PI);
                    // info!("圆 x: {} y: {} z: {}",circle.center.x,circle.center.y,circle.center.z);
                }
                EntityType::Line(ref line) => {
                    if x < line.p1.x {
                        x = line.p1.x;
                    }
                    if x < line.p2.x {
                        x = line.p2.x;
                    }
                    if y < line.p1.y {
                        y = line.p1.y;
                    }
                    if y < line.p2.y {
                        y = line.p2.y;
                    }
                }
                // 模型
                EntityType::ModelPoint(ref _model_point) => {}
                // 文本
                EntityType::Text(ref text) => {
                    if x < text.location.x {
                        x = text.location.x;
                    }
                    if y < text.location.y {
                        y = text.location.y;
                    }
                }
                EntityType::LwPolyline(ref line) => {
                    for vertex in line.vertices.iter() {
                        if x < vertex.x {
                            x = vertex.x;
                        }
                        if y < vertex.y {
                            y = vertex.y;
                        }
                    }
                }
                EntityType::Arc(ref arc) => {
                    // 弧
                    if x < arc.center.x {
                        x = arc.center.x;
                    }
                    if y < arc.center.y {
                        y = arc.center.y;
                    }
                }
                EntityType::RadialDimension(ref _radial) => {
                    // info!("1111");
                }
                EntityType::RotatedDimension(ref radial) => {
                    // 线性标注尺寸
                    if x < radial.dimension_base.definition_point_1.x {
                        x = radial.dimension_base.definition_point_1.x;
                    }
                    if y < radial.dimension_base.definition_point_1.y {
                        y = radial.dimension_base.definition_point_1.y;
                    }

                    if x < radial.dimension_base.text_mid_point.x {
                        x = radial.dimension_base.text_mid_point.x;
                    }
                    if y < radial.dimension_base.text_mid_point.y {
                        y = radial.dimension_base.text_mid_point.y;
                    }
                }
                EntityType::MText(ref text) => {
                    // 多行文字
                    if x < text.insertion_point.x {
                        x = text.insertion_point.x;
                    }
                    if y < text.insertion_point.y {
                        y = text.insertion_point.y;
                    }
                }
                EntityType::DiameterDimension(ref diameter) => {
                    // 标注长度型尺寸
                    if x < diameter.dimension_base.text_mid_point.x {
                        x = diameter.dimension_base.text_mid_point.x;
                    }
                    if y < diameter.dimension_base.text_mid_point.y {
                        y = diameter.dimension_base.text_mid_point.y;
                    }
                }
                EntityType::Insert(ref data) => {
                    // 块
                    if x < data.location.x {
                        x = data.location.x;
                    }
                    if y < data.location.y {
                        y = data.location.y;
                    }
                }
                EntityType::Spline(ref data) => {
                    for control_point in data.control_points.iter() {
                        if x < control_point.x {
                            x = control_point.x;
                        }
                        if y < control_point.y {
                            y = control_point.y;
                        }
                    }
                }
                EntityType::Solid(ref data) => {
                    if x < data.first_corner.x {
                        x = data.first_corner.x;
                    }
                    if y < data.first_corner.y {
                        y = data.first_corner.y;
                    }

                    if x < data.second_corner.x {
                        x = data.second_corner.x;
                    }
                    if y < data.second_corner.y {
                        y = data.second_corner.y;
                    }
                    if x < data.third_corner.x {
                        x = data.third_corner.x;
                    }
                    if y < data.third_corner.y {
                        y = data.third_corner.y;
                    }
                    if x < data.fourth_corner.x {
                        x = data.fourth_corner.x;
                    }
                    if y < data.fourth_corner.y {
                        y = data.fourth_corner.y;
                    }
                }
                _ => {
                    info!("未知 {:?}",e.specific);
                }
            }
        }


        let mut svg = vec![format!(r#"<svg id="svg_{class_id}" width="{}" height="{}" xmlns="http://www.w3.org/2000/svg">"#, x, y)];

        for e in drawing.entities() {
            let index = e.common.handle.0;
            match e.specific {
                EntityType::Circle(ref circle) => {
                    let x_value = circle.center.x;
                    let y_value = circle.center.y;
                    let r_value = circle.radius;
                    let text = format!(r#"<circle class="svg" id="circle_{index}" cx="{x_value}" cy="{y_value}" r="{r_value}" fill="none" stroke="black" stroke-width="0.5" />"#);
                    svg.push(text);
                }
                EntityType::Line(ref line) => {
                    let x1_value = line.p1.x;
                    let y1_value = line.p1.y;
                    let x2_value = line.p2.x;
                    let y2_value = line.p2.y;
                    let text = format!(r#"<line class="svg" id="line_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="black" stroke-width="0.5" />"#);
                    svg.push(text);
                }
                EntityType::ModelPoint(ref model_point) => {
                    info!("模型: {:?} {:?}",model_point.location.x,model_point.location.y);
                }
                EntityType::Text(ref text) => {
                    // info!("Text: {:#?}",text);
                    let text_x = text.location.x;
                    let text_y = text.location.y;
                    let text_rotate = text.rotation;
                    let text_style_name = text.text_style_name.clone();
                    let text_height = text.text_height;
                    let value = text.value.clone();
                    // println!("{}",value);
                    let text = format!(r#"<text class="svg" x="{text_x}" y="{text_y}" transform="rotate({text_rotate})" font-family="{text_style_name}" font-size="{text_height}">{value}</text>"#);
                    svg.push(text);
                }
                EntityType::LwPolyline(ref line) => {
                    let mut points = vec![];
                    for vertex in line.vertices.iter() {
                        points.push(format!("{},{}", vertex.x, vertex.y));
                    }
                    let t = points.join(" ");
                    let text = format!(r#"<polyline class="svg" id="line_{index}" points="{}" fill="none" stroke="black" stroke-width="0.5" />"#, t);
                    svg.push(text);
                }
                // 块
                EntityType::Insert(ref data) => {
                    info!("Insert: {:#?}",data);
                    // let text_x = data.location.x;
                    // let text_y = data.location.y;
                    // let text_rotate = data.rotation.clone();
                    // let value = data.name.clone();
                    // let text = format!(r#"<text class="svg" id="Insert_{index}" x="{text_x}" y="{text_y}" transform="rotate({text_rotate})" font-size="5">{value}1</text>"#);
                    // svg.push(text);
                }
                EntityType::MText(ref data) => {
                    let text_x = data.insertion_point.x;
                    let text_y = data.insertion_point.y;
                    let value = data.text.clone();
                    let text_style_name = data.text_style_name.clone();
                    let initial_text_height = data.initial_text_height;
                    let anchor = match data.attachment_point {
                        AttachmentPoint::TopLeft => "start",
                        AttachmentPoint::TopCenter => "middle",
                        AttachmentPoint::TopRight => "end",
                        AttachmentPoint::MiddleLeft => "start",
                        AttachmentPoint::MiddleCenter => "middle",
                        AttachmentPoint::MiddleRight => "end",
                        AttachmentPoint::BottomLeft => "start",
                        AttachmentPoint::BottomCenter => "middle",
                        AttachmentPoint::BottomRight => "end"
                    };
                    let text = format!(r#"<text class="svg" id="mtext_{index}" x="{text_x}" y="{text_y}" text-anchor="{anchor}" font-family="{text_style_name}" font-size="{initial_text_height}">{value}</text>"#);
                    svg.push(text);
                }
                // 直径标尺
                EntityType::RotatedDimension(ref data) => {
                    // println!("RotatedDimension: {:#?}", data);
                    let text = format!(r#"<g class="svg" id="g_{index}">"#);
                    svg.push(text);

                    let x1_value = data.dimension_base.definition_point_1.x;
                    let y1_value = data.definition_point_2.y;
                    let x2_value = data.definition_point_2.x;
                    let y2_value = data.definition_point_2.y;
                    let text = format!(r#"<line class="svg" id="line1_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);


                    let x1_value = data.dimension_base.definition_point_1.x;
                    let y1_value = data.dimension_base.definition_point_1.y;
                    let x2_value = data.definition_point_3.x;
                    let y2_value = data.definition_point_3.y;
                    let text = format!(r#"<line class="svg" id="line2_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);


                    let x1_value = data.dimension_base.definition_point_1.x;
                    let y1_value = data.definition_point_2.y;
                    let x2_value = data.dimension_base.definition_point_1.x;
                    let y2_value = data.dimension_base.definition_point_1.y;
                    let text = format!(r#"<line class="svg" id="line3_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);


                    let x2_value = data.dimension_base.text_mid_point.x;
                    let y2_value = data.dimension_base.text_mid_point.y;
                    let text_value = data.dimension_base.text.clone();
                    let text_value = symbol(text_value.as_str());
                    let block_name = data.dimension_base.block_name.clone();

                    let anchor = match data.dimension_base.attachment_point {
                        AttachmentPoint::TopLeft => "start",
                        AttachmentPoint::TopCenter => "middle",
                        AttachmentPoint::TopRight => "end",
                        AttachmentPoint::MiddleLeft => "start",
                        AttachmentPoint::MiddleCenter => "middle",
                        AttachmentPoint::MiddleRight => "end",
                        AttachmentPoint::BottomLeft => "start",
                        AttachmentPoint::BottomCenter => "middle",
                        AttachmentPoint::BottomRight => "end"
                    };

                    let text = format!(r#"<text class="svg"  id="RotatedDimension_{index}"  x="{x2_value}" y="{y2_value}"  text-anchor="{anchor}"  font-size="3">{text_value}{block_name}</text>"#);
                    svg.push(text);

                    let text = r#"</g>"#.to_string();
                    svg.push(text);
                }
                // 直径尺寸
                EntityType::DiameterDimension(ref data) => {
                    // info!("DiameterDimension: {:#?}",data);

                    let x1_value = data.dimension_base.definition_point_1.x;
                    let y1_value = data.dimension_base.definition_point_1.y;
                    let x2_value = data.definition_point_2.x;
                    let y2_value = data.definition_point_2.y;
                    let text = format!(r#"<line class="svg" id="line1_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);


                    let x1_value = data.dimension_base.text_mid_point.x;
                    let y1_value = data.dimension_base.text_mid_point.y;
                    let x2_value = data.definition_point_2.x;
                    let y2_value = data.definition_point_2.y;
                    let text = format!(r#"<line class="svg" id="line2_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);

                    let x1_value = data.dimension_base.text_mid_point.x;
                    let y1_value = data.dimension_base.text_mid_point.y;
                    let x2_value = data.dimension_base.text_mid_point.x - 10.0;
                    let y2_value = data.dimension_base.text_mid_point.y;
                    let text = format!(r#"<line class="svg" id="line2_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);

                    let text = data.dimension_base.text.clone();
                    let text_x = data.dimension_base.text_mid_point.x;
                    let text_y = data.dimension_base.text_mid_point.y;
                    let text = symbol(text.as_str());
                    let anchor = match data.dimension_base.attachment_point {
                        AttachmentPoint::TopLeft => "start",
                        AttachmentPoint::TopCenter => "middle",
                        AttachmentPoint::TopRight => "end",
                        AttachmentPoint::MiddleLeft => "start",
                        AttachmentPoint::MiddleCenter => "middle",
                        AttachmentPoint::MiddleRight => "end",
                        AttachmentPoint::BottomLeft => "start",
                        AttachmentPoint::BottomCenter => "middle",
                        AttachmentPoint::BottomRight => "end"
                    };

                    let text = format!(r#"<text class="svg" id="diameter_dimension_{index}" x="{text_x}" y="{text_y}" text-anchor="{anchor}" font-size="3">{text}</text>"#);
                    svg.push(text);
                }
                EntityType::Arc(ref data) => {
                    let x_value = data.center.x + data.radius * data.start_angle.to_radians().cos();
                    let y_value = data.center.y + data.radius * data.start_angle.to_radians().sin();
                    let radius_value = data.radius;
                    let end_x = data.center.x + data.radius * (data.start_angle + data.end_angle).to_radians().cos();
                    let end_y = data.center.y + data.radius * (data.start_angle + data.end_angle).to_radians().sin();

                    let text = format!(r#"<path class="svg" id="diameter_dimension_{index}" d="M {x_value},{y_value} A {radius_value},{radius_value} 0 1,0 {end_x},{end_y}" fill="none" stroke="black" stroke-width="0.3" />"#);
                    svg.push(text);
                }
                EntityType::Spline(ref data) => {
                    // info!("Spline {:#?}",data);
                    let x1 = data.control_points[0].x;
                    let y1 = data.control_points[0].y;
                    let x2 = data.control_points[1].x;
                    let y2 = data.control_points[1].y;
                    let x3 = data.control_points[2].x;
                    let y3 = data.control_points[2].y;
                    let x4 = data.control_points[3].x;
                    let y4 = data.control_points[3].y;
                    let text = format!(r#"<path class="svg" id="diameter_dimension_{index}" d="M{x1} {y1} C{x2} {y2},{x3} {y3},{x4} {y4}" fill="none" stroke="black" stroke-width="0.3" />"#);
                    svg.push(text);
                }
                EntityType::Solid(ref data) => {
                    // info!("Solid {:#?}",data);
                    let x1 = data.first_corner.x;
                    let y1 = data.first_corner.y;
                    let x2 = data.second_corner.x;
                    let y2 = data.second_corner.y;
                    let x3 = data.third_corner.x;
                    let y3 = data.third_corner.y;
                    let x4 = data.fourth_corner.x;
                    let y4 = data.fourth_corner.y;
                    let text = format!(r#"<path class="svg" id="Solid_{index}" d="M{x1} {y1} L{x2} {y2} L{x3} {y3} L{x4} {y4} Z" fill="none" stroke="black" stroke-width="0.3" />"#);
                    svg.push(text);
                }
                EntityType::RadialDimension(ref data) => {
                    // info!("RadialDimension: {:#?}",data);
                    let x1_value = data.dimension_base.definition_point_1.x;
                    let y1_value = data.dimension_base.definition_point_1.y;
                    let x2_value = data.definition_point_2.x;
                    let y2_value = data.definition_point_2.y;
                    let text = format!(r#"<line class="svg" id="line1_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);


                    let x1_value = data.dimension_base.text_mid_point.x;
                    let y1_value = data.dimension_base.text_mid_point.y;
                    let x2_value = data.definition_point_2.x;
                    let y2_value = data.definition_point_2.y;
                    let text = format!(r#"<line class="svg" id="line2_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);

                    let x1_value = data.dimension_base.text_mid_point.x;
                    let y1_value = data.dimension_base.text_mid_point.y;
                    let x2_value = data.dimension_base.text_mid_point.x - 10.0;
                    let y2_value = data.dimension_base.text_mid_point.y;
                    let text = format!(r#"<line class="svg" id="line2_{index}" x1="{x1_value}" y1="{y1_value}" x2="{x2_value}" y2="{y2_value}" stroke="red" stroke-width="0.3" />"#);
                    svg.push(text);

                    let text = data.dimension_base.text.clone();
                    let text_x = data.dimension_base.text_mid_point.x;
                    let text_y = data.dimension_base.text_mid_point.y;
                    let text = symbol(text.as_str());
                    let anchor = match data.dimension_base.attachment_point {
                        AttachmentPoint::TopLeft => "start",
                        AttachmentPoint::TopCenter => "middle",
                        AttachmentPoint::TopRight => "end",
                        AttachmentPoint::MiddleLeft => "start",
                        AttachmentPoint::MiddleCenter => "middle",
                        AttachmentPoint::MiddleRight => "end",
                        AttachmentPoint::BottomLeft => "start",
                        AttachmentPoint::BottomCenter => "middle",
                        AttachmentPoint::BottomRight => "end"
                    };

                    let text = format!(r#"<text class="svg" id="diameter_dimension_{index}" x="{text_x}" y="{text_y}" text-anchor="{anchor}" font-size="3">{text}</text>"#);
                    svg.push(text);
                }
                _ => {
                    info!("未知 {:?}",e.specific);
                }
            }
        }
        svg.push("</svg>".to_string());
        svg.join("")
    }
}

fn symbol(value: &str) -> String {
    match value {
        // 直径
        s if s.contains("<>") => s.replace("<>", "&#x2300;"),
        _ => value.parse().unwrap()
    }.to_string()
}