MapProxy 1.16.1__py3-none-any.whl

mapproxy/proj.py

@@ -0,0 +1,302 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+ctypes based replacement of pyroj (with pyproj fallback) of the old PROJ 4 API.
+
+This module implements the `Proj`, `transform` and `set_datapath` class/functions. This
+module is a drop-in replacement for pyproj. It does implement just enough to work for
+MapProxy, i.e. there is no numpy support, etc.
+
+It uses the C libproj library. If the library could not be found/loaded it will fallback
+to pyroj. You can force the usage of either backend by setting the environment variables
+MAPPROXY_USE_LIBPROJ or MAPPROXY_USE_PYPROJ to any value.
+
+The new PROJ >=5 API is only supported via pyproj. See USE_PROJ4_API.
+
+"""
+from __future__ import print_function
+
+import os
+import sys
+from mapproxy.util.lib import load_library
+
+import ctypes
+from ctypes import (
+   c_void_p,
+   c_char_p,
+   c_int,
+   c_double,
+   c_long,
+   POINTER,
+   create_string_buffer,
+   addressof,
+)
+
+c_double_p = POINTER(c_double)
+FINDERCMD = ctypes.CFUNCTYPE(c_char_p, c_char_p)
+
+import logging
+log_system = logging.getLogger('mapproxy.system')
+
+__all__ = ['Proj', 'transform', 'set_datapath', 'ProjError']
+
+
+def init_libproj():
+    libproj = load_library('libproj')
+
+    if libproj is None: return
+
+    if hasattr(libproj, 'proj_create'):
+       log_system.warning('Found libproj >=5. Using this library without pyproj is '
+                          'deprecated and not fully supported. Please install pyproj >= 2.')
+
+    libproj.pj_init_plus.argtypes = [c_char_p]
+    libproj.pj_init_plus.restype = c_void_p
+
+    libproj.pj_is_latlong.argtypes = [c_void_p]
+    libproj.pj_is_latlong.restype = c_int
+
+
+    libproj.pj_get_def.argtypes = [c_void_p, c_int]
+    libproj.pj_get_def.restype = c_void_p
+
+    libproj.pj_strerrno.argtypes = [c_int]
+    libproj.pj_strerrno.restype = c_char_p
+
+    libproj.pj_get_errno_ref.argtypes = []
+    libproj.pj_get_errno_ref.restype = POINTER(c_int)
+
+    # free proj objects
+    libproj.pj_free.argtypes = [c_void_p]
+    # free() wrapper
+    libproj.pj_dalloc.argtypes = [c_void_p]
+
+    libproj.pj_transform.argtypes = [c_void_p, c_void_p, c_long, c_int,
+                                     c_double_p, c_double_p, c_double_p]
+    libproj.pj_transform.restype = c_int
+
+    if hasattr(libproj, 'pj_set_searchpath'):
+        libproj.pj_set_searchpath.argtypes = [c_int, POINTER(c_char_p)]
+        libproj.pj_set_finder.argtypes = [FINDERCMD]
+
+    return libproj
+
+class SearchPath(object):
+    def __init__(self):
+        self.path = None
+        self.finder_results = {}
+
+    def clear(self):
+        self.path = None
+        self.finder_results = {}
+
+    def set_searchpath(self, path):
+        self.clear()
+        if path is not None:
+            path = path.encode(sys.getfilesystemencoding() or 'utf-8')
+        self.path = path
+
+    def finder(self, name):
+        if self.path is None:
+            return None
+
+        if name in self.finder_results:
+            result = self.finder_results[name]
+        else:
+            sysname = os.path.join(self.path, name)
+            result = self.finder_results[name] = create_string_buffer(sysname)
+
+        return addressof(result)
+
+# search_path and finder_func must be defined in module
+# context to avoid garbage collection
+search_path = SearchPath()
+finder_func = FINDERCMD(search_path.finder)
+_finder_callback_set = False
+
+class ProjError(RuntimeError):
+    pass
+
+class ProjInitError(ProjError):
+    pass
+
+def try_pyproj4_import():
+    try:
+        from pyproj import Proj, transform, set_datapath
+    except ImportError:
+        return False
+    log_system.info('using pyproj with old Proj4 API for coordinate transformation')
+    return Proj, transform, set_datapath
+
+def try_pyproj_import():
+    try:
+        from pyproj import CRS
+        from pyproj.transformer import Transformer
+        from pyproj.datadir import set_data_dir
+    except ImportError:
+        return False
+    log_system.info('using pyproj for coordinate transformation')
+    return CRS, Transformer, set_data_dir
+
+def try_libproj_import():
+    libproj = init_libproj()
+
+    if libproj is None:
+        return False
+
+    log_system.info('using libproj for coordinate transformation')
+
+    RAD_TO_DEG = 57.29577951308232
+    DEG_TO_RAD = .0174532925199432958
+
+    class Proj(object):
+        def __init__(self, proj_def=None, init=None):
+            if init:
+                self._proj = libproj.pj_init_plus(b'+init=' + init.encode('ascii'))
+            else:
+                self._proj = libproj.pj_init_plus(proj_def.encode('ascii'))
+            if not self._proj:
+                errno = libproj.pj_get_errno_ref().contents
+                raise ProjInitError('error initializing Proj(proj_def=%r, init=%r): %s' %
+                    (proj_def, init, libproj.pj_strerrno(errno)))
+
+            self.srs = self._srs()
+            self._latlong = bool(libproj.pj_is_latlong(self._proj))
+
+        def is_latlong(self):
+            """
+            >>> Proj(init='epsg:4326').is_latlong()
+            True
+            >>> Proj(init='epsg:4258').is_latlong()
+            True
+            >>> Proj(init='epsg:31467').is_latlong()
+            False
+            >>> Proj('+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 '
+            ...      '+lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m '
+            ...      '+nadgrids=@null +no_defs').is_latlong()
+            False
+            """
+            return self._latlong
+
+        def _srs(self):
+            res = libproj.pj_get_def(self._proj, 0)
+            srs_def = ctypes.c_char_p(res).value
+            libproj.pj_dalloc(res)
+            return srs_def
+
+        def __del__(self):
+            if self._proj and libproj:
+                libproj.pj_free(self._proj)
+                self._proj = None
+
+    def transform(from_srs, to_srs, x, y, z=None):
+        if from_srs == to_srs:
+            return (x, y) if z is None else (x, y, z)
+
+        if isinstance(x, (float, int)):
+            x = [x]
+            y = [y]
+        assert len(x) == len(y)
+
+        if from_srs.is_latlong():
+            x = [x*DEG_TO_RAD for x in x]
+            y = [y*DEG_TO_RAD for y in y]
+
+        x = (c_double * len(x))(*x)
+        y = (c_double * len(y))(*y)
+        if z is not None:
+            z = (c_double * len(z))(*z)
+        else:
+            # use explicit null pointer instead of None
+            # http://bugs.python.org/issue4606
+            z = c_double_p()
+
+        res = libproj.pj_transform(from_srs._proj, to_srs._proj,
+                                   len(x), 0, x, y, z)
+
+        if res:
+            raise ProjError(libproj.pj_strerrno(res))
+
+        if to_srs.is_latlong():
+            x = [x*RAD_TO_DEG for x in x]
+            y = [y*RAD_TO_DEG for y in y]
+        else:
+            x = x[:]
+            y = y[:]
+
+        if len(x) == 1:
+            x = x[0]
+            y = y[0]
+            z = z[0] if z else None
+
+        return (x, y) if z is None else (x, y, z)
+
+    def set_datapath(path):
+        global _finder_callback_set
+        if not _finder_callback_set:
+            libproj.pj_set_finder(finder_func)
+            _finder_callback_set = True
+        search_path.set_searchpath(path)
+
+    return Proj, transform, set_datapath
+
+
+proj_imports = []
+
+if 'MAPPROXY_USE_LIBPROJ' in os.environ:
+    proj_imports = [try_libproj_import]
+
+if 'MAPPROXY_USE_PYPROJ' in os.environ:
+    proj_imports = [try_pyproj_import, try_pyproj4_import]
+
+if not proj_imports:
+    if sys.platform == 'win32':
+        # prefer pyproj on windows
+        proj_imports = [try_pyproj_import, try_pyproj4_import, try_libproj_import]
+    else:
+        proj_imports = [try_pyproj_import, try_libproj_import, try_pyproj4_import]
+
+# try different imports in previously defined order
+for try_import in proj_imports:
+    if try_import == try_pyproj_import:
+        res = try_import()
+        if res:
+            CRS, Transformer, set_datapath = res
+            Proj, transform = None, None
+            USE_PROJ4_API = False
+            break
+    else:
+        res = try_import()
+        if res:
+            Proj, transform, set_datapath = res
+            CRS, Transformer = None, None
+            USE_PROJ4_API = True
+            break
+else:
+    raise ImportError('could not find pyproj (Python library) or libproj (C library, deprecated)')
+
+if __name__ == '__main__':
+
+    prj1 = Proj(init='epsg:4326')
+    prj2 = Proj(init='epsg:31467')
+
+    coords = [(8.2, 8.22, 8.3), (53.1, 53.15, 53.2)]
+    # coords = [(8, 9, 10), (50, 50, 50)]
+    print(coords)
+    coords = transform(prj1, prj2, *coords)
+    print(coords)
+    coords = transform(prj2, prj1, *coords)
+    print(coords)

mapproxy/request/__init__.py

@@ -0,0 +1,18 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 Omniscale <http://omniscale.de>
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#    http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mapproxy.request.base import Request, url_decode
+
+__all__ = ['Request', 'url_decode']

mapproxy/request/arcgis.py

@@ -0,0 +1,259 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from functools import partial as fp
+from mapproxy.compat import string_type
+from mapproxy.compat.modules import urlparse
+from mapproxy.request.base import RequestParams, BaseRequest
+from mapproxy.srs import make_lin_transf
+
+class ArcGISExportRequestParams(RequestParams):
+    """
+    Supported params f, bbox(required), size, dpi, imageSR, bboxSR, format, layerDefs,
+    layers, transparent, time, layerTimeOptions.
+
+    @param layers: Determines which layers appear on the exported map. There are
+                   four ways to specify layers: show, hide, include, exclude.
+                   (ex show:1,2)
+    """
+    def _get_format(self):
+        """
+        The requested format as string (w/o any 'image/', 'text/', etc prefixes)
+        """
+        return self["format"]
+    def _set_format(self, format):
+        self["format"] = format.rsplit("/")[-1]
+    format = property(_get_format, _set_format)
+    del _get_format
+    del _set_format
+
+    def _get_bbox(self):
+        """
+        ``bbox`` as a tuple (minx, miny, maxx, maxy).
+        """
+        if 'bbox' not in self.params or self.params['bbox'] is None:
+            return None
+        points = [float(val) for val in self.params['bbox'].split(',')]
+        return tuple(points[:4])
+    def _set_bbox(self, value):
+        if value is not None and not isinstance(value, string_type):
+            value = ','.join(str(x) for x in value)
+        self['bbox'] = value
+    bbox = property(_get_bbox, _set_bbox)
+    del _get_bbox
+    del _set_bbox
+
+    def _get_size(self):
+        """
+        Size of the request in pixel as a tuple (width, height),
+        or None if one is missing.
+        """
+        if 'size' not in self.params or self.params['size'] is None:
+            return None
+        dim = [float(val) for val in self.params['size'].split(',')]
+        return tuple(dim[:2])
+    def _set_size(self, value):
+        if value is not None and not isinstance(value, string_type):
+            value = ','.join(str(x) for x in value)
+        self['size'] = value
+    size = property(_get_size, _set_size)
+    del _get_size
+    del _set_size
+
+    def _get_srs(self, key):
+        return self.params.get(key, None)
+    def _set_srs(self, srs, key):
+        if hasattr(srs, 'srs_code'):
+            code = srs.srs_code
+        else:
+            code = srs
+        self.params[key] = code.rsplit(":", 1)[-1]
+
+    bboxSR = property(fp(_get_srs, key="bboxSR"), fp(_set_srs, key="bboxSR"))
+    imageSR = property(fp(_get_srs, key="imageSR"), fp(_set_srs, key="imageSR"))
+    del _get_srs
+    del _set_srs
+
+
+
+class ArcGISIdentifyRequestParams(ArcGISExportRequestParams):
+    def _get_format(self):
+        """
+        The requested format as string (w/o any 'image/', 'text/', etc prefixes)
+        """
+        return self["format"]
+    def _set_format(self, format):
+        self["format"] = format.rsplit("/")[-1]
+    format = property(_get_format, _set_format)
+    del _get_format
+    del _set_format
+
+    def _get_bbox(self):
+        """
+        ``bbox`` as a tuple (minx, miny, maxx, maxy).
+        """
+        if 'mapExtent' not in self.params or self.params['mapExtent'] is None:
+            return None
+        points = [float(val) for val in self.params['mapExtent'].split(',')]
+        return tuple(points[:4])
+    def _set_bbox(self, value):
+        if value is not None and not isinstance(value, string_type):
+            value = ','.join(str(x) for x in value)
+        self['mapExtent'] = value
+    bbox = property(_get_bbox, _set_bbox)
+    del _get_bbox
+    del _set_bbox
+
+    def _get_size(self):
+        """
+        Size of the request in pixel as a tuple (width, height),
+        or None if one is missing.
+        """
+        if 'imageDisplay' not in self.params or self.params['imageDisplay'] is None:
+            return None
+        dim = [float(val) for val in self.params['imageDisplay'].split(',')]
+        return tuple(dim[:2])
+    def _set_size(self, value):
+        if value is not None and not isinstance(value, string_type):
+            value = ','.join(str(x) for x in value) + ',96'
+        self['imageDisplay'] = value
+    size = property(_get_size, _set_size)
+    del _get_size
+    del _set_size
+
+    def _get_pos(self):
+        size = self.size
+        vals = self['geometry'].split(',')
+        x, y = float(vals[0]), float(vals[1])
+        return make_lin_transf(self.bbox, (0, 0, size[0], size[1]))((x, y))
+
+    def _set_pos(self, value):
+        size = self.size
+        req_coord = make_lin_transf((0, 0, size[0], size[1]), self.bbox)(value)
+        self['geometry'] = '%f,%f' % req_coord
+    pos = property(_get_pos, _set_pos)
+    del _get_pos
+    del _set_pos
+
+    @property
+    def srs(self):
+        srs = self.params.get('sr', None)
+        if srs:
+            return 'EPSG:%s' % srs
+
+    @srs.setter
+    def srs(self, srs):
+        if hasattr(srs, 'srs_code'):
+            code = srs.srs_code
+        else:
+            code = srs
+        self.params['sr'] = code.rsplit(':', 1)[-1]
+
+class ArcGISRequest(BaseRequest):
+    request_params = ArcGISExportRequestParams
+    fixed_params = {"f": "image"}
+
+    def __init__(self, param=None, url='', validate=False, http=None):
+        BaseRequest.__init__(self, param, url, validate, http)
+
+        self.url = rest_endpoint(url)
+
+    def copy(self):
+        return self.__class__(param=self.params.copy(), url=self.url)
+
+    @property
+    def query_string(self):
+        params = self.params.copy()
+        for key, value in self.fixed_params.items():
+            params[key] = value
+        return params.query_string
+
+
+class ArcGISIdentifyRequest(BaseRequest):
+    request_params = ArcGISIdentifyRequestParams
+    fixed_params = {'geometryType': 'esriGeometryPoint'}
+    def __init__(self, param=None, url='', validate=False, http=None):
+        BaseRequest.__init__(self, param, url, validate, http)
+
+        self.url = rest_identify_endpoint(url)
+
+    def copy(self):
+        return self.__class__(param=self.params.copy(), url=self.url)
+
+    @property
+    def query_string(self):
+        params = self.params.copy()
+        for key, value in self.fixed_params.items():
+            params[key] = value
+        return params.query_string
+
+
+
+def create_identify_request(req_data, param):
+    req_data = req_data.copy()
+
+    # Pop the URL off the request data.
+    url = req_data['url']
+    del req_data['url']
+
+    return ArcGISIdentifyRequest(url=url, param=req_data)
+
+def create_request(req_data, param):
+    req_data = req_data.copy()
+
+    # Pop the URL off the request data.
+    url = req_data['url']
+    del req_data['url']
+
+    if 'format' in param:
+        req_data['format'] = param['format']
+
+    if 'transparent' in req_data:
+        # Convert boolean to a string.
+        req_data['transparent'] = str(req_data['transparent'])
+
+    return ArcGISRequest(url=url, param=req_data)
+
+
+def rest_endpoint(url):
+    parts = urlparse.urlsplit(url)
+    path = parts.path.rstrip('/').split('/')
+
+    if path[-1] in ('export', 'exportImage'):
+        if path[-2] == 'MapServer':
+            path[-1] = 'export'
+        elif path[-2] == 'ImageServer':
+            path[-1] = 'exportImage'
+    elif path[-1] == 'MapServer':
+        path.append('export')
+    elif path[-1] == 'ImageServer':
+        path.append('exportImage')
+
+    parts = parts[0], parts[1], '/'.join(path), parts[3], parts[4]
+    return urlparse.urlunsplit(parts)
+
+
+def rest_identify_endpoint(url):
+    parts = urlparse.urlsplit(url)
+    path = parts.path.rstrip('/').split('/')
+
+    if path[-1] in ('export', 'exportImage'):
+        path[-1] = 'identify'
+    elif path[-1] in ('MapServer', 'ImageServer'):
+        path.append('identify')
+
+    parts = parts[0], parts[1], '/'.join(path), parts[3], parts[4]
+    return urlparse.urlunsplit(parts)
+