The generated dxf cannot be opened in AutoCAD

[ytl1446109935]

      import math
      import ezdxf
      from ezdxf.enums import TextEntityAlignment
      import geopandas
      
      from tempfile import NamedTemporaryFile
      
      import flask
      import flask_cors
      from flask import send_file
      
      api = flask.Flask(__name__)
      flask_cors.CORS(api, supports_credentials=True)
      
      
      def parse_geojson(_str, file):
          global msp
          global doc
          with NamedTemporaryFile(suffix='.geojson', delete=False) as tmpf:
              with open(tmpf.name, 'w', encoding='utf-8') as f:
                  f.write(_str)
          # 使用GeoPandas读取临时文件中的geoJSON内容
          data = geopandas.read_file(tmpf.name)
      
          points = data[(data.geometry.type == 'Point') | (data.geometry.type == 'MultiPoint')]
          lines = data[(data.geometry.type == 'LineString') | (data.geometry.type == 'MultiLineString')]
          polygons = data[(data.geometry.type == 'Polygon') | (data.geometry.type == 'MultiPolygon')]
      
          doc, msp = newDxf()
          # buffer_dist = 5
      
          doc.layers.new(name='text', dxfattribs={'color': 7})
      
          if len(points.values) > 0:
              for index, row in points.iterrows():
                  x = row['geometry'].x
                  y = row['geometry'].y
                  point_type = row['type']
                  if point_type == 'DZD':
                      try:
                          # 产状类型
                          oc_type = row['occurrenceType']
                          # 绘制点
                          create_layer('DZD' + oc_type, (255, 255, 255))
                          msp.add_circle((x, y), buffer_dist, dxfattribs={'layer': 'DZD' + oc_type})
                          # 添加名称
                          name_content = row['name']
                          name_size = text_size
                          nx = x - len(name_content) * name_size - buffer_dist - 0.1 * buffer_dist
                          ny = y - 0.5 * name_size
                          setText(name_content, name_size, 'DZD' + oc_type, nx, ny)
                          # 生成走向倾向线
                          trend = row['trend']
                          incline = row['incline']
                          tix = x + 0.2 * buffer_dist
                          tiy = y + buffer_dist * 1.5 + 0.2 * buffer_dist
                          set_trend_incline(trend, incline, 'DZD' + oc_type, tix, tiy)
                          # 倾角
                          if len(row['pitch']) > 0:
                              pitch_size = text_size
                              pitch_content = row['pitch'] + '°'
                              pix = x + 0.5 * buffer_dist + 0.4 * buffer_dist
                              piy = y + 1.5 * buffer_dist - 0.5 * pitch_size + 0.2 * buffer_dist
                              setText(pitch_content, pitch_size, 'DZD' + oc_type, pix, piy)
                      except:
                          print('地质点数据错误')
                  if point_type == 'ZK':
                      try:
                          # 绘制点
                          create_layer('ZK', (255, 255, 255))
                          msp.add_circle((x, y), buffer_dist, dxfattribs={'layer': 'ZK'})
                          hatch = msp.add_hatch(color=7, dxfattribs={'layer': 'ZK'})  # 可以设置颜色，这里使用默认颜色7
                          path = hatch.paths.add_edge_path()
                          path.add_arc(center=(x, y), radius=buffer_dist / 2, start_angle=0, end_angle=360)
                          # 添加名称
                          name_content = row['name']
                          name_size = text_size
                          nx = x - len(name_content) / 2 * name_size
                          ny = y - name_size - buffer_dist - 0.2 * buffer_dist
                          setText(name_content, name_size, 'ZK', nx, ny)
                          # 添加高程
                          height_content = row['height']
                          height_size = text_size
                          hix = x + len(name_content) / 2 * name_size + 0.2 * buffer_dist
                          hiy = y - buffer_dist - 0.5 * name_size + 0.2 * buffer_dist
                          setText(height_content, height_size, 'ZK', hix, hiy)
                          # 添加孔深
                          holeDepth_content = row['holeDepth']
                          holeDepth_size = text_size
                          hdx = x + len(name_content) / 2 * name_size + 0.2 * buffer_dist
                          hdy = y - buffer_dist - 1.5 * name_size - 0.4 * buffer_dist
                          setText(holeDepth_content, holeDepth_size, 'ZK', hdx, hdy)
                          # 添加横线
                          hx = x + len(name_content) / 2 * name_size + 0.2 * buffer_dist
                          hy = y - buffer_dist - 0.5 * name_size - 0.2 * buffer_dist
                          hx1, hy1, hx2, hy2 = calc_line(0, [hx, hy], max(len(height_content) * height_size, len(holeDepth_content) * holeDepth_size))
                          msp.add_lwpolyline([(hx1, hy1), (hx2, hy2)], dxfattribs={'layer': 'points'})
                      except:
                          print('钻孔数据错误')
          if len(lines.values) > 0:
              create_layer('lines', (255, 255, 255))
              for index, row in lines.iterrows():
                  try:
                      vertices = []
                      for point in row['geometry'].coords:
                          vertices.append(point)
                      msp.add_lwpolyline(vertices, dxfattribs={'layer': 'lines'})
                      name_content = row['name']
                      name_size = text_size
                      x = row['geometry'].centroid.x - name_size * len(name_content) / 2
                      y = row['geometry'].centroid.y
                      if name_content:
                          setText(name_content, name_size, 'lines', x, y)
                  except:
                      print('线数据格式错误')
          if len(polygons.values) > 0:
              create_layer('polygons', (255, 255, 255))
              for index, row in polygons.iterrows():
                  try:
                      exterior = row['geometry'].exterior
                      e_vertices = []
                      for e_point in exterior.coords:
                          e_vertices.append(e_point)
                      # 创建 HATCH 实体
                      hatch = msp.add_hatch(color=7, dxfattribs={'layer': 'polygons'})  # color=1 表示红色
                      # 创建 HATCH 边界路径
                      hatch.paths.add_polyline_path(e_vertices, is_closed=True)
      
                      interior = row['geometry'].interiors
                      if interior:
                          i_vertices = []
                          for i_point in interior.coords:
                              i_vertices.append(i_point)
                          hatch.paths.add_polyline_path(i_vertices, is_closed=True, flags=1)
                      name_content = row['name']
                      name_size = text_size
                      x = row['geometry'].centroid.x - name_size * len(name_content) / 2
                      y = row['geometry'].centroid.y
                      if name_content:
                          setText(name_content, name_size, 'polygons', x, y)
                  except:
                      print('面数据格式错误')
      
          doc.saveas(file + 'result.dxf')
      
      
      def setText(content, size, layer_name, x, y):
          create_layer(layer_name, (255, 255, 255))
          text = msp.add_text(
              content,
              dxfattribs={
                  'style': 'CustomFontStyle',
                  'height': size,  # 设置文本高度
                  'layer': layer_name,
              }
          )
          text.set_placement((x, y), align=TextEntityAlignment.CENTER)
      
      
      def set_trend_incline(trend, inclination, layer_name, x, y):
          try:
              # 生成走向线
              tr_theta = (float(trend) - 90) * math.pi / 180
              x1, y1, x2, y2 = calc_line2(tr_theta, [x, y], buffer_dist)
              create_layer(layer_name, (255, 255, 255))
              msp.add_lwpolyline([(x1, y1), (x2, y2)], dxfattribs={'layer': layer_name})
              if inclination:
                  # 生成倾向线
                  if float(trend) == 0:
                      if inclination == 'E':
                          theta = float(trend) + 90
                      else:
                          theta = float(trend) + 270
                  elif float(trend) == 90:
                      if inclination == 'S':
                          theta = float(trend) + 90
                      else:
                          theta = 0
                  elif float(trend) == 180:
                      if inclination == 'E':
                          theta = float(trend) - 90
                      else:
                          theta = float(trend) + 90
                  elif float(trend) == 270:
                      if inclination == 'S':
                          theta = float(trend) - 90
                      else:
                          theta = 0
                  elif 0 < float(trend) < 90 or 180 < float(trend) < 270:
                      if inclination == 'SE':
                          theta = float(trend) + 90
                      else:
                          theta = float(trend) + 270
                  elif 90 < float(trend) < 180 or 270 < float(trend) < 360:
                      if inclination == 'SW':
                          theta = float(trend) + 90
                      else:
                          theta = float(trend) + 270
                  if theta > 360:
                      theta -= 360
                  in_theta = (theta - 90) * math.pi / 180
                  xx1, yy1, xx2, yy2 = calc_line(in_theta, [(x1 + x2) / 2, (y1 + y2) / 2], buffer_dist / 2)
                  msp.add_lwpolyline([(xx1, yy1), (xx2, yy2)], dxfattribs={'layer': layer_name})
          except:
              print('无走向或倾向数据')
      
      
      def calc_line(theta, start_point, length):
          '''
              根据斜率和起点提取线段
              输入：斜率，中心点
              输出：线段坐标
          '''
          # 已知线段的起点
          x1 = start_point[0]
          y1 = start_point[1]
          # 计算线段终点
          x2 = start_point[0] + math.cos(theta) * length
          y2 = start_point[1] - math.sin(theta) * length
      
          return x1, y1, x2, y2
      
      
      def calc_line2(theta, start_point, length):
          '''
              根据斜率和起点提取线段
              输入：斜率，中心点
              输出：线段坐标
          '''
          # 已知线段的中点
          x = start_point[0]
          y = start_point[1]
          # 计算线段起点
          x1 = x - math.cos(theta) * length / 2
          y1 = y + math.sin(theta) * length / 2
          # 计算线段终点
          x2 = x + math.cos(theta) * length / 2
          y2 = y - math.sin(theta) * length / 2
      
          return x1, y1, x2, y2
      
      
      def newDxf():
          doc = ezdxf.new(dxfversion='R2007')
          # 获取模型空间
          msp = doc.modelspace()
          return doc, msp
      
      
      def create_layer(layer_name, color):
          try:
              doc.layers.get(layer_name)  # 获取图层，如果不存在则创建
          except:
              layer = doc.layers.new(name=layer_name)  # 白色
              layer.rgb = color
      
      
      @api.route('/main', methods=['post'])
      def main():
          files = 'D:\\ProjectData\\cad\\'
          global buffer_dist
          global text_size
          # request_body = flask.request.get_json()
          # json_str = request_body['geojson']
          # property = request_body['property']
          json_str = flask.request.form.get('geojson')
          try:
              p_size = flask.request.form.get('pointSize')
              buffer_dist = float(p_size)
          except:
              buffer_dist = 4
          try:
              t_size = flask.request.form.get('textSize')
              text_size = float(t_size)
          except:
              text_size = 4
          parse_geojson(json_str, files)
      
          return send_file(files + 'result.dxf', as_attachment=True)
      
      
      if __name__ == '__main__':
          _str = '''
          {
              "type": "FeatureCollection",
              "features": [
                  {
                      "geometry": {"coordinates": [642130.06, 3045232.28], "type": "Point"},
                      "type": "Feature",
                      "properties": {"name": "DZD4", "type": "DZD", "occurrenceType": "DCYX", "trend": "85.0", "incline": "NW", "pitch": "80"}
                  },
                  {
                      "geometry": {"coordinates": [642040.06, 3045232.28], "type": "Point"},
                      "type": "Feature",
                      "properties": {"name": "ZKD4", "type": "ZK", "height": "385.0", "holeDepth": "15"}
                  },
                  {
                      "type": "Feature",
                      "properties": {
                          "line-color": "#038AFE",
                          "id": "220d3c7a-7c93-461e-bb5e-fb3afddcff49",
                          "line-width": 2,
                          "name": "hycd",
                          "type": "BOUNDARY"
                      },
                      "geometry": {
                          "type": "LineString",
                          "coordinates": [
                              [642170.06, 3045232.28],
                              [642190.06, 3045232.28]
                          ]
                      }
                  },
                  {
                      "type": "Feature",
                      "properties": {
                          "fill-opacity": 0.2,
                          "fill-color": "#038AFE",
                          "id": "8fcae9f6-b43a-4015-a1ca-7421f8d6f465",
                          "name": "123",
                          "type": "BAD_GEOLOGIC_BODY"
                      },
                      "geometry": {
                          "type": "Polygon",
                          "coordinates": [
                              [
                                  [642170.06, 3045242.28],
                                  [642190.06, 3045242.28],
                                  [642190.06, 3045252.28],
                                  [642170.06, 3045242.28]
                              ]
                          ]
                      }
                  }
              ]
          }
          '''
          global buffer_dist
          global text_size
          buffer_dist = 4
          text_size = 4
          paths = 'D:\\ProjectData\\cad\\'
          parse_geojson(_str, paths)
      
          # api.run(port=8081, debug=True, host='10.219.101.112', threaded=True)

I can not open the dxf by AutoCAD2022

[gswifort]

Upload the generated dxf file.

[mozman]

This is not useful.

Write a minimal script with as less dependencies as possible and add the required input data. It should be executable as python3 script.py without flask and geopandas.

[mozman]

It is the undefined text style "CustomFontStyle".

You can audit you DXF file before exporting:

import ezdxf

def main():
    doc = ezdxf.new()
    msp = doc.modelspace()
    msp.add_text("abc", dxfattribs= {"style": "mystyle"})
    auditor = doc.audit()
    auditor.print_fixed_errors()
    if not auditor.has_errors:
        doc.saveas("test.dxf")
    else:
        auditor.print_error_report()


if __name__ == "__main__":
    main()

Output:

C:\> py nostyle.py
1 issues fixed.

   1. Issue [102] fixed in TEXT(#2F).
   Removed undefined text style "mystyle" from TEXT(#2F).

[ytl1446109935]

It is worked.Thank you for your reply!