/////////////////////////////////////////////////////////////////////////////////// // Copyright (C) 2022-2023 Jon Beniston, M7RCE // // Copyright (C) 2022 Edouard Griffiths, F4EXB // // // // 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 . // /////////////////////////////////////////////////////////////////////////////////// #include #include "channel/channelwebapiutils.h" #include "util/flightpathpalette.h" #include "util/units.h" #include "util/profiler.h" #include "maincore.h" #include "mapmodel.h" #include "mapgui.h" #include "map.h" #include "SWGTargetAzimuthElevation.h" #include "SWGMapAircraftState.h" QVariant MapModel::data(const QModelIndex &index, int role) const { int row = index.row(); if ((row < 0) || (row >= m_items.count())) { return QVariant(); } switch (role) { case itemSettingsRole: return QVariant::fromValue(m_items[row]->m_itemSettings); case nameRole: return QVariant::fromValue(m_items[row]->m_name); case labelRole: return QVariant::fromValue(m_items[row]->m_label); case positionRole: { // Coordinates to display the label at QGeoCoordinate coords; coords.setLatitude(m_items[row]->m_latitude); coords.setLongitude(m_items[row]->m_longitude); coords.setAltitude(m_items[row]->m_altitude); return QVariant::fromValue(coords); } case mapImageMinZoomRole: // Minimum zoom level at which this is visible return QVariant::fromValue(m_items[row]->m_itemSettings->m_2DMinZoom); default: return QVariant(); } } bool MapModel::setData(const QModelIndex &index, const QVariant& value, int role) { (void) value; (void) role; int row = index.row(); if ((row < 0) || (row >= m_items.count())) { return false; } return true; } void MapModel::add(MapItem *item) { beginInsertRows(QModelIndex(), rowCount(), rowCount()); item->m_row = m_items.size(); m_items.append(item); m_filterData.append(FilterData()); fillFilterData(item, m_filterData.last()); m_itemsHash.insert(item->m_hashKey, item); endInsertRows(); } void MapModel::update(const QObject *sourcePipe, SWGSDRangel::SWGMapItem *swgMapItem, const QString &group) { QString name = *swgMapItem->getName(); // Add, update or delete and item MapItem *item = findMapItem(sourcePipe, name); if (item != nullptr) { QString image = *swgMapItem->getImage(); if (image.isEmpty()) { // Delete the item from 2D map remove(item); // Delete from 3D map item->update(swgMapItem); update3D(item); delete item; } else { // Update the item item->update(swgMapItem); // Explicitly timestamped aircraft states are replay samples. They must // reach CZML now: the ordinary model flush deliberately coalesces every // update to an item, which would otherwise retain only the last PFD state // from a fast ADS-B log load. The item remains dirty so the 2D map can // still redraw once per normal batch. SWGSDRangel::SWGMapAircraftState *aircraftState = swgMapItem->getAircraftState(); if (aircraftState && aircraftState->getDateTime() && !aircraftState->getDateTime()->isEmpty()) { ObjectMapItem *objectItem = dynamic_cast(item); if (objectItem) { objectItem->m_replayTrackPending = true; objectItem->m_replayStateUpdate = true; update3D(item); objectItem->m_replayStateUpdate = false; } } update(item); } } else { // Make sure not a duplicate request to delete QString image = *swgMapItem->getImage(); if (!image.isEmpty()) { // Add new item item = newMapItem(sourcePipe, group, m_gui->getItemSettings(group), swgMapItem); add(item); // Add to 3D Map (we don't appear to get a dataChanged signal when adding) update3D(item); } } } void MapModel::update(MapItem *item) { markDirty(item, item->m_changed); } // The expensive tests - the user's name regex and the great-circle distance to the // station - are done here, once per change to an item, rather than once per item every // time the map moves void MapModel::fillFilterData(MapItem *item, FilterData& data) const { const MapSettings::MapItemSettings *itemSettings = item->m_itemSettings; data.m_latitude = item->m_latitude; data.m_longitude = item->m_longitude; data.m_minZoom = itemSettings->m_2DMinZoom; data.m_flags = 0; if (itemSettings->m_enabled) { data.m_flags |= FilterEnabled; } if (itemSettings->m_display2DIcon) { data.m_flags |= FilterDisplayIcon; } if (itemSettings->m_filterName.isEmpty() || itemSettings->m_filterNameRE.match(item->m_name).hasMatch()) { data.m_flags |= FilterNameMatches; } if (itemSettings->m_filterDistance <= 0) { data.m_flags |= FilterDistanceOk; } else if (m_stationPosition.isValid()) { const QGeoCoordinate position(item->m_latitude, item->m_longitude); if (m_stationPosition.distanceTo(position) <= itemSettings->m_filterDistance) { data.m_flags |= FilterDistanceOk; } } } void MapModel::updateFilterData(int row) { if ((row >= 0) && (row < m_filterData.size())) { fillFilterData(m_items[row], m_filterData[row]); } } void MapModel::rebuildFilterData() { m_filterData.resize(m_items.size()); for (int row = 0; row < m_items.size(); row++) { fillFilterData(m_items[row], m_filterData[row]); } } void MapModel::setStationPosition(const QGeoCoordinate& position) { m_stationPosition = position; rebuildFilterData(); } void MapModel::markDirty(MapItem *item, quint32 changed) { if (item->m_row >= 0) { m_dirty[item] |= changed; // Kept in step here rather than at flush time, so that a pan in between the two // filters on where the item actually is updateFilterData(item->m_row); } } // Tell the map about everything that has changed since the last time, coalescing runs of // neighbouring rows that changed in the same way in to a single signal void MapModel::flush() { if (m_dirty.isEmpty()) { return; } const quint32 of3DInterest = MapItem::ChangedPosition | MapItem::ChangedLabel | MapItem::ChangedImage | MapItem::ChangedText | MapItem::ChangedGeometry | MapItem::ChangedSelection | MapItem::Changed3D; // Bracketed around the whole loop rather than per item: PROFILER_STOP takes a global // mutex, and the per item cost is already covered by Map CZML. This gives what the 3D // map costs per flush, which is the figure to compare against Map flush. PROFILER_START() CesiumInterface *cesium = m_gui->cesium(); const bool batching = cesium && cesium->isConnected(); if (batching) { cesium->beginBatch(); } for (auto it = m_dirty.cbegin(); it != m_dirty.cend(); ++it) { updateFilterData(it.key()->m_row); quint32 interest = of3DInterest; // With a track palette set - or smoothing on - the 3D map draws the track // itself as polylines, so track changes matter to it. Per item rather than in // the mask above: everything else's 3D track is drawn by Cesium from the // position samples, and needs no update when the track changes. if ( !it.key()->m_itemSettings->m_2DTrackPalette.isEmpty() || (it.key()->m_itemSettings->m_smoothingWindow > 0)) { interest |= MapItem::ChangedTrack | MapItem::ChangedPredictedTrack; } if (it.value() & interest) { update3D(it.key()); } } if (batching) { cesium->endBatch(); } PROFILER_STOP("Map 3D update") QVector> pending; pending.reserve(m_dirty.size()); for (auto it = m_dirty.cbegin(); it != m_dirty.cend(); ++it) { if (it.key()->m_row >= 0) { pending.append(qMakePair(it.key()->m_row, it.value())); } } m_dirty.clear(); std::sort(pending.begin(), pending.end()); for (int i = 0; i < pending.size(); ) { const quint32 changed = pending[i].second; int last = i; while ((last + 1 < pending.size()) && (pending[last + 1].second == changed) && (pending[last + 1].first == pending[last].first + 1)) { last++; } emit dataChanged(index(pending[i].first), index(pending[last].first), rolesFor(changed)); i = last + 1; } } QVector MapModel::rolesFor(quint32 changed) const { if (changed == MapItem::ChangedAll) { return QVector(); // All of them } if (m_roleCache.contains(changed)) { return m_roleCache.value(changed); } QVector roles; if (changed & MapItem::ChangedPosition) { roles.append(positionRole); } if (changed & (MapItem::ChangedLabel | MapItem::ChangedText | MapItem::ChangedSelection)) { roles.append(labelRole); } m_roleCache.insert(changed, roles); return roles; } void MapModel::remove(MapItem *item) { int row = item->m_row; if (row >= 0) { QString key = m_items[row]->m_hashKey; beginRemoveRows(QModelIndex(), row, row); m_items.removeAt(row); m_filterData.remove(row); m_itemsHash.remove(key); m_dirty.remove(item); item->m_row = -1; // Everything after it has moved up one for (int i = row; i < m_items.size(); i++) { m_items[i]->m_row = i; } endRemoveRows(); } } void MapModel::removeAll() { if (m_items.count() > 0) { beginRemoveRows(QModelIndex(), 0, m_items.count() - 1); for (auto item : m_items) { item->m_row = -1; } m_dirty.clear(); qDeleteAll(m_items); m_items.clear(); m_filterData.clear(); m_itemsHash.clear(); endRemoveRows(); } } // After new settings are deserialised, we need to update // pointers to item settings for all existing items void MapModel::updateItemSettings(QHash m_itemSettings) { for (auto item : m_items) { if (m_itemSettings.contains(item->m_group)) { item->m_itemSettings = m_itemSettings[item->m_group]; } } rebuildFilterData(); } void MapModel::allUpdated() { // Settings are what most of the filter data is derived from, and this is called // whenever they change rebuildFilterData(); if (m_items.count() > 0) { emit dataChanged(index(0), index(m_items.count()-1)); // The 3D map is no longer driven by dataChanged, so it has to be told here. // update3D() returns immediately when the 3D map isn't running. // // Batched, because this walks EVERY item - of the order of 200,000 once the // airport, navaid, airspace and waypoint databases are loaded. Most of them will // produce nothing at all now that an unchanged item emits only its id, but the // ones that do produce something should still travel together. CesiumInterface *cesium = m_gui->cesium(); const bool batching = cesium && cesium->isConnected(); if (batching) { cesium->beginBatch(); } for (auto item : m_items) { update3D(item); } if (batching) { cesium->endBatch(); } } } MapItem *MapModel::findMapItem(const QObject *source, const QString& name) { QString key = source->objectName() + name; if (m_itemsHash.contains(key)) { return m_itemsHash.value(key); } return nullptr; } // FIXME: This should potentially return a list, as we have have multiple items with the same name // from different sources MapItem *MapModel::findMapItem(const QString& name) { QListIterator i(m_items); while (i.hasNext()) { MapItem *item = i.next(); if (!item->m_name.compare(name, Qt::CaseInsensitive)) { return item; } } return nullptr; } QModelIndex MapModel::findMapItemIndex(const QString& name) { int idx = 0; QListIterator i(m_items); while (i.hasNext()) { MapItem *item = i.next(); if (item->m_name == name) { return index(idx); } idx++; } return index(-1); } QHash MapModel::roleNames() const { QHash roles; roles[itemSettingsRole] = "itemSettings"; roles[nameRole] = "name"; roles[labelRole] = "label"; roles[positionRole] = "position"; roles[mapImageMinZoomRole] = "mapImageMinZoom"; return roles; } // Slot called on dataChanged signal, to update 3D map MapItem *ImageMapModel::newMapItem(const QObject *sourcePipe, const QString &group, MapSettings::MapItemSettings *itemSettings, SWGSDRangel::SWGMapItem *mapItem) { return new ImageMapItem(sourcePipe, group, itemSettings, mapItem); } QVariant ImageMapModel::data(const QModelIndex &index, int role) const { int row = index.row(); if ((row < 0) || (row >= m_items.count())) { return QVariant(); } ImageMapItem *mapItem = (ImageMapItem*)m_items[row]; switch (role) { case imageRole: return QVariant::fromValue(mapItem->m_image); case imageZoomLevelRole: return QVariant::fromValue(mapItem->m_imageZoomLevel); case boundsRole: return QVariant::fromValue(mapItem->m_bounds); default: return MapModel::data(index, role); } } // These items have an extent, so the filter tests that rather than a single position void ImageMapModel::fillFilterData(MapItem *item, FilterData& data) const { MapModel::fillFilterData(item, data); const QGeoRectangle& bounds = ((const ImageMapItem *) item)->m_bounds; data.m_boundsTop = bounds.topLeft().latitude(); data.m_boundsBottom = bounds.bottomRight().latitude(); data.m_boundsLeft = bounds.topLeft().longitude(); data.m_boundsRight = bounds.bottomRight().longitude(); } void ImageMapModel::update3D(MapItem *item) { CesiumInterface *cesium = m_gui->cesium(); if (cesium) { ImageMapItem *imageItem = (ImageMapItem *)item; if (!imageItem->m_image.isEmpty()) { /*qDebug() << "ImageMapModel::update3D - " << imageItem->m_name << imageItem->m_bounds.right() << imageItem->m_bounds.left() << imageItem->m_bounds.top() << imageItem->m_bounds.bottom() ; */ cesium->updateImage(imageItem->m_name, imageItem->m_bounds.topRight().longitude(), imageItem->m_bounds.bottomLeft().longitude(), imageItem->m_bounds.topRight().latitude(), imageItem->m_bounds.bottomLeft().latitude(), imageItem->m_altitude, imageItem->m_image); } else { qDebug() << "ImageMapModel::update3D - removeImage " << imageItem->m_name; cesium->removeImage(imageItem->m_name); } } } MapItem *PolygonMapModel::newMapItem(const QObject *sourcePipe, const QString &group, MapSettings::MapItemSettings *itemSettings, SWGSDRangel::SWGMapItem *mapItem) { return new PolygonMapItem(sourcePipe, group, itemSettings, mapItem); } QVariant PolygonMapModel::data(const QModelIndex &index, int role) const { int row = index.row(); if ((row < 0) || (row >= m_items.count())) { return QVariant(); } PolygonMapItem *polygonItem = ((PolygonMapItem *)m_items[row]); switch (role) { case borderColorRole: return QVariant::fromValue(QColor(0x00, 0x00, 0x00, 0x00)); // Transparent case fillColorRole: if (polygonItem->m_itemSettings->m_display2DTrack) { if (polygonItem->m_colorValid) { return QVariant::fromValue(QColor::fromRgba(polygonItem->m_color)); } else { return QVariant::fromValue(QColor::fromRgba(polygonItem->m_itemSettings->m_2DTrackColor)); } } else { return QVariant::fromValue(QColor(0x00, 0x00, 0x00, 0x00)); // Transparent } case polygonRole: return polygonItem->m_polygon; case boundsRole: return QVariant::fromValue(polygonItem->m_bounds); default: return MapModel::data(index, role); } } // These items have an extent, so the filter tests that rather than a single position void PolygonMapModel::fillFilterData(MapItem *item, FilterData& data) const { MapModel::fillFilterData(item, data); const QGeoRectangle& bounds = ((const PolygonMapItem *) item)->m_bounds; data.m_boundsTop = bounds.topLeft().latitude(); data.m_boundsBottom = bounds.bottomRight().latitude(); data.m_boundsLeft = bounds.topLeft().longitude(); data.m_boundsRight = bounds.bottomRight().longitude(); } void PolygonMapModel::update3D(MapItem *item) { CesiumInterface *cesium = m_gui->cesium(); if (cesium) { cesium->update((PolygonMapItem *)item); } } MapItem *PolylineMapModel::newMapItem(const QObject *sourcePipe, const QString &group, MapSettings::MapItemSettings *itemSettings, SWGSDRangel::SWGMapItem *mapItem) { PolylineMapItem *item = new PolylineMapItem(sourcePipe, group, itemSettings, mapItem); // Before it is added, because adding it is what makes the map read its roles - an // item is only marked dirty when it CHANGES, so a new one would never reach flush() updateTrackSegments(item); return item; } // A line drawn as a track is split in to runs of constant colour, the colour of each point // coming from its altitude and the group's palette. The same mapping an object's ground // track uses, so a track drawn on its own looks like one drawn under an aircraft. void PolylineMapModel::updateTrackSegments(PolylineMapItem *item) { const QString& paletteName = item->m_itemSettings->m_2DTrackPalette; if (!item->m_altitudeColored || paletteName.isEmpty()) { // Drawn in a single colour instead, by the plain polyline delegate if (item->m_trackColorModel) { item->m_trackColorModel->clear(); } return; } const QVariant *palette = FlightPathPalette::getPalette(paletteName); QList segments; QList colors; int lastColor = -1; for (const QVariant& point : item->m_polyline) { const QGeoCoordinate coord = point.value(); const int colorIndex = FlightPathPalette::getColorIndex(Units::metresToFeet(coord.altitude())); if (colorIndex != lastColor) { // Repeat the point the colour changes at in the segment that ends there, so // there's no gap between the two if (lastColor >= 0) { segments.last().append(point); } segments.append(QVariantList()); colors.append(palette[colorIndex]); lastColor = colorIndex; } segments.last().append(point); } if (!item->m_trackColorModel) { item->m_trackColorModel = new TrackColorModel(); } // No firstChanged: unlike a ground track, which grows a point at a time, a line is // re-sent whole whenever it changes at all item->m_trackColorModel->update(segments, colors); } void PolylineMapModel::flush() { for (auto it = m_dirty.cbegin(); it != m_dirty.cend(); ++it) { updateTrackSegments((PolylineMapItem *) it.key()); } MapModel::flush(); } // The palette is a setting, so a change to it recolours every line already drawn void PolylineMapModel::allUpdated() { for (auto item : m_items) { updateTrackSegments((PolylineMapItem *) item); } MapModel::allUpdated(); } QVariant PolylineMapModel::data(const QModelIndex &index, int role) const { int row = index.row(); if ((row < 0) || (row >= m_items.count())) { return QVariant(); } PolylineMapItem *polylineItem = (PolylineMapItem *)m_items[row]; switch (role) { case lineColorRole: if (polylineItem->m_colorValid) { return QVariant::fromValue(QColor::fromRgba(polylineItem->m_color)); } else { return QVariant::fromValue(QColor::fromRgba(polylineItem->m_itemSettings->m_2DTrackColor)); } case coordinatesRole: // Nothing for the plain delegate to draw when the segments are drawing it, or the // two would be drawn one on top of the other and the single colour would win if (polylineItem->m_trackColorModel && (polylineItem->m_trackColorModel->rowCount() > 0)) { return QVariant::fromValue(QVariantList()); } return QVariant::fromValue(polylineItem->m_polyline); case trackModelRole: if (polylineItem->m_trackColorModel) { return QVariant::fromValue(polylineItem->m_trackColorModel); } return QVariant::fromValue(&m_noTrackColors); case boundsRole: return QVariant::fromValue(polylineItem->m_bounds); default: return MapModel::data(index, role); } } // These items have an extent, so the filter tests that rather than a single position void PolylineMapModel::fillFilterData(MapItem *item, FilterData& data) const { MapModel::fillFilterData(item, data); const QGeoRectangle& bounds = ((const PolylineMapItem *) item)->m_bounds; data.m_boundsTop = bounds.topLeft().latitude(); data.m_boundsBottom = bounds.bottomRight().latitude(); data.m_boundsLeft = bounds.topLeft().longitude(); data.m_boundsRight = bounds.bottomRight().longitude(); } void PolylineMapModel::update3D(MapItem *item) { CesiumInterface *cesium = m_gui->cesium(); if (cesium) { cesium->update((PolylineMapItem *)item); } } void ObjectMapModel::allUpdated() { for (auto item : m_items) { updateTrackSegments((ObjectMapItem *) item); } MapModel::allUpdated(); } QVariant TrackColorModel::data(const QModelIndex& index, int role) const { int row = index.row(); if ((row < 0) || (row >= m_segments.size())) { return QVariant(); } if (role == segmentCoordinatesRole) { return m_segments[row]; } else if (role == segmentColorRole) { return m_colors[row]; } return QVariant(); } void TrackColorModel::update(const QList& segments, const QList& colors, int firstChanged) { if (segments.size() == m_segments.size()) { // Same segments as last time, just longer or shorter, so update them in place // rather than having the map delete and recreate a polyline for each one m_segments = segments; m_colors = colors; if (!m_segments.isEmpty() && (firstChanged < m_segments.size())) { emit dataChanged(index(qMax(0, firstChanged)), index(m_segments.size() - 1)); } } else { beginResetModel(); m_segments = segments; m_colors = colors; endResetModel(); } } void TrackColorModel::clear() { if (!m_segments.isEmpty()) { beginResetModel(); m_segments.clear(); m_colors.clear(); endResetModel(); } } ObjectMapModel::ObjectMapModel(MapGUI *gui) : MapModel(gui), m_target(-1), m_frontZOrder(0.0), m_backZOrder(0.0), m_displayNames(false), m_displaySelectedGroundTracks(false), m_displayAllGroundTracks(false), m_bottomLeftLongitude(0.0), m_bottomRightLongitude(0.0) { //connect(this, &ObjectMapModel::dataChanged, this, &ObjectMapModel::update3DMap); } Q_INVOKABLE void ObjectMapModel::add(MapItem *item) { m_selected.append(false); MapModel::add(item); } /*void ObjectMapModel::update(const QObject *sourcePipe, SWGSDRangel::SWGMapItem *swgMapItem, const QString &group) { QString name = *swgMapItem->getName(); // Add, update or delete and item ObjectMapItem *item = (ObjectMapItem *)MapModel::findMapItem(sourcePipe, name); if (item != nullptr) { QString image = *swgMapItem->getImage(); if (image.isEmpty()) { // Delete the item remove(item); // Need to call update, for it to be removed in 3D map // Item is set to not be available from this point in time // It will still be available if time is set in the past item->update(swgMapItem); } else { // Update the item item->update(swgMapItem); splitTracks(item); // ******** diff from base FIXME update(item); } } else { // Make sure not a duplicate request to delete QString image = *swgMapItem->getImage(); if (!image.isEmpty()) { // Add new item item = (ObjectMapItem *)newMapItem(sourcePipe, group, m_gui->getItemSettings(group), swgMapItem); add(item); // Add to 3D Map (we don't appear to get a dataChanged signal when adding) update3D(item); } } }*/ MapItem *ObjectMapModel::newMapItem(const QObject *sourcePipe, const QString &group, MapSettings::MapItemSettings *itemSettings, SWGSDRangel::SWGMapItem *mapItem) { return new ObjectMapItem(sourcePipe, group, itemSettings, mapItem); } void ObjectMapModel::update3D(MapItem *item) { CesiumInterface *cesium = m_gui->cesium(); if (cesium && cesium->isConnected()) // Wait until connected, otherwise initial czml will be lost { ObjectMapItem *objectMapItem = (ObjectMapItem *)item; cesium->update(objectMapItem, isTarget(objectMapItem), isSelected3D(objectMapItem)); // An immediate replay-state update intentionally skipped track serialization. // The normal batched update clears the debt after sending the complete tail. if (!objectMapItem->m_replayStateUpdate) { objectMapItem->m_replayTrackPending = false; } playAnimations(objectMapItem); } } // Slot called on dataChanged signal, to update 3D map /*void ObjectMapModel::update3DMap(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector &roles) { (void) roles; CesiumInterface *cesium = m_gui->cesium(); if (cesium) { for (int row = topLeft.row(); row <= bottomRight.row(); row++) { ObjectMapItem *item = (ObjectMapItem *)m_items[row]; cesium->update(item, isTarget(item), isSelected3D(item)); playAnimations(item); } } } */ void ObjectMapModel::playAnimations(ObjectMapItem *item) { CesiumInterface *cesium = m_gui->cesium(); if (cesium) { for (auto animation : item->m_animations) { m_gui->cesium()->playAnimation(item->m_name, animation); } } qDeleteAll(item->m_animations); item->m_animations.clear(); } void ObjectMapModel::update(MapItem *item) { // The track split and the target azimuth/elevation are done in flush(), so they // happen once per batch rather than once per message MapModel::update(item); } // An object that is off screen is still drawn if its track might be on screen void ObjectMapModel::fillFilterData(MapItem *item, FilterData& data) const { MapModel::fillFilterData(item, data); const ObjectMapItem *objectItem = (const ObjectMapItem *) item; const bool selected = (item->m_row >= 0) && (item->m_row < m_selected.size()) && m_selected[item->m_row]; // Based on the split of the track that actually gets drawn, so that this keeps the // same set of items on the map as before. The split is redone when the batch is // flushed, so this can lag what the item holds by one flush - only ever for an item // that is off screen, whose track isn't drawable until that flush anyway if ( (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && selected)) && ( (objectItem->m_predictedTrack1.size() > 1) || (objectItem->m_predictedTrack2.size() > 1) || (objectItem->m_takenTrack1.size() > 1) || (objectItem->m_takenTrack2.size() > 1))) { data.m_flags |= FilterHasTracks; } } void ObjectMapModel::flush() { if (!hasDirtyItems()) { return; } bool targetMoved = false; ObjectMapItem *targetItem = nullptr; for (auto it = m_dirty.cbegin(); it != m_dirty.cend(); ++it) { ObjectMapItem *item = (ObjectMapItem *) it.key(); if (it.value() & (MapItem::ChangedTrack | MapItem::ChangedPredictedTrack)) { splitTracks(item); } if (item->m_row == m_target) { targetMoved = true; targetItem = item; } } if (targetMoved) { updateTarget(); // The target's label carries the azimuth, elevation, range and coordinates that // updateTarget() has just recomputed, so for THIS row a change of position is a // change of label as well. Saying so in rolesFor() instead would reassign the // label of every moving item on every flush, which is the cost that scoping the // roles exists to avoid - here it is one row, once a flush. Safe after the loop // above has finished, and picked up by the flush below. markDirty(targetItem, MapItem::ChangedLabel); } MapModel::flush(); } QVector ObjectMapModel::rolesFor(quint32 changed) const { if (changed == MapItem::ChangedAll) { return QVector(); // All of them } if (m_roleCache.contains(changed)) { return m_roleCache.value(changed); } QVector roles; if (changed & MapItem::ChangedPosition) { roles.append(positionRole); } if (changed & (MapItem::ChangedLabel | MapItem::ChangedText | MapItem::ChangedSelection)) { roles.append(labelRole); roles.append(mapTextVisibleRole); } if (changed & MapItem::ChangedText) { roles.append(frequenciesRole); roles.append(frequencyStringsRole); } if (changed & MapItem::ChangedImage) { roles.append(mapImageRole); roles.append(mapImageRotationRole); roles.append(mapImageVisibleRole); } if (changed & MapItem::ChangedZOrder) { roles.append(zOrderRole); } if (changed & MapItem::ChangedSelection) { roles.append(selectedRole); roles.append(targetRole); roles.append(bubbleColourRole); } // Which tracks are drawn depends on what is selected, as well as on the track itself if (changed & (MapItem::ChangedTrack | MapItem::ChangedSelection)) { roles.append(groundTrack1Role); roles.append(groundTrack2Role); roles.append(groundTrackModelRole); roles.append(groundTrackColorRole); } if (changed & (MapItem::ChangedPredictedTrack | MapItem::ChangedSelection)) { roles.append(predictedGroundTrack1Role); roles.append(predictedGroundTrack2Role); roles.append(predictedGroundTrackColorRole); } if (changed & (MapItem::ChangedTrack | MapItem::ChangedPredictedTrack | MapItem::ChangedSelection)) { roles.append(hasTracksRole); } m_roleCache.insert(changed, roles); return roles; } void ObjectMapModel::remove(MapItem *item) { int row = item->m_row; if (row >= 0) { ObjectMapItem *objectItem = (ObjectMapItem *) item; if (objectItem->m_tracked) { m_trackedItems.removeOne(objectItem); objectItem->m_tracked = false; } m_selected.removeAt(row); if (row == m_target) { m_target = -1; } else if (row < m_target) { m_target--; } MapModel::remove(item); } } void ObjectMapModel::removeAll() { for (auto item : m_trackedItems) { item->m_tracked = false; } m_trackedItems.clear(); MapModel::removeAll(); m_selected.clear(); } QHash ObjectMapModel::roleNames() const { QHash roles = MapModel::roleNames(); //roles[itemSettingsRole] = "itemSettings"; //roles[nameRole] = "name"; //roles[positionRole] = "position"; //roles[mapTextRole] = "mapText"; roles[MapModel::labelRole] = "mapText"; roles[mapTextVisibleRole] = "mapTextVisible"; roles[mapImageVisibleRole] = "mapImageVisible"; roles[mapImageRole] = "mapImage"; roles[mapImageRotationRole] = "mapImageRotation"; //roles[mapImageMinZoomRole] = "mapImageMinZoom"; roles[bubbleColourRole] = "bubbleColour"; roles[selectedRole] = "selected"; roles[targetRole] = "target"; roles[frequenciesRole] = "frequencies"; roles[frequencyStringsRole] = "frequencyStrings"; roles[predictedGroundTrack1Role] = "predictedGroundTrack1"; roles[predictedGroundTrack2Role] = "predictedGroundTrack2"; roles[groundTrack1Role] = "groundTrack1"; roles[groundTrack2Role] = "groundTrack2"; roles[groundTrackColorRole] = "groundTrackColor"; roles[predictedGroundTrackColorRole] = "predictedGroundTrackColor"; roles[hasTracksRole] = "hasTracks"; roles[groundTrackModelRole] = "groundTrackModel"; roles[zOrderRole] = "zOrder"; return roles; } void ObjectMapModel::updateTarget() { // Calculate range, azimuth and elevation to object from station AzEl *azEl = m_gui->getAzEl(); azEl->setTarget(m_items[m_target]->m_latitude, m_items[m_target]->m_longitude, m_items[m_target]->m_altitude); azEl->calculate(); // Send to Rotator Controllers QList rotatorPipes; MainCore::instance()->getMessagePipes().getMessagePipes(this, "target", rotatorPipes); for (const auto& pipe : rotatorPipes) { MessageQueue *messageQueue = qobject_cast(pipe->m_element); SWGSDRangel::SWGTargetAzimuthElevation *swgTarget = new SWGSDRangel::SWGTargetAzimuthElevation(); swgTarget->setName(new QString(m_items[m_target]->m_name)); swgTarget->setAzimuth(azEl->getAzimuth()); swgTarget->setElevation(azEl->getElevation()); messageQueue->push(MainCore::MsgTargetAzimuthElevation::create(m_gui->getMap(), swgTarget)); } } void ObjectMapModel::setTarget(const QString& name) { if (name.isEmpty()) { QModelIndex idx = index(-1); setData(idx, QVariant(-1), ObjectMapModel::targetRole); } else { QModelIndex idx = findMapItemIndex(name); setData(idx, QVariant(idx.row()), ObjectMapModel::targetRole); } } bool ObjectMapModel::isTarget(const ObjectMapItem *mapItem) const { if (m_target < 0) { return false; } else { return m_items[m_target] == mapItem; } } Q_INVOKABLE void ObjectMapModel::moveToFront(int row) { if ((row >= 0) && (row < m_items.size())) { m_frontZOrder += 1.0; m_items[row]->m_zOrder = m_frontZOrder; markDirty(m_items[row], MapItem::ChangedZOrder); flush(); } } Q_INVOKABLE void ObjectMapModel::moveToBack(int row) { if ((row >= 0) && (row < m_items.size())) { m_backZOrder -= 1.0; m_items[row]->m_zOrder = m_backZOrder; markDirty(m_items[row], MapItem::ChangedZOrder); flush(); } } Q_INVOKABLE void ObjectMapModel::link(const QString& url) { emit linkClicked(url); } QVariant ObjectMapModel::data(const QModelIndex &index, int role) const { int row = index.row(); if ((row < 0) || (row >= m_items.count())) { return QVariant(); } ObjectMapItem *mapItem = (ObjectMapItem*)m_items[row]; switch (role) { case labelRole: // mapTextRole) { // Create the text to go in the bubble next to the image QString name = mapItem->m_label.isEmpty() ? mapItem->m_name :mapItem->m_label; if (row == m_target) { AzEl *azEl = m_gui->getAzEl(); QString text = QString("%1
Az: %2%5 El: %3%5 Dist: %4 km
Coords: %6, %7") .arg(m_selected[row] ? mapItem->m_text : name) .arg(std::round(azEl->getAzimuth())) .arg(std::round(azEl->getElevation())) .arg(std::round(azEl->getDistance() / 1000.0)) .arg(QChar(0xb0)) .arg(mapItem->m_latitude) .arg(mapItem->m_longitude); return QVariant::fromValue(text); } else if (m_selected[row]) { return QVariant::fromValue(mapItem->m_text); } else { return QVariant::fromValue(name); } } case mapTextVisibleRole: return QVariant::fromValue((m_selected[row] || m_displayNames) && mapItem->m_itemSettings->m_display2DLabel); case mapImageVisibleRole: return QVariant::fromValue(mapItem->m_itemSettings->m_display2DIcon); case mapImageRole: // Set an image to use, preferring the livery icon when enabled and available if (!mapItem->m_liveryImage.isEmpty() && m_gui->useLiveryIcons()) { return QVariant::fromValue(mapItem->m_liveryImage); } return QVariant::fromValue(mapItem->m_image); case mapImageRotationRole: return QVariant::fromValue(mapItem->m_imageRotation); // Angle to rotate image by case bubbleColourRole: { // Select a background colour for the text bubble next to the item if (m_selected[row]) { return QVariant::fromValue(QColor("lightgreen")); } else { return QVariant::fromValue(QColor("lightblue")); } } case selectedRole: return QVariant::fromValue(m_selected[row]); case targetRole: return QVariant::fromValue(m_target == row); case frequenciesRole: return QVariant::fromValue(mapItem->m_frequencies); case frequencyStringsRole: return QVariant::fromValue(mapItem->m_frequencyStrings); case predictedGroundTrack1Role: { if ( (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && m_selected[row])) && mapItem->m_itemSettings->m_display2DTrack) { return mapItem->m_predictedTrack1; } else { return QVariantList(); } } case predictedGroundTrack2Role: { if ( (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && m_selected[row])) && mapItem->m_itemSettings->m_display2DTrack) { return mapItem->m_predictedTrack2; } else { return QVariantList(); } } case groundTrack1Role: { if ( (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && m_selected[row])) && mapItem->m_itemSettings->m_display2DTrack && mapItem->m_itemSettings->m_2DTrackPalette.isEmpty()) { return mapItem->m_takenTrack1; } else { return QVariantList(); } } case groundTrack2Role: { if ( (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && m_selected[row])) && mapItem->m_itemSettings->m_display2DTrack && mapItem->m_itemSettings->m_2DTrackPalette.isEmpty()) { return mapItem->m_takenTrack2; } else { return QVariantList(); } } case groundTrackModelRole: { if ( (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && m_selected[row])) && mapItem->m_itemSettings->m_display2DTrack && !mapItem->m_itemSettings->m_2DTrackPalette.isEmpty() && mapItem->m_trackColorModel) { return QVariant::fromValue(mapItem->m_trackColorModel); } else { return QVariant::fromValue(&m_noTrackColors); } } case zOrderRole: return QVariant::fromValue(mapItem->m_zOrder); case groundTrackColorRole: return QVariant::fromValue(QColor::fromRgb(mapItem->m_itemSettings->m_2DTrackColor)); case predictedGroundTrackColorRole: return QVariant::fromValue(QColor::fromRgb(mapItem->m_itemSettings->m_2DTrackColor).lighter()); case hasTracksRole: { bool hasTracks = (m_displayAllGroundTracks || (m_displaySelectedGroundTracks && m_selected[row])) && ( (mapItem->m_predictedTrack1.size() > 1) || (mapItem->m_predictedTrack2.size() > 1) || (mapItem->m_takenTrack1.size() > 1) || (mapItem->m_takenTrack2.size() > 1) ); return QVariant::fromValue(hasTracks); } default: return MapModel::data(index, role); } } bool ObjectMapModel::setData(const QModelIndex &idx, const QVariant& value, int role) { int row = idx.row(); if ((row < 0) || (row >= m_items.count())) return false; if (role == selectedRole) { m_selected[row] = value.toBool(); markDirty(m_items[row], MapItem::ChangedSelection); flush(); return true; } else if (role == targetRole) { if (m_target >= 0) { // Update text bubble for old target markDirty(m_items[m_target], MapItem::ChangedSelection); m_target = -1; } m_target = row; updateTarget(); markDirty(m_items[row], MapItem::ChangedSelection); flush(); return true; } return true; } void ObjectMapModel::setDisplayNames(bool displayNames) { m_displayNames = displayNames; allUpdated(); } void ObjectMapModel::setDisplaySelectedGroundTracks(bool displayGroundTracks) { // Whether an off-screen item is kept for its track depends on this m_displaySelectedGroundTracks = displayGroundTracks; allUpdated(); } void ObjectMapModel::setDisplayAllGroundTracks(bool displayGroundTracks) { // Whether an off-screen item is kept for its track depends on this m_displayAllGroundTracks = displayGroundTracks; allUpdated(); } void ObjectMapModel::track3D(int index) { if (index < m_items.count()) { MapItem *item = m_items[index]; m_gui->track3D(item->m_name); } } QStringList ObjectMapModel::getDeviceSets() const { return MainCore::instance()->getDeviceSetIds(true, true, false); // FIXME: MIMO currently disabled, as we can't get channel stream indexes } void ObjectMapModel::setFrequency(qint64 frequency, const QString& deviceSetId) { unsigned int deviceSetIndex; if (MainCore::getDeviceSetIndexFromId(deviceSetId, deviceSetIndex)) { // Set as centre frequency ChannelWebAPIUtils::setCenterFrequency(deviceSetIndex, frequency); } } void ObjectMapModel::splitTracks(ObjectMapItem *item) { PROFILER_START() if (!item->m_tracked && ((item->m_takenTrackCoords.size() > 1) || (item->m_predictedTrackCoords.size() > 1))) { item->m_tracked = true; m_trackedItems.append(item); } const bool hasTaken = item->m_takenTrackCoords.size() > 1; const bool hasPredicted = item->m_predictedTrackCoords.size() > 1; if (!hasTaken && !hasPredicted) { PROFILER_STOP("Map splitTracks") return; } const ViewLongitudes view = viewLongitudes(); if (hasTaken) { splitTakenTrack(item, view); updateTrackSegments(item); } if (hasPredicted) { splitTrack(view, item->m_predictedTrackCoords, item->m_predictedTrack, item->m_predictedTrack1, item->m_predictedTrack2, item->m_predictedStart1, item->m_predictedStart2, item->m_predictedEnd1, item->m_predictedEnd2); } PROFILER_STOP("Map splitTracks") } // Split the ground track in to segments of constant colour, so it can be drawn // showing the altitude the object was at. The track has already been split where it // crosses the edge of the map, so we split each of those parts again whenever the // altitude moves in to a different band. // Add points to the item's colour segments, starting a new segment wherever the altitude // moves in to a different band void ObjectMapModel::colorTrackPoints(ObjectMapItem *item, const QVariantList& track, int first, const QVariant *palette) { for (int i = first; i < track.size(); i++) { const QVariant& point = track.at(i); const QGeoCoordinate coord = point.value(); const int colorIndex = FlightPathPalette::getColorIndex(Units::metresToFeet(coord.altitude())); if (colorIndex != item->m_trackSegmentLastColor) { // Repeat the point the colour changes at in the segment that ends here, so // there's no gap between the two if (item->m_trackSegmentLastColor >= 0) { item->m_trackSegments.last().append(point); } item->m_trackSegments.append(QVariantList()); item->m_trackSegmentColors.append(palette[colorIndex]); item->m_trackSegmentLastColor = colorIndex; } item->m_trackSegments.last().append(point); } } void ObjectMapModel::updateTrackSegments(ObjectMapItem *item) { if (item->m_itemSettings->m_2DTrackPalette.isEmpty()) { // Not coloured by altitude - the track is drawn as a plain polyline instead if (item->m_trackColorModel) { item->m_trackColorModel->clear(); } item->m_trackSegmentPoints = 0; item->m_trackSegmentLastCoord = QGeoCoordinate(); item->m_trackSegmentRevision = item->m_takenTrackRevision; return; } PROFILER_START() const QString& paletteName = item->m_itemSettings->m_2DTrackPalette; const QVariant *palette = FlightPathPalette::getPalette(paletteName); // Nothing before the last point we looked at can have changed if the whole track is // on screen (so the split is just the track itself) and points have only been added // to the end of it. Then we only have to colour what is new const bool extend = item->m_takenTrackWholeOnScreen && item->m_takenTrack2.isEmpty() && (item->m_trackSegmentPoints > 0) && (item->m_takenTrack1.size() >= item->m_trackSegmentPoints) && (item->m_takenTrack1[item->m_trackSegmentPoints - 1].value() == item->m_trackSegmentLastCoord) && (item->m_trackSegmentRevision == item->m_takenTrackRevision) && (item->m_trackSegmentPalette == paletteName); if (!extend) { item->m_trackSegments.clear(); item->m_trackSegmentColors.clear(); item->m_trackSegmentPoints = 0; item->m_trackSegmentLastColor = -1; item->m_trackSegmentPalette = paletteName; } // Colour the first part, continuing from where we left off if we can. Only the // segment we carry on from, and anything after it, can have changed const int firstChanged = extend ? qMax(0, (int) item->m_trackSegments.size() - 1) : 0; colorTrackPoints(item, item->m_takenTrack1, extend ? item->m_trackSegmentPoints : 0, palette); item->m_trackSegmentPoints = item->m_takenTrack1.size(); item->m_trackSegmentLastCoord = item->m_takenTrack1.isEmpty() ? QGeoCoordinate() : item->m_takenTrack1.last().value(); item->m_trackSegmentRevision = item->m_takenTrackRevision; // The second part starts at the edge of the screen, so it doesn't join on to the // first. It is only ever non-empty when the track had to be split, which is also // when we rebuilt from scratch above if (!item->m_takenTrack2.isEmpty()) { item->m_trackSegmentLastColor = -1; colorTrackPoints(item, item->m_takenTrack2, 0, palette); } if (!item->m_trackColorModel) { item->m_trackColorModel = new TrackColorModel(); } item->m_trackColorModel->update(item->m_trackSegments, item->m_trackSegmentColors, firstChanged); PROFILER_STOP("Map trackSegments") } void ObjectMapModel::interpolateEast(QGeoCoordinate *c1, QGeoCoordinate *c2, double x, QGeoCoordinate *ci, bool offScreen) { double x1 = c1->longitude(); double y1 = c1->latitude(); double x2 = c2->longitude(); double y2 = c2->latitude(); double y; if (x2 < x1) x2 += 360.0; if (x < x1) x += 360.0; y = interpolate(x1, y1, x2, y2, x); if (x > 180) x -= 360.0; if (offScreen) x -= 0.000000001; else x += 0.000000001; ci->setLongitude(x); ci->setLatitude(y); ci->setAltitude(c1->altitude()); } void ObjectMapModel::interpolateWest(QGeoCoordinate *c1, QGeoCoordinate *c2, double x, QGeoCoordinate *ci, bool offScreen) { double x1 = c1->longitude(); double y1 = c1->latitude(); double x2 = c2->longitude(); double y2 = c2->latitude(); double y; if (x2 > x1) x2 -= 360.0; if (x > x1) x -= 360.0; y = interpolate(x1, y1, x2, y2, x); if (x < -180) x += 360.0; if (offScreen) x += 0.000000001; else x -= 0.000000001; ci->setLongitude(x); ci->setLatitude(y); ci->setAltitude(c1->altitude()); } static bool isOnScreen(double lon, double bottomLeftLongitude, double bottomRightLongitude, double width, bool antimed) { bool onScreen = false; if (width == 360) onScreen = true; else if (!antimed) onScreen = (lon > bottomLeftLongitude) && (lon <= bottomRightLongitude); else onScreen = (lon > bottomLeftLongitude) || (lon <= bottomRightLongitude); return onScreen; } static bool crossesAntimeridian(double prevLon, double lon) { bool crosses = false; if ((prevLon > 90) && (lon < -90)) crosses = true; // West to East else if ((prevLon < -90) && (lon > 90)) crosses = true; // East to West return crosses; } static bool crossesAntimeridianEast(double prevLon, double lon) { bool crosses = false; if ((prevLon > 90) && (lon < -90)) crosses = true; // West to East return crosses; } static bool crossesAntimeridianWest(double prevLon, double lon) { bool crosses = false; if ((prevLon < -90) && (lon > 90)) crosses = true; // East to West return crosses; } static bool crossesEdge(double lon, double prevLon, double bottomLeftLongitude, double bottomRightLongitude) { // Determine if antimerdian is between the two points if (!crossesAntimeridian(prevLon, lon)) { bool crosses = false; if ((prevLon <= bottomRightLongitude) && (lon > bottomRightLongitude)) crosses = true; // Crosses right edge East else if ((prevLon >= bottomRightLongitude) && (lon < bottomRightLongitude)) crosses = true; // Crosses right edge West else if ((prevLon >= bottomLeftLongitude) && (lon < bottomLeftLongitude)) crosses = true; // Crosses left edge West else if ((prevLon <= bottomLeftLongitude) && (lon > bottomLeftLongitude)) crosses = true; // Crosses left edge East return crosses; } else { // Determine which point and the edge the antimerdian is between bool prevLonToRightCrossesAnti = crossesAntimeridianEast(prevLon, bottomRightLongitude); bool rightToLonCrossesAnti = crossesAntimeridianEast(bottomRightLongitude, lon); bool prevLonToLeftCrossesAnti = crossesAntimeridianWest(prevLon, bottomLeftLongitude); bool leftToLonCrossesAnti = crossesAntimeridianWest(bottomLeftLongitude, lon); bool crosses = false; if ( ((prevLon > bottomRightLongitude) && prevLonToRightCrossesAnti && (lon > bottomRightLongitude)) || ((prevLon <= bottomRightLongitude) && (lon <= bottomRightLongitude) && rightToLonCrossesAnti) ) crosses = true; // Crosses right edge East else if ( ((prevLon < bottomRightLongitude) && prevLonToRightCrossesAnti && (lon < bottomRightLongitude)) || ((prevLon >= bottomRightLongitude) && (lon >= bottomRightLongitude) && rightToLonCrossesAnti) ) crosses = true; // Crosses right edge West else if ( ((prevLon < bottomLeftLongitude) && prevLonToLeftCrossesAnti && (lon < bottomLeftLongitude)) || ((prevLon >= bottomLeftLongitude) && (lon >= bottomLeftLongitude) && leftToLonCrossesAnti) ) crosses = true; // Crosses left edge West else if ( ((prevLon > bottomLeftLongitude) && prevLonToLeftCrossesAnti && (lon > bottomLeftLongitude)) || ((prevLon <= bottomLeftLongitude) && (lon <= bottomLeftLongitude) && leftToLonCrossesAnti) ) crosses = true; // Crosses left edge East return crosses; } } void ObjectMapModel::interpolate(QGeoCoordinate *c1, QGeoCoordinate *c2, double bottomLeftLongitude, double bottomRightLongitude, QGeoCoordinate* ci, bool offScreen) { double x1 = c1->longitude(); double x2 = c2->longitude(); double crossesAnti = crossesAntimeridian(x1, x2); double x; // Need to work out which edge we're interpolating too // and whether antimeridian is in the way, as that flips x1x2 if (((x1 < x2) && !crossesAnti) || ((x1 > x2) && crossesAnti)) { x = offScreen ? bottomRightLongitude : bottomLeftLongitude; interpolateEast(c1, c2, x, ci, offScreen); } else { x = offScreen ? bottomLeftLongitude : bottomRightLongitude; interpolateWest(c1, c2, x, ci, offScreen); } } void ObjectMapModel::splitTakenTrack(ObjectMapItem *item, const ViewLongitudes& view) { if (wholeTrackOnScreen(view, item->m_takenTrackMinLongitude, item->m_takenTrackMaxLongitude)) { // Nothing to split. The lists are implicitly shared, so this is just a pointer // copy, rather than a walk over every point in the track item->m_takenTrack1 = item->m_takenTrack; item->m_takenTrack2.clear(); item->m_takenTrackWholeOnScreen = true; } else { splitTrack(view, item->m_takenTrackCoords, item->m_takenTrack, item->m_takenTrack1, item->m_takenTrack2, item->m_takenStart1, item->m_takenStart2, item->m_takenEnd1, item->m_takenEnd2); item->m_takenTrackWholeOnScreen = false; } } // The split only exists to stop MapPolyline drawing lines that cross the edge of the map // in the wrong place, so a track that is comfortably within what's on screen doesn't need // it. The margin covers the last track point being moved slightly by extrapolation after // the bounds were last extended bool ObjectMapModel::wholeTrackOnScreen(const ViewLongitudes& view, double minLongitude, double maxLongitude) { const double margin = 1.0; return !view.m_antimeridian && (view.m_width < 360) && (minLongitude - margin > view.m_bottomLeft) && (maxLongitude + margin <= view.m_bottomRight); } // Ask the map what it is showing. This is a synchronous call in to QML, so it's done // once per pass over the items rather than once per track ObjectMapModel::ViewLongitudes ObjectMapModel::viewLongitudes() const { QQuickItem* map = m_gui->getMapItem(); QVariant rectVariant; QMetaObject::invokeMethod(map, "mapRect", Q_RETURN_ARG(QVariant, rectVariant)); QGeoRectangle rect = qvariant_cast(rectVariant); ViewLongitudes view; view.m_bottomLeft = rect.bottomLeft().longitude(); view.m_bottomRight = rect.bottomRight().longitude(); view.m_width = round(rect.width()); view.m_antimeridian = (view.m_width == 360) || (view.m_bottomLeft > view.m_bottomRight); return view; } void ObjectMapModel::splitTrack(const ViewLongitudes& view, const QList& coords, const QVariantList& track, QVariantList& track1, QVariantList& track2, QGeoCoordinate& start1, QGeoCoordinate& start2, QGeoCoordinate& end1, QGeoCoordinate& end2) { /* QStringList l; for (int i = 0; i < track.size(); i++) { QGeoCoordinate c = track[i].value(); l.append(QString("%1").arg((int)c.longitude())); } qDebug() << "Init T: " << l; */ const double bottomLeftLongitude = view.m_bottomLeft; const double bottomRightLongitude = view.m_bottomRight; const int width = view.m_width; const bool antimed = view.m_antimeridian; /* qDebug() << "Anitmed visible: " << antimed; qDebug() << "bottomLeftLongitude: " << bottomLeftLongitude; qDebug() << "bottomRightLongitude: " << bottomRightLongitude; */ track1.clear(); track2.clear(); double lon, prevLon; bool onScreen, prevOnScreen; QList tracks({&track1, &track2}); QList ends({&end1, &end2}); QList starts({&start1, &start2}); int trackIdx = 0; for (int i = 0; i < coords.size(); i++) { lon = coords[i]->longitude(); if (i == 0) { prevLon = lon; prevOnScreen = true; // To avoid interpolation for first point } // Can be onscreen after having crossed edge from other side // Or can be onscreen after previously having been off screen onScreen = isOnScreen(lon, bottomLeftLongitude, bottomRightLongitude, width, antimed); bool crossedEdge = crossesEdge(lon, prevLon, bottomLeftLongitude, bottomRightLongitude); if ((onScreen && !crossedEdge) || (onScreen && !prevOnScreen)) { if ((i > 0) && (tracks[trackIdx]->size() == 0)) // Could also use (onScreen && !prevOnScreen)? { if (trackIdx >= starts.size()) break; // Interpolate from edge of screen interpolate(coords[i-1], coords[i], bottomLeftLongitude, bottomRightLongitude, starts[trackIdx], false); tracks[trackIdx]->append(QVariant::fromValue(*starts[trackIdx])); } tracks[trackIdx]->append(track[i]); } else if (tracks[trackIdx]->size() > 0) { // Either we've crossed to the other side, or have gone off screen if (trackIdx >= ends.size()) break; // Interpolate to edge of screen interpolate(coords[i-1], coords[i], bottomLeftLongitude, bottomRightLongitude, ends[trackIdx], true); tracks[trackIdx]->append(QVariant::fromValue(*ends[trackIdx])); // Start new track trackIdx++; if (trackIdx >= tracks.size()) { // This can happen with highly retrograde orbits, where trace 90% of period // will cover more than 360 degrees - delete last point as Map // will not be able to display it properly tracks[trackIdx-1]->removeLast(); break; } if (onScreen) { // Interpolate from edge of screen interpolate(coords[i-1], coords[i], bottomLeftLongitude, bottomRightLongitude, starts[trackIdx], false); tracks[trackIdx]->append(QVariant::fromValue(*starts[trackIdx])); tracks[trackIdx]->append(track[i]); } } prevLon = lon; prevOnScreen = onScreen; } /* l.clear(); for (int i = 0; i < track1.size(); i++) { QGeoCoordinate c = track1[i].value(); if (!c.isValid()) l.append("Invalid!"); else l.append(QString("%1").arg(c.longitude(), 0, 'f', 1)); } qDebug() << "T1: " << l; l.clear(); for (int i = 0; i < track2.size(); i++) { QGeoCoordinate c = track2[i].value(); if (!c.isValid()) l.append("Invalid!"); else l.append(QString("%1").arg(c.longitude(), 0, 'f', 1)); } qDebug() << "T2: " << l; */ } void ObjectMapModel::viewChanged(double bottomLeftLongitude, double bottomRightLongitude) { PROFILER_START() (void) bottomRightLongitude; if (!std::isnan(bottomLeftLongitude)) { const ViewLongitudes view = viewLongitudes(); for (ObjectMapItem *item : m_trackedItems) { const int row = item->m_row; if ((row >= 0) && item->m_itemSettings->m_enabled) { if (item->m_takenTrackCoords.size() > 1) { const bool wholeOnScreen = wholeTrackOnScreen(view, item->m_takenTrackMinLongitude, item->m_takenTrackMaxLongitude); // If it was wholly on screen before and still is, the split it already // has is the whole track, so the pan hasn't changed anything if (!wholeOnScreen || !item->m_takenTrackWholeOnScreen) { splitTakenTrack(item, view); updateTrackSegments(item); QModelIndex idx = index(row); QVector roles = {groundTrack1Role, groundTrack2Role, groundTrackModelRole}; emit dataChanged(idx, idx, roles); } } if (item->m_predictedTrackCoords.size() > 1) { splitTrack(view, item->m_predictedTrackCoords, item->m_predictedTrack, item->m_predictedTrack1, item->m_predictedTrack2, item->m_predictedStart1, item->m_predictedStart2, item->m_predictedEnd1, item->m_predictedEnd2); QModelIndex idx = index(row); QVector roles = {predictedGroundTrack1Role, predictedGroundTrack2Role}; emit dataChanged(idx, idx, roles); } } } } PROFILER_STOP("Map viewChanged") } // Longitude wraps at the antimeridian, and a QGeoRectangle that crosses it reports a // LEFT edge GREATER than its right - a view centred on the Pacific runs from 170 to // -170. That is why the tests below cannot be plain comparisons: "longitude >= 170 and // longitude <= -170" is false everywhere, so everything actually on screen was filtered // out and the map went empty. QGeoRectangle::intersects() handles the wrap, but it was // replaced by these scalar tests because it cost 10.5 ms a pan against 1.7 ms; these // keep that and handle the wrap too. // // An item can wrap as well as the view - a flight plan from Anchorage to Tokyo does - // so both sides are checked for it. static inline bool longitudeInView(double longitude, double left, double right) { return (left <= right) ? ((longitude >= left) && (longitude <= right)) : ((longitude >= left) || (longitude <= right)); } static inline bool longitudesOverlap(double aLeft, double aRight, double bLeft, double bRight) { const bool aWraps = aLeft > aRight; const bool bWraps = bLeft > bRight; if (aWraps && bWraps) { return true; // both contain the antimeridian, so they share it } if (aWraps) { return (bRight >= aLeft) || (bLeft <= aRight); } if (bWraps) { return (aRight >= bLeft) || (aLeft <= bRight); } return (aLeft <= bRight) && (aRight >= bLeft); } bool ObjectMapFilter::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const { (void) sourceParent; // Everything expensive was worked out when the item last changed - see // MapModel::fillFilterData. This runs for every row every time the map moves const MapModel::FilterData& data = ((const MapModel *) sourceModel())->filterData(sourceRow); if (!(data.m_flags & MapModel::FilterEnabled)) { return false; } // Don't show tiny items when we're zoomed out if (data.m_minZoom - 3 >= m_zoomLevel) { return false; } // Don't show off-screen items, unless they have tracks, as these may be on screen const bool onScreen = (data.m_latitude >= m_bottomRightLatitude) && (data.m_latitude <= m_topLeftLatitude) && longitudeInView(data.m_longitude, m_topLeftLongitude, m_bottomRightLongitude); if (!onScreen && !(data.m_flags & MapModel::FilterHasTracks)) { return false; } // The user's name and distance filters return (data.m_flags & (MapModel::FilterNameMatches | MapModel::FilterDistanceOk)) == (MapModel::FilterNameMatches | MapModel::FilterDistanceOk); } void ObjectMapFilter::viewChanged(double topLeftLongitude, double topLeftLatitude, double bottomRightLongitude, double bottomRightLatitude, double zoomLevel) { PROFILER_START() beginFilterChange(); m_zoomLevel = zoomLevel; if (!std::isnan(topLeftLongitude)) { m_topLeftLongitude = topLeftLongitude; m_topLeftLatitude = topLeftLatitude; m_bottomRightLongitude = bottomRightLongitude; m_bottomRightLatitude = bottomRightLatitude; } endFilterChange(); PROFILER_STOP("Map filter objects") } Q_INVOKABLE int ObjectMapFilter::mapRowToSource(int row) { QModelIndex sourceIndex = mapToSource(index(row, 0)); return sourceIndex.row(); } bool PolygonFilter::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const { (void) sourceParent; const MapModel::FilterData& data = ((const MapModel *) sourceModel())->filterData(sourceRow); if (!(data.m_flags & MapModel::FilterEnabled)) { return false; } // Don't show tiny items when we're zoomed out if (data.m_minZoom - 3 >= m_zoomLevel) { return false; } // Filter off-screen items, by overlap of their extent with what's visible if ( (data.m_boundsBottom > m_view.topLeft().latitude()) || (data.m_boundsTop < m_view.bottomRight().latitude()) || !longitudesOverlap(data.m_boundsLeft, data.m_boundsRight, m_view.topLeft().longitude(), m_view.bottomRight().longitude())) { return false; } // The user's name and distance filters return (data.m_flags & (MapModel::FilterNameMatches | MapModel::FilterDistanceOk)) == (MapModel::FilterNameMatches | MapModel::FilterDistanceOk); } void PolygonFilter::viewChanged(double topLeftLongitude, double topLeftLatitude, double bottomRightLongitude, double bottomRightLatitude, double zoomLevel) { PROFILER_START() beginFilterChange(); m_zoomLevel = zoomLevel; if (!std::isnan(topLeftLongitude)) { m_view = QGeoRectangle(QGeoCoordinate(topLeftLatitude, topLeftLongitude), QGeoCoordinate(bottomRightLatitude, bottomRightLongitude)); } endFilterChange(); PROFILER_STOP("Map filter polygons") } Q_INVOKABLE int PolygonFilter::mapRowToSource(int row) { QModelIndex sourceIndex = mapToSource(index(row, 0)); return sourceIndex.row(); } bool PolylineFilter::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const { (void) sourceParent; const MapModel::FilterData& data = ((const MapModel *) sourceModel())->filterData(sourceRow); if (!(data.m_flags & MapModel::FilterEnabled)) { return false; } // Don't show tiny items when we're zoomed out if (data.m_minZoom - 3 >= m_zoomLevel) { return false; } // Filter off-screen items, by overlap of their extent with what's visible if ( (data.m_boundsBottom > m_view.topLeft().latitude()) || (data.m_boundsTop < m_view.bottomRight().latitude()) || !longitudesOverlap(data.m_boundsLeft, data.m_boundsRight, m_view.topLeft().longitude(), m_view.bottomRight().longitude())) { return false; } // The user's name and distance filters return (data.m_flags & (MapModel::FilterNameMatches | MapModel::FilterDistanceOk)) == (MapModel::FilterNameMatches | MapModel::FilterDistanceOk); } void PolylineFilter::viewChanged(double topLeftLongitude, double topLeftLatitude, double bottomRightLongitude, double bottomRightLatitude, double zoomLevel) { PROFILER_START() beginFilterChange(); m_zoomLevel = zoomLevel; if (!std::isnan(topLeftLongitude)) { m_view = QGeoRectangle(QGeoCoordinate(topLeftLatitude, topLeftLongitude), QGeoCoordinate(bottomRightLatitude, bottomRightLongitude)); } endFilterChange(); PROFILER_STOP("Map filter polylines") } Q_INVOKABLE int PolylineFilter::mapRowToSource(int row) { QModelIndex sourceIndex = mapToSource(index(row, 0)); return sourceIndex.row(); } bool ImageFilter::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const { (void) sourceParent; const MapModel::FilterData& data = ((const MapModel *) sourceModel())->filterData(sourceRow); if (!(data.m_flags & MapModel::FilterEnabled)) { return false; } if (!(data.m_flags & MapModel::FilterDisplayIcon)) { return false; } // Don't show tiny items when we're zoomed out if (data.m_minZoom - 3 >= m_zoomLevel) { return false; } // Filter off-screen items, by overlap of their extent with what's visible if ( (data.m_boundsBottom > m_view.topLeft().latitude()) || (data.m_boundsTop < m_view.bottomRight().latitude()) || !longitudesOverlap(data.m_boundsLeft, data.m_boundsRight, m_view.topLeft().longitude(), m_view.bottomRight().longitude())) { return false; } // The user's name and distance filters return (data.m_flags & (MapModel::FilterNameMatches | MapModel::FilterDistanceOk)) == (MapModel::FilterNameMatches | MapModel::FilterDistanceOk); } void ImageFilter::viewChanged(double topLeftLongitude, double topLeftLatitude, double bottomRightLongitude, double bottomRightLatitude, double zoomLevel) { PROFILER_START() beginFilterChange(); m_zoomLevel = zoomLevel; if (!std::isnan(topLeftLongitude)) { m_view = QGeoRectangle(QGeoCoordinate(topLeftLatitude, topLeftLongitude), QGeoCoordinate(bottomRightLatitude, bottomRightLongitude)); } endFilterChange(); PROFILER_STOP("Map filter images") } Q_INVOKABLE int ImageFilter::mapRowToSource(int row) { QModelIndex sourceIndex = mapToSource(index(row, 0)); return sourceIndex.row(); } void PolygonFilter::setPosition(const QGeoCoordinate& position) { beginFilterChange(); m_position = position; endFilterChange(); } void PolylineFilter::setPosition(const QGeoCoordinate& position) { beginFilterChange(); m_position = position; endFilterChange(); } void ObjectMapFilter::setPosition(const QGeoCoordinate& position) { beginFilterChange(); m_position = position; endFilterChange(); } void ImageFilter::setPosition(const QGeoCoordinate& position) { beginFilterChange(); m_position = position; endFilterChange(); }