Exemple #1
0
def compute_unweighted(
        tracks: pd.DataFrame,
        tolerance_fraction: float
) -> dict:
    """ """

    pes_tracks = tracks[tracks['pes'] == 1].copy()  # type: pd.DataFrame
    tolerance = 0.5 * tolerance_fraction * np.median(pes_tracks['width'].values)
    pes_tracks['tolerance'] = tolerance

    scatter_trace = plotting.create_scatter(
        pes_tracks['curvePosition'],
        pes_tracks['simpleGauge'],
        color='rgba(200, 200, 200, 1)',
        name='Gauges'
    )

    segments = forward_windowing.compute(
        pes_tracks['simpleGauge'].tolist(),
        pes_tracks['tolerance'].tolist(),
        weighted=False
    )

    segment_traces = [
        trace
        for s in segments
        for trace in plotting.make_segment_traces(pes_tracks, s)
    ]

    return dict(
        segments=segments,
        data=[scatter_trace] + segment_traces,
        layout=go.Layout(
            xaxis={'title': 'Trackway Position (m)'},
            yaxis={'title': 'Gauge (m)'}
        )
    )
import measurement_stats as mstats
import plotly.graph_objs as go
from _Gauge_Quantization import plotting

tracks = cd.shared.tracks  # type: pd.DataFrame
trackway_name = cd.shared.TRACKWAY_NAME
pes_tracks = tracks[tracks['pes'] == 1]

layout = go.Layout(
    title='{} Pes Gauge Values Along Trackway'.format(trackway_name),
    xaxis={'title': 'Trackway Position (m)'},
    yaxis={'title': 'Gauge (m)'},
)

scatter_trace = plotting.create_scatter(pes_tracks['curvePosition'],
                                        pes_tracks['simpleGauge'],
                                        name='Gauges')

median_value = np.median(pes_tracks['simpleGauge'].values)
median_absolute_deviation = np.median(
    [abs(gauge - median_value) for gauge in pes_tracks['simpleGauge']])
median = mstats.ValueUncertainty(median_value, median_absolute_deviation)

median_traces = plotting.make_ranged_quantity_traces(
    x_start=pes_tracks['curvePosition'].min(),
    x_end=pes_tracks['curvePosition'].max(),
    quantity=median,
    name='Median',
    legend_group='median')

cd.display.plotly(data=[scatter_trace] + median_traces, layout=layout)
Exemple #3
0
import plotly.graph_objs as go
from _Gauge_Quantization.windowing import forward as forward_windowing
from _Gauge_Quantization import plotting

tracks = cd.shared.tracks  # type: pd.DataFrame
trackway_name = cd.shared.TRACKWAY_NAME
pes_tracks = tracks[tracks['pes'] == 1]

layout = go.Layout(
    title='{} Pes Gauge Values Along Trackway'.format(trackway_name),
    xaxis={'title': 'Trackway Position (m)'},
    yaxis={'title': 'Gauge (m)'})

scatter_trace = plotting.create_scatter(pes_tracks['curvePosition'],
                                        pes_tracks['simpleGauge'],
                                        pes_tracks['simpleGaugeUnc'],
                                        color='rgba(200, 200, 200, 1)',
                                        name='Gauges')

segments = forward_windowing.compute(pes_tracks['simpleGauge'].tolist(),
                                     pes_tracks['simpleGaugeUnc'].tolist())
segment_traces = [
    trace for s in segments
    for trace in plotting.make_segment_traces(pes_tracks, s)
]

cd.display.markdown("""
    ## Segmentation with Uncertainties

    The first, and most crucial, change to make to the analysis is to introduce
    uncertainties into the clustering process. Their introduction allows us to
    We can now run the uncertainty-based clustering on this idealized trackway
    using both the forward and precision algorithms and compare:
    """
)

layout = go.Layout(
    title='Forward-Window Gauge Clustering',
    xaxis={'title': 'Trackway Position (m)'},
    yaxis={'title': 'Gauge (m)'}
)

scatter_trace = plotting.create_scatter(
    tracks['curvePosition'],
    tracks['simpleGauge'],
    tracks['simpleGaugeUnc'],
    color='rgba(200, 200, 200, 1)',
    name='Gauges'
)

forward_segments = forward_windowing.compute(
    tracks['simpleGauge'].tolist(),
    tracks['simpleGaugeUnc'].tolist()
)

cd.display.plotly(
    data=[scatter_trace] + [
        trace
        for s in forward_segments
        for trace in plotting.make_segment_traces(tracks, s)
    ],
    xaxis={'title': 'Trackway Position (m)'},
    yaxis={'title': 'Gauge (m)'}
)

dist = mstats.create_distribution(
    pes_tracks['simpleGauge'].tolist(),
    pes_tracks['simpleGaugeUnc'].tolist()
)
pop = mstats.distributions.population(dist)
median_value = mstats.distributions.percentile(pop)
mad = mstats.distributions.weighted_median_average_deviation(pop)
median = mstats.ValueUncertainty(median_value, mad)

scatter_trace = plotting.create_scatter(
    pes_tracks['curvePosition'],
    pes_tracks['simpleGauge'],
    pes_tracks['simpleGaugeUnc'],
    name='Gauges'
)

median_traces = plotting.make_ranged_quantity_traces(
    x_start=pes_tracks['curvePosition'].min(),
    x_end=pes_tracks['curvePosition'].max(),
    quantity=median,
    name='Median',
    legend_group='median'
)

cd.display.plotly(
    data=[scatter_trace] + median_traces,
    layout=layout
)