shinyHugePlot

Description

An interactive plot for data with a large sample size using shiny andplotly can be obtained. For an easy application, see shiny_hugeplot function. For a manual application, see downsampler class.

Author(s)

Maintainer: Junta Tagusari j.tagusari@eng.hokudai.ac.jp [copyright holder]

Other contributors:

• Jonas Van Der Donckt [copyright holder]

• Jeroen Van Der Donckt [copyright holder]

• Emiel Deprost [copyright holder]

Aggregation using Largest Triangle Three Buckets (LTTB) method.

Description

The LTTB method aggregates the huge samples using the areas of the triangles formed by the samples. Numerical distances are employed in this class, which requires the ratio between x and y values. When the x is datetime, nanosecond is a unit. When the x is factor or character, it will be encoded into numeric codes.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> LTTB_aggregator

Methods

Public methods

• LTTB_aggregator$new()

• LTTB_aggregator$clone()

Method new()

Constructor of the aggregator.

Usage

LTTB_aggregator$new(
  ...,
  nt_y_ratio = 1e+09,
  x_y_ratio = 1,
  interleave_gaps,
  coef_gap,
  NA_position
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

LTTB_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- LTTB_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(
  x = noise_fluct$time, y = noise_fluct$f500, n_out = 1000
  )
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

R6 base class for the aggregation

Description

A base class for the aggregation, which defines the structure of the class and is not available on a stand-alone basis.

Format

An R6::R6Class object

Active bindings

Methods

Public methods

• aggregator$new()

• aggregator$aggregate()

• aggregator$set_parameters()

• aggregator$clone()

Method new()

Constructor of aggregator

Usage

aggregator$new(
  ...,
  interleave_gaps = FALSE,
  NA_position = "begin",
  coef_gap = 3
)

Arguments

Method aggregate()

Aggregates the given input and returns samples.

Usage

aggregator$aggregate(x, y, n_out, db = NULL)

Arguments

Method set_parameters()

Setting of the parameters for the aggregation

Usage

aggregator$set_parameters(..., interleave_gaps, NA_position, coef_gap)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

aggregator$clone(deep = FALSE)

Arguments

Aggregation which returns the candle sticks

Description

This aggregator divides the data into no-overlapping intervals and calculate the first, maximum, minimum, and last values of the data, which represents candle sticks.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> candlestick_aggregator

Methods

Public methods

• candlestick_aggregator$new()

• candlestick_aggregator$clone()

Method new()

Constructor of the aggregator.

Usage

candlestick_aggregator$new(..., interleave_gaps, coef_gap, NA_position)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

candlestick_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- candlestick_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(nanotime::as.nanotime(noise_fluct$time), noise_fluct$f500, 100)
fig <- plotly::plot_ly(
  x = d_agg$x, open = d_agg$open, high = d_agg$high, low = d_agg$low, close = d_agg$close,
  type = "candlestick"
  )

Aggregation using a user-defined function.

Description

Arbitrary function can be applied using this aggregation class.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> custom_func_aggregator

Methods

Public methods

• custom_func_aggregator$new()

• custom_func_aggregator$set_aggregation_func()

• custom_func_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

custom_func_aggregator$new(
  ...,
  aggregation_func,
  interleave_gaps,
  coef_gap,
  NA_position
)

Arguments

Method set_aggregation_func()

Set a function to aggregate the data

Usage

custom_func_aggregator$set_aggregation_func(aggregation_func)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

custom_func_aggregator$clone(deep = FALSE)

Arguments

Examples

custom_agg_func <- function(x, y, n_out) {
  bin_width <- floor(length(x)/n_out)
  x_idx <- seq(floor(bin_width / 2), bin_width * n_out, bin_width)
  y_mat <- y[1:(bin_width * n_out)] %>%
    matrix(nrow = bin_width)
  y_agg <- apply(y_mat, 2, quantile, probs = 0.25)
  return(list(x = x[x_idx], y = y_agg))
}
data(noise_fluct)
agg <- custom_func_aggregator$new(
  aggregation_func = custom_agg_func, interleave_gaps = TRUE
  )
d_agg <- agg$aggregate(
  x = noise_fluct$time, y = noise_fluct$f500, n_out = 1000
  )
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

Aggregation which returns arbitrary statistics

Description

This aggregator divides the data into no-overlapping intervals and calculate specific statistical values such as the mean.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> custom_stat_aggregator

Methods

Public methods

• custom_stat_aggregator$new()

• custom_stat_aggregator$clone()

Method new()

Constructor of the Aggregator.

Constructor of the Aggregator.

Usage

custom_stat_aggregator$new(
  ...,
  y_func = mean,
  x_mean = TRUE,
  interleave_gaps,
  coef_gap,
  NA_position
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

custom_stat_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- custom_stat_aggregator$new(y_func = mean, interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500, 1000)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

R6 class for down-sampling data

Description

A class for down-sampling data with a large number of samples. An instance contains (the reference of) original data, layout of the figure, and options for aggregating the original data. An interactive plot for displaying large-sized data can be obtained using the figure, down-sampler and its options included in the instance, while making the plot using shiny_hugeplot function is easier (see examples). See the super class (plotly_datahandler) to find more members to handle the data in plotly.

Format

An R6::R6Class object

Super class

shinyHugePlot::plotly_datahandler -> downsampler

Active bindings

Methods

Public methods

• downsampler$new()

• downsampler$add_trace()

• downsampler$update_trace()

• downsampler$set_downsample_options()

• downsampler$clone()

Method new()

To construct an instance, original data, layout of the figure, and options for aggregating the original data are necessary. The original data and the layout of the figure can be given by providing a plotly object (figure argument). The options for aggregating the original data can be given by providing an aggregator (aggregator argument) and the number of samples (n_out argument). See the constructor of the plotly_datahandler class for more information on other arguments.

Usage

downsampler$new(
  figure = NULL,
  formula = NULL,
  srcs = NULL,
  srcs_ext = list(),
  n_out = 1000L,
  aggregator = min_max_aggregator$new(),
  tz = Sys.timezone(),
  use_light_build = TRUE,
  legend_options = list(name_prefix = "<b style=\"color:sandybrown\">[S]</b> ",
    name_suffix = "", xdiff_prefix = "<i style=\"color:#fc9944\"> ~", xdiff_suffix =
    "</i>"),
  verbose = F
)

Arguments

Method add_trace()

Add a new series to the data registered in the instance. If a data frame (traces_df argument) compliant with self$orig_data is given, it will be added to self$orig_data. If attributes to construct a plotly object (... argument) are given, a data frame is constructed and added. Options for aggregating data can be set using aggregator and n_out arguments. It is a wrapper of self$set_trace_data and self$set_downsample_options. See these methods for more information. Note that the traces of the figure are not updated with this method and self$update_trace is necessary.

Usage

downsampler$add_trace(..., traces_df = NULL, n_out = NULL, aggregator = NULL)

Arguments

Method update_trace()

Update traces of the figure registered in the instance (self$figure$x$data) according to re-layout order (relayout_order argument). Using reset and reload arguments, traces are updated without re-layout orders. It just registers the new traces and returns nothing by default. It returns the new traces if send_trace is TRUE.

Usage

downsampler$update_trace(
  relayout_order = list(NULL),
  reset = FALSE,
  reload = FALSE,
  send_trace = FALSE
)

Arguments

Method set_downsample_options()

In the instance, options for aggregating data are registered as data frame. (see self$downsample_options.) Using this method, the options can be set.

Usage

downsampler$set_downsample_options(uid = NULL, n_out = NULL, aggregator = NULL)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

downsampler$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)

# example 1 : Easy method using shiny_hugeplot
shiny_hugeplot(noise_fluct$time, noise_fluct$f500)

# example 2 : Manual method using a downsampler object
fig <- plot_ly(
  x = noise_fluct$time,
  y = noise_fluct$f500,
  type = "scatter",
  mode = "lines"
  ) %>%
  layout(xaxis = list(type = "date")) %>%
  shinyHugePlot::plotly_build_light()

ds <- downsampler$new(
  figure = fig,
  aggregator = min_max_aggregator$new(interleave_gaps = TRUE)
)

ui <- fluidPage(
  plotlyOutput(outputId = "hp", width = "800px", height = "600px")
)

server <- function(input, output, session) {

  output$hp <- renderPlotly(ds$figure)

  observeEvent(plotly::event_data("plotly_relayout"),{
    updatePlotlyH(session, "hp", plotly::event_data("plotly_relayout"), ds)
  })

}

shinyApp(ui = ui, server = server)


# example 3 : Add another series of which aggregator is different

noise_events <- tibble(
  time = c("2022-11-09 12:25:50", "2022-11-09 12:26:14"),
  level = c(60, 60)
)

ds$add_trace(
  x = noise_events$time, y = noise_events$level, name = "event",
  type = "scatter", mode = "markers",
  aggregator = null_aggregator$new()
)
ds$update_trace(reset = TRUE)

server <- function(input, output, session) {

  output$hp <- renderPlotly(ds$figure)

  observeEvent(plotly::event_data("plotly_relayout"),{
    updatePlotlyH(session, "hp", plotly::event_data("plotly_relayout"), ds)
  })

}

shinyApp(ui = ui, server = server)

Aggregation using local minimum and maximum values, and Largest Triangle Three Buckets (LTTB) method.

Description

Efficient version off LTTB by first reducing really large data with the min_max_ovlp_aggregator and then further aggregating the reduced result with LTTB_aggregator.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> eLTTB_aggregator

Public fields

Methods

Public methods

• eLTTB_aggregator$new()

• eLTTB_aggregator$clone()

Method new()

Constructor of the aggregator.

Usage

eLTTB_aggregator$new(..., interleave_gaps, coef_gap, NA_position)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

eLTTB_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- eLTTB_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500, 1000)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

Show the aggregation functions

Description

It displays all the aggregators registered in the package. No arguments are necessary.

Usage

list_aggregators()

Examples

list_aggregators()

Aggregation using local maximum (absolute) values.

Description

Divide the data into small data ranges and find the maximum (absolute) value of each. It may be useful for the waveform data.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> max_aggregator

Methods

Public methods

• max_aggregator$new()

• max_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

max_aggregator$new(..., interleave_gaps, coef_gap, NA_position, use_abs = TRUE)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

max_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- max_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500, 1000)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

Aggregation using local minimum and maximum values.

Description

Divide the data into small data ranges and find the maximum and minimum values of each. Note that many samples may be replaced with NA, if interleave_gaps = TRUE and the original data is increased or decreased monotonically. Use min_max_ovlp_aggregator instead in that case. n_out must be even number.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> min_max_aggregator

Methods

Public methods

• min_max_aggregator$new()

• min_max_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

min_max_aggregator$new(..., interleave_gaps, coef_gap, NA_position)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

min_max_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- min_max_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500, 1000)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

Aggregation using local minimum and maximum values of which small data ranges have 50% overlaps.

Description

Divide the data into 50% overlapping intervals and find the maximum and minimum values of each. n_out must be even number.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> min_max_ovlp_aggregator

Methods

Public methods

• min_max_ovlp_aggregator$new()

• min_max_ovlp_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

min_max_ovlp_aggregator$new(..., interleave_gaps, coef_gap, NA_position)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

min_max_ovlp_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- min_max_ovlp_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500, 1000)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

Time-series fluctuations in sound level

Description

Results of the measurement of the sound level, where peaks due to road traffic are observed.

Usage

noise_fluct

Format

A data frame with 32,001 rows and 4 columns:

time

time

f500, f1000, f2000

Octave-band sound levels whose center frequencies are 500, 1000 and 2000 Hz.

Author(s)

Junta Tagusari j.tagusari@eng.hokudai.ac.jp

Aggregation which returns every Nth point.

Description

Aggregation by extracting every Nth data.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> nth_pnt_aggregator

Methods

Public methods

• nth_pnt_aggregator$new()

• nth_pnt_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

nth_pnt_aggregator$new(..., interleave_gaps, coef_gap, NA_position)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

nth_pnt_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- nth_pnt_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500, 1000)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines")

NULL aggregator.

Description

It does not aggregate the data but returns the full samples within the range.

Format

An R6::R6Class object

Super class

shinyHugePlot::aggregator -> null_aggregator

Methods

Public methods

• null_aggregator$new()

• null_aggregator$aggregate()

• null_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

null_aggregator$new(..., interleave_gaps, coef_gap, NA_position)

Arguments

Method aggregate()

A function that does nothing other than inserting NAs.

Usage

null_aggregator$aggregate(...)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

null_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- null_aggregator$new(interleave_gaps = TRUE)
d_agg <- agg$aggregate(noise_fluct$time, noise_fluct$f500)
plotly::plot_ly(
  x = d_agg$x[1:100], y = d_agg$y[1:100], type = "scatter", mode = "lines"
)

Build plotly data with low computation cost

Description

Before illustrating data using plotly, it must be built (figure$x$data are need to be made using figure$x$attrs). However, because a lot of procedures are necessary, the computation cost is relatively high. With this function, the data is built in quite short time by omitting several procedures for high-frequency data. Note that this function is not universally applicable to all plotly objects but made for high-frequency scatter data. plotly::plotly_build function may return better results in specific cases although it takes more time.

Usage

plotly_build_light(fig, vars_hf = c("x", "y", "text", "hovertext"))

Arguments

Value

built plotly object

Examples

data(noise_fluct)
plotly_build_light(
  plotly::plot_ly(
    x = noise_fluct$time,
    y = noise_fluct$f500,
    name = "level",
    type = "scatter"
  )
)

plotly_build_light(
  plotly::plot_ly(
    data = noise_fluct,
    x = ~time,
    y = ~f500,
    name = "level",
    type = "scatter"
  )
)

R6 class for handling plotly data

Description

A class for handling plotly data, which defines functions used in the downsampler class

Format

An R6::R6Class object

Public fields

Active bindings

Methods

Public methods

• plotly_datahandler$new()

• plotly_datahandler$set_trace_data()

• plotly_datahandler$srcs_to_df()

• plotly_datahandler$plotly_data_to_df()

• plotly_datahandler$clone()

Method new()

Constructing an instance. The data contained in a plotly object (figure argument) will be included in the instance (as a reference).

Usage

plotly_datahandler$new(
  figure = NULL,
  srcs = NULL,
  formula = NULL,
  srcs_ext = NULL,
  legend_options = list(name_prefix = "<b style=\"color:sandybrown\">[S]</b> ",
    name_suffix = "", xdiff_prefix = "<i style=\"color:#fc9944\"> ~", xdiff_suffix =
    "</i>"),
  tz = Sys.timezone(),
  use_light_build = TRUE
)

Arguments

Method set_trace_data()

In the instance, data is contained as a data frame (see self$orig_data for detailed information). Using this method, the data can be added or overwritten. If a data frame (traces_df argument) is given, it will be added to self$orig_data or reassigned as self$orig_data. If attributes to construct a plotly object (... argument) are given, a data frame is constructed and used.

Usage

plotly_datahandler$set_trace_data(..., traces_df = NULL, append = FALSE)

Arguments

Method srcs_to_df()

Covert the data contained in srcs file(s) to a duck-db. A minimum data and the path of the database will be returned.

Usage

plotly_datahandler$srcs_to_df(fml, srcs, srcs_ext = NULL)

Arguments

Method plotly_data_to_df()

Covert the data contained in plotly object to a data frame. A unique id (uid) is granted to each data. The data frame will be returned.

Usage

plotly_datahandler$plotly_data_to_df(plotly_data, use_datatable = TRUE)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

plotly_datahandler$clone(deep = FALSE)

Arguments

Aggregation which returns the ranges and nominal values within small data ranges

Description

This aggregator divides the data into no-overlapping intervals and calculate specific statistics that represents the range and nominal values of the data, such as the max, min and mean.

Format

An R6::R6Class object

Super classes

shinyHugePlot::aggregator -> shinyHugePlot::rng_aggregator -> range_stat_aggregator

Methods

Public methods

• range_stat_aggregator$new()

• range_stat_aggregator$clone()

Method new()

Constructor of the aggregator.

Usage

range_stat_aggregator$new(
  ...,
  ylwr = min,
  y = mean,
  yupr = max,
  interleave_gaps,
  coef_gap,
  NA_position
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

range_stat_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- range_stat_aggregator$new(
  ylwr = min, y = mean, yupr = max, interleave_gaps = TRUE
)
d_agg <- agg$aggregate(nanotime::as.nanotime(noise_fluct$time), noise_fluct$f500, 100)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines") %>%
  plotly::add_trace(x = d_agg$x, y = d_agg$ylwr, type = "scatter", mode = "lines")%>%
  plotly::add_trace(x = d_agg$x, y = d_agg$yupr, type = "scatter", mode = "lines")

Aggregation which returns the rms and maximum values within small data ranges

Description

This aggregator divides the data into no-overlapping intervals and calculate the root-mean-square and the maximum absolute values of the data, which may be helpful to understand the waveforms.

Format

An R6::R6Class object

Super classes

shinyHugePlot::aggregator -> shinyHugePlot::rng_aggregator -> rms_max_aggregator

Methods

Public methods

• rms_max_aggregator$new()

• rms_max_aggregator$clone()

Method new()

Constructor of the aggregator.

Usage

rms_max_aggregator$new(
  ...,
  interleave_gaps,
  coef_gap,
  NA_position,
  use_abs = TRUE
)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

rms_max_aggregator$clone(deep = FALSE)

Arguments

Examples

data(noise_fluct)
agg <- rms_max_aggregator$new(
  ylwr = min, y = mean, yupr = max, interleave_gaps = TRUE
)
d_agg <- agg$aggregate(nanotime::as.nanotime(noise_fluct$time), noise_fluct$f500, 100)
plotly::plot_ly(x = d_agg$x, y = d_agg$y, type = "scatter", mode = "lines") %>%
  plotly::add_trace(x = d_agg$x, y = d_agg$ylwr, type = "scatter", mode = "lines")%>%
  plotly::add_trace(x = d_agg$x, y = d_agg$yupr, type = "scatter", mode = "lines")

Aggregation that returns ranges of the data.

Description

A super class for describing aggregator that returns x, y, ylwr and yupr values based on given x and y data.

Format

An R6::R6Class object

Value

List of which elements represent the ranges. If there are no NAs, the length of the list is 1; multiple lists are obtained if there are NAs. Each element of list has x and y values that surround the range of values.

Super class

shinyHugePlot::aggregator -> rng_aggregator

Methods

Public methods

• rng_aggregator$new()

• rng_aggregator$as_plotly_range()

• rng_aggregator$as_range()

• rng_aggregator$clone()

Method new()

Constructor of the Aggregator.

Usage

rng_aggregator$new(interleave_gaps, coef_gap, NA_position, ...)

Arguments

Method as_plotly_range()

Compute a plotly trace to illustrate the range of the data.

Usage

rng_aggregator$as_plotly_range(x, y, ylwr, yupr, opacity = 0.5)

Arguments

Method as_range()

Compute x, ylwr and yupr from a plotly trace made by self$as_plotly_range.

Usage

rng_aggregator$as_range(prng)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

rng_aggregator$clone(deep = FALSE)

Arguments

Wrapper for plotting large-sized data using shinyHugePlot

Description

This is a S3 class function to easily plot large-sized data using downsampler object including plotly and shiny application. Using data that is given as a first argument, shiny application will be constructed and (by default,) executed. As the first argument, many classes are applicable, ranging from a numeric vector representing y values to a downsampler object containing original data, layout of the figure and options for aggregating the original data.

Usage

shiny_hugeplot(obj, ...)

## Default S3 method:
shiny_hugeplot(
  obj = NULL,
  y = NULL,
  tz = Sys.timezone(),
  use_light_build = TRUE,
  plotly_options = list(type = "scatter", mode = "lines"),
  plotly_layout_options = list(),
  aggregator = min_max_aggregator$new(),
  n_out = 1000L,
  run_shiny = TRUE,
  downsampler_options = list(),
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

## S3 method for class 'formula'
shiny_hugeplot(
  obj = NULL,
  srcs = NULL,
  n_out = 1000L,
  aggregator = min_max_aggregator$new(),
  run_shiny = TRUE,
  use_light_build = TRUE,
  fread_options = list(),
  downsampler_options = list(),
  plotly_options = list(type = "scatter", mode = "lines"),
  plotly_layout_options = list(),
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

## S3 method for class 'character'
shiny_hugeplot(
  obj = NULL,
  n_out = 1000L,
  aggregator = min_max_aggregator$new(),
  run_shiny = TRUE,
  use_light_build = TRUE,
  fread_options = list(),
  downsampler_options = list(),
  plotly_options = list(type = "scatter", mode = "lines"),
  plotly_layout_options = list(),
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

## S3 method for class 'matrix'
shiny_hugeplot(
  obj = NULL,
  n_out = 1000L,
  aggregator = min_max_aggregator$new(),
  run_shiny = TRUE,
  use_light_build = TRUE,
  downsampler_options = list(),
  plotly_options = list(type = "scatter", mode = "lines"),
  plotly_layout_options = list(),
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

## S3 method for class 'data.frame'
shiny_hugeplot(
  obj = NULL,
  tz = Sys.timezone(),
  n_out = 1000L,
  aggregator = min_max_aggregator$new(),
  run_shiny = TRUE,
  use_light_build = TRUE,
  downsampler_options = list(),
  plotly_options = list(type = "scatter", mode = "lines"),
  plotly_layout_options = list(),
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

## S3 method for class 'plotly'
shiny_hugeplot(
  obj,
  n_out = 1000L,
  aggregator = min_max_aggregator$new(),
  run_shiny = TRUE,
  use_light_build = TRUE,
  downsampler_options = list(),
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

## S3 method for class 'downsampler'
shiny_hugeplot(
  obj,
  run_shiny = TRUE,
  shiny_options = list(),
  width = "100%",
  height = "600px",
  verbose = FALSE,
  ...
)

Arguments

Examples

data(noise_fluct)

shiny_hugeplot(noise_fluct$f500)
shiny_hugeplot(noise_fluct$time, noise_fluct$f500)

Function to call a method to update plotly traces

Description

It is used by registering in a shiny application. It receives events in plotly figure and update it using a method of a downsampler instance. See the examples in downsampler class.

Usage

updatePlotlyH(
  session,
  outputId,
  relayout_order,
  ds_obj,
  reset = FALSE,
  reload = FALSE,
  verbose = FALSE
)

Arguments