name - Conversión de Python entre coordenadas

subplot python title

Question

¿Hay funciones para la conversión entre diferentes sistemas de coordenadas?

Por ejemplo, Matlab tiene [rho,phi] = cart2pol(x,y) para la conversión de coordenadas cartesianas a coordenadas polares. Parece que debería estar en numpy o scipy.

Answer 1

Hay una mejor manera de escribir polar (), aquí está:

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

Answer 2

Las respuestas existentes se pueden simplificar:

from numpy import exp, abs, angle

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

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

O incluso:

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

Tenga en cuenta que estos también funcionan en matrices.

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

Answer 3

Pensando en ello en general, consideraría fuertemente esconder el sistema de coordenadas detrás de una abstracción bien diseñada. Citando al tío Bob y su libro:

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)

Con una interfaz como esa, cualquier usuario de la clase Point puede elegir una representación conveniente, no se realizarán conversiones explícitas. Todos estos senos feos, cosenos, etc. estarán ocultos en un solo lugar. Clase de punto Solo el lugar donde debería importar qué representación se usa en la memoria de la computadora.

Answer 4

Puede usar el módulo cmath .

Si el número se convierte a un formato complejo, entonces es más fácil simplemente llamar al método polar en el número.

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

Answer 5

Si no puede encontrarlo en numpy o skipy, aquí hay un par de funciones rápidas y una clase de punto:

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
    if y == 0:
        theta = 180 if x < 0 else 0
    elif x == 0:
        theta = 90 if y > 0 else 270
    else:
        theta = math.degrees(math.atan(float(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)

Answer 6

Si sus coordenadas están almacenadas como números complejos, puede usar cmath

Answer 7

Usando numpy, puedes definir lo siguiente:

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)