Hướng dẫn how to rotate a line in python - cách xoay một dòng trong python

Các tọa độ của điểm trung tâm (CX, CY) của một phân đoạn dòng giữa các điểm (x1, y1) và (x2, y2) là:

    cx = (x1 + x2) / 2
    cy = (y1 + y2) / 2

Nói cách khác, nó chỉ là trung bình, hoặc trung bình số học của hai cặp giá trị tọa độ X và Y.

Đối với một dòng nhiều phân đoạn, hoặc polyline, tọa độ x và y của trung tâm logic của nó chỉ là trung bình tương ứng của các giá trị x và y của tất cả các điểm. Trung bình chỉ là tổng của các giá trị chia cho số lượng của chúng.

Các công thức chung để xoay điểm 2D (x, y) θ & nbsp; radian xung quanh gốc (0,0) là:

    x′ = x * cos(θ) - y * sin(θ)
    y′ = x * sin(θ) + y * cos(θ)

Để thực hiện một vòng quay về một trung tâm khác (CX, CY), các giá trị x và y của điểm cần phải được điều chỉnh bằng cách trừ đầu tiên tọa độ của tâm Trong hình học như dịch) Nó được thể hiện về mặt toán học như thế này:

    tx = x - cx
    ty = y - cy

Sau đó xoay điểm trung gian này theo góc mong muốn và cuối cùng thêm các giá trị x và y của điểm xoay trở lại X và Y của mỗi tọa độ. Theo thuật ngữ hình học, đó là chuỗi hoạt động sau: & nbsp; tʀᴀɴsʟᴀᴛᴇ & nbsp; ─ ► & nbsp; rᴏᴛᴀᴛᴇ & nbsp;

Khái niệm này có thể được mở rộng để cho phép xoay toàn bộ đa đường về bất kỳ điểm tùy ý nào, chẳng hạn như trung tâm logic của chính nó bằng cách chỉ áp dụng toán học được mô tả cho từng điểm của từng phân đoạn dòng trong đó.

Để đơn giản hóa việc thực hiện tính toán này, kết quả số của cả ba bộ tính toán có thể được kết hợp và thể hiện với một cặp công thức toán học thực hiện tất cả chúng đồng thời. Vì vậy, một điểm mới (x, y ′) có thể thu được bằng cách xoay một điểm hiện có (x, y), θ & nbsp; radian xung quanh điểm (cx, cy) bằng cách sử dụng:

    x′ = (  (x - cx) * cos(θ) + (y - cy) * sin(θ) ) + cx
    y′ = ( -(x - cx) * sin(θ) + (y - cy) * cos(θ) ) + cy

Kết hợp khái niệm toán học/hình học này vào chức năng của bạn tạo ra những điều sau đây:

from math import sin, cos, radians

def rotate_lines(self, deg=-90):
    """ Rotate self.polylines the given angle about their centers. """
    theta = radians(deg)  # Convert angle from degrees to radians
    cosang, sinang = cos(theta), sin(theta)

    for pl in self.polylines:
        # Find logical center (avg x and avg y) of entire polyline
        n = len(pl.lines)*2  # Total number of points in polyline
        cx = sum(sum(line.get_xdata()) for line in pl.lines) / n
        cy = sum(sum(line.get_ydata()) for line in pl.lines) / n

        for line in pl.lines:
            # Retrieve vertices of the line
            x1, x2 = line.get_xdata()
            y1, y2 = line.get_ydata()

            # Rotate each around whole polyline's center point
            tx1, ty1 = x1-cx, y1-cy
            p1x = ( tx1*cosang + ty1*sinang) + cx
            p1y = (-tx1*sinang + ty1*cosang) + cy
            tx2, ty2 = x2-cx, y2-cy
            p2x = ( tx2*cosang + ty2*sinang) + cx
            p2y = (-tx2*sinang + ty2*cosang) + cy

            # Replace vertices with updated values
            pl.set_line(line, [p1x, p2x], [p1y, p2y])

Tôi rất mới với Python GIS.

Tôi đang tạo mã trong Python bằng thư viện hình học hình dạng. Một trong những mục tiêu là tạo một phân đoạn độ dài cố định, pin một đầu của nó thành một tọa độ đã biết và xoay phân đoạn, tất nhiên, giữ, không đổi chiều dài. Tôi đã tạo dòng với

line = LineString([Point(px0, py0), Point(px1, py1)])

Nơi PX0 và ​​PY0 là nơi tôi muốn phân đoạn được neo. Bây giờ tôi có thể tìm kiếm PX1 và PX2 bằng cách sử dụng lượng giác. Tuy nhiên, sẽ rất tốt nếu tôi có thể mô tả đơn giản phân đoạn này theo chiều dài và góc của nó. Tôi tự hỏi nếu có một thư viện đã được xây dựng mà thực hiện thủ thuật. Tôi đã tìm kiếm tài liệu hình dạng mà không thành công.

Tệp này chứa văn bản unicode hai chiều có thể được giải thích hoặc biên dịch khác với những gì xuất hiện dưới đây. Để xem xét, hãy mở tệp trong một trình soạn thảo cho thấy các ký tự Unicode ẩn. Tìm hiểu thêm về các ký tự unicode hai chiều

"" "
Lyle Scott, III //
Nhiều cách để xoay một điểm 2D xung quanh điểm gốc / một điểm.
Kết quả điểm chuẩn hẹn giờ @ https://gist.github.com/lylescott/d17e9d314fbe6fc29767d8c5c029c362
"" "
từ __future__ Nhập khẩu_function __future__ import print_function
Nhập khẩu math
Nhập khẩu numpy as np
Defrotate_via_numpy (XY, Radians): rotate_via_numpy(xy, radians):
"" "Sử dụng Numpy để xây dựng một ma trận xoay và lấy sản phẩm DOT." ""
x, y = xy, y = xy
C, s = np.cos (radians), np.sin (radian), s = np.cos(radians), np.sin(radians)
j = np.matrix ([[c, s], [-s, c]])) = np.matrix([[c, s], [-s, c]])
m = np.dot (j, [x, y]) = np.dot(j, [x, y])
returnFloat (m.t [0]), float (m.t [1]) float(m.T[0]), float(m.T[1])
defrotate_origin_only (xy, radians): rotate_origin_only(xy, radians):
"" "Chỉ xoay một điểm xung quanh gốc (0, 0)." ""
x, y = xy, y = xy
C, s = np.cos (radians), np.sin (radian) = x * math.cos(radians) + y * math.sin(radians)
j = np.matrix ([[c, s], [-s, c]])) = -x * math.sin(radians) + y * math.cos(radians)
m = np.dot (j, [x, y]) xx, yy
returnFloat (m.t [0]), float (m.t [1]) rotate_around_point_lowperf(point, radians, origin=(0, 0)):
defrotate_origin_only (xy, radians):
"" "Chỉ xoay một điểm xung quanh gốc (0, 0)." ""
xx = x*math.cos (radians) +y*math.sin (radians)
yy = -x*math.sin (radians) +y*math.cos (radians)
returnxx, yy
defrotate_around_point_lowperf (điểm, radians, gốc = (0, 0)):, y = point
"" "Xoay một điểm xung quanh một điểm nhất định., oy = origin
Tôi gọi đây là phiên bản "Hiệu suất thấp" vì nó được tính toán lại = ox + math.cos(radians) * (x - ox) + math.sin(radians) * (y - oy)
Các giá trị tương tự hơn một lần [cos (radians), sin (radians), x-ox, y-oy). = oy + -math.sin(radians) * (x - ox) + math.cos(radians) * (y - oy)
Mặc dù vậy, nó dễ đọc hơn hàm tiếp theo. qx, qy
"" " rotate_around_point_highperf(xy, radians, origin=(0, 0)):
defrotate_origin_only (xy, radians):
"" "Chỉ xoay một điểm xung quanh gốc (0, 0)." ""
xx = x*math.cos (radians) +y*math.sin (radians)
yy = -x*math.sin (radians) +y*math.cos (radians)
returnxx, yy
x, y = xy, y = xy
C, s = np.cos (radians), np.sin (radian), offset_y = origin
j = np.matrix ([[c, s], [-s, c]])) = (x - offset_x)
m = np.dot (j, [x, y]) = (y - offset_y)
returnFloat (m.t [0]), float (m.t [1]) = math.cos(radians)
defrotate_origin_only (xy, radians): = math.sin(radians)
qx=offset_x+cos_rad*adjusted_x+sin_rad*adjusted_y = offset_x + cos_rad * adjusted_x + sin_rad * adjusted_y
qy=offset_y+-sin_rad*adjusted_x+cos_rad*adjusted_y = offset_y + -sin_rad * adjusted_x + cos_rad * adjusted_y
Mặc dù vậy, nó dễ đọc hơn hàm tiếp theo. qx, qy
"" " _main():
x, y = điểm = math.radians(90)
ox, oy = nguồn gốc = (5, -11)
qx = ox +math.cos (radians) * (x-ox) +math.sin (radians) * (y-oy)(rotate_via_numpy(point, theta))
qy = oy +-math.sin (radians) * (x-ox) +math.cos (radians) * (y-oy)(rotate_origin_only(point, theta))
ReturnQX, Qy(rotate_around_point_lowperf(point, theta))
defrotate_around_point_highperf (xy, radians, gốc = (0, 0)):(rotate_around_point_highperf(point, theta))
Tôi gọi đây là phiên bản "Hiệu suất cao" vì chúng tôi đang lưu trữ một số __name__ == '__main__':
các giá trị cần thiết> 1 lần. Nó không dễ đọc hơn trước đó()

Làm cách nào để xoay một dòng?

Xoay dòng..
Trên tab Xem, trong nhóm chương trình, nhấp vào Tác vụ> Kích thước & Vị trí ..
Nhấp vào dòng bạn muốn xoay.Thông tin của dòng xuất hiện trong cửa sổ kích thước & vị trí ..
Trong cửa sổ kích thước & vị trí, trong hộp góc, nhập số độ mà bạn muốn xoay dòng ..

Làm thế nào để bạn xoay một cái gì đó trong Python?

Chức năng xoay () được sử dụng để xoay hình ảnh bằng một góc trong Python. is used to rotate an image by an angle in Python.

Làm thế nào để bạn xoay một dòng theo 90?

Quy tắc cho vòng quay 90 ° về nguồn gốc là (x, y) → (−Y, x).(x,y)→(−y,x) .

Làm thế nào để bạn xoay một dòng 45 độ?

Nếu chúng ta biểu diễn điểm (x, y) theo số phức X+iy, thì chúng ta có thể xoay nó 45 độ theo chiều kim đồng hồ chỉ bằng cách nhân với số phức (1 - i)/√2 và sau đó đọc tọa độ x và y của chúng..Do đó, tọa độ xoay của (x, y) là (x+y√2, y - x √2).multiplying by the complex number (1−i)/√2 and then reading off their x and y coordinates. (x+iy)(1−i)/√2=((x+y)+i(y−x))/√2=x+y√2+iy−x√2. Therefore, the rotated coordinates of (x,y) are (x+y√2,y−x√2).