坐标之间的Python转换

Python conversion between coordinates

提问by cpc333

Are there functions for conversion between different coordinate systems?

是否有不同坐标系之间的转换功能？

For example, Matlab has [rho,phi] = cart2pol(x,y)for conversion from cartesian to polar coordinates. Seems like it should be in numpy or scipy.

例如，Matlab 具有[rho,phi] = cart2pol(x,y)从笛卡尔坐标到极坐标的转换。似乎它应该在 numpy 或 scipy 中。

回答by alcio

If your coordinates are stored as complex numbers you can use cmath

如果您的坐标存储为复数，您可以使用cmath

回答by wwii

If you can't find it in numpy or scipy, here are a couple of quick functions and a point class:

如果你在 numpy 或 scipy 中找不到它，这里有几个快速函数和一个点类：

import math

def rect(r, theta):
    """theta in degrees

    returns tuple; (float, float); (x,y)
    """
    x = r * math.cos(math.radians(theta))
    y = r * math.sin(math.radians(theta))
    return x,y

def polar(x, y):
    """returns r, theta(degrees)
    """
    r = (x ** 2 + y ** 2) ** .5
    theta = math.degrees(math.atan2(y,x))
    return r, theta

class Point(object):
    def __init__(self, x=None, y=None, r=None, theta=None):
        """x and y or r and theta(degrees)
        """
        if x and y:
            self.c_polar(x, y)
        elif r and theta:
            self.c_rect(r, theta)
        else:
            raise ValueError('Must specify x and y or r and theta')
    def c_polar(self, x, y, f = polar):
        self._x = x
        self._y = y
        self._r, self._theta = f(self._x, self._y)
        self._theta_radians = math.radians(self._theta)
    def c_rect(self, r, theta, f = rect):
        """theta in degrees
        """
        self._r = r
        self._theta = theta
        self._theta_radians = math.radians(theta)
        self._x, self._y = f(self._r, self._theta)
    def setx(self, x):
        self.c_polar(x, self._y)
    def getx(self):
        return self._x
    x = property(fget = getx, fset = setx)
    def sety(self, y):
        self.c_polar(self._x, y)
    def gety(self):
        return self._y
    y = property(fget = gety, fset = sety)
    def setxy(self, x, y):
        self.c_polar(x, y)
    def getxy(self):
        return self._x, self._y
    xy = property(fget = getxy, fset = setxy)
    def setr(self, r):
        self.c_rect(r, self._theta)
    def getr(self):
        return self._r
    r = property(fget = getr, fset = setr)
    def settheta(self, theta):
        """theta in degrees
        """
        self.c_rect(self._r, theta)
    def gettheta(self):
        return self._theta
    theta = property(fget = gettheta, fset = settheta)
    def set_r_theta(self, r, theta):
        """theta in degrees
        """
        self.c_rect(r, theta)
    def get_r_theta(self):
        return self._r, self._theta
    r_theta = property(fget = get_r_theta, fset = set_r_theta)
    def __str__(self):
        return '({},{})'.format(self._x, self._y)

回答by nzh

Using numpy, you can define the following:

使用 numpy，您可以定义以下内容：

import numpy as np

def cart2pol(x, y):
    rho = np.sqrt(x**2 + y**2)
    phi = np.arctan2(y, x)
    return(rho, phi)

def pol2cart(rho, phi):
    x = rho * np.cos(phi)
    y = rho * np.sin(phi)
    return(x, y)

回答by ?ukasz Rogalski

Thinking about it in general, I would strongly consider hiding coordinate system behind well-designed abstraction. Quoting Uncle Bob and his book:

总的来说，我会强烈考虑在精心设计的抽象背后隐藏坐标系。引用鲍勃叔叔和他的书：

class Point(object)
    def setCartesian(self, x, y)
    def setPolar(self, rho, theta)
    def getX(self)
    def getY(self)
    def getRho(self)
    def setTheta(self)

With interface like that any user of Point class may choose convenient representation, no explicit conversions will be performed. All this ugly sines, cosines etc. will be hidden in one place. Point class. Only place where you should care which representation is used in computer memory.

有了这样的接口，Point 类的任何用户都可以选择方便的表示形式，不会执行显式转换。所有这些丑陋的正弦、余弦等都将隐藏在一个地方。点类。只有您应该关心计算机内存中使用哪种表示的地方。

回答by P i

The existing answers can be simplified:

现有的答案可以简化：

from numpy import exp, abs, angle

def polar2z(r,theta):
    return r * exp( 1j * theta )

def z2polar(z):
    return ( abs(z), angle(z) )

Or even:

甚至：

polar2z = lambda r,θ: r * exp( 1j * θ )
z2polar = lambda z: ( abs(z), angle(z) )

Note these also work on arrays!

注意这些也适用于数组！

rS, thetaS = z2polar( [z1,z2,z3] )
zS = polar2z( rS, thetaS )

回答by KeithB

There is a better way to write polar(), here it is:

有一个更好的方法来编写 polar()，这里是：

def polar(x,y):
  `returns r, theta(degrees)`
  return math.hypot(x,y),math.degrees(math.atan2(y,x))

回答by CR Vinay Kumar

You can use the cmathmodule.

您可以使用cmath模块。

If the number is converted to a complex format, then it becomes easier to just call the polar method on the number.

如果将数字转换为复杂格式，则只需对数字调用 polar 方法就变得更容易了。

import cmath
input_num = complex(1, 2) # stored as 1+2j
r, phi = cmath.polar(input_num)