geom2field.py

import os

from qgis.PyQt.QtCore import QVariant, QCoreApplication, QUrl
from qgis.PyQt.QtGui import QIcon
from qgis.core import QgsFields, QgsField, QgsFeature, QgsCoordinateTransform, QgsProject

from qgis.core import (
    QgsProcessing,
    QgsProcessingException,
    QgsProcessingAlgorithm,
    QgsProcessingParameterEnum,
    QgsProcessingParameterString,
    QgsProcessingParameterNumber,
    QgsProcessingParameterCrs,
    QgsProcessingParameterFeatureSource,
    QgsProcessingParameterFeatureSink)

from . import mgrs
from .util import epsg4326, convertDD2DMS, formatDmsString
from .utm import latLon2UtmString
from . import olc


def tr(string):
    return QCoreApplication.translate('Processing', string)


class Geom2FieldAlgorithm(QgsProcessingAlgorithm):
    """
    Algorithm to convert a point layer to a Plus codes field.
    """
    # Constants used to refer to parameters and outputs. They will be
    # used when calling the algorithm from another algorithm, or when
    # calling from the QGIS console.
    PrmInputLayer = 'InputLayer'
    PrmOutputFormat = 'OutputFormat'
    PrmYFieldName = 'YFieldName'
    PrmXFieldName = 'XFieldName'
    PrmCoordinateOrder = 'CoordinateOrder'
    PrmCoordinateDelimiter = 'CoordinateDelimiter'
    PrmOutputCRSType = 'OutputCRSType'
    PrmCustomCRS = 'CustomCRS'
    PrmWgs84NumberFormat = 'Wgs84NumberFormat'
    PrmCoordinatePrecision = 'CoordinatePrecision'
    PrmDMSSecondPrecision = 'DMSSecondPrecision'
    PrmPlusCodesLength = 'PlusCodesLength'
    PrmOutputLayer = 'OutputLayer'

    def initAlgorithm(self, config):
        self.addParameter(
            QgsProcessingParameterFeatureSource(
                self.PrmInputLayer,
                tr('Input point vector layer'),
                [QgsProcessing.TypeVectorPoint])
        )
        self.addParameter(
            QgsProcessingParameterEnum(
                self.PrmOutputFormat,
                tr('Output format'),
                options=[
                    tr('Coordinates in 2 fields'),
                    tr('Coordinates in 1 field'),
                    tr('GeoJSON'), tr('WKT'), tr('MGRS'),
                    tr('Plus Codes'), tr('Standard UTM')],
                defaultValue=0,
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterString(
                self.PrmXFieldName,
                tr('Longitude (X) field name'),
                defaultValue='x',
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterString(
                self.PrmYFieldName,
                tr('Latitude (Y) & all other formats field name'),
                defaultValue='y',
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterEnum(
                self.PrmCoordinateOrder,
                tr('Coordinate order when using 1 field'),
                options=[tr('Lat,Lon (Y,X) - Google map order'), tr('Lon,Lat (X,Y) order')],
                defaultValue=0,
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterString(
                self.PrmCoordinateDelimiter,
                tr('Delimiter between coordinates when using 1 field'),
                defaultValue=',',
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterEnum(
                self.PrmOutputCRSType,
                tr('Output CRS of coordinates added to a field'),
                options=[tr('WGS 84'), tr('Layer CRS'), tr('Project CRS'), tr('Custom CRS')],
                defaultValue=0,
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterCrs(
                self.PrmCustomCRS,
                tr('Custom CRS for coordinates added to a field'),
                'EPSG:4326',
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterEnum(
                self.PrmWgs84NumberFormat,
                tr('Select Decimal or DMS degress for WGS 84 numbers'),
                options=[tr('Decimal degrees'), tr('DMS'), tr('DDMMSS')],
                defaultValue=0,
                optional=True)
        )
        self.addParameter(
            QgsProcessingParameterNumber(
                self.PrmCoordinatePrecision,
                tr('Decimal number precision'),
                type=QgsProcessingParameterNumber.Integer,
                defaultValue=8,
                optional=True,
                minValue=0)
        )
        self.addParameter(
            QgsProcessingParameterNumber(
                self.PrmDMSSecondPrecision,
                tr('DMS second / UTM precision'),
                type=QgsProcessingParameterNumber.Integer,
                defaultValue=0,
                optional=True,
                minValue=0)
        )
        self.addParameter(
            QgsProcessingParameterNumber(
                self.PrmPlusCodesLength,
                tr('Plus Codes length'),
                type=QgsProcessingParameterNumber.Integer,
                defaultValue=11,
                optional=True,
                minValue=10,
                maxValue=20)
        )
        self.addParameter(
            QgsProcessingParameterFeatureSink(
                self.PrmOutputLayer,
                tr('Output layer'))
        )

    def processAlgorithm(self, parameters, context, feedback):
        source = self.parameterAsSource(parameters, self.PrmInputLayer, context)
        outputFormat = self.parameterAsInt(parameters, self.PrmOutputFormat, context)
        field1Name = self.parameterAsString(parameters, self.PrmYFieldName, context).strip()
        field2Name = self.parameterAsString(parameters, self.PrmXFieldName, context).strip()
        coordOrder = self.parameterAsInt(parameters, self.PrmCoordinateOrder, context)
        delimiter = self.parameterAsString(parameters, self.PrmCoordinateDelimiter, context)
        crsType = self.parameterAsInt(parameters, self.PrmOutputCRSType, context)
        crsOther = self.parameterAsCrs(parameters, self.PrmCustomCRS, context)
        wgs84Format = self.parameterAsInt(parameters, self.PrmWgs84NumberFormat, context)
        decimalPrecision = self.parameterAsInt(parameters, self.PrmCoordinatePrecision, context)
        dmsPrecision = self.parameterAsInt(parameters, self.PrmDMSSecondPrecision, context)
        plusCodesLength = self.parameterAsInt(parameters, self.PrmPlusCodesLength, context)

        layerCRS = source.sourceCrs()
        # For the first condition, the user has either EPSG:4326 selected or
        # or have chosen GeoJSON or WKT which will be 4326 as well
        if crsType == 0 or outputFormat >= 2:  # Forced WGS 84
            outCRS = epsg4326
        elif crsType == 1:  # Layer CRS
            outCRS = layerCRS
        elif crsType == 2:  # Project CRS
            outCRS = QgsProject.instance().crs()
        else:
            outCRS = crsOther

        fieldsout = QgsFields(source.fields())

        if fieldsout.append(QgsField(field1Name, QVariant.String)) is False:
            msg = "Field names must be unique. There is already a field named '{}'".format(field1Name)
            feedback.reportError(msg)
            raise QgsProcessingException(msg)
        if outputFormat == 0:  # Two fields for coordinates
            if fieldsout.append(QgsField(field2Name, QVariant.String)) is False:
                msg = "Field names must be unique. There is already a field named '{}'".format(field2Name)
                feedback.reportError(msg)
                raise QgsProcessingException(msg)

        (sink, dest_id) = self.parameterAsSink(
            parameters, self.PrmOutputLayer,
            context, fieldsout, source.wkbType(), layerCRS)

        if layerCRS != outCRS:
            transform = QgsCoordinateTransform(layerCRS, outCRS, QgsProject.instance())

        total = 100.0 / source.featureCount() if source.featureCount() else 0

        iterator = source.getFeatures()
        for cnt, feature in enumerate(iterator):
            if feedback.isCanceled():
                break
            pt = feature.geometry().asPoint()
            if layerCRS != outCRS:
                pt = transform.transform(pt)
            try:
                if outputFormat == 0:  # Two fields for coordinates
                    if outCRS == epsg4326:
                        if wgs84Format == 0:  # Decimal Degrees
                            msg = '{:.{prec}f}'.format(pt.y(), prec=decimalPrecision)
                            msg2 = '{:.{prec}f}'.format(pt.x(), prec=decimalPrecision)
                        elif wgs84Format == 1:  # DMS
                            msg = convertDD2DMS(pt.y(), True, True, dmsPrecision)
                            msg2 = convertDD2DMS(pt.x(), False, True, dmsPrecision)
                        else:  # DDMMSS
                            msg = convertDD2DMS(pt.y(), True, False, dmsPrecision)
                            msg2 = convertDD2DMS(pt.x(), False, False, dmsPrecision)
                    else:
                        msg = '{:.{prec}f}'.format(pt.y(), prec=decimalPrecision)
                        msg2 = '{:.{prec}f}'.format(pt.x(), prec=decimalPrecision)
                elif outputFormat == 1:  # One field for coordinate
                    if outCRS == epsg4326:
                        if wgs84Format == 0:  # Decimal Degrees
                            if coordOrder == 0:
                                msg = '{:.{prec}f}{}{:.{prec}f}'.format(pt.y(), delimiter, pt.x(), prec=decimalPrecision)
                            else:
                                msg = '{:.{prec}f}{}{:.{prec}f}'.format(pt.x(), delimiter, pt.y(), prec=decimalPrecision)
                        elif wgs84Format == 1:  # DMS
                            msg = formatDmsString(pt.y(), pt.x(), True, dmsPrecision, coordOrder, delimiter)
                        else:  # DDMMSS
                            msg = formatDmsString(pt.y(), pt.x(), False, dmsPrecision, coordOrder, delimiter)
                    else:
                        if coordOrder == 0:
                            msg = '{:.{prec}f}{}{:.{prec}f}'.format(pt.y(), delimiter, pt.x(), prec=decimalPrecision)
                        else:
                            msg = '{:.{prec}f}{}{:.{prec}f}'.format(pt.x(), delimiter, pt.y(), prec=decimalPrecision)
                elif outputFormat == 2:  # GeoJSON
                    msg = '{{"type": "Point","coordinates": [{:.{prec}f},{:.{prec}f}]}}'.format(pt.x(), pt.y(), prec=decimalPrecision)
                elif outputFormat == 3:  # WKT
                    msg = 'POINT({:.{prec}f} {:.{prec}f})'.format(pt.x(), pt.y(), prec=decimalPrecision)
                elif outputFormat == 4:  # MGRS
                    msg = mgrs.toMgrs(pt.y(), pt.x(), 5)
                elif outputFormat == 5:  # Plus codes
                    msg = olc.encode(pt.y(), pt.x(), plusCodesLength)
                else:  # WGS 84 UTM
                    msg = latLon2UtmString(pt.y(), pt.x(), dmsPrecision)
            except Exception:
                msg = ''

            f = QgsFeature()
            f.setGeometry(feature.geometry())
            if outputFormat == 0:  # Two fields for coordinates
                f.setAttributes(feature.attributes() + [msg, msg2])
            else:
                f.setAttributes(feature.attributes() + [msg])
            sink.addFeature(f)

            if cnt % 100 == 0:
                feedback.setProgress(int(cnt * total))

        return {self.PrmOutputLayer: dest_id}

    def name(self):
        return 'geom2field'

    def icon(self):
        return QIcon(os.path.dirname(__file__) + '/images/geom2field.png')

    def displayName(self):
        return 'Point layer to fields'

    def group(self):
        return 'Vector conversion'

    def groupId(self):
        return 'vectorconversion'

    def helpUrl(self):
        file = os.path.dirname(__file__) + '/index.html'
        if not os.path.exists(file):
            return ''
        return QUrl.fromLocalFile(file).toString(QUrl.FullyEncoded)

    def shortHelpString(self):
        file = os.path.dirname(__file__) + '/doc/geom2fields.help'
        if not os.path.exists(file):
            return ''
        with open(file) as helpf:
            help = helpf.read()
        return help

    def createInstance(self):
        return Geom2FieldAlgorithm()