FlatCAM/appParsers/ParseDXF.py

# ##########################################################
# FlatCAM: 2D Post-processing for Manufacturing            #
# File Author: Marius Adrian Stanciu (c)                   #
# Date: 3/10/2019                                          #
# MIT Licence                                              #
# ##########################################################

from shapely.geometry import LineString, Point
from shapely.affinity import rotate
# Vector was an older name for Vec3; try both for backward compatibility:
try:
    from ezdxf.math import Vec3 as ezdxf_vector
except ImportError:
    from ezdxf.math import Vector as ezdxf_vector

from appParsers.ParseFont import *
from appParsers.ParseDXF_Spline import *
import logging

log = logging.getLogger('base2')


def distance(pt1, pt2):
    return math.sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2)


def dxfpoint2shapely(point):

    geo = Point(point.dxf.location).buffer(0.01)
    return geo


def dxfline2shapely(line):

    try:
        start = (line.dxf.start[0], line.dxf.start[1])
        stop = (line.dxf.end[0], line.dxf.end[1])

    except Exception as e:
        log.debug(str(e))
        return None

    geo = LineString([start, stop])

    return geo


def dxfcircle2shapely(circle, n_points=100):

    ocs = circle.ocs()
    # if the extrusion attribute is not (0, 0, 1) then we have to change the coordinate system from OCS to WCS
    if circle.dxf.extrusion != (0, 0, 1):
        center_pt = ocs.to_wcs(circle.dxf.center)
    else:
        center_pt = circle.dxf.center

    radius = circle.dxf.radius
    geo = Point(center_pt).buffer(radius, int(n_points / 4))

    return geo


def dxfarc2shapely(arc, n_points=100):
    # ocs = arc.ocs()
    # # if the extrusion attribute is not (0, 0, 1) then we have to change the coordinate system from OCS to WCS
    # if arc.dxf.extrusion != (0, 0, 1):
    #     arc_center = ocs.to_wcs(arc.dxf.center)
    #     start_angle = math.radians(arc.dxf.start_angle) + math.pi
    #     end_angle = math.radians(arc.dxf.end_angle) + math.pi
    #     dir = 'CW'
    # else:
    #     arc_center = arc.dxf.center
    #     start_angle = math.radians(arc.dxf.start_angle)
    #     end_angle = math.radians(arc.dxf.end_angle)
    #     dir = 'CCW'
    #
    # center_x = arc_center[0]
    # center_y = arc_center[1]
    # radius = arc.dxf.radius
    #
    # point_list = []
    #
    # if start_angle > end_angle:
    #     start_angle +=  2 * math.pi
    #
    # line_seg = int((n_points * (end_angle - start_angle)) / math.pi)
    # step_angle = (end_angle - start_angle) / float(line_seg)
    #
    # angle = start_angle
    # for step in range(line_seg + 1):
    #     if dir == 'CCW':
    #         x = center_x + radius * math.cos(angle)
    #         y = center_y + radius * math.sin(angle)
    #     else:
    #         x = center_x + radius * math.cos(-angle)
    #         y = center_y + radius * math.sin(-angle)
    #     point_list.append((x, y))
    #     angle += step_angle
    #
    #
    # log.debug("X = %.4f, Y = %.4f, Radius = %.4f, start_angle = %.1f, stop_angle = %.1f, step_angle = %.4f, dir=%s" %
    #           (center_x, center_y, radius, start_angle, end_angle, step_angle, dir))
    #
    # geo = LineString(point_list)
    # return geo

    ocs = arc.ocs()
    # if the extrusion attribute is not (0, 0, 1) then we have to change the coordinate system from OCS to WCS
    if arc.dxf.extrusion != (0, 0, 1):
        arc_center = ocs.to_wcs(arc.dxf.center)
        start_angle = arc.dxf.start_angle + 180
        end_angle = arc.dxf.end_angle + 180
        direction = 'CW'
    else:
        arc_center = arc.dxf.center
        start_angle = arc.dxf.start_angle
        end_angle = arc.dxf.end_angle
        direction = 'CCW'

    center_x = arc_center[0]
    center_y = arc_center[1]
    radius = arc.dxf.radius

    point_list = []

    if start_angle > end_angle:
        start_angle = start_angle - 360
    angle = start_angle

    step_angle = float(abs(end_angle - start_angle) / n_points)

    while angle <= end_angle:
        if direction == 'CCW':
            x = center_x + radius * math.cos(math.radians(angle))
            y = center_y + radius * math.sin(math.radians(angle))
        else:
            x = center_x + radius * math.cos(math.radians(-angle))
            y = center_y + radius * math.sin(math.radians(-angle))
        point_list.append((x, y))
        angle += abs(step_angle)

    # in case the number of segments do not cover everything until the end of the arc
    if angle != end_angle:
        if direction == 'CCW':
            x = center_x + radius * math.cos(math.radians(end_angle))
            y = center_y + radius * math.sin(math.radians(end_angle))
        else:
            x = center_x + radius * math.cos(math.radians(- end_angle))
            y = center_y + radius * math.sin(math.radians(- end_angle))
        point_list.append((x, y))

    # log.debug("X = %.4f, Y = %.4f, Radius = %.4f, start_angle = %.1f, stop_angle = %.1f, step_angle = %.4f" %
    #           (center_x, center_y, radius, start_angle, end_angle, step_angle))

    geo = LineString(point_list)
    return geo


def dxfellipse2shapely(ellipse, ellipse_segments=100):
    # center = ellipse.dxf.center
    # start_angle = ellipse.dxf.start_param
    # end_angle = ellipse.dxf.end_param

    ocs = ellipse.ocs()
    # if the extrusion attribute is not (0, 0, 1) then we have to change the coordinate system from OCS to WCS
    if ellipse.dxf.extrusion != (0, 0, 1):
        center = ocs.to_wcs(ellipse.dxf.center)
        start_angle = ocs.to_wcs(ellipse.dxf.start_param)
        end_angle = ocs.to_wcs(ellipse.dxf.end_param)
        direction = 'CW'
    else:
        center = ellipse.dxf.center
        start_angle = ellipse.dxf.start_param
        end_angle = ellipse.dxf.end_param
        direction = 'CCW'

    # print("Dir = %s" % dir)
    major_axis = ellipse.dxf.major_axis
    ratio = ellipse.dxf.ratio

    points_list = []
    major_axis = Vector(list(major_axis))

    major_x = major_axis[0]
    major_y = major_axis[1]

    if start_angle >= end_angle:
        end_angle += 2.0 * math.pi

    line_seg = int((ellipse_segments * (end_angle - start_angle)) / math.pi)
    step_angle = abs(end_angle - start_angle) / float(line_seg)

    angle = start_angle
    for step in range(line_seg + 1):
        if direction == 'CW':
            major_dim = normalize_2(major_axis)
            minor_dim = normalize_2(Vector([ratio * k for k in major_axis]))
            vx = (major_dim[0] + major_dim[1]) * math.cos(angle)
            vy = (minor_dim[0] - minor_dim[1]) * math.sin(angle)
            x = center[0] + major_x * vx - major_y * vy
            y = center[1] + major_y * vx + major_x * vy
            angle += step_angle
        else:
            major_dim = normalize_2(major_axis)
            minor_dim = (Vector([ratio * k for k in major_dim]))
            vx = (major_dim[0] + major_dim[1]) * math.cos(angle)
            vy = (minor_dim[0] + minor_dim[1]) * math.sin(angle)
            x = center[0] + major_x * vx + major_y * vy
            y = center[1] + major_y * vx + major_x * vy
            angle += step_angle

        points_list.append((x, y))

    geo = LineString(points_list)
    return geo


def dxfpolyline2shapely(polyline):
    final_pts = []
    pts = polyline.points()
    for i in pts:
        final_pts.append((i[0], i[1]))
    if polyline.is_closed:
        final_pts.append(final_pts[0])

    geo = LineString(final_pts)
    return geo


def dxflwpolyline2shapely(lwpolyline):
    final_pts = []

    for point in lwpolyline:
        x, y, _, _, _ = point
        final_pts.append((x, y))
    if lwpolyline.closed:
        final_pts.append(final_pts[0])

    geo = LineString(final_pts)
    return geo


def dxfsolid2shapely(solid):
    iterator = 0
    corner_list = []
    try:
        corner_list.append(solid[iterator])
        iterator += 1
    except Exception:
        return Polygon(corner_list)


def dxfspline2shapely(spline):
    # for old version of ezdxf
    # with spline.edit_data() as spline_data:
    #     ctrl_points = spline_data.control_points
    #     try:
    #         # required if using old version of ezdxf
    #         knot_values = spline_data.knot_values
    #     except AttributeError:
    #         knot_values = spline_data.knots

    ctrl_points = spline.control_points
    knot_values = spline.knots
    is_closed = spline.closed
    degree = spline.dxf.degree

    x_list, y_list, _ = spline2Polyline(ctrl_points, degree=degree, closed=is_closed, segments=20, knots=knot_values)
    points_list = zip(x_list, y_list)

    geo = LineString(points_list)
    return geo


def dxftrace2shapely(trace):
    iterator = 0
    corner_list = []
    try:
        corner_list.append(trace[iterator])
        iterator += 1
    except Exception:
        return Polygon(corner_list)


def getdxfgeo(dxf_object):

    msp = dxf_object.modelspace()
    geos = get_geo(dxf_object, msp)

    # geo_block = get_geo_from_block(dxf_object)

    return geos


def get_geo_from_insert(dxf_object, insert):
    geo_block_transformed = []

    phi = insert.dxf.rotation
    tr = insert.dxf.insert
    sx = insert.dxf.xscale
    sy = insert.dxf.yscale
    r_count = insert.dxf.row_count
    r_spacing = insert.dxf.row_spacing
    c_count = insert.dxf.column_count
    c_spacing = insert.dxf.column_spacing

    # print(phi, tr)

    # identify the block given the 'INSERT' type entity name
    block = dxf_object.blocks[insert.dxf.name]
    block_coords = (block.block.dxf.base_point[0], block.block.dxf.base_point[1])

    # get a list of geometries found in the block
    geo_block = get_geo(dxf_object, block)

    # iterate over the geometries found and apply any transformation found in the 'INSERT' entity attributes
    for geo in geo_block:

        # get the bounds of the geometry
        # minx, miny, maxx, maxy = geo.bounds

        if tr[0] != 0 or tr[1] != 0:
            geo = translate(geo, (tr[0] - block_coords[0]), (tr[1] - block_coords[1]))

        # support for array block insertions
        if r_count > 1:
            for r in range(r_count):
                geo_block_transformed.append(translate(geo, (tr[0] + (r * r_spacing) - block_coords[0]), 0))
        if c_count > 1:
            for c in range(c_count):
                geo_block_transformed.append(translate(geo, 0, (tr[1] + (c * c_spacing) - block_coords[1])))

        if sx != 1 or sy != 1:
            geo = scale(geo, sx, sy)
        if phi != 0:
            if isinstance(tr, str) and tr.lower() == 'c':
                tr = 'center'
            elif isinstance(tr, ezdxf_vector):
                tr = list(tr)
            geo = rotate(geo, phi, origin=tr)

        geo_block_transformed.append(geo)
    return geo_block_transformed


def get_geo(dxf_object, container):
    # store shapely geometry here
    geo = []

    for dxf_entity in container:
        g = []
        # print("Entity", dxf_entity.dxftype())
        if dxf_entity.dxftype() == 'POINT':
            g = dxfpoint2shapely(dxf_entity,)
        elif dxf_entity.dxftype() == 'LINE':
            g = dxfline2shapely(dxf_entity,)
        elif dxf_entity.dxftype() == 'CIRCLE':
            g = dxfcircle2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'ARC':
            g = dxfarc2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'ELLIPSE':
            g = dxfellipse2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'LWPOLYLINE':
            g = dxflwpolyline2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'POLYLINE':
            g = dxfpolyline2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'SOLID':
            g = dxfsolid2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'TRACE':
            g = dxftrace2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'SPLINE':
            g = dxfspline2shapely(dxf_entity)
        elif dxf_entity.dxftype() == 'INSERT':
            g = get_geo_from_insert(dxf_object, dxf_entity)
        else:
            log.debug(" %s is not supported yet." % dxf_entity.dxftype())

        if g is not None:
            if type(g) == list:
                for subg in g:
                    geo.append(subg)
            else:
                geo.append(g)

    return geo


def getdxftext(exf_object, object_type, units=None):
    pass

# def get_geo_from_block(dxf_object):
#     geo_block_transformed = []
#
#     msp = dxf_object.modelspace()
#     # iterate through all 'INSERT' entities found in modelspace msp
#     for insert in msp.query('INSERT'):
#         phi = insert.dxf.rotation
#         tr = insert.dxf.insert
#         sx = insert.dxf.xscale
#         sy = insert.dxf.yscale
#         r_count = insert.dxf.row_count
#         r_spacing = insert.dxf.row_spacing
#         c_count = insert.dxf.column_count
#         c_spacing = insert.dxf.column_spacing
#
#         # print(phi, tr)
#
#         # identify the block given the 'INSERT' type entity name
#         print(insert.dxf.name)
#         block = dxf_object.blocks[insert.dxf.name]
#         block_coords = (block.block.dxf.base_point[0], block.block.dxf.base_point[1])
#
#         # get a list of geometries found in the block
#         # store shapely geometry here
#         geo_block = []
#
#         for dxf_entity in block:
#             g = []
#             # print("Entity", dxf_entity.dxftype())
#             if dxf_entity.dxftype() == 'POINT':
#                 g = dxfpoint2shapely(dxf_entity, )
#             elif dxf_entity.dxftype() == 'LINE':
#                 g = dxfline2shapely(dxf_entity, )
#             elif dxf_entity.dxftype() == 'CIRCLE':
#                 g = dxfcircle2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'ARC':
#                 g = dxfarc2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'ELLIPSE':
#                 g = dxfellipse2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'LWPOLYLINE':
#                 g = dxflwpolyline2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'POLYLINE':
#                 g = dxfpolyline2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'SOLID':
#                 g = dxfsolid2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'TRACE':
#                 g = dxftrace2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'SPLINE':
#                 g = dxfspline2shapely(dxf_entity)
#             elif dxf_entity.dxftype() == 'INSERT':
#                 log.debug("Not supported yet.")
#             else:
#                 log.debug("Not supported yet.")
#
#             if g is not None:
#                 if type(g) == list:
#                     for subg in g:
#                         geo_block.append(subg)
#                 else:
#                     geo_block.append(g)
#
#         # iterate over the geometries found and apply any transformation found in the 'INSERT' entity attributes
#         for geo in geo_block:
#             if tr[0] != 0 or tr[1] != 0:
#                 geo = translate(geo, (tr[0] - block_coords[0]), (tr[1] - block_coords[1]))
#
#             # support for array block insertions
#             if r_count > 1:
#                 for r in range(r_count):
#                     geo_block_transformed.append(translate(geo, (tr[0] + (r * r_spacing) - block_coords[0]), 0))
#
#             if c_count > 1:
#                 for c in range(c_count):
#                     geo_block_transformed.append(translate(geo, 0, (tr[1] + (c * c_spacing) - block_coords[1])))
#
#             if sx != 1 or sy != 1:
#                 geo = scale(geo, sx, sy)
#             if phi != 0:
#                 geo = rotate(geo, phi, origin=tr)
#
#             geo_block_transformed.append(geo)
#     return geo_block_transformed