def Fetch_Location(request): if request.method == 'POST': # serializer = OutputRecordSerializer(data=request.data) if (request.data.get('user_id') != ''): try: validated_data = request.data temp_points = Activity_Record.objects.get( user_id_id=validated_data.get('user_id')) print(temp_points) g = temp_points buffer = GEOSGeometry.buffer(g.location, 0.0005, 4) print(buffer.geojson) # return serialize('geojson', [buffer], # geometry_field='location', fields=('user_id','location')) response_data = {} response_data['type'] = 'FeatureCollection' response_data['features'] = [] geo_obj = dict() geo_obj['type'] = 'Feature' geo_obj['properties'] = {} geo_obj['geometry'] = json.JSONDecoder().decode(buffer.geojson) response_data['features'].append(geo_obj) # response_data['buffer'] = json.JSONDecoder().decode( buffer.geojson ) # response_data['user_id'] = validated_data.get('user_id') except Activity_Record.DoesNotExist: response_data = {} response_data['status'] = "User id not found" response_data['user_id'] = validated_data.get('user_id') return HttpResponse(json.dumps(response_data), status=status.HTTP_201_CREATED)
def load_kml(verbose=True): """ Recorre la carpeta/data/kml --> introduce en la BD los linestrings de los KML https://medium.com/@kitcharoenpoolperm/geodjango-import-data-from-kml-file-de110dba1f60 """ # Ruta al archivo que queremos introducir en la BD BikeLanes kml_file = os.path.abspath( os.path.join(os.path.dirname(__file__), 'data', 'kml', 'bidegorris.kml'), ) # Reading Data by DataSource ds = DataSource(kml_file) # Writes the Well-Known Text representation of a Geometry. wkt_w = WKTWriter() # Iterating Over Layers for layer in ds: for feat in layer: if (feat.geom.geom_type.name.startswith('Line')): # Get the feature geometry. geom = feat.geom # get the feature property property = get_feat_property(feat) if (len(geom.coords) >= 2): # Make a GEOSGeometry object lstring = GEOSGeometry(wkt_w.write(geom.geos), srid=4326) lstring.transform(3035) dist = lstring.length line = BikeLane.objects.create( name=property['name'], distance=dist, lstring=lstring, # ST_Buffer() --> Poligonizamos los bidegorris a una anchura de 10m # https://www.usna.edu/Users/oceano/pguth/md_help/html/approx_equivalents.htm#:~:text=0.00001%C2%B0%20%3D%201.11%20m poly=lstring.buffer(10, quadsegs=8)) logger.info(line)
def post(self, request, *args, **kwargs): print(request.POST) if request.POST['location'] == '': form = FindGymForm(request.POST) form.errors['location'][0] = form.errors['location'][0].replace( "No geometry value provided.", "Need your location to find nearby gyms!") return render(request, "gymfinder.html", { "form": form, }) radius = int(request.POST['max_distance']) location = GEOSGeometry(request.POST["location"]) location = Point(location.coords) area = location.buffer(radius / 40000 * 360) gyms_found = list(Gym.objects.all()) for i in range(len(gyms_found)): dist = requests.get( "http://maps.googleapis.com/maps/api/distancematrix/json?origins=" + str(location.coords[1]) + "," + str(location.coords[0]) + "&destinations=" + str(gyms_found[i].location.coords[1]) + "," + str(gyms_found[i].location.coords[0])).json( )["rows"][0]['elements'][0]['distance']['text'].split(" ")[0] gyms_found[i] = (gyms_found[i], dist) gyms_found = list( filter(lambda gym: float(gym[-1]) < radius, gyms_found)) context = { "gyms_found": len(gyms_found), "max_distance": radius, "gyms": gyms_found, "location": location, } return render(request, "gyms_found.html", context)
def get_geoms(): cntr = GEOSGeometry('SRID=3857;POINT(-13842474.0 5280123.1)') stand_geoms = [] for i in range(NUM_STANDS): cntr.set_x(cntr.x + 150) g1 = cntr.buffer(75) g1.transform(settings.GEOMETRY_DB_SRID) stand_geoms.append(wkt.loads(g1.wkt)) casc_poly = cascaded_union(stand_geoms) if casc_poly.type == 'MultiPolygon': polys = [] for c in casc_poly: interiors = [ x for x in c.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD ] polys.append(Polygon(shell=c.exterior, holes=interiors)) elif casc_poly.type == 'Polygon': interiors = [ x for x in casc_poly.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD ] polys = [Polygon(shell=casc_poly.exterior, holes=interiors)] property_geom = MultiPolygon(polys) return stand_geoms, property_geom
def find_overlapping(request): '''This function queries ES when called via Ajax when a new geometry is created in the Location tab. If pre-existing resources are found within the perimeter of the polygon (or the buffered zone around a point/line/polygon), an alert is raised.''' geomString = request.GET.get('geom', '') geom = GEOSGeometry(geomString, srid=4326) mindistance = settings.METER_RADIUS if not mindistance: mindistance = 1000 # if settings.METER_RADIUS isn't set, default to 1Km geom.transform(3857) buffered_geom = geom.buffer(mindistance) buffered_geom.transform(4326) print geom, buffered_geom se = SearchEngineFactory().create() query = Query(se) boolfilter = Bool() geoshape = GeoShape(field='geometries.value', type=buffered_geom.geom_type, coordinates=buffered_geom.coords) nested = Nested(path='geometries', query=geoshape) boolfilter.must(nested) query.add_filter(boolfilter) results = query.search(index='entity', doc_type='') overlaps = [] for hit in results['hits']['hits']: overlaps.append({ 'id': hit['_id'], 'type': hit['_type'], 'primaryname': hit['_source']['primaryname'] }) return JSONResponse(overlaps)
def test_bad_variant(self): self.assertEqual(self.prop1.variant, self.real) cntr = GEOSGeometry("SRID=3857;POINT(-638474.0 980123.1)") # not on the map, but close to SO g2 = cntr.buffer(75) g2.transform(settings.GEOMETRY_DB_SRID) p2 = MultiPolygon(g2) self.prop1.geometry_final = p2 self.prop1.save() self.assertEqual(self.prop1.variant, self.other)
def test_bad_variant(self): self.assertEqual(self.prop1.variant, self.real) cntr = GEOSGeometry('SRID=3857;POINT(-638474.0 980123.1)') # not on the map, but close to SO g2 = cntr.buffer(75) g2.transform(settings.GEOMETRY_DB_SRID) p2 = MultiPolygon(g2) self.prop1.geometry_final = p2 self.prop1.save() self.assertEqual(self.prop1.variant, self.other)
def test_bad_location(self): self.assertEqual(self.prop1.location, self.realloc) cntr = GEOSGeometry('SRID=3857;POINT(-638474.0 980123.1)') # not on the map g2 = cntr.buffer(75) g2.transform(settings.GEOMETRY_DB_SRID) p2 = MultiPolygon(g2) self.prop1.geometry_final = p2 self.prop1.save() self.assertEqual(self.prop1.location, (None, None))
def test_bad_location(self): self.assertEqual(self.prop1.location, self.realloc) cntr = GEOSGeometry("SRID=3857;POINT(-638474.0 980123.1)") # not on the map g2 = cntr.buffer(75) g2.transform(settings.GEOMETRY_DB_SRID) p2 = MultiPolygon(g2) self.prop1.geometry_final = p2 self.prop1.save() self.assertEqual(self.prop1.location, (None, None))
def handle(self, *args, **options): api_client = ApiClient() api_client.configuration.host = "https://deims.org/api" api = swagger_client.DefaultApi(api_client=api_client) sites = api.sites_get() for s in sites: site = api.sites_resource_id_get(resource_id=s.id.suffix) if not (set(['Italy', 'Slovenia', 'Croatia']) & set(site.attributes.geographic.country)): continue print(site.id.prefix, site.id.suffix, site.title, site.attributes.geographic.country) domain_area = None if site.attributes.geographic.boundaries is not None: domain_area = GEOSGeometry(site.attributes.geographic.boundaries, srid=4326) if domain_area and (isinstance(domain_area, LineString) or (domain_area, MultiLineString)): domain_area = domain_area.buffer(0.0001) if domain_area and isinstance(domain_area, Polygon): domain_area = MultiPolygon(domain_area) obj, created = EcosSite.objects.get_or_create( suffix = site.id.suffix, defaults= {'location' : GEOSGeometry(site.attributes.geographic.coordinates, srid=4326)} ) obj.data = json.loads(api_client.last_response.data) obj.denomination = site.title obj.description = site.attributes.general.abstract obj.domain_area = domain_area obj.website= site.id.prefix+site.id.suffix obj.last_update = site.changed obj.img = imgimport(site.id.suffix) obj.location = GEOSGeometry(site.attributes.geographic.coordinates, srid=4326) obj.save() if site.attributes.focus_design_scale.parameters is not None: #print(site.attributes.focus_design_scale.parameters.__class__, site.attributes.focus_design_scale.parameters.__dict__) #print(site.attributes.focus_design_scale.parameters) #print(site.attributes.focus_design_scale.parameters[0].label) #print(site.attributes.focus_design_scale.parameters[0].uri) preferred_label_en = site.attributes.focus_design_scale.parameters[0].label obj, created = Parameter.objects.get_or_create( uri = site.attributes.focus_design_scale.parameters[0].uri, defaults={'preferred_label_en': preferred_label_en} ) preferred_label_en = preferred_label_en
def run(self): try: g = GEOSGeometry('SRID=4326;POINT(%s %s)' % (self.input_lon, self.input_lat)) g.transform(settings.GEOMETRY_DB_SRID) self.output_point_geom = g self.output_poly_geom = g.buffer(self.input_buffer_distance) self.output_area = self.output_poly_geom.area except: return False return True
def test_search_then_ad(self): house, create = HabitationType.objects.get_or_create(label="Maison") apartment, create = HabitationType.objects.get_or_create(label="Appartement") # create a search with search.location contaning ad.location pnt = GEOSGeometry(geo_from_address("22 rue esquirol Paris")) search = SearchFactory(location=geos.MultiPolygon(pnt.buffer(2)), price_max=700000, surface_min=50, habitation_types=[apartment, ]) # create an ad ad = AdFactory(address="22 rue esquirol Paris", price=600000, surface=60, habitation_type=apartment) # here we should have results ... self.assertEqual(AdSearchRelation.objects.all().count(), 1)
def test_ad_then_search_then_update_ad(self): house, create = HabitationType.objects.get_or_create(label="Maison") apartment, create = HabitationType.objects.get_or_create(label="Appartement") # create an ad ad = AdFactory(address="22 rue esquirol Paris", price=600000, surface=60, habitation_type=apartment) pnt = GEOSGeometry(geo_from_address(u"52 W 52nd St, New York, NY 10019, États-Unis")) # create a search with ad.location inside search.location search = SearchFactory(location=geos.MultiPolygon(pnt.buffer(2)), price_max=700000, surface_min=50, habitation_types=[apartment, ]) # here we should have results ... self.assertEqual(AdSearchRelation.objects.all().count(), 0) search.location = geos.MultiPolygon(ad.location.buffer(2)) search.save() self.assertEqual(AdSearchRelation.objects.all().count(), 1)
def target_to_valid_geom(self, shape): try: if iskml(shape): target = parsekml(shape) else: target = GEOSGeometry(shape) except Exception as e: raise self.InvalidGeometryException(e.message) if not target.valid: target = target.buffer(0) if not target.valid: raise self.InvalidGeometryException() target.set_srid(settings.GEOMETRY_CLIENT_SRID) return target
def _get_users(zip, radius): """Identify users for a zip radius :param zip: :param radius: :return: """ radius = float(radius) logger.debug('finding users within %s miles of zip code %s' % (radius, zip)) zipcode = ZipGeocode.objects.get(pk=zip) geom = GEOSGeometry('POINT(%s %s)' % (zipcode.longitude, zipcode.latitude)) buffered_geom = geom.buffer(radius) extended_users = ExtendedUserData.objects.filter(location__intersects=buffered_geom) return extended_users
def _buffer(geojson, width=0, unit='ft'): geojson = JSONSerializer().serialize(geojson) geom = GEOSGeometry(geojson, srid=4326) try: width = float(width) except: width = 0 if width > 0: if unit == 'ft': width = width / 3.28084 geom.transform(3857) geom = geom.buffer(width) geom.transform(4326) return geom
def create(self, validated_data): try: temp_points = Activity_Record.objects.get(user_id_id=validated_data.get('user_id')) print(temp_points) g = temp_points buffer = GEOSGeometry.buffer(g.location,1) print(buffer.geojson) # return serialize('geojson', [buffer], # geometry_field='location', fields=('user_id','location')) response_data = {} response_data['buffer'] = buffer.geojson response_data['user_id'] = validated_data.get('user_id') json.dumps(response_data) except Activity_Record.DoesNotExist: response_data = {} response_data['status'] = "User id not found" response_data['user_id'] = validated_data.get('user_id') json.dumps(response_data)
def _buffer(geojson, width=0, unit='ft'): geojson = JSONSerializer().serialize(geojson) geom = GEOSGeometry(geojson, srid=4326) try: width = float(width) except: width = 0 if width > 0: if unit == 'ft': width = width/3.28084 geom.transform(settings.ANALYSIS_COORDINATE_SYSTEM_SRID) geom = geom.buffer(width) geom.transform(4326) return geom
def _buffer(geojson, width=0, unit="ft"): geojson = JSONSerializer().serialize(geojson) geom = GEOSGeometry(geojson, srid=4326) try: width = float(width) except Exception: width = 0 if width > 0: if unit == "ft": width = width / 3.28084 geom.transform(settings.ANALYSIS_COORDINATE_SYSTEM_SRID) geom = geom.buffer(width) geom.transform(4326) return geom
def _buffer(geojson, width=0, unit='ft'): geojson = JSONSerializer().serialize(geojson) geom = GEOSGeometry(geojson, srid=4326) try: width = float(width) except: width = 0 if width > 0: if unit == 'ft': width = width/3.28084 geom.transform(3857) geom = geom.buffer(width) geom.transform(4326) return geom
def update_registered_organizations(request): URL = 'http://xmaps.indy.gov/arcgis/rest/services/RegisteredOrganizations/RegisteredOrganizations/MapServer' LAYER = 0 # clear out the db of previous registered organizations number_deleted = registered_organization.objects.all().delete() service = ArcGIS(URL) geojson = service.get(LAYER, fields='*') records = geojson['features'] number_created = 0 number_errors = 0 for record in records: try: geometry = GEOSGeometry(str(record['geometry'])) if not geometry.valid: geometry = geometry.buffer(0) except (GDALException, ValueError): number_errors = number_errors + 1 #print "Error on", record['properties']['ORG_NAME'] try: x = registered_organization( name=record['properties']['ORG_NAME'], first_name=record['properties']['FIRSTNAME'], last_name=record['properties']['LASTNAME'], email=record['properties']['EMAIL'], geometry=geometry, ) x.save() if registered_organization.objects.filter( geometry__isvalid=True).filter(id=x.id).count() == 0: #print "Error, invalid geometry", record['properties']['ORG_NAME'] pass else: number_created = number_created + 1 except IntegrityError: number_errors = number_errors + 1 #print "IntegrityError on ", record['properties']['ORG_NAME'] return HttpResponse( '<html><body><ul><li>Number deleted: {0}</li><li>Number created: {1}</li><li>Number errors: {2}</li></ul></body></html>' .format(number_deleted[0], number_created, number_errors))
def _buffer(geojson, width=0, unit='ft'): geojson = JSONSerializer().serialize(geojson) try: width = float(width) except: width = 0 if width > 0: geom = GEOSGeometry(geojson, srid=4326) geom.transform(3857) # Below 2 lines are deprecated in EAMENA's Arches as the unit of choice is EPSG3857's default metres if unit == 'ft': width = width/3.28084 buffered_geom = geom.buffer(width) buffered_geom.transform(4326) return buffered_geom else: return GEOSGeometry(geojson)
def get_geoms(): cntr = GEOSGeometry("SRID=3857;POINT(-13842474.0 5280123.1)") stand_geoms = [] for i in range(NUM_STANDS): cntr.set_x(cntr.x + 150) g1 = cntr.buffer(75) g1.transform(settings.GEOMETRY_DB_SRID) stand_geoms.append(wkt.loads(g1.wkt)) casc_poly = cascaded_union(stand_geoms) if casc_poly.type == "MultiPolygon": polys = [] for c in casc_poly: interiors = [x for x in c.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD] polys.append(Polygon(shell=c.exterior, holes=interiors)) elif casc_poly.type == "Polygon": interiors = [x for x in casc_poly.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD] polys = [Polygon(shell=casc_poly.exterior, holes=interiors)] property_geom = MultiPolygon(polys) return stand_geoms, property_geom
from django.contrib.auth.models import User from django.test.client import Client from django.contrib.gis.geos import GEOSGeometry from shapely.ops import cascaded_union from shapely.geometry import Polygon, MultiPolygon from shapely import wkt cntr = GEOSGeometry('SRID=3857;POINT(-13842500.0 5280100.0)') NUM_STANDS = 10 * 10 geoms = [] for i in range(int(NUM_STANDS**0.5)): cntr.set_y(cntr.y - 150) for j in range(int(NUM_STANDS**0.5)): cntr.set_x(cntr.x + 150) g1 = cntr.buffer(75).envelope g1.transform(settings.GEOMETRY_DB_SRID) geoms.append(wkt.loads(g1.wkt)) cntr.set_x(cntr.x - int(NUM_STANDS**0.5)*150) casc_poly = cascaded_union(geoms) if casc_poly.type == 'MultiPolygon': polys = [] for c in casc_poly: interiors = [x for x in c.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD] polys.append(Polygon(shell=c.exterior, holes=interiors)) elif casc_poly.type == 'Polygon': interiors = [x for x in casc_poly.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD] polys = [Polygon(shell=casc_poly.exterior, holes=interiors)]
from django.test.client import Client from django.contrib.gis.geos import GEOSGeometry, MultiPolygon from django.contrib.auth.models import User from django.core.exceptions import ValidationError from django.conf import settings from json import loads, dumps from madrona.features import * from madrona.common.utils import kml_errors, enable_sharing from madrona.raster_stats.models import RasterDataset from trees.models import Stand, Strata, ForestProperty, County, FVSVariant, Scenario, Rx, FVSAggregate from trees.utils import StandImporter from django.core.management import call_command cntr = GEOSGeometry('SRID=3857;POINT(-13842474.0 5280123.1)') g1 = cntr.buffer(75) g1.transform(settings.GEOMETRY_DB_SRID) single_p1 = g1.buffer(1000) p1 = MultiPolygon(single_p1) def import_rasters(): d = os.path.dirname(__file__) rast_path = os.path.abspath(os.path.join(d, '..', 'fixtures', 'testdata')) # Here we'll need to create dummy rasterdatasets for everything # in the IMPUTE_RASTERS setting elev = RasterDataset.objects.create(name="elevation", filepath=os.path.join(rast_path,'elevation.tif'), type='continuous') aspect = RasterDataset.objects.create(name="aspect",
def run_task_remote(run_uid): # noqa run = ExportRun.objects.get(uid=run_uid) run.status = 'RUNNING' run.started_at = timezone.now() run.save() LOG.debug('Running ExportRun with id: {0}'.format(run_uid)) job = run.job try: stage_dir = os.path.join(settings.EXPORT_STAGING_ROOT, str(run_uid)) + '/' os.makedirs(stage_dir, 6600) run_dir = os.path.join(settings.EXPORT_DOWNLOAD_ROOT, run_uid) if not os.path.exists(run_dir): os.makedirs(run_dir) aoi = GEOSGeometry(job.the_geom) if job.buffer_aoi: aoi = aoi.buffer( 0.02 ) # 0.02 degrees is a reasonable amount for an admin 0 boundary aoi = simplify_max_points(aoi) try: feature_selection = job.feature_selection_object except Exception: feature_selection = FeatureSelection(SIMPLE) export_formats = map_names_to_formats(job.export_formats) download_dir = os.path.join(settings.EXPORT_DOWNLOAD_ROOT, run_uid) zipper = Zipper(job.name, stage_dir, download_dir, aoi) def on_task_start(formatcls): LOG.debug('Task Start: {0} for run: {1}'.format( formatcls.name, run_uid)) if formatcls in export_formats: task = ExportTask.objects.get(run__uid=run_uid, name=formatcls.name) task.status = 'RUNNING' task.started_at = timezone.now() task.save() def on_task_success(formatcls, results): LOG.debug('Task Success: {0} for run: {1}'.format( formatcls.name, run_uid)) if formatcls in export_formats: task = ExportTask.objects.get(run__uid=run_uid, name=formatcls.name) zipfiles = zipper.run(results) task.filesize_bytes = sum( os.stat(zipfile).st_size for zipfile in zipfiles) task.filenames = [ os.path.basename(zipfile) for zipfile in zipfiles ] task.status = 'SUCCESS' task.finished_at = timezone.now() task.save() r = RunManager(export_formats, aoi, feature_selection, stage_dir, map_creator_dir=settings.OSMAND_MAP_CREATOR_DIR, garmin_splitter=settings.GARMIN_SPLITTER, garmin_mkgmap=settings.GARMIN_MKGMAP, per_theme=True, on_task_start=on_task_start, on_task_success=on_task_success, overpass_api_url=settings.OVERPASS_API_URL) r.run() public_dir = settings.HOSTNAME + os.path.join( settings.EXPORT_MEDIA_ROOT, run_uid) if settings.SYNC_TO_HDX and HDXExportRegion.objects.filter( job_id=run.job_id).exists(): LOG.debug("Adding resources to HDX") region = HDXExportRegion.objects.get(job_id=run.job_id) export_set = region.hdx_dataset export_set.sync_resources(zipper.zipped_resources, public_dir) if run.job.hdx_export_region_set.count() == 0: # not associated with an HDX Export Regon; send mail send_completion_notification(run) else: send_hdx_completion_notification( run, run.job.hdx_export_region_set.first()) run.status = 'COMPLETED' LOG.debug('Finished ExportRun with id: {0}'.format(run_uid)) except Exception as e: client.captureException(extra={ 'run_uid': run_uid, }) run.status = 'FAILED' LOG.warn('ExportRun {0} failed: {1}'.format(run_uid, e)) LOG.warn(traceback.format_exc()) send_error_notification(run) if run.job.hdx_export_region_set.count() >= 0: send_hdx_error_notification(run, run.job.hdx_export_region_set.first()) finally: shutil.rmtree(stage_dir) run.finished_at = timezone.now() run.save()
def toDownload(request): ctx = {} pointExist = Point_Cloud.objects.all()[:1] if pointExist: if request.POST: if '_download' in request.POST: #check which forms are filled in if request.POST['x'] and request.POST['y'] and request.POST[ 'r']: x0 = float(str(request.POST['x'])) y0 = float(str(request.POST['y'])) radius = float(str(request.POST['r'])) elif request.POST['x'] and request.POST['y']: x0 = float(str(request.POST['x'])) y0 = float(str(request.POST['y'])) radius = 459.494 elif request.POST['y'] and request.POST['r']: x0 = '85168.41' y0 = float(str(request.POST['y'])) radius = float(str(request.POST['r'])) elif request.POST['x'] and request.POST['r']: x0 = float(str(request.POST['x'])) y0 = '446709.42' radius = float(str(request.POST['r'])) elif request.POST['x']: x0 = float(str(request.POST['x'])) y0 = '446709.42' radius = 459.494 elif request.POST['y']: x0 = '85168.41' y0 = float(str(request.POST['y'])) radius = 459.494 elif request.POST['r']: x0 = '85168.41' y0 = '446709.42' radius = float(str(request.POST['r'])) else: x0 = '85168.41' y0 = '446709.42' radius = 459.494 center = GEOSGeometry('SRID=28992;POINT (' + str(x0) + ' ' + str(y0) + ')') polygon = center.buffer(radius) if request.POST['filename']: f_name = str(request.POST['filename']) else: f_name = 'downloadedpc' outfile = laspy.file.File(settings.MEDIA_ROOT + '/' + f_name + '.las', mode='w', header=laspy.header.Header()) outfile.define_new_dimension(name="imp", data_type=9, description="Importance value") temp1 = Point_Cloud.objects.values('id', 'imp', 'xypoint') temp2 = [] for p in temp1: if p['xypoint'].distance( center) / radius < p['imp']: #distance query temp2.append(p['id']) #ST_Within query allx = np.array([ x for x in Point_Cloud.objects.filter( xypoint__within=polygon, id__in=temp2).values_list( 'x', flat=True) ]) ally = np.array([ y for y in Point_Cloud.objects.filter( xypoint__within=polygon, id__in=temp2).values_list( 'y', flat=True) ]) allz = np.array([ z for z in Point_Cloud.objects.filter( xypoint__within=polygon, id__in=temp2).values_list( 'z', flat=True) ]) allimp = np.array([ imp for imp in Point_Cloud.objects.filter( xypoint__within=polygon, id__in=temp2).values_list( 'imp', flat=True).order_by('imp') ]) outfile.X = allx outfile.Y = ally outfile.Z = allz outfile.imp = allimp outfile.header.offset = [ min(allx), min(ally), min(allz), min(allimp) ] outfile.header.scale = [0.001, 0.001, 0.001, 0.001] outfile.close() ctx['done'] = 'File ' + f_name + ' is downloaded!' elif '_viewer' in request.POST: if request.POST['x'] and request.POST['y'] and request.POST[ 'r']: x0 = float(str(request.POST['x'])) y0 = float(str(request.POST['y'])) radius = float(str(request.POST['r'])) elif request.POST['x'] and request.POST['y']: x0 = float(str(request.POST['x'])) y0 = float(str(request.POST['y'])) radius = 459.494 elif request.POST['y'] and request.POST['r']: x0 = '85168.41' y0 = float(str(request.POST['y'])) radius = float(str(request.POST['r'])) elif request.POST['x'] and request.POST['r']: x0 = float(str(request.POST['x'])) y0 = '446709.42' radius = float(str(request.POST['r'])) elif request.POST['x']: x0 = float(str(request.POST['x'])) y0 = '446709.42' radius = 459.494 elif request.POST['y']: x0 = '85168.41' y0 = float(str(request.POST['y'])) radius = 459.494 elif request.POST['r']: x0 = '85168.41' y0 = '446709.42' radius = float(str(request.POST['r'])) else: x0 = '85168.41' y0 = '446709.42' radius = 459.494 center = GEOSGeometry('SRID=28992;POINT (' + str(x0) + ' ' + str(y0) + ')') polygon = center.buffer(radius) temp1 = Point_Cloud.objects.values('id', 'imp', 'xypoint') temp2 = [] for p in temp1: if p['xypoint'].distance( center) / radius < p['imp']: #**2: temp2.append(p['id']) selected = Point_Cloud.objects.filter( xypoint__within=polygon, id__in=temp2).order_by('imp') points = [] for i in range(len(selected)): points.append(selected[i].x) points.append(selected[i].y) points.append(selected[i].z) points.append(selected[i].imp) string = 'var visualisation = ' + str( points) + ';\n' + 'var centre = ' + str([x0, y0, 0.0 ]) + ';' outfile = file(settings.MEDIA_ROOT + '/visualisation.js', mode='w') outfile.write(string) outfile.close() ctx['done'] = 'File is ready for the viewer!' else: ctx['done'] = 'No point cloud available!' return render(request, 'upload.html', ctx) return render(request, 'download.html', ctx)
from django.test.client import Client from django.contrib.gis.geos import GEOSGeometry, MultiPolygon from django.contrib.auth.models import User from django.core.exceptions import ValidationError from django.conf import settings from json import loads, dumps from madrona.features import * from madrona.common.utils import kml_errors, enable_sharing from madrona.raster_stats.models import RasterDataset from trees.models import Stand, Strata, ForestProperty, County, FVSVariant, Scenario, Rx, FVSAggregate from trees.utils import StandImporter from django.core.management import call_command cntr = GEOSGeometry("SRID=3857;POINT(-13842474.0 5280123.1)") g1 = cntr.buffer(75) g1.transform(settings.GEOMETRY_DB_SRID) single_p1 = g1.buffer(1000) p1 = MultiPolygon(single_p1) def import_rasters(): d = os.path.dirname(__file__) rast_path = os.path.abspath(os.path.join(d, "..", "fixtures", "testdata")) # Here we'll need to create dummy rasterdatasets for everything # in the IMPUTE_RASTERS setting elev = RasterDataset.objects.create( name="elevation", filepath=os.path.join(rast_path, "elevation.tif"), type="continuous" ) aspect = RasterDataset.objects.create(
def geosearch(request): """ Returns geocoded results in MERCATOR projection First tries coordinates, then a series of geocoding engines """ from geopy import distance if request.method != 'GET': return HttpResponse('Invalid http method; use GET', status=405) try: txt = unicode(request.GET['search']) except: return HttpResponseBadRequest() searchtype = lat = lon = None place = txt try: p = Point(txt) lat, lon, altitude = p searchtype = 'coordinates' except: pass # not a point centerloc = Point("45.54 N 120.64 W") max_dist = 315 # should be everything in WA and Oregon searches = [ geocoders.GeoNames(), geocoders.OpenMapQuest(), geocoders.Yahoo(app_id=settings.APP_NAME), geocoders.Bing(api_key=settings.BING_API_KEY), # these are tried in reverse order, fastest first # TODO thread them and try them as they come in. ] while not (searchtype and lat and lon): # try a geocoder try: g = searches.pop() except IndexError: break # no more search engines left to try try: for p, loc in g.geocode(txt, exactly_one=False): d = distance.distance(loc, centerloc).miles if d < max_dist: # TODO maybe compile these and return the closest to map center? # print g, p, loc place = p lat = loc[0] lon = loc[1] max_dist = d else: pass searchtype = g.__class__.__name__ except: pass if searchtype and lat and lon: # we have a winner cntr = GEOSGeometry('SRID=4326;POINT(%f %f)' % (lon, lat)) cntr.transform(settings.GEOMETRY_DB_SRID) cntrbuf = cntr.buffer(settings.POINT_BUFFER) extent = cntrbuf.extent loc = { 'status': 'ok', 'search': txt, 'place': place, 'type': searchtype, 'extent': extent, 'latlon': [lat, lon], 'center': (cntr[0], cntr[1]), } json_loc = json.dumps(loc) return HttpResponse(json_loc, mimetype='application/json', status=200) else: loc = { 'status': 'failed', 'search': txt, 'type': None, 'extent': None, 'center': None, } json_loc = json.dumps(loc) return HttpResponse(json_loc, mimetype='application/json', status=404)
from django.contrib.auth.models import User from django.test.client import Client from django.contrib.gis.geos import GEOSGeometry from shapely.ops import cascaded_union from shapely.geometry import Polygon, MultiPolygon from shapely import wkt cntr = GEOSGeometry('SRID=3857;POINT(-13842500.0 5280100.0)') NUM_STANDS = 10 * 10 geoms = [] for i in range(int(NUM_STANDS**0.5)): cntr.set_y(cntr.y - 150) for j in range(int(NUM_STANDS**0.5)): cntr.set_x(cntr.x + 150) g1 = cntr.buffer(75).envelope g1.transform(settings.GEOMETRY_DB_SRID) geoms.append(wkt.loads(g1.wkt)) cntr.set_x(cntr.x - int(NUM_STANDS**0.5) * 150) casc_poly = cascaded_union(geoms) if casc_poly.type == 'MultiPolygon': polys = [] for c in casc_poly: interiors = [ x for x in c.interiors if Polygon(x).area > settings.SLIVER_THRESHOLD ] polys.append(Polygon(shell=c.exterior, holes=interiors)) elif casc_poly.type == 'Polygon':