Python Report.add_child方法代码示例

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def create_report(subsets):
    report = Report('tammero_analysis')
    for id, desc, saccades in subsets:
        # XXX temporary
        report.add_child(create_report_subset(id, desc, saccades))
        report.add_child(create_report_randomness(id, desc, saccades))
    return report

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def report_distances2_global(combs, explogs_test, arrows, interps):
    r = Report()
    figs = {}
    
    def get_fig(id_robot):
        if not id_robot in figs:
            figs[id_robot] = r.figure(cols=len(explogs_test), caption=id_robot)
        return figs[id_robot]
    
    for id_robot, id_agent in combs:

        for id_episode in map(str, explogs_test):
            key = dict(id_robot=id_robot, id_agent=id_agent, id_episode=id_episode)
            interp = interps[key]
            interp.nid = basename_from_key(key) + '-interp'
            interp.caption = '%s, %s' % (id_robot, id_agent)
            r.add_child(interp)
            get_fig(id_robot).sub(interp)

        for id_episode in map(str, explogs_test):
            key = dict(id_robot=id_robot, id_agent=id_agent, id_episode=id_episode)
            arrow = arrows[key]
            arrow.nid = basename_from_key(key) + '-vf'
            arrow.caption = '%s, %s' % (id_robot, id_agent)
            r.add_child(arrow)
            get_fig(id_robot).sub(arrow)

    return r

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def report_traj(confid, flydra_db_directory, db_group, version):
    with safe_flydra_db_open(flydra_db_directory) as db:
        
        r = Report('%s_traj' % confid)
        samples = db.list_samples_for_group(db_group)
        
        for i, sample in enumerate(samples):
            print(i, sample)
            with db.safe_get_table(sample, table='rows',
                                   version=version) as rows:
                ri = report_traj_sample(sample, np.array(rows[:]))
                r.add_child(ri) 
             
        return r

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def create_report(outdir, combination_id, saccades):
    r = Report(combination_id)
    
    stats = 'Combination %r has %d saccades' % (combination_id, len(saccades))
    r.text('stats', stats)
    
    desc = ""
    #r.add_child(create_report_subset(combination_id,desc, saccades))
    #r.add_child(create_report_randomness(combination_id, desc, saccades))
    r.add_child(create_report_axis_angle(combination_id, desc, saccades))

    
    rd = os.path.join(outdir, 'images')
    out = os.path.join(outdir, 'combinations', '%s.html' % combination_id)
    print('Writing to %r' % out)
    r.to_html(out, resources_dir=rd)

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def report_servo1_global(combs, explogs_test, parts):
    r = Report()
    figs = {}
    
    def get_fig(id_robot):
        if not id_robot in figs:
            figs[id_robot] = r.figure(cols=len(explogs_test), caption=id_robot)
        return figs[id_robot]
    
    for id_robot, id_agent in combs:
        for id_episode in map(str, explogs_test):
            key = dict(id_robot=id_robot, id_agent=id_agent, id_episode=id_episode)
            part = parts[key]
            part.nid = basename_from_key(key)
            part.caption = '%s, %s' % (id_robot, id_agent)
            r.add_child(part)
            get_fig(id_robot).sub(part)

    return r

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def main():
    parser = OptionParser()

    parser.add_option("--file", help='Pickle file')
    parser.add_option("--outdir")

    (options, args) = parser.parse_args() #@UnusedVariable
    assert not args
    

    data = pickle.load(open(options.file, 'rb'))
    
    select = range(181)
    
    for x in ['y_cov', 'y_dot_cov', 'y_dot_sign_cov']:
        data[x] = data[x][select, :][:, select]
        check('array[NxN]', data[x])
    
    n = data['y_cov'].shape[0]
    #theta = numpy.linspace(0, numpy.pi * 2, n)
    theta = numpy.linspace(0, numpy.pi, n)    
    
    d = OpenStruct(**data) 
    
    # groundtruth 
    d.theta = theta
    d.S = create_s_from_theta(d.theta)
    d.C = get_cosine_matrix_from_s(d.S)
    d.D = get_distance_matrix_from_cosine(d.C)

    r = Report('calibrator_analysis')
    
    #r.add_child(simple_plots(d))
    #r.add_child(ground_truth_plots(d))
    #r.add_child(hist_plots(d))
    r.add_child(iterations_plots(d))
    
    filename = os.path.join(options.outdir, 'calib_1d_stats_plots.html')
    print("Writing to %r" % filename)
    r.to_html(filename)

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def main():    
    parser = OptionParser()
    
    parser.add_option("--outdir",
                  type="string", help='Directory containing data')

    (options, args) = parser.parse_args() #@UnusedVariable
    assert not args
    
    variables = os.path.join(options.outdir, 'results.pickle.part')
    
    data = pickle.load(open(variables, 'rb'))
    
    d = OpenStruct(**data)
    d.P_inv = get_information_matrix(d.P)
    d.Gn = normalize_G(d.G, d.P_inv)
    d.Q_inv = numpy.linalg.pinv(d.Q)
    d.Gnn = normalize_input(d.Gn, d.Q_inv)

    r = Report('boot')    
    r.add_child(cov_plots(d))
    r.add_child(basic_plots(d))
    
    dir = os.path.join(options.outdir, 'plots')
    filename = os.path.join(dir, 'index.html')
    print("Writing report to %r." % filename)
    r.to_html(filename, resources_dir=dir)

    data = {
            'Gnn': d.Gnn,
            'Gn': d.Gn,
            'G': d.G,
            'Q': d.Q,
            'Q_inv': d.Q_inv,
            'P_inv': d.P_inv
        }
    filename = os.path.join(options.outdir, 'tensors.pickle')
    print("Writing tensors to %r." % filename)
    with open(filename, 'wb') as f:
        pickle.dump(data, f)

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def main():    
    parser = OptionParser()
    
    parser.add_option("--outdir",
                  type="string", help='Directory containing data')

    (options, args) = parser.parse_args() #@UnusedVariable
    assert not args
    
    variables = os.path.join(options.outdir, 'variables.pickle.part')
    
    data = pickle.load(open(variables, 'rb'))
    
    d = OpenStruct(**data)
    d.R = d.correlation
    d.num_ref, d.num_sensels = d.R.shape
    assert d.num_ref <= d.num_sensels
    d.imshape = (100, 100) # XXX
    d.toimg = lambda x : x.reshape(d.imshape)
    
    r = Report('calibrator_analysis')
    
    r.add_child(new_analysis(data))
    r.add_child(correlation_embedding_report(R=data['correlation'], num_eig=6)) 
    r.add_child(show_some_correlations(d, num=20))
    
    filename = os.path.join(options.outdir, 'supersensels.html')
    print("Writing to %r" % filename)
    r.to_html(filename)

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def combine_reports(subs, descs, page_id, output_dir):
    if len(subs) == 0:
        raise Exception("Nothing to combine for %r." % page_id)
    r = Report(page_id)
    # FIXME: compmake should throw here
    # comp(combine_reports, subs, page_id)

    # look if we have a description
    if "description" in subs[0].childid2node:
        description = subs[0].childid2node["description"]
        r.add_child(description)

    for example_node in subs[0].children:
        plot_id = example_node.id
        if plot_id == "description":
            continue

        if isinstance(example_node, Table):

            for i, sub in enumerate(subs):
                node = sub.childid2node[plot_id]
                node.id = None
                node.caption = descs[i]
                r.add_child(node)

        else:  # images -> use figures

            f = r.figure(example_node.id, cols=4)
            for i, sub in enumerate(subs):
                node = sub.childid2node[plot_id]
                node.id = None
                r.add_child(node)
                f.sub(node.id, caption=descs[i])

    resources_dir = os.path.join(output_dir, "images")
    filename = os.path.join(output_dir, "%s.html" % page_id)
    print ("Writing to %r." % filename)
    r.to_html(filename, resources_dir, extra_css=extra_css)

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]
def iterations_plots(d):
    
    r = Report('algorithmic_results')
    
    
    # dummy = d.C ** 5  # -- perfect!
    dummy = numpy.maximum(0, d.C ** 7)
    results = cbc(dummy, num_iterations=5, ground_truth=d)
    r.add_child(plot_results('dummy', results))

#    
    y_corr = cov2corr(d.y_cov, False)
    results = cbc(y_corr, num_iterations=5, ground_truth=d)
    r.add_child(plot_results('y_corr', results))
#    
#    y_dot_corr = cov2corr(d.y_dot_cov, False)
#    results = cbc(y_dot_corr, num_iterations=5, ground_truth=d)
#    r.add_child(plot_results('y_dot_corr', results))
    
    y_dot_sign_corr = cov2corr(d.y_dot_sign_cov, False)
    results = cbc(y_dot_sign_corr, num_iterations=5, ground_truth=d)
    r.add_child(plot_results('y_dot_sign_corr', results))
    
    return r

# 需要导入模块: from reprep import Report [as 别名]
# 或者: from reprep.Report import add_child [as 别名]

#.........这里部分代码省略.........
                      help="Outer interval [= %default]")
    parser.add_option("--min_amplitude_deg", default=25, type='float',
                      help="Minimum saccade amplitude (deg) [= %default]")
    parser.add_option("--min_linear_velocity", default=0.1, type='float',
                      help="Minimum linear velocity when"
                      " saccading (m/s) [= %default]")
    parser.add_option("--max_linear_acceleration", default=20, type='float',
                      help="Maximum linear acceleration when saccading "
                      "(m/s^2) [= %default]")
    parser.add_option("--max_angular_velocity", default=8000, type='float',
                      help="Maximum angular velocity when saccading"
                      " (deg/s) [= %default]")
    parser.add_option("--max_orientation_dispersion_deg", default=15,
                      type='float',
                      help="Maximum dispersion (deg) [= %default]")
    parser.add_option("--minimum_interval_sec", default=10 * dt, type='float',
                      help="Minimum interval between saccades. [= %default]")
    
    (options, args) = parser.parse_args(argv)
    
    if not options.db:
        raise Exception('No flydra DB directory  specified.')
    
    if args:
        raise Exception('Spurious arguments')
    
    # Create processed string
    processed = get_computed_string('angvel_saccade_detector', __version__)
        
    rows_table_name = NamingConventions.ROWS_TABLE
    rows_table_version = options.version
    saccades_table_name = NamingConventions.SACCADES_TABLE
    # annotations_table_name = 'annotated'
    saccades_table_version = options.saccades_table_version

    with safe_flydra_db_open(options.db) as db:
        samples = db.list_samples()

        for i, sample in enumerate(samples):
           
            already_has = db.has_table(sample, saccades_table_name,
                                       saccades_table_version)
                
            if options.nocache and already_has:
                msg = ('Sample %r already has table %s:%s; skipping.' % 
                       (sample, saccades_table_name, saccades_table_version))
                logger.info(msg)
                continue
            
            if not db.has_table(sample, rows_table_name, rows_table_version):
                msg = ('Sample %r does not have table %s:%s.' % 
                       (sample, rows_table_name, rows_table_version))
                raise Exception(msg)
            
            with db.safe_get_table(sample, rows_table_name,
                                   rows_table_version) as rows:
                 
                rows = np.array(rows[:])
                params = {}
#                saccades, annotated 
                data = angvel_saccade_detect(rows, **params)
                saccades = data['saccades'] 
                
                for saccade in saccades:
                    check_saccade_is_well_formed(saccade)
        
                DT = rows['timestamp'][-1] - rows['timestamp'][0]  
                logger.info("%4d/%d %s: %6d saccades for %6d rows (%6g saccades/s)" % 
                    (i, len(samples), sample,
                     len(saccades), len(rows), DT / len(saccades))) 
       
                if True:
                    db.set_table(sample=sample,
                                 table=saccades_table_name,
                                 data=saccades,
                                 version=saccades_table_version)
                     
                    db.set_attr(sample,
                                'saccades_%s_processed' % saccades_table_version,
                                processed)
                
                if options.out is not None:
                    outdir = os.path.join(options.out, 'angvel_sac_detect')
                    if not os.path.exists(outdir):
                        os.makedirs(outdir)
                    resources = os.path.join(outdir, 'images')
                    filename = os.path.join(outdir, '%s.html' % sample)
                 
                    r = Report()
                    
                    chunks = enumerate_chunks(len(rows), max_chunk_size=300)
                    for i, select in enumerate(chunks):
                        rows_i = rows[select]
                    
                        ri = plot_angvel_saccade_detect_results(rows_i)
                        ri.nid = 'chunk_%s' % i
                        r.add_child(ri)
                    
                    logger.info('Writing to %r.' % filename)
                    r.to_html(filename, resources_dir=resources)