QgsOpenScope.py

# -*- coding: utf-8 -*-
"""
/***************************************************************************
 QgsOpenScope
                                 A QGIS plugin
 A collection of tools for the openScope project

 Generated by Plugin Builder: http://g-sherman.github.io/Qgis-Plugin-Builder/
                              -------------------
        begin                : 2019-09-13
        git sha              : $Format:%H$
        copyright            : (C) 2019 by openScope
        email                : 3430117+oobayly@users.noreply.github.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; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
"""
#pylint: disable=broad-except

import math
import os.path

#from qgis.core import QgsProcessingFeedback
from qgis.PyQt.QtCore import QSettings, QTranslator, QCoreApplication, Qt
from qgis.PyQt.QtGui import QIcon
from qgis.PyQt.QtWidgets import QAction, QFileDialog, QInputDialog, QMessageBox, QProgressDialog

# Initialize Qt resources from file resources.py
from .resources import * # pylint: disable=wildcard-import,unused-wildcard-import

# Import the code for the dialog
from .ui.export_terrain_dialog import ExportTerrainDialog
from .ui.import_dialog import ImportDialog
from .ui.settings_dialog import SettingsDialog

from .OpenScope.TerrainGenerator import TerrainGenerator, TerrainGeneratorConfig
from .OpenScope.utilities import drawing, exporter, gshhg
from .OpenScope.TextProcessingFeedback import TextProcessingFeedback

class QgsOpenScope:
    """QGIS Plugin Implementation."""

    def __init__(self, iface):
        """Constructor.

        :param iface: An interface instance that will be passed to this class
            which provides the hook by which you can manipulate the QGIS
            application at run time.
        :type iface: QgsInterface
        """
        # Save reference to the QGIS interface
        self.iface = iface
        # initialize plugin directory
        self.pluginDir = os.path.dirname(__file__)
        # initialize locale
        locale = QSettings().value('locale/userLocale')[0:2]
        localePath = os.path.join(
            self.pluginDir,
            'i18n',
            'QgsOpenScope_{}.qm'.format(locale))

        if os.path.exists(localePath):
            self.translator = QTranslator()
            self.translator.load(localePath)
            QCoreApplication.installTranslator(self.translator)

        # Declare instance attributes
        self.actions = []
        self.menu = self.tr(u'&QgsOpenScope')

        # Check if plugin was started the first time in current QGIS session
        # Must be set in initGui() to survive plugin reloads
        self.firstStart = None

        self.migrateSettings()

    # noinspection PyMethodMayBeStatic
    def tr(self, message):
        """Get the translation for a string using Qt translation API.

        We implement this ourselves since we do not inherit QObject.

        :param message: String for translation.
        :type message: str, QString

        :returns: Translated version of message.
        :rtype: QString
        """
        # noinspection PyTypeChecker,PyArgumentList,PyCallByClass
        return QCoreApplication.translate('QgsOpenScope', message)


    # pylint: disable=too-many-arguments
    def addAction(
            self,
            iconPath,
            text,
            callback,
            isEnabled=True,
            isMenuItem=True,
            isToolbarItem=True,
            statusTip=None,
            whatsThis=None,
            parent=None
        ):
        """Add a toolbar icon to the toolbar.

        :param iconPath: Path to the icon for this action. Can be a resource
            path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
        :type iconPath: str

        :param text: Text that should be shown in menu items for this action.
        :type text: str

        :param callback: Function to be called when the action is triggered.
        :type callback: function

        :param isEnabled: A flag indicating if the action should be enabled
            by default. Defaults to True.
        :type isEnabled: bool

        :param isMenuItem: Flag indicating whether the action should also
            be added to the menu. Defaults to True.
        :type isMenuItem: bool

        :param isToolbarItem: Flag indicating whether the action should also
            be added to the toolbar. Defaults to True.
        :type isToolbarItem: bool

        :param statusTip: Optional text to show in a popup when mouse pointer
            hovers over the action.
        :type statusTip: str

        :param parent: Parent widget for the new action. Defaults None.
        :type parent: QWidget

        :param whatsThis: Optional text to show in the status bar when the
            mouse pointer hovers over the action.

        :returns: The action that was created. Note that the action is also
            added to self.actions list.
        :rtype: QAction
        """

        icon = QIcon(iconPath)
        action = QAction(icon, text, parent)
        action.triggered.connect(callback)
        action.setEnabled(isEnabled)

        if statusTip is not None:
            action.setStatusTip(statusTip)

        if whatsThis is not None:
            action.setWhatsThis(whatsThis)

        if isToolbarItem:
            # Adds plugin icon to Plugins toolbar
            self.iface.addToolBarIcon(action)

        if isMenuItem:
            self.iface.addPluginToMenu(
                self.menu,
                action)

        self.actions.append(action)

        return action

    def addMenuSeparator(self):
        """Adds a separator to the specified menu bar"""
        separator = QAction()
        separator.setSeparator(True)

        self.iface.addPluginToMenu(self.menu, separator)
        self.actions.append(separator)

    def initGui(self):
        """Create the menu entries and toolbar icons inside the QGIS GUI."""

        #iconPath = ':/plugins/QgsOpenScope/icon.png'

        # Load
        self.addAction(
            ':/plugins/QgsOpenScope/resources/icons/airport-import.png',
            text=self.tr(u'Load Airport'),
            callback=self.loadAirport,
            parent=self.iface.mainWindow(),
            isToolbarItem=True
        )
        self.addAction(
            ':/plugins/QgsOpenScope/resources/icons/terrain-import.png',
            text='Generate Terrain',
            callback=self.generateTerrain,
            parent=self.iface.mainWindow(),
            isToolbarItem=True
        )

        # Export
        self.addMenuSeparator()
        self.addAction(
            None,
            text='Export Airspace',
            callback=self.exportAirspace,
            parent=self.iface.mainWindow(),
            isToolbarItem=False
        )
        self.addAction(
            None,
            text='Export Fixes',
            callback=self.exportFixes,
            parent=self.iface.mainWindow(),
            isToolbarItem=False
        )
        self.addAction(
            None,
            text='Export Maps',
            callback=self.exportMaps,
            parent=self.iface.mainWindow(),
            isToolbarItem=False
        )
        self.addAction(
            None,
            text='Export Restricted',
            callback=self.exportRestricted,
            parent=self.iface.mainWindow(),
            isToolbarItem=False
        )
        self.addAction(
            ':/plugins/QgsOpenScope/resources/icons/terrain-export.png',
            text='Export Terrain',
            callback=self.exportTerrain,
            parent=self.iface.mainWindow(),
            isToolbarItem=True
        )

        # Drawing
        self.addMenuSeparator()
        self.addAction(
            ':/plugins/QgsOpenScope/resources/icons/draw-circle.png',
            text='Draw Circle around points',
            callback=self.drawCircles,
            parent=self.iface.mainWindow(),
            isToolbarItem=True
        )
        self.addAction(
            ':/plugins/QgsOpenScope/resources/icons/draw-runways.png',
            text='Draw Extended Runway Centrelines',
            callback=self.drawRunwayExtensions,
            parent=self.iface.mainWindow(),
            isToolbarItem=True
        )

        # Settings
        self.addMenuSeparator()
        self.addAction(
            None,
            text='QgsOpenScope Settings',
            callback=self.showSettingsDialog,
            parent=self.iface.mainWindow(),
            isToolbarItem=False
        )

        # will be set False in run()
        self.firstStart = True

    def unload(self):
        """Removes the plugin menu item and icon from QGIS GUI."""
        for action in self.actions:
            self.iface.removePluginMenu(
                self.tr(u'&QgsOpenScope'),
                action)
            self.iface.removeToolBarIcon(action)

    def migrateSettings(self):
        """Migrate settings from a previous version"""
        self.migrateGSHHG()

    def migrateGSHHG(self):
        """Migrate settings from a previous version"""
        gshhgPath = SettingsDialog.getGSHHSPath()
        tmpPath = os.path.join(SettingsDialog.getTempPath(), 'qgsopenscope', 'gshhg')

        os.makedirs(tmpPath, exist_ok=True)

        if not gshhgPath or not os.path.exists(gshhgPath):
            return

        print('Migrating {} to {}'.format(gshhgPath, tmpPath))

        gshhg.migrateArchive(gshhgPath, tmpPath)
        SettingsDialog.setGSHHSPath(None)

#------------------- Handlers -------------------

    def drawCircles(self):
        """Draws a circle around the selected points"""

        radius, okPress = QInputDialog.getDouble(
            None,
            'Circle Radius',
            'The circle radius in NM:',
            5,
            0.005,
            decimals=3
        )

        if not okPress:
            return

        try:
            drawing.drawCircles(radius)
        except Exception as e:
            QMessageBox.warning(None, 'QgsOpenScope', str(e))

    def drawRunwayExtensions(self):
        """Draw the extended runway centrelines"""

        length, okPress = QInputDialog.getInt(
            None,
            'Extended Runway Centrelines',
            'The total length in NM:',
            8,
            1,
            step=4
        )

        if not okPress:
            return

        try:
            drawing.drawRunwayExtension(length)
        except Exception as e:
            QMessageBox.warning(None, 'QgsOpenScope', str(e))

    def exportAirspace(self):
        """Exports the Airspace features as JSON."""
        exporter.exportAirspace()

    def exportFixes(self):
        """Exports the Fixes features as JSON."""
        exporter.exportFixes()

    def exportRestricted(self):
        """Exports the Restricted Airspace features as JSON."""
        exporter.exportRestricted()

    def exportMaps(self):
        """Exports the Map layers as JSON."""
        exporter.exportMaps()

    def exportTerrain(self):
        """Exports the Terrain as GeoJSON."""

        dlg = ExportTerrainDialog()

        # Show and run the dialog event loop
        dlg.show()
        result = dlg.exec_()

        if result:
            pass

    def generateTerrain(self):
        """Generates the terrain"""

        if TerrainGenerator.hasExistingLayers():
            message = (
                "This will remove all existing layers from the Terrain group. "
                "Are you sure you want to continue?"
            )

            response = QMessageBox.question(
                None,
                'QgsOpenScope',
                message,
                QMessageBox.Yes, QMessageBox.No
            )

            if response == QMessageBox.No:
                return

        airportFile = self._getAirportFile()

        if not airportFile:
            return

        config = TerrainGeneratorConfig()

        config.airportFile = airportFile
        config.projectPath = SettingsDialog.getProjectPath()
        config.tmpPath = SettingsDialog.getTempPath()
        config.contourInterval = 304.8

        # For providing UI feedback
        progress = QProgressDialog('', 'Cancel', 0, 100)
        feedback = TextProcessingFeedback()

        feedback.progressChanged.connect(lambda x: self._updateDialog(progress, value=x))
        feedback.progressTextChanged.connect(lambda x: self._updateDialog(progress, text=x))

        progress.setAutoClose(False)
        progress.setWindowModality(Qt.WindowModal)
        progress.setMinimumDuration(500)
        progress.canceled.connect(feedback.cancel)
        progress.show()

        try:
            terrain = TerrainGenerator(config)
            terrain.generateTerrain(feedback)
            terrain.saveProject()

        except Exception as e:
            QMessageBox.warning(None, 'QgsOpenScope', str(e))

        progress.hide()

    def loadAirport(self):
        """Loads an airport into the workspace"""

        dlg = ImportDialog()

        # Show and run the dialog event loop
        dlg.show()
        result = dlg.exec_()

        if result:
            pass

    def showSettingsDialog(self):
        """Show the settings dialog"""

        dlg = SettingsDialog()

        # Show and run the dialog event loop
        dlg.show()
        result = dlg.exec_()

        if result:
            pass

#------------------- Private methods -------------------

    def _getAirportFile(self):
        """Prompts the user to select an airport file and returns the AirportModel"""

        fileName, _ = QFileDialog.getOpenFileName(
            None,
            'Load openScope Airport',
            SettingsDialog.getLastAirportPath(),
            'Airport Files(*.json)',
        )

        if not fileName:
            return None
        if not os.path.isfile(fileName):
            QMessageBox.warning(None, 'QgsOpenScope', 'Airport File \'%s\' does not exist.' % fileName)
            return None

        SettingsDialog.setLastAirportPath(fileName)

        return fileName

    def _updateDialog(self, progressDialog, value=None, text=None):
        """Helper method for updating the value and text of a QProgressDialog"""
        if value is not None:
            if math.isnan(value):
                value = 0

            progressDialog.setValue(int(value))

        if text is not None:
            progressDialog.setLabelText(text)

        QCoreApplication.processEvents()