def print_config(directory, outdir):
from reprep import Report
get_vehicles_config().load(directory)
def write_report(r):
out = os.path.join(outdir, '%s.html' % r.nid)
rd = os.path.join(outdir, 'images')
logger.info('Writing to %r' % out)
r.to_html(out, resources_dir=rd)
worlds = get_conftools_worlds()
r = Report('worlds')
create_generic_table(r, 'VehiclesConfig', worlds, ['desc', 'code'])
write_report(r)
dynamics = get_conftools_dynamics()
r = Report('dynamics')
create_generic_table(r, 'VehiclesConfig', dynamics, ['desc', 'code'])
write_report(r)
sensors = get_conftools_sensors()
r = Report('sensors')
create_generic_table(r, 'VehiclesConfig', sensors, ['desc', 'code'])
write_report(r)
vehicles = get_conftools_vehicles()
r = Report('vehicles')
create_generic_table(r, 'VehiclesConfig', vehicles,
['desc', 'dynamics', 'id_dynamics', 'sensors'])
write_report(r)
def draw_libdepgraph(res):
""" Just display the dependencies between libraries """
r = Report()
fd = res['fd']
assert isinstance(fd, FindDependencies)
G = fd.create_libgraph()
# create another graph only with libraries
gg = my_gvgen.GvGen(options="rankdir=TB")
@memoize_simple
def get_gg_node(entry):
label = entry
return gg.newItem(label)
for entry in G.nodes():
get_gg_node(entry)
for entry1, entry2 in G.edges():
n1 = get_gg_node(entry1)
n2 = get_gg_node(entry2)
gg.newLink(n1, n2)
gg_figure(r, 'graph', gg, do_dot=False)
return r
def draw_depgraph(res):
r = Report()
fd = res['fd']
assert isinstance(fd, FindDependencies)
G = fd.create_graph()
gg = my_gvgen.GvGen(options="rankdir=TB")
@memoize_simple
def get_gg_cluster(libname):
print('creating cluster %s ' % entry)
return gg.newItem(libname)
@memoize_simple
def get_gg_node(entry):
print('creating node %s ' % entry)
parent = get_gg_cluster(entry.libname)
label = '%s/%s' % (entry.libname, entry.name)
return gg.newItem(label, parent=parent)
for entry in G.nodes():
get_gg_node(entry)
for entry1, entry2 in G.edges():
n1 = get_gg_node(entry1)
n2 = get_gg_node(entry2)
gg.newLink(n1, n2)
gg_figure(r, 'graph', gg, do_dot=False)
return r
def report_dds(config, id_discdds, discdds, image='lena'):
set_current_config(config)
r = Report('dds-%s' % (id_discdds))
image = config.images.instance(image)
y0 = UncertainImage(image)
discdds.display(r, y0)
return r
def go():
ieee_fonts_zoom3(pylab)
r = Report()
algos = [InvMult2.ALGO_UNIFORM, InvMult2.ALGO_VAN_DER_CORPUT]
for algo in algos:
InvMult2.ALGO = algo
InvPlus2.ALGO = algo
print('Using algorithm %s ' % algo)
with r.subsection(algo) as r2:
# first
F = parse_poset('dimensionless')
R = F
dp = InvMult2(F, (R, R))
ns = [3, 4, 5, 6, 10, 15]
axis = (0.0, 6.0, 0.0, 6.0)
with r2.subsection('invmult2') as rr:
go1(rr, ns, dp, plot_nominal_invmult, axis)
# second
axis = (0.0, 1.2, 0.0, 1.2)
dp = InvPlus2(F, (R, R))
with r2.subsection('invplus2') as rr:
go1(rr, ns, dp, plot_nominal_invplus, axis)
fn = 'out-plot_approximations/report.html'
print('writing to %s' % fn)
r.to_html(fn)
def create_report_comb_stats(comb_id, tc_ids, alg_ids, deps):
r = Report('set-%s' % comb_id)
# has_ground_truth = 'cheat' in alg_ids or 'echeat' in alg_ids
#
# if 'cheat' in alg_ids: cheater = 'cheat'
# if 'echeat' in alg_ids: cheater = 'echeat'
#
# if has_ground_truth:
# for tc_id in tc_ids:
# max_spearman = deps[(tc_id, cheater)]['spearman']
# for alg_id in alg_ids:
# res = deps[(tc_id, alg_id)]
# res['spearman_score'] = res['spearman'] / max_spearman
def tablevar(var, format='%.2f', not_found=np.NaN):
def getter(tc_id, alg_id):
res = deps[(tc_id, alg_id)]
if var in res:
return format % res[var]
else:
return not_found
return getter
print entries
for var, format in entries:
caption = var
r.table(var,
caption=caption,
**generic_table(tc_ids, alg_ids, tablevar(var, format)))
return r
def test_invalid_id_2(self):
valid = [
"cioa",
"cioa",
"cioa_",
"cioa-0.4",
"cioa-",
]
invalid = [
"cioa/",
"cioa:",
"cioa ",
"cioa <",
"$cioa",
" cioa",
"",
'"',
'""',
"'",
"a\\a",
]
for s in invalid:
print("TRying with %r" % s)
if not contracts.all_disabled():
self.assertRaises((ValueError, ContractNotRespected), Report,
s)
for s in valid:
Report(s)
def create_report(G, constraint_stats=False):
r = Report(G.graph['name'])
f = r.figure("Graph plots")
report_add_coordinates_and_edges(r,
'graph',
G,
f,
plot_edges=True,
plot_vertices=True)
report_add_coordinates_and_edges(r,
'graph-edges',
G,
f,
plot_edges=True,
plot_vertices=False)
report_add_coordinates_and_edges(r,
'graph-vertices',
G,
f,
plot_edges=False,
plot_vertices=True)
r.text('node_statistics', graph_degree_stats(G))
if constraint_stats:
f = r.figure("Constraints statistics")
print('Creating statistics')
stats = graph_errors(G, G)
print(' (done)')
report_add_distances_errors_plot(r, nid='statistics', stats=stats, f=f)
r.text('constraints_stats', graph_errors_print('constraints', stats))
return r
def report_statistics(id_sub, stats):
records = stats['records']
distance = records['distance']
delta = records['delta']
order = scale_score(distance)
order = order / float(order.size)
r = Report('stats-%s' % id_sub)
r.data('records', records)
f = r.figure()
with f.plot('scatter') as pylab:
pylab.scatter(delta, distance)
pylab.xlabel('delta')
pylab.ylabel('distance')
pylab.axis((-1, np.max(delta) + 1, -0.05, np.max(distance)))
with f.plot('with_stats', **dp_predstats_fig) as pylab:
fancy_error_display(pylab, delta, distance, 'g')
with f.plot('distance_order', **dp_predstats_fig) as pylab:
fancy_error_display(pylab, delta, order, color='k')
f = r.figure(cols=1)
bins = np.linspace(0, np.max(distance), 100)
for i, d in enumerate(set(delta)):
with f.plot('conditional%d' % i) as pylab:
which = delta == d
pylab.hist(distance[which], bins)
return r
def show_discdds_geo_main(config, parser):
""" Displays the intrinsic geometry of a learned DDS """
parser.add_option("-o",
"--output",
help="Output directory",
default='out/dp-show-discdds-geo/')
parser.add_option("-t",
"--tolerance",
help="Normalized tolerance",
default=0.3,
type='float')
options, which = parser.parse()
outdir = options.output
if not which:
todo = config.discdds.keys()
else:
todo = config.discdds.expand_names(which)
for id_dds in todo:
dds = config.discdds.instance(id_dds)
report = Report(id_dds)
show_diffeo_structure(dds, report, tolerance=options.tolerance)
write_report_files(report, basename=os.path.join(outdir, id_dds))
def report_vit(mdp, vit_res):
r = Report()
f = r.figure()
with f.plot('value') as pylab:
mdp.display_state_values(pylab, vit_res)
return r
def set_goal_observations(self, goal):
self.goal = self.obs2ui(goal)
self.a_pred = [a.predict(self.goal) for a in self.actions_i]
r = Report('set_goal_observations')
self.report(r)
r.to_html('set_goal_observations.html')
def write_similarity_matrix(A, out, more=False, images=None):
dtu.safe_pickle_dump(A, out + '.pickle')
# rgb = rgb_zoom(scale(A), 8)
rgb = scale(A)
rgb = dtu.d8_image_zoom_linear(rgb, 8)
dtu.write_image_as_jpg(rgb, out + '.jpg')
if more:
r = Report()
n = A.shape[0]
for i in range(n):
f = r.figure()
ignore = 10
Ai = A[i, :].copy()
for i2 in range(i - ignore, i + ignore):
if 0 <= i2 < n:
Ai[i2] = np.inf
jbest = np.argmin(Ai)
with f.plot('i-%d' % i) as pylab:
pylab.plot(A[i, :], '-*')
if images:
f.data_rgb(str(i), dtu.bgr_from_rgb(images[i]))
f.data_rgb(str(jbest), dtu.bgr_from_rgb(images[jbest]))
r.to_html(out + '.html')
def report_resample(mdp, resample_res): # @UnusedVariable
support_points = resample_res['support_points']
sampled_points = resample_res['sampled_points']
delaunay_tri = resample_res['delaunay_tri']
r = Report()
f = r.figure()
with f.plot('support') as pylab:
for p in support_points:
pylab.plot(p[0], p[1], 'kx')
for p in sampled_points:
pylab.plot(p[0], p[1], 'rx')
with f.plot('triangulation') as pylab:
plot_triangulation(pylab, delaunay_tri)
with f.plot('both') as pylab:
plot_triangulation(pylab, delaunay_tri)
for p in support_points:
pylab.plot(p[0], p[1], 'kx')
for p in sampled_points:
pylab.plot(p[0], p[1], 'rx')
return r
def report_trajectories(res, name_obs=False):
r = Report()
f = r.figure()
import networkx as nx
G0 = create_graph_trajectories0(res['trajectories'], label_state=False,
name_obs=name_obs)
f.data('tree0', nx.to_pydot(G0).create_png(), mime=MIME_PNG)
G0 = create_graph_trajectories0(res['trajectories'], label_state=True,
name_obs=name_obs)
f.data('tree1', nx.to_pydot(G0).create_png(), mime=MIME_PNG)
#
# G1 = create_graph_trajectories(res['decisions'])
# d1 = nx.to_pydot(G1) # d is a pydot graph object, dot options can be easily set
# # r.data('tree1', d.create_pdf(), mime=MIME_PDF)
# f.data('tree1', d1.create_png(), mime=MIME_PNG)
#
#
#
# if 'decisions_dis' in res:
# G2 = create_graph_trajectories(res['decisions_dis'])
# d2 = nx.to_pydot(G2) # d is a pydot graph object, dot options can be easily set
# f.data('tree2', d2.create_png(), mime=MIME_PNG)
return r
def report_dds_fill(id_discdds, **params):
dds = get_conftools_discdds().instance(id_discdds)
r = Report('dds_fill-%s' % id_discdds)
ds = DiffeoSystemBounds(id_discdds, dds, **params)
ds.display(r)
return r
def report_summary(results):
# results = tuple (name, res dict)
r = Report()
cols = ['scenario', 'number of bits', 'number of states']
data = []
for name, res in results:
agent = res['agent']
nstates = len(agent.get_all_states())
nbits = agent.get_num_states_components()
row = [name, nbits, nstates]
data.append(row)
r.table('summary', data=data, cols=cols)
cols = ['number of bits', 'number of states']
data = []
rows = []
for name, res in results:
agent = res['agent']
nstates = len(agent.get_all_states())
nbits = agent.get_num_states_components()
rows.append(name)
data.append([nbits, nstates])
r.table('summary2', data=data, cols=cols, rows=rows)
return r
def show_symdiffeo(config, parser): #@UnusedVariable
""" Creates a report for symbolically-defined DDS. """
parser.add_option("-o",
"--output",
help="Output directory",
default='out/dp-show-symdiffeo/')
parser.add_option("-i", "--id_image", help="ID image.", default='lena')
parser.add_option("-d", "--id_diffeo", help="ID diffeo.")
parser.add_option("-r",
"--resolution",
default=64,
help="Resolution (pixels)")
options, which = parser.parse()
outdir = options.output
resolution = int(options.resolution)
if not which:
todo = config.symdiffeos.keys()
else:
todo = config.symdiffeos.expand_names(which)
id_image = options.id_image
image = config.images.instance(id_image)
image = resize(image, resolution, resolution)
for id_diffeo in todo:
diffeo = config.symdiffeos.instance(id_diffeo)
report = Report(id_diffeo)
symdiffeo_display(report, image, diffeo, resolution)
write_report_files(report, basename=os.path.join(outdir, id_diffeo))
def gg_get_format(gg, data_format):
from reprep import Report
r = Report()
do_dot = data_format == 'dot'
do_png = data_format == 'png'
do_pdf = data_format == 'pdf'
do_svg = data_format == 'svg'
with timeit_wall('gg_figure %s' % data_format):
gg_figure(r,
'graph',
gg,
do_dot=do_dot,
do_png=do_png,
do_pdf=do_pdf,
do_svg=do_svg)
if data_format == 'pdf':
pdf = r.resolve_url('graph_pdf').get_raw_data()
return pdf
elif data_format == 'png':
png = r.resolve_url('graph/graph').get_raw_data()
return png
elif data_format == 'dot':
dot = r.resolve_url('dot').get_raw_data()
return dot
elif data_format == 'svg':
svg = r.resolve_url('graph_svg').get_raw_data()
if '<html>' in svg:
msg = 'I did not expect a tag <html> in the SVG output'
svg = indent(svg, '> ')
raise_desc(Exception, msg, svg=svg)
return svg
else:
raise ValueError('No known format %r.' % data_format)
def report_results_single(func, objspec_name, results):
def get_string_result(res):
if res is None:
s = 'ok'
elif isinstance(res, Skipped):
s = 'skipped'
elif isinstance(res, PartiallySkipped):
parts = res.get_skipped_parts()
s = 'no ' + ','.join(parts)
else:
print('how to interpret %s? ' % describe_value(res))
s = '?'
return s
r = Report()
if not results:
r.text('warning', 'no test objects defined')
return r
rows = []
data = []
for id_object, res in results.items():
rows.append(id_object)
data.append([get_string_result(res)])
r.table('summary', rows=rows, data=data)
return r
def show_discdds(config, parser): # @UnusedVariable
""" Creates a report for a DDS. """
parser.add_option("-i", "--id_image", help="ID image.", default='lena')
parser.add_option("-o",
"--output",
help="Output directory",
default='out/dp-show-discdds/')
options, which = parser.parse()
outdir = options.output
if not which:
todo = config.discdds.keys()
else:
todo = config.discdds.expand_names(which)
id_image = options.id_image
image = UncertainImage(config.images.instance(id_image))
for id_dds in todo:
print('Writing %s' % id_dds)
dds = config.discdds.instance(id_dds)
report = Report(id_dds)
dds.display(report, image=image)
write_report_files(report, basename=os.path.join(outdir, id_dds))
def create_report_drone1_mass_cost(data):
matplotlib_settings()
cs = CommonStats(data)
r = Report()
figure_num_implementations2(r, data, cs, 'num_missions', 'endurance')
figure_discrete_choices2(r, data, cs, 'num_missions', 'endurance')
f = r.figure()
with f.plot('total_cost', **fig) as pylab:
ieee_spines_zoom3(pylab)
x = cs.get_functionality('num_missions')
y = cs.get_functionality('endurance')
z = cs.get_min_resource('total_cost')
plot_field(pylab, x, y, z, cmap=colormap)
pylab.title('total_cost', color=color_resources, y=1.08)
with f.plot('total_mass', **fig) as pylab:
ieee_spines_zoom3(pylab)
x = cs.get_functionality('num_missions')
y = cs.get_functionality('endurance')
z = cs.get_min_resource('total_mass')
plot_field(pylab, x, y, z, cmap=colormap)
pylab.title('total_mass', color=color_resources, y=1.08)
return r
def execute_proxy(operations):
report = Report()
resources = {}
resources['report'] = report
for what, kwargs in operations:
what(resources=resources, **kwargs)
print(report.format_tree())
return report
def get_optim_state_report(s, opt):
r = Report()
from mcdp_opt_tests.test_basic import plot_ndp
plot_ndp(r, 'current', s.get_current_ndp(), opt.library)
r.text('order', 'creation order: %s' % s.creation_order)
r.text('msg', s.get_info())
return r
def filter_phase_report(stats):
P = stats['P']
r = Report('unknown')
f = r.figure()
r.data('P', P.T).display('scale').add_to(f)
return r
def create_report_min_joint(data):
matplotlib_settings()
cs = CommonStats(data)
r = Report()
figure_num_implementations2(r, data, cs, 'missions', 'capacity')
figure_discrete_choices2(r, data, cs, 'missions', 'capacity')
return r
def save_graph(self):
""" Saves a copy of the progress so far """
r = Report(self.id_dds)
outdir = 'out/cover-progress/%s/' % self.id_dds
self.draw_graph(r)
filename = os.path.join(outdir, 'graphs.html')
logger.info('Writing to %r' % filename)
r.to_html(filename, write_pickle=True)
def check_ex16b_r(dp):
funsp = dp.get_fun_space()
bot = funsp.get_bottom()
res = dp.solve(bot)
print 'res', res
r = Report()
return r
def report_example(param2, samples):
print('report_example(%s, %s)' % (param2, samples))
if param2 == -1:
print('generating exception')
raise Exception('fake exception')
r = Report()
r.text('samples', str(samples))
print('creating report')
return r
def report_start_dist(mdp):
r = Report()
f = r.figure()
start = mdp.get_start_dist()
with f.plot('start_dist', caption='Start distribution') as pylab:
mdp.display_state_dist(pylab, start)
return r
