コード例 #1
0
    def __coord_transform__(self, coord, source_crs):
        """
        Transforms the specified coordinates from the specified CRS to the configured target
        CRS and creates a point geometry.

        Args:
            coord (tuple): The coordinates to transform (x, y).
            source_crs (intorstr): The source CRS

        Returns:
            shapely.geometry.Point or shapely.geometry.Polygon: The transformed coordinates as
            Point.
        """
        log.debug('----- Transforming Coordinates: -----')
        log.debug('----- X/Y Coordinates: {0} -----'.format(coord))
        epsg = 'epsg:{0}'
        srid = Config.get('srid')
        log.debug('----- srid from config (to_srs): {0} -----'.format(srid))
        log.debug(
            '----- srid from source (from_srs): {0} -----'.format(source_crs))
        rp = Reprojector()
        x, y = rp.transform(coord,
                            from_srs=epsg.format(source_crs),
                            to_srs=epsg.format(srid))
        log.debug(
            '----- X/Y coordinates after transformation: ({0}, {1}) -----'.
            format(x, y))
        return Point(x, y)
コード例 #2
0
 def __init__(self,
              session,
              model,
              geometry_type,
              srid,
              arc_max_diff=0.001,
              arc_precision=3):
     self._session = session
     self._model = model
     self._geometry_type = geometry_type
     self._to_srs = srid
     self._arc_max_diff = arc_max_diff
     self._arc_precision = arc_precision
     self._log = logging.getLogger('import_federal_topic')
     self._reprojector = Reprojector()
コード例 #3
0
    def read(self, street_name, zip_code, street_number):
        """
        Queries an address using the federal GeoAdmin API location search.

        Args:
            street_name (unicode): The name of the street for the desired address.
            zip_code (int): The postal zipcode for the desired address.
            street_number (unicode): The house or so called street number of the desired address.
        """
        headers = {
            'Referer':
            'http://bl.ch'  # TODO: Remove this header when referer is not needed anymore!
        }
        params = {
            'type':
            self._type,
            'origins':
            self._origins,
            'searchText':
            u'{0} {1} {2}'.format(zip_code, street_name, street_number)
        }
        response = requests.get(self._geoadmin_url,
                                params=params,
                                proxies=self._proxies,
                                headers=headers)
        if response.status_code == requests.codes.ok:
            rp = Reprojector()
            srid = Config.get('srid')
            self.records = list()
            data = response.json()
            if 'results' in data:
                for item in data.get('results'):
                    attrs = item.get('attrs')
                    if isinstance(attrs,
                                  dict) and attrs.get('origin') == 'address':
                        x, y = rp.transform(
                            (attrs.get('lon'), attrs.get('lat')), to_srs=srid)
                        self.records.append(
                            AddressRecord(street_name=street_name,
                                          zip_code=zip_code,
                                          street_number=street_number,
                                          geom='POINT({x} {y})'.format(x=x,
                                                                       y=y)))
        else:
            response.raise_for_status()
コード例 #4
0
ファイル: webservice.py プロジェクト: pfirpfel/pyramid_oereb
    def __coord_transform__(self, coord, source_crs):
        """
        Transforms the specified coordinates from the specified CRS to the configured target CRS and creates a
        point geometry.

        Args:
            coord (tuple): The coordinates to transform (x, y).
            source_crs (intorstr): The source CRS

        Returns:
            shapely.geometry.Point or shapely.geometry.Polygon: The transformed coordinates as
            Point.
        """
        epsg = 'epsg:{0}'
        srid = Config.get('srid')
        rp = Reprojector()
        x, y = rp.transform(coord, from_srs=epsg.format(source_crs), to_srs=epsg.format(srid))
        return Point(x, y)
コード例 #5
0
    def read(self, params, street_name, zip_code, street_number):
        """
        Queries an address using the federal GeoAdmin API location search.

        Args:
            params (pyramid_oereb.views.webservice.Parameter): The parameters of the extract request.
            street_name (unicode): The name of the street for the desired address.
            zip_code (int): The postal zipcode for the desired address.
            street_number (unicode): The house or so called street number of the desired address.
        """
        headers = {}
        if self._referer is not None:
            headers.update({'Referer': self._referer})
        request_params = {
            'type':
            self._type,
            'origins':
            self._origins,
            'searchText':
            u'{0} {1} {2}'.format(zip_code, street_name, street_number)
        }
        response = requests.get(self._geoadmin_url,
                                params=request_params,
                                proxies=self._proxies,
                                headers=headers)
        if response.status_code == requests.codes.ok:
            rp = Reprojector()
            srid = Config.get('srid')
            self.records = list()
            data = response.json()
            if 'results' in data:
                for item in data.get('results'):
                    attrs = item.get('attrs')
                    if isinstance(attrs,
                                  dict) and attrs.get('origin') == 'address':
                        x, y = rp.transform(
                            (attrs.get('lon'), attrs.get('lat')), to_srs=srid)
                        self.records.append(
                            AddressRecord(street_name=street_name,
                                          zip_code=zip_code,
                                          street_number=street_number,
                                          geom=Point(x, y)))
        else:
            response.raise_for_status()
コード例 #6
0
class Geometry(object):

    TAG_POINT_LV03 = 'Punkt_LV03'
    TAG_POINT_LV95 = 'Punkt_LV95'
    TAG_LINE_LV03 = 'Linie_LV03'
    TAG_LINE_LV95 = 'Linie_LV95'
    TAG_AREA_LV03 = 'Flaeche_LV03'
    TAG_AREA_LV95 = 'Flaeche_LV95'
    TAG_LAW_STATUS = 'Rechtsstatus'
    TAG_PUBLISHED_FROM = 'publiziertAb'
    TAG_GEO_METADATA = 'MetadatenGeobasisdaten'
    TAG_PUBLIC_LAW_RESTRICTION = 'Eigentumsbeschraenkung'
    TAG_RESPONSIBLE_OFFICE = 'ZustaendigeStelle'
    TAG_COORD = 'COORD'
    TAG_ARC = 'ARC'

    def __init__(self,
                 session,
                 model,
                 geometry_type,
                 srid,
                 arc_max_diff=0.001,
                 arc_precision=3):
        self._session = session
        self._model = model
        self._geometry_type = geometry_type
        self._to_srs = srid
        self._arc_max_diff = arc_max_diff
        self._arc_precision = arc_precision
        self._log = logging.getLogger('import_federal_topic')
        self._reprojector = Reprojector()

    def parse(self, geometry):  # pragma: no cover
        instance = self._model(
            id=geometry.attrib['TID'],
            law_status=parse_string(geometry, self.TAG_LAW_STATUS),
            published_from=parse_string(geometry, self.TAG_PUBLISHED_FROM),
            geo_metadata=parse_string(geometry, self.TAG_GEO_METADATA),
            public_law_restriction_id=parse_ref(
                geometry, self.TAG_PUBLIC_LAW_RESTRICTION),
            office_id=parse_ref(geometry, self.TAG_RESPONSIBLE_OFFICE),
            geom=self._parse_geom(geometry))
        self._session.add(instance)

    def _parse_geom(self, geometry):
        geom_type = self._geometry_type.upper()
        geom = None

        # Check for LV95 geometry
        for element in geometry:
            tag = get_tag(element)
            if tag == self.TAG_POINT_LV95:
                geom = self._parse_point(element, 2056)
            elif tag == self.TAG_LINE_LV95:
                geom = self._parse_line(element, 2056)
            elif tag == self.TAG_AREA_LV95:
                geom = self._parse_area(element, 2056)

        # Check for LV03 geometry as fallback
        if geom is None:
            for element in geometry:
                tag = get_tag(element)
                if tag == self.TAG_POINT_LV03:
                    geom = self._parse_point(element, 21781)
                elif tag == self.TAG_LINE_LV03:
                    geom = self._parse_line(element, 21781)
                elif tag == self.TAG_AREA_LV03:
                    geom = self._parse_area(element, 21781)

        # Wrap in collection if necessary
        if geom is not None:
            if geom_type == 'MULTIPOINT':
                geom = MultiPoint([geom])
            elif geom_type == 'MULTILINESTRING':
                geom = MultiLineString([geom])
            elif geom_type == 'MULTIPOLYGON':
                geom = MultiPolygon([geom])
            elif geom_type == 'GEOMETRYCOLLECTION':
                geom = GeometryCollection([geom])

        # Return geometry or None
        return None if geom is None else from_shape(geom, srid=2056)

    def _parse_coord(self, coord, srs):
        p = dict()
        for c in coord:
            if get_tag(c) == 'C1':
                p['x'] = float(c.text)
            elif get_tag(c) == 'C2':
                p['y'] = float(c.text)
        if srs == self._to_srs:
            return p['x'], p['y']
        else:
            return self._reprojector.transform((p['x'], p['y']),
                                               from_srs=srs,
                                               to_srs=self._to_srs)

    def _parse_point(self, point, srs):
        for coord in point:
            return Point(self._parse_coord(coord, srs))
        return None

    def _parse_line(self, line, srs):
        for polyline in line:
            coords = list()
            for coord in polyline:
                tag = get_tag(coord)
                if tag == self.TAG_COORD:
                    coords.append(self._parse_coord(coord, srs))
                elif tag == self.TAG_ARC:
                    coords.extend(self._parse_arc(coord, coords[-1], srs))
                else:
                    self._log.warning(
                        'Found unsupported geometry element: {0}'.format(tag))

            return LineString(coords)
        return None

    def _parse_area(self, area, srs):
        for surface in area:
            boundaries = list()
            for boundary in surface:
                boundaries.append(self._parse_line(boundary, srs))
            exterior = boundaries[0].coords
            if len(boundaries) > 1:
                interiors = [interior.coords for interior in boundaries[1:]]
            else:
                interiors = None
            return Polygon(shell=exterior, holes=interiors)
        return None

    def _parse_arc(self, arc, start_point, srs):
        e = dict()
        a = dict()
        for element in arc:
            tag = get_tag(element)
            if tag == 'C1':
                e['x'] = float(element.text)
            elif tag == 'C2':
                e['y'] = float(element.text)
            elif tag == 'A1':
                a['x'] = float(element.text)
            elif tag == 'A2':
                a['y'] = float(element.text)
        if srs == self._to_srs:
            arc_point = (a['x'], a['y'])
            end_point = (e['x'], e['y'])
        else:
            arc_point = self._reprojector.transform((a['x'], a['y']),
                                                    from_srs=srs,
                                                    to_srs=self._to_srs)
            end_point = self._reprojector.transform((e['x'], e['y']),
                                                    from_srs=srs,
                                                    to_srs=self._to_srs)
        return stroke_arc(start_point, arc_point, end_point,
                          self._arc_max_diff, self._arc_precision)
コード例 #7
0
import json
from pyreproj import Reprojector

# defining projection
rp = Reprojector()
transform = rp.get_transformation_function(from_srs='epsg:25833', to_srs=4326)

# defining output files
coords = open("coords.json", "a")
districts = open("districts.json", "a")

# loading EPSG25833 data
INPUT_FILE = './ortsteil.json'
ortsfile = open(INPUT_FILE)
ortsdata = json.load(ortsfile)

# Example of JSON access
# mitte_name = ortsdata['FeatureCollection']['featureMember'][0]['re_ortsteil']['spatial_alias']['__text']
# mitte_loc = ortsdata['FeatureCollection']['featureMember'][0]['re_ortsteil']['spatial_geometry']['Polygon']['exterior']['LinearRing']['posList']['__text']

# Example projection
# mitte_loc_lst = mitte_loc.split()
# mitte_loc_pairs = [mitte_loc_lst[i:i+2] for i in range(0,len(mitte_loc_lst),2)]
# for i in mitte_loc_pairs:
#    lat_lng = transform(i[0], i[1])
#    print("{ lat: " + str(lat_lng[0]) + ", lng: " + str(lat_lng[1]) + " },")

for ortsteil in ortsdata['FeatureCollection']['featureMember']:
    name = ortsteil['re_ortsteil']['spatial_alias']['__text']
    districts.write(name + ",\n")
    coords.write("// " + name + "\n")
コード例 #8
0
 def __init__(self, crsEpsg):
     self.crsEpsg = crsEpsg
     rp = Reprojector()
     self.transform_fce = rp.get_transformation_function(to_srs=crsEpsg)