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ờ @ //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 đó[] |