def createIntermediateImage(translated, intermediateShape, pixels):
intermediate = ()
for x in translated.tolist()[0]:
intermediate = intermediate + ((x[0], x[1]), )
poly_unordered = MultiPoint(intermediate).convex_hull
img_width, img_height = pixels
intermediate_img = Image.new('1', (img_width, img_height))
pixels = intermediate_img.load()
white = 1 #(255,255,255)
black = 0 #(0,0,0)
for i in range(img_width):
for j in range(img_height):
point = Point(i, j)
if poly_unordered.contains(point):
pixels[i, j] = white #formerly grey
else:
pixels[i, j] = black
for i in intermediate:
pixels[i[0], i[1]] = white
intermediate_img.save(intermediateShape)
def get_city_name():
if request.headers['Content-Type'] == 'text/plain':
try:
text = request.data.decode("utf-8")
lat, lon = text.split("+")
cur = myConnection.cursor()
query = "SELECT name, coordinates FROM geo_cords"
cur.execute(query)
count = 0
point = Point(float(lat), float(lon))
for place, coor in cur.fetchall():
lats = []
lons = []
coor = coor.replace("{", "").replace("}", "").split(",")
coor = list(map(float, coor))
for index, val in enumerate(coor):
if index % 2 == 0:
lats.append(val)
else:
lons.append(val)
points = []
for i in range(len(lats)):
points.append(Point(lons[i], lats[i]))
hull = MultiPoint(points=points).convex_hull
if hull.contains(point):
count += 0
return "Location found in: " + place
if count == 0:
return "Location not found!"
except:
print("Invalid input provided!")
return "Invalid Input!"
def createIntermediateImage(translated, intermediateShape, pixels):
intermediate=()
for x in translated.tolist()[0]:
intermediate = intermediate + ((x[0],x[1]),)
poly_unordered = MultiPoint(intermediate).convex_hull
img_width, img_height = pixels
intermediate_img = Image.new('1', (img_width, img_height))
pixels = intermediate_img.load()
white = 1 #(255,255,255)
black = 0 #(0,0,0)
for i in range(img_width):
for j in range(img_height):
point = Point(i,j)
if poly_unordered.contains(point):
pixels[i,j] = white #formerly grey
else:
pixels[i,j] = black
for i in intermediate:
pixels[i[0],i[1]] = white
intermediate_img.save(intermediateShape)
def check_polygon_for_image(image_path, polygon):
im = PIL.Image.open(image_path)
width, height = im.size
for x in range(width):
for y in range(height):
#print('Checking pixel '+str(x)+' '+str(y))
point = Point(x, y)
poly = MultiPoint(polygon).convex_hull
#print(poly.contains(point))
if poly.contains(point):
rgb_list = []
r, g, b = im.getpixel((x, y))
rgb_list.append(r)
rgb_list.append(g)
rgb_list.append(b)
hand_list.append(rgb_list)
print(str(r) + ' ' + str(g) + ' ' + str(b))
else:
rgb_list = []
r, g, b = im.getpixel((x, y))
rgb_list.append(r)
rgb_list.append(g)
rgb_list.append(b)
background_list.append(rgb_list)
np.save('handlist.npy', hand_list)
np.save('background_list.npy', background_list)
def PreciseLabels(data_shape, argmin_xy, out_edges, mask_center):
"""
Fuction
"""
mesh_x, mesh_y = np.meshgrid(np.arange(data_shape[1]), np.arange(data_shape[0]))
coords = np.vstack((mesh_x.ravel(), mesh_y.ravel())).T
coords = MultiPoint(coords)
label_data_prec = np.zeros(data_shape, dtype=int)
num = np.sum(mask_center) # number of precise labels
percentage = np.rint(np.linspace(0,num,21)).astype(int)
count = 0 # number of calculated labels
print('Calculated: ', end='')
for i, outs in enumerate(out_edges):
if mask_center[i] == True:
poly = MultiPoint(argmin_xy.T[outs]).convex_hull
inpoints = [point for point in coords if poly.contains(point)]
for point in inpoints:
label_data_prec[point.y, point.x] = i + 1
if count in percentage:
print('{}%... '.format(np.argwhere(percentage==count)[0,0]*5), end='')
elif count == num - 1:
print('100%')
count += 1
return label_data_prec
def get_city_name():
if request.headers['Content-Type'] == 'text/plain':
try:
text = request.data.decode("utf-8")
lat,long=text.split("+")
cur=myConnection.cursor()
query="select name,parent,coordinates from compute"
cur.execute(query)
sd=pd.DataFrame(cur.fetchall(),columns=["name","parent","coordinates"])
for index in sd.iterrows():
kj=sd.coordinates[index[0]].replace("{","").replace("}","").split(",")
xs=[]
ys=[]
c=0
for i in kj:
p=float(i)
if c%2==0:
xs.append(p)
else:
ys.append(p)
c+=1
sd.coordinates[index[0]]=list(zip(xs,ys))
x=float(lat)
y=float(long)
for index, row in sd.iterrows():
poly = MultiPoint(row["coordinates"]).convex_hull
point = Point(y,x)
if poly.contains(point)==True:
print(str(sd.loc[index,"name"]))
return "the place of location is " + str(sd.loc[index,"name"])
except:
print("wrong input given by user")
return "you have entered wrong data"
else:
return "415 Unsupported Media Type ;)"
def in_gate(data, gate, name1, name2):
x_data = data[name1]
y_data = data[name2]
x_data = [np.log10(max(x, 1e-10)) for x in x_data]
y_data = [np.log10(max(y, 1e-10)) for y in y_data]
poly = MultiPoint(gate).convex_hull
usethis = [poly.contains(Point(x, y)) for x, y in zip(x_data, y_data)]
return usethis
class FlightParser(object):
def __init__(self, args):
self.bounds = args.bounds
self.date = args.date
self.days_ahead = int(args.days_ahead)
self.bounds_fp = geojson.load(open(args.bounds))
self.coords = self.bounds_fp['features'][0]['geometry']['coordinates'][0]
self.shape = MultiPoint(self.coords).convex_hull
self.out_tmpfile = "%s.json" % str(uuid.uuid4())
self.inside = []
def run(self):
if self.days_ahead == 1:
self.parse(self.date)
else:
year, month, day = self.date.split('-')
for date in self.find_dates(int(year), int(month), int(day)):
self.parse(date)
with open(self.out_tmpfile, 'w') as f:
f.write(json.dumps(inside))
print 'Filtered data is now in %s' % self.out_tmpfile
def find_dates(self, year, month, day):
base = datetime.datetime(year, month, day)
for obj in [base + datetime.timedelta(days=x) for x in range(0, self.days_ahead)]:
yield obj.strftime('%Y-%m-%d')
def parse(self, date):
print 'Downloading http://history.adsbexchange.com/Aircraftlist.json/%s.zip' % date
temp_file = '/tmp/adsb_%s.zip' % date
if not os.path.exists(temp_file):
r = requests.get('http://history.adsbexchange.com/Aircraftlist.json/%s.zip' % date, stream=True)
with open(temp_file, 'wb') as f:
total_length = int(r.headers.get('content-length'))
for chunk in progress.bar(r.iter_content(chunk_size=1024), expected_size=(total_length/1024) + 1):
if chunk:
f.write(chunk)
f.flush()
self.filter(temp_file, date)
def filter(self, f, date):
out_tmpfile = 'filtered_%s.json' % date
zf = zipfile.ZipFile(f)
for info in zf.infolist():
try:
data = json.loads(zf.read(info.filename))
print "Working on", info.filename
for sample in data['acList']:
if 'Lat' in sample and 'Long' in sample and 'Icao' in sample:
point = Point([sample['Long'], sample['Lat']])
if self.shape.contains(point):
self.inside.append(sample)
except Exception as e:
print "Could not read %s from ZIP archive" % info.filename
print "Error:", e
os.remove(f)
def city_point(city):
"""
:param city:需要查询的城市
:return:城市内的符合要求的等距坐标
"""
list_p = []
list_q = []
# 根据接口查询城市边界的坐标
url = city_url.format(0, GAODE_API_KEY, city)
response = requests.get(url=url, headers=headers)
data = response.json()
# 获得城市边界坐标
poly = data['districts'][0]['polyline']
# 不匹配岛屿
# poly = re.sub('\|.*\|',';',poly)
# poly = poly.split("|")
poly = re.sub('\|', ';', poly)
# print(len(poly))
# 将坐标进行处理，获得四个角落的坐标，构造一个矩形网络
poly_list1 = poly.split(';')
poly_list2 = list(zip(*[a.split(',') for a in poly_list1]))
max_lng = max([int(a.replace('.', '')) for a in poly_list2[0]])
min_lng = min([int(a.replace('.', '')) for a in poly_list2[0]])
max_lat = max([int(a.replace('.', '')) for a in poly_list2[1]])
min_lat = min([int(a.replace('.', '')) for a in poly_list2[1]])
# 纬度1°为111.3195km，经度每度为111.3195cos(纬度)
g = int((max_lng - min_lng) * 102.3022 / 4242640)
g1 = [round(min_lng + i * 4242640 / 102.3022) for i in range(1, g)]
h = int((max_lat - min_lat) * 111.3195 / 4242640)
h1 = [round(min_lat + i * 4242640 / 111.3195) for i in range(1, h)]
# 获得矩形网络内距离为4.2km的所有坐标
while g1:
g11 = g1.pop()
# print(g11)
for j in h1:
list_p.append((g11, j))
k = [a.split(',') for a in poly_list1]
coords = [
tuple(map(int, (i.replace('.', ''), j.replace('.', '')))) for i, j in k
]
poly = MultiPoint(coords).convex_hull
# 根据判断所有属于城市内的坐标并返回值
for p in list_p:
if poly.contains(Point(p)):
list_q.append(p)
# print(len(list_p))
t_list = []
for a, b in list_q:
t_geohash = mzgeohash.encode((a / 1000000, b / 1000000), length=12)
t_list.append((a / 1000000, b / 1000000, t_geohash))
# print(t_list)
return t_list
def Find_Average_Hexagon_Color(self, hex_coords, im):
from shapely.geometry import Point, MultiPoint
coords = list(hex_coords)
# Default RGB values to black opaque and pixel counter to zero.
rgb = [0, 0, 0]
count = 0
# Calculate hexagon bounding box.
minx = min(coords[::2])
maxx = max(coords[::2])
miny = min(coords[1::2])
maxy = max(coords[1::2])
bbox_coords = [minx, miny, maxx, miny, maxx, maxy, minx, maxy]
# Calculate polygon center.
midx = (minx + maxx) / 2.0
midy = (miny + maxy) / 2.0
coords[::2] = [(self.scale * (x - midx)) + midx for x in coords[::2]]
coords[1::2] = [(self.scale * (y - midy)) + midy for y in coords[1::2]]
subhex_coords = list(zip(coords[::2], coords[1::2]))
subhex_hull = MultiPoint(subhex_coords).convex_hull
# Flatten subhex list of tuples to conventional list for plotting.
subhex_coords = list(sum(subhex_coords, ()))
for x in range(int(math.floor(minx)), int(math.ceil(maxx))):
for y in range(int(math.floor(miny)), int(math.ceil(maxy))):
mypt = Point(x, y)
if(subhex_hull.contains(mypt)):
r, g, b = im.getpixel(tuple([x, y]))
rgb[0] += r
rgb[1] += g
rgb[2] += b
count += 1
rgb[0] = rgb[0] / count
rgb[1] = rgb[1] / count
rgb[2] = rgb[2] / count
rgb_color = tuple([int(i) for i in rgb])
return bbox_coords, subhex_coords, rgb_color
def Find_Average_Hexagon_Color(self, hex_coords, im):
from shapely.geometry import Point, MultiPoint
coords = list(hex_coords)
# Default RGB values to black opaque and pixel counter to zero.
rgb = [0, 0, 0]
count = 0
# Calculate hexagon bounding box.
minx = min(coords[::2])
maxx = max(coords[::2])
miny = min(coords[1::2])
maxy = max(coords[1::2])
bbox_coords = [minx, miny, maxx, miny, maxx, maxy, minx, maxy]
# Calculate polygon center.
midx = (minx + maxx) / 2.0
midy = (miny + maxy) / 2.0
coords[::2] = [(self.scale * (x - midx)) + midx for x in coords[::2]]
coords[1::2] = [(self.scale * (y - midy)) + midy for y in coords[1::2]]
subhex_coords = list(zip(coords[::2], coords[1::2]))
subhex_hull = MultiPoint(subhex_coords).convex_hull
# Flatten subhex list of tuples to conventional list for plotting.
subhex_coords = list(sum(subhex_coords, ()))
for x in range(int(math.floor(minx)), int(math.ceil(maxx))):
for y in range(int(math.floor(miny)), int(math.ceil(maxy))):
mypt = Point(x, y)
if (subhex_hull.contains(mypt)):
r, g, b = im.getpixel(tuple([x, y]))
rgb[0] += r
rgb[1] += g
rgb[2] += b
count += 1
rgb[0] = rgb[0] / count
rgb[1] = rgb[1] / count
rgb[2] = rgb[2] / count
rgb_color = tuple([int(i) for i in rgb])
return bbox_coords, subhex_coords, rgb_color
def get_neighborhood_from_kml(results, kml_path):
test_lat, test_lon = (results['geometry']['location']['lat'],
results['geometry']['location']['lng'])
test_point = Point(float(test_lat), float(test_lon))
kml = etree.parse(kml_path)
placemarks = kml.findall('//kml:Placemark', namespaces=NSMAP)
found_neighborhood = None
for placemark in placemarks:
el = placemark.find(COORDINATES, namespaces=NSMAP)
coords = []
for coord in el.text.split(' '):
lat, lon, _ = coord.split(',')
coords.append((float(lon), float(lat)))
poly = MultiPoint(coords).convex_hull
if poly.contains(test_point):
name = placemark.find('kml:name', namespaces=NSMAP)
found_neighborhood = name.text
if found_neighborhood is None:
return get_neighborhood(results)
return found_neighborhood
def get_neighborhood_from_kml(lat_lon, kml_path):
test_lat, test_lon = lat_lon
test_point = Point(float(test_lat), float(test_lon))
kml = etree.parse(kml_path)
placemarks = kml.findall('//kml:Placemark', namespaces=NSMAP)
found_neighborhood = None
for el in kml.findall('.//kml:coordinates', namespaces=NSMAP):
coords = []
for coord in el.text.split(' '):
lat, lon, _ = coord.split(',')
coords.append((float(lon), float(lat)))
poly = MultiPoint(coords).convex_hull
if poly.contains(test_point):
placemark = el.getparent().getparent().getparent().getparent()
if 'MultiGeometry' in str(placemark.tag):
placemark = placemark.getparent()
val = placemark.find('kml:ExtendedData/kml:Data[@name=\'32CitiesNa\']/kml:value', namespaces=NSMAP)
if val is not None:
found_neighborhood = val.text
return found_neighborhood
def get_inlier_guess(rect_pts,
horz_idx,
vert_idx,
lines1,
lines2,
dist=300,
radius_multiple=5):
accepted_pts = set()
for (horz, vert) in itertools.product(horz_idx, vert_idx):
hp1, hp2 = lines1[horz], lines2[horz]
vp1, vp2 = lines1[vert], lines2[vert]
hu = hp2 - hp1
vu = vp2 - vp1
A = np.array([[hu[0], -vu[0]], [hu[1], -vu[1]]])
b = np.array([vp1[0] - hp1[0], vp1[1] - hp1[1]])
mult = np.linalg.solve(A, b)
pt = np.mean([hp1 + mult[0] * hu, vp1 + mult[1] * vu], 0)
dists = np.sum((rect_pts - pt)**2, 1)
idx = np.argmin(dists)
if dists[idx] < 10:
accepted_pts.add(idx)
accepted_pts = list(accepted_pts)
# Broaden the search to any nearby points
hull = MultiPoint(rect_pts[accepted_pts, :]).convex_hull
hull = prep(hull.buffer(np.sqrt(hull.area) * radius_multiple))
inlier_guess = [
i for i in range(rect_pts.shape[0])
if hull.contains(Point(rect_pts[i, :]))
]
# plt.scatter(rect_pts[:,0], rect_pts[:,1], c='r')
# plt.scatter(rect_pts[inlier_guess,0], rect_pts[inlier_guess,1], c='y')
# plt.scatter(rect_pts[accepted_pts,0], rect_pts[accepted_pts,1], c='g')
# plt.show()
return inlier_guess
class SeismicNetwork(object):
def __init__(self, net_lats, net_lons):
poly_x, poly_y = pyproj.transform(wgs84, pj_laea, net_lons, net_lats)
self.polygon = MultiPoint(zip(poly_x, poly_y)).convex_hull
def contains(self, lat, lon):
x, y = pyproj.transform(wgs84, pj_laea, lon, lat)
point = Point(x, y)
if self.polygon.contains(point):
return True
else:
return False
def inside_network(self, epi_lats, epi_lons):
"""
This function returns epicenter coordinates located inside a seismic
station network. The point-in-polygon problem is solved based on ray
casting method.
:param epi_lats: Latitudes of earthquake epicenters.
:param epi_lons: Longitudes of earthquake epicenters.
:type epi_lats: numpy.array, list/tuple or scalar
:type epi_lons: numpy.array, list/tuple or scalar
:returns:
Epicenter coordinates located within network. The first and second
columns are latitude and longitude, respectively.
:rtype: numpy.array
"""
epi_x, epi_y = pyproj.transform(wgs84, pj_laea, epi_lons, epi_lats)
r = []
for i, (x, y) in enumerate(zip(epi_x, epi_y)):
epicenter = Point(x, y)
if epicenter.within(self.polygon):
r.append((epi_lats[i], epi_lons[i]))
return np.array(r)
class Planta:
"""
Essa classe cuida do problema de conhecer todos os pontos dentro de uma determinada
forma geométrica.
"""
# Inicializados no init:
pontos_internos = None
pontos_paredes = None
fontes = None
granularidade = None
# Setados ao procurar os pontos internos (função procurar_pontos_internos):
origem = None
poligono = None
def __init__(self, granularidade: Union[float, int]):
self.pontos_internos = set()
self.pontos_paredes = list()
self.fontes = list()
if not isinstance(granularidade, (float, int)):
raise Exception("Informe a granularidade do tipo float ou int.")
self.granularidade = granularidade
def adicionar_parede(self, *pontos: Union[Ponto, List[Union[float, int]]]):
"""
Adiciona uma lista de pontos (que é uma parede) à lista de paredes.
A planta lembra de todas paredes que a definem.
É importante saber quais são as paredes porque é preciso saber se um determinado
feixe, que surge numa fonte e vai até um ponto, atravessa paredes ou não.
"""
"""
ABAIXO, UM BUCADO DE CHECAGEM DE TIPOS!
"""
if len(pontos) < 2:
raise Exception(
"Ao adicionar uma parede, informe mais pontos! Lembre que uma parede é uma linha."
)
for ponto in pontos:
# vamos verificar todos itens
if isinstance(ponto, Ponto):
# é ponto, sem problemas
pass
elif not isinstance(ponto, list):
# não é ponto nem lista: problemas!
ex = """
Passe pontos separados por vírgula.
Exemplo: adicionar_parede(Ponto(1,1), Ponto(0,0))
ou adicionar_parede([1,1], [0,0])"""
raise Exception(ex)
elif len(ponto) < 2:
# não é ponto, mas é lista e não tem pelo menos 2 itens? problemas!
raise Exception(
"Ao adicionar uma parede, informe mais pontos! Lembre que uma parede é uma linha."
)
else:
# não é ponto, é lista, tem pelo menos 2 itens: vamos ver se todos itens são numéricos!
for x in ponto:
if not isinstance(x, (float, int)):
raise Exception(
"as coordenadas dos pontos precisam ser float ou int!"
)
self.pontos_paredes.append(pontos)
def simular_fontes(self, *fontes: Ponto):
"""
Avalia a intensidade do sinal em todos os pontos internos de acordo com as fontes informadas.
Obs: cada ponto irá guardar sua nova intensidade.
"""
# Se algum dos itens abaixo for none, chamamos a função que os seta
checks = (self.pontos_internos, self.origem, self.poligono)
if any([x is None for x in checks]):
self.procurar_pontos_internos()
# Setamos as fontes na propriedade da classe. Isso é pra que a função self.avaliar() possa
# consultar quais são as fontes!
self.fontes = fontes
# A função abaixo seta o valor de cada ponto de acordo com as fontes.
for ponto in self.pontos_internos:
if ponto in self.fontes:
continue
self.avaliar(ponto)
def procurar_pontos_internos(self):
"""
Escolhe um ponto de partida (ou seja, uma origem) e vai pulando de vizinho em vizinho até
encontrar todos os pontos que estão dentro da planta. Se parece com um Breadth-First-Search.
- A escolha da origem é assim: primeiro vejo se o ponto exatamente no meio dos limites da planta
está dentro da planta.
Se não tiver, eu vou gerar pontos aleatórios dentro dos limites da planta até um cair
dentro da planta.
- Esta é a função que gera o polígono da planta. O polígono é construído com base nas pontas
das paredes. Também, o polígono é o que usamos pra dizer se um ponto está dentro ou fora
da planta.
"""
"""
SETANDO POLÍGONO DA PLANTA
"""
# Pegando todos os pontos de todas paredes
pontos_paredes = []
for parede in self.pontos_paredes:
pontos_paredes.extend(parede)
# Pegando a casca convexa que é formada por esses pontos, e formando o polígono
self.poligono = MultiPoint(pontos_paredes).convex_hull
"""
ACHANDO A ORIGEM
"""
# Achando o ponto central dentro dos limites da planta
minx, miny, maxx, maxy = self.poligono.bounds
origem = [media(minx, maxx), media(miny, maxy)]
origem = Ponto(*origem)
if self.poligono.contains(origem):
self.origem = origem
else:
self.origem = ponto_aleatorio(self.poligono)
# Eu considero a origem como ponto interno!
self.pontos_internos.add(self.origem)
"""
BUSCANDO TODOS PONTOS EM TORNO DA ORIGEM, DENTRO DO POLÍGONO
"""
self.origem.calcular_vizinhos(self.granularidade)
fifo = fila(self.origem.vizinhos)
while fifo:
novo_ponto = fifo.popleft()
if not self.poligono.contains(novo_ponto):
# Se o ponto atual está fora da planta, ignore-o
continue
if novo_ponto in self.pontos_internos:
# Se o ponto atual está dentro da planta e já foi visitado, ignore-o
continue
# Adiciono o ponto atual
self.pontos_internos.add(novo_ponto)
# Acrescento seus vizinhos na fila para serem verificados
fifo.extend(novo_ponto.calcular_vizinhos(self.granularidade))
def encontrar(self, p: Union[Ponto, List[Union[float, int]]]):
"""
Retorna qual é o ponto correspondente às coordenadas passadas.
Já que a área dentro da planta foi "discretizada", se você me der um ponto qualquer, eu te digo
qual é o ponto correspondente na discretização que foi feita a partir da granularidade passada.
Observação: nem sempre retorna qual o ponto discreto mais próximo, porque sempre arredondo as
coordenadas pra baixo!
"""
if isinstance(p, Ponto):
pass
elif not isinstance(p, list):
# não é ponto nem lista: problemas!
raise Exception(
"Informe o ponto como um objeto Ponto ou lista de coordenadas")
elif len(p) < 2:
# não é ponto, mas é lista e não tem pelo menos 2 itens? problemas!
raise Exception("Informe o ponto com todas suas coordenadas!")
else:
for x in p:
# não é ponto, é lista, tem pelo menos 2 itens: vamos ver se todos itens são numéricos!
if not isinstance(x, (float, int)):
raise Exception(
"As coordenadas do ponto precisam ser float ou int!")
p = Ponto(*p)
# quantas "granularidades" inteiras temos da origem até o ponto, no eixo x?
delta_x = int((p.x - self.origem.x) / self.granularidade)
# quantas "granularidades" inteiras temos da origem até o ponto, no eixo y?
delta_y = int((p.y - self.origem.y) / self.granularidade)
estimativa = [
self.origem.x + delta_x * self.granularidade,
self.origem.y + delta_y * self.granularidade
]
estimativa = Ponto(*estimativa)
if self.poligono.contains(estimativa):
for pi in self.pontos_internos:
if pi == estimativa:
# Isso serve para retornar o mesmo objeto que tem dentro de pontos_internos,
# para não perder a informação de vizinhos
return pi
return estimativa
return None
def avaliar(self, p: Ponto):
"""
Essa função só serve para chamar para a função que vai realizar o cálculo.
Isso serve para podermos ter várias funções de cálculo,e poder trocar entre elas facilmente.
O resto do código chama essa função (avaliar). Então basta mudar aqui e já era.
Toda função de cálculo só pode receber um parâmetro: um ponto.
"""
if not isinstance(p, Ponto):
raise Exception(
"A função de avaliar deve receber um objeto Ponto como parâmetro."
)
return self.avaliar_recepcao_sinal(p)
def avaliar_distancia_simples(self, p: Ponto):
"""
Retorna a distância entre o ponto e a origem. Só pra brincar
"""
p.valor = distancia_entre_pontos(p, self.origem)
return p.valor
def avaliar_perda_paredes(self, p: Ponto):
"""
Retorna a quantidade de paredes que o sinal do roteador intercepta até chegar no ponto p.
"""
fonte = self.fontes[0]
intersecoes = []
for parede in self.pontos_paredes:
if line_intersection(parede, [fonte, p]):
intersecoes.append(parede)
return intersecoes
def avaliar_recepcao_sinal(self, p: Ponto):
"""
A função que iremos utilizar é a da página 179 do livro projetando WLAN.
A atenuação do sinal pode ser medido através da seguinte fórmula:
L = L(d0) + 10*n*log(d)
L(d0): é a perda de propagação de referência a um metro de distância em dB. Esse valor é tabelado de acordo com
a faixa de frequência, como vamos trabalhar com 2.4GHZ, então o valor de L(d0) será 40.2 dB
n: Gradiente distância-potência, é o decaimento da potência após uma distância em metros. Utilizaremos o valor
2.8 que é para obstrução média
d: distância do transmissor para o receptor
para calcular o nível de recepcao usaremos a somamos os ganhos e perdas:
Iremos utilizar como base o roteador Roteador Wireless IWR 1000N que tem Potência de 20dBm e ganho da antena
5dbi, então:
(25 - L) - n*atenuação parede interna - n*atenuação parede externa
atenuação parede interna: 4db
atenuação parede externa: 18db
"""
potencia_transmissor = 20
ganho_antena = 5
atenuacao_parede = 4
qtd_paredes = len(self.avaliar_perda_paredes(p))
distancia_transmissor_receptor = distancia_entre_pontos(
p, self.fontes[0])
atenuacao_propagacao = 40.2 + 10 * log10(
distancia_transmissor_receptor)
p.valor = abs(potencia_transmissor + ganho_antena -
atenuacao_propagacao - qtd_paredes * atenuacao_parede)
return abs(p.valor)
def pcontains(points, point):
hull = MultiPoint(points).convex_hull
return hull.contains(point)
def blockers_gen(rate, scenario, route, Plot=False, tolerance=150):
#The blockage rate is given in square meters blocked
blockers = {}
blockers['objects'] = []
'''
totalArea = (scenario['boundaries']['xmax']-scenario['boundaries']['xmin'])*(
scenario['boundaries']['ymax']-scenario['boundaries']['ymin'])
routeBuffer = route.buffer(tolerance, cap_style=3)
totalArea = routeBuffer.area - 2*tolerance*np.sqrt(((tolerance**2)/2) - (tolerance/2)**2)
#'''
routeBuffer = MultiPoint([
(scenario['boundaries']['xmin'], scenario['boundaries']['ymin']),
(scenario['boundaries']['xmin'] + tolerance,
scenario['boundaries']['ymin']),
(scenario['boundaries']['xmin'],
scenario['boundaries']['xmin'] + tolerance),
(scenario['boundaries']['xmax'] - tolerance,
scenario['boundaries']['ymax']),
(scenario['boundaries']['xmax'],
scenario['boundaries']['xmax'] - tolerance),
(scenario['boundaries']['xmax'], scenario['boundaries']['ymax'])
]).convex_hull
totalArea = routeBuffer.area
totalBlockers = np.random.poisson(rate * totalArea)
#print(totalArea)
#print(totalBlockers)
nBlockers = 0
while (nBlockers < totalBlockers): #rate*totalArea):
centroidX = np.random.randint(scenario['boundaries']['xmin'],
scenario['boundaries']['xmax'])
centroidY = np.random.randint(scenario['boundaries']['ymin'],
scenario['boundaries']['ymax'])
point = Point([centroidX, centroidY])
'''
if type(route) == type(LineString([(0,0),(1,1)])):
upperlimit = route.parallel_offset(tolerance,'left')
lowerlimit = route.parallel_offset(tolerance,'right')
if not (upperlimit.crosses(point) or lowerlimit.crosses(point)):
continue
'''
if not (routeBuffer.contains(point)):
continue
blockers['objects'].append({})
blockers['objects'][-1][
'nVertices'] = 4 #All objects are quadrilaterals
blockers['objects'][-1]['centroid'] = {'x': centroidX, 'y': centroidY}
blockers['objects'][-1]['polygon'] = Polygon([
(centroidX - 0.5, centroidY + 0.5),
(centroidX + 0.5, centroidY + 0.5),
(centroidX + 0.5, centroidY - 0.5),
(centroidX - 0.5, centroidY - 0.5)
])
if Plot:
x, y = blockers['objects'][-1]['polygon'].exterior.xy
plt.plot(x, y, color='red')
nBlockers += 1
plt.show()
return blockers
if exclude_France=="True":
m.readshapefile(shape_file,'France')
for shape in m.France:
if shape == m.France[0]:
poly = MultiPoint(shape).convex_hull
else:
poly = poly.union(MultiPoint(shape).convex_hull)
for row in cfile:
if isnumber(row[1]) and isnumber(row[2]) and isnumber(row[3]):
x=float(row[3])
y=float(row[2])
po = Point(m(x,y))
if not poly.contains(po):
for i in range(0,int(row[1])):
lat.append(y)
lon.append(x)
else:
for row in cfile:
if isnumber(row[1]) and isnumber(row[2]) and isnumber(row[3]):
for i in range(0,int(row[1])):
lat.append(float(row[2]))
lon.append(float(row[3]))
#make figure
fig = plt.figure(figsize=(12,5))
def clusteredBlockerGen(parentRate: float, daughterRate: float,
daughterSigma: float, scenario, route, tolerance,
Plot):
'''
This function generates unitary area obstacles following a Thomas Clustered
Process
'''
#The blockage rate is given in square meters blocked
blockers = {}
blockers['objects'] = []
routeBuffer = MultiPoint([
(scenario['boundaries']['xmin'], scenario['boundaries']['ymin']),
(scenario['boundaries']['xmin'] + tolerance,
scenario['boundaries']['ymin']),
(scenario['boundaries']['xmin'],
scenario['boundaries']['xmin'] + tolerance),
(scenario['boundaries']['xmax'] - tolerance,
scenario['boundaries']['ymax']),
(scenario['boundaries']['xmax'],
scenario['boundaries']['xmax'] - tolerance),
(scenario['boundaries']['xmax'], scenario['boundaries']['ymax'])
]).convex_hull
totalArea = routeBuffer.area
nClusters = np.random.poisson(parentRate * totalArea)
clusterPoints = np.random.poisson(daughterRate, nClusters)
totalBlockers = sum(clusterPoints)
if Plot:
print(nClusters, clusterPoints, totalBlockers)
cluster = 0
while cluster < nClusters:
inside = False
while not inside:
parentX = np.random.randint(scenario['boundaries']['xmin'],
scenario['boundaries']['xmax'])
parentY = np.random.randint(scenario['boundaries']['ymin'],
scenario['boundaries']['ymax'])
point = Point([parentX, parentY])
inside = routeBuffer.contains(point)
perCluster = 0
nPoints = clusterPoints[cluster]
cluster += 1
while (perCluster < nPoints):
centroidX = parentX + np.random.normal(0, daughterSigma)
centroidY = parentY + np.random.normal(0, daughterSigma)
point = Point([centroidX, centroidY])
#if not (routeBuffer.contains(point)):
# continue
blockers['objects'].append({})
blockers['objects'][-1][
'nVertices'] = 4 #All objects are quadrilaterals
blockers['objects'][-1]['centroid'] = {
'x': centroidX,
'y': centroidY
}
blockers['objects'][-1]['polygon'] = Polygon([
(centroidX - 0.5, centroidY + 0.5),
(centroidX + 0.5, centroidY + 0.5),
(centroidX + 0.5, centroidY - 0.5),
(centroidX - 0.5, centroidY - 0.5)
])
if Plot:
x, y = blockers['objects'][-1]['polygon'].exterior.xy
plt.plot(x, y, color='red')
perCluster += 1
plt.show()
return blockers
i = 0
coords_list2 = []
with open(TWITTER_FILE) as f:
f.readline()
for line in f:
try:
data = json.loads(line[0:len(line) - 2])
if data["coordinates"]["coordinates"]:
point = Point(data["coordinates"]["coordinates"][1],
data["coordinates"]["coordinates"][0])
# data["coordinates"]["coordinates"][lat, lgt]
for suburb in suburbs.keys():
for dict in suburbs[suburb].items():
poly = dict[1][1]
if poly.contains(point):
suburbs[suburb]['count'] += 1
scores = sid.polarity_scores(data['text'])
sorted_scores = sorted(scores.items(), key=lambda item: item[1], reverse=True)
if sorted_scores[0][0] != 'neg':
suburbs[suburb]['count_pos'] += 1
print ++i
except TypeError:
continue
except ValueError:
data = json.loads(line[0:len(line) - 1])
if data["coordinates"]:
coords = [data["coordinates"]["coordinates"][1],
data["coordinates"]["coordinates"][0]]
coords_list2.append(coords)
print coords
