def findFeature(shapefile, longitude, latitude, buffer=20000, distance=2):
pt = Point(longitude, latitude)
circle = pt.buffer(buffer)
radius = calcSearchRadius(latitude, longitude, distance)
## if shapefile.geom_type in ["Point", "3D Point"]:
## try:
## return Feature.objects.filter(geom_point__intersects=circle, shapefile=shapefile)[:1].get()
## except Feature.DoesNotExist:
## return None
if shapefile.geom_type in ["LineString", "3D LineString", "MultiLineString", "3D MultiLineString"]:
try:
return Feature.objects.get(geom_multilinestring__intersects=circle, shapefile=shapefile)[:1].get()
except Feature.DoesNotExist:
return None
elif shapefile.geom_type in ["Polygon", "3D Polygon", "MultiPolygon", "3D MultiPolygon" ]:
try:
return Feature.objects.get(geom_multipolygon__contains=pt, shapefile=shapefile)
except Feature.DoesNotExist:
return None
elif shapefile.geom_type in ["Point", "MultiPoint", "3D MultiPoint"]:
try:
return Feature.objects.filter(geom_multipoint__intersects=circle, shapefile=shapefile)[:1].get()
except Feature.DoesNotExist:
return None
elif shapefile.geom_type in ["GeometryCollection", "3D GeometryCollection"]:
try:
return feature.objects.get(geom_geometrycollection__dwithin=(pt, radius))
except Feature.DoesNotExist:
return None
else:
print "Unsupported geometry: " + shapefile.geom_type
return None
def test_has_itree_region_with_intersects(self):
p1 = Point(0, 0)
instance = make_instance(point=p1)
instance.save()
ITreeRegion.objects.create(geometry=MultiPolygon((p1.buffer(10))))
self.assertEqual(instance.has_itree_region(), True)
def playground(request):
"""Handle GET Requests for Playgrounds"""
distance = request.GET.get('distance', None)
lat = request.GET.get('lat', None)
lng = request.GET.get('lng', None)
if not all([distance, lat, lng]):
playgrounds = Playground.objects.all()
else:
point = Point(float(lng), float(lat), srid=4326)
point.transform(26918)
circle = point.buffer(float(distance))
playgrounds = Playground.objects.filter(location__within=circle)
serialized = serialize('geojson', playgrounds, geometry_field='location', fields=('name', 'address'))
return HttpResponse(serialized, content_type="application/json")
def get_queryset(self):
if not self.request.GET.get('lat'):
return None
nearby_degrees = 0.3
lat = float(self.request.GET.get('lat'))
lng = float(self.request.GET.get('lng'))
user_location = Point(lng, lat)
near_user = user_location.buffer(nearby_degrees)
points = MapData.objects.filter(points__contained=near_user).distance(user_location, field_name='points').order_by('distance')[:30]
polys = MapData.objects.filter(polys__contained=near_user).distance(user_location, field_name='polys').order_by('distance')[:30]
lines = MapData.objects.filter(lines__contained=near_user).distance(user_location, field_name='lines').order_by('distance')[:30]
queryset = sorted(list(points)+list(polys)+list(lines), key=attrgetter('distance'))[:30]
return queryset
def read(self, obj):
tree = parse(obj)
if self.test(tree):
decoder = SiteFormatDecoder(tree)
location = Point(decoder.longitude, decoder.latitude)
return {
"identifier": decoder.identifier,
"location": location,
"footprint": MultiPolygon(location.buffer(0.01)),
"elevation": decoder.elevation,
"coverage_type": "",
"size": (decoder.size, 1),
"projection": 4326,
"begin_time": min(decoder.start_times),
"end_time": max(decoder.end_times),
"extent": (0, 0, 1, 1),
"coverage_type": "dav_prc.models.SiteDataset",
}
raise Exception("Could not parse from obj '%r'." % obj)
def assertViewPerformsCorrectly(self, before_add_expected_value,
after_add_expected_value,
x=-8515941.0,
y=4953519.0,
params=None,
make_point_from_x_y=True):
params = params or {'x': str(x), 'y': str(y)}
p = Point(x, y) if make_point_from_x_y else Point(0, 0)
request = RequestFactory().get('', params)
result = within_itree_regions(request)
self.assertEqual(result, before_add_expected_value)
ITreeRegion.objects.create(code='NoEastXXX',
geometry=MultiPolygon([p.buffer(1000)]))
result = within_itree_regions(request)
self.assertEqual(result, after_add_expected_value)
def cover_city(city_slug, radius):
"""
An iterator that yields a centroid (lng, lat) for a circle buffer with
radius given. The total buffers completely cover the city and no buffers
that do not intersect with the city boundary are included.
Radius is in kilometers.
"""
def shapefile_path(city):
return os.path.normpath(os.path.join(settings.SHAPEFILE_ROOT, city, 'city_4326'))
ds = DataSource(shapefile_path(city_slug) + '.shp')
city_geom = reduce_layer_geom(ds[0], 'union')
city_geom.srid = 4326
city_geom.transform(900913)
for (x, y) in cover_region(get_metro(city_slug)['extent'], radius):
pt = Point(x, y, srid=4326)
pt.transform(900913)
buf = pt.buffer(radius)
if buf.intersects(city_geom.geos):
yield (x, y)
def get_near(self, json, p_lat, p_lng, p_r):
central_point = Point(p_lng, p_lat)
circle = central_point.buffer(p_r/100000.0)
#print circle.json
points = []
for o in json:
lat = o['geo']['lat']
lng = o['geo']['lng']
if lat == None: continue
point = Point( lng , lat)
points.append(point)
mp = MultiPoint(points)
mp_results = mp.intersection(circle)
result = [mp_results.coords] if mp_results.geom_type == 'Point' else [coord for coord in mp_results.coords]
return result
def setUp(self):
self.instance = make_instance(is_public=True)
self.user = make_commander_user(self.instance)
self.species = Species(otm_code='CEAT',
genus='cedrus',
species='atlantica',
max_dbh=2000,
max_height=100,
instance=self.instance)
self.species.save_with_user(self.user)
ITreeRegion.objects.all().delete()
p1 = Point(-8515941.0, 4953519.0)
self.region_buffer_in_meters = 1000
ITreeRegion.objects.create(
code='NoEastXXX',
geometry=MultiPolygon([p1.buffer(1000)]))
self.plot = Plot(geom=p1,
instance=self.instance)
self.plot.save_with_user(self.user)
self.tree = Tree(plot=self.plot,
instance=self.instance,
readonly=False,
species=self.species,
diameter=1630)
self.tree.save_with_user(self.user)
def school_sheds_results(request=None, school_id=None, bbox=None, width=816, height=1056, srid=3857, format='png'):
'''
Default height and width are 'Letter' ratio
'''
format = format.encode('ascii')
school = School.objects.get(pk=school_id)
point = school.geometry
circle = point.buffer(3400.0)
m = mapnik.Map(int(width), int(height), "+init=epsg:"+str(srid))
mapnik.load_map(m, os.path.dirname(__file__)+"/basemap/basemap.xml")
if bbox is None:
circle.transform(srid)
bbox = mapnik.Box2d(*circle.extent)
m.zoom_to_box(bbox)
#m.background = mapnik.Color('steelblue')
# styles for sheds
s = mapnik.Style()
for name, color in (('0.5', VIOLET), ('1.0', PURPLE), ('1.5', LAVENDER), ('2.0', LIGHTCYAN)):
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = "+name)
c = mapnik.Color(color)
c.a = 80
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color("gray"), 1)
poly_symbolizer = mapnik.PolygonSymbolizer(c)
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
# styles for schools
school_colors = SCHOOL_COLORS
for name, color in school_colors:
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = '"+name+"'")
line_symbolizer = mapnik.LineSymbolizer()
poly_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color(color))
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] != 'map_title' and [name] != 'map_subtitle' and [name] != 'legend_title' and [name] != 'school'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'), 'DejaVu Sans Book', 9, mapnik.Color('black'))
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.halo_radius = 1
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
#text_symbolizer.label_placement = mapnik.label_placement.VERTEX_PLACEMENT
text_symbolizer.allow_overlap = True
text_symbolizer.displacement = (12, 0)
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'map_title'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'), 'DejaVu Sans Book', 15, mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'map_subtitle'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'), 'DejaVu Sans Book', 12, mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'legend_title'")
text_symbolizer = mapnik.TextSymbolizer(mapnik.Expression('[label]'), 'DejaVu Sans Condensed Bold', 11, mapnik.Color('black'))
text_symbolizer.horizontal_alignment = mapnik.horizontal_alignment.RIGHT
text_symbolizer.halo_fill = mapnik.Color('white')
text_symbolizer.halo_radius = 1
text_symbolizer.allow_overlap = True
r.symbols.append(text_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'legend_box'")
poly_symbolizer = mapnik.PolygonSymbolizer(mapnik.Color("white"))
line_symbolizer = mapnik.LineSymbolizer(mapnik.Color("black"), 0.5)
poly_symbolizer.fill_opacity = 0.8
r.symbols.append(line_symbolizer)
r.symbols.append(poly_symbolizer)
s.rules.append(r)
r = mapnik.Rule()
r.filter = mapnik.Expression("[name] = 'school'")
ps = mapnik.PointSymbolizer(mapnik.PathExpression(os.path.dirname(__file__)+'/static/img/School.svg'))
ps.transform = 'scale(0.06)'
ps.allow_overlap = True
#shield.label_placement = mapnik.label_placement.POINT_PLACEMENT
r.symbols.append(ps)
s.rules.append(r)
m.append_style("surveys", s)
def p2l(pct_x, pct_y):
loc_x = bbox.minx + (bbox.maxx - bbox.minx) * pct_x / 100.0
loc_y = bbox.miny + (bbox.maxy - bbox.miny) * pct_y / 100.0
return (loc_x, loc_y)
sheds = {
0.5: school.shed_05,
1.0: school.shed_10,
1.5: school.shed_15,
2.0: school.shed_20
}
csv_string = 'wkt,name,label\n'
for key, g in reversed(sorted(sheds.items(), key=lambda a: a[0])):
if g is None:
continue
g.srid = 26986
g.transform(srid)
csv_string += '"%s","%s",""\n' % (g.wkt, str(key))
surveys = Survey.objects.filter(school=school)
for survey in surveys:
survey.location.transform(srid)
children = list(survey.child_set.all())
if len(children) > 0:
for c in children:
name = str(c.to_school)
point = survey.location
point.x += random.randint(-50, 50)
point.y += random.randint(-50, 50)
school_circle = point.buffer(50)
csv_string += '"%s","%s",""\n' % (school_circle.wkt, name)
else:
name = "o"
point = survey.location
point.x += random.randint(-50, 50)
point.y += random.randint(-50, 50)
school_circle = point.buffer(50)
csv_string += '"%s","%s",""\n' % (school_circle.wkt, name)
#Add School geometry
school.geometry.transform(srid)
csv_string += '"%s","school","%s"\n' % (school.geometry.wkt, school.name)
def box(minx, miny, maxx, maxy):
lmin = Point(p2l(minx, miny))
lmax = Point(p2l(maxx, maxy))
lr = LinearRing((lmin.x, lmin.y), (lmax.x, lmin.y), (lmax.x, lmax.y), (lmin.x, lmax.y), (lmin.x, lmin.y))
poly = Polygon(lr)
return poly
legend = box(2, 108, 50, 113.5)
csv_string += '"%s","%s","%s"\n' % (legend.wkt, "legend_box", "")
xy = p2l(3.5, 112)
point = Point(*xy)
csv_string += '"%s","%s","School Commute Survey Results"\n' % (point.wkt, "map_title")
xy = p2l(3.5, 109.5)
point = Point(*xy)
csv_string += '"%s","%s","%s, %s"\n' % (point.wkt, "map_subtitle", school, school.districtid)
legend_x = 53
legend = box(legend_x, 97, 97.5, 113.5)
csv_string += '"%s","%s","%s"\n' % (legend.wkt, "legend_box", "")
xy = p2l(legend_x + 1.5, 112)
point = Point(*xy)
csv_string += '"%s","legend_title","Approx. home locations and travel to school mode"\n' % (point.wkt, )
walksheds_x = 88
xy = p2l(walksheds_x, 112)
point = Point(*xy)
csv_string += '"%s","legend_title","Walksheds"\n' % (point.wkt, )
y = 111.5
for name, label in school_colors:
y -= 1.8
xy = p2l(legend_x+2, y)
point = Point(*xy)
circle = point.buffer(50)
csv_string += '"%s","%s","%s"\n' % (circle.wkt, name, MODE_DICT[name])
y = 110
for name in ('0.5', '1.0', '1.5', '2.0',):
y -= 2.4
ws = box(walksheds_x, y, walksheds_x+2, y+1.5)
csv_string += '"%s","%s","%s Mile"\n' % (ws.wkt, name, name)
layer = mapnik.Layer('surveys', "+init=epsg:"+str(srid))
ds = mapnik.Datasource(type="csv", inline=csv_string.encode('ascii'))
layer.datasource = ds
layer.styles.append('surveys')
m.layers.append(layer)
# Render to image
if format == 'pdf':
tmp_file = tempfile.NamedTemporaryFile()
surface = cairo.PDFSurface(tmp_file.name, m.width, m.height)
mapnik.render(m, surface)
surface.finish()
tmp_file.seek(0)
im = tmp_file.read()
else:
im = mapnik.Image(m.width, m.height)
mapnik.render(m, im)
im = im.tostring(format)
response = HttpResponse()
response['Content-length'] = str(len(im))
response['Content-Type'] = mimetypes.types_map['.'+format]
response.write(im)
return response
def get_centered_envelope(point=None, radius=None):
if not point:
point = Point(float(fake.longitude()), float(fake.latitude()))
return point.buffer(
fake.random_digit() if radius is None else radius
).envelope
def location(bot, update):
# Colors: Red, Blue, Purple, Green, Yellow, Brown, Orange, Grey
listOfColor = [
'#8B0000', '#0000FF', '#8A2BE2', '#228B22', '#FFD700', '#8B4513',
'#D2691E', '#808080'
]
print("parkingStreetHandler.location")
user = User.objects.get(chat_id=update.message.chat_id)
point = Point(user.lon, user.lat)
#Distance in KM to search the parkings close by
radius = 0.5
radius = radius / 40000 * 360
circle = point.buffer(radius)
print('valori cerchio: ' + str(circle))
shape = multiPolygonHandler.getMultiPolygonByPoint(point)
#shape = multiPolygonHandler.getAllMultiPolygon()
#print(shape)
m = StaticMap(600, 800, 12, 12, tile_size=256)
#icon_flag = IconMarker((user.lon, user.lat), './bot/static/images/marker.png', 100, 100)
marker_outline = CircleMarker((user.lon, user.lat), 'white', 22)
marker = CircleMarker((user.lon, user.lat), 'Red', 18)
m.add_marker(marker_outline)
m.add_marker(marker)
#m = StaticMap(width=600, height=800)
circleLine = Line(circle[0], color='red', width=3)
geoCircle = GEOPolygon(circle[0])
#DISEGNA IL CERCHIO PER CONTROLLARE I PARCHEGGI LIMITROFI
m.add_line(circleLine)
listPolygon, listOfColor2, listOfMultiPolygon = getAllPolygonsInCircleArea(
geoCircle)
i = 0
if len(listPolygon) is not 0:
for p in listPolygon:
polygonLine = Line(p[0], color=listOfColor[i], width=3)
m.add_line(polygonLine)
i = i + 1
image = m.render(zoom=14)
fileName = 'ParkingStreet' + str(update.message.chat_id) + '.png'
image.save(fileName)
baseDir = settings.BASE_DIR
picture = open(baseDir + '/' + fileName, 'rb')
text = buildParkingZoneMessage(listOfMultiPolygon)
btn_keyboard1 = KeyboardButton(text="Find another parking")
btn_keyboard2 = KeyboardButton(
text="Find closest electric charge point")
btn_keyboard3 = KeyboardButton(text="Show my profile")
btn_keyboard4 = KeyboardButton(text="That's all, thanks")
custom_keyboard = [[btn_keyboard1], [btn_keyboard2], [btn_keyboard3],
[btn_keyboard4]]
reply_markup = telegram.ReplyKeyboardMarkup(custom_keyboard,
resize_keyboard=True,
one_time_keyboard=True)
bot.sendPhoto(chat_id=update.message.chat_id, photo=picture)
bot.sendMessage(chat_id=update.message.chat_id,
text=text,
parse_mode='HTML')
bot.sendMessage(chat_id=update.message.chat_id,
text='What do you want to do now?',
reply_markup=reply_markup)
userHandler.setUserBotActived(update.message.chat_id, True)
else:
btn_keyboard1 = KeyboardButton(text="Find another parking")
btn_keyboard2 = KeyboardButton(
text="Find closest electric charge point")
btn_keyboard3 = KeyboardButton(text="Show my profile")
btn_keyboard4 = KeyboardButton(text="That's all, thanks")
custom_keyboard = [[btn_keyboard1], [btn_keyboard2], [btn_keyboard3],
[btn_keyboard4]]
reply_markup = telegram.ReplyKeyboardMarkup(custom_keyboard,
resize_keyboard=True,
one_time_keyboard=True)
bot.sendMessage(
chat_id=update.message.chat_id,
text='There is no parking info close to your position.')
bot.sendMessage(chat_id=update.message.chat_id,
text='What do you want to do now?',
reply_markup=reply_markup)
userHandler.setUserBotActived(update.message.chat_id, True)
