def test_non_uniformed_scaled_ucs(): ucs = UCS(origin=(3, 2, 1)).scale(1.5, 2.5, 3.5) assert ucs.is_cartesian is True assert ucs.to_wcs((0, 0, 0)) == (3, 2, 1) assert ucs.to_wcs((1, 0, 0)) == (4.5, 2, 1) assert ucs.to_wcs((0, 1, 0)) == (3, 4.5, 1) assert ucs.to_wcs((0, 0, 1)) == (3, 2, 4.5)
def test_uniformed_scaled_ucs(): ucs = UCS(origin=(1, 2, 3)).scale(2, 2, 2) assert ucs.is_cartesian is True assert ucs.to_wcs((0, 0, 0)) == (1, 2, 3) assert ucs.to_wcs((1, 0, 0)) == (3, 2, 3) assert ucs.to_wcs((0, 1, 0)) == (1, 4, 3) assert ucs.to_wcs((0, 0, 1)) == (1, 2, 5)
def test_non_uniformed_scaled_ucs_at_origin(): ucs = UCS().scale(1.5, 2.5, 3.5) assert ucs.is_cartesian is True assert ucs.to_wcs((0, 0, 0)) == (0, 0, 0) assert ucs.to_wcs((1, 0, 0)) == (1.5, 0, 0) assert ucs.to_wcs((0, 1, 0)) == (0, 2.5, 0) assert ucs.to_wcs((0, 0, 1)) == (0, 0, 3.5)
def test_uniformed_scaled_ucs_at_origin(): ucs = UCS().scale(2, 2, 2) assert ucs.is_cartesian is True assert ucs.to_wcs((0, 0, 0)) == (0, 0, 0) assert ucs.to_wcs((1, 0, 0)) == (2, 0, 0) assert ucs.to_wcs((0, 1, 0)) == (0, 2, 0) assert ucs.to_wcs((0, 0, 1)) == (0, 0, 2)
def test_points_from_wcs(): points = Vec3.list([(1, 2, 3), (3, 4, 5)]) ucs = PassTroughUCS() assert list(ucs.points_from_wcs(points)) == points ucs2 = UCS() assert list(ucs.points_from_wcs(points)) == list(ucs2.points_from_wcs(points))
def test_translation(): ucs = UCS(origin=(3, 4, 5)) assert ucs.origin == (3, 4, 5) assert ucs.ux == (1, 0, 0) assert ucs.uy == (0, 1, 0) assert ucs.uz == (0, 0, 1) assert ucs.from_wcs((3, 4, 5)) == (0, 0, 0) assert ucs.to_wcs((1, 1, 1)) == (4, 5, 6)
def test_from_wcs(): ucs = PassTroughUCS() assert ucs.from_wcs((1, 2, 3)) == Vec3(1, 2, 3) assert ucs.from_wcs((3, 4, 5)) == Vec3(3, 4, 5) ucs2 = UCS() assert ucs.from_wcs((1, 2, 3)) == ucs2.from_wcs(Vec3(1, 2, 3)) assert ucs.from_wcs((3, 4, 5)) == ucs2.from_wcs(Vec3(3, 4, 5))
def ucs(self): """ Returns the block reference coordinate system as :class:`ezdxf.math.UCS` object. """ m = self.matrix44() ucs = UCS() ucs.matrix = m return ucs
def transform_to_wcs(self, ucs: UCS) -> None: """ Transform LINE entity from local :class:`~ezdxf.math.UCS` coordinates to :ref:`WCS` coordinates. .. versionadded:: 0.11 """ self.dxf.start = ucs.to_wcs(self.dxf.start) self.dxf.end = ucs.to_wcs(self.dxf.end)
def test_ucs_init(): ucs = UCS() assert ucs.origin == (0, 0, 0) assert ucs.ux == (1, 0, 0) assert ucs.uy == (0, 1, 0) assert ucs.uz == (0, 0, 1) assert ucs.from_wcs((3, 4, 5)) == (3, 4, 5) assert ucs.to_wcs((5, 4, 3)) == (5, 4, 3)
def test_rotate_local_z(): ucs = UCS() assert ucs.ux == (1, 0, 0) # WCS x-axis assert ucs.uy == (0, 1, 0) # WCS y-axis assert ucs.uz == (0, 0, 1) # WCS z-axis ucs = ucs.rotate_local_z(pi / 2) assert ucs.ux.isclose((0, 1, 0)) # WCS y-axis assert ucs.uy.isclose((-1, 0, 0)) # WCS -x-axis assert ucs.uz.isclose((0, 0, 1)) # WCS z-axis
def test_arbitrary_ucs(): origin = Vector(3, 3, 3) ux = Vector(1, 2, 0) def_point_in_xy_plane = Vector(3, 10, 4) uz = ux.cross(def_point_in_xy_plane - origin) ucs = UCS(origin=origin, ux=ux, uz=uz) def_point_in_ucs = ucs.from_wcs(def_point_in_xy_plane) assert def_point_in_ucs.z == 0 assert ucs.to_wcs(def_point_in_ucs) == def_point_in_xy_plane assert ucs.is_cartesian is True
def scene1(filename): doc = ezdxf.new('R2010', setup=True) msp = doc.modelspace() ucs = UCS() angle = math.pi / 12 # 15 degree for ix in range(X_COUNT): for iy in range(Y_COUNT): ucs.moveto((ix * DX, iy * DY, 0)) ucs.render_axis(msp, length=1) add_circle(msp, ucs) # add_ocs_circle(msp, ucs) # add_ocs_arc(msp, ucs) # add_text(msp, ucs) add_mtext(msp, ucs) add_ellipse(msp, ucs) # add_solid(msp, ucs) add_trace(msp, ucs) # add_3dface(msp, ucs) # add_lwpolyline(msp, ucs) ucs = ucs.rotate_local_z(angle) ucs = UCS().rotate_local_x(ix * angle) doc.set_modelspace_vport(Y_COUNT * (DY + 2), center=(X_COUNT * DX / 2, Y_COUNT * DY / 2)) doc.saveas(filename)
def test_points_to_wcs(): ucs = PassTroughUCS() assert list(ucs.points_to_wcs([(1, 2, 3), (3, 4, 5)])) == [ Vec3(1, 2, 3), Vec3(3, 4, 5), ] ucs2 = UCS() assert list(ucs.points_to_wcs([ (1, 2, 3), (3, 4, 5) ])) == list(ucs2.points_to_wcs([(1, 2, 3), (3, 4, 5)]))
def test_ocs_points_to_ocs(): ucs = UCS(ux=(0, 0, -1), uz=(1, 0, 0)) points = [(1, 2, 3), (4, 5, 6), (9, 8, 7)] # tests only the actual state - as it is - not granted results are correct expected = [ Vector(-1.4547842173342707, 1.6981174520612865, 3), Vector(-3.0545253372991867, 5.6275993961721635, 6), Vector(-3.8776861825487807, 11.400155694974972, 7), ] result = list(ucs.ocs_points_to_ocs(points, extrusion=Vector(2, 4, 7))) assert result == expected
def test_matrix44_rotation(): # normalization is not necessary ux = Vec3(1, 2, 0) # only cartesian coord systems work uy = ux.rotate_deg(90) ucs = UCS(ux=ux, uy=uy) m = Matrix44.ucs(ux=ux.normalize(), uy=uy.normalize()) assert m.ux == ux.normalize() assert m.uy == uy.normalize() assert m.uz == (0, 0, 1) assert m.is_cartesian v = m.transform((1, 2, 3)) assert v == ucs.to_wcs((1, 2, 3)) assert m.ucs_vertex_from_wcs(v).isclose((1, 2, 3))
def test_transformation(): axis = Vec3.random() angle = 1.5 ucs = UCS(origin=(3, 4, 5)) m = Matrix44.axis_rotate(axis, angle) expected_origin = m.transform(ucs.origin) expected_ux = m.transform(ucs.ux) expected_uy = m.transform(ucs.uy) expected_uz = m.transform(ucs.uz) new = ucs.transform(m) assert new.origin.isclose(expected_origin) assert new.ux.isclose(expected_ux) assert new.uy.isclose(expected_uy) assert new.uz.isclose(expected_uz)
def test_ucs_direction_to_ocs_direction(): ucs = UCS.from_x_axis_and_point_in_xy(origin=(1, 2, 3), axis=(2, 3, 4), point=(3, 2, 5)) assert ucs.is_cartesian is True expected = (-3.350073025395333, 2.9626020192591795, 6) assert ucs.ucs_direction_to_ocs_direction(Vec3(2, 4, 6)).isclose(expected)
def example_for_all_text_placings_in_space_R2007(): ucs = UCS(origin=(20, 20, 0)).rotate_local_x( math.radians(45)).rotate_local_z(math.radians(45)) doc = ezdxf.new('R2007', setup=True) set_text_style(doc) example_for_all_text_placings( doc, 'dim_linear_text_placing_in_space_R2007.dxf', ucs)
def test_virtual_entities_elevation(lwpolyline): ucs = UCS(origin=(1, 1, 1)) lwpolyline = lwpolyline.transform_to_wcs(ucs) assert lwpolyline.dxf.elevation == 1 result = list(lwpolyline.virtual_entities()) assert len(result) == 3 e = result[0] assert e.dxftype() == 'LINE' assert e.dxf.start == (1, 1, 1) assert e.dxf.end == (2, 1, 1) e = result[1] assert e.dxftype() == 'ARC' assert e.dxf.center == (2.5, 1, 1) assert e.dxf.radius == 0.5 assert math.isclose(e.dxf.start_angle, 180, abs_tol=1e-12) assert math.isclose(e.dxf.end_angle, 0, abs_tol=1e-12) assert e.start_point.isclose((2, 1, 1)) assert e.end_point.isclose((3, 1, 1)) e = result[2] assert e.dxftype() == 'LINE' assert e.dxf.start == (3, 1, 1) assert e.dxf.end == (4, 1, 1)
def test_spatial_arc_from_3p(): start_point_wcs = Vector(0, 1, 0) end_point_wcs = Vector(1, 0, 0) def_point_wcs = Vector(0, 0, 1) ucs = UCS.from_x_axis_and_point_in_xy(origin=def_point_wcs, axis=end_point_wcs - def_point_wcs, point=start_point_wcs) start_point_ucs = ucs.from_wcs(start_point_wcs) end_point_ucs = ucs.from_wcs(end_point_wcs) def_point_ucs = Vector(0, 0) arc = ConstructionArc.from_3p(start_point_ucs, end_point_ucs, def_point_ucs) dwg = ezdxf.new('R12') msp = dwg.modelspace() dxf_arc = arc.add_to_layout(msp, ucs) assert dxf_arc.dxftype() == 'ARC' assert isclose(dxf_arc.dxf.radius, 0.81649658, abs_tol=1e-9) assert isclose(dxf_arc.dxf.start_angle, -30) # ??? assert isclose(dxf_arc.dxf.end_angle, -150) # ??? assert is_close_points(dxf_arc.dxf.extrusion, (0.57735027, 0.57735027, 0.57735027), abs_tol=1e-9)
def ucs(self) -> UCS: """ Returns an :class:`ezdxf.math.UCS` object for this UCS table entry. """ return UCS( origin=self.dxf.origin, ux=self.dxf.xaxis, uy=self.dxf.yaxis, )
def test_angles_to_ocs_deg(): ucs = UCS.from_x_axis_and_point_in_xy(origin=(1, 2, 3), axis=(2, 3, 4), point=(3, 2, 5)) angles = [15, 30, 90] expected = [ucs.to_ocs_angle_deg(a) for a in angles] result = ucs.angles_to_ocs_deg(angles) assert result == expected
def test_vertext_array_transform_to_wcs(): vertices = VertexArray() vertices.extend([(0, 0, 0), (1, 0, 0), (1, 1, 0)]) ucs = UCS(origin=(0, 0, 1)) vertices.transform_to_wcs(ucs) assert vertices[0] == (0, 0, 1) assert vertices[1] == (1, 0, 1) assert vertices[2] == (1, 1, 1)
def test_arbitrary_ucs(): origin = Vec3(3, 3, 3) ux = Vec3(1, 2, 0) def_point_in_xy_plane = Vec3(3, 10, 4) uz = ux.cross(def_point_in_xy_plane - origin) ucs = UCS(origin=origin, ux=ux, uz=uz) m = Matrix44.ucs(ucs.ux, ucs.uy, ucs.uz, ucs.origin) def_point_in_ucs = ucs.from_wcs(def_point_in_xy_plane) assert ucs.ux == m.ux assert ucs.uy == m.uy assert ucs.uz == m.uz assert ucs.origin == m.origin assert def_point_in_ucs == m.ucs_vertex_from_wcs(def_point_in_xy_plane) assert def_point_in_ucs.z == 0 assert ucs.to_wcs(def_point_in_ucs).isclose(def_point_in_xy_plane) assert ucs.is_cartesian is True
def test_ocs_angles_to_ocs_deg(): ucs = UCS.from_x_axis_and_point_in_xy(origin=(1, 2, 3), axis=(2, 3, 4), point=(3, 2, 5)) angles = [15, 30, 90] # tests only the actual state - as it is - not granted results are correct expected = [-128.92976741554182, -113.92976741554183, -53.929767415541825] result = ucs.ocs_angles_to_ocs_deg(angles, extrusion=Vector(1, 2, 3)) assert result == expected
def _ucs_and_ocs_transformation(self, ucs: UCS, vector_names: Sequence, angle_names: Sequence = None) -> None: """ Transforms entity for given `ucs` to the parent coordinate system (most likely the WCS). Transforms the entity vectors and angles attributes from `ucs` to the parent coordinate system. Takes established OCS by the extrusion vector :attr:`dxf.extrusion` into account. """ extrusion = self.dxf.extrusion vectors = (self.dxf.get_default(name) for name in vector_names) ocs_vectors = ucs.ocs_points_to_ocs(vectors, extrusion=extrusion) for name, value in zip(vector_names, ocs_vectors): self.dxf.set(name, value) if angle_names is not None: angles = (self.dxf.get_default(name) for name in angle_names) ocs_angles = ucs.ocs_angles_to_ocs_deg(angles=angles, extrusion=extrusion) for name, value in zip(angle_names, ocs_angles): self.dxf.set(name, value) self.dxf.extrusion = ucs.direction_to_wcs(extrusion)
def test_rotation(): # normalization is not necessary ux = Vector(1, 2, 0) # only cartesian coord systems work uy = ux.rotate_deg(90) ucs = UCS(ux=ux, uy=uy) assert ucs.ux == ux.normalize() assert ucs.uy == uy.normalize() assert ucs.uz == (0, 0, 1) assert ucs.is_cartesian is True
def ucs(self) -> UCS: """Returns the :class:`~ezdxf.math.UCS` of the :class:`MText` entity, defined by the insert location (origin), the text direction or rotation (x-axis) and the extrusion vector (z-axis). """ dxf = self.dxf return UCS( origin=dxf.insert, ux=self.get_text_direction(), uz=dxf.extrusion, )
def setup_csys(blk, size=3): # draw axis blk.add_line((0, 0), (size, 0), dxfattribs={'color': RED}) # x-axis blk.add_line((0, 0), (0, size), dxfattribs={'color': GREEN}) # y-axis blk.add_line((0, 0), (0, 0, size), dxfattribs={'color': BLUE}) # z-axis # place text size2 = size / 2 txt_props = { 'style': 'OpenSans', 'height': size / 2, 'color': RED, } # XY-plane text blk.add_text('XY', dxfattribs=txt_props).set_pos((size2, size2), align='MIDDLE_CENTER') # YZ-plane text ucs = UCS(ux=(0, 1, 0), uy=(0, 0, 1)) txt_props['extrusion'] = ucs.uz txt_props['color'] = GREEN blk.add_text('YZ', dxfattribs=txt_props).set_pos(ucs.to_ocs( (size2, size2)), align='MIDDLE_CENTER') # XZ-plane text ucs = UCS(ux=(1, 0, 0), uy=(0, 0, 1)) txt_props['extrusion'] = ucs.uz txt_props['color'] = BLUE txt_props['text_generation_flag'] = MIRROR_X blk.add_text('XZ', dxfattribs=txt_props).set_pos(ucs.to_ocs( (size2, size2)), align='MIDDLE_CENTER')