439 lines
11 KiB
Python
439 lines
11 KiB
Python
import unittest
|
|
|
|
from LinearAlgebra.Spherical import *
|
|
|
|
class PolarTest(unittest.TestCase):
|
|
def test_FromVector2(self):
|
|
v: Vector2 = Vector2(0, 1)
|
|
p: Polar = Polar.FromVector2(v)
|
|
|
|
assert(p.distance == 1)
|
|
assert(p.direction.InDegrees() == 0)
|
|
|
|
v = Vector2(1, 0)
|
|
p = Polar.FromVector2(v)
|
|
|
|
assert(p.distance, 1)
|
|
assert(p.direction.InDegrees(), 90)
|
|
|
|
v = Vector2(-1, 1)
|
|
p = Polar.FromVector2(v)
|
|
|
|
assert(p.distance == math.sqrt(2))
|
|
assert(p.direction.InDegrees() == -45)
|
|
|
|
def test_Equality(self):
|
|
v1: Polar = Polar.Degrees(4, 5)
|
|
|
|
v2: Polar = Polar.Degrees(1, 2)
|
|
assert(v1 != v2)
|
|
|
|
v2 = Polar.Degrees(4, 5)
|
|
assert(v1 == v2)
|
|
|
|
def test_Magnitude(self):
|
|
v: Polar = Polar.Degrees(2, 30)
|
|
r: float = 0
|
|
|
|
r = v.Magnitude()
|
|
assert(r == 2)
|
|
|
|
v = Polar.Degrees(-2, -30)
|
|
r = v.Magnitude()
|
|
assert(r == 2)
|
|
|
|
v = Polar.Degrees(0, 0)
|
|
r = v.Magnitude()
|
|
assert(r == 0)
|
|
|
|
def test_Normalize(self):
|
|
v1: Polar = Polar.Degrees(2, 90)
|
|
r: Polar = Polar.zero
|
|
|
|
r = v1.Normalized()
|
|
assert(r == Polar.Degrees(1, 90))
|
|
|
|
v1 = Polar.Degrees(2, -90)
|
|
r = v1.Normalized()
|
|
assert(r == Polar.Degrees(1, -90))
|
|
|
|
v1 = Polar.Degrees(0, 0)
|
|
r = v1.Normalized()
|
|
assert(r == Polar.Degrees(0, 0))
|
|
|
|
def test_Negate(self):
|
|
v1: Polar = Polar.Degrees(2, 45)
|
|
r: Polar = Polar.zero
|
|
|
|
r = -v1
|
|
assert(r == Polar.Degrees(2, -135))
|
|
|
|
v1 = Polar.Degrees(2, -45)
|
|
r = -v1
|
|
assert(r == Polar.Degrees(2, 135))
|
|
|
|
v1 = Polar.Degrees(2, 0)
|
|
r = -v1
|
|
assert(r == Polar.Degrees(2, 180))
|
|
|
|
v1 = Polar.Degrees(0, 0)
|
|
r = -v1
|
|
assert(r == Polar.Degrees(0, 0))
|
|
|
|
def test_Subtract(self):
|
|
r: Polar = Polar.zero
|
|
v1: Polar = Polar.Degrees(4, 45)
|
|
|
|
v2: Polar = Polar.zero
|
|
r = v1 - v2
|
|
assert(r == v1)
|
|
|
|
r = v1
|
|
r -= v2
|
|
assert(r == v1)
|
|
|
|
v2: Polar = Polar.Degrees(1, 45)
|
|
r = v1 - v2
|
|
assert(r == Polar.Degrees(3, 45))
|
|
|
|
v2: Polar = Polar.Degrees(1, -135)
|
|
r = v1 - v2
|
|
assert(r == Polar.Degrees(5, 45))
|
|
|
|
def test_Addition(self):
|
|
r = Polar.zero
|
|
|
|
v1 = Polar.Degrees(4, 45)
|
|
v2 = Polar.zero
|
|
r = v1 + v2
|
|
assert(r == v1)
|
|
|
|
r = v1
|
|
r += v2
|
|
assert(r == v1)
|
|
|
|
v2 = Polar.Degrees(1, 45)
|
|
r = v1 + v2
|
|
assert(r == Polar.Degrees(5, 45))
|
|
|
|
v2 = Polar.Degrees(1, -135)
|
|
r = v1 + v2
|
|
assert(r == Polar.Degrees(3, 45))
|
|
|
|
def test_Multiply(self):
|
|
r: Polar = Polar.zero
|
|
|
|
v1: Polar = Polar.Degrees(4, 45)
|
|
r = v1 * 2
|
|
assert(r == Polar.Degrees(8, 45))
|
|
|
|
r = v1 * -2
|
|
assert(r == Polar.Degrees(8, -135))
|
|
|
|
r = v1 * 0
|
|
assert(r == Polar.Degrees(0, 0))
|
|
|
|
def test_Divide(self):
|
|
r: Polar.zero
|
|
|
|
v1 = Polar.Degrees(4, 45)
|
|
r = v1 / 2
|
|
assert(r == Polar.Degrees(2, 45))
|
|
|
|
r = v1 / -2
|
|
assert(r == Polar.Degrees(2, -135))
|
|
|
|
def test_Distance(self):
|
|
r: float = 0
|
|
|
|
v1 = Polar.Degrees(4, 45)
|
|
v2 = Polar.Degrees(1, -135)
|
|
r = Polar.Distance(v1, v2)
|
|
assert(r == 5)
|
|
|
|
v2 = Polar.Degrees(-1, -135)
|
|
r = Polar.Distance(v1, v2)
|
|
assert(math.isclose(r, 3))
|
|
|
|
v2 = Polar.Degrees(0, 0)
|
|
r = Polar.Distance(v1, v2)
|
|
assert(r == 4)
|
|
|
|
def test_Angle(self):
|
|
r = Angle.zero
|
|
|
|
v1 = Polar.Degrees(4, 45)
|
|
v2 = Polar.Degrees(1, -45)
|
|
|
|
r = Polar.Angle(v1, v2)
|
|
assert(r.InDegrees() == 90)
|
|
|
|
v2 = Polar.Degrees(1, 135)
|
|
r = Polar.Angle(v1, v2)
|
|
assert(r.InDegrees() == 90)
|
|
|
|
v2 = Polar.Degrees(1, 45)
|
|
r = Polar.Angle(v1, v2)
|
|
assert(r.InDegrees() == 0)
|
|
|
|
def test_SignedAngle(self):
|
|
r = Angle.zero
|
|
|
|
v1 = Polar.Degrees(4, 45)
|
|
v2 = Polar.Degrees(1, -45)
|
|
|
|
r = Polar.SignedAngle(v1, v2)
|
|
assert(r.InDegrees() == -90)
|
|
|
|
v2 = Polar.Degrees(1, 135)
|
|
r = Polar.SignedAngle(v1, v2)
|
|
assert(r.InDegrees() == 90)
|
|
|
|
v2 = Polar.Degrees(1, 45)
|
|
r = Polar.SignedAngle(v1, v2)
|
|
assert(r.InDegrees() == 0)
|
|
|
|
def test_Lerp(self):
|
|
r = Polar.zero
|
|
|
|
v1 = Polar.Degrees(5, 45)
|
|
v2 = Polar.Degrees(1, -45)
|
|
|
|
r = Polar.Lerp(v1, v2, 0)
|
|
assert(r == v1)
|
|
|
|
r = Polar.Lerp(v1, v2, 1)
|
|
assert(Polar.isclose(r, v2))
|
|
|
|
r = Polar.Lerp(v1, v2, 0.5)
|
|
assert(Polar.isclose(r, Polar.Degrees(3, 0)))
|
|
|
|
r = Polar.Lerp(v1, v2, -1)
|
|
assert(r == Polar.Degrees(9, 135))
|
|
|
|
r = Polar.Lerp(v1, v2, 2)
|
|
assert(r == Polar.Degrees(-3, -135))
|
|
|
|
class SphericalTest(unittest.TestCase):
|
|
def test_FromVector3(self):
|
|
v: Vector3 = Vector3(0, 0, 1)
|
|
p: Spherical = Spherical.FromVector3(v)
|
|
|
|
assert(p.distance == 1)
|
|
assert(p.direction.horizontal.InDegrees() == 0)
|
|
assert(p.direction.vertical.InDegrees() == 0)
|
|
|
|
v = Vector3(1, 0, 0)
|
|
p = Spherical.FromVector3(v)
|
|
|
|
assert(p.distance, 1)
|
|
assert(p.direction.horizontal.InDegrees(), 90)
|
|
assert(p.direction.vertical.InDegrees(), 0)
|
|
|
|
v = Vector3(0, 1, 0)
|
|
p = Spherical.FromVector3(v)
|
|
|
|
assert(p.distance, 1)
|
|
assert(p.direction.horizontal.InDegrees(), 0)
|
|
assert(p.direction.vertical.InDegrees(), 90)
|
|
|
|
v = Vector3(-1, 0, 1)
|
|
p = Spherical.FromVector3(v)
|
|
|
|
assert(p.distance == math.sqrt(2))
|
|
assert(p.direction.horizontal.InDegrees() == -45)
|
|
assert(p.direction.vertical.InDegrees() == 0)
|
|
|
|
def test_Equality(self):
|
|
v1: Spherical = Spherical.Degrees(4, 5, 6)
|
|
|
|
v2: Spherical = Spherical.Degrees(1, 2, 3)
|
|
assert(v1 != v2)
|
|
|
|
v2 = Spherical.Degrees(4, 5, 6)
|
|
assert(v1 == v2)
|
|
|
|
def test_Magnitude(self):
|
|
v: Spherical = Spherical.Degrees(2, 30, 0)
|
|
r: float = 0
|
|
|
|
r = v.Magnitude()
|
|
assert(r == 2)
|
|
|
|
v = Spherical.Degrees(-2, -30, 0)
|
|
r = v.Magnitude()
|
|
assert(r == 2)
|
|
|
|
v = Spherical.Degrees(0, 0, 0)
|
|
r = v.Magnitude()
|
|
assert(r == 0)
|
|
|
|
def test_Normalize(self):
|
|
v1: Spherical = Spherical.Degrees(2, 90, 0)
|
|
r: Spherical = Spherical.zero
|
|
|
|
r = v1.Normalized()
|
|
assert(r == Spherical.Degrees(1, 90, 0))
|
|
|
|
v1 = Spherical.Degrees(2, -90, 0)
|
|
r = v1.Normalized()
|
|
assert(r == Spherical.Degrees(1, -90, 0))
|
|
|
|
v1 = Spherical.Degrees(0, 0, 0)
|
|
r = v1.Normalized()
|
|
assert(r == Spherical.Degrees(0, 0, 0))
|
|
|
|
def test_Negate(self):
|
|
v1: Spherical = Spherical.Degrees(2, 45, 0)
|
|
r: Spherical = Spherical.zero
|
|
|
|
r = -v1
|
|
assert(r == Spherical.Degrees(2, -135, 0))
|
|
|
|
v1 = Spherical.Degrees(2, -45, 0)
|
|
r = -v1
|
|
assert(r == Spherical.Degrees(2, 135, 0))
|
|
|
|
v1 = Spherical.Degrees(0, 0, 0)
|
|
r = -v1
|
|
assert(r == Spherical.Degrees(0, 180, 0))
|
|
|
|
def test_Subtract(self):
|
|
r: Spherical = Spherical.zero
|
|
|
|
v1: Spherical = Spherical.Degrees(4, 45, 0)
|
|
v2: Spherical = Spherical.zero
|
|
r = v1 - v2
|
|
assert(r == v1)
|
|
|
|
r = v1
|
|
r -= v2
|
|
assert(r == v1)
|
|
|
|
v2 = Spherical.Degrees(1, 45, 0)
|
|
r = v1 - v2
|
|
assert(Spherical.isclose(r, Spherical.Degrees(3, 45, 0)))
|
|
|
|
v2 = Spherical.Degrees(1, -135, 0)
|
|
r = v1 - v2
|
|
assert(r == Spherical.Degrees(5, 45, 0))
|
|
|
|
def test_Addition(self):
|
|
v1 = Spherical(1, Direction.Degrees(45, 0))
|
|
v2 = Spherical.zero
|
|
r = Spherical.zero
|
|
|
|
r = v1 + v2
|
|
assert(r.distance == v1.distance)
|
|
|
|
r = v1
|
|
r += v2
|
|
assert(r.distance == v1.distance)
|
|
|
|
v2 = Spherical(1, Direction.Degrees(-45, 0))
|
|
r = v1 + v2
|
|
assert(math.isclose(r.distance, math.sqrt(2)))
|
|
assert(Angle.isclose(r.direction.horizontal, Angle.Degrees(0)))
|
|
assert(Angle.isclose(r.direction.vertical, Angle.Degrees(0)))
|
|
|
|
v2 = Spherical(1, Direction.Degrees(0, 90))
|
|
r = v1 + v2
|
|
assert(math.isclose(r.distance, math.sqrt(2)))
|
|
assert(Angle.isclose(r.direction.horizontal, Angle.Degrees(45)))
|
|
assert(Angle.isclose(r.direction.vertical, Angle.Degrees(45)))
|
|
|
|
def test_Multiply(self):
|
|
r = Spherical.zero
|
|
|
|
v1 = Spherical.Degrees(4, 45, 0)
|
|
r = v1 * 3
|
|
assert(r == Spherical.Degrees(12, 45, 0))
|
|
|
|
r = v1 * -3
|
|
assert(r == Spherical.Degrees(12, -135, 0))
|
|
|
|
r = v1 * 0
|
|
assert(r == Spherical.Degrees(0, 0, 0))
|
|
|
|
def test_Divide(self):
|
|
r: Spherical.zero
|
|
|
|
v1 = Spherical.Degrees(4, 45, 0)
|
|
r = v1 / 2
|
|
assert(r == Spherical.Degrees(2, 45, 0))
|
|
|
|
r = v1 / -2
|
|
assert(r == Spherical.Degrees(2, -135, 0))
|
|
|
|
def test_Distance(self):
|
|
r: float = 0
|
|
|
|
v1 = Spherical.Degrees(4, 45, 0)
|
|
v2 = Spherical.Degrees(1, -135, 0)
|
|
r = Spherical.Distance(v1, v2)
|
|
assert(r == 5)
|
|
|
|
v2 = Spherical.Degrees(-1, -135, 0)
|
|
r = Spherical.Distance(v1, v2)
|
|
assert(math.isclose(r, 3))
|
|
|
|
v2 = Spherical.Degrees(0, 0, 0)
|
|
r = Spherical.Distance(v1, v2)
|
|
assert(r == 4)
|
|
|
|
def test_Angle(self):
|
|
r = Angle.zero
|
|
|
|
v1 = Spherical.Degrees(4, 45, 0)
|
|
v2 = Spherical.Degrees(1, -45, 0)
|
|
|
|
r = Spherical.Angle(v1, v2)
|
|
assert(r.InDegrees() == 90)
|
|
|
|
v2 = Spherical.Degrees(1, 135, 0)
|
|
r = Spherical.Angle(v1, v2)
|
|
assert(r.InDegrees() == 90)
|
|
|
|
v2 = Spherical.Degrees(1, 45, 0)
|
|
r = Spherical.Angle(v1, v2)
|
|
assert(r.InDegrees() == 0)
|
|
|
|
def test_SignedAngle(self):
|
|
r = Angle.zero
|
|
|
|
v1 = Spherical.Degrees(4, 45, 0)
|
|
v2 = Spherical.Degrees(1, -45, 0)
|
|
|
|
r = Spherical.SignedAngle(v1, v2, Direction.up)
|
|
assert(r.InDegrees() == -90)
|
|
|
|
v2 = Spherical.Degrees(1, 135, 0)
|
|
r = Spherical.SignedAngle(v1, v2, Direction.up)
|
|
assert(r.InDegrees() == 90)
|
|
|
|
v2 = Spherical.Degrees(1, 45, 0)
|
|
r = Spherical.SignedAngle(v1, v2, Direction.up)
|
|
assert(r.InDegrees() == 0)
|
|
|
|
def test_Lerp(self):
|
|
r = Spherical.zero
|
|
|
|
v1 = Spherical.Degrees(5, 45, 0)
|
|
v2 = Spherical.Degrees(1, -45, 0)
|
|
|
|
r = Spherical.Lerp(v1, v2, 0)
|
|
assert(r == v1)
|
|
|
|
r = Spherical.Lerp(v1, v2, 1)
|
|
assert(Spherical.isclose(r, v2))
|
|
|
|
r = Spherical.Lerp(v1, v2, 0.5)
|
|
assert(Spherical.isclose(r, Spherical.Degrees(3, 0, 0)))
|
|
|
|
r = Spherical.Lerp(v1, v2, -1)
|
|
assert(r == Spherical.Degrees(9, 135, 0))
|
|
|
|
r = Spherical.Lerp(v1, v2, 2)
|
|
assert(r == Spherical.Degrees(-3, -135, 0))
|
|
|