def find_eligible_staging_pod(client: CoreV1Api, exclude_namespaces: [] = None):
pods = client.list_pod_for_all_namespaces()
available_pods = pods.items
if exclude_namespaces:
available_pods = [
pod
for pod in available_pods
if pod.metadata.namespace not in exclude_namespaces
]
print(
f"[*] found {len(available_pods)} pods - checking for eligible staging candidates (this may take a while)"
)
pod_capabilities = []
with FillingCirclesBar("[*] Processing...", max=len(available_pods)) as bar:
for pod_info in available_pods:
capabilities = run_checks(client, pod_info)
pod_capabilities.append(capabilities)
bar.next()
eligible_pods = [pod for pod in pod_capabilities if pod.can_be_staging()]
print(f"[+] valid pods for proxy staging: {len(eligible_pods)}")
for pod in eligible_pods:
print(f"\t{pod.namespace}/{pod.pod_name}")
staging_pods = [pod for pod in eligible_pods if pod.has_dependencies_installed()]
if len(staging_pods) == 0:
install_dependencies(client, eligible_pods)
print(f"[+] selecting {staging_pods[0]}")
return staging_pods[0]
def insert_source(source):
'''
Gets the connection and binding and inserts data.
'''
get_connection(source)
if not isinstance(source, sc.CenPy):
get_binding(source)
if source.engine.dialect.has_table(source.engine, source.tbl_name):
print()
warnings.warn(("Destination table already exists. Current table " +
"will be dropped and replaced."))
print()
if not isinstance(source, sc.CenPy):
source.binding.__table__.drop(source.engine)
try:
if not isinstance(source, sc.CenPy):
source.binding.__table__.create(source.engine)
except ProgrammingError as e:
raise CLIError('Error creating destination table: %s' % str(e))
circle_bar = FillingCirclesBar(' ▶ Loading from source',
max=source.num_rows)
source.insert(circle_bar)
circle_bar.finish()
ui.item('Committing rows (this can take a bit for large datasets).')
source.session.commit()
success = 'Successfully imported %s rows.' % (source.num_rows)
ui.header(success, color='\033[92m')
if source.name == "Socrata" and source.client:
source.client.close()
return
def format_data(self, data_format):
"""
This method format the data to the required format for the database
"""
print('')
progress_bar = 'Mise en forme des données :'
progress_bar = FillingCirclesBar(progress_bar, max=len(self.data))
for i, dictionary in enumerate(self.data):
for key_format in data_format:
key = key_format['name']
if key in dictionary:
data_type = key_format['type']
if data_type == str:
dictionary[key] = str(dictionary[key])
if 'length' in key_format:
length = key_format['length']
dictionary[key] = dictionary[key][:length]
elif data_type == int:
dictionary[key] = int(dictionary[key])
elif data_type == list:
dictionary[key] = self.string_to_list(dictionary[key])
self.data[i] = dictionary
progress_bar.next()
progress_bar.finish()
def keep_required(self, data_required):
"""
This method drop data with missing keys
"""
index_list = list()
print('')
progress_bar = 'Suppression des produits avec données manquantes :'
progress_bar = FillingCirclesBar(progress_bar, max=len(self.data))
for i, dictionary in enumerate(self.data):
try:
for required in data_required:
key = required['name']
required = required['required']
# Check if the data have the required keys
if required and key not in dictionary:
raise KeyError
# Check if the required data are not null
if required and not dictionary[key]:
raise KeyError
except KeyError:
# Save the data's index if there is a key error
index_list.append(i)
progress_bar.next()
progress_bar.finish()
index_list.reverse()
# Delete all datas with a key error
for index in index_list:
self.data.pop(index)
def upload_data(es):
for csv_df in pd.read_csv(
csv_file, index_col=False,
chunksize=500000): #MEMORY MANAGMENT JUST IN CASE.
csv_reader = csv_df.T.to_dict(
) #TRANSFORM CSV TO DICT CAUSE IT HAS SIMILAR STRUCTURE AS JSON FILE.
with FillingCirclesBar("Uploading Data: ", max=len(csv_df)) as bar:
es.indices.create(index='movies', ignore=400,
body=es_settings) # CREATE THE INDEX.
for (key, docs_data) in csv_reader.items():
res = es.index(index="movies", id=key + 1, body=docs_data)
bar.next()
print("Data uploaded successfully")
def download_products(self, categories, page_size, pages):
"""
Download products in temp json files
"""
self.categories = categories
self.page_size = page_size
self.pages = pages
# Download each category
for category in self.categories:
try:
dir_path = path.join(self.tmp_dir, category)
mkdir(dir_path)
except FileExistsError:
print(f'Le répertoire "{dir_path}" existe déjà')
# Headers for the request see : https://en.wiki.openfoodfacts.org/API/Read/Search
headers = {
'User-agent':
'Pur Beurre Substitute - Mac OS X 10.13 - Version 1.0'
}
# A progress bar for seeing the application working
print('')
progress_bar = f'Téléchargement en cours de la catégorie "{category}" :'
progress_bar = FillingCirclesBar(progress_bar, max=self.pages)
for page in range(self.pages):
# Parameters sent with te request
parameters = {
'json': 1,
'page_size': self.page_size,
'page': (page + 1),
'tagtype_0': 'categories',
'tag_contains_0': 'contains',
'tag_0': category,
'action': 'process'
}
# File in wich data are saved
file_name = f'{page}.json'
file_path = path.join(dir_path, file_name)
with open(file_path, 'w') as output_file:
try:
result = requests.get(self.url_base,
params=parameters,
headers=headers,
stream=True)
result.raise_for_status()
except requests.HTTPError as err:
print(err)
# Write data in a json format
json.dump(result.json(), output_file, indent=4)
progress_bar.next()
progress_bar.finish()
def main():
arguments = docopt(__doc__, version=__version__)
client = Socrata(arguments['<site>'], arguments['-a'])
try:
if arguments['ls']:
datasets = list_datasets(client, arguments['<site>'])
print(tabulate(datasets, headers='keys', tablefmt='psql'))
elif arguments['insert']:
dataset_id = arguments['<dataset_id>']
metadata = client.get_metadata(dataset_id)
engine, session, geo = get_connection(arguments['-d'], metadata)
Binding = get_binding(client, dataset_id, metadata, geo,
arguments['-t'])
# Create the table
try:
Binding.__table__.create(engine)
except ProgrammingError as e:
# Catch these here because this is our first attempt to
# actually use the DB
if 'already exists' in str(e):
raise CLIError(
'Destination table already exists. Specify a new table'
' name with -t.')
raise CLIError('Error creating destination table: %s' % str(e))
num_rows = get_row_count(client, dataset_id)
bar = FillingCirclesBar(' ▶ Loading from API', max=num_rows)
# Iterate the dataset and INSERT each page
for page in get_dataset(client, dataset_id):
to_insert = []
for row in page:
to_insert.append(Binding(**parse_row(row, Binding)))
session.add_all(to_insert)
session.flush()
bar.next(n=len(to_insert))
bar.finish()
ui.item(
'Committing rows (this can take a bit for large datasets).')
session.commit()
success = 'Successfully imported %s rows from "%s".' % (
num_rows, metadata['name'])
ui.header(success, color='\033[92m')
client.close()
except CLIError as e:
ui.header(str(e), color='\033[91m')
def search(inputlist, protein_seqs, tsvsalida):
try:
numerodominios = 0 #Inicializa el total de matches
lineaalinea = pd.read_csv(protein_seqs, sep='\t')
bar = FillingCirclesBar('Buscando dominios...',
max=len(inputlist['pattern']) *
(len(lineaalinea['qseqid']) + 1))
with open(tsvsalida, 'a') as found:
found.write('blast hit\tname\taccession\tdescription\tpattern\n')
for j in range(len(lineaalinea['sseqid']) + 1):
for k in range(len(inputlist['pattern'])):
#Para el query hago esto
if j == 0:
busca = inputlist.loc[k, 'pattern']
prosearch = lineaalinea.loc[1, 'qseq']
match = re.search(busca, prosearch, flags=re.I)
bar.next()
if match:
found.write( lineaalinea.loc[1,'qseqid']+'\t' \
+inputlist.loc[k, 'name']+'\t' \
+inputlist.loc[k, 'accession']+'\t' \
+inputlist.loc[k, 'description']+'\t' \
+inputlist.loc[k, 'pattern']+'\n')
numerodominios += 1
# Y esto lo hago para los multiples subjects
else:
busca = inputlist.loc[k, 'pattern']
prosearch = lineaalinea.loc[j - 1, 'sseq']
match = re.search(busca, prosearch, flags=re.I)
bar.next()
if match:
found.write( lineaalinea.loc[j-1,'sseqid']+'\t' \
+inputlist.loc[k, 'name']+'\t' \
+inputlist.loc[k, 'accession']+'\t' \
+inputlist.loc[k, 'description']+'\t' \
+inputlist.loc[k, 'pattern']+'\n')
numerodominios += 1
found.close()
bar.finish()
return (numerodominios)
except:
print('Fallo al buscar dominios')
pass
def Pb6():
from progress.bar import FillingCirclesBar
import time
bar = FillingCirclesBar('进度条6', max=100) #max的值100，可调节
for i in range(100): #这个也需要适当调节
bar.next()
time.sleep(0.1) #延迟时间，可调节，0.1~1之间最佳
bar.finish()
def generate_simple(data_name, count, klass, *args):
"""
Generate data with a simple loop
"""
progress_bar = f'Create {data_name}'
progress_bar = FillingCirclesBar(progress_bar, max=count)
i = 0
while i < count:
i += 1
klass(LANG_CODE, *args)
progress_bar.next()
progress_bar.finish()
def make_video(params_file='output/params.txt',
phi_file='output/phi.txt',
x_file='output/x.txt',
gifname='movie.gif',
duration=0.1,
xkcd=False):
params = get_params(params_file)
phi_array = np.loadtxt(phi_file)
x_array = np.loadtxt(x_file)
solution = {'u': phi_array, 'x': x_array}
step = int(0.01 / params['dt'])
bar = FillingCirclesBar('Loading',
suffix='%(percent)d%%',
max=int((params['steps'] - 1) / step))
images = []
figsize = (6, 6)
for subplot in range(1, int(params['steps']), step):
if xkcd:
plt.rcParams['text.usetex'] = False
plt.xkcd()
fig = plt.figure(figsize=figsize)
ax = plt.subplot(1, 1, 1)
plt.sca(ax)
plt.plot(solution['x'],
solution['u'][subplot - 1, :],
c='#F61067',
lw=3.5)
plt.ylim(-1.5 * params['eta'], 1.5 * params['eta'])
if xkcd:
plt.xlabel(r'x')
plt.ylabel(r'u(x, t)')
else:
plt.xlabel(r'$x$')
plt.ylabel(r'$\phi(x, t)$')
plt.title('t = {:.2f}s'.format((subplot - 1) * params['dt']))
if subplot > 1:
plt.axis(axis)
if subplot == 1:
axis = plt.axis()
filename = 'temp.png'
plt.savefig(filename)
plt.close()
images.append(Image.open(filename))
os.remove(filename)
bar.next()
bar.finish()
print('', end='\r\r')
if xkcd:
imageio.mimsave('xkcd_' + gifname, images, duration=duration)
else:
imageio.mimsave(gifname, images, duration=duration)
def generate_complex_while(data_name, count, parents, klass, *args):
"""
Generate data with a for and a while loops
"""
count_min, count_max = count
progress_bar = f'Create {data_name}'
progress_bar = FillingCirclesBar(progress_bar, max=len(parents))
for parent in parents:
child_count = randrange(count_min, count_max)
i = 0
while i < child_count:
i += 1
klass(LANG_CODE, parent, *args)
progress_bar.next()
progress_bar.finish()
def do_update(self, _):
"***Actualiza las tools"
data = dict()
for x in [x.rstrip() for x in open("mirror.txt", "r").readlines()]:
print(x)
data.update(requests.get(x).json())
bar = FillingCirclesBar('Actualizando', max=len(str(data)))
for i in range(len(str(data))):
with open('update.json', 'w') as upt:
json.dump(data, upt)
bar.next()
bar.finish()
self.requiere = json.loads(open("update.json", "r").read())
def progressbar(title):
# for i in range(21):
# sys.stdout.write('\r')
# # the exact output you're looking for:
# sys.stdout.write("[%-20s] %d%%" % ('='*i, 5*i))
# sys.stdout.flush()
# sleep(0.05)
text = colored(str(title), 'red', attrs=['reverse', 'blink'])
print(text)
bar = FillingCirclesBar('Processing', max=100)
for i in range(100):
# Do some work
sleep(0.025)
bar.next()
bar.finish()
def process_items(items):
processed_items = []
index = 1
number_of_items = len(items)
progress_bar = FillingCirclesBar('Processing pages', max=number_of_items)
for item in items:
product_name = item.xpath('.//a[@class="productName product1Name"]/span')[0].text_content().strip()
actual_price = item.xpath('.//div[@class="mm-price media__price"]')[0].text_content().strip()
processed_item = {'name': product_name, 'price': Decimal(actual_price), 'reduced_price': None, 'discount': None}
processed_items.append(processed_item)
index = index + 1
progress_bar.next()
progress_bar.finish()
return processed_items
def random_status_history():
"""
Create random history for status
"""
progress_bar = 'Create status histories for the orders'
progress_bar = FillingCirclesBar(progress_bar, max=len(Order.orders))
for i, order in enumerate(Order.orders):
history_count = randrange(0, (len(STATUS) - 1))
j = 0
while j < history_count:
j += 1
StatusHistory(order)
Order.orders[i].random_date()
Order.orders[i].random_status(Status.status)
progress_bar.next()
progress_bar.finish()
def generate_complex(data_name, lists, klass, *args, random_choice=False):
"""
Generate data with a double for loop
"""
parents, children = lists
progress_bar = f'Create {data_name}'
progress_bar = FillingCirclesBar(progress_bar, max=len(parents))
for parent in parents:
for child in children:
if random_choice:
if choice([True, False]):
klass(parent, child, *args)
else:
klass(parent, child, *args)
progress_bar.next()
progress_bar.finish()
def collect_epic(self, epic_name):
"""
Collects all jobs in epic
epic_name: name of job series to submit this job to
:raise
KeyError if epic name not registered before
:return
list of worker results
"""
if epic_name not in self.__epics.keys():
raise KeyError("Cannot find named epic '%s'" % epic_name)
if self.__repprog:
bar = FillingCirclesBar("Processing epic '%s'" % epic_name,
max=len(self.__epics[epic_name]))
bar.start()
results = []
j = 0
while j < len(self.__epics[epic_name]):
try:
results.append(
self.__epics[epic_name][j].result(timeout=1))
self.__epics[epic_name].remove(self.__epics[epic_name][j])
if len(self.__epics[epic_name]) > 0:
j %= len(self.__epics[epic_name])
else:
j = 0
bar.next()
except TimeoutError:
j = (j + 1) % len(self.__epics[epic_name])
bar.finish()
else:
results = []
for f in self.__epics[epic_name]:
results.append(f.result())
self.__epics[epic_name] = []
return results
def make_video(solution, gifname='movie.gif', duration=0.1, xkcd=False):
params = solution.params
step = int(0.01 / params['dt'])
bar = FillingCirclesBar('Loading',
suffix='%(percent)d%%',
max=int((solution.steps - 1) / step))
images = []
figsize = (6, 6)
for subplot in range(1, solution.steps, step):
if xkcd:
plt.rcParams['text.usetex'] = False
plt.xkcd()
fig = plt.figure(figsize=figsize)
ax = plt.subplot(1, 1, 1)
plt.sca(ax)
plt.plot(solution.x, solution.u[subplot - 1, :], c='#F61067', lw=3.5)
if xkcd:
plt.xlabel(r'x')
plt.ylabel(r'u(x, t)')
else:
plt.xlabel(r'$x$')
plt.ylabel(r'$u(x, t)$')
plt.title('t = {:.2f}s'.format(params['t0'] +
(subplot - 1) * params['dt']))
if subplot > 1:
plt.axis(axis)
if subplot == 1:
axis = plt.axis()
filename = 'temp.png'
plt.savefig(filename)
plt.close()
images.append(Image.open(filename))
os.remove(filename)
bar.next()
bar.finish()
print('', end='\r\r')
if xkcd:
imageio.mimsave('xkcd_' + gifname, images, duration=duration)
else:
imageio.mimsave(gifname, images, duration=duration)
def retrieve_domain_address():
""" Performs DNS lookup on each domain """
global SUBDOMAIN_LIST
resolver = dns.resolver.Resolver()
pop_list = []
bar = FillingCirclesBar('[*] Resolving Domains', max=len(SUBDOMAIN_LIST))
for i in range(len(SUBDOMAIN_LIST)):
try:
answers = resolver.resolve("%s" % SUBDOMAIN_LIST[i].name, "A")
for response in answers:
SUBDOMAIN_LIST[i].resolved_addresses.append(response.to_text())
except dns.resolver.NoAnswer:
pop_list.append(SUBDOMAIN_LIST[i])
except dns.resolver.NXDOMAIN:
pop_list.append(SUBDOMAIN_LIST[i])
bar.next()
bar.finish()
SUBDOMAIN_LIST = adjust_list(pop_list)
def read_json_with_key(self, key):
"""
This method read json files and return only data on specific key
"""
print('')
progress_bar = 'Lecture des données en cours :'
progress_bar_count = len(self.categories) * self.pages
progress_bar = FillingCirclesBar(progress_bar, max=progress_bar_count)
for category in self.categories:
for page in range(self.pages):
# Create a path for the file
file_name = f'{page}.json'
file_path = path.join(self.tmp_dir, category, file_name)
# Read the JSON file
with open(file_path, 'r') as file:
json_data = json.load(file)
# Store data in list
for line in json_data[key]:
self.data.append(line)
progress_bar.next()
progress_bar.finish()
def main():
args = get_cli_args()
validate_cli_args(args)
alphas = np.array(args.alphas)
beta = np.array(args.beta)**2
mean_prior = np.array([180., 50., 0.])
Sigma_prior = 1e-12 * np.eye(3, 3)
initial_state = Gaussian(mean_prior, Sigma_prior)
if args.input_data_file:
data = load_data(args.input_data_file)
elif args.num_steps:
# Generate data, assuming `--num-steps` was present in the CL args.
data = generate_input_data(initial_state.mu.T, args.num_steps,
args.num_landmarks_per_side,
args.max_obs_per_time_step, alphas, beta,
args.dt)
else:
raise RuntimeError('')
should_show_plots = True if args.animate else False
should_write_movie = True if args.movie_file else False
should_update_plots = True if should_show_plots or should_write_movie else False
field_map = FieldMap(args.num_landmarks_per_side)
fig = get_plots_figure(should_show_plots, should_write_movie)
movie_writer = get_movie_writer(should_write_movie, 'Simulation SLAM',
args.movie_fps, args.plot_pause_len)
progress_bar = FillingCirclesBar('Simulation Progress', max=data.num_steps)
data = load_data("slam-evaluation-input.npy")
slam = SAM(beta, alphas, initial_state)
with movie_writer.saving(
fig, args.movie_file,
data.num_steps) if should_write_movie else get_dummy_context_mgr():
for t in range(data.num_steps):
# Used as means to include the t-th time-step while plotting.
tp1 = t + 1
# Control at the current step.
u = data.filter.motion_commands[t]
# Observation at the current step.
z = data.filter.observations[t]
# print(data.filter.observations.shape)
slam.predict(u)
trajectory, landmarks = slam.update(z)
progress_bar.next()
if not should_update_plots:
continue
plt.cla()
plot_field(field_map, z, slam.lm_positions,
slam.lm_correspondences)
plot_robot(data.debug.real_robot_path[t])
plot_observations(data.debug.real_robot_path[t],
data.debug.noise_free_observations[t],
data.filter.observations[t])
plt.plot(data.debug.real_robot_path[1:tp1, 0],
data.debug.real_robot_path[1:tp1, 1], 'm')
plt.plot(data.debug.noise_free_robot_path[1:tp1, 0],
data.debug.noise_free_robot_path[1:tp1, 1], 'g')
plt.plot([data.debug.real_robot_path[t, 0]],
[data.debug.real_robot_path[t, 1]], '*r')
plt.plot([data.debug.noise_free_robot_path[t, 0]],
[data.debug.noise_free_robot_path[t, 1]], '*g')
# TODO plot SLAM soltion
plt.plot(np.array(trajectory)[:, 0], np.array(trajectory)[:, 1])
plt.scatter(np.array(landmarks)[:, 0], np.array(landmarks)[:, 1])
# print(t)
# for lm in slam.lm_positions:
# # print(len(lm))
# if len(lm)>5:
# lm_mu, lm_sigma = get_gaussian_statistics_xy(np.array(lm[-5:]))
# # print('lm_mu',lm_mu)
# # print('lm_sigma',lm_sigma)
# # print('plot lm')
# plot2dcov(lm_mu, lm_sigma, 3, 50)
if should_show_plots:
# Draw all the plots and pause to create an animation effect.
plt.draw()
plt.pause(args.plot_pause_len)
if should_write_movie:
movie_writer.grab_frame()
progress_bar.finish()
plt.show(block=True)
def download(link):
fileName = link.split("/")[-1]
fileRequest = req.get(link, stream=True)
with open(os.path.join(save_path, fileName), "wb") as musicFile:
musicFile.write(fileRequest.content)
bar.next()
if os.path.isdir("download"):
with requests.Session() as req:
save_path = "download/"
threads = []
bar = FillingCirclesBar("Downloading ", max=len(cleaned_urls))
for link in cleaned_urls:
thread = threading.Thread(target=download, args=(link, ))
threads.append(thread)
for thread in threads:
thread.start()
for thread in threads:
thread.join()
bar.finish()
# rename song files
for file in os.listdir("download"):
tag = TinyTag.get(os.path.join("download", file))
newName = tag.title
filePath = os.path.join("download", file)
if "/" in newName:
""" initialization """
animate = 1
random_obstacles = 1
num_random_obstacles = 8
num_robots = 1
moving_obstacles = 1
impedance = 0
formation_gradient = 1
draw_gradients = 0
postprocessing = 0
pos_coef = 3.0
initialized = False
max_its = 120
# movie writer
progress_bar = FillingCirclesBar('Number of Iterations', max=max_its)
should_write_movie = 0
movie_file_name = os.getcwd() + '/videos/output.avi'
movie_writer = get_movie_writer(should_write_movie,
'Simulation Potential Fields',
movie_fps=10.,
plot_pause_len=0.01)
R_obstacles = 0.05 # [m]
R_swarm = 0.3 # [m]
start = np.array([-1.8, 1.8])
goal = np.array([1.8, -1.8])
V0 = (goal - start) / norm(
goal - start) # initial movement direction, |V0| = 1
U0 = np.array([-V0[1], V0[0]]) / norm(
V0) # perpendicular to initial movement direction, |U0|=1
def main():
args = get_cli_args()
validate_cli_args(args)
# weights for covariance action noise R and observation noise Q
alphas = np.array(args.alphas) **2 # variance of noise R proportional to alphas, see tools/tasks@get_motion_noise_covariance()
beta = np.deg2rad(args.beta) # see also filters/localization_filter.py
mean_prior = np.array([180., 50., 0.])
Sigma_prior = 1e-12 * np.eye(3, 3)
initial_state = Gaussian(mean_prior, Sigma_prior)
if args.input_data_file:
data = load_data(args.input_data_file)
elif args.num_steps:
# Generate data, assuming `--num-steps` was present in the CL args.
data = generate_input_data(initial_state.mu.T, args.num_steps, alphas, beta, args.dt)
else:
raise RuntimeError('')
store_sim_data = True if args.output_dir else False
show_plots = True if args.animate else False
write_movie = True if args.movie_file else False
show_trajectory = True if args.animate and args.show_trajectory else False
show_particles = args.show_particles and args.animate and args.filter_name == 'pf'
update_mean_trajectory = True if show_trajectory or store_sim_data else False
update_plots = True if show_plots or write_movie else False
one_trajectory_per_particle = True if show_particles and not store_sim_data else False
if store_sim_data:
if not os.path.exists(args.output_dir):
os.makedirs(args.output_dir)
save_input_data(data, os.path.join(args.output_dir, 'input_data.npy'))
# ---------------------------------------------------------------------------------------------------
# Student's task: You will fill these function inside 'filters/.py'
# ---------------------------------------------------------------------------------------------------
localization_filter = None
if args.filter_name == 'ekf':
localization_filter = EKF(initial_state, alphas, beta)
elif args.filter_name == 'pf':
localization_filter = PF(initial_state, alphas, beta, args.num_particles, args.global_localization)
fig = None
if show_plots or write_movie:
fig = plt.figure(1)
if show_plots:
plt.ion()
# Initialize the trajectory if user opted-in to display.
sim_trajectory = None
if update_mean_trajectory:
if one_trajectory_per_particle:
mean_trajectory = np.zeros((data.num_steps, localization_filter.state_dim, args.num_particles))
else:
mean_trajectory = np.zeros((data.num_steps, localization_filter.state_dim))
sim_trajectory = FilterTrajectory(mean_trajectory)
if store_sim_data:
# Pre-allocate the memory to store the covariance matrix of the trajectory at each time step.
sim_trajectory.covariance = np.zeros((localization_filter.state_dim,
localization_filter.state_dim,
data.num_steps))
# Initialize the movie writer if `--movie-file` was present in the CL args.
movie_writer = None
if write_movie:
get_ff_mpeg_writer = anim.writers['ffmpeg']
metadata = dict(title='Localization Filter', artist='matplotlib', comment='PS2')
movie_fps = min(args.movie_fps, float(1. / args.plot_pause_len))
movie_writer = get_ff_mpeg_writer(fps=movie_fps, metadata=metadata)
progress_bar = FillingCirclesBar('Simulation Progress', max=data.num_steps)
with movie_writer.saving(fig, args.movie_file, data.num_steps) if write_movie else get_dummy_context_mgr():
for t in range(data.num_steps):
# Used as means to include the t-th time-step while plotting.
tp1 = t + 1
# Control at the current step.
u = data.filter.motion_commands[t]
# Observation at the current step.
z = data.filter.observations[t]
localization_filter.predict(u)
localization_filter.update(z)
if update_mean_trajectory:
if one_trajectory_per_particle:
sim_trajectory.mean[t, :, :] = localization_filter.X.T
else:
sim_trajectory.mean[t] = localization_filter.mu
if store_sim_data:
sim_trajectory.covariance[:, :, t] = localization_filter.Sigma
progress_bar.next()
if not update_plots:
continue
plt.cla()
plot_field(z[1])
plot_robot(data.debug.real_robot_path[t])
plot_observation(data.debug.real_robot_path[t],
data.debug.noise_free_observations[t],
data.filter.observations[t])
plt.plot(data.debug.real_robot_path[1:tp1, 0], data.debug.real_robot_path[1:tp1, 1], 'g')
plt.plot(data.debug.noise_free_robot_path[1:tp1, 0], data.debug.noise_free_robot_path[1:tp1, 1], 'm')
#plt.plot([data.debug.real_robot_path[t, 0]], [data.debug.real_robot_path[t, 1]], '*g')
plt.plot([data.debug.noise_free_robot_path[t, 0]], [data.debug.noise_free_robot_path[t, 1]], '*m')
if show_particles:
samples = localization_filter.X.T
plt.scatter(samples[0], samples[1], s=2)
else:
plot2dcov(localization_filter.mu_bar[:-1],
localization_filter.Sigma_bar[:-1, :-1],
'red', 3,
legend='{} -'.format(args.filter_name.upper()))
plot2dcov(localization_filter.mu[:-1],
localization_filter.Sigma[:-1, :-1],
'blue', 3,
legend='{} +'.format(args.filter_name.upper()))
plt.legend()
if show_trajectory:
if len(sim_trajectory.mean.shape) > 2:
# This means that we probably intend to show the trajectory for ever particle.
x = np.squeeze(sim_trajectory.mean[0:t, 0, :])
y = np.squeeze(sim_trajectory.mean[0:t, 1, :])
plt.plot(x, y)
else:
plt.plot(sim_trajectory.mean[0:t, 0], sim_trajectory.mean[0:t, 1], 'blue')
if show_plots:
# Draw all the plots and pause to create an animation effect.
plt.draw()
plt.pause(args.plot_pause_len)
if write_movie:
movie_writer.grab_frame()
progress_bar.finish()
if show_plots:
plt.show(block=True)
if store_sim_data:
file_path = os.path.join(args.output_dir, 'output_data.npy')
with open(file_path, 'wb') as data_file:
np.savez(data_file,
mean_trajectory=sim_trajectory.mean,
covariance_trajectory=sim_trajectory.covariance)
def main():
arguments = docopt(__doc__)
site = arguments['<site>']
if arguments['--HUD']:
source = "HUD"
dataset_id = site
client = None
if arguments['--Socrata']:
source = "Socrata"
client = Socrata(site, arguments.get('-a'))
try:
if arguments.get('ls'):
datasets = list_datasets(client, site)
print(tabulate(datasets, headers='keys', tablefmt='psql'))
elif arguments.get('insert'):
if source == "Socrata":
dataset_id = arguments['<dataset_id>']
metadata = client.get_metadata(dataset_id)['columns']
if source == "HUD":
metadata = json.loads(
urllib.request.urlopen(site).read())['fields']
engine, session, geo = \
get_connection(arguments['-d'], metadata, source)
if arguments['-t']:
Binding = get_binding(
metadata, geo, arguments['-t'], source
)
else:
Binding = get_binding(
metadata, geo, dataset_id, source
)
# Create the table
try:
Binding.__table__.create(engine)
except ProgrammingError as e:
# Catch these here because this is our first attempt to
# actually use the DB
if 'already exists' in str(e):
raise CLIError(
'Destination table already exists. Specify a new table'
' name with -t.'
)
raise CLIError('Error creating destination table: %s' % str(e))
num_rows, data = get_data(source, dataset_id, client)
bar = FillingCirclesBar(' ▶ Loading from source', max=num_rows)
# Iterate the dataset and INSERT each page
if source == "Socrata":
for page in data:
insert_data(page, session, bar, Binding)
if source == "HUD":
insert_data(data, session, bar, Binding)
bar.finish()
ui.item(
'Committing rows (this can take a bit for large datasets).'
)
session.commit()
success = 'Successfully imported %s rows.' % (
num_rows
)
ui.header(success, color='\033[92m')
if client:
client.close()
except CLIError as e:
ui.header(str(e), color='\033[91m')
filename1 = 'csvs/drone1.csv'
filename2 = 'csvs/drone2.csv'
poses1, scans1 = file_read(filename1)
poses1, scans1 = preprocessing(poses1, scans1)
poses2, scans2 = file_read(filename2)
poses2, scans2 = preprocessing(poses2, scans2)
poses = np.vstack([poses1, poses2])
scans = scans1 + scans2
# Configuration parameters
progress_bar = FillingCirclesBar('Simulation Progress', max=len(poses))
animate = 0
save_frames = 0
# Clear occupancy grid
DIM_X = 4.0
DIM_Y = 4.0
RESOLUTION = 0.04
LOWEST_X = -2.0
LOWEST_Y = -2.0
grid = np.zeros((int(DIM_X / RESOLUTION), int(DIM_Y / RESOLUTION)))
robotX1 = poses1[:, 0]
robotX2 = poses2[:, 0]
robotY1 = poses1[:, 1]
def __init__(self, message, max, tail=None):
FillingCirclesBar.__init__(self, message, max=max)
self._solved = 0
self.suffix = "%(percent)5.1f%% | +%(solved)5s @ %(elapsed_td)s | EST +%(eta_solved)5s @ %(eta_td)s"
if tail:
self.suffix += " | %s " % tail
def main():
args = get_cli_args()
validate_cli_args(args)
alphas = np.array(args.alphas)**2
beta = np.array(args.beta)
beta[1] = np.deg2rad(beta[1])
mean_prior = np.array([180., 50., 0.])
Sigma_prior = 1e-12 * np.eye(3, 3)
initial_state = Gaussian(mean_prior, Sigma_prior)
if args.input_data_file:
data = load_data(args.input_data_file)
elif args.num_steps:
# Generate data, assuming `--num-steps` was present in the CL args.
data = generate_input_data(initial_state.mu.T, args.num_steps,
args.num_landmarks_per_side,
args.max_obs_per_time_step, alphas, beta,
args.dt)
else:
raise RuntimeError('')
should_show_plots = True if args.animate else False
should_write_movie = True if args.movie_file else False
should_update_plots = True if should_show_plots or should_write_movie else False
field_map = FieldMap(args.num_landmarks_per_side)
fig = get_plots_figure(should_show_plots, should_write_movie)
movie_writer = get_movie_writer(should_write_movie, 'Simulation SLAM',
args.movie_fps, args.plot_pause_len)
progress_bar = FillingCirclesBar('Simulation Progress', max=data.num_steps)
with movie_writer.saving(
fig, args.movie_file,
data.num_steps) if should_write_movie else get_dummy_context_mgr():
for t in range(data.num_steps):
# Used as means to include the t-th time-step while plotting.
tp1 = t + 1
# Control at the current step.
u = data.filter.motion_commands[t]
# Observation at the current step.
z = data.filter.observations[t]
# TODO SLAM predict(u)
# TODO SLAM update
progress_bar.next()
if not should_update_plots:
continue
plt.cla()
plot_field(field_map, z)
plot_robot(data.debug.real_robot_path[t])
plot_observations(data.debug.real_robot_path[t],
data.debug.noise_free_observations[t],
data.filter.observations[t])
plt.plot(data.debug.real_robot_path[1:tp1, 0],
data.debug.real_robot_path[1:tp1, 1], 'm')
plt.plot(data.debug.noise_free_robot_path[1:tp1, 0],
data.debug.noise_free_robot_path[1:tp1, 1], 'g')
plt.plot([data.debug.real_robot_path[t, 0]],
[data.debug.real_robot_path[t, 1]], '*r')
plt.plot([data.debug.noise_free_robot_path[t, 0]],
[data.debug.noise_free_robot_path[t, 1]], '*g')
# TODO plot SLAM solution
if should_show_plots:
# Draw all the plots and pause to create an animation effect.
plt.draw()
plt.pause(args.plot_pause_len)
if should_write_movie:
movie_writer.grab_frame()
progress_bar.finish()
plt.show(block=True)
def download_and_verify(path, destination=None):
"""
Downloads the Apache file and verifies its hash
:param path: the download file path, e.g. /nifi/nifi-registry/nifi-registry-0.5.0/nifi-registry-0.5.0-bin.tar.gz
:param destination: the location to save the downloaded file or file object
"""
destination = destination or "."
if isinstance(destination, str):
download_dir = dirname(destination)
download_file = basename(destination) or basename(path)
if isdir(download_file):
download_dir = download_file
download_file = basename(path)
download_path = expanduser(os.path.join(download_dir, download_file))
logging.info(
"Downloading Apache project {path} to destination {dest}".format(
path=path, dest=download_path))
assert not os.path.exists(download_path), "File already exists"
else:
download_path = destination
logging.info("Downloading Apache project {path}".format(path=path))
site = "www"
try:
expected_hash = get_hash(path, site)
except requests.exceptions.HTTPError:
logging.debug("Not found, try from archive")
site = "archive"
expected_hash = get_hash(path, site)
logging.info("Downloading from archive")
with requests.get(get_mirror_url(path, site), stream=True) as r:
r.raise_for_status()
file_length = r.headers.get("content-length")
if file_length:
file_length = int(file_length)
logging.info("File size: {size}".format(
size=humanize.naturalsize(file_length)))
progress_bar = FillingCirclesBar("Downloading",
max=ceil(file_length /
DOWNLOAD_CHUNK_SIZE))
else:
progress_bar = Spinner("Downloading")
def save_to_file(_f):
m = hashlib.sha512()
for chunk in r.iter_content(chunk_size=DOWNLOAD_CHUNK_SIZE):
if chunk:
_f.write(chunk)
m.update(chunk)
progress_bar.next()
actual_hash = m.hexdigest()
assert actual_hash in expected_hash,\
"Hash of downloaded file is invalid, expected {expected_hash} but got {actual_hash}.".format(
expected_hash=expected_hash,
actual_hash=actual_hash
)
if hasattr(download_path, "write"):
save_to_file(download_path)
else:
with open(download_path, "wb") as f:
save_to_file(f)
assert os.path.exists(
download_path), "File could not be downloaded."
print(" Done.", file=sys.stderr)