def testUpdate(self):
"""Tests for `Database.update`.
"""
db = self.makeEmptyDatabase(origin=1)
with db.declareStaticTables(create=True) as context:
tables = context.addTableTuple(STATIC_TABLE_SPECS)
# Insert two rows into table a, both without regions.
db.insert(tables.a, {"name": "a1"}, {"name": "a2"})
# Update one of the rows with a region.
region = ConvexPolygon(
(UnitVector3d(1, 0, 0), UnitVector3d(0, 1,
0), UnitVector3d(0, 0, 1)))
n = db.update(tables.a, {"name": "k"}, {"k": "a2", "region": region})
self.assertEqual(n, 1)
sql = sqlalchemy.sql.select(
[tables.a.columns.name,
tables.a.columns.region]).select_from(tables.a)
self.assertCountEqual([dict(r) for r in db.query(sql).fetchall()],
[{
"name": "a1",
"region": None
}, {
"name": "a2",
"region": region
}])
def testYaml(self):
a = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
b = yaml.safe_load(yaml.dump(a))
self.assertEqual(a, b)
def testRelationships(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertTrue(p.contains(p.getCentroid()))
self.assertEqual(p.getBoundingCircle().relate(p), CONTAINS)
def testPickle(self):
a = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
b = pickle.loads(pickle.dumps(a, pickle.HIGHEST_PROTOCOL))
self.assertEqual(a, b)
def triangle_area(v0: sph.UnitVector3d, v1: sph.UnitVector3d,
v2: sph.UnitVector3d) -> float:
"""Calculate triangle area.
Parameters
----------
v0, v1, v2 : `lsst.sphgeom.UnitVector3d`
Returns
-------
area : `float`
"""
# sides of a triangle
arccos = math.acos
a = arccos(v1.dot(v2))
b = arccos(v0.dot(v2))
c = arccos(v0.dot(v1))
# angles
sin, cos = math.sin, math.cos
alpha = arccos((cos(a) - cos(b) * cos(c)) / (sin(b) * sin(c)))
beta = arccos((cos(b) - cos(a) * cos(c)) / (sin(a) * sin(c)))
gamma = arccos((cos(c) - cos(a) * cos(b)) / (sin(a) * sin(b)))
area = alpha + beta + gamma - math.pi
return area
def test_complement(self):
c = Circle(UnitVector3d.X(), 2.0)
d = c.complemented()
c.complement()
self.assertEqual(c, d)
self.assertEqual(c.getCenter(), -UnitVector3d.X())
self.assertEqual(c.getSquaredChordLength(), 2.0)
def test_dilation_and_erosion(self):
a = Angle(math.pi / 2)
c = Circle(UnitVector3d.X())
d = c.dilatedBy(a).erodedBy(a)
c.dilateBy(a).erodeBy(a)
self.assertEqual(c, d)
self.assertEqual(c, Circle(UnitVector3d.X()))
def testCodec(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
s = p.encode()
self.assertEqual(ConvexPolygon.decode(s), p)
self.assertEqual(Region.decode(s), p)
def test_relationships(self):
e = Ellipse(UnitVector3d.X(), Angle(math.pi / 3), Angle(math.pi / 6),
Angle(0))
self.assertTrue(e.contains(UnitVector3d.X()))
self.assertTrue(UnitVector3d.X() in e)
c = Circle(UnitVector3d.X(), Angle(math.pi / 2))
self.assertEqual(c.relate(e), CONTAINS)
self.assertEqual(e.relate(c), WITHIN)
def testArithmeticOperators(self):
self.assertEqual(-UnitVector3d.X(), UnitVector3d(-1, 0, 0))
self.assertEqual(UnitVector3d.X() - UnitVector3d.X(),
Vector3d(0, 0, 0))
self.assertEqual(UnitVector3d.X() + UnitVector3d(1, 0, 0),
UnitVector3d.X() * 2)
self.assertEqual(UnitVector3d.Y() - Vector3d(0, 0.5, 0),
UnitVector3d.Y() / 2)
self.assertEqual(UnitVector3d.Z().cwiseProduct(Vector3d(2, 3, 4)),
Vector3d(0, 0, 4))
def testString(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertEqual(str(p), repr(p))
self.assertEqual(
repr(p), 'ConvexPolygon([UnitVector3d(0.0, 0.0, 1.0), '
'UnitVector3d(1.0, 0.0, 0.0), '
'UnitVector3d(0.0, 1.0, 0.0)])')
self.assertEqual(
p,
eval(repr(p),
dict(ConvexPolygon=ConvexPolygon, UnitVector3d=UnitVector3d)))
def test_expanding_and_clipping(self):
a = Circle.empty()
b = (a.expandedTo(UnitVector3d.X()).expandedTo(
Circle(UnitVector3d.Y(),
1)).clippedTo(Circle(UnitVector3d(1, 1, 0),
1)).clippedTo(UnitVector3d.Y()))
a.expandTo(UnitVector3d.X())
a.expandTo(Circle(UnitVector3d.Y(), 1))
a.clipTo(Circle(UnitVector3d(1, 1, 0), 1))
a.clipTo(UnitVector3d.Y())
self.assertEqual(a, b)
self.assertEqual(a, Circle(UnitVector3d.Y()))
a.clipTo(UnitVector3d.Z())
self.assertTrue(a.isEmpty())
def test_construction(self):
self.assertTrue(Ellipse.empty().isEmpty())
self.assertTrue(Ellipse().isEmpty())
self.assertTrue(Ellipse.full().isFull())
e = Ellipse(Circle(UnitVector3d.X(), Angle(math.pi / 2)))
f = Ellipse(UnitVector3d.X(), Angle(math.pi / 2))
self.assertEqual(e, f)
self.assertEqual(e.getAlpha(), e.getBeta())
self.assertTrue(e.isCircle())
self.assertTrue(e.isGreatCircle())
g = Ellipse(e)
h = e.clone()
self.assertEqual(e, g)
self.assertEqual(g, h)
self.assertNotEqual(id(e), id(g))
self.assertNotEqual(id(g), id(h))
def test_construction(self):
self.assertTrue(Circle.empty().isEmpty())
self.assertTrue(Circle().isEmpty())
self.assertTrue(Circle.full().isFull())
c = Circle(UnitVector3d.X())
self.assertEqual(c.getOpeningAngle(), Angle(0))
self.assertEqual(c.getSquaredChordLength(), 0)
c = Circle(UnitVector3d.Z(), 2.0)
self.assertTrue(c.contains(UnitVector3d.Z()))
c = Circle(UnitVector3d.Z(), Angle(math.pi))
self.assertTrue(c.isFull())
d = c.clone()
self.assertEqual(c, d)
self.assertNotEqual(id(c), id(d))
e = Circle(d)
self.assertEqual(d, e)
def _makePixelRanges():
"""Generate pixel ID ranges for some envelope region"""
pointing_v = UnitVector3d(1., 1., -1.)
fov = 0.05 # radians
region = Circle(pointing_v, Angle(fov / 2))
pixelator = HtmPixelization(HTM_LEVEL)
indices = pixelator.envelope(region, 128)
return indices.ranges()
def testRelationships(self):
p = ConvexPolygon(
[UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertTrue(p.contains(p.getCentroid()))
boundingCircle = p.getBoundingCircle()
self.assertEqual(boundingCircle.relate(p), CONTAINS)
self.assertTrue(p.isWithin(boundingCircle))
self.assertTrue(p.intersects(boundingCircle))
self.assertFalse(p.isDisjointFrom(boundingCircle))
self.assertFalse(p.contains(boundingCircle))
tinyCircle = Circle(boundingCircle.getCenter())
self.assertFalse(p.isWithin(tinyCircle))
self.assertTrue(p.intersects(tinyCircle))
self.assertFalse(p.isDisjointFrom(tinyCircle))
self.assertTrue(p.contains(tinyCircle))
def testConstruction(self):
points = [UnitVector3d.Z(), UnitVector3d.X(), UnitVector3d.Y()]
p1 = ConvexPolygon(points)
self.assertEqual(points, p1.getVertices())
p2 = p1.clone()
self.assertEqual(p1, p2)
p3 = ConvexPolygon(
[-UnitVector3d.Z(),
UnitVector3d.X(),
UnitVector3d.Y()])
self.assertNotEqual(p1, p3)
p4 = ConvexPolygon.convexHull([
UnitVector3d.Y(),
UnitVector3d.X(),
UnitVector3d(1, 1, 1),
UnitVector3d.Z()
])
self.assertEqual(p1, p4)
def testConstruction(self):
a1 = NormalizedAngle(1.0)
a2 = NormalizedAngle.fromRadians(1.0)
a3 = NormalizedAngle.fromDegrees(57.29577951308232)
self.assertEqual(a1, a2)
self.assertEqual(a1.asRadians(), 1.0)
self.assertEqual(a1, a3)
self.assertEqual(a1.asDegrees(), 57.29577951308232)
self.assertEqual(
NormalizedAngle.between(NormalizedAngle(0), NormalizedAngle(1)),
NormalizedAngle(1))
a = NormalizedAngle.center(NormalizedAngle(0), NormalizedAngle(1))
self.assertAlmostEqual(a.asRadians(), 0.5, places=15)
a = NormalizedAngle(LonLat.fromDegrees(45, 0),
LonLat.fromDegrees(90, 0))
self.assertAlmostEqual(a.asDegrees(), 45.0, places=13)
a = NormalizedAngle(UnitVector3d.Y(), UnitVector3d.Z())
self.assertAlmostEqual(a.asDegrees(), 90.0, places=13)
def test_string(self):
c = Circle(UnitVector3d.Z(), Angle(1.0))
self.assertEqual(str(c), 'Circle([0.0, 0.0, 1.0], 1.0)')
self.assertEqual(repr(c),
'Circle(UnitVector3d(0.0, 0.0, 1.0), Angle(1.0))')
self.assertEqual(
c,
eval(repr(c),
dict(Angle=Angle, Circle=Circle, UnitVector3d=UnitVector3d)))
def test_envelope_and_interior(self):
pixelization = Mq3cPixelization(1)
c = Circle(UnitVector3d(1.0, -0.5, -0.5), Angle.fromDegrees(0.1))
rs = pixelization.envelope(c)
self.assertTrue(rs == RangeSet(44))
rs = pixelization.envelope(c, 1)
self.assertTrue(rs == RangeSet(44))
self.assertTrue(rs.isWithin(pixelization.universe()))
rs = pixelization.interior(c)
self.assertTrue(rs.empty())
def testConstruction(self):
v = Vector3d(1, 1, 1)
u = UnitVector3d.orthogonalTo(v)
self.assertAlmostEqual(u.dot(v), 0.0, places=15)
u = UnitVector3d(1, 1, 1)
self.assertEqual(u, UnitVector3d(Vector3d(1, 1, 1)))
self.assertAlmostEqual(u.x(), math.sqrt(3.0) / 3.0, places=15)
self.assertAlmostEqual(u.y(), math.sqrt(3.0) / 3.0, places=15)
self.assertAlmostEqual(u.z(), math.sqrt(3.0) / 3.0, places=15)
u = UnitVector3d(Angle.fromDegrees(45), Angle.fromDegrees(45))
self.assertEqual(u, UnitVector3d(LonLat.fromDegrees(45, 45)))
self.assertAlmostEqual(u.x(), 0.5, places=15)
self.assertAlmostEqual(u.y(), 0.5, places=15)
self.assertAlmostEqual(u.z(), 0.5 * math.sqrt(2.0), places=15)
u = UnitVector3d.northFrom(u.asVector3d())
w = UnitVector3d(LonLat.fromDegrees(225, 45))
self.assertAlmostEqual(u.x(), w.x(), places=15)
self.assertAlmostEqual(u.y(), w.y(), places=15)
self.assertAlmostEqual(u.z(), w.z(), places=15)
def test_envelope_and_interior(self):
pixelization = HtmPixelization(3)
c = Circle(UnitVector3d(1, 1, 1), Angle.fromDegrees(0.1))
rs = pixelization.envelope(c)
self.assertTrue(rs == RangeSet(0x3ff))
rs = pixelization.envelope(c, 1)
self.assertTrue(rs == RangeSet(0x3ff))
self.assertTrue(rs.isWithin(pixelization.universe()))
rs = pixelization.interior(c)
self.assertTrue(rs.empty())
def testReplace(self):
"""Tests for `Database.replace`.
"""
db = self.makeEmptyDatabase(origin=1)
with db.declareStaticTables(create=True) as context:
tables = context.addTableTuple(STATIC_TABLE_SPECS)
# Use 'replace' to insert a single row that contains a region and
# query to get it back.
region = ConvexPolygon(
(UnitVector3d(1, 0, 0), UnitVector3d(0, 1,
0), UnitVector3d(0, 0, 1)))
row1 = {"name": "a1", "region": region}
db.replace(tables.a, row1)
self.assertEqual(
[dict(r) for r in db.query(tables.a.select()).fetchall()], [row1])
# Insert another row without a region.
row2 = {"name": "a2", "region": None}
db.replace(tables.a, row2)
self.assertCountEqual(
[dict(r) for r in db.query(tables.a.select()).fetchall()],
[row1, row2])
# Use replace to re-insert both of those rows again, which should do
# nothing.
db.replace(tables.a, row1, row2)
self.assertCountEqual(
[dict(r) for r in db.query(tables.a.select()).fetchall()],
[row1, row2])
# Replace row1 with a row with no region, while reinserting row2.
row1a = {"name": "a1", "region": None}
db.replace(tables.a, row1a, row2)
self.assertCountEqual(
[dict(r) for r in db.query(tables.a.select()).fetchall()],
[row1a, row2])
# Replace both rows, returning row1 to its original state, while adding
# a new one. Pass them in in a different order.
row2a = {"name": "a2", "region": region}
row3 = {"name": "a3", "region": None}
db.replace(tables.a, row3, row2a, row1)
self.assertCountEqual(
[dict(r) for r in db.query(tables.a.select()).fetchall()],
[row1, row2a, row3])
def test_index_to_string(self):
strings = ['+X', '+Y', '+Z', '-X', '-Y', '-Z']
for i in range(6):
s = strings[i]
components = [0.0] * 3
components[i % 3] = 1.0 if i < 3 else -1.0
v = UnitVector3d(*components)
f = Q3cPixelization(0).index(v)
self.assertEqual(Q3cPixelization(0).toString(f), s)
for j in range(4):
self.assertEqual(
Q3cPixelization(1).toString(f * 4 + j), s + str(j))
def test_string(self):
c = Ellipse(UnitVector3d.Z(), Angle(1.0))
self.assertEqual(str(c),
'Ellipse([0.0, 0.0, 1.0], [0.0, 0.0, 1.0], 1.0)')
self.assertEqual(
repr(c), 'Ellipse(UnitVector3d(0.0, 0.0, 1.0), '
'UnitVector3d(0.0, 0.0, 1.0), Angle(1.0))')
self.assertEqual(
c,
eval(repr(c),
dict(Angle=Angle, Ellipse=Ellipse,
UnitVector3d=UnitVector3d)))
def testAccess(self):
v = UnitVector3d.X()
self.assertEqual(len(v), 3)
self.assertEqual(v[0], 1)
self.assertEqual(v[1], 0)
self.assertEqual(v[2], 0)
self.assertEqual(v[-3], 1)
self.assertEqual(v[-2], 0)
self.assertEqual(v[-1], 0)
with self.assertRaises(IndexError):
v[-4]
with self.assertRaises(IndexError):
v[3]
def test_center_and_dimensions(self):
e = Ellipse(UnitVector3d.X(), UnitVector3d.Y(), Angle(2 * math.pi / 3))
self.assertAlmostEqual(e.getF1().dot(UnitVector3d.X()), 1.0)
self.assertAlmostEqual(e.getF2().dot(UnitVector3d.Y()), 1.0)
self.assertAlmostEqual(e.getAlpha(), Angle(2 * math.pi / 3))
f = Ellipse(UnitVector3d.X(), Angle(math.pi / 3), Angle(math.pi / 6),
Angle(0))
self.assertEqual(f.getCenter(), UnitVector3d.X())
def testConstruction(self):
p = LonLat.fromDegrees(45, 45)
self.assertEqual(p, LonLat(NormalizedAngle.fromDegrees(45),
Angle.fromDegrees(45)))
u = UnitVector3d(p)
q = LonLat(u)
self.assertAlmostEqual(
p.getLon().asRadians(), q.getLon().asRadians(), places=13)
self.assertAlmostEqual(
p.getLat().asRadians(), q.getLat().asRadians(), places=13)
self.assertAlmostEqual(p.getLon().asRadians(),
LonLat.latitudeOf(u).asRadians(),
places=13)
self.assertAlmostEqual(p.getLon().asRadians(),
LonLat.longitudeOf(u).asRadians(),
places=13)
def test_relationships(self):
c = Circle(UnitVector3d.X(), Angle.fromDegrees(0.1))
d = Circle(UnitVector3d(1, 1, 1), Angle(math.pi / 2))
e = Circle(-UnitVector3d.X())
self.assertTrue(c.contains(UnitVector3d.X()))
self.assertTrue(UnitVector3d.X() in c)
self.assertTrue(d.contains(c))
self.assertTrue(c.isWithin(d))
self.assertTrue(c.intersects(d))
self.assertTrue(c.intersects(UnitVector3d.X()))
self.assertTrue(e.isDisjointFrom(d))
self.assertEqual(d.relate(c), CONTAINS)
self.assertEqual(e.relate(d), DISJOINT)
def test_relationships(self):
b1 = Box.fromDegrees(90, 0, 180, 45)
p = LonLat.fromDegrees(135, 10)
self.assertTrue(p in b1)
self.assertTrue(b1.contains(p))
b2 = Box.fromDegrees(135, 15, 135, 30)
self.assertTrue(b1.contains(b2))
self.assertTrue(b2.isWithin(b1))
b3 = Box.fromDegrees(0, -45, 90, 0)
u = UnitVector3d(1, 1, -1)
self.assertTrue(b1.intersects(b3))
self.assertTrue(u in b3)
self.assertTrue(b3.contains(u))
b4 = Box.fromDegrees(200, 10, 300, 20)
self.assertTrue(b1.isDisjointFrom(b4))
r = b1.relate(LonLat.fromDegrees(135, 10))
self.assertEqual(r, CONTAINS)
r = b4.relate(b1)
self.assertEqual(r, DISJOINT)
def testConstruction(self):
v = Vector3d(1, 1, 1)
u = UnitVector3d.orthogonalTo(v)
self.assertAlmostEqual(u.dot(v), 0.0, places=15)
a = UnitVector3d(1, 1, 1)
self.assertEqual(a, UnitVector3d(Vector3d(1, 1, 1)))
self.assertAlmostEqual(a.x(), math.sqrt(3.0) / 3.0, places=15)
self.assertAlmostEqual(a.y(), math.sqrt(3.0) / 3.0, places=15)
self.assertAlmostEqual(a.z(), math.sqrt(3.0) / 3.0, places=15)
b = UnitVector3d(Angle.fromDegrees(45), Angle.fromDegrees(45))
self.assertEqual(b, UnitVector3d(LonLat.fromDegrees(45, 45)))
self.assertAlmostEqual(b.x(), 0.5, places=15)
self.assertAlmostEqual(b.y(), 0.5, places=15)
self.assertAlmostEqual(b.z(), 0.5 * math.sqrt(2.0), places=15)
c = UnitVector3d.northFrom(b)
d = UnitVector3d(LonLat.fromDegrees(225, 45))
self.assertAlmostEqual(c.x(), d.x(), places=15)
self.assertAlmostEqual(c.y(), d.y(), places=15)
self.assertAlmostEqual(c.z(), d.z(), places=15)
