def __init__(self, iface):

def setupUi():

def getLayout(parent, widgets):

lyt = QGridLayout( parent )

for item in widgets:

if 'spam' in item:

sRow, sCol = item['spam']['row'], item['spam']['col']

lyt.addWidget( item['widget'], item['row'], item['col'], sRow, sCol, Qt.AlignLeft )

else:

lyt.addWidget( item['widget'], item['row'], item['col'], Qt.AlignLeft )

return lyt

def getGroupBox(name, parent, widgets):

lyt = getLayout( parent, widgets )

gbx = QGroupBox(name, parent )

gbx.setLayout( lyt )

return gbx

def getSpinBoxOffset(wgt, value):

sp = QDoubleSpinBox( wgt)

sp.setRange(0.0, 50.0)

sp.setSingleStep(12.5)

sp.setDecimals(2)

sp.setSuffix(' %')

sp.setValue(value)

return sp

def getSpinRemoveAreaPixels(wgt, value):

sp = QSpinBox( wgt)

sp.setRange(0, 1000)

sp.setSingleStep(1)

sp.setSuffix(' pixels')

sp.setValue(value)

return sp

def getSpinBoxAzimuth(wgt, value):

sp = QSpinBox( wgt)

sp.setRange(0, 45)

sp.setSingleStep(1)

sp.setSuffix(' degrees')

sp.setValue(value)

msg = QCoreApplication.translate('GimpSelectionFeature', 'Degrees of azimuth between vertexs')

sp.setToolTip( msg )

return sp

def getSpinBoxIteration(wgt, value):

sp = QSpinBox( wgt)

sp.setRange(0, 3)

sp.setSingleStep(1)

sp.setValue(value)

return sp

self.setObjectName('gimpselectionfeature_dockwidget')

wgt = QWidget( self )

wgt.setAttribute(Qt.WA_DeleteOnClose)

# Image

width = 180

self.lblLegendImages = QLabel('', wgt )

self.lblLegendImages.setWordWrap( True )

self.lblLegendImages.setMaximumWidth(width )

l_wts = [ { 'widget': self.lblLegendImages, 'row': 0, 'col': 0 } ]

name = self.formatTitleImages.format(0)

self.gbxImage = getGroupBox(name, wgt, l_wts)

# Transfer

msg = QCoreApplication.translate('GimpSelectionFeature', 'Send image')

self.btnSendImage = QPushButton(msg, wgt )

#

msg = QCoreApplication.translate('GimpSelectionFeature', 'Get features')

self.btnGetFeatures = QPushButton( msg, wgt )

msg = QCoreApplication.translate('GimpSelectionFeature', 'Remove last features')

self.btnRemoveLastFeatures = QPushButton( msg, wgt )

#

msg = QCoreApplication.translate('GimpSelectionFeature', 'Adjust the borders' )

self.chkAdjustBorder = QCheckBox( msg, wgt )

self.leditAnnotation = QLineEdit( wgt )

self.sbRemoveAreaPixels = getSpinRemoveAreaPixels( wgt, 10 )

self.sbAzimuthThreshold = getSpinBoxAzimuth( wgt, 0 )

self.spSmoothOffset = getSpinBoxOffset( wgt, 25 )

self.sbSmoothIteration = getSpinBoxIteration( wgt, 1)

msgLevel = QCoreApplication.translate('GimpSelectionFeature','Level(0-3):')

msgFraction = QCoreApplication.translate('GimpSelectionFeature','Fraction of line(0-50):')

l_wts = [

{ 'widget': QLabel( msgLevel, wgt ), 'row': 0, 'col': 0 },

{ 'widget': self.sbSmoothIteration, 'row': 0, 'col': 1 },

{ 'widget': QLabel( msgFraction, wgt ), 'row': 1, 'col': 0 },

{ 'widget': self.spSmoothOffset, 'row': 1, 'col': 1 }

]

msg = QCoreApplication.translate('GimpSelectionFeature', 'Smooth')

gbxSmooth = getGroupBox( msg, wgt, l_wts)

spamSmooth = { 'row': 1, 'col': 2 }

msgAnnotation = QCoreApplication.translate('GimpSelectionFeature', 'Annotation:' )

msgRemoveArea = QCoreApplication.translate('GimpSelectionFeature', 'Remove Area:' )

msgRemoveVertex = QCoreApplication.translate('GimpSelectionFeature', 'Remove Vertex:' )

l_wts = [

{ 'widget': QLabel( msgAnnotation, wgt ), 'row': 0, 'col': 0 },

{ 'widget': self.leditAnnotation, 'row': 0, 'col': 1 },

{ 'widget': QLabel( msgRemoveArea, wgt ), 'row': 1, 'col': 0 },

{ 'widget': self.sbRemoveAreaPixels, 'row': 1, 'col': 1 },

{ 'widget': QLabel( msgRemoveVertex, wgt ), 'row': 2, 'col': 0 },

{ 'widget': self.sbAzimuthThreshold, 'row': 2, 'col': 1 },

{ 'widget': gbxSmooth, 'row': 3, 'col': 0, 'spam': spamSmooth },

{ 'widget': self.chkAdjustBorder, 'row': 4, 'col': 0, }

]

msg = QCoreApplication.translate('GimpSelectionFeature', 'Setting' )

self.gbxSettingFeatures = getGroupBox( msg, wgt, l_wts)

spamSetting = { 'row': 1, 'col': 2 }

l_wts = [

{ 'widget': self.btnGetFeatures, 'row': 0, 'col': 0 },

{ 'widget': self.btnRemoveLastFeatures, 'row': 0, 'col': 1 },

{ 'widget': self.gbxSettingFeatures, 'row': 1, 'col': 0, 'spam': spamSetting }

]

gbxGQ = getGroupBox( "GIMP->QGIS", wgt, l_wts)

l_wts = [

{ 'widget': self.btnSendImage, 'row': 0, 'col': 0 }

]

gbxQG = getGroupBox( "QGIS->GIMP", wgt, l_wts)

spamGroup = { 'row': 1, 'col': 2 }

l_wts = [

{ 'widget': gbxQG, 'row': 0, 'col': 0, 'spam': spamGroup },

{ 'widget': gbxGQ, 'row': 1, 'col': 0, 'spam': spamGroup }

]

msg = QCoreApplication.translate('GimpSelectionFeature', 'Transfer' )

gbxTransfer = getGroupBox( msg, wgt, l_wts)

#

l_wts = [

{ 'widget': self.gbxImage, 'row': 0, 'col': 0 },

{ 'widget': gbxTransfer, 'row': 1, 'col': 0 }

]

lyt = getLayout( wgt, l_wts )

lyt.setSizeConstraint( QLayout.SetMaximumSize )

wgt.setLayout( lyt )

self.setWidget( wgt )

super().__init__( "Gimp Selection Feature", iface.mainWindow() )

#

msg = QCoreApplication.translate('GimpSelectionFeature', 'Visibles Images(total {})')

self.formatTitleImages = msg

setupUi()

self.gsf = GimpSelectionFeature( iface, self )

# def __del__(self):

# del self.gsf

def clean(self):

nameModulus = "GimpSelectionFeature"

def __init__(self, iface, dockWidgetGui):

def createDirectories():

dirPlugin = os.path.dirname(__file__)

dirImage = os.path.join( dirPlugin, 'img' )

if not os.path.isdir( dirImage ):

os.mkdir( dirImage )

dirLayer = os.path.join( dirPlugin, 'db' )

if not os.path.isdir( dirLayer ):

os.mkdir( dirLayer )

return { 'image': dirImage, 'gpkg': dirLayer }

def copyPluginGimp():

findedDir = []

def getDirectories(srcDir, mask, totalSearch):

for root, _dirs, _files in os.walk( srcDir ):

if re.match( mask, root.replace('\\', '/'), re.IGNORECASE ):

findedDir.append( root )

if len( findedDir ) == totalSearch:

break

return findedDir

def msgError(dirPlugin):

msg = QCoreApplication.translate('GimpSelectionFeature', "Not found profile Gimp(2.8 or 2.10) or '{}' inside profile" )

msg = msg.format( dirPlugin )

return msg

def copyNewPlugin(dirPluginQgis, dirsPluginGimp, name):

fromFile = os.path.join( dirPluginQgis, name )

toFile = os.path.join( dirsPluginGimp, name )

if not os.path.exists( toFile ) or not filecmp.cmp( fromFile, toFile ):

shutil.copy2( fromFile, toFile )

if sys.platform != 'win32': # Add executable

st = os.stat( toFile )

os.chmod( toFile, st.st_mode | stat.S_IEXEC )

dirPluginQgis = os.path.dirname(__file__)

copyFiles = ('socket_server_selection.py', 'sockets.py')

s = QSettings()

dirsPluginGimp = s.value( self.localSetting.format('dirsPluginGimp'), None )

if not dirsPluginGimp is None:

existsDirs = [ os.path.isdir( d ) for d in dirsPluginGimp ]

if False in existsDirs:

dirsPluginGimp = None

else:

for d in dirsPluginGimp:

for f in copyFiles:

copyNewPlugin( dirPluginQgis, d, f )

if dirsPluginGimp is None:

# Search GIMP 2.8 and 2.10

totalSearch = 2

dirUser = os.path.expanduser('~')

dirPlugin = "plug-ins"

mask = r".+/\.?GIMP.2\.[81]0?/{}".format( dirPlugin )

dirsPluginGimp = getDirectories( dirUser, mask, totalSearch )

if len( dirsPluginGimp ) == 0:

return { 'isOk': False, 'message': msgError( dirPlugin ) }

s.setValue( self.localSetting.format('dirsPluginGimp'), dirsPluginGimp )

dirPluginQgis = os.path.dirname(__file__)

for item in dirsPluginGimp:

copyNewPlugin( dirPluginQgis, item, 'socket_server_selection.py' )

copyNewPlugin( dirPluginQgis, item, 'sockets.py' )

return { 'isOk': True }

super().__init__()

self.dockWidgetGui = dockWidgetGui

self.localSetting = 'gimpselectionfeature_plugin/{}'

self.layerPolygon, self.isIniEditable = None, None

self.layerImages = []

self.hasConnect = None

self.sc = SocketClient()

self.canvas, self.msgBar = iface.mapCanvas(), iface.messageBar()

self.project = QgsProject.instance()

self.mapCanvasEffects = MapCanvasGeometry()

self.root = self.project.layerTreeRoot()

self.taskManager = QgsApplication.taskManager()

dirs = createDirectories()

self.defLayerPolygon = {

'filepath': os.path.join( dirs['gpkg'], 'gimp_selection.gpkg' ),

'layername': 'gimp_selection'

}

self.pathfileImage = os.path.join( dirs['image'], 'tmp_gimp-plugin.tif' )

self.pathfileImageSelect = os.path.join( dirs['image'], 'tmp_gimp-plugin_sel.tif' )

self._setEnabledWidgetTransfer( False )

r = copyPluginGimp()

if not r['isOk']:

self.msgBar.pushMessage( self.nameModulus, r['message'], Qgis.Critical, 0 )

return

self._connect()

def __del__(self):

del self.sc

def _connect(self, isConnect = True):

ss = [

{ 'signal': self.project.layerWillBeRemoved, 'slot': self.removeLayer },

{ 'signal': self.project.readProject, 'slot': self.readProject },

{ 'signal': self.root.visibilityChanged, 'slot': self.visibilityChanged },

{ 'signal': self.dockWidgetGui.btnSendImage.clicked, 'slot': self.sendImageGimp },

{ 'signal': self.dockWidgetGui.btnGetFeatures.clicked, 'slot': self.getFeatures },

{ 'signal': self.dockWidgetGui.btnRemoveLastFeatures.clicked, 'slot': self.removeLastFeatures }

]

if isConnect:

self.hasConnect = True

for item in ss:

item['signal'].connect( item['slot'] )

else:

self.hasConnect = False

for item in ss:

item['signal'].disconnect( item['slot'] )

def _setEnabledWidgetTransfer( self, isEnabled, removeLastFeatures=False):

wgts = [

self.dockWidgetGui.btnSendImage,

self.dockWidgetGui.btnGetFeatures,

self.dockWidgetGui.btnRemoveLastFeatures,

self.dockWidgetGui.gbxSettingFeatures

]

[ item.setEnabled( isEnabled ) for item in wgts ]

self.dockWidgetGui.btnRemoveLastFeatures.setEnabled( removeLastFeatures )

def _pushMessageTask(self, result, isCanceled, message):

self.msgBar.clearWidgets()

if result:

level = Qgis.Info if not isCanceled else Qgis.Warning

else:

level = Qgis.Critical

self.msgBar.pushMessage( self.nameModulus, message, level )

def _setLegendImages(self):

def layerIntersectsCanvas(layer):

mapSettings = self.canvas.mapSettings()

crsCanvas = mapSettings.destinationCrs()

extentCanvas = self.canvas.extent()

if layer.crs() != crsCanvas:

extentCanvas = mapSettings.mapToLayerCoordinates( layer, extentCanvas )

extentLayer = layer.extent()

return extentLayer.intersects( extentCanvas )

del self.layerImages[:]

txtLegend = ''

hasImages = False

totalImages = 0

rasters = list( filter( lambda l: not l is None and l.type() == QgsMapLayer.RasterLayer, self.root.checkedLayers() ) )

if len( rasters ) > 0:

for r in rasters:

if layerIntersectsCanvas( r ):

self.layerImages.append( r )

totalImages = len( self.layerImages )

if totalImages > 0:

names = list( map( lambda l: l.name(), self.layerImages ) )

txtLegend = f"{names[0]}\n" if len( names ) == 1 else '\n'.join( names )

hasImages = True

title = self.dockWidgetGui.formatTitleImages.format( totalImages )

self.dockWidgetGui.gbxImage.setTitle( title )

self.dockWidgetGui.lblLegendImages.setText( txtLegend )

self.dockWidgetGui.btnSendImage.setEnabled( hasImages )

def _getMaximumValueAdd(self):

if self.layerPolygon.featureCount() == 0:

return 0

idx = self.layerPolygon.fields().indexFromName('id_add')

return self.layerPolygon.maximumValue( idx )

def _getFirstLayerPolygon(self):

source = "{}|layername={}".format( self.defLayerPolygon['filepath'], self.defLayerPolygon['layername'] )

layers = [ ltl.layer() for ltl in self.root.findLayers() if ltl.layer().source() == source ]

if len( layers ) == 0:

return { 'isOk': False }

return { 'isOk': True, 'layer': layers[0] }

def _setConnectionSocket(self):

if not self.sc.hasConnect:

r = self.sc.connect()

if not r['isOk']:

self.msgBar.clearWidgets()

self.msgBar.pushMessage( self.nameModulus, r['message'], Qgis.Critical )

return False

return True

def _getIteratorLastFeatures(self):

exp = QgsExpression( f"\"id_add\" = {self._getMaximumValueAdd()}" )

request = QgsFeatureRequest( exp )

request.setFlags( QgsFeatureRequest.NoGeometry )

return self.layerPolygon.getFeatures( request )

@pyqtSlot(str)

def removeLayer(self, sIdLayer):

if not self.layerPolygon is None and self.layerPolygon.id() == sIdLayer:

self.layerPolygon = None

if self.layerPolygon is None or sIdLayer in [ lyr.id() for lyr in self.layerImages ]:

self._setLegendImages()

@pyqtSlot('QDomDocument')

def readProject(self, dom=None):

r = self._getFirstLayerPolygon()

if r['isOk']:

self.layerPolygon = r['layer']

self._setLegendImages()

@pyqtSlot('QgsLayerTreeNode*')

def visibilityChanged(self, node):

self._setLegendImages()

@pyqtSlot()

def sendImageGimp(self):

@pyqtSlot(bool, bool, str)

def finished(result, isCanceled, message):

self._pushMessageTask( result, isCanceled, message )

self._setEnabledWidgetTransfer(True)

if len( self.layerImages ) == 0 or not self._setConnectionSocket():

return

self._setEnabledWidgetTransfer( False )

self._setLegendImages() # Update the order of images

msg = QCoreApplication.translate('GimpSelectionFeature', 'Sending image to GIMP...')

self.msgBar.pushMessage( self.nameModulus, msg, Qgis.Info )

data = {

'canvas': self.canvas,

'layers': self.layerImages,

'filepath': self.pathfileImage

}

task = TaskSendImage( self.sc, data )

task.finish.connect( finished )

self.taskManager.addTask( task )

#task.finished( task.run() )

@pyqtSlot()

def getFeatures(self):

def setLayerPolygon():

def createLayerPolygon():

def createLayerMemory():

atts = {

'id_add': 'integer',

'total_imgs': 'integer',

'images': 'string(254)',

'user': 'string(20)',

'date_add': 'string(20)',

'crs_map': 'string(50)',

'extent_map': 'string(200)',

'annotation': 'string(100)'

}

l_fields = [ f"field={k}:{atts[ k ]}" for k in atts ]

crs = QgsCoordinateReferenceSystem('EPSG:4326')

l_fields.insert( 0, f"polygon?crs={crs.authid().lower()}" )

uri = '&'.join( l_fields )

return QgsVectorLayer( uri, self.defLayerPolygon['layername'], 'memory' )

if os.path.isfile( self.defLayerPolygon['filepath'] ):

os.remove( self.defLayerPolygon['filepath'] )

r = { 'isOk': True }

args = {

'layer': createLayerMemory(),

'fileName': self.defLayerPolygon['filepath'],

'fileEncoding': 'utf-8',

'driverName': 'GPKG'

}

rc, errmsg = QgsVectorFileWriter.writeAsVectorFormat( **args )

if not rc == QgsVectorFileWriter.NoError:

r = { 'isOk': False, 'message': errmsg }

if not r['isOk']:

return r

source = "{}|layername={}".format( self.defLayerPolygon['filepath'], self.defLayerPolygon['layername'] )

r['layer'] = QgsVectorLayer( source, self.defLayerPolygon['layername'], 'ogr' )

return r

if self.layerPolygon is None:

r = self._getFirstLayerPolygon()

if r['isOk']:

self.layerPolygon = r['layer']

else:

r = createLayerPolygon()

if not r['isOk']:

self.msgBar.pushMessage( self.nameModulus, r['message'], Qgis.Critical )

return False

self.layerPolygon = self.project.addMapLayer( r['layer'] )

# Refresh Symbology

self.layerPolygon.loadNamedStyle( os.path.join( os.path.dirname( __file__ ), "gimpselectionfeature_no_expression.qml" ) )

ltl = self.root.findLayer( self.layerPolygon.id() )

ltl.setCustomProperty('showFeatureCount', True)

ltl.setItemVisibilityChecked( True )

return True

def getDataParams():

# paramSmooth: iter = interations, offset = 0.0 - 1.0(100%)

# paramsSieve: threshold = Size in Pixel, connectedness = 4 or 8(diagonal)

tSieve = self.dockWidgetGui.sbRemoveAreaPixels.value() + 1

tAzimuth = self.dockWidgetGui.sbAzimuthThreshold.value()

offset = self.dockWidgetGui.spSmoothOffset.value() / 100.0

viter = self.dockWidgetGui.sbSmoothIteration.value()

pixelsRemove = None if not self.dockWidgetGui.chkAdjustBorder.isChecked() \

else self.dockWidgetGui.sbRemoveAreaPixels.value() + 1

return {

'layerPolygon': self.layerPolygon,

'filepath': self.pathfileImageSelect,

'id_add': self._getMaximumValueAdd() + 1,

'user': QgsApplication.userFullName(),

'annotation': self.dockWidgetGui.leditAnnotation.text(),

'pixelsRemove': pixelsRemove,

'smooth': { 'iter': viter, 'offset': offset },

'sieve': { 'threshold': tSieve, 'connectedness': 4 },

'azimuth': { 'threshold': tAzimuth }

}

def startEditable():

self.isIniEditable = self.layerPolygon.isEditable()

if not self.isIniEditable:

self.layerPolygon.startEditing()

@pyqtSlot(bool, bool, str)

def finished(result, isCanceled, message):

def commit():

def setRenderLayer():

fileStyle = os.path.join( os.path.dirname( __file__ ), "gimpselectionfeature_with_expression.qml" )

self.layerPolygon.loadNamedStyle( fileStyle )

def flashFeatures():

geoms = []

for feat in self._getIteratorLastFeatures():

geoms.append( feat.geometry() )

self.mapCanvasEffects.flash( geoms, self.layerPolygon )

self.layerPolygon.commitChanges()

self.layerPolygon.updateExtents()

if self.isIniEditable:

self.layerPolygon.startEditing()

setRenderLayer()

flashFeatures()

self._pushMessageTask( result, isCanceled, message )

if result and not isCanceled:

commit()

self._setEnabledWidgetTransfer(True, True)

if not setLayerPolygon() or not self._setConnectionSocket():

return

self._setEnabledWidgetTransfer(False)

startEditable() # Task NOT commit

msg = QCoreApplication.translate('GimpSelectionFeature', 'Adding features...')

self.msgBar.pushMessage( self.nameModulus, msg, Qgis.Info )

data = getDataParams()

task = TaskGetFeatures( self.sc, data )

task.setDependentLayers( [ self.layerPolygon ] )

task.finish.connect( finished )

task.addFeature.connect( self.layerPolygon.addFeature )

self.taskManager.addTask( task )

#task.finished( task.run() )

@pyqtSlot()

def removeLastFeatures(self):

self.isIniEditable = self.layerPolygon.isEditable()

if not self.isIniEditable:

self.layerPolygon.startEditing()

for feat in self._getIteratorLastFeatures():

self.layerPolygon.deleteFeature( feat.id() )

self.layerPolygon.commitChanges()

if self.isIniEditable:

self.layerPolygon.startEditing()

self.layerPolygon.updateExtents()

finish = pyqtSignal(bool, bool, str)

def __init__(self, description, socketClient, data):

"""

TaskBaseGimp: Base Task for send data for Gimp

:params str description: Description task

:params socket socket: Socket for send message for Gimp

:params dict data: parameters for processing, define in subclasses

"""

super().__init__( description, QgsTask.CanCancel )

self.socketClient = socketClient

self.data = data

self.message = None

self.paramsSendData = None

def _sendData(self):

r = self.socketClient.send( self.paramsSendData )

if not r['isOk']:

msg = QCoreApplication.translate('GimpSelectionFeature', 'Error connection GIMP Server: {}' )

msg = msg.format( r['message'] )

return { 'isOk': False, 'message': msg }

data = r['data']

if data is None:

msg = "Run IBAMA Plugin, 'IBAMA/Service for save the selected regions', in GIMP!"

msg = QCoreApplication.translate('GimpSelectionFeature', "Run IBAMA Plugin, 'IBAMA/Service for save the selected regions', in GIMP!" )

msg = msg.format( msg )

return { 'isOk': False, 'message': msg }

return data

# Overwrite QgsTask methods

def run(self):

# Overwrite by subclass

return True

def finished(self, result):

self.finish.emit( result, self.isCanceled(), self.message )

def cancel(self):

self.message = QCoreApplication.translate('GimpSelectionFeature', 'Cancel by user')

def __init__(self, socketClient, data):

"""

TaskSendImage: Task for create canvas image canvas and send message to Gimp

:params socket socket: Socket for send message for Gimp

:params dict data: parameters for create image canvas

'canvas': MapCanvas

'layers': Image layers

'filepath': file path of canvas image

"""

super().__init__('Send image to Gimp', socketClient, data )

self.message = QCoreApplication.translate('GimpSelectionFeature', "Sent image '{}' to GIMP")

self.message = self.message.format( data['filepath'] )

def _setParamsSendData(self, image):

e = self.data['canvas'].extent()

imgWidth, imgHeight = image.width(), image.height()

resX, resY = e.width() / imgWidth, e.height() / imgHeight

vmap = { l.name(): l.source() for l in self.data['layers'] }

self.paramsSendData = {

'function': 'add_image',

'filename': self.data['filepath'],

'paramImage': {

'extent_map': e.asWktCoordinates(), # xMin, yMin, xMax, yMax,

'crs_map': self.data['canvas'].mapSettings().destinationCrs().authid(),

'res': { 'X': resX, 'Y': resY },

'json_images': json.dumps( vmap )

}

}

def _process(self):

def finished():

image = job.renderedImage()

if bool( self.data['canvas'].property('retro') ):

image = image.scaled( image.width() / 3, image.height() / 3 )

image = image.convertToFormat( QImage.Format_Indexed8, Qt.OrderedDither | Qt.OrderedAlphaDither )

image.save( self.data['filepath'], "TIFF", 100 ) # 100: Uncompressed

self._setParamsSendData( image )

settings = QgsMapSettings( self.data['canvas'].mapSettings() )

settings.setBackgroundColor( QColor( Qt.transparent ) )

settings.setLayers( self.data['layers'] )

job = QgsMapRendererParallelJob( settings )

job.start()

job.finished.connect( finished)

job.waitForFinished()

def run(self):

self._process()

r = self._sendData()

if not r['isOk']:

self.message = r['message']

return False

addFeature = pyqtSignal(QgsFeature)

def __init__(self, socketClient, data):

"""

TaskGetFeatures: Task for get features from Gimp

:params socket socket: Socket for send message for Gimp

:params dict data: parameters for get features

'filepath': file path of selection image

'layerPolygon': Layer of polygon

'smooth': Parameters { 'iter', 'offset' }

'sieve': Parameters { 'threshold', 'connectedness' }

'azimuth': Parameters { 'threshold' }

"""

super().__init__('Get features from Gimp', socketClient, data )

self.project = QgsProject.instance()

self.message = QCoreApplication.translate('GimpSelectionFeature', 'Received features from GIMP')

self.paramsProcess = data

self.paramsSendData = {

'function': 'create_selection_image',

'filename': data['filepath']

}

def _process(self, paramsReceive):

def getParamsTransform(extent_map, ulPixelSelect, resolution):

smin, smax = extent_map.split(',')

ulX = float( smin.split(' ')[0])

ulY = float( smax.strip().split(' ')[1])

ulX_SelImage = ulX + ulPixelSelect['X'] * resolution['X']

ulY_SelImage = ulY - ulPixelSelect['Y'] * resolution['Y']

return ( ulX_SelImage, resolution['X'], 0.0, ulY_SelImage, 0.0, -1 * resolution['Y'] )

def getBandSelect():

ds = gdal.Open( self.paramsProcess['filepath'], gdal.GA_ReadOnly )

if gdal.GetLastErrorType() != 0:

ds = None

return { 'isOk': False, 'message': gdal.GetLastErrorMsg() }

band = ds.GetRasterBand( 1 )

band.SetNoDataValue( 0.0 )

return { 'isOk': True, 'dataset': ds, 'band': band}

def polygonizeSelectionBand(ds_Select, band_Select, paramsTransform, wktProj):

def setGeomAzimuthTolerance(geom, threshold):

def changeRing(ring):

def azimuth(p1, p2):

dx = p2[0] - p1[0]

dy = p2[1] - p1[1]

az = math.atan2( dx, dy ) * 180.0 / math.pi

return az

if ring.GetPointCount() < 4:

return

points = ring.GetPoints()

ids_new = [ 0 ]

upperIdPoints = len( points ) -1

for i in range( 1, upperIdPoints ):

aznew = azimuth( points[ ids_new[-1] ], points[ i ] )

az = azimuth( points[ i ], points[ i+1 ] )

if abs( az - aznew ) > threshold:

ids_new.append( i )

ids_new.append( upperIdPoints )

if len( ids_new ) < len( points ):

ids_remove = list( set( range( len( points ) ) ) - set( ids_new ) )

ids_remove.sort()

ids_remove.reverse()

for i in range( len( ids_remove ) ):

del points[ ids_remove[ i ] ]

ring.Empty()

for i in range( len( points ) ):

ring.SetPoint_2D( i, points[i][0], points[i][1] )

numPolygons = geom.GetGeometryCount()

for id1 in range( numPolygons ):

polygon = geom.GetGeometryRef( id1 )

numRings = polygon.GetGeometryCount()

if numRings == 0:

changeRing( polygon ) # Only Out ring!

else:

for id2 in range( numRings ):

ring = polygon.GetGeometryRef( id2)

changeRing( ring )

# Sieve Band

drvMem = gdal.GetDriverByName('MEM')

ds_sieve = drvMem.Create( '', ds_Select.RasterXSize, ds_Select.RasterYSize, 1, band_Select.DataType )

ds_sieve.SetGeoTransform( paramsTransform )

band_sieve = ds_sieve.GetRasterBand(1)

p_threshold = self.paramsProcess['sieve']['threshold']

p_connectedness = self.paramsProcess['sieve']['connectedness']

gdal.SieveFilter( band_Select, None, band_sieve, p_threshold, p_connectedness, [], callback=None )

if gdal.GetLastErrorType() != 0:

return { 'isOk': False, 'message': gdal.GetLastErrorMsg() }

# Memory layer - Polygonize

srs = osr.SpatialReference()

srs.ImportFromWkt( wktProj )

drv_poly = ogr.GetDriverByName('MEMORY')

ds_poly = drv_poly.CreateDataSource('memData')

layer_poly = ds_poly.CreateLayer( 'memLayer', srs, ogr.wkbPolygon )

field = ogr.FieldDefn("dn", ogr.OFTInteger)

layer_poly.CreateField( field )

idField = 0

gdal.Polygonize( band_sieve, None, layer_poly, idField, [], callback=None )

ds_sieve = band_sieve = None

if gdal.GetLastErrorType() != 0:

ds_poly,layer_poly = None, None

return { 'isOk': False, 'message': gdal.GetLastErrorMsg() }

# Get Geoms - Apply Azimuth tolerance

geoms = []

layer_poly.SetAttributeFilter("dn = 255")

p_threshold = self.paramsProcess['azimuth']['threshold']

if p_threshold > 0:

p_threshold = float( p_threshold )

for feat in layer_poly:

geom = feat.GetGeometryRef()

setGeomAzimuthTolerance( geom, p_threshold )

geoms.append( geom.Clone() )

else:

for feat in layer_poly:

geoms.append( feat.GetGeometryRef().Clone() )

ds_poly,layer_poly = None, None

return { 'isOk': True, 'geoms': geoms }

def calcAreaPixelInLayerPolygon(crs_map, paramsTransform):

crsImage = QgsCoordinateReferenceSystem( crs_map )

crsLayer = self.paramsProcess['layerPolygon'].crs()

ct = QgsCoordinateTransform( crsImage, crsLayer, QgsCoordinateTransformContext() )

p1 = ct.transform( paramsTransform[0], paramsTransform[3] )

p2 = ct.transform( p1.x() + paramsTransform[1], p1.y() + paramsTransform[5] )

dist = p1.distance( p2 )

return dist * dist

def getAttributes(json_images, crs_map, extent_map):

v_json = json.loads( json_images )

html = getHtmlTreeMetadata( v_json, '')

sdatetime = str( datetime.datetime.today().replace(microsecond=0) )

return {

'images': html,

'total_imgs': len( v_json ),

'crs_map': crs_map,

'extent_map': extent_map,

'date_add': sdatetime,

'id_add': self.paramsProcess['id_add'],

'user': self.paramsProcess['user'],

'annotation': self.paramsProcess['annotation']

}

def addFeatures(geoms, attributes, areaPixel):

def getGeometryAdjustedBorder(geom, areaMinInLayer):

def getGeomPolygonRing(rings, idRing):

# rings = [ QgsPointXY ]

ringPoints = [ QgsPoint( p ) for p in rings[ idRing ] ] # [ QgsPoint ]

line = QgsLineString( ringPoints )

del ringPoints[:]

polygon = QgsPolygon()

polygon.setExteriorRing( line )

del line

return QgsGeometry( polygon )

def getGeomOutCombines(geom):

geomCombines = None

iter = self.paramsProcess['layerPolygon'].getFeatures( geom.boundingBox() )

feat = QgsFeature()

while iter.nextFeature( feat ):

g = getGeomPolygonRing( feat.geometry().asPolygon(), 0 )

if geom.overlaps( g ):

if geomCombines is None:

geomCombines = g

else:

gTemp = geomCombines.combine( g )

geomCombines = gTemp

return geomCombines

def getGapsBorder(geom, geomBorder):

geomOutRing = getGeomPolygonRing( geom.asPolygon(), 0 )

g = geomOutRing.combine( geomBorder )

del geomOutRing

polygons = g.asPolygon()

del polygons[0] # Out ring

del g

return polygons

def addGapsInGeom(geom, polygonGaps, areaMinInLayer):

geomResult = geom

for id in range( len( polygonGaps ) ):

g = getGeomPolygonRing( polygonGaps, id )

if g.area() <= areaMinInLayer:

gTemp = geomResult.combine( g )

geomResult = gTemp

del g

return geomResult

geomCombines = getGeomOutCombines(geom) # No holes

if geomCombines is None:

return geom

geomDiff = geom.difference( geomCombines )

polygonsGap = getGapsBorder( geomDiff, geomCombines )

return addGapsInGeom( geomDiff, polygonsGap, areaMinInLayer )

feature = QgsFeature( self.paramsProcess['layerPolygon'].fields() )

for k in attributes.keys():

feature.setAttribute( k, attributes[ k ] )

args = (

QgsCoordinateReferenceSystem( paramsReceive['crs_map'] ),

self.paramsProcess['layerPolygon'].crs(),

self.project

)

ct = QgsCoordinateTransform( *args )

p_iter = self.paramsProcess['smooth']['iter']

p_offset = self.paramsProcess['smooth']['offset']

for geom in geoms:

_geom = QgsGeometry.fromWkt( geom.ExportToIsoWkt() )

geom = None

_geom.transform( ct )

geomLayer = _geom.smooth( p_iter, p_offset )

del _geom

if not self.paramsProcess['pixelsRemove'] is None:

areaMinInLayer = areaPixel * self.paramsProcess['pixelsRemove']

geomLayer = getGeometryAdjustedBorder( geomLayer, areaMinInLayer )

feat = QgsFeature( feature )

feat.setGeometry( geomLayer )

self.addFeature.emit( feat )

del geomLayer

# Calculate Geometry

r = getBandSelect()

if not r['isOk']:

self.message = r['message']

return False

if self.isCanceled():

r['dataset'], r['band'] = None, None

return True

ds_Select = r['dataset']

band_Select = r['band']

args = ( paramsReceive['extent_map'], paramsReceive['ulPixelSelect'], paramsReceive['res'] )

paramsTransform = getParamsTransform( *args )

wktProj = QgsCoordinateReferenceSystem( paramsReceive['crs_map'] ).toWkt()

r = polygonizeSelectionBand( ds_Select, band_Select, paramsTransform, wktProj )

band_Select, ds_Select = None, None

if not r['isOk']:

self.message = r['message']

return False

if self.isCanceled():

return True

geoms = r['geoms']

totalFeats = len( geoms )

if totalFeats == 0:

msg = QCoreApplication.translate('GimpSelectionFeature', "Not found features in selections ('{}')")

msg = msg.format( self.paramsProcess['filepath'] )

self.message = msg

return False

# Send data for create Features

msg = QCoreApplication.translate('GimpSelectionFeature', "Added {} features in '{}'")

msg = msg.format( totalFeats, self.paramsProcess['layerPolygon'].name() )

self.message = msg

args = ( paramsReceive['json_images'], paramsReceive['crs_map'], paramsReceive['extent_map'] )

atts = getAttributes( *args )

areaPixel = calcAreaPixelInLayerPolygon( paramsReceive['crs_map'], paramsTransform )

addFeatures( geoms, atts, areaPixel )

return True

def run(self):

r = self._sendData()

if not r['isOk']:

self.message = r['message']

return False