def setUp(self): # n1 -- n2 -- n3 -- n4 # \_ n3bis self.n1 = Node("n1") self.n3bis = self.n1.data("n3", None) self.n2 = self.n1.data("n2", None) self.n3 = self.n2.data("n3", None) self.n4 = self.n3.data("n4", None) self.all = [self.n1, self.n2, self.n3, self.n4, self.n3bis]
def create_report_affine(state, report_id): y_dot_mean = state.result.y_dot_stats.mean y_dot_cov = state.result.y_dot_stats.covariance y_dot_inf = state.result.y_dot_stats.information y_dot_min = state.result.y_dot_stats.minimum y_dot_max = state.result.y_dot_stats.maximum y_mean = state.result.y_stats.mean y_cov = state.result.y_stats.covariance y_inf = state.result.y_stats.information y_min = state.result.y_stats.minimum y_max = state.result.y_stats.maximum u_mean = state.result.u_stats.mean u_inf = state.result.u_stats.information u_cov = state.result.u_stats.covariance N = state.result.N.get_value() report_y_dot = create_report_var( name="y_dot", mean=y_dot_mean, cov=y_dot_cov, inf=y_dot_inf, minimum=y_dot_min, maximum=y_dot_max ) report_y = create_report_var(name="y", mean=y_mean, cov=y_cov, inf=y_inf, minimum=y_min, maximum=y_max) report_u = create_report_var(name="u", mean=u_mean, cov=u_cov, inf=u_inf) T = state.result.T.get_value() report_T = create_report_figure_tensors(T, report_id="T", caption="Learned T") Nreport = Node("n-report") with Nreport.data("N", N).data_file("N", "image/png") as filename: pylab.figure() for i in range(N.shape[1]): v = N[:, i].squeeze() pylab.plot(v) pylab.savefig(filename) pylab.close() f = Nreport.figure("nfig") f.sub("N/N") bT = state.result.bT.get_value() report_bT = create_report_figure_tensors(bT, report_id="bT", caption="Learned bT") bTn = state.result.bTn.get_value() report_bTn = create_report_figure_tensors(bTn, report_id="bTn", caption="Learned bTn") node = Node(id=report_id, children=[report_y, report_y_dot, report_u, report_T, Nreport, report_bT, report_bTn]) return node
def create_report_tensors(state, report_id): T = state.result.T vname = "" #TODO caption = '%s learned tensors, %d iterations' % \ (vname, state.total_iterations) A = create_report_figure_tensors(T, same_scale=False, report_id='tensors', caption=caption) B = create_report_figure_tensors(T, same_scale=True, report_id='tensors-ss', caption='%s (on the same scale)' % caption) report = Node(report_id) report.add_child(A) report.add_child(B) return report
def create_report_var(name, mean, cov, inf, minimum=None, maximum=None): report = Node(id=name) report.data("covariance", cov) report.data("information", inf) node_mean = report.data("mean", mean) with node_mean.data_file("bounds", "image/png") as filename: e = 3 * sqrt(cov.diagonal()) pylab.ioff() f = pylab.figure() x = range(len(mean)) pylab.errorbar(x, mean, yerr=e) if minimum is not None: pylab.plot(x, minimum, "b-") if maximum is not None: pylab.plot(x, maximum, "b-") pylab.savefig(filename) pylab.close(f) f = report.figure(name) f.sub("mean/bounds", caption="Mean") f.sub("covariance", caption="Covariance", display="posneg") f.sub("information", caption="Information", display="posneg") return report
def create_report_figure_tensors(T, report_id, same_scale=False, caption=None): report = Node(report_id) f = report.figure('tensors', caption=caption) if same_scale: max_value = abs(T).max() else: max_value = None components = [(0, 'Tx', '$T_x$'), (1, 'Ty', '$T_y$'), (2, 'Ttheta', '$T_{\\theta}$')] for component, slice, caption in components: report.data(slice, T[component, :, :].squeeze()) f.sub(slice, display='posneg', max_value=max_value) return report
def node_from_hdf_group_v1(hf, group): major = group._v_attrs["reprep_format_version"][0] if major != 1: raise ValueError("I can oly read v1, not %s" % major) nid = group._v_name caption = group._v_title cgroups = [ child for child in group._f_listNodes("Group") if "reprep_format_version" in child._v_attrs ] cgroups.sort(key=lambda x: x._v_attrs["reprep_order"]) children = [node_from_hdf_group_v1(hf, child) for child in cgroups] nodetype = group._v_attrs["reprep_node_type"] if nodetype == "Node": return Node(nid=nid, children=children, caption=caption) elif nodetype == "Figure": cols = group.ncols.read() if cols == 0: cols = None figure = Figure(nid=nid, caption=caption, cols=cols) nsubs = len(group.subfigures._f_listNodes()) for i in range(nsubs): s = group.subfigures._v_children["sub%d" % i] sub = SubFigure( resource=s.resource.read(), image=s.image.read(), web_image=s.web_image.read(), caption=s.caption.read(), ) figure.subfigures.append(sub) figure.children = children return figure elif nodetype == "Table": table_data = group.table_data.read() rows = group.rows.read() cols = group.cols.read() table = Table(nid, data=table_data, cols=cols, rows=rows, caption=caption) table.children = children return table elif nodetype == "DataNode": mime, raw_data = read_python_data(group, "data") res = DataNode(nid=nid, data=raw_data, mime=mime, caption=caption) res.children = children return res else: raise ValueError("Unknown node_type %r" % nodetype)
def create_report_covariance(state, report_id): covariance = state.result.cov_sensels report = Node(report_id) report.data('covariance', covariance) report.data('correlation', cov2corr(covariance)) report.data('information', pinv(covariance, rcond=1e-2)) f = report.figure('matrices') f.sub('covariance', caption='Covariance matrix', display='posneg') f.sub('correlation', caption='Correlation matrix', display='posneg') f.sub('information', caption='Information matrix', display='posneg') return report
class Test(unittest.TestCase): def setUp(self): # n1 -- n2 -- n3 -- n4 # \_ n3bis self.n1 = Node("n1") self.n3bis = self.n1.data("n3", None) self.n2 = self.n1.data("n2", None) self.n3 = self.n2.data("n3", None) self.n4 = self.n3.data("n4", None) self.all = [self.n1, self.n2, self.n3, self.n4, self.n3bis] def test_normal(self): """ Testing normal cases of resolve_url """ self.assertEqual(self.n1, self.n2.resolve_url("..")) self.assertEqual(self.n1, self.n3.resolve_url("../..")) self.assertEqual(self.n1, self.n4.resolve_url("../../..")) self.assertEqual(self.n2, self.n4.resolve_url("../../../n2")) self.assertEqual(self.n2, self.n1.resolve_url("n2")) self.assertEqual(self.n3, self.n1.resolve_url("n2/n3")) def test_smart(self): """ Testing smart cases of resolve_url """ self.assertEqual(self.n1.resolve_url("n3"), self.n3bis) self.assertEqual(self.n2.resolve_url("n3"), self.n3) self.assertEqual(self.n3.resolve_url("n3"), self.n3) self.assertEqual(self.n2.resolve_url("n1/n3"), self.n3bis) self.assertEqual(self.n3.resolve_url("n1/n3"), self.n3bis) self.assertEqual(self.n4.resolve_url("n4"), self.n4) self.assertEqual(self.n3.resolve_url("n4"), self.n4) self.assertEqual(self.n2.resolve_url("n4"), self.n4) self.assertEqual(self.n1.resolve_url("n4"), self.n4) for n in self.all: self.assertEqual(n.resolve_url("n4"), self.n4) def test_relative(self): for A in self.all: for B in self.all: if A == B: continue url = A.get_relative_url(B) self.assertEqual(A.resolve_url_dumb(url), B) def test_not_existent(self): """ Testing that we warn if not existent """ self.assertRaises(NotExistent, self.n1.resolve_url, "x") def test_not_found(self): self.assertRaises(NotExistent, self.n1.resolve_url, "..") def test_well_formed(self): """ Testing that we can recognize invalid urls """ self.assertRaises(InvalidURL, self.n1.resolve_url, "") self.assertRaises(InvalidURL, self.n2.resolve_url, "//")
def main(): """ Prepare data with: average_logs_results --dir . --experiment laser_bgds_boot """ print "Loading first..." results = my_pickle_load('out/average_logs_results/laser_bgds_boot.pickle') report = Node('laser_bgds_boot') manual = my_figures(results) write_figures_for_paper(manual) report.add_child(manual) k = 1 variants = sorted(results.keys()) # FIXME: this was uncommented (Was I in a hurry?) # variants = [] for variant in variants: data = results[variant] G = data['G'] B = data['B'] # gy_mean = data['gy_mean'] # y_mean = data['y_mean'] # one_over_y_mean = data['one_over_y_mean'] y_dot_var = data['y_dot_var'] y_dot_svar = data['y_dot_svar'] gy_var = data['gy_var'] gy_svar = data['gy_svar'] print 'Considering %s' % variant n = report.node(variant) #readings = range(360, G.shape[0]) readings = range(0, G.shape[0]) N = len(readings) G = G[readings, :] B = B[readings, :] y_dot_var = y_dot_var[readings] y_dot_svar = y_dot_svar[readings] gy_var = gy_var[readings] gy_svar = gy_svar[readings] for k in [0, 2]: var = 'G[%s]' % k G_k = n.data(var, G[:, k]) G_k_n = G[:, k] / gy_var with G_k.data_pylab('original') as pylab: pylab.plot(G[:, k]) pylab.title(var + ' original') M = abs(G[:, k]).max() pylab.axis([0, N, -M, M]) with G_k.data_pylab('normalized') as pylab: pylab.plot(G_k_n) pylab.title(var + ' normalized') M = abs(G_k_n).max() pylab.axis([0, N, -M, M]) for k in [0, 2]: var = 'B[%s]' % k B_k = n.data(var, B[:, k]) B_k_n = B[:, k] / gy_var with B_k.data_pylab('original') as pylab: pylab.plot(B[:, k]) pylab.title(var + ' original') M = abs(B[:, k]).max() pylab.axis([0, N, -M, M]) with B_k.data_pylab('normalized') as pylab: pylab.plot(B_k_n) pylab.title(var + ' normalized') M = abs(B_k_n).max() pylab.axis([0, N, -M, M]) n.figure('obtained', sub=['B[0]/normalized', 'B[2]/normalized', 'G[0]/normalized', 'G[2]/normalized', ]) n.figure('G', sub=['G[0]/original', 'G[0]/normalized', 'G[2]/original', 'G[2]/normalized']) n.figure('B', sub=['B[0]/original', 'B[0]/normalized', 'B[2]/original', 'B[2]/normalized']) theta = linspace(0, 2 * math.pi, N) - math.pi / 2 with n.data_pylab('B_v') as pylab: pylab.plot(-cos(theta)) pylab.axis([0, N, -2, 2]) with n.data_pylab('B_omega') as pylab: pylab.plot(0 * theta) pylab.axis([0, N, -2, 2]) with n.data_pylab('G_v') as pylab: pylab.plot(-sin(theta)) pylab.axis([0, N, -2, 2]) with n.data_pylab('G_omega') as pylab: pylab.plot(numpy.ones((N))) pylab.axis([0, N, -2, 2]) n.figure('expected', sub=['B_v', 'B_omega', 'G_v', 'G_omega']) norm = lambda x: x / x.max() # norm = lambda x : x with n.data_pylab('y_dot_var') as pylab: pylab.plot(norm(y_dot_var), 'b', label='y_dot_var') pylab.plot(norm(y_dot_svar ** 2), 'g', label='y_dot_svar') pylab.axis([0, N, 0, 1]) pylab.legend() with n.data_pylab('gy_var') as pylab: pylab.plot(norm(gy_var) , 'b', label='gy_var') pylab.plot(norm(gy_svar ** 2), 'g', label='gy_svar') pylab.axis([0, N, 0, 1]) pylab.legend() f = n.figure('stats') f.sub('y_dot_var') f.sub('gy_var') for var in ['y_dot_mean', 'gy_mean', 'y_mean', 'y_var', 'one_over_y_mean']: with n.data_pylab(var) as pylab: pylab.plot(data[var][readings]) f.sub(var) with n.data_pylab('y_mean+var') as pylab: y = data['y_mean'][readings] var = data['y_var'][readings] pylab.errorbar(range(0, N), y, yerr=3 * numpy.sqrt(var), fmt='ro') f.sub('y_mean+var') print variant if True: #variant == 'GS_DS': s = {'variant': variant, 'Gl':G[:, 0] / gy_var, 'Ga':G[:, 2] / gy_var, 'Bl':B[:, 0] / gy_var, 'Ba':B[:, 2] / gy_var } filename = "out/laser_bgds_boot/%s:GB.pickle" % variant.replace('/', '_') make_sure_dir_exists(filename) my_pickle_dump(s, filename) print 'Written on %s' % filename node_to_html_document(report, 'out/laser_bgds_boot/report.html')
def my_figures(results): r = Node('myfigures') sick_indices = range(342, 704) N = len(sick_indices) theta = linspace(0, 2 * math.pi, N) - math.pi / 2 theta_deg = theta * 180 / math.pi variants = ['GI_DI', 'GS_DS'] xlabel = 'ray direction (deg)' ylabel = 'normalized tensor (unitless)' a = 0.9 figparams = { 'mime': 'application/pdf', 'figsize': (4 * a, 3 * a) } def adjust_axes(pylab): # left, bottom, right, top #borders = [0.15, 0.15, 0.03, 0.05] borders = [0.2, 0.17, 0.05, 0.05] w = 1 - borders[0] - borders[2] h = 1 - borders[1] - borders[3] pylab.axes([borders[0], borders[1], w, h]) def set0axis(pylab): a = pylab.axis() pylab.axis([-91, +271, 0, a[3]]) pylab.xticks([-90, 0, 90, 180, 270]) with r.data_pylab('report_y_mean', **figparams) as pylab: adjust_axes(pylab) pylab.plot(theta_deg, results[variants[0]]['y_mean'][sick_indices], 'k-') pylab.xlabel(xlabel) pylab.ylabel('distance (m)') set0axis(pylab) with r.data_pylab('report_y_var', **figparams) as pylab: adjust_axes(pylab) var = results[variants[0]]['y_var'][sick_indices] pylab.plot(theta_deg, numpy.sqrt(var), 'k-') pylab.xlabel(xlabel) pylab.ylabel('std-dev (m)') set0axis(pylab) norm = lambda x: x / x.mean() with r.data_pylab('report_gy_var', **figparams) as pylab: adjust_axes(pylab) for variant in variants: x = results[variant]['gy_var'][sick_indices] x /= numpy.max(abs(x)) pylab.plot(theta_deg, numpy.sqrt(x) , label=variant) pylab.legend(loc='lower right') pylab.xlabel(xlabel) pylab.ylabel('norm. std-dev (unitless)') set0axis(pylab) with r.data_pylab('report_y_dot_var', **figparams) as pylab: adjust_axes(pylab) for variant in variants: x = results[variant]['y_dot_var'][sick_indices] x /= numpy.max(abs(x)) pylab.plot(theta_deg, numpy.sqrt(x) , label=variant) pylab.legend(loc='lower right') pylab.xlabel(xlabel) pylab.ylabel('norm. std-dev (unitless)') set0axis(pylab) def set_x_axis(pylab): a = pylab.axis() pylab.axis([-91, +271, a[2], a[3]]) pylab.xticks([-90, 0, 90, 180, 270]) with r.data_pylab('report_Gv', **figparams) as pylab: adjust_axes(pylab) for variant in variants: gy_var = results[variant]['gy_var'][sick_indices] x = results[variant]['G'][sick_indices, 0] / gy_var #x /= normG[variant] x /= numpy.max(abs(x)) pylab.plot(theta_deg, x , label=variant) pylab.plot(theta_deg, -sin(theta), label='expected') pylab.plot(theta_deg, 0 * theta, 'k--') #pylab.axis([0, N, -2, 2]) #pylab.legend(loc='lower right') pylab.xlabel(xlabel) pylab.ylabel(ylabel) set_x_axis(pylab) with r.data_pylab('report_Gomega', **figparams) as pylab: adjust_axes(pylab) for variant in variants: gy_var = results[variant]['gy_var'][sick_indices] x = results[variant]['G'][sick_indices, 2] / gy_var #x /= normG[variant] x /= numpy.mean(abs(x)) pylab.plot(theta_deg, x, label=variant) pylab.plot(theta_deg, norm(numpy.ones((N))), label='expected') pylab.plot(theta_deg, 0 * theta, 'k--') #pylab.axis([0, N, 0, 1.5]) pylab.legend(loc='lower right') pylab.xlabel(xlabel) pylab.ylabel(ylabel) set_x_axis(pylab) with r.data_pylab('report_Bv', **figparams) as pylab: adjust_axes(pylab) for variant in variants: gy_var = results[variant]['gy_var'][sick_indices] x = results[variant]['B'][sick_indices, 0] / gy_var #x /= normB[variant] x /= numpy.max(abs(x)) pylab.plot(theta_deg, x, label=variant) pylab.plot(theta_deg, -cos(theta), label='expected') pylab.plot(theta_deg, 0 * theta, 'k--') #pylab.axis([0, N, -2, 2]) #pylab.legend(loc='lower right') pylab.xlabel(xlabel) pylab.ylabel(ylabel) set_x_axis(pylab) with r.data_pylab('report_Bomega', **figparams) as pylab: adjust_axes(pylab) for variant in variants: gy_var = results[variant]['gy_var'][sick_indices] x = norm(results[variant]['B'][sick_indices, 2]) / gy_var # /= normB[variant] x /= numpy.max(abs(x)) * 10 pylab.plot(theta_deg, x, label=variant) pylab.plot(theta_deg, 0 * theta, label='expected') #pylab.axis([0, N, -2, 2]) #pylab.legend(loc='lower right') pylab.xlabel(xlabel) pylab.ylabel(ylabel) set_x_axis(pylab) r.figure(sub=['report_y_mean', 'report_y_var', 'report_gy_var', 'report_y_dot_var']) r.figure(sub=['report_Gv', 'report_Gomega', 'report_Bv', 'report_Bomega']) return r
def testImageRGB(self): rgb = numpy.zeros((4, 4, 3), 'uint8') report = Node('test') report.data_rgb('rgb', rgb)
def analyze_olfaction_covariance(covariance, receptors): ''' Covariance: n x n covariance matrix. Positions: list of n positions ''' positions = [pose.get_2d_position() for pose, sens in receptors] #@UnusedVariable positions = array(positions).transpose().squeeze() require_shape(square_shape(), covariance) n = covariance.shape[0] require_shape((2, n), positions) distances = create_distance_matrix(positions) correlation = cov2corr(covariance) flat_distances = distances.reshape(n * n) flat_correlation = correlation.reshape(n * n) # let's fit a polynomial deg = 4 poly = polyfit(flat_distances, flat_correlation, deg=deg) knots = linspace(min(flat_distances), max(flat_distances), 2000) poly_int = polyval(poly, knots) poly_fder = polyder(poly) fder = polyval(poly_fder, distances) Ttheta = create_olfaction_Ttheta(positions, fder) Tx, Ty = create_olfaction_Txy(positions, fder, distances) report = Node('olfaction-theory') report.data('flat_distances', flat_distances) report.data('flat_correlation', flat_correlation) with report.data_file('dist_vs_corr', 'image/png') as filename: pylab.figure() pylab.plot(flat_distances, flat_correlation, '.') pylab.plot(knots, poly_int, 'r-') pylab.xlabel('distance') pylab.ylabel('correlation') pylab.title('Correlation vs distance') pylab.legend(['data', 'interpolation deg = %s' % deg]) pylab.savefig(filename) pylab.close() with report.data('fder', fder).data_file('fder', 'image/png') as filename: pylab.figure() pylab.plot(knots, polyval(poly_fder, knots), 'r-') pylab.title('f der') pylab.savefig(filename) pylab.close() report.data('distances', distances) report.data('correlation', correlation) report.data('covariance', covariance) report.data('f', polyval(poly, distances)) f = report.figure(id='cor-vs-distnace', caption='Estimated kernels', shape=(3, 3)) f.sub('dist_vs_corr') f.sub('fder') f.sub('f', display='scale') f.sub('distances', display='scale') f.sub('correlation', display='posneg') f.sub('covariance', display='posneg') T = numpy.zeros(shape=(3, Tx.shape[0], Tx.shape[1])) T[0, :, :] = Tx T[1, :, :] = Ty T[2, :, :] = Ttheta T_report = create_report_figure_tensors(T, report_id='tensors', caption="Predicted learned tensors") report.add_child(T_report) return report
def main(): """ Prepare data with: :: be_average_logs_results --dir . --experiment camera_bgds_boot -v gray/GI_DI -v contrast/GS_DS be_average_logs_results --dir . --experiment camera_bgds_stats -v gray/GI_DI -v contrast/GS_DS Reads: :: out/average_logs_results/camera_bgds_boot.pickle out/average_logs_results/camera_bgds_stats.pickle Writes: :: out/camera_bgds_boot/report.html out/camera_bgds_boot/report.pickle out/camera_bgds_boot/<variant>:G.pickle moreover, it calls camera_figures() that creates output_pattern = 'out/camera_figures/{variant}.tex' """ input1 = 'out/average_logs_results/camera_bgds_boot.pickle' input2 = 'out/average_logs_results/camera_bgds_stats.pickle' variant_pattern = "out/camera_bgds_boot/{variant}:G.pickle" out_html = 'out/camera_bgds_boot/report.html' out_pickle = 'out/camera_bgds_boot/report.pickle' results = my_pickle_load(input1) print 'Found variants: %s' % results.keys() stats = my_pickle_load(input2) print 'Found variants: %s' % stats.keys() print "Creating report..." report = Node('camera_bgds_boot') k = 1 variants = sorted(results.keys()) for variant_id in variants: variant = variant_id.replace('/', '_') print 'Considering %s' % variant data = results[variant_id] data2 = stats[variant_id] print data2.keys() #if not variant in ['gray_GI_DI', 'contrast_GS_DS']: # continue n = report.node(variant) f1 = n.figure('value') f2 = n.figure('sign') f3 = n.figure('abs') for variable, value in data.items(): v = n.data(variable, value) if len(value.shape) == 3: f1.sub(variable, display='rgb') else: v.data('sign', numpy.sign(value), desc='sign of %s' % variable) v.data('abs', numpy.abs(value), desc='abs of %s' % variable) f1.sub(variable, display='posneg', skim=1) f2.sub('%s/sign' % variable, display='posneg') f3.sub('%s/abs' % variable, display='scale', min_value=0) f4 = n.figure('stats') for variable, value in data2.items(): if len(value.shape) == 3: v = n.data(variable, value.astype('uint8')) f1.sub(variable, display='rgb') else: v = n.data(variable, value) #f4.sub(variable, display='scale', skim=1) f4.sub(variable, display='scale', skim=1, min_value=0) Gxl = data['Gxl'] Gyl = data['Gyl'] Gxa = data['Gxa'] Gya = data['Gya'] def set_zeros_to_one(x): x = x.copy() zeros, = nonzero(x.flat == 0) x.flat[zeros] = 1 print "%d/%d of data were 0" % (len(zeros), len(x.flat)) return x norm_gx = set_zeros_to_one (data2['gx_abs']) norm_gy = set_zeros_to_one (data2['gy_abs']) Gxl_norm = Gxl / norm_gx Gyl_norm = Gyl / norm_gy Gxa_norm = Gxa / norm_gx Gya_norm = Gya / norm_gy n.data('Gxl_norm', Gxl_norm) n.data('Gyl_norm', Gyl_norm) n.data('Gxa_norm', Gxa_norm) n.data('Gya_norm', Gya_norm) f5 = n.figure('normalized') display = {'display': 'posneg', 'skim': 2} f5.sub('Gxl_norm', **display) f5.sub('Gyl_norm', **display) f5.sub('Gxa_norm', **display) f5.sub('Gya_norm', **display) k += 1 if k > 1: pass # break # tmp if True: s = {'variant': variant, 'Gxl':Gxl_norm, 'Gyl':Gyl_norm, 'Gxa':Gxa_norm, 'Gya':Gya_norm } filename = variant_pattern.format(variant=variant) dir = os.path.dirname(filename) if not os.path.exists(dir): os.makedirs(dir) my_pickle_dump(s, filename) print 'Written on %s' % filename print "Writing on %s" % out_html report.to_html(out_html) #print "Writing on %s" % out_pickle my_pickle_dump(report, out_pickle)
def main(): def find_in_path(path, pattern): for root, dirs, files in os.walk(path): #@UnusedVariable for f in files: if fnmatch.fnmatch(f, pattern): yield os.path.join(root, f) dir = 'Bicocca_2009-02-25a/out/camera_bgds_predict/gray_GI_DI/' files = list(find_in_path(dir, '*.??.pickle*')) if not files: raise Exception('No files found.') for f in files: print 'Loading {0}'.format(f) data = my_pickle_load(f) basename = os.path.splitext(f)[0] out_html = basename + '/report.html' #out_pickle = basename + '/report.pickle' if not os.path.exists(basename): os.makedirs(basename) logdir = data['logdir'] time = data['time'] y = data['y'] y_dot = data['y_dot'] y_dot_pred = data['y_dot_pred'] y_dot_s = data['y_dot_s'] y_dot_pred_s = data['y_dot_pred_s'] report = Node('{logdir}-{time:.2f}'.format(logdir=logdir, time=time)) prod = -numpy.minimum(0, y_dot_s * y_dot_pred_s) report.data('y', y) report.data('y_dot', y_dot) report.data('y_dot_pred', y_dot_pred) report.data('y_dot_s', y_dot_s) report.data('y_dot_pred_s', y_dot_pred_s) report.data('prod', prod) f = report.figure('display') f.sub('y', display='rgb') f.sub('y_dot', display='posneg') f.sub('y_dot_pred', display='posneg') f.sub('y_dot_s', display='posneg') f.sub('y_dot_pred_s', display='posneg') f.sub('prod', display='scale') zones = [ ('ZoneA', range(95, 181), range(55, 140)), ('ZoneB', range(80, 111), range(480, 510)), ('ZoneC', range(50, 181), range(330, 460)) ] for zone in zones: name, y, x = zone zr = report.node(name) zf = zr.figure() for var in ['y', 'y_dot', 'y_dot_pred', 'y_dot_s', 'y_dot_pred_s', 'prod']: zd = data[var][y, :][:, x] zr.data(var, zd) if var == 'y': disp = {'display': 'rgb'} elif var == 'prod': disp = {'display': 'scale'} else: disp = {'display': 'posneg'} zf.sub(var, **disp) outdir = basename + '/' + name id = "%s:%.2f:%s" % (logdir, time, name) print id if not os.path.exists(outdir): os.makedirs(outdir) create_latex_frag(os.path.join(outdir, 'conf.tex'), outdir, zr, id, True) create_latex_frag(os.path.join(outdir, 'report.tex'), outdir, zr, id, False) print 'Writing on %s' % out_html node_to_html_document(report, out_html)
def testImage(self): C = numpy.random.rand(50, 50) information = pinv(C) T = numpy.random.rand(50, 50, 3) report = Node("rangefinder") report.data("Tx", T[:, :, 0]) report.data("Ty", T[:, :, 1]) report.data("Tz", T[:, :, 2]) cov = report.data("covariance", C) report.data("information", information) pylab = get_pylab_instance() with cov.data_file("plot", MIME_PNG) as f: pylab.figure() pylab.plot(C) pylab.savefig(f) pylab.close() report.table("results", cols=["One", "Two"], data=[[1, 2], [3, 4]]) f = report.figure(caption="Covariance and information matrix", cols=3) f.sub("covariance", "should default to plot") f.sub("covariance/plot", "Same as <-") f = report.figure("Tensors", cols=3) f.sub("Tx", display="posneg") f.sub("Ty", display="posneg") f.sub("Tz", display="posneg") self.node_serialization_ok(report)
def testImageRGB(self): rgb = numpy.zeros((4, 4, 3), "uint8") report = Node("test") report.data_rgb("rgb", rgb)
def testImage(self): C = numpy.random.rand(50, 50) information = pinv(C) T = numpy.random.rand(50, 50, 3) report = Node('rangefinder') report.data('Tx', T[:, :, 0]) report.data('Ty', T[:, :, 1]) report.data('Tz', T[:, :, 2]) cov = report.data('covariance', C) report.data('information', information) pylab = get_pylab_instance() with cov.data_file('plot', 'image/png') as f: pylab.figure() pylab.plot(C) pylab.savefig(f) pylab.close() report.table('results', cols=['One', 'Two'], data=[[1, 2], [3, 4]]) f = report.figure(caption='Covariance and information matrix', cols=3) f.sub('covariance', 'should default to plot') f.sub('covariance/plot', 'Same as <-') f = report.figure('Tensors', cols=3) f.sub('Tx', display='posneg') f.sub('Ty', display='posneg') f.sub('Tz', display='posneg') self.node_serialization_ok(report)