def testPosition(self):
pos = czml.Position()
now = datetime.now()
pos.epoch = now
coords = [7.0, 0.0, 1.0, 2.0, 6.0, 3.0, 4.0, 5.0]
pos.cartographicRadians = coords
self.assertEqual(pos.data()['cartographicRadians'],
coords)
js = {'epoch': now.isoformat(), 'cartographicRadians': coords}
self.assertEqual(pos.data(), js)
self.assertEqual(pos.dumps(), json.dumps(js))
pos.cartographicDegrees = coords
self.assertEqual(pos.data()['cartographicDegrees'],
coords)
pos.cartesian = coords
self.assertEqual(pos.data()['cartesian'],
coords)
pos2 = czml.Position()
pos2.loads(pos.dumps())
self.assertEqual(pos.data(), pos2.data())
def _filter_users_criteria(filters):
try:
users = db.session.query(Users.userid, Users.userpos,
func.length(Users.userpos),
func.twAvg(func.speed(Users.userpos))).filter(
*filters, ).all()
except:
traceback.print_exc()
return jsonify({"errors": [DATA_UNINITIALIZED_ERROR]}), 400
# Import the library
from czml import czml
# Initialize a document
doc = czml.CZML()
# Create and append the document packet
packet1 = czml.CZMLPacket(id='document', version='1.0')
doc.packets.append(packet1)
# Create and append a POINT packet
packet3 = czml.CZMLPacket()
for user_id, user, distance, speed in users:
packet3.id = user_id
pp = czml.Point()
pp.color = {'rgba': [0, 255, 127, 55]}
pp.outlineColor = {'rgba': [255, 0, 0, 128]}
#varPos = czml.Position(cartographicDegrees=[2020-06-04T16:00:00Z,-56.189652081027,-34.8888227843656,0,2020-06-04T16:05:00Z,-56.189652081027,-34.8888227843656,0])
pos = czml.Position()
#coords = ['2020-06-04T16:00:00Z','-56.189652081027','-34.8888227843656','0','2020-06-04T16:05:00Z','-56.189652081027','-34.8888227843656','0']
coords = serialize_trajectory(user)
pos.epoch = coords['epoch']
pos.cartographicDegrees = coords['cartographicDegrees']
#varPos.cartographicDegrees = [2020-06-04T16:00:00Z,-56.189652081027,-34.8888227843656,0,2020-06-04T16:05:00Z,-56.189652081027,-34.8888227843656,0]
#trayectoria = Path(pos,pp)
packet3.position = pos
packet3.point = pp
#Path(pos, pp)
#packet3.path = trayectoria
#pp.Position = Position(varPos)
doc.packets.append(packet3)
# Write the CZML document to a file
filename = "example.czml"
doc.write(filename)
return jsonify({
"users": [{
"id": user_id,
"trajectory": serialize_trajectory(user),
"distance": distance,
"speed": speed,
} for user_id, user, distance, speed in users]
})
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(
id=rail['segment'].lower().replace(' ', ""),
status="t") #id=str(random.randint(0, 99999)), name=rail['segment'])
def testCZMLPacket(self):
p = czml.CZMLPacket(id='abc')
self.assertEqual(p.dumps(), '{"id": "abc"}')
bb = czml.Billboard()
bb.image = 'http://localhost/img.png'
bb.scale = 0.7
bb.show = True
p.billboard = bb
self.assertEqual(p.data(),
{'billboard': {'image': 'http://localhost/img.png',
'scale': 0.7, 'show': True}, 'id': 'abc'})
p2 = czml.CZMLPacket(id='abc')
p2.loads(p.dumps())
self.assertEqual(p.data(), p2.data())
pos = czml.Position()
coords = [7.0, 0.0, 1.0, 2.0, 6.0, 3.0, 4.0, 5.0]
pos.cartesian = coords
p.position = pos
l = czml.Label()
l.text = 'test label'
l.show = False
p.label = l
self.assertEqual(p.data(),
{'billboard': {'image': 'http://localhost/img.png',
'scale': 0.7, 'show': True}, 'id': 'abc',
'label': {'show': False, 'text': 'test label'},
'position': {'cartesian': [7.0, 0.0, 1.0, 2.0, 6.0, 3.0, 4.0, 5.0]},
})
p2.loads(p.dumps())
self.assertEqual(p.data(), p2.data())
p3 = czml.CZMLPacket(id='cde')
p3.point = {'color':
{'rgba': [0, 255, 127, 55]},
'show': True}
self.assertEqual(p3.data(), {'id': 'cde',
'point': {'color':
{'rgba': [0, 255, 127, 55]},
'show': True}})
p32 = czml.CZMLPacket(id='abc')
p32.loads(p3.dumps())
self.assertEqual(p3.data(), p32.data())
p4 = czml.CZMLPacket(id='defg')
pl = czml.Polyline()
pl.color = {'rgba': [0, 255, 127, 55]}
pl.width = 10
pl.outlineWidth = 2
pl.show = True
v = czml.VertexPositions()
v.cartographicDegrees = [0.0, 0.0, .0, 1.0, 1.0, 1.0]
p4.vertexPositions = v
p4.polyline = pl
self.assertEqual(p4.data(),
{'polyline':
{'color': {'rgba': [0, 255, 127, 55]},
'width': 10,
'outlineWidth': 2,
'show': True},
'id': 'defg',
'vertexPositions':
{'cartographicDegrees':
[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]}
})
p42 = czml.CZMLPacket(id='abc')
p42.loads(p4.dumps())
self.assertEqual(p4.data(), p42.data())
p5 = czml.CZMLPacket(id='efgh')
p5.vertexPositions = v
poly = czml.Polygon(color={'rgba': [0, 255, 127, 55]})
p5.polygon = poly
self.assertEqual(p5.data(),
{'polygon':
{'material':
{'solidColor':
{'color':
{'rgba': [0, 255, 127, 55]}}}},
'id': 'efgh',
'vertexPositions':
{'cartographicDegrees':
[0.0, 0.0, 0.0, 1.0, 1.0, 1.0]}})
p52 = czml.CZMLPacket(id='abc')
p52.loads(p5.dumps())
self.assertEqual(p5.data(), p52.data())
return p
def testPath(self):
# Create a new path
sc = czml.SolidColor(color={'rgba': [0, 255, 127, 55]})
m1 = czml.Material(solidColor=sc)
c1 = [0, -62, 141, 0, 2, -51, 143, 0, 4, -40, 145, 0]
v1 = czml.Position(cartographicDegrees=c1)
p1 = czml.Path(show=True,
width=5,
leadTime=2,
trailTime=6,
resolution=3,
material=m1,
position=v1)
self.assertEqual(
p1.data(), {
'show': True,
'width': 5,
'leadTime': 2,
'trailTime': 6,
'resolution': 3,
'material': {
'solidColor': {
'color': {
'rgba': [0, 255, 127, 55]
}
},
},
'position': {
'cartographicDegrees':
[0, -62, 141, 0, 2, -51, 143, 0, 4, -40, 145, 0]
},
})
# Create a new path from an existing path
p2 = czml.Path()
p2.loads(p1.dumps())
self.assertEqual(p2.data(), p1.data())
# Modify an existing path
po = czml.PolylineOutline(color={'rgba': [0, 255, 127, 55]},
outlineColor={'rgba': [0, 55, 127, 255]},
outlineWidth=4)
m2 = czml.Material(polylineOutline=po)
c2 = [0, 1000, 7500, 90, 4, 2000, 6500, 50, 8, 3000, 5500, 20]
v2 = czml.Position(cartesian=c2)
p2.show = False
p2.material = m2
p2.position = v2
self.assertEqual(
p2.data(), {
'show': False,
'width': 5,
'leadTime': 2,
'trailTime': 6,
'resolution': 3,
'material': {
'polylineOutline': {
'color': {
'rgba': [0, 255, 127, 55]
},
'outlineColor': {
'rgba': [0, 55, 127, 255]
},
'outlineWidth': 4
},
},
'position': {
'cartesian':
[0, 1000, 7500, 90, 4, 2000, 6500, 50, 8, 3000, 5500, 20]
},
})
# Add a path to a CZML packet
packet = czml.CZMLPacket(id='abc')
packet.path = p2
self.assertEqual(
packet.data(), {
'id': 'abc',
'path': {
'show': False,
'width': 5,
'leadTime': 2,
'trailTime': 6,
'resolution': 3,
'material': {
'polylineOutline': {
'color': {
'rgba': [0, 255, 127, 55]
},
'outlineColor': {
'rgba': [0, 55, 127, 255]
},
'outlineWidth': 4
},
},
'position': {
'cartesian': [
0, 1000, 7500, 90, 4, 2000, 6500, 50, 8, 3000,
5500, 20
]
},
},
})
def testEllipse(self):
# Create a new ellipse
sc = czml.SolidColor(color={'rgba': [127, 127, 127, 255]})
mat1 = czml.Material(solidColor=sc)
pts1 = [50, 20, 2]
pos1 = czml.Position(cartographicDegrees=pts1)
ell1 = czml.Ellipse(show=True,
fill=True,
height=50,
extrudedHeight=200,
outline=True,
outlineColor={'rgba': [0, 255, 127, 55]},
semiMajorAxis=150,
semiMinorAxis=75,
numberOfVerticalLines=800,
rotation=1.2,
material=mat1,
position=pos1)
self.assertEqual(
ell1.data(), {
'show': True,
'fill': True,
'outline': True,
'height': 50,
'extrudedHeight': 200,
'rotation': 1.2,
'semiMajorAxis': 150,
'semiMinorAxis': 75,
'numberOfVerticalLines': 800,
'outlineColor': {
'rgba': [0, 255, 127, 55]
},
'material': {
'solidColor': {
'color': {
'rgba': [127, 127, 127, 255]
}
},
},
'position': {
'cartographicDegrees': [50, 20, 2]
},
})
# Create a new ellipse from an existing ellipse
ell2 = czml.Ellipse()
ell2.loads(ell1.dumps())
self.assertEqual(ell2.data(), ell1.data())
# Modify an existing ellipse
strp = czml.Stripe(evenColor={'rgba': [127, 55, 255, 255]},
oddColor={'rgba': [127, 255, 55, 127]},
offset=1.3,
repeat=64,
orientation='VERTICAL')
mat2 = czml.Material(stripe=strp)
pts2 = [0, 1.5, 1.2, 0, 2, 1.6, 1.3, 0, 4, 1.5, 1.3, 0, 6, 1.6, 1.2, 0]
pos2 = czml.Position(cartographicRadians=pts2)
ell2.material = mat2
ell2.position = pos2
ell2.perPositionHeight = False
ell2.height = 7
ell2.extrudedHeight = 30
ell2.semiMajorAxis = 600
ell2.semiMinorAxis = 400
self.assertEqual(
ell2.data(), {
'show': True,
'fill': True,
'outline': True,
'height': 7,
'extrudedHeight': 30,
'rotation': 1.2,
'semiMajorAxis': 600,
'semiMinorAxis': 400,
'numberOfVerticalLines': 800,
'outlineColor': {
'rgba': [0, 255, 127, 55]
},
'material': {
'stripe': {
'evenColor': {
'rgba': [127, 55, 255, 255]
},
'oddColor': {
'rgba': [127, 255, 55, 127]
},
'offset': 1.3,
'repeat': 64,
'orientation': 'VERTICAL'
},
},
'position': {
'cartographicRadians': [
0, 1.5, 1.2, 0, 2, 1.6, 1.3, 0, 4, 1.5, 1.3, 0, 6, 1.6,
1.2, 0
]
},
})
# Add an ellipse to a CZML packet
packet = czml.CZMLPacket(id='abc')
packet.ellipse = ell2
self.assertEqual(
packet.data(), {
'id': 'abc',
'ellipse': {
'show': True,
'fill': True,
'outline': True,
'height': 7,
'extrudedHeight': 30,
'rotation': 1.2,
'semiMajorAxis': 600,
'semiMinorAxis': 400,
'numberOfVerticalLines': 800,
'outlineColor': {
'rgba': [0, 255, 127, 55]
},
'material': {
'stripe': {
'evenColor': {
'rgba': [127, 55, 255, 255]
},
'oddColor': {
'rgba': [127, 255, 55, 127]
},
'offset': 1.3,
'repeat': 64,
'orientation': 'VERTICAL'
},
},
'position': {
'cartographicRadians': [
0, 1.5, 1.2, 0, 2, 1.6, 1.3, 0, 4, 1.5, 1.3, 0, 6,
1.6, 1.2, 0
]
},
},
})
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())