def to_python(self, value): """Transform the value to a Geometry object.""" if value in self.empty_values: return None if not isinstance(value, GEOSGeometry): if hasattr(self.widget, 'deserialize'): try: value = self.widget.deserialize(value) except GDALException: value = None else: try: value = GEOSGeometry(value) except (GEOSException, ValueError, TypeError): value = None if value is None: raise forms.ValidationError(self.error_messages['invalid_geom'], code='invalid_geom') # Try to set the srid if not value.srid: try: value.srid = self.widget.map_srid except AttributeError: if self.srid: value.srid = self.srid return value
def from_native(self, value): import json geom = GEOSGeometry(json.dumps(value)) srid = getattr(settings, 'SRID', 4326) if 'crs' in value and value['crs'].get('type', None) == 'name': name = value['crs']['properties']['name'] if name.startswith('urn:ogc:def:crs:EPSG::'): geom.srid = int(name.replace('urn:ogc:def:crs:EPSG::', '')) if geom.srid is None: geom.srid = 4326 if geom.srid != srid: geom.transform(srid) return geom
def tile_json(request, layer_name, z, x, y): x, y, z = int(x), int(y), int(z) # mimetype, data = stache(request, layer_name, z, x, y, "mvt") # mvt_features = mvt.decode(StringIO(data)) if request.tenant is not None: cache_path = os.path.join(settings.STATIC_ROOT, "tiles", "tenant-" + str(request.tenant.pk)) else: cache_path = os.path.join(settings.STATIC_ROOT, "tiles") mvt_features = manual_mvt(cache_path, layer_name, z, x, y) features = [] for wkb, props in mvt_features: geom = GEOSGeometry(buffer(wkb)) geom.srid = 3857 geom.transform(4326) try: props['properties']['id'] = props['__id__'] except Exception as e: print('tile_json', e) feature = '{ "type": "Feature", "geometry": ' + geom.json + "," feature += ' "properties": {}'.format(json.dumps(props['properties'])) feature += '}' features.append(feature) features = ",\n".join(features) response = '{"type": "FeatureCollection", "features": [' + features + ']}' return HttpResponse(response, content_type="application/json")
def processa(p1, p2): cidade = get_ibge(p1, p2) str_ponto = 'POINT({0} {1})'.format(p2, p1) pt = GEOSGeometry(str_ponto) pt.srid = 4326 normal = automatica_proxima(pt, 'N') automatica = automatica_proxima(pt, 'A') result = { 'normal': { 'estacao': normal.Nome, 'dist': str(round(normal.distance.km, 2)), 'id': str(normal.id) }, 'automatica': { 'estacao': automatica.Nome, 'dist': str(round(automatica.distance.km, 2)), 'id': str(automatica.id), 'codigo': automatica.Codigo }, 'cidade': cidade, } return result
def get_prep_value(self, value): obj = super().get_prep_value(value) if obj is None: return None # When the input is not a geometry or raster, attempt to construct one # from the given string input. if isinstance(obj, GEOSGeometry): pass else: # Check if input is a candidate for conversion to raster or geometry. is_candidate = isinstance(obj, (bytes, str)) or hasattr( obj, '__geo_interface__') # Try to convert the input to raster. raster = self.get_raster_prep_value(obj, is_candidate) if raster: obj = raster elif is_candidate: try: obj = GEOSGeometry(obj) except (GEOSException, GDALException): raise ValueError( "Couldn't create spatial object from lookup value '%s'." % obj) else: raise ValueError( 'Cannot use object with type %s for a spatial lookup parameter.' % type(obj).__name__) # Assigning the SRID value. obj.srid = self.get_srid(obj) return obj
def get_prep_value(self, value): obj = super().get_prep_value(value) # When the input is not a geometry or raster, attempt to construct one # from the given string input. if isinstance(obj, GEOSGeometry): pass else: # Check if input is a candidate for conversion to raster or geometry. is_candidate = isinstance(obj, (bytes, str)) or hasattr(obj, '__geo_interface__') # Try to convert the input to raster. raster = self.get_raster_prep_value(obj, is_candidate) if raster: obj = raster elif is_candidate: try: obj = GEOSGeometry(obj) except (GEOSException, GDALException): raise ValueError("Couldn't create spatial object from lookup value '%s'." % obj) else: raise ValueError('Cannot use object with type %s for a spatial lookup parameter.' % type(obj).__name__) # Assigning the SRID value. obj.srid = self.get_srid(obj) return obj
def to_internal_value(self, value): import json if isinstance(value, dict): value = json.dumps(value) geom = GEOSGeometry(value) srid = getattr(settings, 'SRID', 4326) if 'crs' in value and value['crs'].get('type', None) == 'name': name = value['crs']['properties']['name'] if name.startswith('urn:ogc:def:crs:EPSG::'): geom.srid = int(name.replace('urn:ogc:def:crs:EPSG::', '')) if geom.srid is None: geom.srid = 4326 if geom.srid != srid: geom.transform(srid) return geom
def get_polygons(self, geom): result = GEOSGeometry(json.dumps(geom)) if isinstance(result, Polygon): result = MultiPolygon(result) if self.srid: result.srid = self.srid return result
def form_valid(self, form): lat = form.cleaned_data.get('lat') lng = form.cleaned_data.get('lng') wkt = "POINT({} {})".format(lng, lat) point = GEOSGeometry(wkt) point.srid = 4326 form.instance.geom = point form.save() messages.success(self.request, 'Your point was updated successfully!') return super().form_valid(form)
def test04_wkbwriter(self): wkb_w = WKBWriter() # Representations of 'POINT (5 23)' in hex -- one normal and # the other with the byte order changed. g = GEOSGeometry("POINT (5 23)") hex1 = b"010100000000000000000014400000000000003740" wkb1 = memoryview(binascii.a2b_hex(hex1)) hex2 = b"000000000140140000000000004037000000000000" wkb2 = memoryview(binascii.a2b_hex(hex2)) self.assertEqual(hex1, wkb_w.write_hex(g)) self.assertEqual(wkb1, wkb_w.write(g)) # Ensuring bad byteorders are not accepted. for bad_byteorder in (-1, 2, 523, "foo", None): # Equivalent of `wkb_w.byteorder = bad_byteorder` with self.assertRaises(ValueError): wkb_w._set_byteorder(bad_byteorder) # Setting the byteorder to 0 (for Big Endian) wkb_w.byteorder = 0 self.assertEqual(hex2, wkb_w.write_hex(g)) self.assertEqual(wkb2, wkb_w.write(g)) # Back to Little Endian wkb_w.byteorder = 1 # Now, trying out the 3D and SRID flags. g = GEOSGeometry("POINT (5 23 17)") g.srid = 4326 hex3d = b"0101000080000000000000144000000000000037400000000000003140" wkb3d = memoryview(binascii.a2b_hex(hex3d)) hex3d_srid = ( b"01010000A0E6100000000000000000144000000000000037400000000000003140" ) wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid)) # Ensuring bad output dimensions are not accepted for bad_outdim in (-1, 0, 1, 4, 423, "foo", None): with self.assertRaisesMessage( ValueError, "WKB output dimension must be 2 or 3"): wkb_w.outdim = bad_outdim # Now setting the output dimensions to be 3 wkb_w.outdim = 3 self.assertEqual(hex3d, wkb_w.write_hex(g)) self.assertEqual(wkb3d, wkb_w.write(g)) # Telling the WKBWriter to include the srid in the representation. wkb_w.srid = True self.assertEqual(hex3d_srid, wkb_w.write_hex(g)) self.assertEqual(wkb3d_srid, wkb_w.write(g))
def test04_wkbwriter(self): wkb_w = WKBWriter() # Representations of 'POINT (5 23)' in hex -- one normal and # the other with the byte order changed. g = GEOSGeometry('POINT (5 23)') hex1 = b'010100000000000000000014400000000000003740' wkb1 = memoryview(binascii.a2b_hex(hex1)) hex2 = b'000000000140140000000000004037000000000000' wkb2 = memoryview(binascii.a2b_hex(hex2)) self.assertEqual(hex1, wkb_w.write_hex(g)) self.assertEqual(wkb1, wkb_w.write(g)) # Ensuring bad byteorders are not accepted. for bad_byteorder in (-1, 2, 523, 'foo', None): # Equivalent of `wkb_w.byteorder = bad_byteorder` self.assertRaises(ValueError, wkb_w._set_byteorder, bad_byteorder) # Setting the byteorder to 0 (for Big Endian) wkb_w.byteorder = 0 self.assertEqual(hex2, wkb_w.write_hex(g)) self.assertEqual(wkb2, wkb_w.write(g)) # Back to Little Endian wkb_w.byteorder = 1 # Now, trying out the 3D and SRID flags. g = GEOSGeometry('POINT (5 23 17)') g.srid = 4326 hex3d = b'0101000080000000000000144000000000000037400000000000003140' wkb3d = memoryview(binascii.a2b_hex(hex3d)) hex3d_srid = b'01010000A0E6100000000000000000144000000000000037400000000000003140' wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid)) # Ensuring bad output dimensions are not accepted for bad_outdim in (-1, 0, 1, 4, 423, 'foo', None): # Equivalent of `wkb_w.outdim = bad_outdim` self.assertRaises(ValueError, wkb_w._set_outdim, bad_outdim) # These tests will fail on 3.0.0 because of a bug that was fixed in 3.1: # http://trac.osgeo.org/geos/ticket/216 if not geos_version_info()['version'].startswith('3.0.'): # Now setting the output dimensions to be 3 wkb_w.outdim = 3 self.assertEqual(hex3d, wkb_w.write_hex(g)) self.assertEqual(wkb3d, wkb_w.write(g)) # Telling the WKBWriter to include the srid in the representation. wkb_w.srid = True self.assertEqual(hex3d_srid, wkb_w.write_hex(g)) self.assertEqual(wkb3d_srid, wkb_w.write(g))
def test04_wkbwriter(self): wkb_w = WKBWriter() # Representations of 'POINT (5 23)' in hex -- one normal and # the other with the byte order changed. g = GEOSGeometry('POINT (5 23)') hex1 = '010100000000000000000014400000000000003740' wkb1 = buffer(binascii.a2b_hex(hex1)) hex2 = '000000000140140000000000004037000000000000' wkb2 = buffer(binascii.a2b_hex(hex2)) self.assertEqual(hex1, wkb_w.write_hex(g)) self.assertEqual(wkb1, wkb_w.write(g)) # Ensuring bad byteorders are not accepted. for bad_byteorder in (-1, 2, 523, 'foo', None): # Equivalent of `wkb_w.byteorder = bad_byteorder` self.assertRaises(ValueError, wkb_w._set_byteorder, bad_byteorder) # Setting the byteorder to 0 (for Big Endian) wkb_w.byteorder = 0 self.assertEqual(hex2, wkb_w.write_hex(g)) self.assertEqual(wkb2, wkb_w.write(g)) # Back to Little Endian wkb_w.byteorder = 1 # Now, trying out the 3D and SRID flags. g = GEOSGeometry('POINT (5 23 17)') g.srid = 4326 hex3d = '0101000080000000000000144000000000000037400000000000003140' wkb3d = buffer(binascii.a2b_hex(hex3d)) hex3d_srid = '01010000A0E6100000000000000000144000000000000037400000000000003140' wkb3d_srid = buffer(binascii.a2b_hex(hex3d_srid)) # Ensuring bad output dimensions are not accepted for bad_outdim in (-1, 0, 1, 4, 423, 'foo', None): # Equivalent of `wkb_w.outdim = bad_outdim` self.assertRaises(ValueError, wkb_w._set_outdim, bad_outdim) # These tests will fail on 3.0.0 because of a bug that was fixed in 3.1: # http://trac.osgeo.org/geos/ticket/216 if not geos_version_info()['version'].startswith('3.0.'): # Now setting the output dimensions to be 3 wkb_w.outdim = 3 self.assertEqual(hex3d, wkb_w.write_hex(g)) self.assertEqual(wkb3d, wkb_w.write(g)) # Telling the WKBWriter to inlcude the srid in the representation. wkb_w.srid = True self.assertEqual(hex3d_srid, wkb_w.write_hex(g)) self.assertEqual(wkb3d_srid, wkb_w.write(g))
def to_python(self, value): """ Transforms the value to a Geometry object. """ if value in validators.EMPTY_VALUES: return None if not isinstance(value, GEOSGeometry): try: value = GEOSGeometry(value) except (GEOSException, ValueError, TypeError): raise forms.ValidationError(self.error_messages['invalid_geom'], code='invalid_geom') # Try to set the srid if not value.srid: try: value.srid = self.widget.map_srid except AttributeError: if self.srid: value.srid = self.srid return value
def to_internal_value(self, value): import json if isinstance(value, dict): value = json.dumps(value) if not GEOSGeometry: raise Exception("Missing GDAL") geom = GEOSGeometry(value) srid = getattr(settings, 'SRID', 4326) if 'crs' in value and value['crs'].get('type', None) == 'name': name = value['crs']['properties']['name'] if name.startswith('urn:ogc:def:crs:EPSG::'): geom.srid = int(name.replace('urn:ogc:def:crs:EPSG::', '')) if geom.srid is None: geom.srid = 4326 if geom.srid != srid: geom.transform(srid) return geom
def test04_wkbwriter(self): wkb_w = WKBWriter() # Representations of 'POINT (5 23)' in hex -- one normal and # the other with the byte order changed. g = GEOSGeometry('POINT (5 23)') hex1 = b'010100000000000000000014400000000000003740' wkb1 = memoryview(binascii.a2b_hex(hex1)) hex2 = b'000000000140140000000000004037000000000000' wkb2 = memoryview(binascii.a2b_hex(hex2)) self.assertEqual(hex1, wkb_w.write_hex(g)) self.assertEqual(wkb1, wkb_w.write(g)) # Ensuring bad byteorders are not accepted. for bad_byteorder in (-1, 2, 523, 'foo', None): # Equivalent of `wkb_w.byteorder = bad_byteorder` with self.assertRaises(ValueError): wkb_w._set_byteorder(bad_byteorder) # Setting the byteorder to 0 (for Big Endian) wkb_w.byteorder = 0 self.assertEqual(hex2, wkb_w.write_hex(g)) self.assertEqual(wkb2, wkb_w.write(g)) # Back to Little Endian wkb_w.byteorder = 1 # Now, trying out the 3D and SRID flags. g = GEOSGeometry('POINT (5 23 17)') g.srid = 4326 hex3d = b'0101000080000000000000144000000000000037400000000000003140' wkb3d = memoryview(binascii.a2b_hex(hex3d)) hex3d_srid = b'01010000A0E6100000000000000000144000000000000037400000000000003140' wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid)) # Ensuring bad output dimensions are not accepted for bad_outdim in (-1, 0, 1, 4, 423, 'foo', None): # Equivalent of `wkb_w.outdim = bad_outdim` with self.assertRaises(ValueError): wkb_w._set_outdim(bad_outdim) # Now setting the output dimensions to be 3 wkb_w.outdim = 3 self.assertEqual(hex3d, wkb_w.write_hex(g)) self.assertEqual(wkb3d, wkb_w.write(g)) # Telling the WKBWriter to include the srid in the representation. wkb_w.srid = True self.assertEqual(hex3d_srid, wkb_w.write_hex(g)) self.assertEqual(wkb3d_srid, wkb_w.write(g))
def normalize_geo(point): """ If we encounter a polygon. change it to point """ if point['type'] == 'Point': n_point = GEOSGeometry(json.dumps(point)) elif point['type'] == 'Polygon': # create centroid from polygon (ligplaats) n_point = GEOSGeometry(json.dumps(point)).centroid # geojson now defaults to 4326! n_point.srid = 28992 return n_point
def to_python(self, value): """ Transforms the value to a Geometry object. """ if value in self.empty_values: return None if not isinstance(value, GEOSGeometry): try: value = GEOSGeometry(value) if not value.srid: value.srid = self.widget.map_srid except (GEOSException, ValueError, TypeError): raise forms.ValidationError(self.error_messages['invalid_geom'], code='invalid_geom') return value
def _convert_point(self): ''' Get the point lat , lng Convert the point in Point object ''' lng = self.data[0] lat = self.data[1] wkt = "POINT({} {})".format(lng, lat) print(wkt) try: point = GEOSGeometry(wkt) point.srid = 4326 except GEOSException: point = None return point
def handle_wkt(self, wkt, name): g1 = GEOSGeometry(wkt) srid = g1.srid if not srid: raise Exception("Unknown SRID. Try ewkt format; `SRID=4326;POLYGON((.....))`") if g1 and isinstance(g1, geos.Polygon): g1 = geos.MultiPolygon(g1) g1.srid = srid if not name: raise Exception("No --name provided!") g1.transform(settings.GEOMETRY_DB_SRID) region = StudyRegion.objects.create(geometry=g1, name=name, active=True) region.save() print "Study region created: %s, primary key = %s" % (region.name, region.pk)
def dynamic_geojson(request): bbox = request.GET.get('bbox', None) if bbox: bbox = [float(x) for x in bbox.split(',')] else: bbox = [-180, -90, 180, 90] # TODO: calc to 3857 bbox_dict = { 'min_x': bbox[0], 'min_y': bbox[1], 'max_x': bbox[2], 'max_y': bbox[3], } geom = GEOSGeometry( 'POLYGON (({min_x} {min_y}, {min_x} {max_y}, {max_x} {max_y}, {max_x} {min_y}, {min_x} {min_y}))' .format(**bbox_dict)) geom.srid = 3857 geom.transform(TRANSF) points = Points.objects.filter(geom_point__bboverlaps=geom) return HttpResponse(serialize('geojson', points), content_type='application/json')
def dynamic_geojson(request): bbox = request.GET.get('bbox', None) if bbox: bbox = [float(x) for x in bbox.split(',')] else: bbox = [-180, -90, 180, 90] # TODO: calc to 3857 bbox_dict = { 'min_x': bbox[0], 'min_y': bbox[1], 'max_x': bbox[2], 'max_y': bbox[3], } geom = GEOSGeometry( 'POLYGON (({min_x} {min_y}, {min_x} {max_y}, {max_x} {max_y}, {max_x} {min_y}, {min_x} {min_y}))'.format( **bbox_dict )) geom.srid = 3857 geom.transform(TRANSF) points = Points.objects.filter(geom_point__bboverlaps=geom) return HttpResponse(serialize('geojson', points), content_type='application/json')
def handle_wkt(self, wkt, name): g1 = GEOSGeometry(wkt) srid = g1.srid if not srid: raise Exception( "Unknown SRID. Try ewkt format; `SRID=4326;POLYGON((.....))`") if g1 and isinstance(g1, geos.Polygon): g1 = geos.MultiPolygon(g1) g1.srid = srid if not name: raise Exception("No --name provided!") g1.transform(settings.GEOMETRY_DB_SRID) region = StudyRegion.objects.create(geometry=g1, name=name, active=True) region.save() print "Study region created: %s, primary key = %s" % (region.name, region.pk)
def clean(self, value): """ Validates that the input value can be converted to a Geometry object (which is returned). A ValidationError is raised if the value cannot be instantiated as a Geometry. """ if not value: if self.null and not self.required: # The geometry column allows NULL and is not required. return None else: raise forms.ValidationError(self.error_messages['no_geom']) # Trying to create a Geometry object from the form value. try: geom = GEOSGeometry(value) except: raise forms.ValidationError(self.error_messages['invalid_geom']) # Ensuring that the geometry is of the correct type (indicated # using the OGC string label). if str(geom.geom_type).upper( ) != self.geom_type and not self.geom_type == 'GEOMETRY': raise forms.ValidationError( self.error_messages['invalid_geom_type']) # Transforming the geometry if the SRID was set. if self.srid: if not geom.srid: # Should match that of the field if not given. geom.srid = self.srid elif self.srid != -1 and self.srid != geom.srid: try: geom.transform(self.srid) except: raise forms.ValidationError( self.error_messages['transform_error']) return geom
def add(request): """ Add new project """ # save form if request.method == 'POST': new_project = Project() project = ProjectForm(request.POST, instance=new_project) # TODO: mixin permission check if project.is_valid(): # transform location entry = project.save(commit=False) new_location = GEOSGeometry(entry.location) new_location.srid = 4326 new_location.transform(26986) entry.location = new_location entry.save( user=request.user, update_walkscore=True ) return redirect('detail', dd_id=entry.dd_id) # show empty form else: project = ProjectForm() return render_to_response('development/update.html', locals(), context_instance=RequestContext(request))
def _convert_linestring(self): ''' Get the route from the array Convert the route in LineString object ''' linestring_raw = '' k = 0 for i in self.data: k += 1 if i in linestring_raw: pass else: linestring_raw += i linestring_raw += ',' wkt = "LineString({})".format(linestring_raw).replace(',)', ')') try: linestring = GEOSGeometry(wkt) linestring.srid = 4326 except GEOSException: linestring = None return linestring
def _convert_polygon(self): ''' Get the polygon from the array Convert the polygon in Polygon object ''' polygon_raw_string = '' for i in self.data: if i in polygon_raw_string: pass else: polygon_raw_string += i polygon_raw_string += ' , ' polygon_raw_string += self.data[0] wkt = "POLYGON((" + polygon_raw_string + "))" try: polygon = GEOSGeometry(wkt) polygon.srid = 4326 except GEOSException: polygon = None return polygon
def processa(p1,p2): cidade = get_ibge(p1, p2) str_ponto = 'POINT({0} {1})'.format(p2,p1) pt = GEOSGeometry(str_ponto) pt.srid = 4326 normal = automatica_proxima(pt, 'N') automatica = automatica_proxima(pt, 'A') result = { 'normal' : { 'estacao' : normal.Nome, 'dist' : str(round(normal.distance.km,2)), 'id' : str(normal.id) } , 'automatica' : { 'estacao' : automatica.Nome, 'dist' : str(round(automatica.distance.km,2)), 'id' : str(automatica.id), 'codigo' : automatica.Codigo }, 'cidade' : cidade, } return result
def add(request): """ Add new project """ # save form if request.method == 'POST': new_project = Project() project = ProjectForm(request.POST, instance=new_project) # TODO: mixin permission check if project.is_valid(): # transform location entry = project.save(commit=False) new_location = GEOSGeometry(entry.location) new_location.srid = 4326 new_location.transform(26986) entry.location = new_location entry.save(user=request.user, update_walkscore=True) return redirect('detail', dd_id=entry.dd_id) # show empty form else: project = ProjectForm() return render_to_response('development/update.html', locals(), context_instance=RequestContext(request))
def to_internal_value(self, data): """ Accepts string or dict representation of a geojson polygon or multipolygon, either contained in a feature or standalone. Validates the shape can be processed, and returns a MultiPolygon geojson string. """ if data == '' or data is None: return data if isinstance(data, str): data = json.loads(data) geometry = data try: if not isinstance(geometry, GEOSGeometry): geometry = data['geometry'] if 'geometry' in data else data geometry = GEOSGeometry(json.dumps(geometry)) geometry.srid = 4326 except Exception: raise ValidationError('Area of interest must ' + 'be valid GeoJSON, of type ' + 'Feature, Polygon or MultiPolygon') if geometry.dims != 2: raise ValidationError('Area of interest must be a Polygon' + ' or MultiPolygon') if geometry.geom_type == 'Polygon': geometry = MultiPolygon(geometry, srid=4326) validate_aoi(geometry) return geometry.geojson
def clean(self, value): """ Validates that the input value can be converted to a Geometry object (which is returned). A ValidationError is raised if the value cannot be instantiated as a Geometry. """ if not value: if self.null and not self.required: # The geometry column allows NULL and is not required. return None else: raise forms.ValidationError(self.error_messages['no_geom']) # Trying to create a Geometry object from the form value. try: geom = GEOSGeometry(value) except: raise forms.ValidationError(self.error_messages['invalid_geom']) # Ensuring that the geometry is of the correct type (indicated # using the OGC string label). if str(geom.geom_type).upper() != self.geom_type and not self.geom_type == 'GEOMETRY': raise forms.ValidationError(self.error_messages['invalid_geom_type']) # Transforming the geometry if the SRID was set. if self.srid: if not geom.srid: # Should match that of the field if not given. geom.srid = self.srid elif self.srid != -1 and self.srid != geom.srid: try: geom.transform(self.srid) except: raise forms.ValidationError(self.error_messages['transform_error']) return geom
def update(request, dd_id): """ Update existing project """ try: project = Project.objects.transform(4326).get(pk=dd_id) except Project.DoesNotExist: raise Http404 # TODO: refactor this whole block if has_permissions(request.user, project.taz.municipality): user = request.user.profile if request.method == 'POST': mod_proj = ModeratedProject.new_from_project(project) mod_proj.user = request.user updated_project = ModeratedProjectForm(request.POST, instance=mod_proj) if updated_project.is_valid(): entry = updated_project.save(commit=False) new_location = GEOSGeometry(entry.location) new_location.srid = 4326 new_location.transform(26986) entry.location = new_location entry.save(user=request.user, update_walkscore=True) if user.is_trusted() or user.is_municipal(): # TODO: refactor entry.accept() municipal_users = User.objects.filter( profile__municipality=entry.municipality()) emails = [user.email for user in municipal_users] body = get_template( 'mail_templates/new_published_edit.html').render( Context({ 'project_id': entry.project.dd_id, 'project_name': entry.project.ddname, 'municipality_name': entry.municipality().name, 'project': entry, 'domain': request.META['HTTP_HOST'], })) send_mail('Development Database: New Published Edit', body, emails.pop(), emails, fail_silently=False) messages.add_message( request, messages.INFO, 'You are a trusted user, so your edits will be published immediately.' ) else: # TODO: refactor municipal_users = User.objects.filter( profile__municipality=entry.municipality()) emails = [user.email for user in municipal_users] body = get_template( 'mail_templates/new_pending_edit.html').render( Context({ 'project_id': entry.project.dd_id, 'project_name': entry.project.ddname, 'municipality_name': entry.municipality().name, 'project': entry, 'domain': request.META['HTTP_HOST'], })) send_mail('Development Database: New Pending Edit', body, emails.pop(), emails, fail_silently=False) messages.add_message(request, messages.INFO, 'Your edits will be moderated.') messages.add_message( request, messages.INFO, 'Your edits to %s were saved.' % (entry.ddname)) return redirect('detail', dd_id=entry.project.dd_id) else: messages.add_message( request, messages.INFO, "There were errors in your submission: %s" % (updated_project.errors)) return redirect('update', dd_id=project.dd_id) else: project = ModeratedProjectForm( instance=ModeratedProject.new_from_project(project)) else: messages.add_message( request, messages.INFO, 'You are not authorized to edit projects outside your municipality.' ) return redirect('detail', dd_id=dd_id) return render_to_response('development/update.html', locals(), context_instance=RequestContext(request))
from __future__ import unicode_literals
def convert(self, value): from django.contrib.gis.geos import GEOSGeometry srid = value.get('srid') value = GEOSGeometry(json.dumps(value)) value.srid = srid return value
path = argv[1] except IndexError: print("Requires filename") exit(1) reader = GDALDatasetEnvisatMetadataFormatReader(env) ds = gdal.Open(path) if not ds: print("Cannot open '%s' as GDAL Dataset." % path) exit(1) elif not reader.test_ds(ds): print("Dataset '%s' does not contain required ENVISAT metadata." % path) exit(1) md = reader.read_ds(ds) del ds footprint = GEOSGeometry(get_footprint_wkt(ds)) footprint.srid = 4326 encoder = EOP20Encoder() xml = encoder.serialize( encoder.encode_earth_observation(EOMetadata(footprint=footprint, **md))) with open(os.path.join(os.path.dirname(path))) as f: f.write(xml)
return datetime(year, month, day, hour, minute, second) if __name__=="__main__": path = argv[1] ds = gdal.Open(path) eo_id = os.path.splitext(os.path.basename(path))[0] begin_time = parse_timestamp(ds.GetMetadataItem("MPH_SENSING_START")) end_time = parse_timestamp(ds.GetMetadataItem("MPH_SENSING_STOP")) del ds footprint = GEOSGeometry(get_footprint_wkt(path)) footprint.srid = 4326 encoder = EOPEncoder() xml = DOMElementToXML( encoder.encodeEarthObservation( eo_id, begin_time, end_time, footprint ) ) xml_file = open(os.path.join(os.path.dirname(path), "%s.xml" % eo_id), "w") xml_file.write(xml) xml_file.close()
def update(request, dd_id): """ Update existing project """ try: project = Project.objects.transform(4326).get(pk=dd_id) except Project.DoesNotExist: raise Http404 # TODO: refactor this whole block if has_permissions(request.user, project.taz.municipality): user = request.user.profile if request.method == 'POST': mod_proj = ModeratedProject.new_from_project(project) mod_proj.user = request.user updated_project = ModeratedProjectForm(request.POST, instance=mod_proj) if updated_project.is_valid(): entry = updated_project.save(commit=False) new_location = GEOSGeometry(entry.location) new_location.srid = 4326 new_location.transform(26986) entry.location = new_location entry.save(user=request.user, update_walkscore=True) if user.is_trusted() or user.is_municipal(): # TODO: refactor entry.accept() municipal_users = User.objects.filter(profile__municipality=entry.municipality()) emails = [ user.email for user in municipal_users ] body = get_template('mail_templates/new_published_edit.html').render( Context({ 'project_id' : entry.project.dd_id, 'project_name' : entry.project.ddname, 'municipality_name' : entry.municipality().name, 'project': entry, 'domain': request.META['HTTP_HOST'], }) ) send_mail( 'Development Database: New Published Edit', body, emails.pop(), emails, fail_silently=False) messages.add_message(request, messages.INFO, 'You are a trusted user, so your edits will be published immediately.') else: # TODO: refactor municipal_users = User.objects.filter(profile__municipality=entry.municipality()) emails = [ user.email for user in municipal_users ] body = get_template('mail_templates/new_pending_edit.html').render( Context({ 'project_id' : entry.project.dd_id, 'project_name' : entry.project.ddname, 'municipality_name' : entry.municipality().name, 'project': entry, 'domain': request.META['HTTP_HOST'], }) ) send_mail( 'Development Database: New Pending Edit', body, emails.pop(), emails, fail_silently=False) messages.add_message(request, messages.INFO, 'Your edits will be moderated.') messages.add_message(request, messages.INFO, 'Your edits to %s were saved.' % (entry.ddname) ) return redirect('detail', dd_id=entry.project.dd_id) else: messages.add_message(request, messages.INFO, "There were errors in your submission: %s" % (updated_project.errors)) return redirect('update', dd_id=project.dd_id) else: project = ModeratedProjectForm(instance=ModeratedProject.new_from_project(project)) else: messages.add_message(request, messages.INFO, 'You are not authorized to edit projects outside your municipality.' ) return redirect('detail', dd_id=dd_id) return render_to_response('development/update.html', locals(), context_instance=RequestContext(request))
def addRunlet(run, old, new): if ((old.lat == new.lat) and (old.lon == new.lon) and (run['runlets'] == 0)): return path_id = getNearestPath(old) if (path_id == None): path_id = -1 old_lat = old.lat old_lon = old.lon t0 = old.t new_lat = new.lat new_lon = new.lon tn = new.t if (old.dirTag != new.dirTag): old_lat = new_lat old_lon = new_lon t0 = tn sql = "insert into runlet (run_id,lat0,lon0,loc0,t0,latn,lonn,locn,tn,path_id,distance) values (" + str( run['id']) + "," + str(old_lat) + "," + str( old_lon) + ", ST_SetSRID(ST_MakePoint(" + str(old_lon) + "," + str( old_lat ) + " )," + srid + ")," + str(t0) + "," + str(new_lat) + "," + str( new_lon) + ",ST_SetSRID(ST_MakePoint(" + str( new_lon) + "," + str(new_lat) + " )," + srid + ") ," + str( tn) + "," + str(path_id) + ",0) returning id" cur = old.db.cursor() cur.execute(sql) old.db.commit() id = cur.fetchone()[0] GEOSGeom0 = GEOSGeometry("POINT(" + str(old.lon) + " " + str(old.lat) + ")") GEOSGeom0.srid = 4326 GEOSGeomn = GEOSGeometry("POINT(" + str(new.lon) + " " + str(new.lat) + ")") GEOSGeomn.srid = 4326 GEOSGeom0.transform(ct) GEOSGeomn.transform(ct) dist = GEOSGeom0.distance(GEOSGeomn) sql = "update runlet set distance=%s where id=%s" cur.execute(sql, ( dist, id, )) old.db.commit() freq = int((t - run['startTime']) / (run['runlets'] + 1)) sql = "update run set distance = distance + %s, runlets = runlets + 1, freq = %s where id = " + str( run['id']) cur.execute(sql, ( dist, freq, )) old.db.commit() """