def get_series_initial_info(self):
url = unicode(self.url)
html_data = urllib.urlopen(url).read()
soup = BeautifulSoup(html_data, 'lxml')
# Get Form
title_section = soup.find('h2', attrs={'style': 'padding-left:0.5em'})
title = title_section.find('a')
# print title.text
url_init = ''.join(['http://mangachameleon.com/', title_section.find('a').get('href')])
# print url_init
html_data = urllib.urlopen(unicode(url_init)).read()
soup_init = BeautifulSoup(html_data, 'lxml')
image_cover_main = soup_init.find('img',
attrs={'style': 'max-width: 222px; padding-bottom:2em '})
image_cover = image_cover_main.get('src')
#print image_cover_main.find('img')
image_local = urllib.urlretrieve(image_cover, os.path.join(unicode(QDir.tempPath()), 'cover'))
self.series_title = title.text
self.temp_file = tempfile.mkdtemp(suffix=title.text, dir=unicode(QDir.tempPath()))
# Get chapter number
chapter_section = soup.find('form', attrs={'class': 'col-md-3 col-sm-4 col-xs-12'})
current_chapter = (chapter_section.find('select')).find('option', attrs={'selected': 'selected'})
print current_chapter.text
match = re.search(r'\b[0-9]+(.[0-9]+)?', current_chapter.text)
self.chapter = match.group()
print match.group()
self.page_init.emit(os.path.join(unicode(QDir.tempPath()), 'cover'), title.text, self.chapter)
def testComposition(self, page=0, pixelDiff=0):
if self.mComposition is None:
myMessage = "Composition not valid"
return False, myMessage
# load expected image
self.setControlName("expected_" + self.mTestName)
# get width/height, create image and render the composition to it
outputImage = QImage(self.mSize, QImage.Format_RGB32)
self.mComposition.setPlotStyle(QgsComposition.Print)
outputImage.setDotsPerMeterX(self.mDotsPerMeter)
outputImage.setDotsPerMeterY(self.mDotsPerMeter)
QgsMultiRenderChecker.drawBackground(outputImage)
p = QPainter(outputImage)
self.mComposition.renderPage(p, page)
p.end()
renderedFilePath = QDir.tempPath() + QDir.separator() + QFileInfo(self.mTestName).baseName() + "_rendered.png"
outputImage.save(renderedFilePath, "PNG")
self.setRenderedImage(renderedFilePath)
testResult = self.runTest(self.mTestName, pixelDiff)
return testResult, self.report()
def initPlugin(self, signalproxy):
"""Init function - called when pluginloader loads plugin."""
self.signalproxy = signalproxy
self.model = EntryModel()
self.config = NavigationPluginConfig()
signalproxy.distributedObjects.configStore.registerConfigSet(
self.config)
self.config.itemsHaveChanged.connect(self.update)
self.view = NavigationView(self.signalproxy)
self.view.setModel(self.model)
# create and place DockWidget in mainwindow using signalproxy
self.signalproxy.insertDockWidget(self, self.view, "Navigation",
Qt.BottomDockWidgetArea, True,
QIcon(PluginIcon))
self.signalproxy.distributedObjects.debugController.executableOpened.connect(
self.update)
self.ctagsRunner = CTagsRunner("%s/tags%d" %
(str(QDir.tempPath()), os.getpid()))
self.ctagsRunner.tagsFileAvailable.connect(self.tagsFileReady,
Qt.QueuedConnection)
# load the tags if the plugin was loaded after the executable
self.update()
def show_selector(self):
if self.selector != self.stack.currentWidget():
temp_dir = os.path.join(QDir.tempPath(), "ninja-ide")
if not os.path.exists(temp_dir):
os.mkdir(temp_dir)
collected_data = []
current = self.stack.currentIndex()
for index in range(self.stack.count()):
widget = self.stack.widget(index)
if widget == self.selector:
continue
closable = True
if widget == self.splitter:
closable = False
pixmap = QPixmap.grabWidget(widget, widget.rect())
path = os.path.join(temp_dir, "screen%s.png" % index)
pixmap.save(path)
if index == current:
self.selector.set_preview(index, path)
collected_data.insert(0, (index, path, closable))
else:
collected_data.append((index, path, closable))
self.selector.set_model(collected_data)
else:
self.selector.close_selector()
def tempFolder():
tempDir = os.path.join(unicode(QDir.tempPath()),
'processing' + _tempFolderSuffix)
if not QDir(tempDir).exists():
QDir().mkpath(tempDir)
return unicode(os.path.abspath(tempDir))
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
authcfg = repositories.all()[plugin["zip_repository"]]["authcfg"]
if authcfg and isinstance(authcfg, basestring):
if not QgsAuthManager.instance().updateNetworkRequest(
self.request, authcfg.strip()):
self.mResult = self.tr(
"Update of network request with authentication "
"credentials FAILED for configuration '{0}'").format(authcfg)
self.request = None
if self.request is not None:
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def testComposition(self, page=0, pixelDiff=0 ):
if self.mComposition is None:
myMessage = "Composition not valid"
return False, myMessage
#load expected image
self.setControlName("expected_"+self.mTestName)
# get width/height, create image and render the composition to it
outputImage = QImage( self.mSize, QImage.Format_RGB32 )
self.mComposition.setPlotStyle( QgsComposition.Print )
outputImage.setDotsPerMeterX( self.mDotsPerMeter )
outputImage.setDotsPerMeterY( self.mDotsPerMeter )
QgsMultiRenderChecker.drawBackground( outputImage )
p = QPainter( outputImage )
self.mComposition.renderPage( p, page )
p.end()
renderedFilePath = QDir.tempPath() + QDir.separator() + QFileInfo(self.mTestName).baseName() + "_rendered.png"
outputImage.save( renderedFilePath, "PNG" )
self.setRenderedImage( renderedFilePath )
testResult = self.runTest( self.mTestName, pixelDiff )
return testResult, self.report()
def show_selector(self):
if self.selector != self.stack.currentWidget():
temp_dir = os.path.join(QDir.tempPath(), "ninja-ide")
if not os.path.exists(temp_dir):
os.mkdir(temp_dir)
collected_data = []
current = self.stack.currentIndex()
for index in range(self.stack.count()):
widget = self.stack.widget(index)
if widget == self.selector:
continue
closable = True
if widget == self.splitter:
closable = False
pixmap = QPixmap.grabWidget(widget, widget.rect())
path = os.path.join(temp_dir, "screen%s.png" % index)
pixmap.save(path)
if index == current:
self.selector.set_preview(index, path)
collected_data.insert(0, (index, path, closable))
else:
collected_data.append((index, path, closable))
self.selector.set_model(collected_data)
else:
self.selector.close_selector()
def testDateTimeWriteShapefile(self):
"""Check writing date and time fields to an ESRI shapefile."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int&'
'field=date_f:date&field=time_f:time&field=dt_f:datetime'),
'test', 'memory')
assert ml is not None, 'Provider not initialised'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
ft.setAttributes([
1,
QDate(2014, 3, 5),
QTime(13, 45, 22),
QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))
])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name),
u'test', u'ogr')
fields = created_layer.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_f')).type(), QVariant.Date)
#shapefiles do not support time types, result should be string
self.assertEqual(
fields.at(fields.indexFromName('time_f')).type(), QVariant.String)
#shapefiles do not support datetime types, result should be date
self.assertEqual(
fields.at(fields.indexFromName('dt_f')).type(), QVariant.Date)
f = created_layer.getFeatures(QgsFeatureRequest()).next()
date_idx = created_layer.fieldNameIndex('date_f')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fieldNameIndex('time_f')
#shapefiles do not support time types
assert isinstance(f.attributes()[time_idx], basestring)
self.assertEqual(f.attributes()[time_idx], '13:45:22')
#shapefiles do not support datetime types
datetime_idx = created_layer.fieldNameIndex('dt_f')
assert isinstance(f.attributes()[datetime_idx], QDate)
self.assertEqual(f.attributes()[datetime_idx], QDate(2014, 3, 5))
def openProject(projectFile):
folder = os.path.dirname(projectFile)
projectName = os.path.basename(projectFile)
tempDir = os.path.join(QDir.tempPath(), 'lessons' , 'lesson' + str(time.time()))
dest = os.path.abspath(tempDir)
shutil.copytree(folder, dest)
tempProjectFile = os.path.join(dest, projectName)
iface.addProject(tempProjectFile)
def get_temp_dir(dirname=''):
""" get path to temporary directory """
temp = str(QDir.tempPath()+'/sidd/')
if not os.path.exists(temp):
os.mkdir(temp)
if dirname != '':
temp = temp + dirname + '/'
if not os.path.exists(temp):
os.mkdir(temp)
return temp
def get_temp_dir(dirname=''):
""" get path to temporary directory """
temp = str(QDir.tempPath() + '/sidd/')
if not os.path.exists(temp):
os.mkdir(temp)
if dirname != '':
temp = temp + dirname + '/'
if not os.path.exists(temp):
os.mkdir(temp)
return temp
def testDateTimeWriteShapefile(self):
"""Check writing date and time fields to an ESRI shapefile."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int&'
'field=date_f:date&field=time_f:time&field=dt_f:datetime'),
'test',
'memory')
assert ml is not None, 'Provider not initialized'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
ft.setAttributes([1, QDate(2014, 3, 5), QTime(13, 45, 22), QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
fields = created_layer.dataProvider().fields()
self.assertEqual(fields.at(fields.indexFromName('date_f')).type(), QVariant.Date)
#shapefiles do not support time types, result should be string
self.assertEqual(fields.at(fields.indexFromName('time_f')).type(), QVariant.String)
#shapefiles do not support datetime types, result should be string
self.assertEqual(fields.at(fields.indexFromName('dt_f')).type(), QVariant.String)
f = created_layer.getFeatures(QgsFeatureRequest()).next()
date_idx = created_layer.fieldNameIndex('date_f')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fieldNameIndex('time_f')
#shapefiles do not support time types
assert isinstance(f.attributes()[time_idx], basestring)
self.assertEqual(f.attributes()[time_idx], '13:45:22')
#shapefiles do not support datetime types
datetime_idx = created_layer.fieldNameIndex('dt_f')
assert isinstance(f.attributes()[datetime_idx], basestring)
self.assertEqual(f.attributes()[datetime_idx], QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"))
def testPrintMapFromTemplate(self):
"""Test that we can get a map to render in the template."""
myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
myFileInfo = QFileInfo(myPath)
myRasterLayer = QgsRasterLayer(myFileInfo.filePath(),
myFileInfo.completeBaseName())
myRenderer = QgsMultiBandColorRenderer(
myRasterLayer.dataProvider(), 2, 3, 4
)
#mRasterLayer.setRenderer( rasterRenderer )
myPipe = myRasterLayer.pipe()
assert myPipe.set( myRenderer ), "Cannot set pipe renderer"
QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])
myMapRenderer = QgsMapRenderer()
myLayerStringList = []
myLayerStringList.append(myRasterLayer.id())
myMapRenderer.setLayerSet(myLayerStringList)
myMapRenderer.setProjectionsEnabled(False)
myComposition = QgsComposition(myMapRenderer)
myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
myTemplateFile = file(myFile, 'rt')
myTemplateContent = myTemplateFile.read()
myTemplateFile.close()
myDocument = QDomDocument()
myDocument.setContent(myTemplateContent)
myComposition.loadFromTemplate(myDocument)
# now render the map, first zooming to the raster extents
myMap = myComposition.getComposerMapById(0)
myMessage = ('Map 0 could not be found in template %s', myFile)
assert myMap is not None, myMessage
myExtent = myRasterLayer.extent()
myMap.setNewExtent(myExtent)
myImagePath = os.path.join(str(QDir.tempPath()),
'template_map_render_python.png')
myPageNumber = 0
myImage = myComposition.printPageAsRaster(myPageNumber)
myImage.save(myImagePath)
assert os.path.exists(myImagePath), 'Map render was not created.'
# Not sure if this is a predictable way to test but its quicker than
# rendering.
myFileSize = QFileInfo(myImagePath).size()
myExpectedFileSize = 100000
myMessage = ('Expected file size to be greater than %s, got %s'
' for %s' %
(myExpectedFileSize, myFileSize, myImagePath))
assert myFileSize > myExpectedFileSize, myMessage
def __init__(self, xdk_filename):
# create the new XdkItem
super(XdkItem, self).__init__(None, xdk_filename)
# creates the new XdkItem
basename = os.path.basename(str(xdk_filename))
name = os.path.splitext(basename)[0]
temppath = str(QDir.tempPath())
temp_path = os.path.join(temppath, 'xdk/%s' % name)
# define custom properties
self._tempFilepath = temp_path
self._searchurls = {}
# set the options
self.setChildIndicatorPolicy(self.ShowIndicator)
self.setIcon(0, QIcon(projexui.resources.find('img/sdk.png')))
toc_file = os.path.join(temp_path, 'toc.xml')
toc_xml = None
if toc_file:
try:
toc_xml = ElementTree.parse(toc_file).getroot()
except:
pass
if toc_xml is not None:
self._url = 'file:///%s/index.html' % temp_path.strip('/')
self.setText(0, toc_xml.get('name', self.text(0)))
self.loadFromXml(toc_xml, temp_path)
else:
# load the url information for this entry
for name in sorted(os.listdir(temp_path)):
# ignore 'hidden' folders
if name.startswith('_') and not name.startswith('__'):
continue
# ignore special cases (only want modules for this)
if '-' in name or name == 'toc.xml':
continue
# use the index or __init__ information
if name == '__init__.html':
self._url = 'file:///%s/%s' % (temp_path, name)
continue
elif name == 'index.html':
self._url = 'file:///%s/%s' % (temp_path, name)
# otherwise, load a childitem
XdkEntryItem(self, os.path.join(temp_path, name))
def __init__( self, xdk_filename ):
# create the new XdkItem
super(XdkItem, self).__init__(None, xdk_filename)
# creates the new XdkItem
basename = os.path.basename(str(xdk_filename))
name = os.path.splitext(basename)[0]
temppath = str(QDir.tempPath())
temp_path = os.path.join(temppath, 'xdk/%s' % name)
# define custom properties
self._tempFilepath = temp_path
self._searchurls = {}
# set the options
self.setChildIndicatorPolicy(self.ShowIndicator)
self.setIcon(0, QIcon(projexui.resources.find('img/sdk.png')))
toc_file = os.path.join(temp_path, 'toc.xml')
toc_xml = None
if toc_file:
try:
toc_xml = ElementTree.parse(toc_file).getroot()
except:
pass
if toc_xml is not None:
self._url = 'file:///%s/index.html' % temp_path.strip('/')
self.setText(0, toc_xml.get('name', self.text(0)))
self.loadFromXml(toc_xml, temp_path)
else:
# load the url information for this entry
for name in sorted(os.listdir(temp_path)):
# ignore 'hidden' folders
if name.startswith('_') and not name.startswith('__'):
continue
# ignore special cases (only want modules for this)
if '-' in name or name == 'toc.xml':
continue
# use the index or __init__ information
if name == '__init__.html':
self._url = 'file:///%s/%s' % (temp_path, name)
continue
elif name == 'index.html':
self._url = 'file:///%s/%s' % (temp_path, name)
# otherwise, load a childitem
XdkEntryItem(self, os.path.join(temp_path, name))
def testDateTimeWriteShapefile(self):
"""Check writing date and time fields to an ESRI shapefile."""
ml = QgsVectorLayer(
("Point?crs=epsg:4326&field=id:int&" "field=date_f:date&field=time_f:time&field=dt_f:datetime"),
"test",
"memory",
)
assert ml is not None, "Provider not initialised"
assert ml.isValid(), "Source layer not valid"
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
ft.setAttributes(
[1, QDate(2014, 0o3, 0o5), QTime(13, 45, 22), QDateTime(QDate(2014, 0o3, 0o5), QTime(13, 45, 22))]
)
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), "datetime.shp")
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(ml, dest_file_name, "utf-8", crs, "ESRI Shapefile")
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u"{}|layerid=0".format(dest_file_name), u"test", u"ogr")
fields = created_layer.dataProvider().fields()
self.assertEqual(fields.at(fields.indexFromName("date_f")).type(), QVariant.Date)
# shapefiles do not support time types, result should be string
self.assertEqual(fields.at(fields.indexFromName("time_f")).type(), QVariant.String)
# shapefiles do not support datetime types, result should be date
self.assertEqual(fields.at(fields.indexFromName("dt_f")).type(), QVariant.Date)
f = created_layer.getFeatures(QgsFeatureRequest()).next()
date_idx = created_layer.fieldNameIndex("date_f")
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 0o3, 0o5))
time_idx = created_layer.fieldNameIndex("time_f")
# shapefiles do not support time types
assert isinstance(f.attributes()[time_idx], basestring)
self.assertEqual(f.attributes()[time_idx], "13:45:22")
# shapefiles do not support datetime types
datetime_idx = created_layer.fieldNameIndex("dt_f")
assert isinstance(f.attributes()[datetime_idx], QDate)
self.assertEqual(f.attributes()[datetime_idx], QDate(2014, 0o3, 0o5))
def testWrite(self):
for name in glob.glob( "%s/raster/*.tif" % self.testDataDir ):
baseName = os.path.basename ( name )
allOk = True
ok = self.write( "raster/%s" % baseName )
if not ok: allOk = False
reportFilePath = "%s/qgistest.html" % QDir.tempPath()
reportFile = open(reportFilePath,'a')
reportFile.write( self.report )
reportFile.close()
assert allOk, "Raster file writer test failed"
def testWrite(self):
for name in glob.glob("%s/raster/*.tif" % self.testDataDir):
baseName = os.path.basename(name)
allOk = True
ok = self.write("raster/%s" % baseName)
if not ok: allOk = False
reportFilePath = "%s/qgistest.html" % QDir.tempPath()
reportFile = open(reportFilePath, 'a')
reportFile.write(self.report)
reportFile.close()
assert allOk, "Raster file writer test failed"
def imageCheck(self, name, reference_image, image):
self.report += "<h2>Render {}</h2>\n".format(name)
temp_dir = QDir.tempPath() + '/'
file_name = temp_dir + 'symbol_' + name + ".png"
image.save(file_name, "PNG")
checker = QgsRenderChecker()
checker.setControlPathPrefix("symbolv2")
checker.setControlName("expected_" + reference_image)
checker.setRenderedImage(file_name)
checker.setColorTolerance(2)
result = checker.compareImages(name, 20)
self.report += checker.report()
print self.report
return result
def imageCheck(self, name, reference_image, image):
self.report += "<h2>Render {}</h2>\n".format(name)
temp_dir = QDir.tempPath() + '/'
file_name = temp_dir + 'symbol_' + name + ".png"
image.save(file_name, "PNG")
checker = QgsRenderChecker()
checker.setControlPathPrefix("symbolv2")
checker.setControlName("expected_" + reference_image)
checker.setRenderedImage(file_name)
checker.setColorTolerance(2)
result = checker.compareImages(name, 20)
self.report += checker.report()
print self.report
return result
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
drag = QDrag(self)
data = QMimeData()
data.setData("text/plain", str(self.text()))
path = QDir.tempPath() + "/hello.txt"
f = open(path, "w")
f.write("Hello world!")
f.close()
data.setUrls([QUrl.fromLocalFile(path)])
drag.setMimeData(data)
drag.exec_()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
drag = QDrag(self)
data = QMimeData()
data.setData("text/plain", str(self.text()))
path = QDir.tempPath() + "/hello.txt"
f = open(path, "w")
f.write("Hello world!")
f.close()
data.setUrls([QUrl.fromLocalFile(path)])
drag.setMimeData(data)
drag.exec_()
def mapCanvasImage(self, transp_background=False):
""" returns base64 encoded map canvas image """
if transp_background:
size = self.context.mapSettings.outputSize()
return self.renderedImage(size.width(), size.height(), self.context.baseExtent, transp_background)
canvas = self.context.canvas
if QGis.QGIS_VERSION_INT >= 20400:
return tools.base64image(canvas.map().contentImage())
temp_dir = QDir.tempPath()
texfilename = os.path.join(temp_dir, "tex%s.png" % (self.context.timestamp))
canvas.saveAsImage(texfilename)
texData = gdal2threejs.base64image(texfilename)
tools.removeTemporaryFiles([texfilename, texfilename + "w"])
return texData
def writeShape(theMemoryLayer, theFileName):
myFileName = os.path.join(str(QDir.tempPath()), theFileName)
print myFileName
# Explicitly giving all options, not really needed but nice for clarity
myErrorMessage = ''
myOptions = []
myLayerOptions = []
mySelectedOnlyFlag = False
mySkipAttributesFlag = False
myGeoCrs = QgsCoordinateReferenceSystem()
myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
myResult = QgsVectorFileWriter.writeAsVectorFormat(
theMemoryLayer, myFileName, 'utf-8', myGeoCrs, 'ESRI Shapefile',
mySelectedOnlyFlag, myErrorMessage, myOptions, myLayerOptions,
mySkipAttributesFlag)
assert myResult == QgsVectorFileWriter.NoError
def display_downloaded_content(self):
"""
Called when an unsupported content type is finished downloading.
"""
file_path = QDir.toNativeSeparators(QDir.tempPath() + "/XXXXXX_" + self.content_filename)
myfile = QTemporaryFile(file_path)
myfile.setAutoRemove(False)
if (myfile.open()):
myfile.write(self.reply.readAll())
myfile.close()
subprocess.Popen([self.content_handlers.get(str(self.content_type)), myfile.fileName()])
#Sometimes downloading files opens an empty window.
#So if the current window has no URL, close it.
if(str(self.url().toString()) in ('', 'about:blank')):
self.close()
def unload(self):
self.iface.removePluginMenu(u"Lessons", self.action)
del self.helpAction
self.iface.removePluginMenu(u"Lessons", self.helpAction)
del self.helpAction
tempDir = os.path.join(QDir.tempPath(), "lessons", "lesson")
if QDir(tempDir).exists():
shutil.rmtree(tempDir, True)
try:
from qgistester.tests import removeTestModule
from lessons.test import testerplugin
removeTestModule(testerplugin, "Lessons")
except Exception as e:
pass
def unload(self):
self.toolbox.cmbLayers.layerChanged.disconnect(
self._changeLandmarkLayer)
self.iface.removePluginVectorMenu(LandmarkPlugin.tr('Landmark'),
self.actionToolbox)
self.iface.removePluginVectorMenu(LandmarkPlugin.tr('Landmark'),
self.actionIdentify)
self.iface.removePluginVectorMenu(LandmarkPlugin.tr('Landmark'),
self.actionNewLandmark)
self.iface.removePluginVectorMenu(LandmarkPlugin.tr('Landmark'),
self.actionMoveLandmark)
self.iface.removePluginVectorMenu(LandmarkPlugin.tr('Landmark'),
self.actionImport)
self.iface.removePluginVectorMenu(LandmarkPlugin.tr('Landmark'),
self.actionExport)
if self.iface.mapCanvas().mapTool() == self.identifyTool:
self.iface.mapCanvas().unsetMapTool(self.identifyTool)
if self.iface.mapCanvas().mapTool() == self.addLandmarkTool:
self.iface.mapCanvas().unsetMapTool(self.addLandmarkTool)
if self.iface.mapCanvas().mapTool() == self.moveLandmarkTool:
self.iface.mapCanvas().unsetMapTool(self.moveLandmarkTool)
del self.identifyTool
del self.addLandmarkTool
del self.moveLandmarkTool
self.iface.mainWindow().removeToolBar(self.toolbar)
self.toolbox.close()
if self.toolbox.db is not None:
if self.toolbox.db.isOpen():
self.toolbox.db.close()
if hasattr(self.toolbox, 'highlight'):
del self.toolbox.highlight
del self.toolbox
self.toolbox = None
tmp = unicode(os.path.join(QDir.tempPath(), 'landmark'))
if QDir(tmp).exists():
shutil.rmtree(tmp, True)
def mapCanvasImage(self, transp_background=False):
""" returns base64 encoded map canvas image """
canvas = self.exportSettings.canvas
if canvas is None or transp_background:
size = self.exportSettings.mapSettings.outputSize()
return self.renderedImage(size.width(), size.height(),
self.exportSettings.baseExtent,
transp_background)
if QGis.QGIS_VERSION_INT >= 20400:
return tools.base64image(canvas.map().contentImage())
temp_dir = QDir.tempPath()
texfilename = os.path.join(
temp_dir, "tex%s.png" % (self.exportSettings.timestamp))
canvas.saveAsImage(texfilename)
texData = gdal2threejs.base64image(texfilename)
tools.removeTemporaryFiles([texfilename, texfilename + "w"])
return texData
def __init__(self,layer, settingsdict = {}):
#show the user this may take a long time...
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.settingsdict = settingsdict
provider = layer.dataProvider() # OGR provider
kolumnindex = provider.fieldNameIndex('obsid') # To find the column named 'obsid'
observations = layer.selectedFeatures()
i = 0
reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports')
if not os.path.exists(reportfolder):
os.makedirs(reportfolder)
reportpath = os.path.join(reportfolder, "w_qual_report.html")
#f = open(reportpath, "wb" )
f = codecs.open(reportpath, "wb", "utf-8")
#write some initiating html
rpt = r"""<head><title>water quality report from Midvatten plugin for QGIS</title></head>"""
rpt += r""" <meta http-equiv="content-type" content="text/html; charset=utf-8" />""" #NOTE, all report data must be in 'utf-8'
rpt += "<html><body>"
#rpt += "<table width=\"100%\" border=\"1\">\n"
#rpt2 = rpt.encode("utf-8")
f.write(rpt)
for object in observations:
attributes = observations[i]
obsid = attributes[kolumnindex]
print('about to get data for ' + obsid + ', at time: ' + str(time.time()))#debug
ReportData = self.GetData(self.settingsdict['database'], obsid) # one observation at a time
print('done with getting data for ' + obsid + ', at time: ' + str(time.time()))#debug
if ReportData:
self.WriteHTMLReport(ReportData, f)
i = i+1
print('wrote html report for ' + obsid + ', at time: ' + str(time.time()))#debug
#write some finishing html and close the file
f.write("\n</body></html>")
f.close()
QApplication.restoreOverrideCursor()#now this long process is done and the cursor is back as normal
if ReportData:
QDesktopServices.openUrl(QUrl.fromLocalFile(reportpath))
def testWrite(self):
"""Check we can write a vector file."""
self.mMemoryLayer = QgsVectorLayer(
('Point?crs=epsg:4326&field=name:string(20)&'
'field=age:integer&field=size:double&index=yes'),
'test',
'memory')
assert self.mMemoryLayer is not None, 'Provider not initialised'
myProvider = self.mMemoryLayer.dataProvider()
assert myProvider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10,10)))
ft.setAttributeMap({0 : QVariant('Johny'),
1 : QVariant(20),
2 : QVariant(0.3)})
myResult, myFeatures = myProvider.addFeatures([ft])
assert myResult == True
assert len(myFeatures) > 0
myFileName = os.path.join(str(QDir.tempPath()), 'writetest.shp')
print myFileName
# Explicitly giving all options, not really needed but nice for clarity
myErrorMessage = QString()
myOptions = QStringList()
myLayerOptions = QStringList()
mySelectedOnlyFlag = False
mySkipAttributesFlag = False
myGeoCrs = QgsCoordinateReferenceSystem()
myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
myResult = QgsVectorFileWriter.writeAsVectorFormat(
self.mMemoryLayer,
myFileName,
'utf-8',
myGeoCrs,
'ESRI Shapefile',
mySelectedOnlyFlag,
myErrorMessage,
myOptions,
myLayerOptions,
mySkipAttributesFlag)
assert myResult == QgsVectorFileWriter.NoError
def testStatistics(self):
"""Test zonal stats"""
sep = os.sep
TEST_DATA_DIR = unitTestDataPath() + sep + "zonalstatistics" + sep
myTempPath = QDir.tempPath() + sep
testDir = QDir(TEST_DATA_DIR)
for f in testDir.entryList(QDir.Files):
QFile.remove(myTempPath + f)
QFile.copy(TEST_DATA_DIR + f, myTempPath + f)
myVector = QgsVectorLayer(myTempPath + "polys.shp", "poly", "ogr")
myRasterPath = myTempPath + "edge_problem.asc"
zs = QgsZonalStatistics(myVector, myRasterPath, "", 1)
zs.calculateStatistics(None)
feat = QgsFeature()
# validate statistics for each feature
request = QgsFeatureRequest().setFilterFid(0)
feat = myVector.getFeatures(request).next()
myMessage = ('Expected: %f\nGot: %f\n' % (12.0, feat[1]))
assert feat[1] == 12.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (8.0, feat[2]))
assert feat[2] == 8.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (0.666666666666667, feat[3]))
assert abs(feat[3] - 0.666666666666667) < 0.00001, myMessage
request.setFilterFid(1)
feat = myVector.getFeatures(request).next()
myMessage = ('Expected: %f\nGot: %f\n' % (9.0, feat[1]))
assert feat[1] == 9.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (5.0, feat[2]))
assert feat[2] == 5.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (0.555555555555556, feat[3]))
assert abs(feat[3] - 0.555555555555556) < 0.00001, myMessage
request.setFilterFid(2)
feat = myVector.getFeatures(request).next()
myMessage = ('Expected: %f\nGot: %f\n' % (6.0, feat[1]))
assert feat[1] == 6.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (5.0, feat[2]))
assert feat[2] == 5.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (0.833333333333333, feat[3]))
assert abs(feat[3] - 0.833333333333333) < 0.00001, myMessage
def testStatistics(self):
"""Test zonal stats"""
sep = os.sep
TEST_DATA_DIR = unitTestDataPath() + sep + "zonalstatistics" + sep
myTempPath = QDir.tempPath() + sep
testDir = QDir(TEST_DATA_DIR)
for f in testDir.entryList(QDir.Files):
QFile.remove(myTempPath + f)
QFile.copy(TEST_DATA_DIR + f, myTempPath + f)
myVector = QgsVectorLayer(myTempPath + "polys.shp", "poly", "ogr")
myRasterPath = myTempPath + "edge_problem.asc"
zs = QgsZonalStatistics(myVector, myRasterPath, "", 1)
zs.calculateStatistics(None)
feat = QgsFeature()
# validate statistics for each feature
request = QgsFeatureRequest().setFilterFid(0)
feat = myVector.getFeatures(request).next()
myMessage = ('Expected: %f\nGot: %f\n' % (12.0, feat[1]))
assert feat[1] == 12.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (8.0, feat[2]))
assert feat[2] == 8.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (0.666666666666667, feat[3]))
assert abs(feat[3] - 0.666666666666667) < 0.00001, myMessage
request.setFilterFid(1)
feat = myVector.getFeatures(request).next()
myMessage = ('Expected: %f\nGot: %f\n' % (9.0, feat[1]))
assert feat[1] == 9.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (5.0, feat[2]))
assert feat[2] == 5.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (0.555555555555556, feat[3]))
assert abs(feat[3] - 0.555555555555556) < 0.00001, myMessage
request.setFilterFid(2)
feat = myVector.getFeatures(request).next()
myMessage = ('Expected: %f\nGot: %f\n' % (6.0, feat[1]))
assert feat[1] == 6.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (5.0, feat[2]))
assert feat[2] == 5.0, myMessage
myMessage = ('Expected: %f\nGot: %f\n' % (0.833333333333333, feat[3]))
assert abs(feat[3] - 0.833333333333333) < 0.00001, myMessage
def dropEvent( self, event ):
"""
Handles a drop event.
"""
url = event.mimeData().urls()[0]
url_path = str(url.toString())
# download an icon from the web
if ( not url_path.startswith('file:') ):
filename = os.path.basename(url_path)
temp_path = os.path.join(str(QDir.tempPath()), filename)
try:
urllib.urlretrieve(url_path, temp_path)
except IOError:
return
self.setFilepath(temp_path)
else:
self.setFilepath(url_path.replace('file://', ''))
def dropEvent(self, event):
"""
Handles a drop event.
"""
url = event.mimeData().urls()[0]
url_path = str(url.toString())
# download an icon from the web
if (not url_path.startswith('file:')):
filename = os.path.basename(url_path)
temp_path = os.path.join(str(QDir.tempPath()), filename)
try:
urllib.urlretrieve(url_path, temp_path)
except IOError:
return
self.setFilepath(temp_path)
else:
self.setFilepath(url_path.replace('file://', ''))
def testWriteShapefileWithMultiConversion(self):
"""Check writing geometries to an ESRI shapefile with conversion to multi."""
ml = QgsVectorLayer(('Point?crs=epsg:4326&field=id:int'), 'test',
'memory')
assert ml is not None, 'Provider not initialized'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt('Point (1 2)'))
ft.setAttributes([1])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'to_multi.shp')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
forceMulti=True)
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name),
u'test', u'ogr')
f = created_layer.getFeatures(QgsFeatureRequest()).next()
g = f.geometry()
wkt = g.exportToWkt()
expWkt = 'MultiPoint ((1 2))'
assert compareWkt(
expWkt, wkt
), "saving geometry with multi conversion failed: mismatch Expected:\n%s\nGot:\n%s\n" % (
expWkt, wkt)
def testWriteShapefileWithMultiConversion(self):
"""Check writing geometries to an ESRI shapefile with conversion to multi."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int'),
'test',
'memory')
assert ml is not None, 'Provider not initialized'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt('Point (1 2)'))
ft.setAttributes([1])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'to_multi.shp')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
forceMulti=True)
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
f = created_layer.getFeatures(QgsFeatureRequest()).next()
g = f.geometry()
wkt = g.exportToWkt()
expWkt = 'MultiPoint ((1 2))'
assert compareWkt(expWkt, wkt), "saving geometry with multi conversion failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt)
def loadFile(self, filename):
# creates the new XdkItem
filename = str(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
temp_dir = str(QDir.tempPath())
temp_path = os.path.join(temp_dir, 'xdk/%s' % name)
# remove existing files from the location
if os.path.exists(temp_path):
shutil.rmtree(temp_path, True)
# make sure we have the temp location available
if not os.path.exists(temp_path):
os.makedirs(temp_path)
# extract the zip files to the temp location
zfile = zipfile.ZipFile(filename, 'r')
zfile.extractall(temp_path)
zfile.close()
self.loadingFinished.emit(filename)
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0,0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir+"/"+fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
self.reply = QgsNetworkAccessManager.instance().get( self.request )
self.reply.downloadProgress.connect( self.readProgress )
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def __init__(self, parent, plugin):
QDialog.__init__(self, parent)
self.setupUi(self)
self.plugin = plugin
self.mResult = ""
self.progressBar.setRange(0, 0)
self.progressBar.setFormat("%p%")
self.labelName.setText(plugin["name"])
self.buttonBox.clicked.connect(self.abort)
url = QUrl(plugin["download_url"])
fileName = plugin["filename"]
tmpDir = QDir.tempPath()
tmpPath = QDir.cleanPath(tmpDir + "/" + fileName)
self.file = QFile(tmpPath)
self.request = QNetworkRequest(url)
self.reply = QgsNetworkAccessManager.instance().get(self.request)
self.reply.downloadProgress.connect(self.readProgress)
self.reply.finished.connect(self.requestFinished)
self.stateChanged(4)
def loadFile(self, filename):
# creates the new XdkItem
filename = str(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
temp_dir = str(QDir.tempPath())
temp_path = os.path.join(temp_dir, 'xdk/%s' % name)
# remove existing files from the location
if os.path.exists(temp_path):
shutil.rmtree(temp_path, True)
# make sure we have the temp location available
if not os.path.exists(temp_path):
os.makedirs(temp_path)
# extract the zip files to the temp location
zfile = zipfile.ZipFile(filename, 'r')
zfile.extractall(temp_path)
zfile.close()
self.loadingFinished.emit(filename)
def initPlugin(self, signalproxy):
"""Init function - called when pluginloader loads plugin."""
self.signalproxy = signalproxy
self.model = EntryModel()
self.config = NavigationPluginConfig()
signalproxy.distributedObjects.configStore.registerConfigSet(self.config)
self.config.itemsHaveChanged.connect(self.update)
self.view = NavigationView(self.signalproxy)
self.view.setModel(self.model)
# create and place DockWidget in mainwindow using signalproxy
self.signalproxy.insertDockWidget(self, self.view, "Navigation", Qt.BottomDockWidgetArea, True, QIcon(PluginIcon))
self.signalproxy.distributedObjects.debugController.executableOpened.connect(self.update)
self.ctagsRunner = CTagsRunner("%s/tags%d" % (str(QDir.tempPath()), os.getpid()))
self.ctagsRunner.tagsFileAvailable.connect(self.tagsFileReady, Qt.QueuedConnection)
# load the tags if the plugin was loaded after the executable
self.update()
def writeShape(theMemoryLayer, theFileName):
myFileName = os.path.join(str(QDir.tempPath()), theFileName)
print myFileName
# Explicitly giving all options, not really needed but nice for clarity
myErrorMessage = ''
myOptions = []
myLayerOptions = []
mySelectedOnlyFlag = False
mySkipAttributesFlag = False
myGeoCrs = QgsCoordinateReferenceSystem()
myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
myResult = QgsVectorFileWriter.writeAsVectorFormat(
theMemoryLayer,
myFileName,
'utf-8',
myGeoCrs,
'ESRI Shapefile',
mySelectedOnlyFlag,
myErrorMessage,
myOptions,
myLayerOptions,
mySkipAttributesFlag)
assert myResult == QgsVectorFileWriter.NoError
def testWrite(self):
"""Check we can write a vector file."""
self.mMemoryLayer = QgsVectorLayer(
('Point?crs=epsg:4326&field=name:string(20)&'
'field=age:integer&field=size:double&index=yes'), 'test',
'memory')
assert self.mMemoryLayer is not None, 'Provider not initialised'
myProvider = self.mMemoryLayer.dataProvider()
assert myProvider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(10, 10)))
ft.setAttributeMap({
0: QVariant('Johny'),
1: QVariant(20),
2: QVariant(0.3)
})
myResult, myFeatures = myProvider.addFeatures([ft])
assert myResult == True
assert len(myFeatures) > 0
myFileName = os.path.join(str(QDir.tempPath()), 'writetest.shp')
print myFileName
# Explicitly giving all options, not really needed but nice for clarity
myErrorMessage = QString()
myOptions = QStringList()
myLayerOptions = QStringList()
mySelectedOnlyFlag = False
mySkipAttributesFlag = False
myGeoCrs = QgsCoordinateReferenceSystem()
myGeoCrs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
myResult = QgsVectorFileWriter.writeAsVectorFormat(
self.mMemoryLayer, myFileName, 'utf-8', myGeoCrs, 'ESRI Shapefile',
mySelectedOnlyFlag, myErrorMessage, myOptions, myLayerOptions,
mySkipAttributesFlag)
assert myResult == True
def __init__(self, obsids=[''], settingsdict={}):
reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports')
if not os.path.exists(reportfolder):
os.makedirs(reportfolder)
reportpath = os.path.join(reportfolder, "drill_report.html")
logopath = os.path.join(os.sep, os.path.dirname(__file__), "..",
"templates", "midvatten_logga.png")
imgpath = os.path.join(os.sep, os.path.dirname(__file__), "..",
"templates")
if len(obsids) == 0:
utils.pop_up_info(
ru(
QCoreApplication.translate(
u'Drillreport', u"Must select one or more obsids!")))
return None
elif len(obsids) == 1:
merged_question = False
else:
#Due to problems regarding speed when opening many tabs, only the merge mode is used.
#merged_question = utils.Askuser(question='YesNo', msg="Do you want to open all drill reports merged on the same tab?\n"
# "Else they will be opened separately.\n\n(If answering no, creating drill reports for many obsids take 0.2 seconds per obsid.\nIt might fail if the computer is to slow.\nIf it fails, try to select only one obsid at the time)").result
merged_question = True
if merged_question:
f, rpt = self.open_file(', '.join(obsids), reportpath)
for obsid in obsids:
self.write_obsid(obsid, rpt, imgpath, logopath, f)
self.close_file(f, reportpath)
else:
#opened = False
for obsid in obsids:
f, rpt = self.open_file(obsid, reportpath)
self.write_obsid(obsid, rpt, imgpath, logopath, f)
url_status = self.close_file(f, reportpath)
def testWriteShapefileWithZ(self):
"""Check writing geometries with Z dimension to an ESRI shapefile."""
#start by saving a memory layer and forcing z
ml = QgsVectorLayer(('Point?crs=epsg:4326&field=id:int'), 'test',
'memory')
assert ml is not None, 'Provider not initialized'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt('PointZ (1 2 3)'))
ft.setAttributes([1])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
# check with both a standard PointZ and 25d style Point25D type
for t in [QgsWKBTypes.PointZ, QgsWKBTypes.Point25D]:
dest_file_name = os.path.join(
str(QDir.tempPath()),
'point_{}.shp'.format(QgsWKBTypes.displayString(t)))
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
overrideGeometryType=t)
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(
u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
f = created_layer.getFeatures(QgsFeatureRequest()).next()
g = f.geometry()
wkt = g.exportToWkt()
expWkt = 'PointZ (1 2 3)'
assert compareWkt(
expWkt, wkt
), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (
expWkt, wkt)
#also try saving out the shapefile version again, as an extra test
#this tests that saving a layer with z WITHOUT explicitly telling the writer to keep z values,
#will stay retain the z values
dest_file_name = os.path.join(
str(QDir.tempPath()),
'point_{}_copy.shp'.format(QgsWKBTypes.displayString(t)))
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
created_layer, dest_file_name, 'utf-8', crs, 'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer_from_shp = QgsVectorLayer(
u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
f = created_layer_from_shp.getFeatures(QgsFeatureRequest()).next()
g = f.geometry()
wkt = g.exportToWkt()
assert compareWkt(
expWkt, wkt
), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (
expWkt, wkt)
#storm shadow
#shows content of %AppData/local/temp
import idaapi
import sip
from PyQt4 import QtCore
from PyQt4.QtCore import *
from PyQt4.QtGui import (QApplication, QColumnView, QFileSystemModel,
QSplitter, QTreeView)
from PyQt4.QtCore import QDir, Qt
idahome = QDir.tempPath()
class MyWidget(QtGui.QDialog):
def __init__(self):
super(MyWidget, self).__init__()
def paintEvent(self, event):
self.splitter = QSplitter()
model = QFileSystemModel()
model.setRootPath(QDir.rootPath())
# model.setRootPath(idahome)
# using ida home instead
views = []
for ViewType in (QColumnView, QTreeView):
view = ViewType(self.splitter)
view.setModel(model)
view.setRootIndex(model.index(idahome))
view.setDragEnabled(True)
def testWriteShapefileWithZ(self):
"""Check writing geometries with Z dimension to an ESRI shapefile."""
#start by saving a memory layer and forcing z
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int'),
'test',
'memory')
assert ml is not None, 'Provider not initialized'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromWkt('PointZ (1 2 3)'))
ft.setAttributes([1])
res, features = provider.addFeatures([ft])
assert res
assert len(features) > 0
# check with both a standard PointZ and 25d style Point25D type
for t in [QgsWKBTypes.PointZ, QgsWKBTypes.Point25D]:
dest_file_name = os.path.join(str(QDir.tempPath()), 'point_{}.shp'.format(QgsWKBTypes.displayString(t)))
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile',
overrideGeometryType=t)
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
f = created_layer.getFeatures(QgsFeatureRequest()).next()
g = f.geometry()
wkt = g.exportToWkt()
expWkt = 'PointZ (1 2 3)'
assert compareWkt(expWkt, wkt), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt)
#also try saving out the shapefile version again, as an extra test
#this tests that saving a layer with z WITHOUT explicitly telling the writer to keep z values,
#will stay retain the z values
dest_file_name = os.path.join(str(QDir.tempPath()), 'point_{}_copy.shp'.format(QgsWKBTypes.displayString(t)))
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
created_layer,
dest_file_name,
'utf-8',
crs,
'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer_from_shp = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name), u'test', u'ogr')
f = created_layer_from_shp.getFeatures(QgsFeatureRequest()).next()
g = f.geometry()
wkt = g.exportToWkt()
assert compareWkt(expWkt, wkt), "saving geometry with Z failed: mismatch Expected:\n%s\nGot:\n%s\n" % (expWkt, wkt)
def tempFolder():
tempDir = os.path.join(unicode(QDir.tempPath()), 'qgis2web')
if not QDir(tempDir).exists():
QDir().mkpath(tempDir)
return unicode(os.path.abspath(tempDir))
def __init__(self, obsid='', settingsdict = {}):
#open connection to report file
reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports')
if not os.path.exists(reportfolder):
os.makedirs(reportfolder)
reportpath = os.path.join(reportfolder, "drill_report.html")
logopath = os.path.join(os.sep,os.path.dirname(__file__),"..","about","midvatten_logga.png")
imgpath = os.path.join(os.sep,os.path.dirname(__file__),"..","reports")
f = codecs.open(reportpath, "wb", "utf-8")
#write some initiating html, header and also
rpt = r"""<meta http-equiv="content-type" content="text/html; charset=utf-8" />"""
rpt += r"""<head><title>%s General report from Midvatten plugin for QGIS</title></head>"""%obsid
rpt += r"""<html><TABLE WIDTH=100% BORDER=0 CELLPADDING=1 CELLSPACING=1><TR VALIGN=TOP><TD WIDTH=15%><h3 style="font-family:'arial';font-size:18pt; font-weight:600">"""
rpt += obsid
if utils.getcurrentlocale() == 'sv_SE':
rpt += ''.join([r'''</h3><img src="''', os.path.join(imgpath, 'for_general_report_sv.png'), r'''" /><br><img src=''', r"""'"""])
#rpt += r"""</h3><img src="for_general_report_sv.png" /><br><img src='"""
else:
rpt += ''.join([r'''</h3><img src="''', os.path.join(imgpath, 'for_general_report.png'), r'''" /><br><img src=''', r"""'"""])
#rpt += r"""</h3><img src="for_general_report.png" /><br><img src='"""
rpt += logopath
rpt +="""' /></TD><TD WIDTH=85%><TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=3><TR VALIGN=TOP><TD WIDTH=50%><P><U><B>"""
if utils.getcurrentlocale() == 'sv_SE':
rpt += u'Allmän information'
else:
rpt += u'General information'
rpt += r"""</B></U></P><TABLE style="font-family:'arial'; font-size:10pt; font-weight:400; font-style:normal;" WIDTH=100% BORDER=0 CELLPADDING=0 CELLSPACING=1><COL WIDTH=43*><COL WIDTH=43*>"""
f.write(rpt)
# GENERAL DATA UPPER LEFT QUADRANT
ConnectionOK, GeneralData = self.GetData(obsid, 'obs_points', 'n')#MacOSX fix1
#utils.pop_up_info(str(ConnectionOK))#debug
if ConnectionOK==True:
result2 = (utils.sql_load_fr_db(r"""SELECT srid FROM geometry_columns where f_table_name = 'obs_points'""")[1])[0][0]
CRS = utils.returnunicode(result2) #1st we need crs
result3 = (utils.sql_load_fr_db(r"""SELECT ref_sys_name FROM spatial_ref_sys where srid =""" + CRS)[1])[0][0]
CRSname = utils.returnunicode(result3) # and crs name
if utils.getcurrentlocale() == 'sv_SE':
reportdata_1 = self.rpt_upper_left_sv(GeneralData, CRS, CRSname)
else:
reportdata_1 = self.rpt_upper_left(GeneralData, CRS, CRSname)
f.write(reportdata_1)
rpt = r"""</TABLE></TD><TD WIDTH=50%><P><U><B>"""
if utils.getcurrentlocale() == 'sv_SE':
rpt += u'Lagerföljd'
else:
rpt += u'Stratigraphy'
rpt += r"""</B></U></P><TABLE style="font-family:'arial'; font-size:10pt; font-weight:400; font-style:normal;" WIDTH=100% BORDER=0 CELLPADDING=0 CELLSPACING=1><COL WIDTH=43*><COL WIDTH=43*><COL WIDTH=43*><COL WIDTH=43*><COL WIDTH=43*><COL WIDTH=43*>"""
f.write(rpt)
# STRATIGRAPHY DATA UPPER RIGHT QUADRANT
StratData = self.GetData(obsid, 'stratigraphy', 'n')[1] #MacOSX fix1
if utils.getcurrentlocale() == 'sv_SE':
reportdata_2 = self.rpt_upper_right_sv(StratData)
else:
reportdata_2 = self.rpt_upper_right(StratData)
f.write(reportdata_2)
rpt = r"""</TABLE></TD></TR><TR VALIGN=TOP><TD WIDTH=50%><P><U><B>"""
if utils.getcurrentlocale() == 'sv_SE':
rpt += u'Kommentarer'
else:
rpt += u'Comments'
rpt += r"""</B></U></P>"""
f.write(rpt)
# COMMENTS LOWER LEFT QUADRANT
reportdata_3 = self.rpt_lower_left(GeneralData)
f.write(reportdata_3)
rpt = r"""</TD><TD WIDTH=50%><P><U><B>"""
if utils.getcurrentlocale() == 'sv_SE':
rpt += u'Vattennivåer'
else:
rpt += u'Water levels'
rpt += r"""</B></U></P>"""
f.write(rpt)
# WATER LEVEL STATISTICS LOWER RIGHT QUADRANT
meas_or_level_masl, statistics = GetStatistics(obsid)#MacOSX fix1
if utils.getcurrentlocale() == 'sv_SE':
reportdata_4 = self.rpt_lower_right_sv(statistics,meas_or_level_masl)
else:
reportdata_4 = self.rpt_lower_right(statistics,meas_or_level_masl)
f.write(reportdata_4)
f.write(r"""</TD></TR></TABLE></TD></TR></TABLE>""")
f.write("\n</p></body></html>")
f.close()
#print reportpath#debug
QDesktopServices.openUrl(QUrl.fromLocalFile(reportpath))
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
def tearDown(self):
report_file_path = "%s/qgistest.html" % QDir.tempPath()
with open(report_file_path, 'a') as report_file:
report_file.write(self.report)
def test_InteractiveSegmentationItemModuleMgr():
def h5equal(filename, a):
f = h5py.File(filename, 'r')
d = f['volume/data'].value.squeeze()
a = a.squeeze()
assert a.shape == d.shape
if a.dtype != d.dtype:
print a.dtype, '!=', d.dtype
assert a.dtype == d.dtype
assert numpy.array_equal(d, a)
return True
def arrayEqual(a,b):
assert a.shape == b.shape
assert a.dtype == b.dtype
if not numpy.array_equal(a,b):
assert len(a.shape) == 3
for x in range(a.shape[0]):
for y in range(a.shape[1]):
for z in range(a.shape[2]):
if a[x,y,z] != b[x,y,z]:
print x,y,z, "a=", a[x,y,z], "b=", b[x,y,z]
return False
return True
class FakeSegmentor(SegmentorBase):
segmentation = None
seeds = None
segmentationGT = []
seedsGT = []
def __init__(self):
for ver in range(3):
seeds = numpy.zeros((120,120,120,1), dtype=numpy.uint8)
if ver == 0:
seeds[0,0,0,0] = 1
elif ver == 1:
seeds[0,0,0,0] = 2
elif ver == 2:
seeds[0,0,0,0] = 3
self.seedsGT.append(seeds)
for i in range(3):
seg = numpy.ones((120,120,120,1), dtype=numpy.uint8)
if i == 0:
seg[5:10,5:10,5:10,0] = 2
elif i == 1:
seg[5:30,5:20,8:17,0] = 3
seg[50:70,50:70,40:60,0] = 5
elif i == 2:
seg[8:12,10:30,30:40,0] = 2
seg[20:30,10:30,30:40,0] = 4
seg[40:50,10:30,30:40,0] = 6
self.segmentationGT.append(seg)
def segment(self, labelVolume, labelValues, labelIndices):
print "fake segment"
assert labelVolume.shape == (120,120,120,1)
if labelVolume[0,0,0,0] == 1:
self.segmentation = self.segmentationGT[0]
elif labelVolume[0,0,0,0] == 2:
self.segmentation = self.segmentationGT[1]
elif labelVolume[0,0,0,0] == 3:
self.segmentation = self.segmentationGT[2]
# create project with some fake data
project = Project('Project Name', 'Labeler', 'Description')
filename = str(QDir.tempPath())+'/testdata.h5'
f = h5py.File(filename, 'w')
f.create_group('volume')
f.create_dataset('volume/data', data=numpy.zeros(shape=(1,120,120,120,1), dtype=numpy.uint8))
f.close; del f
project.addFile([filename])
os.remove(filename)
dataMgr = project.dataMgr
segmentor = FakeSegmentor()
dataMgr.Interactive_Segmentation.segmentor = segmentor
#initialize the module to testQDir.tempPath()+'/testdata.h5'
s = dataMgr._activeImage.module["Interactive_Segmentation"]
#create outputPath, make sure it is empty
outputPath = str(QDir.tempPath())+"/tmpseg"
print outputPath
if os.path.exists(outputPath):
shutil.rmtree(outputPath)
os.makedirs(outputPath)
s.init()
s.outputPath = outputPath
shape3D = (120,120,120)
shape4D = (120,120,120,1)
shape5D = (1,120,120,120,1)
version = 0
print "*************************************************************************"
print "* segment for the first time (version 0) *"
print "*************************************************************************"
s.seedLabelsVolume._data[:] = segmentor.seedsGT[version][:] #fake drawing some seeds
s.segment() #segment
assert arrayEqual(s.segmentation[0,:,:,:,:], segmentor.segmentation)
assert not os.path.exists(s.outputPath+'/one')
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
#save as 'one'
s.saveCurrentSegmentsAs('one')
#we now have a 'done' overlay
doneRef = s.done
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath+'/done.h5')
assert os.path.exists(s.outputPath+'/mapping.dat')
assert os.path.exists(s.outputPath+'/one/segmentation.h5')
assert os.path.exists(s.outputPath+'/one/seeds.h5')
h5equal(s.outputPath+'/one/segmentation.h5', segmentor.segmentation)
h5equal(s.outputPath+'/one/seeds.h5', segmentor.seedsGT[version])
assert numpy.where(s.seedLabelsVolume._data != 0) == ()
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
doneGT[numpy.where(segmentor.segmentation == 2)] = 1
h5equal(s.outputPath+'/done.h5', doneGT)
f = open(s.outputPath+'/mapping.dat')
assert f.readlines() == ['1|one\r\n']
f.close()
assert s._mapKeysToLabels == {'one': set([1])}
assert s._mapLabelsToKeys == {1: 'one'}
assert s.segmentKeyForLabel(1) == 'one'
assert s.segmentLabelsForKey('one') == set([1])
s.discardCurrentSegmentation()
assert s.segmentation == None
assert numpy.where(s.seedLabelsVolume._data != 0) == ()
print "*************************************************************************"
print "* remove segment 'one' *"
print "*************************************************************************"
#remove segment by key
s.removeSegmentsByKey('one')
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
assert numpy.array_equal(s.done, numpy.zeros(shape=s.done.shape, dtype=s.done.dtype))
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath+'/done.h5')
assert os.path.exists(s.outputPath+'/mapping.dat')
assert not os.path.exists(s.outputPath+'/one')
f = open(s.outputPath+'/mapping.dat')
assert f.readlines() == []
f.close()
print "*************************************************************************"
print "* segment for the second time (version 1) *"
print "*************************************************************************"
version = 1
s.seedLabelsVolume._data[:] = segmentor.seedsGT[version][:] #fake drawing some seeds
s.segment()
assert arrayEqual(s.segmentation[0,:,:,:,:], segmentor.segmentation)
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
s.saveCurrentSegmentsAs('two')
assert os.path.exists(s.outputPath+'/two/segmentation.h5')
assert os.path.exists(s.outputPath+'/two/seeds.h5')
relabeledGT = segmentor.segmentation.copy()
relabeledGT[numpy.where(relabeledGT == 1)] = 0
relabeledGT[numpy.where(relabeledGT == 3)] = 1
relabeledGT[numpy.where(relabeledGT == 5)] = 2
assert arrayEqual(s.done.squeeze(), relabeledGT.squeeze().astype(numpy.uint32))
assert s._mapKeysToLabels == {'two': set([1, 2])}
assert s._mapLabelsToKeys == {1: 'two', 2: 'two'}
print "*************************************************************************"
print "* segment again (version 2) *"
print "*************************************************************************"
version = 2
s.seedLabelsVolume._data[:] = segmentor.seedsGT[version][:] #fake drawing some seeds
s.segment()
assert arrayEqual(s.segmentation[0,:,:,:,:], segmentor.segmentationGT[version])
s.saveCurrentSegmentsAs('three')
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath+'/done.h5')
assert os.path.exists(s.outputPath+'/mapping.dat')
assert os.path.exists(s.outputPath+'/two/segmentation.h5')
assert os.path.exists(s.outputPath+'/two/seeds.h5')
assert os.path.exists(s.outputPath+'/three/segmentation.h5')
assert os.path.exists(s.outputPath+'/three/seeds.h5')
assert s._mapKeysToLabels == {'two': set([1, 2]), 'three': set([3, 4, 5])}
assert s._mapLabelsToKeys == {1: 'two', 2: 'two', 3: 'three', 4: 'three', 5: 'three'}
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
doneGT[numpy.where(segmentor.segmentationGT[1] == 3)] = 1
doneGT[numpy.where(segmentor.segmentationGT[1] == 5)] = 2
doneGT[numpy.where(segmentor.segmentationGT[2] == 2)] = 3
doneGT[numpy.where(segmentor.segmentationGT[2] == 4)] = 4
doneGT[numpy.where(segmentor.segmentationGT[2] == 6)] = 5
assert arrayEqual(doneGT.squeeze(), s.done.squeeze())
assert h5equal(s.outputPath+'/two/segmentation.h5', segmentor.segmentationGT[1])
assert h5equal(s.outputPath+'/three/segmentation.h5', segmentor.segmentationGT[2])
print "*************************************************************************"
print "* remove segments 'three' *"
print "*************************************************************************"
s.removeSegmentsByKey('three')
assert s._mapKeysToLabels == {'two': set([1, 2])}
assert s._mapLabelsToKeys == {1: 'two', 2: 'two'}
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath+'/done.h5')
assert os.path.exists(s.outputPath+'/mapping.dat')
assert os.path.exists(s.outputPath+'/two/segmentation.h5')
assert os.path.exists(s.outputPath+'/two/seeds.h5')
assert not os.path.exists(s.outputPath+'/three')
f = open(s.outputPath+'/mapping.dat')
assert f.readlines() == ['1|two\r\n', '2|two\r\n']
f.close()
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
doneGT[numpy.where(segmentor.segmentationGT[1] == 3)] = 1
doneGT[numpy.where(segmentor.segmentationGT[1] == 5)] = 2
assert arrayEqual(doneGT.squeeze(), s.done.squeeze())
assert h5equal(s.outputPath+'/done.h5', doneGT)
print "*************************************************************************"
print "* edit segments 'two' *"
print "*************************************************************************"
s.editSegmentsByKey('two')
print "check...."
assert arrayEqual(s.seedLabelsVolume._data[0,:,:,:,:], segmentor.seedsGT[1])
#assert arrayEqual(s.segmentation[0,:,:,:,:].squeeze(), segmentor.segmentation.squeeze())
s.saveCurrentSegment()
print "*************************************************************************"
print "* remove segments 'two' *"
print "*************************************************************************"
s.removeSegmentsByKey('two')
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath+'/done.h5')
assert os.path.exists(s.outputPath+'/mapping.dat')
assert not os.path.exists(s.outputPath+'/two')
assert not os.path.exists(s.outputPath+'/three')
f = open(s.outputPath+'/mapping.dat')
assert f.readlines() == []
f.close()
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
assert arrayEqual(doneGT.squeeze(), s.done.squeeze())
assert h5equal(s.outputPath+'/done.h5', doneGT)
#make sure that we have not overwritten the done overlay, which
#would cause the connection with the 'Segmentation/Done' overlay
#to break
assert doneRef is s.done
jobMachine.GLOBAL_WM.stopWorkers()
def __init__(self, obsids, settingsdict, general_metadata, geo_metadata,
strat_columns, header_in_table, skip_empty, include_comments,
general_metadata_header, geo_metadata_header,
strat_columns_header, comment_header,
empty_row_between_obsids, topleft_topright_colwidths,
general_colwidth, geo_colwidth, decimal_separator):
reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports')
if not os.path.exists(reportfolder):
os.makedirs(reportfolder)
reportpath = os.path.join(reportfolder, "drill_report.html")
logopath = os.path.join(os.sep, os.path.dirname(__file__), "..",
"templates", "midvatten_logga.png")
imgpath = os.path.join(os.sep, os.path.dirname(__file__), "..",
"templates")
if len(obsids) == 0:
utils.pop_up_info(
ru(
QCoreApplication.translate(
u'Drillreport', u"Must select one or more obsids!")))
return None
obs_points_translations = {
'obsid':
ru(QCoreApplication.translate('Drillreport2', 'obsid')),
'name':
ru(QCoreApplication.translate('Drillreport2', 'name')),
'place':
ru(QCoreApplication.translate('Drillreport2', 'place')),
'type':
ru(QCoreApplication.translate('Drillreport2', 'type')),
'length':
ru(QCoreApplication.translate('Drillreport2', 'length')),
'drillstop':
ru(QCoreApplication.translate('Drillreport2', 'drillstop')),
'diam':
ru(QCoreApplication.translate('Drillreport2', 'diam')),
'material':
ru(QCoreApplication.translate('Drillreport2', 'material')),
'screen':
ru(QCoreApplication.translate('Drillreport2', 'screen')),
'capacity':
ru(QCoreApplication.translate('Drillreport2', 'capacity')),
'drilldate':
ru(QCoreApplication.translate('Drillreport2', 'drilldate')),
'wmeas_yn':
ru(QCoreApplication.translate('Drillreport2', 'wmeas_yn')),
'wlogg_yn':
ru(QCoreApplication.translate('Drillreport2', 'wlogg_yn')),
'east':
ru(QCoreApplication.translate('Drillreport2', 'east')),
'north':
ru(QCoreApplication.translate('Drillreport2', 'north')),
'ne_accur':
ru(QCoreApplication.translate('Drillreport2', 'ne_accur')),
'ne_source':
ru(QCoreApplication.translate('Drillreport2', 'ne_source')),
'h_toc':
ru(QCoreApplication.translate('Drillreport2', 'h_toc')),
'h_tocags':
ru(QCoreApplication.translate('Drillreport2', 'h_tocags')),
'h_gs':
ru(QCoreApplication.translate('Drillreport2', 'h_gs')),
'h_accur':
ru(QCoreApplication.translate('Drillreport2', 'h_accur')),
'h_syst':
ru(QCoreApplication.translate('Drillreport2', 'h_syst')),
'h_source':
ru(QCoreApplication.translate('Drillreport2', 'h_source')),
'source':
ru(QCoreApplication.translate('Drillreport2', 'source')),
'com_onerow':
ru(QCoreApplication.translate('Drillreport2', 'com_onerow')),
'com_html':
ru(QCoreApplication.translate('Drillreport2', 'com_html'))
}
"""
thelist = [ "obsid", "stratid", "depthtop", "depthbot", "geology", "geoshort", "capacity", "development", "comment"]
>>> y = '\n'.join(["'%s'"%x + ': ' + "ru(QCoreApplication.translate('Drillreport2', '%s')),"%x for x in thelist])
>>> print(y)
"""
dbconnection = db_utils.DbConnectionManager()
obs_points_cols = [
"obsid", "name", "place", "type", "length", "drillstop", "diam",
"material", "screen", "capacity", "drilldate", "wmeas_yn",
"wlogg_yn", "east", "north", "ne_accur", "ne_source", "h_toc",
"h_tocags", "h_gs", "h_accur", "h_syst", "h_source", "source",
"com_onerow", "com_html"
]
all_obs_points_data = ru(db_utils.get_sql_result_as_dict(
u'SELECT %s FROM obs_points WHERE obsid IN (%s) ORDER BY obsid' %
(u', '.join(obs_points_cols), u', '.join(
[u"'{}'".format(x) for x in obsids])),
dbconnection=dbconnection)[1],
keep_containers=True)
if strat_columns:
strat_sql_columns_list = [x.split(u';')[0] for x in strat_columns]
if u'depth' in strat_sql_columns_list:
strat_sql_columns_list.extend([u'depthtop', u'depthbot'])
strat_sql_columns_list.remove(u'depth')
strat_sql_columns_list = [
x for x in strat_sql_columns_list if x not in (u'obsid')
]
all_stratigrapy_data = ru(db_utils.get_sql_result_as_dict(
u'SELECT obsid, %s FROM stratigraphy WHERE obsid IN (%s) ORDER BY obsid, stratid'
% (u', '.join(strat_sql_columns_list), u', '.join(
[u"'{}'".format(x) for x in obsids])),
dbconnection=dbconnection)[1],
keep_containers=True)
else:
all_stratigrapy_data = {}
strat_sql_columns_list = []
crs = ru(
db_utils.sql_load_fr_db(
u"""SELECT srid FROM geometry_columns where f_table_name = 'obs_points'""",
dbconnection=dbconnection)[1][0][0])
crsname = ru(db_utils.get_srid_name(crs, dbconnection=dbconnection))
dbconnection.closedb()
f, rpt = self.open_file(', '.join(obsids), reportpath)
rpt += ur"""<html>"""
for obsid in obsids:
obs_points_data = all_obs_points_data[obsid][0]
general_data_no_rounding = [
x.split(u';')[0] for x in general_metadata
]
general_rounding = [
x.split(u';')[1] if len(x.split(u';')) == 2 else None
for x in general_metadata
]
general_data = [
(obs_points_translations.get(header, header),
obs_points_data[obs_points_cols.index(header) - 1])
for header in general_data_no_rounding
]
if geo_metadata:
geo_metadata_no_rounding = [
x.split(u';')[0] for x in geo_metadata
]
geo_rounding = [
x.split(u';')[1] if len(x.split(u';')) == 2 else None
for x in geo_metadata
]
geo_data = [
(obs_points_translations.get(header, header),
obs_points_data[obs_points_cols.index(header) - 1])
for header in geo_metadata_no_rounding
]
if u'east' in geo_metadata_no_rounding or u'north' in geo_metadata_no_rounding:
geo_data.append(
(ru(
QCoreApplication.translate(
'Drillreport2', u'XY Reference system')),
'%s' % ('%s, ' % crsname if crsname else '') +
'EPSG:' + crs))
else:
geo_data = []
geo_rounding = []
strat_data = all_stratigrapy_data.get(obsid, None)
if include_comments:
comment_data = [
obs_points_data[obs_points_cols.index(header) - 1]
for header in (u'com_onerow', u'com_html') if all([
obs_points_data[obs_points_cols.index(header) -
1].strip(),
u'text-indent:0px;"><br /></p>' not in obs_points_data[
obs_points_cols.index(header) -
1], u'text-indent:0px;"></p>' not in
obs_points_data[obs_points_cols.index(header) -
1], u'text-indent:0px;">NULL</p>'
not in obs_points_data[obs_points_cols.index(header) -
1].strip()
])
]
else:
comment_data = []
rpt += self.write_obsid(
obsid,
general_data,
geo_data,
strat_data,
comment_data,
strat_columns,
header_in_table=header_in_table,
skip_empty=skip_empty,
general_metadata_header=general_metadata_header,
geo_metadata_header=geo_metadata_header,
strat_columns_header=strat_columns_header,
comment_header=comment_header,
general_rounding=general_rounding,
geo_rounding=geo_rounding,
strat_sql_columns_list=strat_sql_columns_list,
topleft_topright_colwidths=topleft_topright_colwidths,
general_colwidth=general_colwidth,
geo_colwidth=geo_colwidth,
decimal_separator=decimal_separator)
rpt += ur"""<p> </p>"""
if empty_row_between_obsids:
rpt += ur"""<p>empty_row_between_obsids</p>"""
rpt += ur"""</html>"""
f.write(rpt)
self.close_file(f, reportpath)
def test_InteractiveSegmentationItemModuleMgr():
def h5equal(filename, a):
f = h5py.File(filename, 'r')
d = f['volume/data'].value.squeeze()
a = a.squeeze()
assert a.shape == d.shape
if a.dtype != d.dtype:
print a.dtype, '!=', d.dtype
assert a.dtype == d.dtype
assert numpy.array_equal(d, a)
return True
def arrayEqual(a, b):
assert a.shape == b.shape
assert a.dtype == b.dtype
if not numpy.array_equal(a, b):
assert len(a.shape) == 3
for x in range(a.shape[0]):
for y in range(a.shape[1]):
for z in range(a.shape[2]):
if a[x, y, z] != b[x, y, z]:
print x, y, z, "a=", a[x, y, z], "b=", b[x, y, z]
return False
return True
class FakeSegmentor(SegmentorBase):
segmentation = None
seeds = None
segmentationGT = []
seedsGT = []
def __init__(self):
for ver in range(3):
seeds = numpy.zeros((120, 120, 120, 1), dtype=numpy.uint8)
if ver == 0:
seeds[0, 0, 0, 0] = 1
elif ver == 1:
seeds[0, 0, 0, 0] = 2
elif ver == 2:
seeds[0, 0, 0, 0] = 3
self.seedsGT.append(seeds)
for i in range(3):
seg = numpy.ones((120, 120, 120, 1), dtype=numpy.uint8)
if i == 0:
seg[5:10, 5:10, 5:10, 0] = 2
elif i == 1:
seg[5:30, 5:20, 8:17, 0] = 3
seg[50:70, 50:70, 40:60, 0] = 5
elif i == 2:
seg[8:12, 10:30, 30:40, 0] = 2
seg[20:30, 10:30, 30:40, 0] = 4
seg[40:50, 10:30, 30:40, 0] = 6
self.segmentationGT.append(seg)
def segment(self, labelVolume, labelValues, labelIndices):
print "fake segment"
assert labelVolume.shape == (120, 120, 120, 1)
if labelVolume[0, 0, 0, 0] == 1:
self.segmentation = self.segmentationGT[0]
elif labelVolume[0, 0, 0, 0] == 2:
self.segmentation = self.segmentationGT[1]
elif labelVolume[0, 0, 0, 0] == 3:
self.segmentation = self.segmentationGT[2]
# create project with some fake data
project = Project('Project Name', 'Labeler', 'Description')
filename = str(QDir.tempPath()) + '/testdata.h5'
f = h5py.File(filename, 'w')
f.create_group('volume')
f.create_dataset('volume/data',
data=numpy.zeros(shape=(1, 120, 120, 120, 1),
dtype=numpy.uint8))
f.close
del f
project.addFile([filename])
os.remove(filename)
dataMgr = project.dataMgr
segmentor = FakeSegmentor()
dataMgr.Interactive_Segmentation.segmentor = segmentor
#initialize the module to testQDir.tempPath()+'/testdata.h5'
s = dataMgr._activeImage.module["Interactive_Segmentation"]
#create outputPath, make sure it is empty
outputPath = str(QDir.tempPath()) + "/tmpseg"
print outputPath
if os.path.exists(outputPath):
shutil.rmtree(outputPath)
os.makedirs(outputPath)
s.init()
s.outputPath = outputPath
shape3D = (120, 120, 120)
shape4D = (120, 120, 120, 1)
shape5D = (1, 120, 120, 120, 1)
version = 0
print "*************************************************************************"
print "* segment for the first time (version 0) *"
print "*************************************************************************"
s.seedLabelsVolume._data[:] = segmentor.seedsGT[
version][:] #fake drawing some seeds
s.segment() #segment
assert arrayEqual(s.segmentation[0, :, :, :, :], segmentor.segmentation)
assert not os.path.exists(s.outputPath + '/one')
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
#save as 'one'
s.saveCurrentSegmentsAs('one')
#we now have a 'done' overlay
doneRef = s.done
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath + '/done.h5')
assert os.path.exists(s.outputPath + '/mapping.dat')
assert os.path.exists(s.outputPath + '/one/segmentation.h5')
assert os.path.exists(s.outputPath + '/one/seeds.h5')
h5equal(s.outputPath + '/one/segmentation.h5', segmentor.segmentation)
h5equal(s.outputPath + '/one/seeds.h5', segmentor.seedsGT[version])
assert numpy.where(s.seedLabelsVolume._data != 0) == ()
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
doneGT[numpy.where(segmentor.segmentation == 2)] = 1
h5equal(s.outputPath + '/done.h5', doneGT)
f = open(s.outputPath + '/mapping.dat')
assert f.readlines() == ['1|one\r\n']
f.close()
assert s._mapKeysToLabels == {'one': set([1])}
assert s._mapLabelsToKeys == {1: 'one'}
assert s.segmentKeyForLabel(1) == 'one'
assert s.segmentLabelsForKey('one') == set([1])
s.discardCurrentSegmentation()
assert s.segmentation == None
assert numpy.where(s.seedLabelsVolume._data != 0) == ()
print "*************************************************************************"
print "* remove segment 'one' *"
print "*************************************************************************"
#remove segment by key
s.removeSegmentsByKey('one')
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
assert numpy.array_equal(
s.done, numpy.zeros(shape=s.done.shape, dtype=s.done.dtype))
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath + '/done.h5')
assert os.path.exists(s.outputPath + '/mapping.dat')
assert not os.path.exists(s.outputPath + '/one')
f = open(s.outputPath + '/mapping.dat')
assert f.readlines() == []
f.close()
print "*************************************************************************"
print "* segment for the second time (version 1) *"
print "*************************************************************************"
version = 1
s.seedLabelsVolume._data[:] = segmentor.seedsGT[
version][:] #fake drawing some seeds
s.segment()
assert arrayEqual(s.segmentation[0, :, :, :, :], segmentor.segmentation)
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
s.saveCurrentSegmentsAs('two')
assert os.path.exists(s.outputPath + '/two/segmentation.h5')
assert os.path.exists(s.outputPath + '/two/seeds.h5')
relabeledGT = segmentor.segmentation.copy()
relabeledGT[numpy.where(relabeledGT == 1)] = 0
relabeledGT[numpy.where(relabeledGT == 3)] = 1
relabeledGT[numpy.where(relabeledGT == 5)] = 2
assert arrayEqual(s.done.squeeze(),
relabeledGT.squeeze().astype(numpy.uint32))
assert s._mapKeysToLabels == {'two': set([1, 2])}
assert s._mapLabelsToKeys == {1: 'two', 2: 'two'}
print "*************************************************************************"
print "* segment again (version 2) *"
print "*************************************************************************"
version = 2
s.seedLabelsVolume._data[:] = segmentor.seedsGT[
version][:] #fake drawing some seeds
s.segment()
assert arrayEqual(s.segmentation[0, :, :, :, :],
segmentor.segmentationGT[version])
s.saveCurrentSegmentsAs('three')
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath + '/done.h5')
assert os.path.exists(s.outputPath + '/mapping.dat')
assert os.path.exists(s.outputPath + '/two/segmentation.h5')
assert os.path.exists(s.outputPath + '/two/seeds.h5')
assert os.path.exists(s.outputPath + '/three/segmentation.h5')
assert os.path.exists(s.outputPath + '/three/seeds.h5')
assert s._mapKeysToLabels == {'two': set([1, 2]), 'three': set([3, 4, 5])}
assert s._mapLabelsToKeys == {
1: 'two',
2: 'two',
3: 'three',
4: 'three',
5: 'three'
}
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
doneGT[numpy.where(segmentor.segmentationGT[1] == 3)] = 1
doneGT[numpy.where(segmentor.segmentationGT[1] == 5)] = 2
doneGT[numpy.where(segmentor.segmentationGT[2] == 2)] = 3
doneGT[numpy.where(segmentor.segmentationGT[2] == 4)] = 4
doneGT[numpy.where(segmentor.segmentationGT[2] == 6)] = 5
assert arrayEqual(doneGT.squeeze(), s.done.squeeze())
assert h5equal(s.outputPath + '/two/segmentation.h5',
segmentor.segmentationGT[1])
assert h5equal(s.outputPath + '/three/segmentation.h5',
segmentor.segmentationGT[2])
print "*************************************************************************"
print "* remove segments 'three' *"
print "*************************************************************************"
s.removeSegmentsByKey('three')
assert s._mapKeysToLabels == {'two': set([1, 2])}
assert s._mapLabelsToKeys == {1: 'two', 2: 'two'}
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath + '/done.h5')
assert os.path.exists(s.outputPath + '/mapping.dat')
assert os.path.exists(s.outputPath + '/two/segmentation.h5')
assert os.path.exists(s.outputPath + '/two/seeds.h5')
assert not os.path.exists(s.outputPath + '/three')
f = open(s.outputPath + '/mapping.dat')
assert f.readlines() == ['1|two\r\n', '2|two\r\n']
f.close()
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
doneGT[numpy.where(segmentor.segmentationGT[1] == 3)] = 1
doneGT[numpy.where(segmentor.segmentationGT[1] == 5)] = 2
assert arrayEqual(doneGT.squeeze(), s.done.squeeze())
assert h5equal(s.outputPath + '/done.h5', doneGT)
print "*************************************************************************"
print "* edit segments 'two' *"
print "*************************************************************************"
s.editSegmentsByKey('two')
print "check...."
assert arrayEqual(s.seedLabelsVolume._data[0, :, :, :, :],
segmentor.seedsGT[1])
#assert arrayEqual(s.segmentation[0,:,:,:,:].squeeze(), segmentor.segmentation.squeeze())
s.saveCurrentSegment()
print "*************************************************************************"
print "* remove segments 'two' *"
print "*************************************************************************"
s.removeSegmentsByKey('two')
assert s._mapKeysToLabels == {}
assert s._mapLabelsToKeys == {}
assert os.path.exists(s.outputPath)
assert os.path.exists(s.outputPath + '/done.h5')
assert os.path.exists(s.outputPath + '/mapping.dat')
assert not os.path.exists(s.outputPath + '/two')
assert not os.path.exists(s.outputPath + '/three')
f = open(s.outputPath + '/mapping.dat')
assert f.readlines() == []
f.close()
doneGT = numpy.zeros(shape=shape4D, dtype=numpy.uint32)
assert arrayEqual(doneGT.squeeze(), s.done.squeeze())
assert h5equal(s.outputPath + '/done.h5', doneGT)
#make sure that we have not overwritten the done overlay, which
#would cause the connection with the 'Segmentation/Done' overlay
#to break
assert doneRef is s.done
jobMachine.GLOBAL_WM.stopWorkers()
def temporaryOutputDir():
return QDir.tempPath() + "/PhyloGeoRec"
def temporaryOutputDir(): return QDir.tempPath() + "/Qgis2threejs"
def __init__(self, layer, settingsdict={}):
#show the user this may take a long time...
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.settingsdict = settingsdict
provider = layer.dataProvider() # OGR provider
kolumnindex = provider.fieldNameIndex(
'obsid') # To find the column named 'obsid'
observations = layer.selectedFeatures()
reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports')
if not os.path.exists(reportfolder):
os.makedirs(reportfolder)
reportpath = os.path.join(reportfolder, "w_qual_report.html")
#f = open(reportpath, "wb" )
f = codecs.open(reportpath, "wb", "utf-8")
#write some initiating html
rpt = r"""<head><title>%s</title></head>""" % ru(
QCoreApplication.translate(
u'Wqualreport',
u'water quality report from Midvatten plugin for QGIS'))
rpt += r""" <meta http-equiv="content-type" content="text/html; charset=utf-8" />""" #NOTE, all report data must be in 'utf-8'
rpt += "<html><body>"
#rpt += "<table width=\"100%\" border=\"1\">\n"
#rpt2 = rpt.encode("utf-8")
f.write(rpt)
dbconnection = db_utils.DbConnectionManager()
for i, object in enumerate(observations):
attributes = observations[i]
obsid = attributes[kolumnindex]
try:
print('about to get data for ' + obsid + ', at time: ' +
str(time.time())) #debug
except:
pass
ReportData = self.GetData(
self.settingsdict['database'], obsid,
dbconnection) # one observation at a time
try:
print('done with getting data for ' + obsid + ', at time: ' +
str(time.time())) #debug
except:
pass
if ReportData:
self.WriteHTMLReport(ReportData, f)
try:
print('wrote html report for ' + obsid + ', at time: ' +
str(time.time())) #debug
except:
pass
dbconnection.closedb()
#write some finishing html and close the file
f.write("\n</body></html>")
f.close()
QApplication.restoreOverrideCursor(
) #now this long process is done and the cursor is back as normal
if ReportData:
QDesktopServices.openUrl(QUrl.fromLocalFile(reportpath))
def tempFolder():
tempDir = os.path.join(unicode(QDir.tempPath()), 'qgis2web')
if not QDir(tempDir).exists():
QDir().mkpath(tempDir)
return unicode(os.path.abspath(tempDir))
