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)