def testPositions(self):
# Create a new positions
v = czml.Positions()
l = geometry.LineString([(0, 0), (1, 1)])
r = geometry.LinearRing([(0, 0), (1, 1), (1, 0), (0, 0)])
ext = [(0, 0), (0, 2), (2, 2), (2, 0), (0, 0)]
int_1 = [(0.5, 0.25), (1.5, 0.25), (1.5, 1.25), (0.5, 1.25),
(0.5, 0.25)]
int_2 = [(0.5, 1.25), (1, 1.25), (1, 1.75), (0.5, 1.75), (0.5, 1.25)]
p = geometry.Polygon(ext, [int_1, int_2])
v.cartesian = l
v.cartographicDegrees = r
v.cartographicRadians = p
self.assertEqual(
v.data(), {
'cartesian': [0.0, 0.0, 0, 1.0, 1.0, 0],
'cartographicRadians': [
0.0, 0.0, 0, 0.0, 2.0, 0, 2.0, 2.0, 0, 2.0, 0.0, 0, 0.0,
0.0, 0
],
'cartographicDegrees':
[0.0, 0.0, 0, 1.0, 1.0, 0, 1.0, 0.0, 0, 0.0, 0.0, 0]
})
# Modify an existing positions
v.cartesian = None
v.cartographicDegrees = None
v.cartographicRadians = [0.0, 0.0, .0, 1.0, 1.0, 1.0]
self.assertEqual(
v.data(), {'cartographicRadians': [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]})
# Create a new positions from an existing positions
v2 = czml.Positions()
v2.loads(v.dumps())
self.assertEqual(v.data(), v2.data())
coordinates = []
current_time = datetime.datetime(year=2020, month=1, day=1, hour=12)
for segment in segments:
points_db.append(segment.points)
for point in segment.points:
flat_points.append(point)
coordinates.append(current_time)
coordinates.append(segment.lat)
coordinates.append(segment.long)
coordinates.append(0)
current_time += datetime.timedelta(minutes=180)
#
#
packet = czml.CZMLPacket(id=f"train", status="moving")
positions = czml.Positions(cartographicDegrees=flat_points)
packet.position = czml.Position(cartographicDegrees=coordinates)
print((points_db[0][-1], points_db[0][-2], 0))
print(points_db[0])
bb = czml.Billboard(scale=0.1, show=True)
bb.image = "https://terriamap.iorama.geosynergy.com.au/train_express.png"
bb.color = {'rgba': [255, 255, 255, 255]}
packet.billboard = bb
doc.packets.append(packet)
for index, rail in enumerate(payload):
# rail = segment.rail
positions = multilinestring_to_positions(rail, False, index)
packet = czml.CZMLPacket(
def testPolygon(self):
# Create a new polygon
img = czml.Image(image='http://localhost/img.png', repeat=2)
mat = czml.Material(image=img)
pts = geometry.LineString([(50, 20, 2), (60, 30, 3), (50, 30, 4),
(60, 20, 5)])
pos = czml.Positions(cartographicDegrees=pts)
col = {'rgba': [0, 255, 127, 55]}
pol = czml.Polygon(show=True,
material=mat,
positions=pos,
perPositionHeight=True,
fill=True,
outline=True,
outlineColor=col)
self.assertEqual(
pol.data(), {
'show': True,
'fill': True,
'outline': True,
'perPositionHeight': True,
'outlineColor': {
'rgba': [0, 255, 127, 55]
},
'material': {
'image': {
'image': 'http://localhost/img.png',
'repeat': 2
},
},
'positions': {
'cartographicDegrees':
[50, 20, 2, 60, 30, 3, 50, 30, 4, 60, 20, 5]
},
})
# Create a new polygon from an existing polygon
pol2 = czml.Polygon()
pol2.loads(pol.dumps())
self.assertEqual(pol2.data(), pol.data())
# Modify an existing polygon
grid = czml.Grid(color={'rgba': [0, 55, 127, 255]},
cellAlpha=0.4,
lineCount=5,
lineThickness=2,
lineOffset=0.3)
mat2 = czml.Material(grid=grid)
pts2 = geometry.LineString([(1.5, 1.2, 0), (1.6, 1.3, 0),
(1.5, 1.3, 0), (1.6, 1.2, 0)])
pos2 = czml.Positions(cartographicRadians=pts2)
pol2.material = mat2
pol2.positions = pos2
pol2.perPositionHeight = False
pol2.height = 7
pol2.extrudedHeight = 30
self.assertEqual(
pol2.data(), {
'show': True,
'fill': True,
'outline': True,
'perPositionHeight': False,
'height': 7,
'extrudedHeight': 30,
'outlineColor': {
'rgba': [0, 255, 127, 55]
},
'material': {
'grid': {
'color': {
'rgba': [0, 55, 127, 255]
},
'cellAlpha': 0.4,
'lineCount': 5,
'lineThickness': 2,
'lineOffset': 0.3
},
},
'positions': {
'cartographicRadians':
[1.5, 1.2, 0, 1.6, 1.3, 0, 1.5, 1.3, 0, 1.6, 1.2, 0]
},
})
# Add a polygon to a CZML packet
packet = czml.CZMLPacket(id='abc')
packet.polygon = pol2
self.assertEqual(
packet.data(), {
'id': 'abc',
'polygon': {
'show': True,
'fill': True,
'outline': True,
'perPositionHeight': False,
'height': 7,
'extrudedHeight': 30,
'outlineColor': {
'rgba': [0, 255, 127, 55]
},
'material': {
'grid': {
'color': {
'rgba': [0, 55, 127, 255]
},
'cellAlpha': 0.4,
'lineCount': 5,
'lineThickness': 2,
'lineOffset': 0.3
},
},
'positions': {
'cartographicRadians':
[1.5, 1.2, 0, 1.6, 1.3, 0, 1.5, 1.3, 0, 1.6, 1.2, 0]
},
},
})
def testPolyline(self):
# Create a new polyline
sc = czml.SolidColor(color={'rgba': [0, 255, 127, 55]})
m1 = czml.Material(solidColor=sc)
c1 = geometry.LineString([(-162, 41, 0), (-151, 43, 0), (-140, 45, 0)])
v1 = czml.Positions(cartographicDegrees=c1)
p1 = czml.Polyline(show=True,
width=5,
followSurface=False,
material=m1,
positions=v1)
self.assertEqual(
p1.data(), {
'show': True,
'width': 5,
'followSurface': False,
'material': {
'solidColor': {
'color': {
'rgba': [0, 255, 127, 55]
}
},
},
'positions': {
'cartographicDegrees':
[-162, 41, 0, -151, 43, 0, -140, 45, 0]
},
})
# Create a new polyline
pg = czml.PolylineGlow(color={'rgba': [0, 255, 127, 55]},
glowPower=0.25)
m2 = czml.Material(polylineGlow=pg)
c2 = geometry.LineString([(1.6, 5.3, 10), (2.4, 4.2, 20),
(3.8, 3.1, 30)])
v2 = czml.Positions(cartographicRadians=c2)
p2 = czml.Polyline(show=False,
width=7,
followSurface=True,
material=m2,
positions=v2)
self.assertEqual(
p2.data(), {
'show': False,
'width': 7,
'followSurface': True,
'material': {
'polylineGlow': {
'color': {
'rgba': [0, 255, 127, 55]
},
'glowPower': 0.25
},
},
'positions': {
'cartographicRadians':
[1.6, 5.3, 10, 2.4, 4.2, 20, 3.8, 3.1, 30]
},
})
# Create a polyline from an existing polyline
p3 = czml.Polyline()
p3.loads(p2.dumps())
self.assertEqual(p3.data(), p2.data())
# Modify an existing polyline
po = czml.PolylineOutline(color={'rgba': [0, 255, 127, 55]},
outlineColor={'rgba': [0, 55, 127, 255]},
outlineWidth=4)
m3 = czml.Material(polylineOutline=po)
c3 = geometry.LineString([(1000, 7500, 90), (2000, 6500, 50),
(3000, 5500, 20)])
v3 = czml.Positions(cartesian=c3)
p3.material = m3
p3.positions = v3
self.assertEqual(
p3.data(), {
'show': False,
'width': 7,
'followSurface': True,
'material': {
'polylineOutline': {
'color': {
'rgba': [0, 255, 127, 55]
},
'outlineColor': {
'rgba': [0, 55, 127, 255]
},
'outlineWidth': 4
},
},
'positions': {
'cartesian':
[1000, 7500, 90, 2000, 6500, 50, 3000, 5500, 20]
},
})
# Add a polyline to a CZML packet
packet = czml.CZMLPacket(id='abc')
packet.polyline = p3
self.assertEqual(
packet.data(), {
'id': 'abc',
'polyline': {
'show': False,
'width': 7,
'followSurface': True,
'material': {
'polylineOutline': {
'color': {
'rgba': [0, 255, 127, 55]
},
'outlineColor': {
'rgba': [0, 55, 127, 255]
},
'outlineWidth': 4
},
},
'positions': {
'cartesian':
[1000, 7500, 90, 2000, 6500, 50, 3000, 5500, 20]
},
},
})
def czml(self):
doc = czml.CZML();
iso = self.date.isoformat()
# Generate time-specific lists for various objects
central_polyline_degrees = []
north_polyline_degrees = []
south_polyline_degrees = []
ellipse_position = []
ellipse_semiMajorAxis = []
ellipse_semiMinorAxis = []
ellipse_rotation = []
for t in range(len(self.time)):
time = iso + "T" + self.time[t] + ":00Z"
# Define polyline waypoints only where data exist
if self.position['north'][t] != None:
north_polyline_degrees += [self.position['north'][t][0], self.position['north'][t][1], 0.0]
if self.position['central'][t] != None:
central_polyline_degrees += [self.position['central'][t][0], self.position['central'][t][1], 0.0]
if self.position['south'][t] != None:
south_polyline_degrees += [self.position['south'][t][0], self.position['south'][t][1], 0.0]
# Define ellipse positions and attributes for every time in the interval, using limits where necessary
use_limit = min(int(math.floor(t/(len(self.time)/2))),1)
if self.position['north'][t] == None:
north = self.limits['north'][use_limit]
else:
north = self.position['north'][t]
if self.position['central'][t] == None:
central = self.limits['central'][use_limit]
else:
central = self.position['central'][t]
if self.position['south'][t] == None:
south = self.limits['south'][use_limit]
else:
south = self.position['south'][t]
# Approximate ellipse semiMajorAxis from vincenty distance between limit polylines
north2 = (north[1], north[0])
south2 = (south[1], south[0])
semi_major_axis = vincenty(north2, south2).meters / 2
# Approximate elipse semiMinorAxis from sun altitude (probably way wrong!)
ellipse_axis_ratio = self.sun_altitude[t] / 90
semi_minor_axis = semi_major_axis * ellipse_axis_ratio
# Approximate ellipse rotation using basic spheroid (TODO: replace with WGS-84)
# Calculate bearing in both directions and average them
nlat = north[1]/180 * math.pi;
nlon = north[0]/180 * math.pi;
clat = central[1]/180 * math.pi;
clon = central[0]/180 * math.pi;
slat = south[1]/180 * math.pi;
slon = south[0]/180 * math.pi;
y = math.sin(slon-nlon) * math.cos(slat);
x = math.cos(nlat) * math.sin(slat) - math.sin(nlat) * math.cos(slat) * math.cos(slon-nlon);
initial_bearing = math.atan2(y, x)
if (initial_bearing < 0):
initial_bearing += math.pi * 2
y = math.sin(nlon-slon) * math.cos(nlat);
x = math.cos(slat) * math.sin(nlat) - math.sin(slat) * math.cos(nlat) * math.cos(nlon-slon);
final_bearing = math.atan2(y, x) - math.pi
if (final_bearing < 0):
final_bearing += math.pi * 2
rotation = -1 * ((initial_bearing + final_bearing) / 2 - (math.pi / 2))
ellipse_position += [time, central[0], central[1], 0.0]
ellipse_semiMajorAxis += [time, round(semi_major_axis, 3)]
ellipse_semiMinorAxis += [time, round(semi_minor_axis, 3)]
ellipse_rotation += [time, round(rotation, 3)]
# Generate document packet with clock
start_time = iso + "T" + self.time[0] + ":00Z"
end_time = iso + "T" + self.time[-1] + ":00Z"
packet = czml.CZMLPacket(id='document',version='1.0')
c = czml.Clock()
c.multiplier = 300
c.range = "LOOP_STOP"
c.step = "SYSTEM_CLOCK_MULTIPLIER"
c.currentTime = start_time
c.interval = start_time + "/" + end_time
packet.clock = c
doc.packets.append(packet)
# Generate a polyline packet for the north and south polylines, connected and filled
limit_polyline_degrees = list(north_polyline_degrees)
point = len(south_polyline_degrees)/3
while (point > 0):
offset = (point-1) * 3
limit_polyline_degrees += [ south_polyline_degrees[offset],
south_polyline_degrees[offset+1],
south_polyline_degrees[offset+2] ]
point -= 1
packet_id = iso + '_bounds_polygon'
packet = czml.CZMLPacket(id=packet_id)
boc = czml.Color(rgba=(232, 72, 68, 255))
bsc = czml.SolidColor(color=czml.Color(rgba=(0, 0, 0, 66)))
bmat = czml.Material(solidColor=bsc)
bdeg = limit_polyline_degrees
bpos = czml.Positions(cartographicDegrees=bdeg)
bpg = czml.Polygon(show=True, height=0, outline=True, outlineColor=boc, outlineWidth=2, material=bmat, positions=bpos)
packet.polygon = bpg
doc.packets.append(packet)
# Generate central polyline packet
packet_id = iso + '_central_polyline'
packet = czml.CZMLPacket(id=packet_id)
csc = czml.SolidColor(color=czml.Color(rgba=(241, 226, 57, 255)))
cmat = czml.Material(solidColor=csc)
cpos = czml.Positions(cartographicDegrees=central_polyline_degrees)
cpl = czml.Polyline(show=True, width=4, followSurface=True, material=cmat, positions=cpos)
packet.polyline = cpl
doc.packets.append(packet)
# Generate ellipse shadow packet
packet_id = iso + '_shadow_ellipse'
packet = czml.CZMLPacket(id=packet_id)
esc = czml.SolidColor(color=czml.Color(rgba=(0, 0, 0, 160)))
emat = czml.Material(solidColor=esc)
xmaj = czml.Number(ellipse_semiMajorAxis)
xmin = czml.Number(ellipse_semiMinorAxis)
rot = czml.Number(ellipse_rotation)
ell = czml.Ellipse(show=True, fill=True, granularity=0.002, material=emat, semiMajorAxis=xmaj, semiMinorAxis=xmin, rotation=rot)
packet.ellipse = ell
packet.position = czml.Position(cartographicDegrees=ellipse_position)
doc.packets.append(packet)
return list(doc.data())