Example #1
0
def start_app(gui_flag=False):
    """
    Will start a QgsApplication and call all initialization code like
    registering the providers and other infrastructure. It will not load
    any plugins.
    You can always get the reference to a running app by calling `QgsApplication.instance()`.
    The initialization will only happen once, so it is safe to call this method repeatedly.
        Returns
        -------
        QgsApplication
        A QgsApplication singleton
    """
    global QGISAPP
    QCoreApplication.setOrganizationName('QGIS')
    QCoreApplication.setApplicationName('QGIS2')
    QgsApplication.setPrefixPath("/usr/share/", True)

    # Note: QGIS_PREFIX_PATH is evaluated in QgsApplication -
    # no need to mess with it here.
    QGISAPP = QgsApplication(sys.argv, gui_flag)
    QGISAPP.initQgis()

    if len(QgsProviderRegistry.instance().providerList()) == 0:
        raise RuntimeError('No data providers available.')

    return QGISAPP
Example #2
0
    def testImportCSVFile(self):
        QgsApplication.setPrefixPath("/usr/share/qgis", True)
        qgs = QgsApplication([], False)
        # load providers
        qgs.initQgis()

        # shapefile
        aroundtheblockPath = os.path.join(
            os.path.abspath("../../sampledata/aroundtheblock/"),
            "aroundtheblock.csv")
        logger = mockLogger()
        messageBar = MockMessageBar(logger)
        messageBox = MockMessageBox
        layer = loadCSVLayer(dateFormat='mm/dd/yyyy',
                             gpsPath=aroundtheblockPath,
                             logger=logger,
                             mainWindow=None,
                             messageBar=messageBar,
                             messageBox=messageBox)

        self.assertIsNotNone(layer)
        self.assertIsInstance(layer, QgsVectorLayer)
        self.assertTrue(layer.isValid())

        featuresCount = sum(1 for _ in layer.getFeatures())
        self.assertEqual(featuresCount, 587)
Example #3
0
def set_up_interface():
    """
    Sets up a QGIS pseudo-application which enables calling methods as if when calling them from QGIS-console.

    :return qgis_app: Pseudo QGIS-instance
    :rtype: QgsApplication
    :return canvas: The map canvas
    :rtype: QgsMapCanvas
    :return iface: A dummy interface, giving access to needed method-calls
    :rtype: QgisInterface
    """
    gui_flag = True  # All test will run qgis in gui mode
    qgis_app = QgsApplication(sys.argv, gui_flag)
    prefix_path = config.qgis_prefix_path()
    qgis_app.setPrefixPath(prefix_path, True)
    qgis_app.initQgis()
    QCoreApplication.setOrganizationName('QGIS')
    QCoreApplication.setApplicationName('QGIS2')

    # parent = QWidget()
    # canvas = QgsMapCanvas(parent)
    # canvas.resize(QSize(400, 400))
    canvas = MyMapCanvas()

    iface = QgisInterface(canvas)

    return qgis_app, canvas, iface
def globalQgis():
    """Singleton implementation for a global QGIS app instance.

    Args:
        None
    Returns:
        A QGIS Application instance
    Raises:
        None
    """

    global QGISAPP

    if QGISAPP is None:
        myGuiFlag = True  # All test will run qgis in gui mode
        QGISAPP = QgsApplication(sys.argv, myGuiFlag)
        if 'QGISPATH' in os.environ:
            myPath = os.environ['QGISPATH']
            myUseDefaultPathFlag = True
            QGISAPP.setPrefixPath(myPath, myUseDefaultPathFlag)

        QGISAPP.initQgis()
        s = QGISAPP.showSettings()
        print s
    return QGISAPP
Example #5
0
    def testImportCSVFile(self):
        QgsApplication.setPrefixPath("/usr/share/qgis", True)
        qgs = QgsApplication([], False)
        # load providers
        qgs.initQgis()

        # shapefile
        aroundtheblockPath = os.path.join(os.path.abspath("../../sampledata/aroundtheblock/"), "aroundtheblock.csv")
        logger = mockLogger()
        messageBar = MockMessageBar(logger)
        messageBox = MockMessageBox
        layer = loadCSVLayer(
            dateFormat='mm/dd/yyyy',
            gpsPath=aroundtheblockPath,
            logger=logger,
            mainWindow=None,
            messageBar=messageBar,
            messageBox=messageBox
        )

        self.assertIsNotNone(layer)
        self.assertIsInstance(layer, QgsVectorLayer)
        self.assertTrue(layer.isValid())

        featuresCount = sum(1 for _ in layer.getFeatures())
        self.assertEqual(featuresCount, 587)
Example #6
0
def init_qgis(verbose=False):
    """ Initialize qgis application
    """
    from qgis.core import Qgis, QgsApplication
    global qgis_application

    qgisPrefixPath = os.environ.get('QGIS_PREFIX_PATH', '/usr/')
    sys.path.append(os.path.join(qgisPrefixPath, "share/qgis/python/plugins/"))

    # Set offscreen mode when no display
    # This will prevent Qt tryning to connect to display
    if os.environ.get('DISPLAY') is None:
        os.environ['QT_QPA_PLATFORM'] = 'offscreen'

    qgis_application = QgsApplication([], False)
    qgis_application.setPrefixPath(qgisPrefixPath, True)
    qgis_application.initQgis()

    os.environ['QGIS_PREFIX_PATH'] = qgisPrefixPath

    # Auto cleanup
    @atexit.register
    def extQgis():
        global qgis_application
        if qgis_application:
            qgis_application.exitQgis()
            del qgis_application

    if verbose:
        print(qgis_application.showSettings(), file=sys.stderr)

    # Install logging hook
    install_message_hook(verbose)
Example #7
0
def main(argv):

    # create Qt application
    app = QtGui.QApplication(argv, True)

    # Set the app style
    mySplashPix = QtGui.QPixmap(QtCore.QString(DATA_DIR + '/OCEAN.png'))
    mySplashPixScaled = mySplashPix.scaled(500, 300, Qt.Qt.KeepAspectRatio)
    mySplash = QtGui.QSplashScreen(mySplashPixScaled)
    mySplash.show()

    # initialize qgis libraries
    QgsApplication.setPrefixPath(QGIS_PREFIX, True)
    QgsApplication.initQgis()

    # create main window
    wnd = MainWindow(mySplash)
    wnd.show()

    # Create signal for app finish
    app.connect(
        app, QtCore.SIGNAL('lastWindowClosed()'), app, QtCore.SLOT('quit()'))

    # Start the app up
    retval = app.exec_()

    # We got an exit signal so time to clean up
    QgsApplication.exitQgis()

    sys.exit(retval)
Example #8
0
    def init(self, logo, title):
        from qgis.core import QgsApplication
        from PyQt4.QtGui import QApplication, QFont, QIcon
        from PyQt4.QtCore import QLocale, QTranslator
        try:
            import PyQt4.QtSql
        except ImportError:
            pass

        self.app = QgsApplication(self.sysargv, True)
        import roam.roam_style
        self.app.setStyleSheet(roam.roam_style.appstyle)
        QgsApplication.setPrefixPath(self.prefixpath, True)
        QgsApplication.initQgis()

        locale = QLocale.system().name()
        self.translationFile = os.path.join(self.i18npath, '{0}.qm'.format(locale))
        translator = QTranslator()
        translator.load(self.translationFile, "i18n")
        self.app.installTranslator(translator)

        QApplication.setStyle("Plastique")
        QApplication.setFont(QFont('Segoe UI'))
        QApplication.setWindowIcon(QIcon(logo))
        QApplication.setApplicationName(title)

        import roam.editorwidgets.core
        roam.editorwidgets.core.registerallwidgets()
        return self
Example #9
0
def init_qgis(verbose=False):
    """ Initialize qgis application
    """
    from qgis.core import Qgis, QgsApplication
    global qgis_application 

    qgisPrefixPath = os.environ.get('QGIS_PREFIX_PATH','/usr/')
    sys.path.append(os.path.join(qgisPrefixPath, "share/qgis/python/plugins/"))

    # Set offscreen mode when no display 
    # This will prevent Qt tryning to connect to display
    if os.environ.get('DISPLAY') is None:
        os.environ['QT_QPA_PLATFORM'] = 'offscreen'

    qgis_application = QgsApplication([], False )
    qgis_application.setPrefixPath(qgisPrefixPath, True)
    qgis_application.initQgis()

    os.environ['QGIS_PREFIX_PATH'] = qgisPrefixPath

    # Auto cleanup
    @atexit.register
    def extQgis():
        global qgis_application
        if qgis_application:
            qgis_application.exitQgis()
            del qgis_application

    if verbose:
         print(qgis_application.showSettings(),file=sys.stderr)
    
    # Install logging hook
    install_message_hook( verbose )
 def setUpClass(cls):
     # to see how to setup a qgis app in pyqgis
     # https://hub.qgis.org/issues/13494#note-19
     os.environ["QGIS_DEBUG"] = str(-1)
     QCoreApplication.setOrganizationName('QGIS')
     QCoreApplication.setApplicationName('QGIS2')
     QgsApplication.setPrefixPath(os.getenv("QGIS_PREFIX_PATH"), True)
     QgsApplication.setAuthDbDirPath('/home/richard/.qgis2/')
def main(args=None):

    # supply path to qgis install location
    QgsApplication.setPrefixPath("/usr", True)

    # create a reference to the QgsApplication
    # setting the second argument to True enables the IquaView GUI,
    # which we need to do since this is a custom application
    qgs = QgsApplication([], True)

    # init splash screen
    splash_pix = QPixmap(':/resources/iquaview.png')
    splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
    splash.setMask(splash_pix.mask())

    light_blue = QColor(165, 197, 192)
    dark_blue = QColor(11, 52, 70)
    # adding progress bar
    progress_bar = QProgressBar(splash)
    p = progress_bar.palette()
    p.setColor(QPalette.Highlight, light_blue)
    p.setColor(QPalette.HighlightedText, dark_blue)
    progress_bar.setPalette(p)
    progress_bar.setMaximum(10)
    progress_bar.setGeometry(0,
                             splash_pix.height() - 50, splash_pix.width(), 20)

    splash.show()
    splash.showMessage("Initializing interface...",
                       Qt.AlignBottom | Qt.AlignCenter, light_blue)

    # progress bar...
    for i in range(1, 11):
        progress_bar.setValue(i)
        t = time()
        if i == 5:
            splash.showMessage("Loading providers...",
                               Qt.AlignBottom | Qt.AlignCenter, light_blue)
            # load providers
            qgs.initQgis()
            LOGGER.info(qgs.showSettings())
        if i == 10:
            # exec iquaview window
            window = MainWindow()
            window.setWindowIcon(QIcon(":/resources/iquaview_vector.svg"))
            splash.showMessage("IQUAview ready!",
                               Qt.AlignBottom | Qt.AlignCenter, light_blue)

        while time() < t + 0.1:
            qgs.processEvents()

    window.showMaximized()
    splash.finish(window)

    qgs.exec_()
    window.deleteLater()
    # when app terminates, call exitQgis() to remove the provider and layer registries from memory
    qgs.exitQgis()
Example #12
0
def qgis_init():
    # Initialize QGIS Application
    qgs = QgsApplication([], False)
    QgsApplication.setPrefixPath("/home/gnodj/anaconda3/envs/38/bin/qgis",
                                 True)
    QgsApplication.initQgis()
    for alg in QgsApplication.processingRegistry().algorithms():
        print(alg.id(), "->", alg.displayName())
    return (qgs)
Example #13
0
def setup_qgis(project_filename: str) -> QgsApplication:
    # app = QApplication([])
    QgsApplication.setPrefixPath("/usr", True)
    QgsApplication.initQgis()
    qgs = QgsApplication([], False)

    find_processing_lib()

    QgsProject.instance().read(project_filename)
    return qgs
Example #14
0
def get_qgis_app():
    """ Start one QGIS application to test against.

    :returns: Handle to QGIS app, canvas, iface and parent. If there are any
        errors the tuple members will be returned as None.
    :rtype: (QgsApplication, CANVAS, IFACE, PARENT)

    If QGIS is already running the handle to that app will be returned.
    """
    global QGIS_APP, PARENT, IFACE, CANVAS  # pylint: disable=W0603

    if iface:
        from qgis.core import QgsApplication
        QGIS_APP = QgsApplication
        CANVAS = iface.mapCanvas()
        PARENT = iface.mainWindow()
        IFACE = iface
        return QGIS_APP, CANVAS, IFACE, PARENT

    try:
        from qgis.PyQt import QtGui, QtCore, QtWidgets
        from qgis.core import QgsApplication
        from qgis.gui import QgsMapCanvas

    except ImportError:
        return None, None, None, None

    if QGIS_APP is None:
        gui_flag = True  # All test will run qgis in gui mode
        # noinspection PyPep8Naming
        QgsApplication.setPrefixPath('/usr', True)

        QGIS_APP = QgsApplication([], gui_flag)

        # Make sure QGIS_PREFIX_PATH is set in your env if needed!
        QGIS_APP.initQgis()
        s = QGIS_APP.showSettings()

        LOGGER.debug(s)

    if PARENT is None:
        # noinspection PyPep8Naming
        PARENT = QtWidgets.QWidget

    if CANVAS is None:
        # noinspection PyPep8Naming
        CANVAS = QgsMapCanvas()
        CANVAS.resize(QtCore.QSize(400, 400))
    if IFACE is None:
        # QgisInterface is a stub implementation of the QGIS plugin interface
        # noinspection PyPep8Naming
        # IFACE = QgisInterface(CANVAS)
        IFACE = None

    return QGIS_APP, CANVAS, IFACE, PARENT
Example #15
0
def convert_qml(gdb_path, layer, qml_path, logger=None):
    """Convert a QML style definition into an SLD. Returns the XML string.
    """
    # Ensure that the required Qt env var is set.
    if not os.getenv('QT_QPA_PLATFORM'):
        os.environ['QT_QPA_PLATFORM'] = 'offscreen'

    # Initialise a QGIS application.
    QgsApplication.setPrefixPath('/usr', True)
    qgis = QgsApplication([], False)
    qgis.initQgis()

    uri = '{}|layername={}'.format(gdb_path, layer)
    vector_layer = QgsVectorLayer(uri, layer, 'ogr')
    load_msg, load_success = vector_layer.loadNamedStyle(qml_path)
    if not load_success:
        if logger:
            logger.error('Error loading QML for {}: {}'.format(layer, load_msg))
        return

    sld_file = tempfile.NamedTemporaryFile(prefix=layer, suffix='.sld', delete=False)
    write_msg, write_success = vector_layer.saveSldStyle(sld_file.name)
    if not write_success:
        if logger:
            logger.error('Error writing SLD for {}: {}'.format(layer, write_msg))
        return

    # Define XML namespaces.
    ns = {
        'sld': 'http://www.opengis.net/sld',
        'se': 'http://www.opengis.net/se',
        'ogc': 'http://www.opengis.net/ogc',
        'xsi': 'http://www.w3.org/2001/XMLSchema-instance',
    }
    # Parse the SLD.
    root = ET.fromstring(sld_file.read())
    # Alter any Name elements where the element value == layer (uppercase).
    for el in root.findall('.//se:Name', ns):
        if el.text == layer:
            el.text = el.text.lower()
    # Alter any PropertyName element values to lowercase (these are db column names).
    for el in root.findall('.//ogc:PropertyName', ns):
        el.text = el.text.lower()
    # TODO: additional SLD cleansing.

    # Return the XML string.
    ET.register_namespace('', 'http://www.opengis.net/sld')  # Register default namespace
    for k, v in ns.items():  # Register remaining namespaces.
        ET.register_namespace(k, v)
    # Write a new XML tree to a file, then return the contents.
    tree = ET.ElementTree(root)
    f = io.StringIO()
    tree.write(f, encoding='unicode')
    f.seek(0)
    return f.read()
Example #16
0
    def testExportToFileWithModel(self):
        QgsApplication.setPrefixPath("/usr/share/qgis", True)
        qgs = QgsApplication([], False)
        # load providers
        qgs.initQgis()

        # shapefile
        aroundtheblockPath = os.path.join(os.path.abspath("../../sampledata/"), "amsterdam-yymmdd.csv")
        logger = test_MMImport.mockLogger()
        messageBar = test_MMImport.MockMessageBar(logger)
        messageBox = test_MMImport.MockMessageBox
        layer = loadCSVLayer(
            dateFormat='yyyy/mm/dd',
            gpsPath=aroundtheblockPath,
            logger=logger,
            mainWindow=None,
            messageBar=messageBar,
            messageBox=messageBox
        )
        self.assertTrue(layer.isValid())

        # reset the flag
        messageBar.gotSuccess = False

        fields = test_MMImport.field_indices(layer)
        # if model data should be included
        modelTemplate = {'link': None, 'longitude': None, 'latitude': None, 'altitude' : None, 'scale': None}
        layer.startEditing()
        layer.beginEditCommand("Rendering Editing")
        for feature in layer.getFeatures():
            attributes = feature.attributes()
            model = modelTemplate
            model['link'] = 'files/red_sphereC.dae'
            model['longitude'] = attributes[fields['x']]
            model['latitude'] = attributes[fields['y']]
            model['scale'] = 1
            model['altitude'] = attributes[fields['altitude']]
            layer.changeAttributeValue(feature.id(), fields['model'], str(model))
        layer.endEditCommand()

        loggerPath = ""
        exportToFile(
            activeLayer=layer,
            audioHREF="",
            audioOffset=0,
            exportPath="amsterdam-yymmdd-model.kml",
            fields=fields,
            lastDirectory=".",
            logger=logger,
            loggerPath=loggerPath,
            messageBar=messageBar
        )

        self.assertTrue(messageBar.gotSuccess)
Example #17
0
def main():
    qgs = QgsApplication([], True)
    qgs.setPrefixPath('qgis', True)
    qgs.initQgis()

    window = MapExplorer()
    window.show()

    exit_code = qgs.exec_()
    qgs.exitQgis()
    sys.exit(exit_code)
Example #18
0
def init():
  a = QgsApplication(sys.argv, True)
  a.setApplicationName("Teste PyCharm")
  QgsApplication.setPrefixPath("C:\\PROGRA~2\\QGISWI~1\\apps\\qgis", True)
  print QgsApplication.showSettings()


  QgsApplication.initQgis()
#  providers = QgsProviderRegistry.instance().providerList()
#  for provider in providers:
#    print provider
  return a
Example #19
0
def main():
    app = QApplication(sys.argv)
    QgsApplication.setPrefixPath(qgis_prefix, True)
    QgsApplication.initQgis()

    model = Model()
    ex = login.Window(model)

    r = app.exec_()

    QgsApplication.exitQgis()
    sys.exit(r)
Example #20
0
def main():
    QgsApplication.setPrefixPath('/usr/local', True)
    QgsApplication.initQgis()
    layer = QgsVectorLayer("/home/cfarmer/Downloads/qgis_sample_data/vmap0_shapefiles/majrivers.shp", "majrivers", "ogr")
    provider = layer.dataProvider()
    if not robjects.r.require('sp')[0]:
        raise Exception("Error: missing 'sp' package: classes and methods for spatial data")
    if not robjects.r.require('rgdal')[0]:
        raise Exception("Error: missing 'rgdal' package: classes and methods for spatial data")
    output = qOGRVectorDataFrame(layer, True)
    robjects.r.plot(robjects.r.get("majrivers"))
    s = raw_input('Waiting for input... (Return)')
Example #21
0
 def __new__(cls):
     if QgsSingleton._qgs is None:
         # Init qGis API
         QgsSingleton._qgs = QgsApplication([], False)
         qgis_prefix = os.getenv("QGISHOME")
         if qgis_prefix:
             QgsApplication.setPrefixPath(qgis_prefix, True)
         QgsApplication.initQgis()
         # sets GDAL to convert xlink references to fields but not resolve
         gdal.SetConfigOption("GML_ATTRIBUTES_TO_OGR_FIELDS", "YES")
         gdal.SetConfigOption("GML_SKIP_RESOLVE_ELEMS", "ALL")
     return QgsSingleton._qgs
Example #22
0
def main(argv):

    # load plugins
    if os.path.exists(PLUGIN_FILE):
        imp.load_source('hmtk.plugin', PLUGIN_FILE)

    # create Qt application

    # Claim to be QGIS2 so that used plugins that tries to access
    # QSettings will get the QGIS2 settings
    QtGui.QApplication.setApplicationName('QGIS2')
    QtGui.QApplication.setOrganizationDomain('qgis.org')

    if QtCore.QSettings().value('locale/userLocale') is None:
        QtGui.QApplication.setOrganizationDomain('QGIS')

    app = QtGui.QApplication(argv, True)

    # setup QGIS
    QgsApplication.setPrefixPath(os.environ['QGIS_PREFIX_PATH'], True)
    QgsApplication.initQgis()

    # Install a custom exception hook that prints exception into a
    # MessageBox
    sys.excepthook = excepthook

    # create main window
    wnd = MainWindow()  # classname
    wnd.show()

    if sys.platform == "darwin":
        wnd.raise_()

    if len(argv) > 1:
        wnd.change_model(CatalogueModel.from_csv_file(argv[1]))

        if len(argv) > 2:
            wnd.load_fault_source(argv[2])
    else:
        wnd.load_catalogue()

    # Connect signal for app finish
    def on_quit():
        QgsApplication.exitQgis()
        app.quit()

    app.lastWindowClosed.connect(on_quit)

    # Start the app up
    ret = app.exec_()

    sys.exit(ret)
Example #23
0
def main():
    QgsApplication.setPrefixPath("/usr", True)
    qgis = QgsApplication([], False)
    qgis.initQgis()

    params = argv[1:]
    if len(params) > 0:
        for param in params:
            create_sdl_for_fgdb_layers(param)
    else:
        print("Usage: create_sdl.py fgdb_path [fgdb_path2 ...]")

    qgis.exitQgis()
def run_qgis_algorithm(algorithm_id, algorithm_parameters):
    import sys
    import qgis.utils

    from qgis.core import (
        QgsApplication,
        QgsProcessingFeedback,
        QgsVectorLayer,
        QgsProcessingProvider,
        QgsProcessingRegistry,
    )
    from qgis.analysis import QgsNativeAlgorithms

    # See https://gis.stackexchange.com/a/155852/4972 for details about the prefix
    QgsApplication.setPrefixPath('/usr', True)
    qgs = QgsApplication([], False)
    qgs.initQgis()

    #  # Append the path where processing plugin can be found
    sys.path.append('/usr/share/qgis/python/plugins/')

    import processing
    from processing.core.Processing import Processing
    Processing.initialize()
    QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())

    print('You are using QGIS version: %s ', qgis.utils.Qgis.QGIS_VERSION)
    print('You are running:  %s ', algorithm_id)

    provider = NDVIProvider()
    provider.loadAlgorithms()

    QgsApplication.processingRegistry().addProvider(provider)

    # Checking if the algorithm is added
    # last_alg = QgsApplication.processingRegistry().algorithms()[-1]
    # print(last_alg.name())
    # print(last_alg.id())
    # last_alg = QgsApplication.processingRegistry().algorithms()[-2]
    # print(last_alg.name())
    # print(last_alg.id())

    # Show help for the algorithm
    processing.algorithmHelp(algorithm_id)
    print('Running algorithm')
    result = processing.run(algorithm_id, algorithm_parameters)
    print('### Result:')
    print(result)

    qgs.exitQgis()
    return result
Example #25
0
    def setUpClass(cls):

        if 'linux' in sys.platform:
            QgsApplication.setPrefixPath('/usr', True)
        elif 'win' in sys.platform:
            pass

        cls.qgs = QgsApplication([], False)
        cls.qgs.initQgis()

        from processing.core.Processing import Processing
        Processing.initialize()

        # Old calc
        ##
        cls.conf_ = ConfigHandler()
        cls.conf_.loadSettings(PROJECT_FILE)
        cls.conf_.prepareForCalculation()
        proj_ = cls.conf_.project
        param_ = cls.conf_.params.getSimpleParameterDict()

        cls.projInfo_ = {
            'Anfangspunkt': proj_.getPoint('A')[0],
            'Endpunkt': proj_.getPoint('E')[0],
            'Projektname': proj_.getProjectName() + '_old',
            'Hoehenmodell': {
                'path': proj_.getHeightSourceAsStr()
            }
        }
        cls.inputData_ = {}
        for key, val in param_.items():
            cls.inputData_[key] = [val]
        cls.inputData_['HM_fix_d'] = proj_.fixedPoles['HM_fix_d']
        cls.inputData_['HM_fix_h'] = proj_.fixedPoles['HM_fix_h']
        cls.inputData_['noStue'] = proj_.noPoleSection
        cls.inputData_ = checkInputParams(cls.inputData_)

        # New calc
        cls.conf = ConfigHandler()
        cls.params = cls.conf.params
        cls.project = cls.conf.project
        cls.conf.loadSettings(PROJECT_FILE)
        cls.conf.prepareForCalculation()

        cls.dhm = cls.project.heightSource
        cls.profile = cls.project.profile
        cls.poles = cls.project.poles
        cls.deltaP = cls.profile.SAMPLING_DISTANCE
        cls.points = cls.project.points['A'] \
                     + cls.project.points['E']
Example #26
0
def main():
    app = QtGui.QApplication(sys.argv, True)
    # supply path to where is your qgis installed
    QgsApplication.setPrefixPath("/usr", True)
    # load providers
    QgsApplication.initQgis()
    # print QgsApplication.showSettings()
    mw = MainWindow()
    try:
        mw.create_layer(DATA)
        mw.show()
        app.exec_()
    finally:
        QgsApplication.exitQgis()
Example #27
0
    def init(self):
        self.app = QgsApplication(self.sysargv, True)
        QgsApplication.setPrefixPath(self.prefixpath, True)
        QgsApplication.initQgis()

        locale = QLocale.system().name()
        self.translationFile = os.path.join(self.i18npath, '{0}.qm'.format(locale))
        translator = QTranslator()
        translator.load(self.translationFile, "i18n")
        self.app.installTranslator(translator)

        QApplication.setStyle("Plastique")
        QApplication.setFont(QFont('Segoe UI'))
        return self
def get_qgis_app():
    """ Start one QGis application to test against

    Input
        NIL

    Output
        handle to qgis app


    If QGis is already running the handle to that app will be returned
    """

    global QGIS_APP  # pylint: disable=W0603

    if QGIS_APP is None:
        gui_flag = True  # All test will run qgis in safe_qgis mode
        #noinspection PyPep8Naming
        QGIS_APP = QgsApplication(sys.argv, gui_flag)

        # Note: This block is not needed for  QGIS > 1.8 which will
        # automatically check the QGIS_PREFIX_PATH var so it is here
        # for backwards compatibility only
        if 'QGIS_PREFIX_PATH' in os.environ:
            path = os.environ['QGIS_PREFIX_PATH']
            use_default_path_flag = True
            QGIS_APP.setPrefixPath(path, use_default_path_flag)

        QGIS_APP.initQgis()
        s = QGIS_APP.showSettings()
        LOGGER.debug(s)

    global PARENT  # pylint: disable=W0603
    if PARENT is None:
        #noinspection PyPep8Naming
        PARENT = QtGui.QWidget()

    global CANVAS  # pylint: disable=W0603
    if CANVAS is None:
        #noinspection PyPep8Naming
        CANVAS = QgsMapCanvas(PARENT)
        CANVAS.resize(QtCore.QSize(400, 400))

    global IFACE  # pylint: disable=W0603
    if IFACE is None:
        # QgisInterface is a stub implementation of the QGIS plugin interface
        #noinspection PyPep8Naming
        IFACE = QgisInterface(CANVAS)

    return QGIS_APP, CANVAS, IFACE, PARENT
def get_qgis_app():
    """ Start one QGis application to test against

    Input
        NIL

    Output
        handle to qgis app


    If QGis is already running the handle to that app will be returned
    """

    global QGIS_APP  # pylint: disable=W0603

    if QGIS_APP is None:
        gui_flag = True  # All test will run qgis in safe_qgis mode
        # noinspection PyPep8Naming
        QGIS_APP = QgsApplication(sys.argv, gui_flag)

        # Note: This block is not needed for  QGIS > 1.8 which will
        # automatically check the QGIS_PREFIX_PATH var so it is here
        # for backwards compatibility only
        if "QGIS_PREFIX_PATH" in os.environ:
            path = os.environ["QGIS_PREFIX_PATH"]
            use_default_path_flag = True
            QGIS_APP.setPrefixPath(path, use_default_path_flag)

        QGIS_APP.initQgis()
        s = QGIS_APP.showSettings()
        LOGGER.debug(s)

    global PARENT  # pylint: disable=W0603
    if PARENT is None:
        # noinspection PyPep8Naming
        PARENT = QtGui.QWidget()

    global CANVAS  # pylint: disable=W0603
    if CANVAS is None:
        # noinspection PyPep8Naming
        CANVAS = QgsMapCanvas(PARENT)
        CANVAS.resize(QtCore.QSize(400, 400))

    global IFACE  # pylint: disable=W0603
    if IFACE is None:
        # QgisInterface is a stub implementation of the QGIS plugin interface
        # noinspection PyPep8Naming
        IFACE = QgisInterface(CANVAS)

    return QGIS_APP, CANVAS, IFACE, PARENT
Example #30
0
def main():
  QgsApplication.setPrefixPath('/usr/local', True)
  QgsApplication.initQgis()
  layer = QgsVectorLayer('/path/to/layer.shp', 'layer', 'ogr')
  provider = layer.dataProvider()
  layer.select(provider.attributeIndexes())
  values = []
  for feat in layer:
    values.append(feat.attributeMap()[1].toDouble()[0])
  print "Quantile: ", quantile(values, 5)
  print "Equal Interval: ", equal(values, 5)
  print "R's Pretty: ", pretty(values, 5)
  print "Standard Deviation: ", std_dev(values, 5)
  print "Natural Breaks (Jenks): ", jenks(values, classes=5)
  print "Sampled Jenks: ", jenks_sample(values, classes=5)
Example #31
0
def heatmap(table):
    """TODO
    Still having issues running the alg from terminal
    """

    from qgis.core import QgsVectorLayer, QgsDataSourceURI, QgsApplication
    from PyQt4.QtGui import QApplication
    qgs = QgsApplication([], True, None)
    qgs.setPrefixPath("/usr/bin", True)
    sys.path.append('/usr/share/qgis/python/plugins')
    from processing.core.Processing import Processing
    qgs.initQgis()

    #app = QApplication([])
    Processing.initialize()
    Processing.updateAlgsList()
    params = cnx_params.blight
    db = params['db']
    host = params['host']
    user = params['user']
    pwd = params['password']
    dbcnx = ("dbname='{db}' host={host} port=5432 "
             "user='******' password='******'")
    id_field = "uid"
    table = ("(select row_number() over () as uid, li_type, "
             "count(li_type), parcelnumb, "
             "st_centroid(wkb_geometry) geom_pt "
             "from clean_stat.survey_issues, sca_parcels "
             "where li_type = '{1}' and parcelnumb = parcelid "
             "group by parcelnumb, li_type, wkb_geometry)")
    uri = "{0} key={1} table={2} (geom_pt) sql="
    lyr = QgsVectorLayer(
        uri.format(
            dbcnx.format(**params),
            id_field,
            table.format("ll", "LL"),
        ), "li_type_ll_test", "postgres")
    Processing.runAlgorithm("saga:kerneldensityestimation", lyr, "count", 300,
                            0, ("754005.201649,760791.665104,"
                                "316181.236576,323293.188451"), 25, 0,
                            "/home/nate/temp/ll_del.tif")
    uri = QgsDataSourceURI()
    uri.setConnection(host, '5432', db, user, pwd, sslmode=uri.SSLrequire)
    uri.setDataSource('clean_stat', table, 'geom_pt', "", "uid")
    lyr = QgsVectorLayer(uri.uri(False), table, "postgres")
    processing.runalg("saga:kerneldensityestimation", lyr, "count", 300., 0,
                      "", 25, 0, "/home/nate/temp/ll_del.tif")
Example #32
0
def getQgisTestApp():
    """ Start one QGis application to test agaist

    Input
        NIL

    Output
        handle to qgis app


    If QGis is already running the handle to that app will be returned
    """

    global QGISAPP

    if QGISAPP is None:
        myGuiFlag = True  # All test will run qgis in gui mode
        QGISAPP = QgsApplication(sys.argv, myGuiFlag)
        if 'QGISPATH' in os.environ:
            myPath = os.environ['QGISPATH']
            myUseDefaultPathFlag = True
            QGISAPP.setPrefixPath(myPath, myUseDefaultPathFlag)
        else:
            print 'Warning: QGISPATH is not set'

        QGISAPP.initQgis()
        s = QGISAPP.showSettings()
        print s

    global PARENT
    if PARENT is None:
        PARENT = QtGui.QWidget()

    global CANVAS
    if CANVAS is None:
        CANVAS = QgsMapCanvas(PARENT)
        CANVAS.resize(QtCore.QSize(400, 400))

    global IFACE
    if IFACE is None:
        # QgisInterface is a stub implementation of the QGIS plugin
        # interface
        IFACE = QgisInterface(CANVAS)

    return (QGISAPP, CANVAS, IFACE, PARENT)
Example #33
0
def getQgisTestApp():
    """ Start one QGis application to test agaist

    Input
        NIL

    Output
        handle to qgis app


    If QGis is already running the handle to that app will be returned
    """

    global QGISAPP

    if QGISAPP is None:
        myGuiFlag = True  # All test will run qgis in gui mode
        QGISAPP = QgsApplication(sys.argv, myGuiFlag)
        if 'QGISPATH' in os.environ:
            myPath = os.environ['QGISPATH']
            myUseDefaultPathFlag = True
            QGISAPP.setPrefixPath(myPath, myUseDefaultPathFlag)
        else:
            print 'Warning: QGISPATH is not set'

        QGISAPP.initQgis()
        s = QGISAPP.showSettings()
        print s

    global PARENT
    if PARENT is None:
        PARENT = QtGui.QWidget()

    global CANVAS
    if CANVAS is None:
        CANVAS = QgsMapCanvas(PARENT)
        CANVAS.resize(QtCore.QSize(400, 400))

    global IFACE
    if IFACE is None:
        # QgisInterface is a stub implementation of the QGIS plugin
        # interface
        IFACE = QgisInterface(CANVAS)

    return (QGISAPP, CANVAS, IFACE, PARENT)
def v_to_points(input_file_line_shp, output_file_points_shp):
    import sys
    #    from qgis.core import *
    #    from PyQt4.QtGui import *
    from qgis.core import QgsApplication
    from PyQt4.QtGui import QApplication
    app = QApplication([], True)
    QgsApplication.setPrefixPath("/usr", True)
    QgsApplication.initQgis()
    sys.path.append('/usr/share/qgis/python/plugins')
    # impport qgis procesing
    from processing.core.Processing import Processing
    Processing.initialize()
    #    from processing.tools import *
    from processing.tools import general
    #    import processing
    #grass7:v.to.points
    general.runalg("grass7:v.to.points", input_file_line_shp, "100", 1, True,
                   "2603510,2624270,1260650,1274890", -1, 0.0001, 0,
                   output_file_points_shp)
def v_in_lines(input_file_points_csv, output_file_line_shp):
    import sys
    #    from qgis.core import *
    #    from PyQt4.QtGui import *
    from qgis.core import QgsApplication
    from PyQt4.QtGui import QApplication
    app = QApplication([], True)
    QgsApplication.setPrefixPath("/usr", True)
    QgsApplication.initQgis()
    sys.path.append('/usr/share/qgis/python/plugins')
    # impport qgis procesing
    from processing.core.Processing import Processing
    Processing.initialize()
    #    from processing.tools import *
    from processing.tools import general
    #    import processing
    # grass7:v.in.lines  #using general.runalg instead of processing.runalg
    general.runalg("grass7:v.in.lines", input_file_points_csv, ",", False,
                   "2605158.67928,2621471.50192,1265877.44552,1269377.45567",
                   0, output_file_line_shp)
Example #36
0
    def setUpClass( self ):
        self.msg = MessageManager( 'debug', None ) 
        self.msg.show( "Info! SetUp started", 'info', True )
        #Initialize QGIS app
        app = QgsApplication([], True)
        QgsApplication.setPrefixPath("/usr", True)
        QgsApplication.initQgis()
        
        #Configure QSettings (organization and application name)
        self.settings = QSettings("GeoTux", "QGIS-Plugin-Test") 

        #Load layer, add field f1, and add layer to Registry
        baseDir = os.path.dirname( os.path.realpath( __file__ ) )
        self.layerPath = os.path.join( baseDir, 'test_data', 'test_points.shp' )
        self.layer = QgsVectorLayer( self.layerPath, 'puntos', 'ogr' )   
        self.layer.dataProvider().addAttributes([QgsField('f1', QVariant.Double)])
        self.layer.updateFields()
        QgsMapLayerRegistry.instance().addMapLayer( self.layer )  
        
        #Instantiate AutoFieldManager
        self.autoFieldManager = AutoFieldManager( self.msg, None, '/AutoFieldsTest', 'GeoTux', 'QGIS-Plugin-Test' )
Example #37
0
    def init(self):
        from qgis.core import QgsApplication
        from PyQt4.QtGui import QApplication, QFont
        from PyQt4.QtCore import QLocale, QTranslator
        try:
            import PyQt4.QtSql
        except ImportError:
            pass

        self.app = QgsApplication(self.sysargv, True)
        QgsApplication.setPrefixPath(self.prefixpath, True)
        QgsApplication.initQgis()

        locale = QLocale.system().name()
        self.translationFile = os.path.join(self.i18npath, '{0}.qm'.format(locale))
        translator = QTranslator()
        translator.load(self.translationFile, "i18n")
        self.app.installTranslator(translator)

        QApplication.setStyle("Plastique")
        QApplication.setFont(QFont('Segoe UI'))
        return self
def main(argv):

    # create Qt application
    app = QtGui.QApplication(argv, True)

    # Set the app style

    # initialize qgis libraries
    QgsApplication.setPrefixPath(QGIS_PREFIX_PATH, True)
    QgsApplication.initQgis()

    # create main window
    wnd = MainWindow()
    wnd.show()

    # Start the app up
    retval = app.exec_()

    # We got an exit signal so time to clean up
    QgsApplication.exitQgis()

    sys.exit(retval)
Example #39
0
def main(argv):    
    names = []
    for n in LAYERS:
        names.append(QString(n))
    qgisPrefix =  homeDir()        
    QApplication.setOrganizationName("ICIMOD");
    QApplication.setOrganizationDomain("icimod.org");
    QApplication.setApplicationName("Glacial Lakes Viewer");

    app = QApplication(argv, True)
    splash = SplashScreen(qgisPrefix)
    splash.showMessage(unicode("starting..."))
    QgsApplication.setPrefixPath(qgisPrefix, True)
    QgsApplication.initQgis()        
    window = MainWindow(splash)
    window.mapCanvas.loadInitialLayers(splash)
    layers,rLayers = window.mapCanvas.getMapLayers(names)       
    window.show()    
    window.mapCanvas.refreshCanvas(splash,layers,rLayers)
    del splash

    app.exec_()
    QgsApplication.exitQgis()
Example #40
0
import roam
import roam.environ
import roam.project
import roam.resources_rc

from configmanager.ui.configmanagerdialog import ConfigManagerDialog

import configmanager.settings
import configmanager.logger as logger

logger.info("Loading Roam Config Manager")
roamapp = roam.environ.setup(sys.argv)

app = QgsApplication(sys.argv, True)
QgsApplication.setPrefixPath(roamapp.prefixpath, True)
QgsApplication.initQgis()

logger.info(QgsApplication.showSettings())
logger.info(QgsProviderRegistry.instance().pluginList())
logger.info(QgsApplication.libraryPaths())

logger.info("Roam Version: {}".format(roam.__version__))
logger.info("QGIS Version: {}".format(str(QGis.QGIS_VERSION)))

QApplication.setStyle("Plastique")
QApplication.setFont(QFont('Segoe UI'))
QApplication.setWindowIcon(QIcon(':/branding/logo'))
QApplication.setApplicationName("IntraMaps Roam Config Manager")

configmanager.settings.load(roamapp.settingspath)
    def __init__(self, q_application):
        QtGui.QMainWindow.__init__(self, None)
        self.setupUi(self)
        self.q_application = q_application
        self.layers = []
        self._forms = []
        """List of editor windows used during this session, kept here so they are not automatically closed."""
        self.model = "Not Set"
        self.project_type = Project
        self.project = None
        self.obj_tree = None
        self.obj_list = None
        self.obj_view_model = QStandardItemModel()
        self.plugins = self.get_plugins()
        self.populate_plugins_menu()
        QtCore.QObject.connect(self.actionStdNewProjectMenu, QtCore.SIGNAL('triggered()'), self.new_project)
        QtCore.QObject.connect(self.actionStdNewProject, QtCore.SIGNAL('triggered()'), self.new_project)
        QtCore.QObject.connect(self.actionStdOpenProjMenu, QtCore.SIGNAL('triggered()'), self.open_project)
        QtCore.QObject.connect(self.actionStdOpenProj, QtCore.SIGNAL('triggered()'), self.open_project)
        QtCore.QObject.connect(self.actionStdExit, QtCore.SIGNAL('triggered()'), self.action_exit)
        QtCore.QObject.connect(self.actionIPython, QtCore.SIGNAL('triggered()'), self.script_ipython)
        QtCore.QObject.connect(self.actionExec, QtCore.SIGNAL('triggered()'), self.script_exec)
        QtCore.QObject.connect(self.actionStdSave, QtCore.SIGNAL('triggered()'), self.save_project)
        QtCore.QObject.connect(self.actionStdSaveMenu, QtCore.SIGNAL('triggered()'), self.save_project)
        QtCore.QObject.connect(self.actionStdSave_As, QtCore.SIGNAL('triggered()'), self.save_project_as)
        QtCore.QObject.connect(self.actionStdRun_Simulation, QtCore.SIGNAL('triggered()'), self.run_simulation)
        QtCore.QObject.connect(self.actionRun_SimulationMenu, QtCore.SIGNAL('triggered()'), self.run_simulation)
        QtCore.QObject.connect(self.actionStdProjCalibration_Data, QtCore.SIGNAL('triggered()'), self.calibration_data)

        self.setAcceptDrops(True)
        self.tree_section = ''

        try:
            from qgis.core import QgsApplication
            from qgis.gui import QgsMapCanvas
            from map_tools import EmbedMap

            # TODO: make sure this works on all platforms, both in dev environment and in our installed packages
            search_paths = [os.path.join(INSTALL_DIR, "qgis"),
                            os.path.join(INSTALL_DIR, "../qgis"),
                            os.path.join(INSTALL_DIR, "../../qgis"),
                            "C:/OSGeo4W/apps/qgis/",
                            "/usr",
                            "/Applications/QGIS.app/Contents/MacOS"]
            if os.environ.has_key("QGIS_HOME"):
                search_paths.insert(0, os.environ.get("QGIS_HOME"))
            if os.environ.has_key("QGIS_PREFIX_PATH"):
                search_paths.insert(0, os.environ.get("QGIS_PREFIX_PATH"))
            try:
                for qgis_home in search_paths:
                    if os.path.isdir(qgis_home):
                        QgsApplication.setPrefixPath(qgis_home, True)
                        QgsApplication.initQgis()
                        self.canvas = QgsMapCanvas(self, 'mapCanvas')
                        self.canvas.setMouseTracking(True)
                        self.map_widget = EmbedMap(session=self, mapCanvas=self.canvas)
                        self.map_win = self.map.addSubWindow(self.map_widget, QtCore.Qt.Widget)
                        if self.map_win:
                            self.map_win.setGeometry(0, 0, 600, 400)
                            self.map_win.setWindowTitle('Study Area Map')
                            self.map_win.show()
                            QtCore.QObject.connect(self.actionAdd_Vector, QtCore.SIGNAL('triggered()'), self.map_addvector)
                            QtCore.QObject.connect(self.actionAdd_Raster, QtCore.SIGNAL('triggered()'), self.map_addraster)
                            QtCore.QObject.connect(self.actionPan, QtCore.SIGNAL('triggered()'), self.setQgsMapTool)
                            QtCore.QObject.connect(self.actionZoom_in, QtCore.SIGNAL('triggered()'), self.setQgsMapTool)
                            QtCore.QObject.connect(self.actionZoom_out, QtCore.SIGNAL('triggered()'), self.setQgsMapTool)
                            QtCore.QObject.connect(self.actionZoom_full, QtCore.SIGNAL('triggered()'), self.zoomfull)
                            QtCore.QObject.connect(self.actionAdd_Feature, QtCore.SIGNAL('triggered()'), self.map_addfeature)
                            break  # Success, done looking for a qgis_home
                else:
                    QMessageBox.information(None, "QGIS Home not found", "Not creating map", QMessageBox.Ok)
            except Exception as e1:
                msg = str(e1) + '\n' + str(traceback.print_exc())
                print(msg)
                QMessageBox.information(None, "Error Initializing Map", msg, QMessageBox.Ok)

        except Exception as eImport:
            self.canvas = None
            print "QGIS libraries not found, Not creating map\n" + str(eImport)
            # QMessageBox.information(None, "QGIS libraries not found", "Not creating map\n" + str(eImport), QMessageBox.Ok)
        self.onLoad()
Example #42
0
    
    #suite.addTest(UtilsTestCase('test_Grid'))
    return suite

if __name__ == '__main__':
    try:
        opts, args = getopt.getopt(sys.argv[1:], "s", ["test suite"])
    except getopt.GetoptError, err:
        # print help information and exit:
        print str(err) # will print something like "option -a not recognized"
        sys.exit(2)

    os.environ['QGIS_DEBUG'] = '-1'
    
    # supply path to where is your qgis installed
    QgsApplication.setPrefixPath(os.environ['QGIS'], True)
    # load providers
    QgsApplication.initQgis()

    run_test_case=False
    for o, a in opts:
        if o == "-s":
            run_test_case=True

    if run_test_case:
        print 'Running custom test suite ... '
        print '----------------------------------------------------------------------'
        runner = unittest.TextTestRunner(verbosity=2)
        runner.run(suite())            
    else:            
        print 'Running all test cases ... '
Example #43
0
def init_test():
    QgsApplication.setPrefixPath(r'/usr', True)
    app = QgsApplication.initQgis()
    QtCore.QCoreApplication.setOrganizationName('QGIS')
    QtCore.QCoreApplication.setApplicationName('QGIS2')
    return app
Example #44
0
# Extra installed apps
INSTALLED_APPS += (
    # any 3rd party apps
)

# enable cached storage
STATICFILES_STORAGE = (
    'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
)


STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder'
)


# QGIS specific settings
QGIS_PYTHON_PATH = '/usr/share/qgis/python'

# add QGIS_PYTHON_PATH to system path
import sys
sys.path.append(QGIS_PYTHON_PATH)

QGIS_PREFIX_PATH = '/usr'

from qgis.core import QgsApplication
qgis_app = QgsApplication([], False)
QgsApplication.setPrefixPath(QGIS_PREFIX_PATH, True)
QgsApplication.initQgis()
def main( argv ):
    print 'I: Starting viewer ...'    
    app = SingletonApp( argv )

    dictOpts = { '-h':'', '-p':'5432', '-U':'', '-W':'', '-d':'', '-s':'public', 
                  '-t':'', '-g':'', 'type':'unknown', 'srid':'', 'col':'' }

    opts, args = getopt.getopt( sys.argv[1:], 'h:p:U:W:d:s:t:g:', [] )
    dictOpts.update( opts )
    
    if dictOpts['-t'] == '':
        print >> sys.stderr, 'E: Table name is required'
        print __doc__
        sys.exit( 1 )

    d = QSqlDatabase.addDatabase( "QPSQL", "PgSQLDb" )
    d.setHostName( dictOpts['-h'] )
    d.setPort( int( dictOpts['-p'] ) )
    d.setDatabaseName( dictOpts['-d'] )
    d.setUserName( dictOpts['-U'] )
    d.setPassword( dictOpts['-W'] )

    if d.open():
        print 'I: Database connection was succesfull'
        
        query = QSqlQuery( d )
        query.exec_( "SELECT Count(srid) FROM raster_columns WHERE r_table_schema = '%s' AND r_table_name = '%s'" % ( dictOpts['-s'], dictOpts['-t'] ) )
        
        if query.next() and query.value( 0 ).toBool(): # Raster layer (WKTRaster)!            
            query.exec_( "SELECT srid, r_raster_column FROM raster_columns \
                          WHERE r_table_schema = '%s' AND \
                          r_table_name = '%s' " % ( dictOpts['-s'], dictOpts['-t'] ) )
            if query.next():
                dictOpts[ 'srid' ] = str( query.value( 0 ).toString() )
                dictOpts[ 'col' ] = str( query.value( 1 ).toString() )

            dictOpts['type'] = 'raster'
            print 'I: Raster layer detected'
            
        else: # Vector layer?            
            query.exec_( "SELECT column_name FROM information_schema.columns \
                    WHERE table_schema = '%s' AND \
                    table_name = '%s' AND \
                    udt_name = 'geometry' LIMIT 1" % ( dictOpts['-s'], dictOpts['-t'] ) )          

            if not query.next(): # Geography layer?        
                query.exec_( "SELECT column_name FROM information_schema.columns \
                        WHERE table_schema = '%s' AND \
                        table_name = '%s' AND \
                        udt_name = 'geography' LIMIT 1" % ( dictOpts['-s'], dictOpts['-t'] ) )

            if query.first(): # Vector layer!        
                dictOpts[ '-g' ] = str( query.value( 0 ).toString() )

                query.exec_( "SELECT srid FROM geometry_columns \
                              WHERE f_table_schema = '%s' AND \
                              f_table_name = '%s' " % ( dictOpts['-s'], dictOpts['-t'] ) )
                if query.next():
                    dictOpts[ 'srid' ] = str( query.value( 0 ).toString() )

                dictOpts['type'] = 'vector'
                print 'I: Vector layer detected'

        if not dictOpts[ 'type' ] == 'unknown': # The object is a layer
            if app.is_running:
                # Application already running, send message to load data
                app.send_message( dictOpts )
            else:
                # Start the Viewer

                # QGIS libs init
                QgsApplication.setPrefixPath(qgis_prefix, True)
                QgsApplication.initQgis()

                # Open viewer
                wnd = ViewerWnd( app, dictOpts )
                wnd.move(100,100)
                wnd.resize(400, 500)
                wnd.show()

                retval = app.exec_()

                # Exit
                QgsApplication.exitQgis()
                print 'I: Exiting ...'
                sys.exit(retval)      
        else:
            show_error("Error when opening layer", 
                "Layer '%s.%s' doesn't exist. Be sure the selected object is either raster or vector layer." % (dictOpts['-s'], dictOpts['-t']))
    else:
        show_error("Connection error", "Error when connecting to database.")
Example #46
0
    def renderer(self):
        qgis = QgsApplication([], False)
        qgis.setPrefixPath(self.settings.get('path'), True)
        qgis.setMaxThreads(1)
        qgis.initQgis()

        while True:
            try:
                fndata, srs, render_size, extended, \
                    target_box, result = self.queue.get()

                layer = QgsVectorLayer(fndata, 'layer', 'ogr')

                crs = QgsCoordinateReferenceSystem(srs.id)
                layer.setCrs(crs)

                settings = QgsMapSettings()
                settings.setLayers([layer.id()])
                settings.setFlag(QgsMapSettings.DrawLabeling)
                settings.setFlag(QgsMapSettings.Antialiasing)

                settings.setCrsTransformEnabled(True)
                settings.setDestinationCrs(crs)
                settings.setMapUnits(crs.mapUnits())
                settings.setOutputSize(QSize(*render_size))
                settings.setExtent(QgsRectangle(*extended))

                settings.setOutputImageFormat(QImage.Format_ARGB32)
                bgcolor = QColor.fromRgba(qRgba(255, 255, 255, 0))
                settings.setBackgroundColor(bgcolor)
                settings.setOutputDpi(96)

                QgsMapLayerRegistry.instance().addMapLayer(layer)
                settings.setLayers([layer.id()])

                # Создаем QImage руками чтобы можно было использовать
                # QgsMapRendererCustomPainterJob. Остальные не позволяют
                # обойти баг с рисованием поверх старого.
                img = QImage(settings.outputSize(), QImage.Format_ARGB32)

                # Эти костыли нужны для того, чтобы корректно рисовались
                # слои на прозрачном фоне, без этого получается каша.
                img.fill(QColor.fromRgba(qRgba(255, 255, 255, 255)))
                img.fill(QColor.fromRgba(qRgba(255, 255, 255, 0)))

                # DPI должно быть таким же как в settings, иначе ошибка. В QImage
                # разрешение указывается в точках на метр по каждой оси.
                dpm = settings.outputDpi() / 25.4 * 1000
                img.setDotsPerMeterX(dpm)
                img.setDotsPerMeterY(dpm)

                painter = QPainter(img)
                job = QgsMapRendererCustomPainterJob(settings, painter)
                job.renderSynchronously()
                painter.end()

                QgsMapLayerRegistry.instance().removeAllMapLayers()

                # Преобразование QImage в PIL
                ba = QByteArray()
                bf = QBuffer(ba)
                bf.open(QIODevice.WriteOnly)
                img.save(bf, 'PNG')
                bf.close()

                buf = StringIO()
                buf.write(bf.data())
                buf.seek(0)

                img = PIL.Image.open(buf)

                # Вырезаем нужный нам кусок изображения
                result.put(img.crop(target_box))

            except Exception as e:
                self.logger.error(e.message)

        qgis.exitQgis()
Example #47
0
# for running standalone:
from qgis.core import QgsApplication
QgsApplication.setPrefixPath("/usr", True)


from sector import Sector, Roos, SectorSet, SectorSets
import time


doGenerateData = False
doExport = True


'''
sec = Sector()
print(sec)
print(sec.getInsertQuery())
print(sec.getQgsFeature())
'''


'''
roos = Roos()
print(roos)
for geom in roos.sectors:
    print(geom)
'''



if doGenerateData:
Example #48
0
# We have to start this here or else the image drivers don't load for some reason
app = QgsApplication(sys.argv, True)

import roam
import roam.yaml as yaml
import roam.utils
from roam.mainwindow import MainWindow

def excepthook(errorhandler, exctype, value, traceback):
    errorhandler(exctype, value, traceback)
    roam.utils.error("Uncaught exception", exc_info=(exctype, value, traceback))

start = time.time()
roam.utils.info("Loading Roam")

QgsApplication.setPrefixPath(prefixpath, True)
QgsApplication.initQgis()

roam.utils.info(QgsApplication.showSettings())
roam.utils.info(QgsProviderRegistry.instance().pluginList())
roam.utils.info(QImageReader.supportedImageFormats())
roam.utils.info(QImageWriter.supportedImageFormats())
roam.utils.info(QgsApplication.libraryPaths())

QApplication.setStyle("Plastique")
QApplication.setFont(QFont('Segoe UI'))

class Settings:
    def __init__(self, path):
        self.path = path
        self.settings = {}
Example #49
-1
def getQgisTestApp():
    """ Start one QGis application to test agaist

    Input
        NIL

    Output
        handle to qgis app


    If QGis is already running the handle to that app will be returned
    """

    global QGISAPP  # pylint: disable=W0603

    if QGISAPP is None:
        myGuiFlag = True  # All test will run qgis in gui mode
        QGISAPP = QgsApplication(sys.argv, myGuiFlag)
        if 'QGIS_PREFIX_PATH' in os.environ:
            myPath = os.environ['QGIS_PREFIX_PATH']
            myUseDefaultPathFlag = True
            QGISAPP.setPrefixPath(myPath, myUseDefaultPathFlag)

        if sys.platform.startswith('darwin'):
            # override resource paths, otherwise looks for Resources in app
            if 'QGIS_MAC_PKGDATA_DIR' in os.environ:
                myPkgPath = os.environ['QGIS_MAC_PKGDATA_DIR']
                QGISAPP.setPkgDataPath(myPkgPath)
            if 'QGIS_MAC_SVG_DIR'  in os.environ:
                mySVGPath = os.environ['QGIS_MAC_SVG_DIR']
                mySVGPaths = QGISAPP.svgPaths()
                # doesn't get rid of incorrect path, just adds correct one
                mySVGPaths.prepend(mySVGPath)
                QGISAPP.setDefaultSvgPaths(mySVGPaths)

        QGISAPP.initQgis()
        s = QGISAPP.showSettings()
        print s

    global PARENT  # pylint: disable=W0603
    if PARENT is None:
        PARENT = QtGui.QWidget()

    global CANVAS  # pylint: disable=W0603
    if CANVAS is None:
        CANVAS = QgsMapCanvas(PARENT)
        CANVAS.resize(QtCore.QSize(400, 400))

    global IFACE  # pylint: disable=W0603
    if IFACE is None:
        # QgisInterface is a stub implementation of the QGIS plugin interface
        IFACE = QgisInterface(CANVAS)

    return QGISAPP, CANVAS, IFACE, PARENT