"""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.plugin_dir = os.path.dirname(__file__)

# initialize locale

locale = QSettings().value('locale/userLocale')[0:2]

locale_path = os.path.join(

self.plugin_dir,

'i18n',

'Point2One_{}.qm'.format(locale))

if os.path.exists(locale_path):

self.translator = QTranslator()

self.translator.load(locale_path)

QCoreApplication.installTranslator(self.translator)

# Declare instance attributes

self.actions = []

self.menu = self.tr(u'&Point2One')

# TODO: We are going to let the user set this up in a future iteration

self.toolbar = self.iface.addToolBar(u'Point2One')

self.toolbar.setObjectName(u'Point2One')

#print "** INITIALIZING Point2One"

self.pluginIsActive = False

self.dockwidget = None

# 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('Point2One', message)

def add_action(

self,

icon_path,

text,

callback,

enabled_flag=True,

add_to_menu=True,

add_to_toolbar=True,

status_tip=None,

whats_this=None,

parent=None):

"""Add a toolbar icon to the toolbar.

:param icon_path: 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 icon_path: 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 enabled_flag: A flag indicating if the action should be enabled

by default. Defaults to True.

:type enabled_flag: bool

:param add_to_menu: Flag indicating whether the action should also

be added to the menu. Defaults to True.

:type add_to_menu: bool

:param add_to_toolbar: Flag indicating whether the action should also

be added to the toolbar. Defaults to True.

:type add_to_toolbar: bool

:param status_tip: Optional text to show in a popup when mouse pointer

hovers over the action.

:type status_tip: str

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

:type parent: QWidget

:param whats_this: 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(icon_path)

action = QAction(icon, text, parent)

action.triggered.connect(callback)

action.setEnabled(enabled_flag)

if status_tip is not None:

action.setStatusTip(status_tip)

if whats_this is not None:

action.setWhatsThis(whats_this)

if add_to_toolbar:

self.toolbar.addAction(action)

if add_to_menu:

self.iface.addPluginToMenu(

self.menu,

action)

self.actions.append(action)

return action

def initGui(self):

"""Create the menu entries and toolbar icons inside the QGIS GUI."""

icon_path = ':/plugins/Point2One/icon.png'

self.add_action(

icon_path,

text=self.tr(u'Point2One'),

callback=self.run,

parent=self.iface.mainWindow())

#--------------------------------------------------------------------------

def onClosePlugin(self):

"""Cleanup necessary items here when plugin dockwidget is closed"""

#print "** CLOSING Point2One"

# disconnects

self.dockwidget.closingPlugin.disconnect(self.onClosePlugin)

# remove this statement if dockwidget is to remain

# for reuse if plugin is reopened

# Commented next statement since it causes QGIS crashe

# when closing the docked window:

# self.dockwidget = None

self.pluginIsActive = False

def unload(self):

"""Removes the plugin menu item and icon from QGIS GUI."""

#print "** UNLOAD Point2One"

for action in self.actions:

self.iface.removePluginMenu(

self.tr(u'&Point2One'),

action)

self.iface.removeToolBarIcon(action)

# remove the toolbar

del self.toolbar

#--------------------------------------------------------------------------

def run(self):

"""Run method that loads and starts the plugin"""

if not self.pluginIsActive:

self.pluginIsActive = True

#print "** STARTING Point2One"

# dockwidget may not exist if:

# first run of plugin

# removed on close (see self.onClosePlugin method)

if self.dockwidget == None:

# Create the dockwidget (after translation) and keep reference

self.dockwidget = Point2OneDockWidget()

self.dockwidget.layers.setFilters(QgsMapLayerProxyModel.PointLayer)

self.dockwidget.OK.clicked.connect(self.Point2One)

# connect to provide cleanup on closing of dockwidget

self.dockwidget.closingPlugin.connect(self.onClosePlugin)

self.dockwidget.layers.layerChanged.connect(self.dockwidget.SortVerticesBy.setLayer) # setLayer is a native slot function

self.dockwidget.layers.layerChanged.connect(self.dockwidget.GroupFeaturesBy.setLayer) # setLayer is a native slot function

self.dockwidget.SortVerticesBy.setLayer(self.dockwidget.layers.currentLayer())

self.dockwidget.GroupFeaturesBy.setLayer(self.dockwidget.layers.currentLayer())

self.dockwidget.output_dir.setStorageMode(QgsFileWidget.GetDirectory)

# show the dockwidget

# TODO: fix to allow choice of dock location

self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dockwidget)

self.dockwidget.show()

# The function loads input point layer

def loadPointLayer(self):

return self.dockwidget.layers.currentLayer()

# The function creates linestring from point layer

def createLinestringLayer(self, points, point_layer, closed):

# create a new memory layer

v_layer = QgsVectorLayer("LineString", "line", "memory")

v_layer.setCrs(QgsCoordinateReferenceSystem(point_layer.crs()))

pr = v_layer.dataProvider()

# save features into layer

for key in points.keys():

# retrieve single grouped point list from dictionary

PointList = points[key]

verticies = PointList[1:len(PointList)]

line_end = PointList[0]

first_point = PointList[0]

segments = []

for point in verticies:

# create a new feature

seg = QgsFeature()

line_start = line_end

line_end = point

seg.setGeometry(QgsGeometry.fromPolylineXY([line_start, line_end]))

# add the geometry to the layer

segments.append(seg)

# checkbox close, creating a line between the first and last point

if closed:

seg = QgsFeature()

seg.setGeometry(QgsGeometry.fromPolylineXY([line_end, first_point]))

segments.append(seg)

pr.addFeatures(segments)

# update extent of the layer (not necessary)

v_layer.updateExtents()

return v_layer

# The function creates polygons from point layer

def createPolygonLayer(self, points, point_layer):

layer = QgsVectorLayer('Polygon', 'poly' , "memory")

layer.setCrs(QgsCoordinateReferenceSystem(point_layer.crs()))

pr = layer.dataProvider()

poly = QgsFeature()

for key in points.keys():

# retrieve single grouped point list from dictionary

PointList = points[key]

poly.setGeometry(QgsGeometry.fromPolygonXY([PointList]))

pr.addFeatures([poly])

layer.updateExtents()

return layer

# The function saves the created layer to geopackage

def saveGeopackage(self, save_layer):

# load path from dockwidget

path = self.dockwidget.output_dir.filePath()

# load filename

name_layer = self.dockwidget.Filename.text() + '.gpkg'

if not path:

iface.messageBar().pushMessage("Error", "set output", level=Qgis.Critical)

return

data_folder = os.path.join(path, name_layer)

# create geopackage

error = QgsVectorFileWriter.writeAsVectorFormat(save_layer,

data_folder,

"")

if error[0] != QgsVectorFileWriter.NoError:

iface.messageBar().pushMessage("Error", "Creating of the geopackage is failed", level=Qgis.Critical)

return

# open layer

vlayer = QgsVectorLayer(data_folder, self.dockwidget.Filename.text(), "ogr")

QgsProject.instance().addMapLayer(vlayer)

# The function sorts by attributes and group by attributes

def generatePoints(self, sortAttr, groupAttr, point_layer):

points = {}

features = list(point_layer.getFeatures())

# sort by attributes

if sortAttr:

unique = []

# testing a unique value in attribute

for feature in features:

attrValue = feature.attribute(sortAttr)

if attrValue not in unique:

unique.append(attrValue)

else:

iface.messageBar().pushMessage("Warning", "values in the attribute are not unique ", level=Qgis.Warning)

features.sort(key=lambda a: a.attribute(sortAttr))

# group by attributes

if groupAttr:

for feature in features:

# get value of attribute by which we group

attrValue = feature.attribute(groupAttr)

if attrValue not in points.keys():

# if there isn't list of points for given attribute value, we create empty list

points[attrValue] = []

# append this point to list

points[attrValue].append(feature.geometry().asPoint())

else:

points["all"] = []

for feature in features:

points["all"].append(feature.geometry().asPoint())

return points

def Point2One(self):

#self.iface.messageBar().pushMessage(

#"Warning", "It may take a while! Don't close QGIS!", level=Qgis.Warning

#)

# load point layer into map canvas

point_layer=self.loadPointLayer()

# get input parameters

if self.dockwidget.checkSortVertices.isChecked():

sortAttr = self.dockwidget.SortVerticesBy.currentField()

if sortAttr == "":

iface.messageBar().pushMessage("Error", "You have to select attribute to sort by", level=Qgis.Critical)

else:

sortAttr = None

if self.dockwidget.checkGroupBy.isChecked():

groupAttr = self.dockwidget.GroupFeaturesBy.currentField()

if groupAttr == "":

iface.messageBar().pushMessage("Error", "You have to select attribute to group by", level=Qgis.Critical)

else:

groupAttr = None

# generate vertices for linestrings/polygons

points = self.generatePoints(sortAttr, groupAttr, point_layer)

# selection of line or polygon

# if you choose line

if self.dockwidget.create_lines.isChecked():

closed = self.dockwidget.closed.isChecked()

output_layer = self.createLinestringLayer(points, point_layer, closed)

# if you choose polygon

elif self.dockwidget.create_polygon.isChecked():

output_layer = self.createPolygonLayer(points, point_layer)

# if is not selected line or polygon

else:

iface.messageBar().pushMessage("Error", "Choose lines or polygon", level=Qgis.Critical)

return

# if is check geopackage

if self.dockwidget.Output_geopackage.isChecked():

self.saveGeopackage(output_layer)

# if isn't check geopackage, created layer in opened into map canvas

else: