def setUpClass(cls):
        print '=============='
        print 'Start GernicJobsTest tests ...'
        print '=============='

        cls.logger = createLogger('GernicJobsTest', logging.DEBUG)
        cls.dbsession = initializeDb(
            getPostgresEngineString(DBCONFIG_PARAMS_TESTING))
Esempio n. 2
0
def loadLogger(debug=True):
    """ This function initialize the logger for the application.
        
    @param boolean: debug (Default=True) """
    if debug:
        LOGGER = createLogger('georeference', logging.DEBUG)
    else:
        LOGGER = logging.getLogger(__name__)
Esempio n. 3
0
    def testCreateGdalGeoTiffDatasetGeoreferenced(self):
        destPath = os.path.join(self.dir, 'test-create-gdal-dataset-georeferenced.tif')
        destPath2 = os.path.join(self.dir, 'test-create-gdal-dataset-georeferenced2.tif')

        image = Image.open(self.file)
        
        ndarray = maskImage(image, self.testData)
        offset = getOffsetValues(self.testData, image)
        driver = gdal.GetDriverByName("GTiff")
        if driver is None:
            raise ValueError("Can't find GeoTiff Driver")
        
        response = createGdalDataset(image, ndarray, driver, None, destPath)
        response1 = createGdalDataset(image, ndarray, driver, offset, destPath2)
        
        print '====================='
        print 'Test if testCreateGdalGeoTiffDataset ...'
        print 'Response: %s'%response
        print '====================='
         
        
        geoTransform = gdal.GCPsToGeoTransform(self.testGcp)
        geoTransform1 = gdal.GCPsToGeoTransform(correctGCPOffset(self.testGcp, offset))
        geoProj = SRC_DICT_WKT[4314]
        response.SetProjection(geoProj)
        response.SetGeoTransform(geoTransform)
        response1.SetProjection(geoProj)
        response1.SetGeoTransform(geoTransform1)        
        response.FlushCache() 
        response1.FlushCache()
        # clear up
        del image
        del ndarray
        del response
        del response1
        
        # create vrt
        dst_path = os.path.join(self.dir, 'test_createVrt.vrt')
        dataset = gdal.Open(self.file, GA_ReadOnly)
        vrt = createVrt(dataset, dst_path)
        vrt.SetProjection(geoProj)
        vrt.SetGeoTransform(geoTransform)
        vrt.FlushCache()
        del vrt
        
        # create georef classic
        dst_path2 = os.path.join(self.dir, 'test-mtb-georef.tif')
        logger = createLogger('GeoreferenceTest', logging.DEBUG)
        georeference(self.file, dst_path2, self.dir, 
                geoTransform, 4314, 'polynom', logger)
#         if os.path.exists(destPath):
#             os.remove(destPath)

        # create georef clipped 
        dst_path3 = os.path.join(self.dir, 'test-mtb-georef-clipped.tif')
        clipPath = createClipShapefile(self.bbox, os.path.join(self.dir, 'test_shp'), 4314)
        response = georeference(self.file, dst_path3, self.dir, 
                                geoTransform, 4314, 'polynom', logger, clipPath)
Esempio n. 4
0
from sqlalchemy.orm import scoped_session
from zope.sqlalchemy import ZopeTransactionExtension

from settings import DBCONFIG_PARAMS
from settings import ROUTE_PREFIX
from georeference.models.meta import initialize_sql
from georeference.models.meta import Base
from georeference.models.meta import getPostgresEngineString
from georeference.utils.logger import createLogger

# set path for finding correct project scripts and modules
sys.path.insert(0,os.path.dirname(__file__))
sys.path.append(os.path.join(os.path.dirname(__file__), "python"))

# load logger
LOGGER = createLogger('georeference', logging.DEBUG)

# base path
here = os.path.dirname(os.path.abspath(__file__))

def loadLogger(debug=True):
    """ This function initialize the logger for the application.
        
    @param boolean: debug (Default=True) """
    if debug:
        LOGGER = createLogger('georeference', logging.DEBUG)
    else:
        LOGGER = logging.getLogger(__name__)
    
def addRoutes(config):
    """ Adds routing endpoints to the pyramid application 
Esempio n. 5
0
BASE_PATH = os.path.dirname(os.path.realpath(__file__))
BASE_PATH_PARENT = os.path.abspath(os.path.join(BASE_PATH, os.pardir))
ROOT_PATH = os.path.abspath(os.path.join(os.path.abspath(os.path.join(BASE_PATH_PARENT, os.pardir)), os.pardir))
sys.path.insert(0, BASE_PATH)
sys.path.append(BASE_PATH_PARENT)
sys.path.append(ROOT_PATH)


# Initialize the logger
if not os.path.exists(GEOREFERENCE_DAEMON_LOGGER['file']):
    open(GEOREFERENCE_DAEMON_LOGGER['file'], 'a').close()

formatter = logging.Formatter(GEOREFERENCE_DAEMON_LOGGER['formatter'])
handler = TimedRotatingFileHandler(GEOREFERENCE_DAEMON_LOGGER['file'], when='d', interval=1, backupCount=14)
handler.setFormatter(formatter)
LOGGER = createLogger(GEOREFERENCE_DAEMON_LOGGER['name'], GEOREFERENCE_DAEMON_LOGGER['level'], handler = handler)

class GeoreferenceDaemonApp():
    """ The GeoreferenceDaemonApp is used to run the update of the georeference
        basis in a regulary time. It could be programmed by the options parameter
        in the settings.py 
    """
        
    def __init__(self):
        self.stdin_path = GEOREFERENCE_DAEMON_SETTINGS['stdin']
        if not os.path.exists(self.stdin_path):
            open(self.stdin_path, 'a').close()

        self.stdout_path = GEOREFERENCE_DAEMON_SETTINGS['stdout']
        self.stderr_path = GEOREFERENCE_DAEMON_SETTINGS['stderr']
        self.pidfile_path = GEOREFERENCE_DAEMON_SETTINGS['pidfile_path']
Esempio n. 6
0
    def setUpClass(cls):   
        print '=============='
        print 'Start process modul tests ...'
        print '=============='
        
        cls.dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../../test-data')
        
        # new test data 
        cls.testData = [
            (637, 652),
            (625, 7125),
            (7741, 7133),
            (7755, 668),
            (637, 652)
        ]
        cls.size = [8383, 9089]
        cls.testGcp = [
            gdal.GCP(9.99999904632568, 48.9000015258789, 0, 637, 652),
            gdal.GCP(9.99999904632568, 48.7999992370605, 0, 625, 7125),
            gdal.GCP(10.1666669845581, 48.7999992370605,0, 7741, 7133),
            gdal.GCP(10.1666669845581, 48.9000015258789, 0, 7755, 668)
        ]
        cls.bbox = [
            [9.99999904632568, 48.7999992370605],
            [9.99999904632568, 48.9000015258789],
            [10.1666669845581, 48.9000015258789],
            [10.1666669845581, 48.7999992370605],
            [9.99999904632568, 48.7999992370605]
        ]
        cls.file = os.path.join(cls.dir,'test-mtb.tif')   
        
        # old test data    
        cls.proj =  '+proj=longlat +ellps=bessel +datum=potsdam +no_defs'
        cls.logger = createLogger('GeoreferenceTest', logging.DEBUG)
        cls.testData1 = {
            'mtb': {
                'srcFile': os.path.join(cls.dir,'test-mtb.tif'),
                'gcps': [
                    gdal.GCP(9.999999047035397, 48.90000152653428, 0, 637, 652),
                    gdal.GCP(9.999999047069203, 48.79999923774097, 0, 625, 7125),
                    gdal.GCP(10.166666985288636, 48.79999923771421,0, 7741, 7133),
                    gdal.GCP(10.166666985254116, 48.90000152650738, 0, 7755, 668)
#                     gdal.GCP(10.109429790857027, 48.872275997293876, 0, 5274, 2654),
#                     gdal.GCP(10.097754297988152, 48.83477141386819, 0, 4724, 5086),
#                     gdal.GCP(10.137929188012347, 48.85194532840476, 0, 2434, 3808)
                ],
                'bbox': [
                    [9.999999047035397, 48.79999923774097],
                    [9.999999047035397, 48.90000152653428],
                    [10.166666985288636, 48.90000152653428],
                    [10.166666985288636, 48.79999923774097],
                    [9.999999047035397, 48.79999923774097]
                ],
                'clip': [
                    [637, 652],
                    [625, 7125],
                    [7741, 7133],
                    [7755, 668],
                    [637, 652]
                ],
                'srs': 4314
            }
        }
        cls.gcps = []
        cls.gcps.append(gdal.GCP(21.1666679382324, 55.7999992370605, 0, 7057,7348))
        cls.gcps.append(gdal.GCP(21.1666679382324, 55.9000015258789, 0, 7043,879))
        cls.gcps.append(gdal.GCP(20.9999980926514, 55.7999992370605, 0, 985,7331))
        cls.gcps.append(gdal.GCP(20.9999980926514, 55.9000015258789, 0, 969,869))
        cls.boundingbox = [[20.9999980926514,55.7999992370605],[20.9999980926514,55.9000015258789],
                           [21.1666679382324,55.9000015258789],[21.1666679382324,55.7999992370605],
                           [20.9999980926514,55.7999992370605]]
Esempio n. 7
0
    """
    logger.info('Check for unprocessed update georeference jobs ...')
    unprocessedJobs = Georeferenzierungsprozess.getUnprocessedObjectsOfTypeUpdate(dbsession)
    counter = 0
    for job in unprocessedJobs:
        logger.info('Start processing of a "update" georeference process with id - %s'%job.id)
        georefObj = Georeferenzierungsprozess.clearRaceConditions(job, dbsession)

        # get active georeference process and deactive him, if exist
        activeGeorefProcess = Georeferenzierungsprozess.getActualGeoreferenceProcessForMapId(georefObj.mapid, dbsession)
        mapObj = Map.by_id(georefObj.mapid, dbsession)

        if activeGeorefProcess:
            logger.info('Deactivate georeference processes with id %s ...'%activeGeorefProcess.id)
            deactivate(activeGeorefProcess, mapObj, dbsession, logger)

        logger.info('Activate georeference processes with id %s ...'%georefObj.id)
        activate(georefObj, mapObj, dbsession, logger)

        logger.info('Finish processing of a "update" georeference process with id - %s'%job.id)
        counter += 1

    return counter

""" Main """
if __name__ == '__main__':
    logger = createLogger('test', logging.DEBUG)
    logger.info('Looking for pending georeference processes ...')
    dbsession = initializeDb(getPostgresEngineString(DBCONFIG_PARAMS))
    updateDataBasis(dbsession, logger, TEST_MODE)
    dbsession.commit()
 def setUpClass(cls):
     print '=============='
     print 'Start georeferenceupdate tests ...'
     print '=============='
     cls.logger = createLogger('GeoreferenceUpdateTest', logging.DEBUG)
Esempio n. 9
0
    parser.add_argument('--log_file', help='define a log file')
    parser.add_argument(
        '--tmp_dir',
        default='/tmp',
        help='define directory for temporary files (default: /tmp')
    parser.add_argument('--vrt_dir',
                        default='/tmp',
                        help='define directory for vrt files (default: /tmp')
    arguments = parser.parse_args()

    # create logger
    if arguments.log_file:
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        sqlalchemy_logger = createLogger('sqlalchemy.engine',
                                         logging.DEBUG,
                                         logFile=''.join(arguments.log_file),
                                         formatter=formatter)
        logger = createLogger('UpdateVRT',
                              logging.DEBUG,
                              logFile=''.join(arguments.log_file),
                              formatter=formatter)
    else:
        sqlalchemy_logger = createLogger('sqlalchemy.engine', logging.WARN)
        logger = createLogger('UpdateVRT', logging.DEBUG)

    # parse parameter parameters
    database_params = {}
    if arguments.host:
        database_params['host'] = arguments.host
    if arguments.user:
        database_params['user'] = arguments.user
Esempio n. 10
0
            job, dbsession)

        # get active georeference process and deactive him, if exist
        activeGeorefProcess = Georeferenzierungsprozess.getActualGeoreferenceProcessForMapId(
            georefObj.mapid, dbsession)
        mapObj = Map.by_id(georefObj.mapid, dbsession)

        if activeGeorefProcess:
            logger.info('Deactivate georeference processes with id %s ...' %
                        activeGeorefProcess.id)
            deactivate(activeGeorefProcess, mapObj, dbsession, logger)

        logger.info('Activate georeference processes with id %s ...' %
                    georefObj.id)
        activate(georefObj, mapObj, dbsession, logger)

        logger.info(
            'Finish processing of a "update" georeference process with id - %s'
            % job.id)
        counter += 1

    return counter


""" Main """
if __name__ == '__main__':
    logger = createLogger('test', logging.DEBUG)
    logger.info('Looking for pending georeference processes ...')
    dbsession = initializeDb(getPostgresEngineString(DBCONFIG_PARAMS))
    updateDataBasis(dbsession, logger, TEST_MODE)
    dbsession.commit()
Esempio n. 11
0
 def setUpClass(cls):
     print '=============='
     print 'Start GernicJobsTest tests ...'
     print '=============='
     cls.logger = createLogger('GernicJobsTest', logging.DEBUG)
     cls.dbsession = initializeDb(getPostgresEngineString(DBCONFIG_PARAMS_TESTING))
Esempio n. 12
0
    # parse command line
    parser = argparse.ArgumentParser(description='Parse the key/value pairs from the command line!')
    parser.add_argument('--mode', type=str, default='testing', help='Run in "production" or "testing" mode. Without mode parameter it run\'s in testing mode.')
    parser.add_argument('--host', help='host for messtischblattdb')
    parser.add_argument('--user', help='user for messtischblattdb')
    parser.add_argument('--password', help='password for messtischblattdb')
    parser.add_argument('--db', help='db name for messtischblattdb')
    parser.add_argument('--log_file', help='define a log file')
    parser.add_argument('--tmp_dir', default='/tmp', help='define directory for temporary files (default: /tmp')
    parser.add_argument('--vrt_dir', default='/tmp', help='define directory for vrt files (default: /tmp')
    arguments = parser.parse_args()
    
    # create logger
    if arguments.log_file:
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        sqlalchemy_logger = createLogger('sqlalchemy.engine', logging.DEBUG, logFile=''.join(arguments.log_file), formatter=formatter)     
        logger = createLogger('UpdateVRT', logging.DEBUG, logFile=''.join(arguments.log_file), formatter=formatter)
    else: 
        sqlalchemy_logger = createLogger('sqlalchemy.engine', logging.WARN)
        logger = createLogger('UpdateVRT', logging.DEBUG)   

    # parse parameter parameters
    database_params = {}
    if arguments.host:
        database_params['host'] = arguments.host
    if arguments.user:
        database_params['user'] = arguments.user
    if arguments.password:
        database_params['password'] = arguments.password
    if arguments.db:
        database_params['db'] = arguments.db
Esempio n. 13
0
sys.path.insert(0, BASE_PATH)
sys.path.append(BASE_PATH_PARENT)
sys.path.append(ROOT_PATH)

# Initialize the logger
if not os.path.exists(GEOREFERENCE_DAEMON_LOGGER['file']):
    open(GEOREFERENCE_DAEMON_LOGGER['file'], 'a').close()

formatter = logging.Formatter(GEOREFERENCE_DAEMON_LOGGER['formatter'])
handler = TimedRotatingFileHandler(GEOREFERENCE_DAEMON_LOGGER['file'],
                                   when='d',
                                   interval=1,
                                   backupCount=14)
handler.setFormatter(formatter)
LOGGER = createLogger(GEOREFERENCE_DAEMON_LOGGER['name'],
                      GEOREFERENCE_DAEMON_LOGGER['level'],
                      handler=handler)


class GeoreferenceDaemonApp():
    """ The GeoreferenceDaemonApp is used to run the update of the georeference
        basis in a regulary time. It could be programmed by the options parameter
        in the settings.py 
    """
    def __init__(self):
        self.stdin_path = GEOREFERENCE_DAEMON_SETTINGS['stdin']
        if not os.path.exists(self.stdin_path):
            open(self.stdin_path, 'a').close()

        self.stdout_path = GEOREFERENCE_DAEMON_SETTINGS['stdout']
        self.stderr_path = GEOREFERENCE_DAEMON_SETTINGS['stderr']