コード例 #1
0
def plot_strides(
        report: Report,
        advancement_data: dict
):
    """

    :param report:
    :param advancement_data:
    :return:
    """

    keys = (
        (0, 'left_pes_strides'),
        (1, 'right_pes_strides'),
        (2, 'left_manus_strides'),
        (4, 'right_manus_strides')
    )

    traces = []
    layout = dict()

    for entry in keys:
        color_index = entry[0]
        key = entry[1]


        times = [e.time for e in advancement_data[key]]
        values = [e.value for e in advancement_data[key]]
        values, uncertainties = mstats.values.unzip(values)

        name = ' '.join(key.split('_')[:2]).capitalize()
        plot = plotting.make_line_data(
            times,
            values,
            uncertainties,
            name=name,
            color=plotting.get_color(color_index, 0.5, True),
            fill_color=plotting.get_color(color_index, 0.2, True)
        )
        traces.extend(plot['data'])
        layout.update(plot['layout'])

    report.add_plotly(
        data=traces,
        layout=plotting.create_layout(
            layout,
            'Stepping Distances',
            'Activity Cycle (#)',
            'Distance (m)'
        )
    )
コード例 #2
0
def plot_deviations(
        report: Report,
        coupling_data: dict
):
    """

    :param report:
    :param coupling_data:
    :return:
    """

    times = [e.time for e in coupling_data['lengths']]
    deviations = []
    for dev in coupling_data['deviations']:
        deviations.append(100.0 * dev)

    values, uncertainties = mstats.values.unzip(deviations)

    plot = plotting.make_line_data(
        times,
        values,
        uncertainties,
        name='Deviation',
        color=plotting.get_color(1, as_string=True)
    )

    report.add_plotly(
        data=plot['data'],
        layout=plotting.create_layout(
            plot['layout'],
            'Coupling Length Median Deviations',
            'Activity Cycle (#)',
            'Median Deviation (%)'
        )
    )
コード例 #3
0
def plot_advance(report: Report, coupling_data: dict):
    """

    :param report:
    :param coupling_data:
    :param times:
    :return:
    """

    traces = []

    sources = dict(
        rear_advance={
            'name': 'Rear',
            'index': 0
        },
        forward_advance={
            'name': 'Forward',
            'index': 1
        }
    )

    for key, data in sources.items():
        events = coupling_data[key]

        times = [e.time for e in events]
        values, uncertainties = mstats.values.unzip([e.value for e in events])

        plot = plotting.make_line_data(
            x=times,
            y=values,
            y_unc=uncertainties,
            name=data['name'],
            color=plotting.get_color(data['index'], 0.6, as_string=True),
            fill_color=plotting.get_color(data['index'], 0.2, as_string=True)
        )
        traces += plot['data']

    report.add_plotly(
        data=traces,
        layout=plotting.create_layout(
            title='Coupler Rate of Advancement',
            x_label='Activity Cycle (#)',
            y_label='Advance Rate (m/cycle)'
        )
    )
コード例 #4
0
ファイル: band.py プロジェクト: sernst/Trackway-Gait-Analysis
def coupling(trial):
    """
    :param trial:
    :return:
    """

    data = trial['couplings']['lengths']
    couplings = mstats.values.from_serialized([v['value'] for v in data])
    y, unc = mstats.values.unzip(couplings)
    gait_index = int(trial['id'][1])

    return plotting.make_line_data(
        x=[v['time'] for v in data],
        y=y,
        y_unc=unc,
        color=plotting.get_color(gait_index, 0.8, as_string=True),
        fill_color=plotting.get_color(gait_index, 0.3, as_string=True)
    )
コード例 #5
0
def add_header_section(
        report: reporting.Report,
        settings: dict,
        trials: typing.List[dict]
):
    trial_data = []
    for t in trials:
        color = plotting.get_color(t['index'] - 1, as_string=True)

        trial_data.append(dict(
            index=t['index'],
            id=t['id'],
            name=t['settings']['name'],
            summary=t['settings'].get('summary', ''),
            back_color=color
        ))

    report.add_template(
        path=paths.resource('group', 'header.html'),
        title=settings['name'],
        date=datetime.utcnow().strftime("%m-%d-%Y %H:%M"),
        summary=settings.get('summary'),
        trials=trial_data
    )
コード例 #6
0
def add_length_plot(report: Report, separation_data: dict, times:dict):
    """

    :param report:
    :param separation_data:
    :param times:
    :return:
    """

    sources = [
        dict(
            layout=plotting.create_layout(
                title='Left & Right Separations',
                x_label='Activity Cycle (#)',
                y_label='Separation (m)'
            ),
            items=[
                dict(
                    name='Left',
                    data=separation_data['left_lengths'],
                    index=2
                ),
                dict(
                    name='Right',
                    data=separation_data['right_lengths'],
                    index=4
                )
            ]
        ),

        dict(
            layout=plotting.create_layout(
                title='Forward & Rear Separations',
                x_label='Activity Cycle (#)',
                y_label='Separation (m)'
            ),
            items=[
                dict(
                    name='Forward',
                    data=separation_data['forward_lengths'],
                    index=1
                ),
                dict(
                    name='Rear',
                    data=separation_data['rear_lengths'],
                    index=0
                )
            ]
        )
    ]

    for source in sources:
        traces = []

        for item in source['items']:
            values, uncertainties = mstats.values.unzip(item['data'])
            color = plotting.get_color(item['index'], 0.7, as_string=True)
            fill = plotting.get_color(item['index'], 0.2, as_string=True)

            plot = plotting.make_line_data(
                x=times['cycles'],
                y=values,
                y_unc=uncertainties,
                name=item['name'],
                color=color,
                fill_color=fill
            )
            traces += plot['data']

        report.add_plotly(data=traces, layout=source['layout'])