Exemplo n.º 1
0
 def test_template(self):
     template_file = TemplateFinder().filepath('AC1009')
     self.assertTrue(is_dxf_file(template_file))
Exemplo n.º 2
0
 def test_template(self):
     template_file = TemplateFinder().filepath('AC1009')
     self.assertTrue(is_dxf_file(template_file))
Exemplo n.º 3
0
    def merge(self, merge_dxf, move=(0.0, 0.0)):
        merge_dxf = '{}{}/{}'.format(self.__base_folder, self.__source_folder,
                                     merge_dxf)
        if not os.path.isfile(merge_dxf):
            raise IOError(
                2, 'No such file or directory: \'{}\''.format(merge_dxf))
        if not ezdxf.is_dxf_file(merge_dxf):
            raise IOError(
                2, 'No such file or directory: \'{}\''.format(merge_dxf))
        src = ezdxf.readfile(merge_dxf)

        print('\tAdding {}[{}] @ {}'.format(merge_dxf, src.dxfversion, move))
        dxf = ezdxf.new(src.dxfversion)
        lay = dxf.layers.get('0')
        lay.set_color(2)
        if os.path.isfile(self.__dxf_file):
            if ezdxf.is_dxf_file(self.__dxf_file):
                dxf = ezdxf.readfile(self.__dxf_file)
        target_msp = dxf.modelspace()
        source_msp = src.modelspace()

        # for lay in src.layers:
        for e in source_msp:
            if e.dxf.layer in self.__ignore_layers:
                continue
            t = '{}'.format(e.dxftype)
            e_lay = self.__rename_layers.get(e.dxf.layer, e.dxf.layer)
            if t[14:17] == 'Arc':
                self.add_layer(e_lay, dxf, src)
                c = tuple(map(operator.add, e.dxf.center, move))
                target_msp.add_arc(c,
                                   e.dxf.radius,
                                   e.dxf.start_angle,
                                   e.dxf.end_angle,
                                   dxfattribs={'layer': e_lay})
            elif t[14:20] == 'Circle':
                self.add_layer(e_lay, dxf, src)
                c = tuple(map(operator.add, e.dxf.center, move))
                target_msp.add_circle(c,
                                      e.dxf.radius,
                                      dxfattribs={'layer': e_lay})
            elif t[14:19] == 'Point':
                self.add_layer(e_lay, dxf, src)
                loc = tuple(map(operator.add, e.dxf.location, move))
                target_msp.add_point(loc, dxfattribs={'layer': e_lay})
            elif t[14:18] == 'Text':
                self.add_layer(e_lay, dxf, src)
                c = (e.dxf.insert[0] + move[0], e.dxf.insert[1] + move[1],
                     e.dxf.insert[2])
                target_msp.add_text(e.dxf.text,
                                    dxfattribs={
                                        'insert': c,
                                        'height': e.dxf.height,
                                        'rotation': e.dxf.rotation,
                                        'style': e.dxf.style,
                                        'width': e.dxf.width,
                                        'halign': e.dxf.halign,
                                        'valign': e.dxf.valign,
                                        'layer': e_lay
                                    })
            elif t[14:19] == 'MText':
                # print('MTEXT: {}'.format(e.get_text()))
                self.add_layer(e_lay, dxf, src)
                c = (e.dxf.insert[0] + move[0], e.dxf.insert[1] + move[1],
                     e.dxf.insert[2])
                target_msp.add_mtext(e.get_text(),
                                     dxfattribs={
                                         'insert': c,
                                         'char_height': e.dxf.char_height,
                                         'width': e.dxf.width,
                                         'attachment_point':
                                         e.dxf.attachment_point,
                                         'flow_direction':
                                         e.dxf.flow_direction,
                                         'style': e.dxf.style,
                                         'rotation': e.dxf.rotation,
                                         'line_spacing_style':
                                         e.dxf.line_spacing_style,
                                         'line_spacing_factor':
                                         e.dxf.line_spacing_factor,
                                         'layer': e_lay
                                     })
            elif t[14:18] == 'Line':
                self.add_layer(e_lay, dxf, src)
                start = tuple(map(operator.add, e.dxf.start, move))
                end = tuple(map(operator.add, e.dxf.end, move))
                target_msp.add_line(start, end, dxfattribs={'layer': e_lay})
            # elif t[14:22] == 'Polyline':
            #     addLayer(e_lay, dxf, src)
            #     points = e.points()
            #     new_points = []
            #     for p in points:
            #         new_points.append((p[0] + move[0], p[1] + move[1]))
            #     poly = target_msp.add_polyline(new_points, dxfattribs={
            #         'layer': e_lay,
            #         'flags': e.dxf.flags
            #     })
            #     poly.closed = e.closed
            elif t[14:20] == 'LWPoly':
                self.add_layer(e_lay, dxf, src)
                points = e.get_points()
                new_points = []
                for p in points:
                    new_points.append(
                        (p[0] + move[0], p[1] + move[1], p[2], p[3], p[4]))
                poly = target_msp.add_lwpolyline(new_points,
                                                 dxfattribs={
                                                     'layer': e_lay,
                                                     'flags': e.dxf.flags
                                                 })
                poly.closed = e.closed
            elif t[14:20] == 'Spline':
                self.add_layer(e_lay, dxf, src)
                points = e.get_fit_points()
                new_points = []
                for p in points:
                    new_points.append((p[0] + move[0], p[1] + move[1], p[2]))
                spline = target_msp.add_spline(new_points,
                                               dxfattribs={
                                                   'layer': e_lay,
                                                   'flags': e.dxf.flags
                                               })

                points = e.get_control_points()
                new_points = []
                for p in points:
                    new_points.append((p[0] + move[0], p[1] + move[1], p[2]))
                spline.set_control_points(new_points)

                spline.set_knot_values(e.get_knot_values())
                spline.set_weights(e.get_weights())

                spline.closed = e.closed
            elif t[14:20] == 'Modern':
                # addLayer(e.dxf.layer, dxf, src)
                # target_msp.add_entity(e)
                # ignore = 1
                pass
            else:
                print(t[14:])
                print(e_lay)
                # target_msp.add_entity(e)
            # source_msp.unlink_entity(e)
            # target_msp.add_entity(e)
        dxf.saveas(self.__dxf_file)
Exemplo n.º 4
0
def test_template():
    template_file = TemplateLoader().filepath('AC1009')
    assert is_dxf_file(template_file) is True
Exemplo n.º 5
0
    def merge(self, merge_dxf, move=(0.0, 0.0)):
        merge_dxf = '{}{}/{}'.format(self.__base_folder, self.__source_folder,
                                     merge_dxf)
        if not os.path.isfile(merge_dxf):
            raise IOError(
                2, 'No such file or directory: \'{}\''.format(merge_dxf))
        if not ezdxf.is_dxf_file(merge_dxf):
            raise IOError(
                2, 'No such file or directory: \'{}\''.format(merge_dxf))
        src = ezdxf.readfile(merge_dxf)

        print('\tAdding {}[{}] @ {}'.format(merge_dxf, src.dxfversion, move))
        dxf = ezdxf.new(src.dxfversion)
        lay = dxf.layers.get('0')
        lay.set_color(2)
        if os.path.isfile(self.__dxf_file):
            if ezdxf.is_dxf_file(self.__dxf_file):
                dxf = ezdxf.readfile(self.__dxf_file)
        target_msp = dxf.modelspace()
        source_msp = src.modelspace()

        # for lay in src.layers:
        for e in source_msp:
            if e.dxf.layer in self.__ignore_layers:
                continue
            e_lay = self.__rename_layers.get(e.dxf.layer, e.dxf.layer)
            if e.DXFTYPE == 'ARC':
                self.add_layer(e_lay, dxf, src)
                c = tuple(map(operator.add, e.dxf.center, move))
                target_msp.add_arc(c,
                                   e.dxf.radius,
                                   e.dxf.start_angle,
                                   e.dxf.end_angle,
                                   dxfattribs={'layer': e_lay})
                self.sum_perimeter += 2 * math.pi * e.dxf.radius * abs(
                    e.dxf.start_angle - e.dxf.end_angle) / 360.0
            elif e.DXFTYPE == 'CIRCLE':
                self.add_layer(e_lay, dxf, src)
                c = tuple(map(operator.add, e.dxf.center, move))
                target_msp.add_circle(c,
                                      e.dxf.radius,
                                      dxfattribs={'layer': e_lay})
                self.sum_perimeter += 2 * math.pi * e.dxf.radius
            elif e.DXFTYPE == 'POINT':
                self.add_layer(e_lay, dxf, src)
                loc = tuple(map(operator.add, e.dxf.location, move))
                target_msp.add_point(loc, dxfattribs={'layer': e_lay})
            elif e.DXFTYPE == 'TEXT':
                self.add_layer(e_lay, dxf, src)
                c = (e.dxf.insert[0] + move[0], e.dxf.insert[1] + move[1],
                     e.dxf.insert[2])
                target_msp.add_text(e.dxf.text,
                                    dxfattribs={
                                        'insert': c,
                                        'height': e.dxf.height,
                                        'rotation': e.dxf.rotation,
                                        'style': e.dxf.style,
                                        'width': e.dxf.width,
                                        'halign': e.dxf.halign,
                                        'valign': e.dxf.valign,
                                        'layer': e_lay
                                    })
            elif e.DXFTYPE == 'MTEXT':
                self.add_layer(e_lay, dxf, src)
                c = (e.dxf.insert[0] + move[0], e.dxf.insert[1] + move[1],
                     e.dxf.insert[2])
                target_msp.add_mtext(e.text,
                                     dxfattribs={
                                         'insert': c,
                                         'char_height': e.dxf.char_height,
                                         'width': e.dxf.width,
                                         'attachment_point':
                                         e.dxf.attachment_point,
                                         'flow_direction':
                                         e.dxf.flow_direction,
                                         'style': e.dxf.style,
                                         'rotation': e.dxf.rotation,
                                         'line_spacing_style':
                                         e.dxf.line_spacing_style,
                                         'line_spacing_factor':
                                         e.dxf.line_spacing_factor,
                                         'layer': e_lay
                                     })
            elif e.DXFTYPE == 'LINE':
                self.add_layer(e_lay, dxf, src)
                start = tuple(map(operator.add, e.dxf.start, move))
                end = tuple(map(operator.add, e.dxf.end, move))
                target_msp.add_line(start, end, dxfattribs={'layer': e_lay})
                self.sum_perimeter += self.distance(e.dxf.start, e.dxf.end)
            # elif t[14:22] == 'Polyline':
            #     addLayer(e_lay, dxf, src)
            #     points = e.points()
            #     new_points = []
            #     for p in points:
            #         new_points.append((p[0] + move[0], p[1] + move[1]))
            #     poly = target_msp.add_polyline(new_points, dxfattribs={
            #         'layer': e_lay,
            #         'flags': e.dxf.flags
            #     })
            #     poly.closed = e.closed
            elif e.DXFTYPE == 'LWPOLYLINE':
                self.add_layer(e_lay, dxf, src)
                points = e.get_points()
                new_points = []
                for p in points:
                    new_points.append(
                        (p[0] + move[0], p[1] + move[1], p[2], p[3], p[4]))
                poly = target_msp.add_lwpolyline(new_points,
                                                 dxfattribs={
                                                     'layer': e_lay,
                                                     'flags': e.dxf.flags
                                                 })
                poly.closed = e.closed
                self.sum_perimeter += self.length(points)
            elif e.DXFTYPE == 'SPLINE':
                self.add_layer(e_lay, dxf, src)
                points = e.fit_points
                new_points = []
                for p in points:
                    new_points.append((p[0] + move[0], p[1] + move[1], p[2]))
                spline = target_msp.add_spline(new_points,
                                               dxfattribs={
                                                   'layer': e_lay,
                                                   'flags': e.dxf.flags
                                               })

                points = e.control_points
                new_points = []
                for p in points:
                    new_points.append((p[0] + move[0], p[1] + move[1], p[2]))
                spline.control_points = new_points

                spline.knots = e.knots
                spline.weights = e.weights

                spline.closed = e.closed
                self.sum_perimeter += self.length(points)
            elif e.DXFTYPE == 'MODERN':
                # addLayer(e.dxf.layer, dxf, src)
                # target_msp.add_entity(e)
                # ignore = 1
                pass
            else:
                if self.DEBUG:
                    print('Unhandled[{0}]: {1}'.format(e_lay, e.DXFTYPE))
                # target_msp.add_entity(e)
            # source_msp.unlink_entity(e)
            # target_msp.add_entity(e)
        dxf.saveas(self.__dxf_file)