def _clean_buildings(self):
"""
Budovy mohou byt v KML zadany budto jako polygony, nebo jako jednoduche
body (spendliky). Body se ale zde prevedenou na male kolecka (polygony),
protoze veskery ostatni kod s tim pocita.
"""
# normalne rozparsujeme KML
url, err = self._common_clean('buildings', ['polygon', 'point'])
if not err:
# no ale ted rozdelime vysledek na 2 hromadky: polygony a body
points = [i for i in self.buildings_data if i['type'] == 'point']
polys = [i for i in self.buildings_data if i['type'] != 'point']
# hromadku bodu prevedeme na malinke polygony (male kolca)
out = []
ct1 = CoordTransform(SpatialReference('WGS84'), SpatialReference(102065))
ct2 = CoordTransform(SpatialReference(102065), SpatialReference('WGS84'))
for point in points:
_point = Point(point['coordinates'][0]['lon'], point['coordinates'][0]['lat'], srid=4326)
m_point = _point.transform(ct1, clone=True)
m_point2 = m_point.buffer(3)
m_point2.transform(ct2)
point['coordinates'] = [dict(zip(['lon', 'lat'], i)) for i in m_point2.coords[0]]
out.append(point)
# no a vratime origos polygony a nase pretransformovane body na kolca
self.buildings_data = polys + out
return url, err
def calculate_zone(self, distance, ct1=None, ct2=None):
"""
Vypocita okoli budovy a ulozi jej do self.zone.
"""
# pokud uz nejake okoli vypocitane mame, odstranime je...
if self.zone:
self.zone.delete()
# prepocteme WGS84 souradnice obrysu budovy do krovaka
if ct1 is None:
ct1 = CoordTransform(SpatialReference('WGS84'),
SpatialReference(102065))
m_poly = self.poly.transform(ct1, clone=True)
# vypocitame okoli/sousedstvi budovy
zone = m_poly.buffer(distance)
# prevedeme okoli zpet na WGS84
if ct2 is None:
ct2 = CoordTransform(SpatialReference(102065),
SpatialReference('WGS84'))
zone.transform(ct2)
# vytvorime v DB novy objekt
self.zone = Zone.objects.create(poly=zone)
self.save()
def __init__(self, options):
super(Importer, self).__init__()
self._images = {obj.url: obj for obj in Image.objects.all()}
self.options = options
self.verbosity = options['verbosity']
self.logger = logging.getLogger(__name__)
importer_langs = set(self.supported_languages)
configured_langs = set(l[0] for l in settings.LANGUAGES)
# Intersection is all the languages possible for the importer to use.
self.languages = {}
for lang_code in importer_langs & configured_langs:
# FIXME: get language name translations from Django
lang_obj, _ = Language.objects.get_or_create(id=lang_code)
self.languages[lang_code] = lang_obj
self.target_srid = settings.PROJECTION_SRID
gps_srs = SpatialReference(4326)
target_srs = SpatialReference(self.target_srid)
if getattr(settings, 'BOUNDING_BOX'):
self.bounding_box = Polygon.from_bbox(settings.BOUNDING_BOX)
self.bounding_box.set_srid(self.target_srid)
target_to_gps_ct = CoordTransform(target_srs, gps_srs)
self.bounding_box.transform(target_to_gps_ct)
else:
self.bounding_box = None
self.gps_to_target_ct = CoordTransform(gps_srs, target_srs)
self.setup()
def __init__(self, options):
super(Importer, self).__init__()
self.options = options
importer_langs = set(self.supported_languages)
configured_langs = set(l[0] for l in settings.LANGUAGES)
# Intersection is all the languages possible for the importer to use.
self.languages = {}
for lang_code in importer_langs & configured_langs:
# FIXME: get language name translations from Django
lang_obj, _ = Language.objects.get_or_create(id=lang_code)
self.languages[lang_code] = lang_obj
self.target_srid = settings.PROJECTION_SRID
gps_srs = SpatialReference(4326)
target_srs = SpatialReference(self.target_srid)
if getattr(settings, 'BOUNDING_BOX'):
self.bounding_box = Polygon.from_bbox(settings.BOUNDING_BOX)
self.bounding_box.srid = self.target_srid
target_to_gps_ct = CoordTransform(target_srs, gps_srs)
self.bounding_box.transform(target_to_gps_ct)
else:
self.bounding_box = None
self.gps_to_target_ct = CoordTransform(gps_srs, target_srs)
self.setup()
# this has to be run after setup, as it relies on organization and data source being set
self._images = {
obj.url: obj
for obj in Image.objects.filter(publisher=self.organization,
data_source=self.data_source)
}
def save_buildings(self, entry):
"""
Ulozi vyparsovane obrysy budov. Ke kazde budove vypocita jeji obrys.
"""
ct1 = CoordTransform(SpatialReference('WGS84'), SpatialReference(102065))
ct2 = CoordTransform(SpatialReference(102065), SpatialReference('WGS84'))
for building in self.buildings_data:
# vytvorime polygon
coords = [(i['lon'], i['lat']) for i in building['coordinates']]
if coords[0] != coords[-1]:
coords.append(coords[0])
if not coords:
logger.info('No coordinates information in KML data for %s record' % building['name'])
continue
poly = Polygon(coords, srid=4326)
# ulozime zaznam o budove do DB
b = Building.objects.create(
title = building['name'],
description = building['description'],
slug = slugify(building['name'][:99]),
entry = entry,
poly = poly
)
# vypocteme okoli budovy
b.calculate_zone(M100, ct1, ct2)
def simplify(geom: GEOSGeometry, tolerance: float = 10.0) -> GEOSGeometry:
wgs_proj = SpatialReference("+proj=longlat +datum=WGS84")
# TODO: determine zone number from longitude
utm_proj = SpatialReference("+proj=utm +zone=33 +ellps=WGS84")
# Transform to planar coordinates for better simplify operation
ct = CoordTransform(wgs_proj, utm_proj)
simplified_geom = geom.transform(ct, clone=True).simplify(tolerance)
# Transform back to geographical coordinates
ct = CoordTransform(utm_proj, wgs_proj)
simplified_geom.transform(ct)
return simplified_geom
def next_row(self):
datasource = DataSource(self.filename, encoding=self.encoding)
layer = datasource[0]
SpatialRefSys = connection.ops.spatial_ref_sys()
target_srs = SpatialRefSys.objects.get(srid=settings.SRID).srs
coord_transform = CoordTransform(layer.srs, target_srs)
self.nb = len(layer)
for i, feature in enumerate(layer):
row = {
self.normalize_field_name(field.name): field.value
for field in feature
}
try:
ogrgeom = feature.geom
except GDALException:
print(_("Invalid geometry pointer"), i)
geom = None
else:
ogrgeom.coord_dim = 2 # Flatten to 2D
ogrgeom.transform(coord_transform)
geom = ogrgeom.geos
if self.simplify_tolerance and geom is not None:
geom = geom.simplify(self.simplify_tolerance)
row[self.normalize_field_name('geom')] = geom
yield row
def upload(request):
ctoken = {}
ctoken.update(csrf(request))
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
shp = form.handle(request.FILES['file_obj'])
ds = gdal.DataSource(shp)
ct = CoordTransform(SpatialReference('EPSG:4326'),
SpatialReference('EPSG:900913'))
dados = []
for layer in ds[0]:
aux = layer.geom
aux.transform(ct)
dados.append(aux)
form = UploadForm()
return render_to_response(
'googlev3_upload.html',
RequestContext(request, {
'form': form,
'dados': dados,
'token': ctoken
}))
else:
form = UploadForm()
return render_to_response('googlev3_upload.html',
RequestContext(request, {'form': form}))
def loadFilesToDB(user_id):
user_data_folder = getUserDataFolder(user_id)
try:
for file in os.listdir(user_data_folder):
if not file.endswith(".shp"):
continue
filename = os.path.splitext(file)[0]
if not hasMandatoryFiles(user_data_folder, filename):
continue
file_dir = os.path.join(user_data_folder, file)
ds = DataSource(file_dir)
layer = ds[0] # Shapefiles have only one layer
srs = layer.srs
coord_trans = CoordTransform(srs, SpatialReference(4326))
models_to_save = []
for feature in layer:
try:
name = feature.get('name')
except:
name = ""
stripstring = name.strip()
if not stripstring:
name = ('%s_no_name') % filename
geom = GEOSGeometry(feature.geom.geos)
geom.transform(coord_trans)
models_to_save.append(adrian(name = name, geom = geom,\
user_id = user_id, color = None, filename = filename))
adrian.objects.bulk_create(models_to_save, 100)
shutil.rmtree(user_data_folder)
return True
except:
shutil.rmtree(user_data_folder)
print "Unexpected error:", sys.exc_info()[0]
raise
def __load_geojson__(self, crs: int):
# Load geojson
fd = open(self.vectorlayer_file.path, 'r')
geojson = json.load(fd)
src_crs = 4326
for item in geojson['features']:
# get data
_properties = item['properties']
coords = item['geometry']['coordinates']
# create multipolygon
polygons = [Polygon(coord[0]) for coord in coords]
mpolygon = MultiPolygon(polygons)
# Tranform geometry
gcoord = SpatialReference(src_crs)
mycoord = SpatialReference(crs)
trans = CoordTransform(gcoord, mycoord)
mpolygon.transform(trans)
# Create vector geometry
VectorGeometry.objects.create(vectorgeometry_layer=self,
geom=mpolygon)
def clean(self):
cleaned_data = super(NamedPlaceForm, self).clean()
if (cleaned_data.get('verbatim_coordinates', None)
and cleaned_data.get('verbatim_srid', None)):
my_srid = cleaned_data['verbatim_srid'].srid
srs_from = SpatialReference(my_srid)
srs_to = SpatialReference(4326)
ptransf = CoordTransform(srs_from, srs_to)
value = cleaned_data['verbatim_coordinates']
x, y = parse_coordinate_string(value)
point = Point(x=x, y=y, srid=my_srid)
point.transform(ptransf)
country = cleaned_data['adm0']
try:
VALIDATE_COORDINATES = settings.VALIDATE_COORDINATES
except AttributeError:
VALIDATE_COORDINATES = True
if VALIDATE_COORDINATES:
try:
g = AdmUnitBoundary.objects.get(
geoname_id=country.geoname_id)
if g.geom.intersects(point):
pass
else:
raise ValidationError('Point does not fall within'
' selected country boundary.')
except ObjectDoesNotExist:
pass
cleaned_data['point'] = point
def save(self, *args, **kwargs):
if self.layer_path is None or self.layer_path == '':
self.layer_path = unique_layer_directory(self)
if os.path.isdir(self.image):
info = get_image_dir_info(self.image, self.projection)
else:
info = get_image_file_info(self.image)
polygon = Polygon.from_bbox(info['bbox'])
polygon.srid = self.projection
ct = CoordTransform(SpatialReference(self.projection),
SpatialReference('WGS84'))
polygon.transform(ct)
self.extent = polygon
super(Layer, self).save(*args, **kwargs)
# mask
mask_path = None
if self.mask:
target_path = extract_zipfile(self.mask.path)
mask_path = find_shapefile(target_path)
self.mask_path = mask_path
super(Layer, self).save()
# update layer preview info if any
if hasattr(self, 'layerpreview'):
self.layerpreview.save()
# update services using this layer
for serviceLayer in self.services.all():
serviceLayer.service.save()
def make_point(point, origin_coord_srid, destiny_coord_srid):
origin_coord = SpatialReference(origin_coord_srid)
destination_coord = SpatialReference(destiny_coord_srid)
trans = CoordTransform(origin_coord, destination_coord)
transformed_point = copy(point)
transformed_point.transform(trans)
return transformed_point
def import_voting_district_boundaries(self):
path = os.path.join(self.data_path, 'aan/PKS_aanestysalueet_kkj2.TAB')
ds = DataSource(path)
kkj2 = SpatialReference(
'+proj=tmerc +lat_0=0 +lon_0=24 +k=1 +x_0=2500000 +y_0=0 +ellps=intl +towgs84=-96.0617,-82.4278,-121.7535,4.80107,0.34543,-1.37646,1.4964 +units=m +no_defs'
)
kkj2_to_wgs84 = CoordTransform(kkj2, SpatialReference('WGS84'))
lyr = ds[0]
election = Election.objects.get(type='muni', year=2012)
count = 0
for feat in lyr:
muni_id = int(feat.get('KUNTA'))
muni = Municipality.objects.get(id=muni_id)
name = feat.get('Nimi').decode('iso8859-1')
feat.geom.srs = kkj2
geom = feat.geom
geom.transform(kkj2_to_wgs84)
origin_id = feat.get('TKTUNNUS')
args = {'municipality': muni, 'origin_id': origin_id}
ed, created = VotingDistrict.objects.get_or_create(**args)
ed.name = name
gm = GEOSGeometry(geom.wkb, srid=geom.srid)
if not isinstance(gm, MultiPolygon):
gm = MultiPolygon(gm)
ed.borders = gm
ed.save()
ed.elections.add(election)
if created:
count += 1
print "%d voting districts added." % count
def photo_info(request):
form = DelfiPhotoInfoRequestForm(request.query_params)
if form.is_valid():
photo = form.cleaned_data['id']
our_ref = SpatialReference(4326)
delfi_ref = SpatialReference(3301)
trans = CoordTransform(our_ref, delfi_ref)
location = Point(x=photo.lon, y=photo.lat, srid=4326)
location.transform(trans)
source_str = ''
if photo.source and photo.source_key:
source_str = photo.source.description + ' ' + photo.source_key
return Response({
'id': photo.id,
'author': photo.author,
'description': photo.get_display_text,
'latitude': location.y,
'longitude': location.x,
'source': source_str,
'url': request.build_absolute_uri(
reverse('photo', args=(photo.id, photo.get_pseudo_slug()))
),
'thumbUrl': request.build_absolute_uri(
reverse('image_thumb', args=(photo.id, 400, photo.get_pseudo_slug()))
)
})
return Response({})
def formatNewData(location):
ct = CoordTransform(SpatialReference('epsg:4326'),
SpatialReference('epsg:3857'))
for n in location:
if n.name.isdigit():
temp = n.name
if n.description == '':
if n.addit_info == '':
n.delete()
continue
else:
n.name = n.addit_info.capitalize() + ", id: " + temp
n.description = n.addit_info
else:
if n.addit_info == '' or n.addit_info == 'building':
n.name = n.description + ", id: " + temp
else:
n.name = n.addit_info.capitalize(
) + ': ' + n.description + ", id: " + temp
n.description = n.addit_info + " id: " + temp
n.name = re.sub(r'[^\x00-\x7F]+', ' ', n.name)
n.fence.transform(ct)
try:
n.update()
except Exception as e:
print(str(e))
print("\n updated " + temp)
def spatial_search():
geojson = [
u'POLYGON ((272268.6283144115 200270.16611863102,272618.35541865695 214073.16809610612,353647.5501633153 212672.1529419519,353520.31875525665 198867.7012925945,272268.6283144115 200270.16611863102))'
]
ct = CoordTransform(SpatialReference('EPSG:27700'),
SpatialReference('EPSG:4326'))
# geom = GEOSGeometry(geojson[0], srid=27700).transform(ct)
geom = GEOSGeometry(geojson[0], srid=27700)
spatial_intersects = models.FeatureStore.objects.filter(
geometry__intersects=geom)
print spatial_intersects.count()
response_data = {}
response_data['data'] = list(
spatial_intersects.values_list('name', flat=True))
print response_data['data']
print type(response_data['data'])
f = models.FeatureStore.objects.filter(id=2)[0]
print f.name
print f.geometry.distance(geom)
def project_meter2degree(layer=None, num=1, offset=0, topo=True):
'''
Function to reproject gdal layer(in meters) to degree, and output geojson file
num is the amount of block to keep from the layer
In: layer : a json layer with a meter or feet projection
Out: json : a json reprojected to decimal degrees in order to be displayed on a background map
'''
layer_json = []
for la in layer[offset * num:num + offset * num]:
if topo:
myjson = la.topo_json
else:
myjson = la.road_json
#convert json to gdal object
new_layer = DataSource(myjson)[0]
#get the srs
srs = la.srs
#check if srs is not numerical
if not isnumber(srs):
#if not numerical assign default srs
srs = default_srs
new_proj = []
#reproject gdal layer
coord_transform = CoordTransform(SpatialReference(srs),
SpatialReference(4326))
for feat in new_layer:
geom = feat.geom
geom.transform(coord_transform)
new_proj.append(json.loads(geom.json))
layer_json.extend(new_proj)
#save new layer as a json
layer_json = json.dumps(layer_json)
return layer_json
def photos_bbox(request):
form = DelfiBboxRequestForm(request.query_params)
if form.is_valid():
qs = Photo.objects.filter(
rephoto_of__isnull=True,
lat__isnull=False,
lon__isnull=False,
confidence__gte=0.2,
lat__gte=form.cleaned_data['top_left'].y,
lon__gte=form.cleaned_data['top_left'].x,
lat__lte=form.cleaned_data['bottom_right'].y,
lon__lte=form.cleaned_data['bottom_right'].x).order_by('?')[:500]
our_ref = SpatialReference(4326)
delfi_ref = SpatialReference(3301)
trans = CoordTransform(our_ref, delfi_ref)
photos = []
for p in qs:
location = Point(x=p.lon, y=p.lat, srid=4326)
location.transform(trans)
photos.append({
'id': p.id,
'latitude': location.y,
'longitude': location.x,
'description': p.description,
})
return Response(photos)
return Response([])
def transform(self, srs):
"""
Transforms the geometry to EPSG:4326 and ensures it's a MultiPolygon.
"""
geometry = self.geometry_to_multipolygon(self.geometry)
geometry.transform(CoordTransform(srs, SpatialReference(4326)))
return Geometry(geometry)
def clean(self):
cleaned_data = super(DelfiBboxRequestForm, self).clean()
bbox_str = cleaned_data.get('bbox')
if not bbox_str:
raise forms.ValidationError(_('Bounding box must be set'))
bbox_parts = bbox_str.split(',')
if len(bbox_parts) != 4:
raise forms.ValidationError(
_('Bounding box must have 4 comma-separated members'))
else:
try:
bbox_parts = [float(x) for x in bbox_parts]
except:
raise forms.ValidationError(
_('Bounding box values must be numbers'))
our_ref = SpatialReference(4326)
delfi_ref = SpatialReference(3301)
trans = CoordTransform(delfi_ref, our_ref)
top_left = Point(y=bbox_parts[1], x=bbox_parts[0], srid=3301)
bottom_right = Point(y=bbox_parts[3], x=bbox_parts[2], srid=3301)
top_left.transform(trans)
bottom_right.transform(trans)
cleaned_data['top_left'] = top_left
cleaned_data['bottom_right'] = bottom_right
return cleaned_data
def handle(self, *args, **options):
'''
Import practice eastings and northings, from HSCIC data.
'''
if not options['filename']:
print 'Please supply a filename'
else:
self.IS_VERBOSE = False
if options['verbosity'] > 1:
self.IS_VERBOSE = True
gridall = csv.reader(open(options['filename'], 'rU'))
postcodes = {}
for row in gridall:
postcode = row[1].replace(' ', '').strip()
postcodes[postcode] = [row[36], row[37]]
wgs84 = SpatialReference(4326)
bng = SpatialReference(27700)
trans = CoordTransform(bng, wgs84)
practices = Practice.objects.all().reverse()
for practice in practices:
practice.location = None
postcode = practice.postcode.replace(' ', '').strip()
if postcode in postcodes:
lng = postcodes[postcode][0]
lat = postcodes[postcode][1]
pnt = Point(int(lng), int(lat), srid=27700)
pnt.transform(trans)
practice.location = pnt
practice.save()
def AbrirBeneficiario(request,id_beneficiario):
if request.user.is_authenticated():
from geo_liberty.models import Municipio
from models import Beneficiario,Familia,PoliticaPublica_Beneficiario,OrganizacaoSocial_Beneficiario
ct = CoordTransform(SpatialReference('EPSG:4326'), SpatialReference('EPSG:900913'))
taquarucu = Municipio.objects.filter(id = 4321329)
for feat in taquarucu:
municipio = feat.mpoly
municipio.transform(ct)
unidade = UnidadeProducao.objects.filter(beneficiario = id_beneficiario)
for feat in unidade:
feat.ponto.transform(ct)
beneficiario = Beneficiario.objects.filter(id=id_beneficiario)
familia = Familia.objects.filter(beneficiario=id_beneficiario)
politicasPublicas = PoliticaPublica_Beneficiario.objects.filter(beneficiario=id_beneficiario)
organizacoesSociais = OrganizacaoSocial_Beneficiario.objects.filter(beneficiario=id_beneficiario)
return render_to_response('beneficiario.html',
RequestContext(request,{'beneficiario': beneficiario,
'familia':familia,
'politicasPublicas':politicasPublicas,
'organizacoesSociais':organizacoesSociais,
'municipio':municipio,
'unidade':unidade}))
else:
return render_to_response('login.html',
RequestContext(request,{}))
def planify_coords(lat, lon):
""" See osmdata/geo_utils.py """
planification = CoordTransform(SpatialReference(4326),
SpatialReference(3857))
point = Point(lon, lat, srid=4326)
point.transform(planification)
return point
def update_sedes_municipais(shapefilename, srid=4618):
# dados de um shapefile de 2001
ds = DataSource(shapefilename)
transform_coord = None
if srid != SRID:
transform_coord = CoordTransform(SpatialReference(srid), SpatialReference(SRID))
ct = 0
cta = 0
for f in ds[0]:
ct +=1
cod = f.get('CODIGO')
muns = Municipio.objects.extra(where=['CAST(id_ibge AS VARCHAR) ILIKE %s'], params=['%s%%' % cod])
if muns:
if len(muns) > 1:
print("Mais de 1 municipio para", cod)
for m in muns:
print(m.id_ibge, m)
else:
g = f.geom
g.srs = SpatialReference(srid)
g.srid = srid
if transform_coord:
g.transform(transform_coord)
print(g.ewkt)
muns[0].sede = g.ewkt
muns[0].save()
cta += 1
else:
print(cod, "nao econtrado!")
print("Atualizados", cta, "sedes")
print("Total de", ct, "registros no shapefile")
def geom_to_json(geom, target_srs):
srs = srs_cache.get(geom.srid, None)
if not srs:
srs = geom.srs
srs_cache[geom.srid] = srs
if target_srs:
ct_id = '%s-%s' % (geom.srid, target_srs.srid)
ct = coord_transforms.get(ct_id, None)
if not ct:
ct = CoordTransform(srs, target_srs)
coord_transforms[ct_id] = ct
else:
ct = None
if ct:
wkb = geom.wkb
geom = gdal.OGRGeometry(wkb, srs)
geom.transform(ct)
geom_name = geom.geom_name.lower()
else:
geom_name = geom.geom_type.lower()
# Accelerated path for points
if geom_name == 'point':
if target_srs.projected:
digits = 2
else:
digits = 7
coords = [round(n, digits) for n in [geom.x, geom.y]]
return {'type': 'Point', 'coordinates': coords}
s = geom.geojson
return json.loads(s)
def test_srs_transform(self):
"Testing transform()."
orig = OGRGeometry('POINT (-104.609 38.255)', 4326)
trans = OGRGeometry('POINT (992385.4472045 481455.4944650)', 2774)
# Using an srid, a SpatialReference object, and a CoordTransform object
# or transformations.
t1, t2, t3 = orig.clone(), orig.clone(), orig.clone()
t1.transform(trans.srid)
t2.transform(SpatialReference('EPSG:2774'))
ct = CoordTransform(SpatialReference('WGS84'), SpatialReference(2774))
t3.transform(ct)
# Testing use of the `clone` keyword.
k1 = orig.clone()
k2 = k1.transform(trans.srid, clone=True)
self.assertEqual(k1, orig)
self.assertNotEqual(k1, k2)
# Different PROJ versions use different transformations, all are
# correct as having a 1 meter accuracy.
prec = -1
for p in (t1, t2, t3, k2):
self.assertAlmostEqual(trans.x, p.x, prec)
self.assertAlmostEqual(trans.y, p.y, prec)
def handle(self, *args, **options):
"""
Import practice eastings and northings, from HSCIC data.
"""
if not options["filename"]:
print("Please supply a filename")
else:
self.IS_VERBOSE = False
if options["verbosity"] > 1:
self.IS_VERBOSE = True
gridall = csv.reader(open(options["filename"], "rU"))
postcodes = {}
for row in gridall:
postcode = row[1].replace(" ", "").strip()
postcodes[postcode] = [row[36], row[37]]
wgs84 = SpatialReference(4326)
bng = SpatialReference(27700)
trans = CoordTransform(bng, wgs84)
practices = Practice.objects.filter(
postcode__isnull=False).reverse()
for practice in practices:
practice.location = None
postcode = practice.postcode.replace(" ", "").strip()
if postcode in postcodes:
lng = postcodes[postcode][0]
lat = postcodes[postcode][1]
if lng and lat:
pnt = Point(int(lng), int(lat), srid=27700)
pnt.transform(trans)
practice.location = pnt
practice.save()
def project_to_WGS84(self, ov_bbox, ov_crs, center=None):
try:
srid = int(ov_crs.split(':')[1])
srid = 3857 if srid == 900913 else srid
poly = Polygon(((ov_bbox[0], ov_bbox[1]), (ov_bbox[0], ov_bbox[3]),
(ov_bbox[2], ov_bbox[3]), (ov_bbox[2], ov_bbox[1]),
(ov_bbox[0], ov_bbox[1])),
srid=srid)
if srid != 4326:
gcoord = SpatialReference(4326)
ycoord = SpatialReference(srid)
trans = CoordTransform(ycoord, gcoord)
poly.transform(trans)
try:
if not center:
center = {
"x": get_valid_number(poly.centroid.coords[0]),
"y": get_valid_number(poly.centroid.coords[1]),
"crs": "EPSG:4326"
}
zoom = GoogleZoom().get_zoom(poly) + 1
except Exception:
center = (0, 0)
zoom = 0
tb = traceback.format_exc()
logger.debug(tb)
except Exception:
tb = traceback.format_exc()
logger.debug(tb)
return (center, zoom)
def handle_shapefile(filename, folderPath, user_id):
print "okay so long"
filepath = os.path.abspath(os.path.join(folderPath, filename))
category = os.path.basename(os.path.splitext(filename)[0])
folder = os.path.join(folderPath, category)
ds = DataSource(filepath)
layer = ds[0]
srs = layer.srs
coord_trans = CoordTransform(
srs, SpatialReference(4326)) # if we get data in another ref sys
geomtype = str(layer.geom_type)
geometry = geometry_mapper[geomtype]
models_to_save = []
for feature in layer:
geom_geos = geometry(feature.geom.geos)
try:
name = feature.get("name")
except:
name = category
if not name:
name = category
geom_geos.transform(coord_trans)
models_to_save.append(LarshbjGeoModel(name = name, category = category,\
user_id = user_id, geom=geom_geos, geom_type = geomtype))
LarshbjGeoModel.objects.bulk_create(models_to_save, 100)
