You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1758 lines
77 KiB
1758 lines
77 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2022-2023 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <cmath> |
|
|
|
#include <QDebug> |
|
#include <QJsonDocument> |
|
|
|
#include "czml.h" |
|
#include "mapsettings.h" |
|
#include "mapmodel.h" |
|
|
|
#include "util/aircraft3dmodels.h" |
|
#include "util/coordinates.h" |
|
#include "util/flightpathpalette.h" |
|
#include "util/units.h" |
|
|
|
// FIXME: Cesium now has some additional options: CLAMP_TO_TERRAIN, RELATIVE_TO_TERRAIN, CLAMP_TO_3D_TILE, RELATIVE_TO_3D_TILE |
|
// CLIP_TO_GROUND is our own addition |
|
const QStringList CZML::m_heightReferences = {"NONE", "CLAMP_TO_GROUND", "RELATIVE_TO_GROUND", "CLIP_TO_GROUND"}; |
|
|
|
// Using CLAMP_TO_GROUND on a label, billboard or point, results in all of them being visible through the globe. |
|
// So use CLIP_TO_GROUND instead. |
|
// A single CLAMP_TO_GROUND label, billboard or point latches _shaderDisableDepthDistance |
|
// on the Cesium collection it lands in, which recompiles every item in that collection |
|
// onto Cesium's manual globe-depth path. That path discards nothing beyond |
|
// coarseDepthTestDistance (~635 km), so at map viewing distances labels and images on the |
|
// far side of the Earth draw straight through the globe - including unclamped ones that |
|
// merely share the collection - and the latch is never cleared once set. CLIP_TO_GROUND |
|
// keeps them above the surface without tripping it, as Cesium's isHeightReferenceClamp |
|
// covers only the CLAMP_* references. Points come too: Cesium draws a clamped point as a |
|
// billboard, in the same collection as the images, so leaving them would keep it latched |
|
static int clipRatherThanClamp(int altitudeReference) |
|
{ |
|
return altitudeReference == 1 ? 3 : altitudeReference; // CLAMP_TO_GROUND -> CLIP_TO_GROUND |
|
} |
|
|
|
|
|
CZML::CZML(const MapSettings *settings) : |
|
m_settings(settings) |
|
{ |
|
} |
|
|
|
// Set position from which distance filter is calculated |
|
void CZML::setPosition(const QGeoCoordinate& position) |
|
{ |
|
m_position = position; |
|
} |
|
|
|
bool CZML::filter(const MapItem *mapItem) const |
|
{ |
|
return ( !mapItem->m_itemSettings->m_filterName.isEmpty() |
|
&& !mapItem->m_itemSettings->m_filterNameRE.match(mapItem->m_name).hasMatch() |
|
) |
|
|| ( (mapItem->m_itemSettings->m_filterDistance > 0) |
|
&& (m_position.distanceTo(QGeoCoordinate(mapItem->m_latitude, mapItem->m_longitude, mapItem->m_altitude)) > mapItem->m_itemSettings->m_filterDistance) |
|
); |
|
} |
|
|
|
// Cesium rejects a null inside a coordinate array with a DeveloperError that stops the |
|
// whole scene, and Qt writes null for any non-finite double - so one NaN from one sender |
|
// takes the 3D map down rather than misplacing one item. A QGeoCoordinate built from the |
|
// two argument constructor has altitude qQNaN() while still reporting isValid(), which |
|
// makes this easy to introduce and invisible until Cesium sees it. Substituting zero |
|
// puts the item somewhere wrong, which is recoverable and obvious; a null is not. |
|
static double finiteOrZero(double value) |
|
{ |
|
if (!qIsFinite(value)) |
|
{ |
|
static bool warned = false; |
|
if (!warned) |
|
{ |
|
warned = true; |
|
qWarning() << "CZML: a non-finite coordinate was substituted with zero -" |
|
<< "some map item is sending NaN or infinity"; |
|
} |
|
return 0.0; |
|
} |
|
return value; |
|
} |
|
|
|
void CZML::clear() |
|
{ |
|
m_ids.clear(); |
|
m_lastPosition.clear(); |
|
m_hasMoved.clear(); |
|
} |
|
|
|
QJsonObject CZML::init() |
|
{ |
|
// Start a few seconds in the past, to allow for data to be received. |
|
// |
|
// Only the interval is read: the page creates its viewer with |
|
// automaticallyTrackDataSourceClocks false, so the currentTime below is discarded and |
|
// map3d.html gives the clock the same lag as its STARTING value instead. Left here |
|
// because the interval has to begin at or before that time, and because a document |
|
// packet without a clock would be odd - but do not change this expecting the map's |
|
// clock to follow |
|
QString start = QDateTime::currentDateTimeUtc().addSecs(-4).toString(Qt::ISODate); |
|
QString stop = QDateTime::currentDateTimeUtc().addSecs(60*60).toString(Qt::ISODate); |
|
QString interval = QString("%1/%2").arg(start).arg(stop); |
|
|
|
QJsonObject spec { |
|
{"interval", interval}, |
|
{"currentTime", start}, |
|
{"range", "UNBOUNDED"} |
|
}; |
|
QJsonObject doc { |
|
{"id", "document"}, |
|
{"version", "1.0"}, |
|
{"clock", spec} |
|
}; |
|
|
|
return doc; |
|
} |
|
|
|
// A delete is only worth sending for an entity Cesium has actually been told about, and |
|
// only once. Everything else was the great majority of the CZML traffic: in a measured run |
|
// 231,680 of 231,779 deletes were for entities the page had never had - every airport in |
|
// the database, filtered out by distance, deleted on first sight - and every airspace was |
|
// deleted afresh on each settings pass. 91% of all packets. |
|
// |
|
// When a delete is sent, everything cached about the entity is reset, because Cesium is |
|
// being told to throw it away entirely - history and all. Kept, it makes the next |
|
// description a difference against a state Cesium no longer holds, and every unchanged |
|
// property is then left out of a packet describing an entity that no longer has any of |
|
// them. The position is the one that bites: it is suppressed when it has not moved, so a |
|
// waypoint deleted and re-added in the same place - which is what selecting away from a |
|
// flight and back does - came back as a billboard with nowhere to be drawn, and never |
|
// appeared. Clearing m_seen alone was not enough; that only governs the early-out, while |
|
// the rest of the packet is built against existingId, which is what m_firstSeenDateTime |
|
// carries - so it is the whole State that goes. |
|
bool CZML::deleteNeeded(const QString& id) |
|
{ |
|
auto it = m_ids.find(id); |
|
|
|
// Never described (an entry may exist without one: the track segments create them), |
|
// or already deleted - which also clears m_firstSeenDateTime, so that check covers both |
|
if ((it == m_ids.end()) || it->m_deleted || it->m_firstSeenDateTime.isEmpty()) { |
|
return false; |
|
} |
|
*it = State(); |
|
it->m_deleted = true; |
|
m_lastPosition.remove(id); |
|
m_hasMoved.remove(id); |
|
return true; |
|
} |
|
|
|
void CZML::described(const QString& id) |
|
{ |
|
State& state = m_ids[id]; |
|
|
|
if (state.m_firstSeenDateTime.isEmpty()) { |
|
state.m_firstSeenDateTime = QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs); |
|
} |
|
state.m_deleted = false; // visible again, so a later filter must re-delete it |
|
} |
|
|
|
QJsonObject CZML::update(PolygonMapItem *mapItem) |
|
{ |
|
QString id = mapItem->m_name; |
|
|
|
QJsonObject obj { |
|
{"id", id} // id must be unique |
|
}; |
|
|
|
if ( !mapItem->m_itemSettings->m_enabled |
|
|| !mapItem->m_itemSettings->m_display3DTrack |
|
|| filter(mapItem) |
|
|| mapItem->m_deleted |
|
) |
|
{ |
|
// Delete obj completely (including any history) - if Cesium has it |
|
if (deleteNeeded(id)) { |
|
obj.insert("delete", true); |
|
} |
|
return obj; // id only otherwise, so nothing is sent |
|
} |
|
described(id); |
|
|
|
// Need to use perPositionHeight for vertical polygons |
|
bool perPosition = mapItem->m_extrudedHeight == 0; |
|
// A flat polygon clamped to the ground is draped over it instead: terrain, 3D tiles |
|
// and all. Given per position heights, Cesium neither subdivides a polygon nor |
|
// projects it for its size - it fills between the vertices it was given with flat |
|
// triangles. Sampling the ground at each vertex, as map3d.html does for |
|
// altitudeReference, lifts the vertices and nothing between them, so the fill cut |
|
// under the curve of the Earth as soon as the vertices were far apart. The Aircraft |
|
// feature's coverage, spanning thousands of km, showed only as slivers along its |
|
// outer edge, and HFDL's not at all. |
|
const bool draped = perPosition && (mapItem->m_altitudeReference == 1); |
|
|
|
QJsonArray positions; |
|
for (const auto c : mapItem->m_points) |
|
{ |
|
positions.append(finiteOrZero(c->longitude())); |
|
positions.append(finiteOrZero(c->latitude())); |
|
positions.append(finiteOrZero(c->altitude())); |
|
} |
|
|
|
QJsonObject positionList { |
|
{"cartographicDegrees", positions}, |
|
}; |
|
|
|
QColor color; |
|
if (mapItem->m_colorValid) { |
|
color = QColor::fromRgba(mapItem->m_color); |
|
} else { |
|
color = QColor::fromRgba(mapItem->m_itemSettings->m_3DTrackColor); |
|
} |
|
QJsonArray colorRGBA { |
|
color.red(), color.green(), color.blue(), color.alpha() |
|
}; |
|
QJsonObject colorObj { |
|
{"rgba", colorRGBA} |
|
}; |
|
|
|
QJsonObject solidColor { |
|
{"color", colorObj}, |
|
}; |
|
|
|
QJsonObject material { |
|
{"solidColor", solidColor} |
|
}; |
|
|
|
// Outlined only when the polygon is FLAT, which is the difference between an outline |
|
// that helps and one that ruins the picture. |
|
// |
|
// Cesium draws the outline of an extruded polygon at every vertex - not just around |
|
// the top and bottom but a vertical edge at each point of the perimeter - in opaque |
|
// black whatever colour the polygon is. An airspace is a faint translucent wall built |
|
// from a great many vertices, so that came out as a row of hard dark bars across it. |
|
// A flat polygon has no verticals, and its outline is simply its boundary: the ILS |
|
// demodulator's beams and the Aircraft feature's coverage wedges both want that. |
|
// |
|
// Cesium has one flag for the whole outline, so this is decided from the item rather |
|
// than asked of it - perPosition is already the test for "not extruded", and an |
|
// explicit flag would mean a new SWGMapItem field and a swagger regeneration. |
|
QJsonArray outlineColorRGBA { |
|
0, 0, 0, 255 |
|
}; |
|
QJsonObject outlineColor { |
|
{"rgba", outlineColorRGBA} |
|
}; |
|
|
|
// Cesium cannot outline a polygon on the ground, and says so on the console if asked |
|
QJsonObject polygon { |
|
{"positions", positionList}, |
|
{"material", material}, |
|
{"outline", perPosition && !draped}, |
|
{"outlineColor", outlineColor}, |
|
}; |
|
if (draped) |
|
{ |
|
polygon.insert("heightReference", m_heightReferences[mapItem->m_altitudeReference]); |
|
} |
|
else if (perPosition) |
|
{ |
|
polygon.insert("perPositionHeight", true); |
|
if (mapItem->m_altitudeReference != 0) { |
|
polygon.insert("altitudeReference", m_heightReferences[mapItem->m_altitudeReference]); // Custom code in map3d.html |
|
} |
|
} |
|
else |
|
{ |
|
polygon.insert("height", mapItem->m_altitude); |
|
polygon.insert("heightReference", m_heightReferences[mapItem->m_altitudeReference]); |
|
polygon.insert("extrudedHeight", mapItem->m_extrudedHeight); |
|
} |
|
|
|
// We need to have a position, otherwise viewer entity tracking doesn't seem to work |
|
QJsonArray coords { |
|
finiteOrZero(mapItem->m_longitude), finiteOrZero(mapItem->m_latitude), |
|
finiteOrZero(mapItem->m_altitude) |
|
}; |
|
QJsonObject position { |
|
{"cartographicDegrees", coords}, |
|
}; |
|
obj.insert("position", position); |
|
|
|
obj.insert("polygon", polygon); |
|
obj.insert("description", mapItem->m_label); |
|
|
|
//qDebug() << "Polygon " << obj; |
|
return obj; |
|
} |
|
|
|
QJsonObject CZML::update(PolylineMapItem *mapItem) |
|
{ |
|
QString id = mapItem->m_name; |
|
|
|
QJsonObject obj { |
|
{"id", id} // id must be unique |
|
}; |
|
|
|
if ( !mapItem->m_itemSettings->m_enabled |
|
|| !mapItem->m_itemSettings->m_display3DTrack |
|
|| filter(mapItem) |
|
|| mapItem->m_deleted |
|
) |
|
{ |
|
// Delete obj completely (including any history) - if Cesium has it |
|
if (deleteNeeded(id)) { |
|
obj.insert("delete", true); |
|
} |
|
return obj; // id only otherwise, so nothing is sent |
|
} |
|
described(id); |
|
|
|
QJsonArray positions; |
|
for (const auto c : mapItem->m_points) |
|
{ |
|
positions.append(finiteOrZero(c->longitude())); |
|
positions.append(finiteOrZero(c->latitude())); |
|
positions.append(finiteOrZero(c->altitude())); |
|
} |
|
|
|
QJsonObject positionList { |
|
{"cartographicDegrees", positions}, |
|
}; |
|
|
|
QColor color; |
|
if (mapItem->m_colorValid) { |
|
color = QColor::fromRgba(mapItem->m_color); |
|
} else { |
|
color = QColor::fromRgba(mapItem->m_itemSettings->m_3DTrackColor); |
|
} |
|
QJsonArray colorRGBA { |
|
color.red(), color.green(), color.blue(), color.alpha() |
|
}; |
|
QJsonObject colorObj { |
|
{"rgba", colorRGBA} |
|
}; |
|
|
|
QJsonObject solidColor { |
|
{"color", colorObj}, |
|
}; |
|
|
|
QJsonObject material { |
|
{"solidColor", solidColor} |
|
}; |
|
|
|
QJsonObject polyline { |
|
{"positions", positionList}, |
|
{"material", material} |
|
}; |
|
polyline.insert("clampToGround", mapItem->m_altitudeReference == 1); |
|
if (mapItem->m_altitudeReference == 3) { |
|
polyline.insert("altitudeReference", m_heightReferences[mapItem->m_altitudeReference]); // Custom code in map3d.html |
|
} |
|
|
|
// We need to have a position, otherwise viewer entity tracking doesn't seem to work |
|
QJsonArray coords { |
|
finiteOrZero(mapItem->m_longitude), finiteOrZero(mapItem->m_latitude), |
|
finiteOrZero(mapItem->m_altitude) |
|
}; |
|
QJsonObject position { |
|
{"cartographicDegrees", coords}, |
|
}; |
|
obj.insert("position", position); |
|
|
|
obj.insert("polyline", polyline); |
|
obj.insert("description", mapItem->m_label); |
|
|
|
//qDebug() << "Polyline " << obj; |
|
return obj; |
|
} |
|
|
|
static void insertConstantProperty(QJsonObject& properties, const QString& name, const QString& value) |
|
{ |
|
properties.insert(name, value); |
|
} |
|
|
|
// A sample needs a time. An item can legitimately not have one - a position datetime |
|
// is invalid until a protocol that carries times has been heard, and the per-field |
|
// datetimes are sender strings that serialize an invalid QDateTime as "" - and an |
|
// empty string here made Cesium reject the ENTIRE packet ("Invalid ISO 8601 date."), |
|
// state, position, model and all. The state being described is current, so 'now' is |
|
// the honest anchor when the sender gave none. |
|
static QString sampleTime(const QString& dateTime) |
|
{ |
|
return dateTime.isEmpty() ? QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs) : dateTime; |
|
} |
|
|
|
static void insertProperty(QJsonObject& properties, const QString& name, const QString& dateTime, float value) |
|
{ |
|
if (!std::isnan(value)) |
|
{ |
|
QJsonArray ar; |
|
ar.push_back(sampleTime(dateTime)); |
|
ar.push_back(value); |
|
QJsonObject obj { |
|
{"number", ar}, |
|
{"backwardExtrapolationType", "HOLD"}, |
|
{"backwardExtrapolationDuration", 30}, |
|
{"forwardExtrapolationType", "HOLD"}, |
|
{"forwardExtrapolationDuration", 30}, |
|
}; |
|
properties.insert(name, obj); |
|
} |
|
} |
|
|
|
// Two samples in one packet. CZML takes a sampled number as a flat |
|
// [time, value, time, value] array. Used to close a run of identical values with the last |
|
// sample that still carried the old value, immediately before the sample that changes it, |
|
// so the run reconstructs as a flat line instead of a ramp from where the run began. |
|
static void insertProperty2(QJsonObject& properties, const QString& name, |
|
const QString& dateTime0, float value0, |
|
const QString& dateTime1, float value1) |
|
{ |
|
if (!std::isnan(value0) && !std::isnan(value1)) |
|
{ |
|
QJsonArray ar; |
|
ar.push_back(sampleTime(dateTime0)); |
|
ar.push_back(value0); |
|
ar.push_back(sampleTime(dateTime1)); |
|
ar.push_back(value1); |
|
QJsonObject obj { |
|
{"number", ar}, |
|
{"backwardExtrapolationType", "HOLD"}, |
|
{"backwardExtrapolationDuration", 30}, |
|
{"forwardExtrapolationType", "HOLD"}, |
|
{"forwardExtrapolationDuration", 30}, |
|
}; |
|
properties.insert(name, obj); |
|
} |
|
} |
|
|
|
void CZML::SampledChannel::write(QJsonObject& properties, const QString& name, |
|
const QString& dateTime, const QDateTime& frameTime, float value, bool force) |
|
{ |
|
if (std::isnan(value)) { |
|
return; // insertProperty() would drop it anyway |
|
} |
|
|
|
const bool first = force || std::isnan(m_emitted) || !m_sentFrame.isValid(); |
|
|
|
// How often this aircraft is being updated, which bounds how early the keepalive has |
|
// to fire. Measured from the previous call rather than assumed: it varies from about |
|
// 0.5 s to tens of seconds across the traffic on the map |
|
const qint64 interval = m_lastFrame.isValid() |
|
? qAbs(m_lastFrame.secsTo(frameTime)) : 1; |
|
m_lastFrame = frameTime; |
|
|
|
if (first || (value != m_emitted)) |
|
{ |
|
// Close the run that has just ended before opening the new one, so the old value |
|
// is still held at the time it was last measured and the change stays a step |
|
if (!first && !m_heldTime.isEmpty() && m_heldFrame.isValid() |
|
&& (m_heldFrame < frameTime)) |
|
{ |
|
insertProperty2(properties, name, m_heldTime, m_emitted, dateTime, value); |
|
} |
|
else |
|
{ |
|
insertProperty(properties, name, dateTime, value); |
|
} |
|
m_emitted = value; |
|
m_heldTime.clear(); |
|
m_heldFrame = QDateTime(); |
|
m_sentFrame = frameTime; |
|
return; |
|
} |
|
|
|
// Unchanged, so withhold it - but keep the trailing edge of the run inside the |
|
// forward HOLD, or the PFD field would blank mid-cruise. Emitting at `threshold` |
|
// lands at up to threshold + interval, so the threshold has to leave room for the |
|
// next update to be late; at a large enough interval it goes non-positive and every |
|
// update is emitted, which is the only thing that can work at that cadence |
|
const qint64 threshold = qMin<qint64>(m_keepaliveMaxSecs, |
|
m_holdSecs - 2 * interval); |
|
m_heldTime = dateTime; |
|
m_heldFrame = frameTime; |
|
if (qAbs(m_sentFrame.secsTo(frameTime)) >= threshold) |
|
{ |
|
insertProperty(properties, name, dateTime, value); |
|
m_sentFrame = frameTime; |
|
m_heldTime.clear(); |
|
m_heldFrame = QDateTime(); |
|
} |
|
} |
|
|
|
// The flight plan is structured data of variable length, so it is sent as a single |
|
// constant string property containing compact JSON, which the ND parses |
|
static QString flightPlanJson(const MapFlightPlan& plan) |
|
{ |
|
if (!plan.m_valid) { |
|
return QString(); |
|
} |
|
QJsonObject obj; |
|
if (!plan.m_departure.isEmpty()) { |
|
obj.insert("dep", plan.m_departure); |
|
} |
|
if (!plan.m_arrival.isEmpty()) { |
|
obj.insert("arr", plan.m_arrival); |
|
} |
|
if (!plan.m_arrivalRunway.isEmpty()) { |
|
obj.insert("rwy", plan.m_arrivalRunway); |
|
} |
|
if (!plan.m_approach.isEmpty()) { |
|
obj.insert("app", plan.m_approach); |
|
} |
|
obj.insert("act", plan.m_activeWaypoint); |
|
QJsonArray waypoints; |
|
for (const auto& wp : plan.m_waypoints) |
|
{ |
|
QJsonObject waypoint; |
|
waypoint.insert("n", wp.m_name); |
|
if (!std::isnan(wp.m_latitude) && !std::isnan(wp.m_longitude)) |
|
{ |
|
waypoint.insert("lat", wp.m_latitude); |
|
waypoint.insert("lon", wp.m_longitude); |
|
} |
|
if (!std::isnan(wp.m_altitudeFt)) { |
|
waypoint.insert("alt", wp.m_altitudeFt); |
|
} |
|
if (!wp.m_eta.isEmpty()) { |
|
waypoint.insert("eta", wp.m_eta); |
|
} |
|
waypoints.append(waypoint); |
|
} |
|
obj.insert("wpts", waypoints); |
|
return QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact)); |
|
} |
|
|
|
// A datalink (CPDLC/PDC) message for the DCDU, as a single constant string property of |
|
// compact JSON, like the flight plan above |
|
static QString datalinkMessageJson(const MapDatalinkMessage& message) |
|
{ |
|
if (!message.m_valid) { |
|
return QString(); |
|
} |
|
QJsonObject obj; |
|
obj.insert("id", message.m_id); |
|
if (!message.m_received.isEmpty()) { |
|
obj.insert("rx", message.m_received); |
|
} |
|
obj.insert("up", message.m_uplink ? 1 : 0); |
|
if (!message.m_station.isEmpty()) { |
|
obj.insert("stn", message.m_station); |
|
} |
|
obj.insert("txt", message.m_text); |
|
return QString::fromUtf8(QJsonDocument(obj).toJson(QJsonDocument::Compact)); |
|
} |
|
|
|
// SampledProperties are interpolated |
|
// Need to use intervals to avoid interpolation |
|
// See: https://sandcastle.cesium.com/?src=CZML%20Custom%20Properties.html&label=All |
|
static void insertProperty0(QJsonObject& properties, const QString& name, const QString& dateTime, float value) |
|
{ |
|
if (!std::isnan(value)) |
|
{ |
|
QJsonObject obj { |
|
{"interval", sampleTime(dateTime) + "/3000"}, // Year 3000 |
|
{"number", value} |
|
}; |
|
|
|
QJsonArray array { |
|
obj |
|
}; |
|
properties.insert(name, array); |
|
} |
|
} |
|
|
|
// The 3D map's altitude coloured track: the taken track split into one polyline entity |
|
// per altitude band, sharing the 2D map's palette and its 5000 ft bands. A Cesium path |
|
// has a single material, so a multi coloured track cannot be drawn with the entity's |
|
// own path graphic - when a palette is set the path is hidden (see the path block in |
|
// update()) and these entities, named "<item name> t3d <n>", are drawn instead. |
|
// |
|
// Items with a predicted track (satellites) keep the path, which also draws the future |
|
// leg - something a polyline of taken positions cannot. |
|
// |
|
// Called BEFORE update(), which resets the item's cached state when it is deleted. |
|
QList<QJsonObject> CZML::updateTrackSegments3D(ObjectMapItem *mapItem, bool isSelected) |
|
{ |
|
QList<QJsonObject> packets; |
|
const QString id = mapItem->m_name; |
|
|
|
// PFD samples from a fast log replay are sent immediately, while the accumulated |
|
// track is sent by the model's normal flush. Rebuilding the growing tail for every |
|
// frame would be quadratic work and can swamp the 3D page on a large log. |
|
if (mapItem->m_replayStateUpdate) { |
|
return packets; |
|
} |
|
|
|
const QString& palette = mapItem->m_itemSettings->m_2DTrackPalette; |
|
// With no palette but smoothing on, the track is still drawn as polylines - in the |
|
// single track colour - rather than left to the entity's path. The path is drawn |
|
// from the POSITION SAMPLES, which carry every raw live report interleaved between |
|
// the smoothed ones at different timestamps, so it stays jagged whatever lambda is. |
|
// Only the polylines below draw the smoothed track and nothing else. |
|
const bool smoothedPlain = palette.isEmpty() |
|
&& (mapItem->m_itemSettings->m_smoothingWindow > 0) |
|
&& mapItem->m_trackSupplied; |
|
const bool segmented = (!palette.isEmpty() || smoothedPlain) |
|
&& !mapItem->m_fixedPosition |
|
&& mapItem->m_predictedTrackCoords.isEmpty() |
|
&& mapItem->m_itemSettings->m_enabled |
|
&& !mapItem->m_deleted |
|
&& (mapItem->m_image != "") |
|
&& !filter(mapItem); |
|
|
|
if (!segmented) |
|
{ |
|
// Take down anything drawn. Without creating a state entry: the settings walks |
|
// visit every one of the model's items, most of which never segment a track. |
|
auto it = m_ids.find(id); |
|
if ((it == m_ids.end()) || (it->m_trackSegmentsEmitted == 0)) { |
|
return packets; |
|
} |
|
State& state = *it; |
|
for (int i = 0; i < state.m_trackSegmentsEmitted; i++) |
|
{ |
|
packets.append(QJsonObject { |
|
{"id", QString("%1 t3d %2").arg(id).arg(i)}, |
|
{"delete", true} |
|
}); |
|
} |
|
state.m_trackSegmentsEmitted = 0; |
|
state.m_trackSegmentSizes.clear(); |
|
state.m_trackSegmentBands.clear(); |
|
state.m_trackPointCount = 0; |
|
state.m_trackLastColorIndex = -1; |
|
state.m_trackPalette.clear(); |
|
state.m_trackSegmentsShow = false; |
|
return packets; |
|
} |
|
|
|
State& state = m_ids[id]; |
|
const QList<QGeoCoordinate *>& coords = mapItem->m_takenTrackCoords; |
|
|
|
const bool show = mapItem->m_itemSettings->m_display3DTrack |
|
&& ( m_settings->m_displayAllGroundTracks |
|
|| (m_settings->m_displaySelectedGroundTracks && isSelected)); |
|
const bool showChanged = (show != state.m_trackSegmentsShow) |
|
&& (state.m_trackSegmentsEmitted > 0); |
|
|
|
// Rebuild from scratch when the palette changed or the track is not simply longer |
|
// than before - it shrank, or its first point moved, which is what a trim or a |
|
// flight change looks like. In plain mode the key carries the track colour, so a |
|
// colour change also recolours the already closed chunks |
|
const QString paletteKey = smoothedPlain |
|
? QString("#plain %1").arg(mapItem->m_itemSettings->m_3DTrackColor) |
|
: palette; |
|
const bool tailChanged = (state.m_trackPointCount > 0) |
|
&& (coords.size() >= state.m_trackPointCount) |
|
&& (*coords[state.m_trackPointCount - 1] != state.m_trackLastCoord); |
|
const bool rebuild = (paletteKey != state.m_trackPalette) |
|
|| (coords.size() < state.m_trackPointCount) |
|
|| tailChanged |
|
|| (state.m_trackRevision != mapItem->m_takenTrackRevision) |
|
|| ( (state.m_trackPointCount > 0) && !coords.isEmpty() |
|
&& (*coords[0] != state.m_trackFirstCoord)); |
|
if (rebuild) |
|
{ |
|
state.m_trackSegmentSizes.clear(); |
|
state.m_trackSegmentBands.clear(); |
|
state.m_trackPointCount = 0; |
|
state.m_trackLastColorIndex = -1; |
|
state.m_trackPalette = paletteKey; |
|
} |
|
if (!coords.isEmpty()) { |
|
state.m_trackFirstCoord = *coords[0]; |
|
} |
|
|
|
// Extend the segmentation over the new points, mirroring the 2D map's |
|
// ObjectMapModel::colorTrackPoints(): the point a colour change happens at is |
|
// repeated, in the segment that ends there and the one that starts there, so |
|
// consecutive segments join without a gap |
|
// A segment is also split when it reaches a maximum size. A closed segment is never |
|
// re-sent, but the growing tail is - and a band only changes when the aircraft |
|
// crosses 5000 ft, so at cruise the tail segment was the whole cruise, thousands of |
|
// points re-serialized on the GUI thread every few seconds for every aircraft. That |
|
// is what made position updates jerky with a few hundred tracks on screen. The cap |
|
// bounds the tail: at most this many points per re-send, whatever the flight phase. |
|
const int maxSegmentSize = 250; |
|
const int previousCount = state.m_trackSegmentSizes.size(); |
|
for (int i = state.m_trackPointCount; i < coords.size(); i++) |
|
{ |
|
// Plain mode has no altitude bands - everything is one band in the single |
|
// track colour, and the size cap alone chunks it |
|
const int band = smoothedPlain |
|
? 0 |
|
: FlightPathPalette::getColorIndex(Units::metresToFeet(coords[i]->altitude())); |
|
if ( (band != state.m_trackLastColorIndex) |
|
|| (state.m_trackSegmentSizes.last() >= maxSegmentSize)) |
|
{ |
|
if (state.m_trackLastColorIndex >= 0) { |
|
state.m_trackSegmentSizes.last()++; |
|
} |
|
state.m_trackSegmentSizes.append(0); |
|
state.m_trackSegmentBands.append(band); |
|
state.m_trackLastColorIndex = band; |
|
} |
|
state.m_trackSegmentSizes.last()++; |
|
} |
|
const bool grew = coords.size() > state.m_trackPointCount; |
|
state.m_trackPointCount = coords.size(); |
|
state.m_trackLastCoord = coords.isEmpty() ? QGeoCoordinate() : *coords.last(); |
|
state.m_trackRevision = mapItem->m_takenTrackRevision; |
|
|
|
const int segmentCount = state.m_trackSegmentSizes.size(); |
|
if (segmentCount == 0) |
|
{ |
|
state.m_trackSegmentsShow = show; |
|
return packets; |
|
} |
|
|
|
// While the track is hidden, nothing is emitted at all - the segmentation state |
|
// above still advances, and showing the track re-emits everything current in one |
|
// go (the show change below makes firstEmit 0). Hiding just flips the show flag |
|
// on what is already drawn, rather than re-sending every position hidden |
|
if (!show) |
|
{ |
|
if (showChanged) |
|
{ |
|
for (int k = 0; k < state.m_trackSegmentsEmitted; k++) |
|
{ |
|
packets.append(QJsonObject { |
|
{"id", QString("%1 t3d %2").arg(id).arg(k)}, |
|
{"polyline", QJsonObject {{"show", false}}} |
|
}); |
|
} |
|
} |
|
state.m_trackSegmentsShow = false; |
|
return packets; |
|
} |
|
|
|
// Decide which segments go out. Closed segments never change again, so in the |
|
// steady state only the growing tail is re-sent - and that at most once a second. |
|
// The throttle was 5 s when the tail was a CZML polyline entity, whose every update |
|
// re-batched static geometry on the page's main thread; the page now draws these |
|
// through a PolylineCollection, where an update rewrites one line's vertex data |
|
// (measured ~30 us a packet), so the track can afford to hug the aircraft. |
|
int firstEmit; |
|
const QDateTime now = QDateTime::currentDateTimeUtc(); |
|
if (rebuild || showChanged || (state.m_trackSegmentsEmitted == 0)) { |
|
firstEmit = 0; |
|
} else if (segmentCount > previousCount) { |
|
// A segment closed: it gained its boundary point, so re-send from it |
|
firstEmit = qMax(0, previousCount - 1); |
|
} else if (grew && (mapItem->m_replayTrackPending |
|
|| !state.m_trackTailEmit.isValid() || (state.m_trackTailEmit.msecsTo(now) >= 1000))) { |
|
firstEmit = segmentCount - 1; |
|
} else { |
|
return packets; // Nothing changed, or the tail is throttled |
|
} |
|
// The Whittaker-Eilers smoother refines the last two windows of points in place |
|
// (smoothTrack() filters twice the setting), which can reach back beyond |
|
// the segment that grew - re-send far enough to cover it |
|
const int smoothingWindow = 2 * mapItem->m_itemSettings->m_smoothingWindow; |
|
if (smoothingWindow > 0) |
|
{ |
|
int covered = (firstEmit < segmentCount) ? state.m_trackSegmentSizes[firstEmit] : 0; |
|
while ((firstEmit > 0) && (covered < smoothingWindow)) { |
|
firstEmit--; |
|
covered += state.m_trackSegmentSizes[firstEmit] - 1; |
|
} |
|
} |
|
|
|
const QVariant *paletteColors = smoothedPlain ? nullptr : FlightPathPalette::getPalette(palette); |
|
const QColor plainColor = QColor::fromRgba(mapItem->m_itemSettings->m_3DTrackColor); |
|
|
|
// Draw the smoothed shadow of the track where one is being maintained - the bands |
|
// above stay keyed on the raw altitudes, which never change under us. The provisional |
|
// live point rides one past the shadow (updateProvisionalTrackPoint() does not shadow |
|
// it), and it is there on almost every flush - requiring exact equality here meant |
|
// the raw track was what actually got drawn, quantized altitudes and all. |
|
const int shadowSize = mapItem->m_smoothedTrackCoords.size(); |
|
const bool smoothed = (shadowSize == coords.size()) |
|
|| (mapItem->m_trackProvisional && (shadowSize == coords.size() - 1)); |
|
|
|
// Consecutive segments share their boundary point, so segment k starts at the sum |
|
// of the earlier sizes less one shared point per join |
|
int start = 0; |
|
for (int k = 0; k < firstEmit; k++) { |
|
start += state.m_trackSegmentSizes[k] - 1; |
|
} |
|
for (int k = firstEmit; k < segmentCount; k++) |
|
{ |
|
const int size = state.m_trackSegmentSizes[k]; |
|
QJsonArray positions; |
|
for (int j = start; j < start + size; j++) |
|
{ |
|
const QGeoCoordinate& coord = (smoothed && (j < shadowSize)) |
|
? mapItem->m_smoothedTrackCoords[j] : *coords[j]; |
|
// Rounded, not full precision: a raw double serializes to up to 17 |
|
// significant digits, which is most of the packet's bytes. 1e-7 degrees |
|
// is about a centimetre |
|
positions.push_back(std::round(finiteOrZero(coord.longitude()) * 1e7) / 1e7); |
|
positions.push_back(std::round(finiteOrZero(coord.latitude()) * 1e7) / 1e7); |
|
positions.push_back(std::round(finiteOrZero(coord.altitude()) * 100.0) / 100.0); |
|
} |
|
const QColor color = smoothedPlain ? plainColor : paletteColors[state.m_trackSegmentBands[k]].value<QColor>(); |
|
QJsonArray colorRGBA { |
|
color.red(), color.green(), color.blue(), color.alpha() |
|
}; |
|
QJsonObject polyline { |
|
{"positions", QJsonObject {{"cartographicDegrees", positions}}}, |
|
{"material", QJsonObject {{"solidColor", QJsonObject {{"color", QJsonObject {{"rgba", colorRGBA}}}}}}}, |
|
{"width", 2}, |
|
{"show", show} |
|
}; |
|
packets.append(QJsonObject { |
|
{"id", QString("%1 t3d %2").arg(id).arg(k)}, |
|
{"polyline", polyline} |
|
}); |
|
start += size - 1; |
|
} |
|
|
|
// A rebuild can produce fewer segments than were drawn |
|
for (int k = segmentCount; k < state.m_trackSegmentsEmitted; k++) |
|
{ |
|
packets.append(QJsonObject { |
|
{"id", QString("%1 t3d %2").arg(id).arg(k)}, |
|
{"delete", true} |
|
}); |
|
} |
|
|
|
state.m_trackSegmentsEmitted = segmentCount; |
|
state.m_trackSegmentsShow = show; |
|
state.m_trackTailEmit = now; |
|
return packets; |
|
} |
|
|
|
QJsonObject CZML::update(ObjectMapItem *mapItem, bool isTarget, bool isSelected) |
|
{ |
|
(void) isTarget; |
|
|
|
QString id = mapItem->m_name; |
|
|
|
QJsonObject obj { |
|
{"id", id} // id must be unique |
|
}; |
|
|
|
if (!mapItem->m_itemSettings->m_enabled || filter(mapItem) || mapItem->m_deleted) |
|
{ |
|
// Delete obj completely (including any history) - if Cesium has it, and only |
|
// once. See deleteNeeded() for what that was costing. |
|
if (deleteNeeded(id)) { |
|
obj.insert("delete", true); |
|
} |
|
return obj; // id only otherwise, so nothing is sent |
|
} |
|
|
|
// Models, labels, points and billboards are all kept above the surface by the |
|
// CLIP_TO_GROUND height reference added to our Cesium, which re-queries the surface |
|
// under each every frame - as terrain and tiles load, and between the positions we |
|
// send, where Cesium interpolates and extrapolates. That costs: against Google's 3D |
|
// tiles each query is a ray pick through the tile geometry, measured at 21 ms a |
|
// frame for 90 models and far more for their labels. The alternative, clipping the |
|
// positions we send in map3d.html from a height sampled off the depth buffer, was |
|
// cheaper but wrong on those tiles - a sample that lands on a hangar roof or a parked |
|
// aircraft's mesh lifts everything crossing that cell into the air - so Cesium's |
|
// is used for everything until that is right, and this comment records the cost |
|
const QStringList heightReferences = {"NONE", "CLAMP_TO_GROUND", "RELATIVE_TO_GROUND", "CLIP_TO_GROUND"}; |
|
QString dt; |
|
|
|
if (mapItem->m_availableFrom.isValid()) { |
|
dt = mapItem->m_availableFrom.toString(Qt::ISODateWithMs); |
|
} else if (mapItem->m_takenTrackDateTimes.size() > 0) { |
|
dt = mapItem->m_takenTrackDateTimes.last()->toString(Qt::ISODateWithMs); |
|
} else { |
|
dt = QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs); |
|
} |
|
|
|
// Keep a hash of the time we first saw each item |
|
State& state = m_ids[id]; |
|
// An item that was previously filtered out already has an entry, so the presence of |
|
// one no longer means we have described it |
|
bool existingId = !state.m_firstSeenDateTime.isEmpty(); |
|
if (!existingId) { |
|
state.m_firstSeenDateTime = dt; |
|
} |
|
state.m_deleted = false; // visible again, so a later filter must re-delete it |
|
|
|
bool removeObj = false; |
|
bool fixedPosition = mapItem->m_fixedPosition; |
|
|
|
// EARLY OUT, before any JSON is built. |
|
// |
|
// allUpdated() walks every item whenever settings are applied, and the model holds of |
|
// the order of 200,000 - airports, navaids, airspaces, waypoints - none of which ever |
|
// move. Filtering the resulting packet was enough to stop them being SENT, but each |
|
// one was still assembled into a QJsonObject and then discarded: measured at 217,510 |
|
// constructions to produce 1,242 batches worth sending. |
|
// |
|
// A fixed item that we have already described, whose position, label, image and the |
|
// settings CZML reads are all as they were, cannot produce anything but its own id. |
|
const quint32 settingsSignature = mapItem->m_itemSettings->czmlSignature(); |
|
if (state.m_seen |
|
&& fixedPosition |
|
&& (state.m_settingsSignature == settingsSignature) |
|
&& (state.m_latitude == mapItem->m_latitude) |
|
&& (state.m_longitude == mapItem->m_longitude) |
|
&& (state.m_altitude == mapItem->m_altitude) |
|
&& (state.m_lastLabel == mapItem->m_label) |
|
&& (state.m_lastImage == mapItem->m_image)) |
|
{ |
|
return obj; // id only, which CesiumInterface::update() will not send |
|
} |
|
// How fast height is being lost, from the last update, so that the extrapolation |
|
// below can be stopped before it flies the item into the ground. Worked out here |
|
// because the previous altitude is about to be overwritten |
|
double descentRate = 0.0; // m/s, positive while descending |
|
if (state.m_altitudeDateTime.isValid() && mapItem->m_positionDateTime.isValid()) |
|
{ |
|
const double seconds = state.m_altitudeDateTime.msecsTo(mapItem->m_positionDateTime) / 1000.0; |
|
if (seconds > 0.0) |
|
{ |
|
const double rate = (state.m_altitude - mapItem->m_altitude) / seconds; |
|
if ((rate > 0.0) && (rate < 100.0)) { // Anything faster is a bad altitude, not a descent |
|
descentRate = rate; |
|
} |
|
} |
|
} |
|
|
|
state.m_seen = true; |
|
state.m_settingsSignature = settingsSignature; |
|
state.m_latitude = mapItem->m_latitude; |
|
state.m_longitude = mapItem->m_longitude; |
|
state.m_altitude = mapItem->m_altitude; |
|
state.m_altitudeDateTime = mapItem->m_positionDateTime; |
|
state.m_lastLabel = mapItem->m_label; |
|
state.m_lastImage = mapItem->m_image; |
|
if (mapItem->m_image == "") |
|
{ |
|
// Need to remove this from the map (but history is retained) |
|
removeObj = true; |
|
} |
|
|
|
QJsonArray coords; |
|
if (!removeObj) |
|
{ |
|
if (!fixedPosition && (mapItem->m_predictedTrackCoords.size() > 0)) |
|
{ |
|
QListIterator<QGeoCoordinate *> i(mapItem->m_takenTrackCoords); |
|
QListIterator<QDateTime *> j(mapItem->m_takenTrackDateTimes); |
|
while (i.hasNext()) |
|
{ |
|
QGeoCoordinate *c = i.next(); |
|
coords.append(j.next()->toString(Qt::ISODateWithMs)); |
|
coords.append(c->longitude()); |
|
coords.append(c->latitude()); |
|
coords.append(c->altitude()); |
|
} |
|
if (mapItem->m_predictedTrackCoords.size() > 0) |
|
{ |
|
QListIterator<QGeoCoordinate *> k(mapItem->m_predictedTrackCoords); |
|
QListIterator<QDateTime *> l(mapItem->m_predictedTrackDateTimes); |
|
k.toBack(); |
|
l.toBack(); |
|
while (k.hasPrevious()) |
|
{ |
|
QGeoCoordinate *c = k.previous(); |
|
coords.append(l.previous()->toString(Qt::ISODateWithMs)); |
|
coords.append(c->longitude()); |
|
coords.append(c->latitude()); |
|
coords.append(c->altitude()); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
bool useDateTime = !fixedPosition && mapItem->m_positionDateTime.isValid(); |
|
|
|
// Update positions that have been recalculated with interpolation |
|
if (!mapItem->m_interpolatedCoords.isEmpty()) |
|
{ |
|
for (int i = 0; i < mapItem->m_interpolatedCoords.size(); i++) |
|
{ |
|
if (useDateTime) { |
|
coords.push_back(mapItem->m_interpolatedDateTimes[i]->toString(Qt::ISODateWithMs)); |
|
} |
|
coords.push_back(finiteOrZero(mapItem->m_interpolatedCoords[i]->longitude())); |
|
coords.push_back(finiteOrZero(mapItem->m_interpolatedCoords[i]->latitude())); |
|
// The same offset the live position gets below - 0,0,0 is the |
|
// middle of a 3D model, not the bottom of its undercarriage, so |
|
// without it these samples sit lower than the ones around them |
|
coords.push_back(finiteOrZero(mapItem->m_interpolatedCoords[i]->altitude() + mapItem->m_modelAltitudeOffset)); |
|
} |
|
mapItem->m_interpolatedCoords.clear(); |
|
mapItem->m_interpolatedDateTimes.clear(); |
|
} |
|
else |
|
{ |
|
// Only send latest position, to reduce processing |
|
if (!mapItem->m_takenTrackPositionExtrapolated.isEmpty() && mapItem->m_takenTrackPositionExtrapolated.back()) |
|
{ |
|
if (useDateTime) { |
|
coords.push_back(mapItem->m_takenTrackDateTimes.back()->toString(Qt::ISODateWithMs)); |
|
} |
|
coords.push_back(finiteOrZero(mapItem->m_takenTrackCoords.back()->longitude())); |
|
coords.push_back(finiteOrZero(mapItem->m_takenTrackCoords.back()->latitude())); |
|
} |
|
else |
|
{ |
|
if (useDateTime) { |
|
coords.push_back(mapItem->m_positionDateTime.toString(Qt::ISODateWithMs)); |
|
} |
|
coords.push_back(finiteOrZero(mapItem->m_longitude)); |
|
coords.push_back(finiteOrZero(mapItem->m_latitude)); |
|
} |
|
if (!mapItem->m_takenTrackAltitudeExtrapolated.isEmpty() && mapItem->m_takenTrackAltitudeExtrapolated.back()) { |
|
coords.push_back(finiteOrZero(mapItem->m_takenTrackCoords.back()->altitude())); |
|
} else { |
|
coords.push_back(finiteOrZero(mapItem->m_altitude + mapItem->m_modelAltitudeOffset)); // See nodeTransformations comment below, as to why we use this here |
|
} |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
coords = m_lastPosition.value(id); |
|
} |
|
// A position that has not moved does not need re-sending. For a fixed item - an |
|
// airport, a navaid, an airspace - that is every update after the first, and there |
|
// are of the order of 200,000 of those in the model. |
|
const bool positionUnchanged = existingId && m_lastPosition.contains(id) |
|
&& (m_lastPosition.value(id) == coords); |
|
|
|
QJsonObject position { |
|
{"cartographicDegrees", coords}, |
|
}; |
|
if (!fixedPosition) |
|
{ |
|
// Don't use forward extrapolation for satellites (with predicted tracks), as |
|
// it seems to jump about. We use it for AIS and ADS-B that don't have predicted tracks |
|
if (mapItem->m_predictedTrackCoords.size() == 0) |
|
{ |
|
// Need 2 different positions to enable extrapolation, otherwise entity may not appear |
|
bool hasMoved = m_hasMoved.contains(id); |
|
|
|
if (!hasMoved && m_lastPosition.contains(id) && (m_lastPosition.value(id) != coords)) |
|
{ |
|
hasMoved = true; |
|
m_hasMoved.insert(id, true); |
|
} |
|
if (hasMoved && (mapItem->m_itemSettings->m_extrapolate > 0)) |
|
{ |
|
position.insert("forwardExtrapolationType", "EXTRAPOLATE"); |
|
//position.insert("forwardExtrapolationType", "LINEAR_EXTRAPOLATE"); // LAGRANGE is poor for extrapolation |
|
//position.insert("forwardExtrapolationType", "HOLD"); // Keeps at last position |
|
// Extrapolation carries the last vertical rate on, so an aircraft still |
|
// descending when its updates stop is flown down through the ground and |
|
// keeps going - they were seen 82 m under it. It may only be extrapolated |
|
// for as long as the height it had would last at the rate it was losing |
|
// it: an aircraft at cruise is unaffected, one on approach stops being |
|
// extrapolated at the point it would have arrived. Only for items drawn |
|
// at an absolute altitude that are meant to sit above the ground, so |
|
// shipping, which is clamped to it, is untouched |
|
int extrapolationSeconds = mapItem->m_itemSettings->m_extrapolate; |
|
if ((mapItem->m_altitudeReference == 3) && (descentRate > 0.0) && (mapItem->m_altitude > 0.0f)) |
|
{ |
|
const int secondsToGround = (int) (mapItem->m_altitude / descentRate); |
|
extrapolationSeconds = qMin(extrapolationSeconds, qMax(1, secondsToGround)); |
|
} |
|
position.insert("forwardExtrapolationDuration", extrapolationSeconds); |
|
// To calc acceleration, we need to use non-linear interpolation. |
|
position.insert("interpolationAlgorithm", "LINEAR"); |
|
position.insert("interpolationDegree", 2); |
|
//position.insert("interpolationAlgorithm", "HERMITE"); |
|
//position.insert("interpolationDegree", 2); |
|
//position.insert("interpolationAlgorithm", "LAGRANGE"); |
|
//position.insert("interpolationDegree", 5); // crazy interpolation for LAGRANGE |
|
} |
|
else |
|
{ |
|
position.insert("forwardExtrapolationType", "HOLD"); |
|
} |
|
} |
|
else |
|
{ |
|
// Interpolation goes wrong at end points. FIXME: Check if still true |
|
//position.insert("interpolationAlgorithm", "LAGRANGE"); |
|
//position.insert("interpolationDegree", 5); |
|
//position.insert("interpolationAlgorithm", "HERMITE"); |
|
//position.insert("interpolationDegree", 2); |
|
} |
|
} |
|
|
|
QQuaternion q = Coordinates::orientation(mapItem->m_longitude, mapItem->m_latitude, mapItem->m_altitude, |
|
mapItem->m_heading, mapItem->m_pitch, mapItem->m_roll); |
|
QJsonArray quaternion; |
|
if (!fixedPosition && mapItem->m_orientationDateTime.isValid()) { |
|
quaternion.push_back(mapItem->m_orientationDateTime.toString(Qt::ISODateWithMs)); |
|
} |
|
quaternion.push_back(q.x()); |
|
quaternion.push_back(q.y()); |
|
quaternion.push_back(q.z()); |
|
quaternion.push_back(q.scalar()); |
|
|
|
QJsonObject orientation { |
|
{"unitQuaternion", quaternion}, |
|
{"forwardExtrapolationType", "HOLD"}, // If we extrapolate, aircraft tend to spin around |
|
{"forwardExtrapolationDuration", mapItem->m_itemSettings->m_extrapolate}, |
|
// {"interpolationAlgorithm", "LAGRANGE"} |
|
}; |
|
QJsonObject orientationPosition { |
|
{"velocityReference", "#position"}, |
|
}; |
|
QJsonObject noPosition { |
|
{"cartographicDegrees", coords}, |
|
{"forwardExtrapolationType", "NONE"} |
|
}; |
|
|
|
if (!removeObj) |
|
{ |
|
QJsonObject properties; |
|
if (mapItem->m_aircraftState) |
|
{ |
|
// A replay sample has its own frame time. Live/coalesced senders omit it |
|
// and retain the historical behaviour of tying state to the position time. |
|
QDateTime aircraftStateDateTime = mapItem->m_aircraftState->m_dateTime.isValid() |
|
? mapItem->m_aircraftState->m_dateTime : mapItem->m_positionDateTime; |
|
QString dateTime = aircraftStateDateTime.toString(Qt::ISODateWithMs); |
|
bool aircraftStateDateTimeChanged = aircraftStateDateTime != state.m_aircraftStateDateTime; |
|
const bool replayState = mapItem->m_aircraftState->m_dateTime.isValid(); |
|
QString aircraftCallsign = mapItem->m_aircraftState->m_callsign; |
|
QString aircraftType = mapItem->m_aircraftState->m_aircraftType; |
|
// During replay this is a complete snapshot, so even fields whose most |
|
// recent measurement has its own time are sampled at the frame time. That |
|
// preserves their held value throughout the replay instead of letting the |
|
// CZML 30-second extrapolation expire between sparse measurements. |
|
QString aircraftIndicatedAirspeedDateTime = replayState |
|
? dateTime : mapItem->m_aircraftState->m_indicatedAirspeedDateTime; |
|
float aircraftIndicatedAirspeed = mapItem->m_aircraftState->m_indicatedAirspeed; |
|
float aircraftTrueAirspeed = mapItem->m_aircraftState->m_trueAirspeed; |
|
float aircraftGroundspeed = mapItem->m_aircraftState->m_groundspeed; |
|
QString aircraftAltitudeDateTime = replayState |
|
? dateTime : mapItem->m_aircraftState->m_altitudeDateTime; |
|
float aircraftAltitude = mapItem->m_aircraftState->m_altitude; |
|
int aircraftOnSurface = mapItem->m_aircraftState->m_onSurface; |
|
float aircraftMach = mapItem->m_aircraftState->m_mach; |
|
float aircraftQNH = mapItem->m_aircraftState->m_qnh; |
|
float aircraftVerticalSpeed = mapItem->m_aircraftState->m_verticalSpeed; |
|
float aircraftHeading = mapItem->m_aircraftState->m_heading; |
|
float aircraftTrack = mapItem->m_aircraftState->m_track; |
|
float aircraftRoll = mapItem->m_roll; |
|
// The same estimate that orients the 3D model, so the attitude indicator and |
|
// the aircraft on the map agree |
|
float aircraftPitch = mapItem->m_pitch; |
|
float aircraftSelectedAltitude = mapItem->m_aircraftState->m_selectedAltitude; |
|
float aircraftSelectedHeading = mapItem->m_aircraftState->m_selectedHeading; |
|
int aircraftAutopilot = mapItem->m_aircraftState->m_autopilot; |
|
MapAircraftState::VerticalMode aircraftVerticalMode = mapItem->m_aircraftState->m_verticalMode; |
|
MapAircraftState::LateralMode aircraftLateralMode = mapItem->m_aircraftState->m_lateralMode; |
|
MapAircraftState::TCASMode aircraftTCASMode = mapItem->m_aircraftState->m_tcasMode; |
|
int aircraftTcasRA = mapItem->m_aircraftState->m_tcasRA; |
|
QString aircraftTcasThreatIcao = mapItem->m_aircraftState->m_tcasThreatIcao; |
|
int aircraftSquawk = mapItem->m_aircraftState->m_squawk; |
|
QString aircraftIcao = mapItem->m_aircraftState->m_icao; |
|
float aircraftWindSpeed = mapItem->m_aircraftState->m_windSpeed; |
|
float aircraftWindDirection = mapItem->m_aircraftState->m_windDirection; |
|
float aircraftStaticAirTemperature = mapItem->m_aircraftState->m_staticAirTemperature; |
|
|
|
if ( (!existingId && !aircraftCallsign.isEmpty()) |
|
|| (aircraftCallsign != state.m_aircraftState.m_callsign) |
|
) |
|
{ |
|
insertConstantProperty(properties, "pfdCallsign", aircraftCallsign); |
|
state.m_aircraftState.m_callsign = aircraftCallsign; |
|
} |
|
if ( (!existingId && !aircraftType.isEmpty()) |
|
|| (aircraftType != state.m_aircraftState.m_aircraftType) |
|
) |
|
{ |
|
insertConstantProperty(properties, "pfdAircraftType", aircraftType); |
|
state.m_aircraftState.m_aircraftType = aircraftType; |
|
} |
|
state.m_chIndicatedAirspeed.write(properties, "pfdIndicatedAirspeed", |
|
aircraftIndicatedAirspeedDateTime, aircraftStateDateTime, aircraftIndicatedAirspeed, |
|
!existingId && !aircraftIndicatedAirspeedDateTime.isEmpty()); |
|
state.m_chTrueAirspeed.write(properties, "pfdTrueAirspeed", |
|
dateTime, aircraftStateDateTime, aircraftTrueAirspeed, |
|
!existingId); |
|
state.m_chGroundspeed.write(properties, "pfdGroundspeed", |
|
dateTime, aircraftStateDateTime, aircraftGroundspeed, |
|
!existingId); |
|
state.m_chAltitude.write(properties, "pfdAltitude", |
|
aircraftAltitudeDateTime, aircraftStateDateTime, aircraftAltitude, |
|
!existingId && !aircraftAltitudeDateTime.isEmpty()); |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftOnSurface != state.m_aircraftState.m_onSurface) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdOnSurface", dateTime, aircraftOnSurface); |
|
state.m_aircraftState.m_onSurface = aircraftOnSurface; |
|
} |
|
state.m_chMach.write(properties, "pfdMach", |
|
dateTime, aircraftStateDateTime, aircraftMach, |
|
!existingId); |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftQNH != state.m_aircraftState.m_qnh) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdQNH", dateTime, aircraftQNH); |
|
state.m_aircraftState.m_qnh = aircraftQNH; |
|
} |
|
state.m_chVerticalSpeed.write(properties, "pfdVerticalSpeed", |
|
dateTime, aircraftStateDateTime, aircraftVerticalSpeed, |
|
!existingId); |
|
state.m_chHeading.write(properties, "pfdHeading", |
|
dateTime, aircraftStateDateTime, aircraftHeading, |
|
!existingId); |
|
state.m_chTrack.write(properties, "pfdTrack", |
|
dateTime, aircraftStateDateTime, aircraftTrack, |
|
!existingId); |
|
state.m_chRoll.write(properties, "pfdRoll", |
|
dateTime, aircraftStateDateTime, aircraftRoll, |
|
!existingId); |
|
state.m_chPitch.write(properties, "pfdPitch", |
|
dateTime, aircraftStateDateTime, aircraftPitch, |
|
!existingId); |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftSelectedAltitude != state.m_aircraftState.m_selectedAltitude) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdSelectedAltitude", dateTime, aircraftSelectedAltitude); |
|
state.m_aircraftState.m_selectedAltitude = aircraftSelectedAltitude; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftSelectedHeading != state.m_aircraftState.m_selectedHeading) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdSelectedHeading", dateTime, aircraftSelectedHeading); |
|
state.m_aircraftState.m_selectedHeading = aircraftSelectedHeading; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftAutopilot != state.m_aircraftState.m_autopilot) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdAutopilot", dateTime, aircraftAutopilot); |
|
state.m_aircraftState.m_autopilot = aircraftAutopilot; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftVerticalMode != state.m_aircraftState.m_verticalMode) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdVerticalMode", dateTime, aircraftVerticalMode); |
|
state.m_aircraftState.m_verticalMode = aircraftVerticalMode; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftLateralMode != state.m_aircraftState.m_lateralMode) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdLateralMode", dateTime, aircraftLateralMode); |
|
state.m_aircraftState.m_lateralMode = aircraftLateralMode; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftTCASMode != state.m_aircraftState.m_tcasMode) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdTCASMode", dateTime, aircraftTCASMode); |
|
state.m_aircraftState.m_tcasMode = aircraftTCASMode; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftTcasRA != state.m_aircraftState.m_tcasRA) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdTcasRA", dateTime, aircraftTcasRA); |
|
state.m_aircraftState.m_tcasRA = aircraftTcasRA; |
|
} |
|
if ( (!existingId && !aircraftTcasThreatIcao.isEmpty()) |
|
|| (aircraftTcasThreatIcao != state.m_aircraftState.m_tcasThreatIcao) |
|
) |
|
{ |
|
insertConstantProperty(properties, "pfdThreatIcao", aircraftTcasThreatIcao); |
|
state.m_aircraftState.m_tcasThreatIcao = aircraftTcasThreatIcao; |
|
} |
|
if ( (!existingId && (aircraftSquawk >= 0)) |
|
|| (aircraftSquawk != state.m_aircraftState.m_squawk) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdSquawk", dateTime, aircraftSquawk); |
|
state.m_aircraftState.m_squawk = aircraftSquawk; |
|
} |
|
if ( (!existingId && !aircraftIcao.isEmpty()) |
|
|| (aircraftIcao != state.m_aircraftState.m_icao) |
|
) |
|
{ |
|
insertConstantProperty(properties, "pfdIcao", aircraftIcao); |
|
state.m_aircraftState.m_icao = aircraftIcao; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftWindSpeed != state.m_aircraftState.m_windSpeed) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdWindSpeed", dateTime, aircraftWindSpeed); |
|
state.m_aircraftState.m_windSpeed = aircraftWindSpeed; |
|
} |
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftWindDirection != state.m_aircraftState.m_windDirection) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdWindDirection", dateTime, aircraftWindDirection); |
|
state.m_aircraftState.m_windDirection = aircraftWindDirection; |
|
} |
|
|
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
|| (aircraftStaticAirTemperature != state.m_aircraftState.m_staticAirTemperature) |
|
) |
|
{ |
|
insertProperty0(properties, "pfdStaticAirTemperature", dateTime, aircraftStaticAirTemperature); |
|
state.m_aircraftState.m_staticAirTemperature = aircraftStaticAirTemperature; |
|
} |
|
|
|
QString ndPlan = flightPlanJson(mapItem->m_aircraftState->m_flightPlan); |
|
if ( (!existingId && !ndPlan.isEmpty()) |
|
|| (existingId && (ndPlan != state.m_ndFlightPlan)) // Empty when a plan goes away, so the ND clears it |
|
) |
|
{ |
|
insertConstantProperty(properties, "ndFlightPlan", ndPlan); |
|
state.m_ndFlightPlan = ndPlan; |
|
} |
|
|
|
QString dcduMessage = datalinkMessageJson(mapItem->m_aircraftState->m_datalinkMessage); |
|
if ( (!existingId && !dcduMessage.isEmpty()) |
|
|| (existingId && (dcduMessage != state.m_dcduMessage)) |
|
) |
|
{ |
|
insertConstantProperty(properties, "dcduMessage", dcduMessage); |
|
state.m_dcduMessage = dcduMessage; |
|
} |
|
|
|
//QJsonObject speedProperty { |
|
// {"velocityReference", "#position"}, |
|
//}; |
|
//properties.insert("pfdSpeed", speedProperty); |
|
|
|
if ( !existingId |
|
|| aircraftStateDateTimeChanged |
|
) |
|
{ |
|
state.m_aircraftStateDateTime = aircraftStateDateTime; |
|
} |
|
|
|
} |
|
|
|
// The engine sound looped at the item, which is on the item rather than the |
|
// aircraft state, so it works for anything the sender knows a sound for |
|
if ( (!existingId && !mapItem->m_loopSound.isEmpty()) |
|
|| (existingId && (mapItem->m_loopSound != state.m_loopSound)) |
|
) |
|
{ |
|
insertConstantProperty(properties, "loopSound", mapItem->m_loopSound); |
|
state.m_loopSound = mapItem->m_loopSound; |
|
} |
|
|
|
if (properties.size() > 0) { |
|
obj.insert("properties", properties); |
|
} |
|
|
|
// ... while a moving aircraft still sends one every update, which is the point |
|
if (!positionUnchanged) { |
|
obj.insert("position", position); |
|
} |
|
|
|
if (!fixedPosition) |
|
{ |
|
// Orientation is a sampled property, so a sample Cesium already has is a no-op |
|
// there - and a packet raised by something else, an altitude message say, |
|
// carries the same sample as the last one. That was 36% of the orientations |
|
// sent in a measured run, at ~190 bytes each. |
|
if (mapItem->m_useHeadingPitchRoll) |
|
{ |
|
const int extrapolate = mapItem->m_itemSettings->m_extrapolate; |
|
if ( (state.m_orientationMode != 1) |
|
|| (quaternion != state.m_orientationQuaternion) |
|
|| (extrapolate != state.m_orientationExtrapolate)) |
|
{ |
|
obj.insert("orientation", orientation); |
|
state.m_orientationMode = 1; |
|
state.m_orientationQuaternion = quaternion; |
|
state.m_orientationExtrapolate = extrapolate; |
|
} |
|
} |
|
else if (state.m_orientationMode != 0) // A reference to the position: constant |
|
{ |
|
obj.insert("orientation", orientationPosition); |
|
state.m_orientationMode = 0; |
|
state.m_orientationQuaternion = QJsonArray(); |
|
} |
|
} |
|
|
|
// Point |
|
quint32 pointColorInt = mapItem->m_itemSettings->m_3DPointColor; |
|
int pointAltitudeReference = clipRatherThanClamp(mapItem->m_altitudeReference); |
|
bool pointShow = mapItem->m_itemSettings->m_enabled && mapItem->m_itemSettings->m_display3DPoint; |
|
|
|
if ( !existingId |
|
|| (pointColorInt != state.m_pointColorInt) |
|
|| (pointAltitudeReference != state.m_pointAltitudeReference) |
|
|| (pointShow != state.m_pointShow) |
|
) |
|
{ |
|
QColor pointColor = QColor::fromRgba(pointColorInt); |
|
QJsonArray pointRGBA { |
|
pointColor.red(), pointColor.green(), pointColor.blue(), pointColor.alpha() |
|
}; |
|
QJsonObject pointColorObj { |
|
{"rgba", pointRGBA} |
|
}; |
|
QJsonObject point { |
|
{"pixelSize", 8}, |
|
{"color", pointColorObj}, |
|
{"heightReference", heightReferences[pointAltitudeReference]}, |
|
{"show", pointShow} |
|
}; |
|
obj.insert("point", point); |
|
|
|
state.m_pointColorInt = pointColorInt; |
|
state.m_pointAltitudeReference = pointAltitudeReference; |
|
state.m_pointShow = pointShow; |
|
} |
|
|
|
// Label |
|
|
|
float labelAltitudeOffset = mapItem->m_labelAltitudeOffset; |
|
QString labelText = mapItem->m_label; |
|
bool labelShow = m_settings->m_displayNames && mapItem->m_itemSettings->m_enabled && mapItem->m_itemSettings->m_display3DLabel; |
|
float labelScale = mapItem->m_itemSettings->m_3DLabelScale; |
|
int labelAltitudeReference = clipRatherThanClamp(mapItem->m_altitudeReference); |
|
|
|
if ( !existingId |
|
|| (labelAltitudeOffset != state.m_lableAltitudeOffset) |
|
|| (labelText != state.m_labelText) |
|
|| (labelShow != state.m_labelShow) |
|
|| (labelScale != state.m_labelScale) |
|
|| (labelAltitudeReference != state.m_labelAltitudeReference) |
|
) |
|
{ |
|
// Prevent labels from being too cluttered when zoomed out |
|
// FIXME: These values should come from mapItem or mapItemSettings |
|
float displayDistanceMax = std::numeric_limits<float>::max(); |
|
if ((mapItem->m_group == "Beacons") |
|
|| (mapItem->m_group == "AM") || (mapItem->m_group == "FM") || (mapItem->m_group == "DAB") |
|
|| (mapItem->m_group == "NavAid") |
|
|| (mapItem->m_group == "Waypoints") |
|
) { |
|
displayDistanceMax = 1000000; |
|
} else if ((mapItem->m_group == "Station") || (mapItem->m_group == "Radar") || (mapItem->m_group == "Radio Time Transmitters") |
|
|| (mapItem->m_group == "WEFAX Transmitters")) { |
|
displayDistanceMax = 10000000; |
|
} else if (mapItem->m_group == "Ionosonde Stations") { |
|
displayDistanceMax = 30000000; |
|
} |
|
|
|
QJsonArray labelPixelOffsetScaleArray { |
|
1000000, 20, 10000000, 5 |
|
}; |
|
QJsonObject labelPixelOffsetScaleObject { |
|
{"nearFarScalar", labelPixelOffsetScaleArray} |
|
}; |
|
QJsonArray labelPixelOffsetArray { |
|
1, 0 |
|
}; |
|
QJsonObject labelPixelOffset { |
|
{"cartesian2", labelPixelOffsetArray} |
|
}; |
|
QJsonArray labelEyeOffsetArray { |
|
0, labelAltitudeOffset, 0 // Position above the object, dependent on the height of the model |
|
}; |
|
QJsonObject labelEyeOffset { |
|
{"cartesian", labelEyeOffsetArray} |
|
}; |
|
QJsonObject labelHorizontalOrigin { |
|
{"horizontalOrigin", "LEFT"} |
|
}; |
|
QJsonArray labelDisplayDistance { |
|
0, displayDistanceMax |
|
}; |
|
QJsonObject labelDistanceDisplayCondition { |
|
{"distanceDisplayCondition", labelDisplayDistance} |
|
}; |
|
|
|
// On a copy: replace() is in place, and the state must keep the raw text it is |
|
// compared against, or the guard above never matches and the whole label - |
|
// ~390 bytes of styling - goes out on every packet, as it did until measured |
|
QString labelDisplayText = labelText; |
|
labelDisplayText.replace("<br>", "\n"); |
|
QJsonObject label { |
|
//{"text", labelText}, |
|
{"show", labelShow}, |
|
{"scale", labelScale}, |
|
{"pixelOffset", labelPixelOffset}, |
|
{"pixelOffsetScaleByDistance", labelPixelOffsetScaleObject}, |
|
{"eyeOffset", labelEyeOffset}, |
|
{"verticalOrigin", "BASELINE"}, |
|
{"horizontalOrigin", "LEFT"}, |
|
{"heightReference", heightReferences[labelAltitudeReference]}, |
|
{"style", "FILL_AND_OUTLINE"}, |
|
}; |
|
if (!mapItem->m_labelDateTime.isValid()) |
|
{ |
|
label.insert("text", labelDisplayText); |
|
} |
|
else |
|
{ |
|
QString interval = sampleTime(mapItem->m_labelDateTime.toString(Qt::ISODateWithMs)) + "/2999-12-31"; |
|
QJsonObject labelInterval { |
|
{"interval", interval}, |
|
{"string", labelDisplayText} |
|
}; |
|
QJsonArray labelIntervalArray { |
|
labelInterval |
|
}; |
|
label.insert("text", labelIntervalArray); |
|
} |
|
if (displayDistanceMax != std::numeric_limits<float>::max()) { |
|
label.insert("distanceDisplayCondition", labelDistanceDisplayCondition); |
|
} |
|
|
|
obj.insert("label", label); |
|
|
|
state.m_lableAltitudeOffset = labelAltitudeOffset; |
|
state.m_labelText = labelText; |
|
state.m_labelShow = labelShow; |
|
state.m_labelScale = labelScale; |
|
state.m_labelAltitudeReference = labelAltitudeReference; |
|
} |
|
|
|
if (!mapItem->m_model.isEmpty()) |
|
{ |
|
// Model |
|
QString modelGLTF = m_settings->m_modelURL + mapItem->m_model; |
|
int modelAltitudeReference = mapItem->m_altitudeReference; |
|
bool modelShow = mapItem->m_itemSettings->m_enabled && mapItem->m_itemSettings->m_display3DModel; |
|
int modelMinimumPixelSize = mapItem->m_itemSettings->m_3DModelMinPixelSize; |
|
|
|
if ( !existingId |
|
|| (modelGLTF != state.m_modelGLTF) |
|
|| (modelAltitudeReference != state.m_modelAltitudeReference) |
|
|| (modelShow != state.m_modelShow) |
|
|| (modelMinimumPixelSize != state.m_modelMinimumPixelSize) |
|
) |
|
{ |
|
QJsonObject model { |
|
{"gltf", modelGLTF}, |
|
// With the default of true an aircraft flashes untextured as it appears, |
|
// and every shader it has is built twice: once without its textures and |
|
// again when they arrive |
|
{"incrementallyLoadTextures", false}, |
|
{"heightReference", heightReferences[modelAltitudeReference]}, |
|
{"runAnimations", false}, |
|
{"show", modelShow}, |
|
{"minimumPixelSize", modelMinimumPixelSize}, |
|
{"maximumScale", 20000} // Stop it getting too big when zoomed really far out |
|
}; |
|
// Using nodeTransformations stops animations from running. |
|
// See: https://github.com/CesiumGS/cesium/issues/11566 |
|
/*QJsonArray node0Cartesian { |
|
{0.0, mapItem->m_modelAltitudeOffset, 0.0} |
|
}; |
|
QJsonObject node0Translation { |
|
{"cartesian", node0Cartesian} |
|
}; |
|
QJsonObject node0Transform { |
|
{"translation", node0Translation} |
|
}; |
|
QJsonObject nodeTransforms { |
|
{"node0", node0Transform}, |
|
}; |
|
if (mapItem->m_modelAltitudeOffset != 0.0) { |
|
model.insert("nodeTransformations", nodeTransforms); |
|
}*/ |
|
|
|
// Not CZML: map3d.html takes it out, and switches the entity to this |
|
// model while the aircraft is small on screen |
|
const QString lowDetail = Aircraft3DModels::instance().lowDetailModel(mapItem->m_model); |
|
if (!lowDetail.isEmpty()) { |
|
model.insert("lowDetailGltf", m_settings->m_modelURL + lowDetail); |
|
} |
|
|
|
obj.insert("model", model); |
|
|
|
state.m_modelGLTF = modelGLTF; |
|
state.m_modelAltitudeReference = modelAltitudeReference; |
|
state.m_modelShow = modelShow; |
|
state.m_modelMinimumPixelSize = modelMinimumPixelSize; |
|
} |
|
// A packet only adds to what Cesium has for an entity, so an item that was a |
|
// billboard and now has a model would otherwise show both |
|
if (state.m_billboardShown) |
|
{ |
|
obj.insert("billboard", QJsonObject{{"show", false}}); |
|
state.m_billboardShown = false; |
|
} |
|
} |
|
else |
|
{ |
|
// And the other way round: an aircraft whose model is taken away - its stand-in |
|
// replaced by one for its emitter category that is not installed - was left |
|
// drawn as the old model with the billboard on top of it |
|
if (!state.m_modelGLTF.isEmpty()) |
|
{ |
|
obj.insert("model", QJsonObject{{"show", false}}); |
|
state.m_modelGLTF.clear(); |
|
} |
|
state.m_billboardShown = true; |
|
|
|
// Use billboard for APRS as we don't currently have 3D objects |
|
QString imageURL = mapItem->m_image; |
|
if (imageURL.startsWith("qrc://")) { |
|
imageURL = imageURL.mid(6); // Redirect to our embedded webserver, which will check resources |
|
} |
|
QJsonObject billboard { |
|
{"image", imageURL}, |
|
{"show", true}, // In case a model had hidden it |
|
{"heightReference", heightReferences[clipRatherThanClamp(mapItem->m_altitudeReference)]}, |
|
{"verticalOrigin", "BOTTOM"} // To stop it being cut in half when zoomed out |
|
}; |
|
|
|
obj.insert("billboard", billboard); |
|
} |
|
|
|
// Description |
|
// Images in the description are qrc:/// URLs, which Qt Quick and the widgets |
|
// resolve themselves, but the 3D map is a page served over http and Chromium |
|
// refuses to load a local scheme resource from it - "Not allowed to load local |
|
// resource". Point them at the embedded web server, which looks the path up in |
|
// our resources, exactly as the billboard image above is redirected |
|
QString description = mapItem->m_text; |
|
description.replace("qrc://", ""); |
|
if ( !existingId |
|
|| (description != state.m_description) |
|
) |
|
{ |
|
obj.insert("description", description); |
|
state.m_description = description; |
|
} |
|
|
|
// Path |
|
if (!fixedPosition) |
|
{ |
|
quint32 pathColorInt = mapItem->m_itemSettings->m_3DTrackColor; |
|
bool pathShow = mapItem->m_itemSettings->m_enabled |
|
&& mapItem->m_itemSettings->m_display3DTrack |
|
&& ( m_settings->m_displayAllGroundTracks |
|
|| (m_settings->m_displaySelectedGroundTracks && isSelected)); |
|
// When a palette is set - or the supplied track is smoothed - the track is |
|
// drawn as polylines instead - see updateTrackSegments3D(). Items with a |
|
// predicted track keep the path, which also draws the future leg. |
|
if ( ( !mapItem->m_itemSettings->m_2DTrackPalette.isEmpty() |
|
|| ( (mapItem->m_itemSettings->m_smoothingWindow > 0) |
|
&& mapItem->m_trackSupplied)) |
|
&& mapItem->m_predictedTrackCoords.isEmpty()) { |
|
pathShow = false; |
|
} |
|
|
|
if ( !existingId |
|
|| (pathColorInt != state.m_pathColorInt) |
|
|| (pathShow != state.m_pathShow) |
|
) |
|
{ |
|
QColor pathColor = QColor::fromRgba(pathColorInt); |
|
QJsonArray pathColorRGBA { |
|
pathColor.red(), pathColor.green(), pathColor.blue(), pathColor.alpha() |
|
}; |
|
QJsonObject pathColorObj { |
|
{"rgba", pathColorRGBA} |
|
}; |
|
// Paths can't be clamped to ground, so AIS paths can be underground if terrain is used |
|
// See: https://github.com/CesiumGS/cesium/issues/7133 |
|
QJsonObject pathSolidColorMaterial { |
|
{"color", pathColorObj} |
|
}; |
|
QJsonObject pathMaterial { |
|
{"solidColor", pathSolidColorMaterial} |
|
}; |
|
QJsonObject path { |
|
// We want full paths for sat tracker, so leadTime and trailTime should be 0 |
|
// Should be configurable.. 6000=100mins ~> 1 orbit for LEO |
|
//{"leadTime", "6000"}, |
|
//{"trailTime", "6000"}, |
|
{"width", "3"}, |
|
{"material", pathMaterial}, |
|
{"show", pathShow}, |
|
{"resolution", 1} |
|
}; |
|
|
|
obj.insert("path", path); |
|
|
|
state.m_pathColorInt = pathColorInt; |
|
state.m_pathShow = pathShow; |
|
} |
|
} |
|
|
|
// Availability, when it has changed. It moves on with each position - which is |
|
// what keeps an aircraft that has gone quiet from being drawn for ever - but a |
|
// packet raised by anything else carried the same interval again: 63% of them |
|
QString availability; |
|
if (!fixedPosition && (mapItem->m_takenTrackDateTimes.size() > 0) && (mapItem->m_predictedTrackDateTimes.size() > 0)) |
|
{ |
|
availability = QString("%1/%2") |
|
.arg(mapItem->m_takenTrackDateTimes.last()->toString(Qt::ISODateWithMs)) |
|
.arg(mapItem->m_predictedTrackDateTimes.last()->toString(Qt::ISODateWithMs)); |
|
} |
|
else if (mapItem->m_availableUntil.isValid()) |
|
{ |
|
availability = QString("%1/%2").arg(state.m_firstSeenDateTime).arg(mapItem->m_availableUntil.toString(Qt::ISODateWithMs)); |
|
} |
|
if (!availability.isEmpty() && (availability != state.m_availability)) |
|
{ |
|
obj.insert("availability", availability); |
|
state.m_availability = availability; |
|
} |
|
m_lastPosition.insert(id, coords); |
|
} |
|
else |
|
{ |
|
// Disable forward extrapolation |
|
obj.insert("position", noPosition); |
|
} |
|
|
|
//qDebug() << obj; |
|
|
|
/*if (id == "400b00") |
|
{ |
|
QJsonDocument doc(obj); |
|
if (!m_file.isOpen()) |
|
{ |
|
m_file.setFileName(QString("%1.czml").arg(id)); |
|
m_file.open(QIODeviceBase::WriteOnly); |
|
} |
|
m_file.write(doc.toJson()); |
|
m_file.write(",\n"); |
|
}*/ |
|
|
|
return obj; |
|
}
|
|
|