def generateScenesExtentLayerForDay(year, month, day, tle_line1, tle_line2, sat_name, splitBool):
    WIDTH = 1165000

    trackLayer = mtl_track_generator.create_orbital_track_shapefile_for_day(year, month, day, 5, tle_line1, tle_line2,
                                                                            sat_name)
    trackFeatures = mtl_lib.getFeaturesAsList(trackLayer)

    i = 0
    j = 0
    scenesExtentLayerName = 'Scene\'s extents (' + sat_name + ': ' + str(year) + ':' + str(month) + ':' + str(day) + ')'
    scenesExtentLayer = QgsVectorLayer("MultiPolygon", scenesExtentLayerName, "memory")
    scenesExtentLayer.setCrs(QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.PostgisCrsId))
    scenesExtentLayer.startEditing()
    scenesExtentLayerDataProvider = scenesExtentLayer.dataProvider()
    scenesExtentLayerDataProvider.addAttributes([QgsField("ID", QVariant.Int),
                                                 QgsField("TIME", QVariant.String)])

    while i < len(trackFeatures) - 2:
        j = 0
        trackPointsPack = []
        while j <= 1:
            QApplication.processEvents()
            trackPointsPack.append(trackFeatures[i])

            j += 1
            i += 1

        if i != len(trackFeatures):
            i -= 1

        # now have pack with 2 points
        WGS84 = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.PostgisCrsId)
        TPED = generateTPEDProjection(round(trackPointsPack[0].geometry().asPoint()[1], 3),
                                      round(trackPointsPack[0].geometry().asPoint()[0], 3),
                                      round(trackPointsPack[1].geometry().asPoint()[1], 3),
                                      round(trackPointsPack[1].geometry().asPoint()[0], 3))
        trackPackLine = generateLineWithPointFeatures(trackPointsPack, True, WGS84, TPED)
        scene = generateSceneExtentForTrackLine(trackPackLine, WIDTH, TPED, WGS84, splitBool)
        scene.setAttributes([i, trackFeatures[i-1]['TIME']])
        scenesExtentLayerDataProvider.addFeatures([scene])

    scenesExtentLayer.commitChanges()
    scenesExtentLayer.updateExtents()
    return scenesExtentLayer
示例#2
0
    def run(self):

        if self.ui.satellitePositionOutputCheckBox.isChecked():
            if not self.ui.satellitePositionOutputLine.text():
                QtGui.QMessageBox.critical(None, "Error", "Output file name not set")
                return
        if self.ui.extentPolygonsOutputCheckBox.isChecked():
            if not self.ui.extentPolygonsOutputLine.text():
                QtGui.QMessageBox.critical(None, "Error", "Output file name not set")
                return
        if self.ui.checkoutForObjectsCheckBox.isChecked():
            if not self.ui.layersComboBox.currentText():
                QtGui.QMessageBox.critical(None, "Error", "Layer is not selected")
                return
        ### End check inputs

        userDate = self.ui.orbitDate.date()
        userYear = userDate.year()
        userMonth = userDate.month()
        userDay = userDate.day()

        # TRACK
        self.busyInterface()
        QApplication.processEvents()

        if self.ui.satellitePositionOutputCheckBox.isChecked():

            try:
                trackLayer = mtl_track_generator.create_orbital_track_shapefile_for_day(
                    userYear,
                    userMonth,
                    userDay,
                    5,
                    self.ui.TLELine1.text(),
                    self.ui.TLELine2.text(),
                    self.ui.satelliteComboBox.currentText(),
                )
            except (NameError):
                QtGui.QMessageBox.critical(None, "Error", "Invalid TLE")
                self.readyInterface()
                return
            except (TypeError):
                QtGui.QMessageBox.critical(None, "Error", "Invalid Inputs")
                self.readyInterface()
                return

            mtl_lib.saveVectorLayerToSHP(trackLayer, self.ui.satellitePositionOutputLine.text())
            if self.ui.addOutputsToProjectCheckBox.isChecked():
                QgsMapLayerRegistry.instance().addMapLayer(trackLayer)

        # EXTENTS
        if self.ui.extentPolygonsOutputCheckBox.isChecked():
            try:
                sceneExtentsLayer = mtl_extent_generator.generateScenesExtentLayerForDay(
                    userYear,
                    userMonth,
                    userDay,
                    self.ui.TLELine1.text(),
                    self.ui.TLELine2.text(),
                    self.ui.satelliteComboBox.currentText(),
                    self.ui.splitToMultuGeomCheckBox.isChecked(),
                )
            except (NameError):
                QtGui.QMessageBox.critical(None, "Error", "Invalid TLE")
                self.readyInterface()
                return
            except (TypeError):
                QtGui.QMessageBox.critical(None, "Error", "Invalid Inputs")
                self.readyInterface()
                return

            mtl_lib.saveVectorLayerToSHP(sceneExtentsLayer, self.ui.extentPolygonsOutputLine.text())
            if self.ui.addOutputsToProjectCheckBox.isChecked():
                extentLayerName = (
                    "Scene's extents ("
                    + self.ui.satelliteComboBox.currentText()
                    + ": "
                    + str(userYear)
                    + ":"
                    + str(userMonth)
                    + ":"
                    + str(userDay)
                    + ")"
                )
                extentsLayer = QgsVectorLayer(self.ui.extentPolygonsOutputLine.text(), extentLayerName, "ogr")
                QgsMapLayerRegistry.instance().addMapLayer(extentsLayer)

        # OBJECTS
        if self.ui.checkoutForObjectsCheckBox.isChecked():
            userLayer = mtl_lib.getLayerByName(self.ui.layersComboBox.currentText())
            if userLayer.isValid() == False:
                QtGui.QMessageBox.critical(None, "Error", "Invalid input vector layer")
                self.readyInterface()
                return

            if self.ui.extentPolygonsOutputCheckBox.isChecked() and self.ui.splitToMultuGeomCheckBox.isChecked():
                pass
            else:
                sceneExtentsLayer = mtl_extent_generator.generateScenesExtentLayerForDay(
                    userYear,
                    userMonth,
                    userDay,
                    self.ui.TLELine1.text(),
                    self.ui.TLELine2.text(),
                    self.ui.satelliteComboBox.currentText(),
                    True,
                )

            QgsMapLayerRegistry.instance().addMapLayer(sceneExtentsLayer)

            WGS84 = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.PostgisCrsId)
            reproj = False
            if userLayer.crs() != WGS84:
                # Reproject userLayer to WGS84
                try:
                    userLayerReprojected = mtl_lib.reprojectVectorLayerToMemoryLayer(userLayer.crs(), WGS84, userLayer)
                    QgsMapLayerRegistry.instance().addMapLayer(userLayerReprojected)
                    reproj = True
                except:
                    pass

            # Intersects
            try:
                if reproj:
                    processing.runalg(
                        "qgis:selectbylocation", sceneExtentsLayer, userLayerReprojected, u"intersects", 0
                    )
                else:
                    processing.runalg("qgis:selectbylocation", sceneExtentsLayer, userLayer, u"intersects", 0)
            except:
                QtGui.QMessageBox.critical(None, "Error", "Processing must be enabled!")
                self.readyInterface()
                return

            features = sceneExtentsLayer.selectedFeatures()
            intersectsList = []
            for f in features:
                intersectsList.append(f[1])

            # Contains
            try:
                if reproj:
                    processing.runalg("qgis:selectbylocation", sceneExtentsLayer, userLayerReprojected, u"contains", 0)
                else:
                    processing.runalg("qgis:selectbylocation", sceneExtentsLayer, userLayer, u"contains", 0)
            except:
                QtGui.QMessageBox.critical(None, "Error", "Processing must be enabled!")
                self.readyInterface()
                return

            features = sceneExtentsLayer.selectedFeatures()
            containsList = []
            for f in features:
                containsList.append(f[1])
            QgsMapLayerRegistry.instance().removeMapLayer(sceneExtentsLayer.id())
            if reproj:
                QgsMapLayerRegistry.instance().removeMapLayer(userLayerReprojected.id())

            resultText = "Associated scenes: <br> "
            for sceneTime in intersectsList:
                resultText += sceneTime + "<br>"

            self.ui.checkoutTextBox.setText(resultText)

        self.readyInterface()