Python conversion between coordinates

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

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

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)

Using numpy, you can define the following:

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)

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.

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 )

There is a better way to write a method to convert from Cartesian to polar coordinates; here it is:

import numpy as np
def polar(x, y) -> tuple:
"""returns rho, theta (degrees)"""
return np.hypot(x, y), np.degrees(np.arctan2(y, x))

You can use the cmath module.

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

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

Mix of all the above answers which suits me:

import numpy as np


def pol2cart(r,theta):
'''
Parameters:
- r: float, vector amplitude
- theta: float, vector angle
Returns:
- x: float, x coord. of vector end
- y: float, y coord. of vector end
'''


z = r * np.exp(1j * theta)
x, y = z.real, z.imag


return x, y


def cart2pol(x, y):
'''
Parameters:
- x: float, x coord. of vector end
- y: float, y coord. of vector end
Returns:
- r: float, vector amplitude
- theta: float, vector angle
'''


z = x + y * 1j
r,theta = np.abs(z), np.angle(z)


return r,theta

In case, like me, you're trying to control a robot that accepts a speed and heading value based off of a joystick value, use this instead (it converts the radians to degrees:

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

If you have an array of (x,y) coordinates or (rho, phi) coordinates you can transform them all at once with numpy.

The functions return an array of converted coordinates.

import numpy as np


def combine2Coord(c1, c2):
return np.concatenate((c1.reshape(-1, 1), c2.reshape(-1, 1)), axis=1)


def cart2pol(xyArr):
rho = np.sqrt((xyArr**2).sum(1))
phi = np.arctan2(xyArr[:,1], xyArr[:,0])
return combine2Coord(rho, phi)


def pol2cart(rhoPhiArr):
x = rhoPhiArr[:,0] * np.cos(rhoPhiArr[:,1])
y = rhoPhiArr[:,0] * np.sin(rhoPhiArr[:,1])
return combine2Coord(x, y)

Do you care about speed? Use cmath, it's an order faster than numpy. And it's already included in any python since python 2!

Using ipython:

import cmath, numpy as np


def polar2z(polar):
rho, phi = polar
return rho * np.exp( 1j * phi )


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




def cart2polC(xy):
x, y = xy
return(cmath.polar(complex(x, y))) # rho, phi


def pol2cartC(polar):
rho, phi = polar
z = rho * cmath.exp(1j * phi)
return z.real, z.imag


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


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


xy = (100,100)
polar = (100,0)


%timeit cart2polC(xy)
%timeit pol2cartC(polar)


%timeit cart2polNP(xy)
%timeit pol2cartNP(polar)


%timeit z2polar(complex(*xy))
%timeit polar2z(polar)


373 ns ± 4.76 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
337 ns ± 0.976 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
4.3 µs ± 34.2 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
3.41 µs ± 5.78 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
3.4 µs ± 5.4 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
1.39 µs ± 3.86 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)