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))