Title:	Flexible, Interactive 'shiny' Modules for Almost Any Plot
Version:	0.1.1
Description:	Offers a core selection of interactivity-first 'shiny' modules for many plot types meant to serve as flexible building blocks for applications and as the base for more complex modules. These modules allow for the rapid and convenient construction of 'shiny' apps with very few lines of code and decouple plotting from the underlying data. These modules allow for full plot aesthetic customization by the end user through UI inputs. Utility functions for simple UI organization, automated UI tooltips, and additional plot enhancements are also provided.
License:	MIT + file LICENSE
Depends:	shiny, dittoViz, plotly, R (≥ 4.5), shinyBS, plotthis (≥ 0.11.0)
Imports:	roclang, colourpicker, dplyr, DT, readxl, shinyjs, scales, shinyjqui, ggplot2, htmltools, jsonlite, methods, shinyWidgets, htmlwidgets
Encoding:	UTF-8
LazyData:	true
RoxygenNote:	7.3.3
Suggests:	knitr, rmarkdown, shinytest2, testthat (≥ 3.0.0)
VignetteBuilder:	knitr
Config/testthat/edition:	3
URL:	https://j-andrews7.github.io/VizModules/, https://github.com/j-andrews7/VizModules
NeedsCompilation:	no
Packaged:	2026-04-01 15:57:59 UTC; jandrews
Author:	Jared Andrews [aut, cre], Jacob Martin [aut]
Maintainer:	Jared Andrews <jared.andrews07@gmail.com>
Repository:	CRAN
Date/Publication:	2026-04-08 19:00:02 UTC

Null-or-empty coalescing operator

Description

Returns the left-hand side unless it is NULL or has length zero, in which case the right-hand side is returned.

Usage

x %__% y

Arguments

Value

x when present, otherwise y.

Author(s)

Jared Andrews

Build diagonal (abline) line shapes for a plotly figure

Description

Creates shape specifications for one or more diagonal lines defined by slope and intercept. Lines are drawn across the provided or computed axis range.

Usage

.add_ablines(
  fig,
  slopes,
  intercepts,
  colors = "#000000",
  widths = 1,
  linetypes = "solid",
  opacities = 1
)

Arguments

Details

If style vector lengths don't match the number of lines, only the first value of each style vector is used for all lines. If slopes and intercepts have different lengths, the shorter one is recycled. When the figure contains subplots (e.g., from faceting), lines are replicated across all panels with correct axis references.

Value

A list of shape specifications for use with plotly::layout().

Author(s)

Jared Andrews

Add fit line traces to all subplot panels

Description

Adds linear or LOESS fit line traces to a plotly figure, handling subplot panels when faceting is applied. Determines subplot axes from existing traces and adds fit lines to each panel.

Usage

.add_fit_lines_to_subplots(
  fig,
  df,
  x.col,
  y.col,
  split.by = NULL,
  group.col = NULL,
  color_mapping = NULL,
  line_color = "#000000",
  fit_type = c("linear", "loess"),
  span = 0.75,
  line_width = 3
)

Arguments

Value

The modified plotly figure with fit lines added to all subplot panels.

Author(s)

Jared Andrews

Build horizontal line shapes for a plotly figure

Description

Creates shape specifications for one or more horizontal lines at specified y-intercepts. Supports independent styling for each line.

Usage

.add_hlines(
  fig,
  intercepts,
  colors = "#000000",
  widths = 1,
  linetypes = "solid",
  opacities = 1
)

Arguments

Details

If style vector lengths don't match the number of intercepts, only the first value of each style vector is used for all lines. When the figure contains subplots (e.g., from faceting), lines are replicated across all panels with correct axis references.

Value

A list of shape specifications for use with plotly::layout().

Author(s)

Jared Andrews

Add multi-axis traces to a plotly figure

Description

Appends scatter traces for each element of a multi-valued x or multi-valued y vector to an existing plotly figure. Handles data ordering, line/marker styling, and palette colouring.

Usage

.add_multi_axis_traces(
  fig,
  data,
  x,
  y,
  order.cols,
  plot.mode,
  line.type,
  palette.selection,
  show.legend = TRUE
)

Arguments

Value

The modified plotly figure with added traces.

Author(s)

Jared Andrews

Create default Plotly configuration

Description

Constructs a configuration list for Plotly plots, enabling interactive editing of titles and legends, export options, and additional drawing tools in the modebar.

Usage

.add_plot_config(
  download.format = "png",
  filename = as.character(Sys.Date()),
  include.modebar.buttons = TRUE,
  facet.by = NULL
)

Arguments

Details

The configuration enables interactive editing of axis titles, plot title, legend text and position, colorbar position and title, and annotation tails. It also adds drawing tools (lines, paths, circles, rectangles, and an eraser) to the modebar.

Value

A named list suitable for use as the config argument in Plotly calls, containing edit options, image download settings, extra modebar buttons, and logo display preferences.

Author(s)

Jacob Martin

Add reference lines to a plotly figure from Shiny inputs

Description

Convenience wrapper that adds horizontal, vertical, and/or diagonal lines to a plotly figure based on parsed Shiny input values.

Usage

.add_reference_lines(
  fig,
  hline.intercepts = NULL,
  hline.colors = NULL,
  hline.widths = NULL,
  hline.linetypes = NULL,
  hline.opacities = NULL,
  vline.intercepts = NULL,
  vline.colors = NULL,
  vline.widths = NULL,
  vline.linetypes = NULL,
  vline.opacities = NULL,
  abline.slopes = NULL,
  abline.intercepts = NULL,
  abline.colors = NULL,
  abline.widths = NULL,
  abline.linetypes = NULL,
  abline.opacities = NULL
)

Arguments

Value

The modified plotly figure with all specified lines added.

Author(s)

Jared Andrews

Build vertical line shapes for a plotly figure

Description

Creates shape specifications for one or more vertical lines at specified x-intercepts. Supports independent styling for each line.

Usage

.add_vlines(
  fig,
  intercepts,
  colors = "#000000",
  widths = 1,
  linetypes = "solid",
  opacities = 1
)

Arguments

Details

If style vector lengths don't match the number of intercepts, only the first value of each style vector is used for all lines. When the figure contains subplots (e.g., from faceting), lines are replicated across all panels with correct axis references.

Value

A list of shape specifications for use with plotly::layout().

Author(s)

Jared Andrews

Apply axis title font styling to shared facet axis annotations

Description

When ggplotly converts a faceted ggplot, shared axis titles become annotations rather than axis title properties. This function finds those shared title annotations and applies the user's axis title font settings to them.

Usage

.apply_axis_title_to_annotations(fig, input, isolate_fn = isolate)

Arguments

Value

The modified plotly figure with updated annotation fonts.

Author(s)

Jacob Martin

Apply Plotly newshape styling from uniform Plotly inputs

Description

Applies user-drawn shape styling to a Plotly figure using inputs from .uniform_plotly_inputs_ui(). Updates the newshape layout property to style shapes drawn with Plotly's drawing tools (rectangles, circles, lines, etc.) in the modebar.

Usage

.apply_plotly_newshape(fig, input, isolate_fn = isolate)

Arguments

Value

The modified plotly figure with updated newshape layout settings.

Author(s)

Jared Andrews

Apply statistical annotation shapes and annotations to a plotly figure

Description

Appends the shapes and annotations from .create_stat_annotations() to an existing plotly figure's layout. Adjusts the y-axis range to accommodate the annotation brackets.

Usage

.apply_stat_annotations(fig, stat_result, y.min = NULL)

Arguments

Value

The modified plotly figure.

Author(s)

Jared Andrews

Apply axis styling to all subplot axes in a plotly figure

Description

When using plotly subplots (e.g., via split.by in dittoViz), axis styling must be applied to all subplot axes (xaxis, xaxis2, xaxis3, etc.) individually. This helper function detects how many subplots exist and applies the provided axis styling to all of them.

Usage

.apply_subplot_axis_styling(fig, xaxis_style, yaxis_style)

Arguments

Value

The modified plotly figure with axis styling applied to all subplots.

Author(s)

Jared Andrews

Build facet subplot annotations

Description

Creates a list of plotly annotation objects suitable for labelling faceted subplots arranged in a single row. Optionally appends a shared X-axis title (bottom centre) and a shared, rotated Y-axis title (left centre).

Usage

.build_facet_annotations(
  facet_levels,
  x.title = NULL,
  y.title = NULL,
  title.font.size = 14
)

Arguments

Value

A list of annotation lists suitable for plotly::layout(annotations = ...).

Author(s)

Jared Andrews

Build palette select options

Description

Creates option and optgroup tags used by the palette selector input.

Usage

.build_palette_options(palette_source, selected_palette)

Arguments

Value

A tagList containing the option/optgroup elements.

Author(s)

Jared Andrews

Build trace-to-annotation mapping

Description

Creates a mapping between trace data and annotation values by parsing trace hover text. This is used for robust point matching when creating annotations.

Usage

.build_trace_anno_map(trace, annotate.by)

Arguments

Value

A data frame with columns:

• coord_id: Unique coordinate identifier string

• anno_value: Extracted annotation value Returns NULL if trace has no valid data.

Author(s)

Jared Andrews

Calculate axis range from data

Description

Computes a numeric range for the Y-axis based on specified columns in a data frame, applying a scaling factor to the maximum value. Handles both simple (non-stacked) and stacked bar scenarios, where stacking occurs when group.by or fill.by is numeric.

Usage

.calculate_range(
  df,
  data_col_x = NULL,
  data_col_y = NULL,
  axis_scale_factor,
  grouping = FALSE,
  stack_by = NULL
)

Arguments

Details

The function resolves the primary data column from data_col_y or data_col_x and validates that it exists and is numeric in df.

Behaviour depends on whether bars are stacked:

• Non-stacked (grouping = FALSE, categorical or absent stack_by): the Y range is computed directly from the raw column values using min() and max().

• Stacked (grouping = TRUE or stack_by is numeric): Y values are summed within each unique X category using tapply(), and the maximum of those sums is used. The minimum is fixed at 0 since stacked bars always originate from zero.

Non-finite results (e.g. from empty or all-NA columns) are replaced with default values of 0 for the minimum and 1 for the maximum.

Value

A named list with components min and max giving the lower and upper limits for the Y-axis, or NULL if any required column is missing, non-numeric, or otherwise invalid.

Author(s)

Jacob Martin

Compute linear regression fit line data

Description

Computes predicted values from a linear model for plotting a fit line. Can optionally compute separate fit lines for each group in a grouping variable.

Usage

.compute_linear_fit(df, x.col, y.col, group.col = NULL, n.points = 100)

Arguments

Value

If group.col is NULL, a data frame with columns x and y. If group.col is provided, a named list of data frames (one per group).

Author(s)

Jared Andrews

Compute LOESS smooth fit line data

Description

Computes predicted values from a LOESS model for plotting a smooth fit line. Can optionally compute separate fit lines for each group in a grouping variable.

Usage

.compute_loess_fit(
  df,
  x.col,
  y.col,
  group.col = NULL,
  span = 0.75,
  n.points = 100
)

Arguments

Value

If group.col is NULL, a data frame with columns x and y. If group.col is provided, a named list of data frames (one per group).

Author(s)

Jared Andrews

Compute pairwise statistical tests between groups

Description

Performs pairwise statistical tests between groups defined by a categorical variable. Supports Wilcoxon rank-sum, t-test, Kruskal-Wallis, and ANOVA. Handles nested grouping (comparing color.by groups within each x-level) and per-facet testing.

Usage

.compute_pairwise_stats(
  df,
  x,
  y,
  pairs = NULL,
  test = "wilcox.test",
  p.adjust.method = "holm",
  paired = FALSE,
  group.by = NULL,
  facet.by = NULL,
  per.facet = TRUE,
  sig.threshold = 0.05
)

Arguments

Value

A data.frame with columns: group1, group2, p.value, p.adj, p.signif, test, facet_level, x_level (when group.by is set).

Author(s)

Jared Andrews, Jacob Martin

Create Plotly axis style list

Description

Constructs a style list for a Plotly axis using values from a Shiny input object, including title font, axis lines, tick appearance, and gridline settings.

Usage

.create_axis_styles(
  input,
  axis_side = c("x", "y"),
  isolate_fn = isolate,
  ggplot.axis.styling = TRUE
)

Arguments

Details

The function collects axis- and font-related settings from the provided input object and assembles them into a list suitable for use as an axis specification in Plotly layouts. The tick angle and gridline visibility are chosen based on the value of axis_side. If gridline inputs are not present in the input object, defaults to showing gridlines.

Value

A named list containing Plotly-compatible axis styling components, including title font, line properties, tick label formatting, and gridline visibility.

Author(s)

Jacob Martin

Create coordinate identifier for matching points

Description

Creates a unique coordinate identifier string for matching points between traces and data frames.

Usage

.create_coord_id(x, y, precision = 10)

Arguments

Value

Character vector. Coordinate identifiers in format "x_y".

Author(s)

Jared Andrews

Create a Dumbbell Plot for a Single Dataset

Description

Helper function that generates a plotly scatter plot in either single dot or dumbbell mode for one dataset (i.e., one facet). Called internally by dumbbellPlot.

Usage

.create_dumbbell_plot(
  data,
  x,
  y,
  colour.by,
  palette.selection,
  line.colour,
  show.legend
)

Arguments

Value

A plotly object representing the dumbbell (or single dot) plot for the supplied data.

Author(s)

Jacob Martin

Create ggplot axis styling theme arguments

Description

Creates ggplot2 theme arguments for axis borders and lines based on user inputs. This function handles axis styling through ggplot2 themes rather than plotly overlays, which provides better control especially when faceting is used.

Usage

.create_ggplot_axis_style(input, isolate_fn = isolate)

Arguments

Details

When faceting is enabled, panel borders are always shown for the full plot. When faceting is disabled:

• If both axis.showline and axis.mirror are TRUE: Full panel border

• If only axis.showline is TRUE: Axis lines on x and y axes only

• Otherwise: No borders

Value

A named list of ggplot2 theme arguments to be passed to theme_args parameter.

Author(s)

Jacob Martin

Create annotations for highlighted points

Description

Creates plotly annotation objects for points highlighted by value matching. This function finds all points in the plot data that match the highlight values and creates annotations for them.

Usage

.create_highlight_annotations(
  plot_data,
  fig,
  annotate.by,
  highlight_vals,
  x_col,
  y_col,
  annotation_params,
  show.others = TRUE
)

Arguments

Value

List of plotly annotation objects, or NULL if no valid annotations.

Author(s)

Jared Andrews

Create download handler for interactive plotly plots

Description

Generates a Shiny downloadHandler that saves a plotly widget as an interactive HTML file with resizable functionality. This is used by all VizModules to provide a "Save Interactive" button.

Usage

.create_plot_download_handler(
  plot_reactive,
  filename_base = "interactive_plot"
)

Arguments

Value

A downloadHandler function that can be assigned to output$download.interactive.

Author(s)

Jared Andrews

Create annotations for selected points

Description

Creates plotly annotation objects for selected points from event_data("plotly_selected"). This function handles the complex logic of matching selected points to their corresponding traces and extracting annotation text.

Usage

.create_selected_annotations(
  selected_data,
  fig,
  annotate.by,
  annotation_params,
  show.others = TRUE
)

Arguments

Value

List of plotly annotation objects, or NULL if no valid annotations.

Author(s)

Jared Andrews

Create plotly shapes and annotations for statistical test results

Description

Converts results from .compute_pairwise_stats() into plotly-compatible shapes (brackets) and annotations (text labels). Sorts comparisons so that small-gap brackets are closest to the data and large-gap brackets are higher.

Usage

.create_stat_annotations(
  stats_df,
  fig,
  df,
  x,
  y,
  display = "p.adj",
  hide.ns = FALSE,
  sig.threshold = 0.05,
  line.color = "#000000",
  line.width = 1,
  bracket.style = "capped",
  group.by = NULL,
  facet.by = NULL,
  x.order = NULL,
  font.size = 12,
  step.increase = 0.06,
  text.bump = 0.04,
  bracket.inset = 0.025
)

Arguments

Value

A list with components:

annotations

List of plotly annotation objects.

shapes

List of plotly shape objects.

y.max

Numeric; maximum y value needed to accommodate all annotations.

Author(s)

Jared Andrews, Jacob Martin

Create an empty ggplot2 plot or plotly plot with input text

Description

This function creates an empty ggplot2 or plotly plot and places a user-provided text string in the middle of the plot.

Usage

.empty_plot(text = NULL, plotly = FALSE)

Arguments

Value

Either a ggplot object or a plotly object if plotly = TRUE.

Author(s)

Jared Andrews

See Also

geom_text, theme_void

Extract annotation text from trace hover text

Description

Parses the hover text of a plotly trace to extract the value of a specific annotation field.

Usage

.extract_annotation_from_text(trace_text, annotate.by)

Arguments

Details

The hover text is expected to be in the format: "field1: value1\nfield2: value2\n..." or "field1 value1\nfield2 value2\n..."

Value

Character. The extracted annotation value, or NULL if not found.

Author(s)

Jared Andrews

Fix boxplot positioning across faceted subplots

Description

Sets the offsetgroup property on each box trace to ensure consistent positioning across faceted subplot panels. Without this, plotly.js may calculate different box offsets per subplot when boxmode = "group" is used, causing boxes in different facets to appear at different x-positions.

Usage

.fix_boxplot_facet_positions(fig)

Arguments

Details

When ggplotly converts a faceted ggplot, each facet becomes a subplot with its own axis pair. Plotly.js calculates box offsets independently per subplot unless offsetgroup is explicitly set on each trace. This function sets offsetgroup to the trace's name property (which corresponds to the color/grouping variable level), ensuring identical positioning of same-group boxes across all facet panels.

Value

The modified plotly figure with offsetgroup set on all box traces.

Author(s)

Jared Andrews

Flatten nested palette options

Description

Converts a nested list of palette choices into a single-level named list where each entry is a character vector of colors.

Usage

.flatten_palette_options(palettes)

Arguments

Value

A flattened named list of palettes.

Author(s)

Jared Andrews

Generate comparison pair strings from data columns

Description

Creates formatted pair strings for populating the comparison selector UI. Handles both standard x-axis comparisons and nested group.by comparisons.

Usage

.generate_pair_strings(df, x, group.by = NULL)

Arguments

Value

A character vector of pair strings in "group1 vs group2" format.

Author(s)

Jared Andrews

Resolve a default value from a named list

Description

Looks up key in defaults. If present and passes validator (when supplied), returns the stored value; otherwise returns fallback. Uses standard if/⁠else⁠ instead of vectorized ifelse() to avoid silent truncation of multi-valued defaults.

Usage

.get_default(defaults, key, fallback, validator = NULL)

Arguments

Value

The resolved default value or fallback.

Author(s)

Jared Andrews

Hide jitter points from plotly legend

Description

Hides jitter point traces from the legend by setting showlegend to FALSE. The jitter points remain visible in the plot but do not clutter the legend with individual point entries.

Usage

.hide_jitter_from_legend(fig)

Arguments

Details

This function iterates through all traces in the plotly figure and identifies scatter traces that represent jitter points (mode = "markers"). For each jitter trace, it sets showlegend to FALSE, preventing them from appearing in the legend while keeping them visible in the plot. Box traces and other trace types are returned unchanged.

Value

The modified plotly figure with jitter points hidden from the legend.

Author(s)

Jacob Martin

Convert linetype name to plotly dash style

Description

Maps common linetype names to plotly dash specifications.

Usage

.linetype_to_dash(linetype)

Arguments

Value

Character. Plotly-compatible dash specification.

Author(s)

Jared Andrews

CSS for the multi-color picker widget

Description

Provides the inline stylesheet used to render the multi-color picker UI.

Usage

.multi_color_picker_css()

Value

A character string containing the CSS rules.

Author(s)

Jared Andrews

HTML dependency for the multi-color picker widget

Description

Points htmltools to the bundled JavaScript assets so Shiny can initialize the widget on the client.

Usage

.multi_color_picker_dependency()

Value

An htmltools::htmlDependency object.

Author(s)

Jared Andrews

Convert NA or empty string to NULL

Description

A helper function to convert NA values or empty strings to NULL. Used to handle Shiny input default values which return NA or "" instead of NULL when the input field is empty. numericInput returns NA, textInput returns "".

Usage

.na_to_null(x)

Arguments

Value

NULL if x is a single NA value or empty string, otherwise x unchanged.

Author(s)

Jared Andrews

Normalize colors to hex strings

Description

Converts color names or shorthand hex values to full ⁠#RRGGBB⁠ strings and returns empty strings for missing values.

Usage

.normalize_hex(x)

Arguments

Value

A character vector of uppercase hex colors.

Author(s)

Jared Andrews

Parse comma-separated numeric string to vector

Description

Parses a text string containing comma-separated numeric values into a numeric vector. Used for parsing user input for line intercepts, slopes, etc.

Usage

.parse_numeric_list(text)

Arguments

Details

Whitespace around values is trimmed. Non-numeric values are converted to NA. If all values are NA or the input is empty, returns NULL.

Value

A numeric vector of parsed values, or NULL if input is empty/invalid.

Author(s)

Jared Andrews

Parse pair strings from UI into list of length-2 vectors

Description

Converts the "group1 vs group2" strings from the comparison selector back into a list of length-2 character vectors for .compute_pairwise_stats().

Usage

.parse_pair_strings(pair_strings)

Arguments

Value

A list of length-2 character vectors, or NULL if input is empty.

Author(s)

Jared Andrews

Recycle style vector to match line count

Description

Extends or truncates a style vector to match the number of lines being drawn. If the input length doesn't match the target length, uses only the first value for all lines (as documented behavior).

Usage

.recycle_line_style(values, n, default)

Arguments

Value

A vector of length n with recycled values.

Author(s)

Jared Andrews

Register input handler for the multi-color picker

Description

Creates the VizModules.multiColorPicker input handler that turns the JavaScript payload into a named vector of hex codes.

Usage

.register_multi_color_picker_handler()

Value

Invisibly returns the result of registerInputHandler().

Author(s)

Jared Andrews

Remove boxplot outliers from plotly figure

Description

Hides outlier points in boxplot traces by setting their marker opacity to zero and disabling hover information. The outliers remain in the underlying data but are not visually displayed or interactive.

Usage

.remove_boxplot_outliers(fig)

Arguments

Details

This function iterates through all traces in the plotly figure and identifies those with type "box". For each boxplot trace, it sets the marker opacity to 0 and disables hover information, effectively hiding the outlier points while preserving the box, whiskers, and median line. Non-boxplot traces are returned unchanged.

Value

The modified plotly figure with outliers hidden in all boxplot traces.

Author(s)

Jared Andrews

Reset uniform axes inputs to defaults

Description

Resets all inputs created by .uniform_axes_inputs_ui() to their default values. Call inside an observeEvent(input$reset, ...) block to avoid duplicating 20 updateXxxInput calls in every module server.

Usage

.reset_axes_inputs(session, defaults = NULL)

Arguments

Value

Called for side effects; returns invisible(NULL).

Author(s)

Jared Andrews

Reset uniform lines inputs to defaults

Description

Resets all inputs created by .uniform_lines_inputs_ui() to their default values. Call inside an observeEvent(input$reset, ...) block to avoid duplicating line-reset boilerplate in every module server.

Usage

.reset_lines_inputs(session, include.fit.lines = FALSE, defaults = NULL)

Arguments

Value

Called for side effects; returns invisible(NULL).

Author(s)

Jared Andrews

Reset uniform Plotly inputs to defaults

Description

Resets all inputs created by .uniform_plotly_inputs_ui() to their default values. Call inside an observeEvent(input$reset, ...) block to avoid duplicating Plotly-reset boilerplate in every module server.

Usage

.reset_plotly_inputs(session, defaults = NULL)

Arguments

Value

Called for side effects; returns invisible(NULL).

Author(s)

Jared Andrews

Reset uniform stats inputs to defaults

Description

Resets all inputs created by .uniform_stats_inputs_ui() to their default values. Call inside an observeEvent(input$reset, ...) block.

Usage

.reset_stats_inputs(session, defaults = NULL)

Arguments

Value

Called for side effects; returns invisible(NULL).

Author(s)

Jared Andrews

Resolve facet axis sharing from facet.scales

Description

Converts a facet.scales string (one of "fixed", "free", "free_x", "free_y") into the shareX / shareY logical values expected by plotly::subplot.

Usage

.resolve_facet_sharing(facet.scales = "fixed")

Arguments

Value

A named list with logical elements shareX and shareY.

Author(s)

Jared Andrews

Seed group colors from a palette

Description

Recycles palette values to cover all requested groups and names the result.

Usage

.seed_colors(groups, palette)

Arguments

Value

A named character vector of colors aligned to groups.

Author(s)

Jared Andrews

Check if a plotly trace should be included in annotations

Description

Determines whether a trace in a plotly figure should be included when processing annotations. "show.others" background traces are excluded.

Usage

.should_include_trace(trace, show.others = TRUE)

Arguments

Details

Background traces (show.others) are identified by checking for:

• name field containing "show.others"

• legendgroup field containing "show.others"

• Single text element (this check is REMOVED as it's unreliable)

Value

Logical. TRUE if the trace should be included in annotation processing, FALSE if it should be skipped.

Author(s)

Jared Andrews

Parse and validate linetype string to a vector

Description

Parses a comma-separated string of linetypes and validates each element. Invalid linetypes are replaced with "solid" and a warning is issued.

Usage

.string_to_linetypes(x)

Arguments

Value

A character vector of validated linetypes. If the input is "" or NULL, returns "solid".

Author(s)

Jared Andrews

Parse a string indicating a set of vectors to a list of vectors.

Description

Used to parse text inputs into a list of vectors.

Usage

.string_to_list_of_vectors(x)

Arguments

Value

A list like list(c("a", "b", "c"), c("d", "e")). If the input is "", just returns "". If the input is NULL, returns NULL.

Author(s)

Jared Andrews

Parse a string delimited by commas, whitespace, or new lines to a vector.

Description

Used to parse text inputs into a vector.

Usage

.string_to_vector(x)

Arguments

Value

A vector of strings like c("a", "b", "c", "d", "e"). If the input is "", just returns "". If the input is NULL, returns NULL.

Author(s)

Jared Andrews

Generate uniform Axes input UI

Description

Creates a standardized tagList of axis-related inputs for use across plot modules.

Usage

.uniform_axes_inputs_ui(
  ns,
  defaults = NULL,
  include.rotate = FALSE,
  include.flip = FALSE
)

Arguments

Value

A tagList containing the axis input UI elements.

Author(s)

Jared Andrews Jacob Martin

Generate uniform Lines input UI

Description

Creates a standardized tagList of line-related inputs (horizontal, vertical, and diagonal lines) for use across plot modules.

Usage

.uniform_lines_inputs_ui(ns, defaults = NULL, include.fit.lines = FALSE)

Arguments

Value

A tagList containing the line input UI elements.

Author(s)

Jared Andrews

Generate uniform Plotly input UI

Description

Creates a standardized tagList of Plotly-specific inputs used across all plot modules. Includes interactive download controls, plot margin adjustments, subplot spacing, and user-drawn shape styling for Plotly's drawing tools.

Usage

.uniform_plotly_inputs_ui(ns, defaults = NULL)

Arguments

Value

A tagList containing the Plotly input UI elements.

Author(s)

Jared Andrews

Generate uniform Stats input UI

Description

Creates a standardized tagList of statistical testing inputs for use across plot modules that support pairwise comparisons (BoxPlot, ViolinPlot, yPlot).

Usage

.uniform_stats_inputs_ui(ns, defaults = NULL)

Arguments

Value

A tagList containing the stats input UI elements.

Author(s)

Jared Andrews

Write stats table CSV with metadata header

Description

Writes the stats data frame to a CSV file with a metadata header block containing the p-value correction method, significance threshold, and symbol legend.

Usage

.write_stats_csv(
  stats_df,
  file,
  p.adjust.method = "holm",
  sig.threshold = 0.05
)

Arguments

Value

Called for side effects; writes to file.

Author(s)

Jared Andrews

Adjust numeric column values in a data frame using mathematical transformations

Description

Applies a named mathematical transformation to a specified numeric column in a data frame, adding the transformed values as a new column (original column name + ".adj"). The transformation name must be one of the allowed functions listed in safe_resolve_adj_fxn (e.g., "log2", "log10", "sqrt", "abs", "as.factor"). The original data frame is returned unchanged if no transformation is specified or if the supplied name is invalid.

Usage

adjust_column_values(
  df,
  x.col = NULL,
  y.col = NULL,
  color.col = NULL,
  x.adj.fun = NULL,
  y.adj.fun = NULL,
  color.adj.fun = NULL
)

Arguments

Value

A data frame identical to input df but with transformed columns added (e.g., mpg.adj) when valid transformations are specified.

Author(s)

Jacob Martin, Jared Andrews

Examples

data(mtcars)
mtcars_mod <- adjust_column_values(mtcars, x.col = "mpg", x.adj.fun = "log2")
head(mtcars_mod$mpg.adj)

Create an Example Module App from Any Module Trio

Description

Factory function that generates a standard Shiny application for any VizModules module. The resulting app features a Data Import section for uploading data files, a Data Table for viewing and editing the active dataset, and a Plot area for configuring and displaying an interactive plot.

Usage

createModuleApp(
  inputs_ui_fn,
  output_ui_fn,
  server_fn,
  data_list,
  title = "VizModules App"
)

Arguments

Details

Uploaded files (Excel, CSV, TSV, or tab-delimited text) are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

Every module-specific ⁠*App()⁠ convenience function (e.g. plotthis_BarPlotApp(), linePlotApp()) is a thin wrapper around createModuleApp(). You can also call it directly for quick prototyping or to create apps for custom wrapper modules.

Value

A shiny::shinyApp() object.

Author(s)

Jared Andrews

Examples

library(VizModules)

# Quick-launch a bar plot app with custom data:
app <- createModuleApp(
    inputs_ui_fn = plotthis_BarPlotInputsUI,
    output_ui_fn = plotthis_BarPlotOutputUI,
    server_fn    = plotthis_BarPlotServer,
    data_list    = list("iris" = iris),
    title        = "My Bar Plot"
)
if (interactive()) runApp(app)

# Works with any module trio, including custom wrapper modules:
app2 <- createModuleApp(
    inputs_ui_fn = dittoViz_scatterPlotInputsUI,
    output_ui_fn = dittoViz_scatterPlotOutputUI,
    server_fn    = dittoViz_scatterPlotServer,
    data_list    = list("iris" = iris),
    title        = "Scatter"
)
if (interactive()) runApp(app2)

Server logic for the dataFilter module

Description

Renders an interactive DT table with column-level filters and returns a reactive containing only the currently visible (filtered) rows. This reactive can be passed directly to any plotting module as its data argument.

Usage

dataFilterServer(id, data, factor.char.cols = TRUE, page.length = 10)

Arguments

Value

A reactive expression that evaluates to the filtered subset of data based on the current DT selection/filter state. Pass this reactive to a plotting module's data argument to keep the plot in sync with the table filters.

Author(s)

Jacob Martin

See Also

dataFilterUI()

Examples

library(shiny)
library(VizModules)

ui <- fluidPage(
    dataFilterUI("filter"),
    verbatimTextOutput("rows")
)

server <- function(input, output, session) {
    data <- reactive(iris)
    filtered <- dataFilterServer("filter", data, factor.char.cols = TRUE)
    output$rows <- renderPrint(nrow(filtered()))
}

if (interactive()) shinyApp(ui, server)

UI component for the dataFilter module

Description

Renders an interactive DT table that allows users to filter rows of a data frame. Place this in the UI where you want the filterable table to appear, using an id that matches the one passed to dataFilterServer().

Usage

dataFilterUI(id)

Arguments

Value

A Shiny tagList containing the DT table output.

Author(s)

Jacob Martin

See Also

dataFilterServer()

Examples

library(VizModules)
dataFilterUI("myFilter")

Color palette options for palettePicker

Description

Returns a list of predefined color palettes grouped by category (Defaults, Viridis, Diverging, Qualitative, Sequential) for use with color picker UI components.

Usage

default_palettes()

Value

A named list with two elements: choices (a nested list of palette name to color vector mappings, grouped by category) and textColor (a character vector of text colors for each palette).

Author(s)

Jared Andrews

Examples

pals <- default_palettes()
names(pals$choices)

Create an example Modular scatterPlot Shiny Application

Description

This function generates a Shiny application with modular dittoViz::scatterPlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive scatter plot.

Usage

dittoViz_scatterPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with gallery_sales as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jared Andrews

See Also

dittoViz::scatterPlot(), dittoViz_scatterPlotInputsUI(), dittoViz_scatterPlotOutputUI(), dittoViz_scatterPlotServer()

Examples

library(VizModules)
# Launch with default example data:
app <- dittoViz_scatterPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- dittoViz_scatterPlotApp(list("sales" = example_sales))
if (interactive()) runApp(app2)

Input UI components for the scatterPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the dittoViz_scatterPlotServer() and dittoViz_scatterPlotOutputUI() functions.

Usage

dittoViz_scatterPlotInputsUI(
  id,
  data,
  defaults = NULL,
  title = NULL,
  columns = 2
)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for dittoViz::scatterPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Note that some of the parameters may have input types that differ from the actual function, e.g. shape.panel is a text input for comma-separated integers, while the function expects a vector of integers. The module will parse such inputs into the appropriate format for dittoViz::scatterPlot() automatically.

Value

A Shiny tagList containing the UI elements

Plot parameters not implemented or with altered functionality

The following dittoViz::scatterPlot() parameters are not available via UI inputs or have been superseded:

• xlab - X-axis label (plotly allows interactive editing)

• ylab - Y-axis label (plotly allows interactive editing)

• main - Plot title (plotly allows interactive editing)

• sub - Plot subtitle (not supported in plotly)

• theme - ggplot2 theme (not applicable to plotly)

• legend.title - Legend title (managed by plotly interactively)

• add.xline - Use vline.intercepts instead for vertical lines with full styling options

• add.yline - Use hline.intercepts instead for horizontal lines with full styling options

• xline.linetype - Use vline.linetypes instead

• xline.color - Use vline.colors instead

• yline.linetype - Use hline.linetypes instead

• yline.color - Use hline.colors instead

• do.letter - Lettering subplots (not implemented for plotly)

• do.label - Labeling points interactively (not compatible with plotly hover)

The new Lines tab provides enhanced functionality including multiple lines per type, individual line widths, opacities, and diagonal/ablines with slope control.

Plot parameters and defaults

The following dittoViz::scatterPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• x.by - X-axis variable (UI: "X Data", default: 2nd column)

• y.by - Y-axis variable (UI: "Y Data", default: 3rd column)

• color.by - Coloring variable (UI: "Color By", default: "")

• shape.by - Shape variable (UI: "Shape By", default: "")

• split.by - Faceting variable (UI: "Split By", default: "")

• rows.use - Row filter expression (UI: "Rows Filter", default: "")

• x.adjustment - X-axis adjustment (UI: "X Adjustment", default: "")

• y.adjustment - Y-axis adjustment (UI: "Y Adjustment", default: "")

• color.adjustment - Color adjustment (UI: "Color Adjustment", default: "")

• x.adj.fxn - X adjustment function (UI: "X Adjustment Function", default: "")

• y.adj.fxn - Y adjustment function (UI: "Y Adjustment Function", default: "")

• color.adj.fxn - Color adjustment function (UI: "Color Adjustment Function", default: "")

• size - Point size (UI: "Point Size", default: 1)

• opacity - Point opacity (UI: "Point Opacity", default: 1)

• show.others - Show others (UI: "Show Others", default: TRUE)

• split.show.all.others - Show split others (UI: "Show Split Others", default: TRUE)

• plot.order - Plot order (UI: "Plot Order", default: "unordered")

• shape.panel - Shape panel values (UI: "Shape Panel", default: "16, 15, 17, 23, 25, 8")

• min.color - Minimum color (UI: "Min Color", default: "#F0E442")

• max.color - Maximum color (UI: "Max Color", default: "#0072B2")

• contour.color - Contour color (UI: "Contour Color", default: "black")

• contour.linetype - Contour linetype (UI: "Contour Linetype", default: "solid")

• color.panel - Custom color values (UI: color.panel.ui, derived from palette)

• split.nrow - Number of split rows (UI: "Split Rows", default: NA)

• split.ncol - Number of split columns (UI: "Split Columns", default: NA)

• multivar.split.dir - Multivar split direction (UI: "Multivar Split Dir", default: "col")

• split.adjust.scales - Facet scales (UI: "Facet Scales", default: "fixed")

• annotate.by - Annotate by column (UI: "Annotate By", default: "")

• highlight.points - Points to highlight (UI: "Points to Highlight", default: "")

• highlight.color - Highlight fill (UI: "Highlight Fill", default: "#00FFF7")

• highlight.size - Highlight size (UI: "Highlight Size", default: 7)

• highlight.border.color - Highlight border color (UI: "Highlight Border Color", default: "#000000")

• highlight.border.width - Highlight border width (UI: "Highlight Border Width", default: 1)

• highlight.auto.annotate - Auto-annotate highlights (UI: "Auto-annotate Highlights", default: TRUE)

• annotation.color - Annotation color (UI: "Annotation Color", default: "black")

• annotation.ax - Annotation X offset (UI: "Annotation X Offset", default: 20)

• annotation.ay - Annotation Y offset (UI: "Annotation Y Offset", default: -20)

• annotation.size - Annotation size (UI: "Annotation Size", default: 10)

• annotation.showarrow - Show arrow (UI: "Show Arrow", default: TRUE)

• annotation.arrowcolor - Arrow color (UI: "Arrow Color", default: "black")

• annotation.arrowhead - Arrowhead style (UI: "Arrowhead Style", default: 2)

• annotation.arrowwidth - Arrow linewidth (UI: "Arrow Linewidth", default: 1.5)

• legend.show - Show legend (UI: "Show Legend", default: TRUE)

• legend.color.title - Legend title (UI: "Legend Title", default: "make")

• legend.color.size - Legend color size (UI: "Legend Color Size", default: 5)

• legend.shape.size - Legend shape size (UI: "Legend Shape Size", default: 5)

• legend.color.breaks - Legend tick breaks (UI: "Legend Tick Breaks", default: "")

• min.value - Minimum value (UI: "Min Value", default: NA)

• max.value - Maximum value (UI: "Max Value", default: NA)

• trajectory.group.by - Trajectory group by (UI: "Trajectory Group By", default: "")

• add.trajectory.by.groups - Add trajectory by groups (UI: "Add Trajectory By Groups", default: "")

• trajectory.arrow.size - Trajectory arrow size (UI: "Trajectory Arrow Size", default: 0.15)

• do.ellipse - Enable ellipses (UI: "Enable Ellipses", default: FALSE)

• do.contour - Enable contour (UI: "Enable Contour", default: FALSE)

• hover.data - Hover data columns (UI: "Hover Data", default: "")

• hover.round.digits - Hover round digits (UI: "Hover Round Digits", default: 5)

Parameters controlling additional functionality

The following parameters implementing new functionality or controlling plotly-specific features are also available:

• webgl - Plot with webGL (UI: "Plot with webGL", default: TRUE)

• shape.fill - Shape fill color (UI: "Shape Fill", default: "rgba(0, 0, 0, 0)")

• shape.line.color - Shape line color (UI: "Shape Line Color", default: "black")

• shape.line.width - Shape line width (UI: "Shape Line Width", default: 4)

• shape.linetype - Shape linetype (UI: "Shape Linetype", default: "solid")

• shape.opacity - Shape opacity (UI: "Shape Opacity", default: 1)

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show Axis Borders", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror Axis Borders", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X Gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y Gridlines", default: TRUE)

• grid.color - Gridline color (UI: "Gridline Color", default: "#CCCCCC")

• axis.linecolor - Color of axis lines (UI: "Axis Line Color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis Line Width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick Label Size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick Label Color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick Label Font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X Tick Label Angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y Tick Label Angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick Position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick Mark Color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick Mark Length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick Mark Width", default: 1)

• facet.title.font.size - Facet subplot title font size (UI: "Facet Subplot Title Size", default: 18)

• facet.title.font.color - Facet subplot title font color (UI: "Facet Title Color", default: "#000000")

• facet.title.font.family - Facet subplot title font family (UI: "Facet Title Font", default: "Arial")

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line Types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line Types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• best.fit - Enable line of best fit (UI: "Line of best fit:", default: FALSE)

• line.best.smoothness - Smoothness of line of best fit (UI: "Smoothness of line of best fit:", default: 1)

• line.best.colour - Color of line of best fit (UI: "Line of best fit colour:", default: "#000000")

• linear.model - Enable linear model line (UI: "Linear model line", default: FALSE)

Author(s)

Jared Andrews

See Also

dittoViz::scatterPlot(), organize_inputs(), dittoViz_scatterPlotOutputUI(), dittoViz_scatterPlotServer(), dittoViz_scatterPlotApp()

Examples

library(VizModules)
dittoViz_scatterPlotInputsUI("scatterPlot", example_mtcars)

Output UI components for the scatterPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

dittoViz_scatterPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the scatterplot

Author(s)

Jared Andrews

Server logic for scatterPlot module

Description

Server logic for scatterPlot module

Usage

dittoViz_scatterPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  manual.colors = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the scatterPlot module.

Author(s)

Jared Andrews

See Also

dittoViz::scatterPlot(), dittoViz_scatterPlotInputsUI(), dittoViz_scatterPlotOutputUI(), dittoViz_scatterPlotApp()

Create an example Modular yPlot Shiny Application

Description

This function generates a Shiny application with modular dittoViz::yPlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive y plot.

Usage

dittoViz_yPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with gallery_demographics as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jared Andrews

See Also

dittoViz::yPlot(), dittoViz_yPlotInputsUI(), dittoViz_yPlotOutputUI(), dittoViz_yPlotServer()

Examples

library(VizModules)
# Launch with default example data:
app <- dittoViz_yPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- dittoViz_yPlotApp(list("demographics" = example_demographics))
if (interactive()) runApp(app2)

Input UI components for the yPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the dittoViz_yPlotServer() and dittoViz_yPlotOutputUI() functions.

Usage

dittoViz_yPlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for dittoViz::yPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters not implemented or with altered functionality

The following dittoViz::yPlot() parameters are not available via UI inputs:

• xlab - X-axis label (plotly allows interactive editing)

• ylab - Y-axis label (plotly allows interactive editing)

• main - Plot title (plotly allows interactive editing)

• sub - Plot subtitle (not supported in plotly)

• theme - ggplot2 theme (not applicable to plotly)

• legend.title - Legend title (managed by plotly interactively)

• add.line - Use hline.intercepts instead for horizontal lines with full styling options

• line.linetype - Use hline.linetypes instead

• line.color - Use hline.colors instead

Plot parameters and defaults

The following dittoViz::yPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• var - Y-axis variable (UI: "Y data (var)", default: 2nd numeric variable)

• group.by - Grouping variable for x-axis (UI: "Group by", default: 2nd categorical variable)

• color.by - Coloring variable (UI: "Color by", default: "")

• shape.by - Shape variable (UI: "Shape by", default: "")

• split.by - Faceting variable (UI: "Split by (facet)", default: "")

• plots - Plot types to show (UI: "Plots to show", default: c("boxplot", "jitter"))

• color.panel - Custom color values (UI: palette picker, derived from palette)

• min - Y-axis minimum (UI: "Y Axis Min", auto-calculated)

• max - Y-axis maximum (UI: "Y Axis Max", auto-calculated)

• split.nrow - Number of facet rows (UI: "Number of Rows", default: 4)

• split.ncol - Number of facet columns (UI: "Number of Columns", default: 4)

• split.adjust - Facet scale behavior (UI: "Facet Scaling", default: "free")

• do.raster - Rasterize jitter points (UI: "Rasterize Jitter", default: FALSE)

• raster.dpi - DPI for rasterization (UI: "Raster DPI", default: 600)

• jitter.size - Jitter point size (UI: "Jitter Point Size", default: 1)

• jitter.width - Jitter width (UI: "Jitter Width", default: 0.2)

• jitter.color - Jitter point color (UI: "Jitter Point Color", default: "#000000")

• jitter.shape.legend.size - Shape legend size (UI: "Shape Legend Size", default: 5)

• jitter.shape.legend.show - Show shape legend (UI: "Show Shape Legend", default: TRUE)

• jitter.position.dodge - Jitter position dodge (calculated from boxgap)

• boxplot.show.outliers - Show boxplot outliers

• boxplot.color - Boxplot outline color (UI: "Boxplot Color", default: "#000000")

• boxplot.fill - Fill boxplot (UI: "Fill Boxplot", default: TRUE)

• boxplot.lineweight - Boxplot line weight (UI: "Boxplot Line Weight", default: 0.5)

• vlnplot.lineweight - Violin line weight (UI: "Violin Line Weight", default: 0.5)

• vlnplot.scaling - Violin scaling method (UI: "Violin Scaling", default: "area")

• vlnplot.quantiles - Violin quantiles (UI: "Violin Quantiles (0-1)", default: "")

• vlnplot.width - Violin width (derived from boxgap; not directly settable)

• ridgeplot.lineweight - Ridge line weight (UI: "Ridge Line Weight", default: 0.5)

• ridgeplot.scale - Ridge overlap scale (UI: "Ridge Scale (overlap)", default: 1.25)

• ridgeplot.ymax.expansion - Ridge Y-max expansion (UI: "Ridge Y-max Expansion", default: NA)

• ridgeplot.shape - Ridge shape (UI: "Ridge Shape", default: "smooth")

• ridgeplot.bins - Ridge bins (UI: "Ridge Bins", default: 30)

• ridgeplot.binwidth - Ridge binwidth (UI: "Ridge Binwidth", default: NULL)

• legend.show - Show legend (always TRUE; not directly settable)

Parameters controlling additional functionality

The following parameters implementing new functionality or controlling plotly-specific features are also available:

• boxmode - Boxplot mode grouping (calculated: "group" or "overlay" based on color.by)

• boxgap - Boxplot position dodge (UI: "Boxplot Position Dodge", default: 0.3)

• boxgroupgap - Boxplot group dodge (UI: "Boxplot Group Dodge", default: 0.2)

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show Axis Lines", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror Axis Lines", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X Major Gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y Major Gridlines", default: TRUE)

• axis.linecolor - Color of axis lines (UI: "Axis Line Color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis Line Width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick Label Size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick Label Color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick Label Font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X-axis Tick Label Angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y-axis Tick Label Angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick Position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick Mark Color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick Mark Length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick Mark Width", default: 1)

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line Types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line Types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• abline.intercepts - Y-intercepts for diagonal lines (UI: "Y-intercepts", default: "")

• abline.colors - Colors for diagonal lines (UI: "Colors", default: "#000000")

• abline.widths - Widths for diagonal lines (UI: "Widths", default: "1")

• abline.linetypes - Line types for diagonal lines (UI: "Line Types", default: "dashed")

• abline.opacities - Opacities for diagonal lines (UI: "Opacities (0-1)", default: "1")

Author(s)

Jared Andrews, Jacob Martin

See Also

dittoViz::yPlot(), organize_inputs(), dittoViz_yPlotOutputUI(), dittoViz_yPlotServer(), dittoViz_yPlotApp()

Examples

library(VizModules)
data(mtcars)
dittoViz_yPlotInputsUI("yPlot", mtcars)

Output UI components for the yPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

dittoViz_yPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the yPlot

Author(s)

Jared Andrews

Server logic for yPlot module

Description

Server logic for yPlot module

Usage

dittoViz_yPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the yPlot module.

Author(s)

Jared Andrews, Jacob Martin

See Also

dittoViz::yPlot(), dittoViz_yPlotInputsUI(), dittoViz_yPlotOutputUI(), dittoViz_yPlotApp()

Create an Interactive Dumbbell Plot with plotly

Description

Generates a customizable interactive dumbbell plot using plotly. Supports single dot mode (1 x variable) or dumbbell mode (2 x variables), with flexible coloring by either X or Y variables, faceting, and transformations.

Usage

dumbbellPlot(
  data,
  x,
  y,
  colour.by = "X variables",
  palette.selection,
  show.legend = TRUE,
  facet.by = NULL,
  line.colour = "gray80",
  facet.scales = "fixed",
  subplot.margin = 0.05,
  axis.showline = TRUE,
  axis.mirror = TRUE,
  axis.linecolor = "black",
  axis.linewidth = 0.5,
  axis.tickfont.size = 12,
  axis.tickfont.color = "black",
  axis.tickfont.family = "Arial",
  axis.tickangle.x = 0,
  axis.tickangle.y = 0,
  axis.ticks = "outside",
  axis.tickcolor = "black",
  axis.ticklen = 5,
  axis.tickwidth = 1,
  title.text = "",
  title.font.size = 26,
  title.font.family = "Arial",
  title.font.color = "black",
  y.title = NULL,
  x.title = NULL,
  flip.x = FALSE,
  flip.y = FALSE,
  x.adjustment = NULL,
  order.by = NULL
)

Arguments

Details

The dumbbell plot is designed for comparing two values across categories.

Modes:

• Single dot mode (1 x variable): Shows one marker per y category

• Dumbbell mode (2 x variables): Shows two markers connected by a line per y category

Coloring options:

• By X variables: Each x variable gets a different color (e.g., Male=blue, Female=pink)

• By Y variables: Each y category gets a different color (e.g., School A=red, School B=blue)

Value

A plotly object representing the interactive dumbbell plot.

Author(s)

Jacob Martin

Examples

data <- data.frame(
    School = c("MIT", "Stanford", "Harvard"),
    Women = c(152, 96, 112),
    Men = c(95, 151, 165)
)

fig <- dumbbellPlot(
    data = data,
    x = c("Women", "Men"),
    y = "School",
    colour.by = "X variables",
    palette.selection = c("green", "blue"),
    show.legend = TRUE,
    line.colour = "gray80"
)

Create a Shiny App for Dumbbell Plots

Description

This function generates a Shiny application for interactive dumbbell plots. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive dumbbell plot.

Usage

dumbbellPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with example_school_earnings as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

See Also

dumbbellPlot(), dumbbellPlotInputsUI(), dumbbellPlotOutputUI(), dumbbellPlotServer()

Examples

library(VizModules)
# Launch with default example data:
app <- dumbbellPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
data <- data.frame(
    School = c("MIT", "Stanford", "Harvard"),
    Women = c(94, 96, 112),
    Men = c(152, 151, 165),
    Group = c("A", "B", "A")
)
app2 <- dumbbellPlotApp(list("School Earnings" = data))
if (interactive()) runApp(app2)

Input UI components for the dumbbellPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the dumbbellPlotServer() and dumbbellPlotOutputUI() functions.

Usage

dumbbellPlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument.

Value

A Shiny tagList containing the UI elements

Plot parameters and defaults

The following dumbbellPlot() parameters can be accessed via UI inputs:

• x - X values (UI: "X Values (max 2)", defaults key: x.value, multiple: TRUE, max 2 enforced)

• y - Y value (UI: "Y Value", defaults key: y.value, single selection)

• x.adjustment - X-axis transformation (UI: "X Adjustment", default: "")

• colour.by - Color by X or Y (UI: "Colour By", default: "X variables")

• facet.by - Faceting variable (UI: "Facet By", default: "")

• facet.scales - Facet scale behavior (UI: "Facet Scales", default: "fixed")

• line.colour - Color of connecting lines (UI: "Colour of Connectors", default: "gray30")

• palette.selection - Color palette (UI: palette picker)

Parameters controlling additional functionality

The following parameters controlling plotly-specific features and styling are also available:

• flip.x - Flip X-axis (UI: "Flip X Axis", default: FALSE)

• flip.y - Flip Y-axis (UI: "Flip Y Axis", default: FALSE)

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show Axis Borders", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror Axis Borders", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X Gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y Gridlines", default: TRUE)

• grid.color - Gridline color (UI: "Gridline Color", default: "#CCCCCC")

• axis.linecolor - Color of axis lines (UI: "Axis Line Color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis Line Width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick Label Size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick Label Color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick Label Font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X Tick Label Angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y Tick Label Angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick Position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick Mark Color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick Mark Length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick Mark Width", default: 1)

• facet.title.font.size - Facet subplot title font size (UI: "Facet Subplot Title Size", default: 18)

• facet.title.font.color - Facet subplot title font color (UI: "Facet Title Color", default: "#000000")

• facet.title.font.family - Facet subplot title font family (UI: "Facet Title Font", default: "Arial")

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line Types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line Types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• margin.t - Top margin in pixels (UI: "Margin Top", default: 70)

• margin.b - Bottom margin in pixels (UI: "Margin Bottom", default: 70)

• margin.l - Left margin in pixels (UI: "Margin Left", default: 70)

• margin.r - Right margin in pixels (UI: "Margin Right", default: 70)

• subplot.margin - Spacing between facet panels as fraction of plot area (UI: "Subplot Spacing", default: 0.04)

• shape.fill - Fill color for drawn shapes (UI: "Shape Fill", default: "rgba(0, 0, 0, 0)")

• shape.line.color - Outline color for drawn shapes (UI: "Shape Line Color", default: "black")

• shape.line.width - Outline width for drawn shapes (UI: "Shape Line Width", default: 4)

• shape.linetype - Line dash style for drawn shapes (UI: "Shape Linetype", default: "solid")

• shape.opacity - Opacity for drawn shapes (UI: "Shape Opacity", default: 1)

Author(s)

Jacob Martin

See Also

dumbbellPlot(), organize_inputs(), dumbbellPlotOutputUI(), dumbbellPlotServer(), dumbbellPlotApp()

Examples

library(VizModules)
data <- data.frame(
    School = c("MIT", "Stanford", "Harvard"),
    Women = c(94, 96, 112),
    Men = c(152, 151, 165)
)
dumbbellPlotInputsUI("dumbbellPlot", data)

Output UI components for the dumbbellPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

dumbbellPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the dumbbellPlot

Author(s)

Jacob Martin, Jared Andrews

Server logic for dumbbellPlot module

Description

Server logic for dumbbellPlot module

Usage

dumbbellPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the dumbbellPlot module.

Author(s)

Jacob Martin

See Also

dumbbellPlot(), dumbbellPlotInputsUI(), dumbbellPlotOutputUI(), dumbbellPlotApp()

Bar dataset for bar and split bar plot examples

Description

A small dataset with five groups, two categorical variables, and three numeric variables. Used as the default data for plotthis_BarPlotApp() and plotthis_SplitBarPlotApp().

Usage

example_bar

Format

A data frame with 5 rows and 5 columns:

Group

Group label (A through E)

Type

Category type (Alpha, Beta, or Gamma)

Values

Primary numeric values (positive)

Numbers

Secondary numeric values (can be negative)

Score

Tertiary numeric values (can be negative)

Author(s)

Jacob Martin

Source

Generated in data-raw/generate_example_data.R.

Example demographics dataset

Description

A simulated employee survey dataset with 500 rows spanning six departments and four job levels. Designed to showcase violin, box, yPlot, density, and histogram plot modules with realistic numeric distributions.

Usage

example_demographics

Format

A data frame with 500 rows and 9 columns:

department

Employee department (factor: Engineering, Marketing, Sales, HR, Finance, Operations)

job_level

Job seniority level (factor: Junior, Mid, Senior, Lead)

gender

Employee gender (factor: Male, Female)

age

Employee age in years

salary

Annual salary in USD

satisfaction

Job satisfaction score (1–10)

performance

Performance rating (1–10)

tenure_years

Years with the company

weekly_hours

Average weekly hours worked (35–65)

Author(s)

Jared Andrews

Source

Simulated in data-raw/generate_example_data.R.

Example grouped iris dataset

Description

The classic iris dataset with an added 'Group' column to facilitate multi-group plot examples.

Usage

example_iris

Format

A data frame with 150 rows and 6 columns:

Sepal.Length

Sepal length in cm

Sepal.Width

Sepal width in cm

Petal.Length

Petal length in cm

Petal.Width

Petal width in cm

Species

Species of the iris (factor: setosa, versicolor, virginica)

Group

Group assignment (factor: A, B, C, D)

Author(s)

Jared Andrews

Source

Generated from the classic iris dataset.

Example mtcars dataset with factors

Description

The classic mtcars dataset with key numeric columns converted to factors for categorical plotting examples.

Usage

example_mtcars

Format

A data frame with 32 rows and 11 columns:

mpg

Miles per gallon

cyl

Number of cylinders (factor)

disp

Displacement (cubic inches)

hp

Gross horsepower

drat

Rear axle ratio

wt

Weight (1000 lbs)

qsec

1/4 mile time

vs

Engine (0 = V-shaped, 1 = straight) (factor)

am

Transmission (0 = automatic, 1 = manual) (factor)

gear

Number of forward gears (factor)

carb

Number of carburetors (factor)

Author(s)

Jared Andrews

Source

Generated from the classic mtcars dataset.

Example population dataset A simulated population dataset with 400 rows covering 50 years and 8 age groups. Designed for line, area, and stacked bar plot examples.

Description

Example population dataset A simulated population dataset with 400 rows covering 50 years and 8 age groups. Designed for line, area, and stacked bar plot examples.

Usage

example_population

Format

A data frame with 400 rows and 4 columns:

year

Year of the population record (factor: 1975–2024)

age_group

Age group category (factor: 0-9, 10-17, 18-34, 35-44, 45-54, 55-64, 65-74, 75+)

count

Population count for the given year and age group

record_id

Unique identifier for each population record

Author(s)

Jared Andrews

Source

Generated in data-raw/generate_example_data.R.

Example roles dataset for ternary plots

Description

A dataset of role proportions (journalist, developer, designer) for eleven individuals across two teams, suitable for ternary plot examples.

Usage

example_roles

Format

A data frame with 11 rows and 5 columns:

journalist

Journalist role proportion

developer

Developer role proportion

designer

Designer role proportion

label

Point label (point 1 through point 11)

team

Team assignment (Team A or Team B)

Author(s)

Jacob Martin

Source

Generated in data-raw/generate_example_data.R.

Example sales dataset

Description

A simulated product-sales dataset (720 rows total). Designed to showcase bar, box, violin, area, line, scatter, split-bar, density, and histogram plot modules.

Usage

example_sales

Format

A data frame with 720 rows and 7 columns:

region

Region of the sale (factor: North, South, East, West, Central, International)

revenue

Revenue for month

year

The year

month

The month

units

Units sold

sale_id

Unique sale identifier

product_line

Product line (factor: Gadgets, Widgets, Doohickeys)

Author(s)

Jared Andrews

Source

Generated in data-raw/generate_example_data.R.

Example school earnings dataset for dumbbell plots

Description

A small dataset of median annual earnings for men and women at six universities, suitable for dumbbell plot examples.

Usage

example_school_earnings

Format

A data frame with 6 rows and 4 columns:

School

University name

Women

Median earnings for women (thousands of USD)

Men

Median earnings for men (thousands of USD)

Group

University type (STEM-heavy or Liberal Arts)

Author(s)

Jacob Martin

Source

Generated in data-raw/generate_example_data.R.

Example multi-player skills dataset for radar plots

Description

A dataset of skill ratings across five categories for three players, suitable for radar/spider chart examples.

Usage

example_skills

Format

A data frame with 15 rows and 3 columns:

category

Skill category (Speed, Strength, Defense, Stamina, Agility)

value

Skill rating (1-10)

player

Player identifier (Player A, B, or C)

Author(s)

Jacob Martin

Source

Simulated in data-raw/generate_example_data.R.

Extract parameter documentation from an R function help page

Description

Parses the Rd documentation for a given function and extracts parameter descriptions for specified parameter names.

Usage

get_documentation(package_name, type = "param", selected = NULL, cap = FALSE)

Arguments

Value

A named list where names are parameter names and values are their documentation strings. Returns empty strings for parameters not found in the documentation.

Author(s)

Jacob Martin, Jared Andrews

Check if column inputs contain mixed data types

Description

This function validates that a vector of column names from a data frame contains columns of only one data type category: either all numeric OR all categorical (factor/character). Returns FALSE for mixed numeric + categorical columns. Single columns always return TRUE. Used for Shiny plotting module input validation.

Usage

is_pure_type(inputs, d)

Arguments

Value

Logical scalar: TRUE if all numeric OR all categorical (factor/character); FALSE if mixed numeric + categorical/factor detected.

Author(s)

Jacob Martin

See Also

for

Examples

df <- data.frame(num1 = 1:3, num2 = 4:6, cat1 = letters[1:3], fac1 = factor(1:3))
is_pure_type(c("num1", "num2"), df) # TRUE (all numeric)
is_pure_type(c("cat1", "fac1"), df) # TRUE (all categorical)
is_pure_type(c("num1"), df) # TRUE (single)
is_pure_type(c("num1", "cat1"), df) # FALSE (mixed numeric + cat)

Create an Interactive Line Plot with plotly

Description

Generates a customizable interactive line plot using plotly, supporting grouping, faceting, axis adjustments, and color palettes.

Usage

linePlot(
  data,
  x,
  y,
  palette.selection,
  plot.mode = "lines",
  line.type = "solid",
  colour.group.by = NULL,
  show.legend = TRUE,
  facet.by = NULL,
  facet.scales = "fixed",
  subplot.margin = 0.05,
  axis.showline = TRUE,
  axis.mirror = TRUE,
  axis.linecolor = "black",
  axis.linewidth = 0.5,
  axis.tickfont.size = 12,
  axis.tickfont.color = "black",
  axis.tickfont.family = "Arial",
  axis.tickangle.x = 0,
  axis.tickangle.y = 0,
  axis.ticks = "outside",
  axis.tickcolor = "black",
  axis.ticklen = 5,
  axis.tickwidth = 1,
  show.grid.x = TRUE,
  show.grid.y = TRUE,
  title.text = "",
  title.font.size = 14,
  title.font.family = "Arial",
  title.font.color = "black",
  y.title = NULL,
  x.title = NULL,
  flip.x = FALSE,
  flip.y = FALSE,
  x.adjustment = NULL,
  y.adjustment = NULL,
  color.adjustment = NULL,
  order.by = NULL,
  error.colour = NULL,
  error.width = NULL,
  error.bar = FALSE
)

Arguments

Value

A plotly object representing the interactive line plot.

Author(s)

Jacob Martin, Jared Andrews

Examples

palette <- plotthis::palette_list[["Set2"]]
fig <- linePlot(
    data = mtcars,
    x = "cyl",
    y = "mpg",
    plot.mode = "lines",
    line.type = "solid",
    colour.group.by = "mpg",
    palette.selection = palette,
    show.legend = TRUE
)

Create an example Modular linePlot Shiny Application

Description

This function generates a Shiny application with modular linePlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive line plot.

Usage

linePlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with gallery_sales as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

See Also

linePlot(), linePlotInputsUI(), linePlotOutputUI(), linePlotServer()

Examples

library(VizModules)
# Launch with default example data (example_sales):
app <- linePlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- linePlotApp(list("sales" = example_sales))
if (interactive()) runApp(app2)

Input UI components for the linePlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the linePlotServer() and linePlotOutputUI() functions.

Usage

linePlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for linePlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters and defaults

The following linePlot() parameters can be accessed via UI inputs and/or the defaults argument:

• x - X-axis variable(s) (UI: "Select X values", defaults key: x.value, default: 1st column, multiple: TRUE)

• y - Y-axis variable(s) (UI: "Select Y values", defaults key: y.value, default: 2nd column, multiple: TRUE)

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• group.by - Grouping variable (UI: "Group by", default: 1st categorical variable)

• order.by - Order by Y values (UI: "Order by Y", default: FALSE)

• x.adjustment - X-axis adjustment function (UI: "X Adjustment", default: "")

• y.adjustment - Y-axis adjustment function (UI: "Y Adjustment", default: "")

• facet.by - Faceting variable (UI: "Facet by", default: "")

• facet.scales - Facet scale behavior (UI: "Facet scales", default: "fixed")

• plot.mode - Plot type (UI: "Plot type", default: "lines")

• line.type - Line type (UI: "Line type", default: "solid")

• palette.selection - Color palette (UI: palette picker, derived from palette)

• axis.showline - Show axis border lines (UI: "Show Axis Borders", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror Axis Borders", default: TRUE)

• axis.linecolor - Color of axis lines (UI: "Axis Line Color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis Line Width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick Label Size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick Label Color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick Label Font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X Tick Label Angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y Tick Label Angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick Position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick Mark Color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick Mark Length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick Mark Width", default: 1)

• facet.title.font.size - Facet subplot title font size (UI: "Facet Subplot Title Size", default: 18)

• facet.title.font.color - Facet subplot title font color (UI: "Facet Title Color", default: "#000000")

• facet.title.font.family - Facet subplot title font family (UI: "Facet Title Font", default: "Arial")

• show.grid.x - Show X-axis gridlines (UI: "Show X Gridlines", default: TRUE)

• show.grid.y - Show Y-axis gridlines (UI: "Show Y Gridlines", default: TRUE)

• grid.color - Gridline color (UI: "Gridline Color", default: "#CCCCCC")

• x.title - X-axis title (auto-calculated from data)

• y.title - Y-axis title (auto-calculated from data)

• flip.x - Flip X-axis (UI: "Flip X", default: FALSE)

• flip.y - Flip Y-axis (UI: "Flip Y", default: FALSE)

Parameters controlling additional functionality

The following parameters implementing plotly-specific features are also available:

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line Types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line Types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• abline.intercepts - Y-intercepts for diagonal lines (UI: "Y-intercepts", default: "")

• abline.colors - Colors for diagonal lines (UI: "Colors", default: "#000000")

• abline.widths - Widths for diagonal lines (UI: "Widths", default: "1")

• abline.linetypes - Line types for diagonal lines (UI: "Line Types", default: "dashed")

• abline.opacities - Opacities for diagonal lines (UI: "Opacities (0-1)", default: "1")

Author(s)

Jacob Martin, Jared Andrews

See Also

linePlot(), organize_inputs(), linePlotOutputUI(), linePlotServer(), linePlotApp()

Examples

library(VizModules)
data(mtcars)
linePlotInputsUI("linePlot", mtcars)

Output UI components for the linePlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

linePlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the linePlot

Author(s)

Jacob Martin

Server logic for linePlot module

Description

Server logic for linePlot module

Usage

linePlotServer(id, data, hide.inputs = NULL, hide.tabs = NULL, defaults = NULL)

Arguments

Value

The moduleServer function for the linePlot module.

Author(s)

Jacob Martin

See Also

linePlot(), linePlotInputsUI(), linePlotOutputUI(), linePlotApp()

Create standard tack UI for module inputs

Description

Generates a consistent set of control buttons for VizModules that includes Auto Update toggle, Update and Reset buttons, an optional Stats download button, and the "Plotly" tab containing plot margin and shape annotation controls.

Usage

module_tack_ui(ns, defaults = NULL, has.stats = FALSE)

Arguments

Value

A Shiny tagList containing the standard control buttons and inputs.

Author(s)

Jared Andrews

Examples

library(VizModules)
library(shiny)
ns <- NS("myModule")
module_tack_ui(ns)

Compact multi-group color picker input

Description

Build a compact Shiny input that assigns colors to a set of groups using a palette or manual hex pickers. The value returned to input[[inputId]] is a named character vector of hex colors keyed by group.

Usage

multiColorPicker(
  inputId,
  label = NULL,
  groups,
  palette_options = NULL,
  selected_palette = NULL,
  colors = NULL,
  width = NULL,
  show_text = TRUE,
  compact = FALSE,
  panel = TRUE
)

Arguments

Value

A UI element that produces a named character vector of colors.

Author(s)

Jared Andrews

Examples

if (interactive()) {
    library(shiny)
    groups <- c("setosa", "virginica", "versicolor")

    ui <- fluidPage(
        multiColorPicker(
            "species_cols",
            "Species colors",
            groups = groups,
            selected_palette = "dittoColors"
        ),
        verbatimTextOutput("chosen")
    )

    server <- function(input, output, session) {
        output$chosen <- renderPrint(input$species_cols)
    }

    shinyApp(ui, server)
}

Negative log10 transformation

Description

A helper function for -log10 transformation.

Usage

neg_log10(x)

Arguments

Value

-log10(x)

Author(s)

Jared Andrews

Organize arbitrary Shiny inputs into a grid layout

Description

Organize arbitrary Shiny inputs into a grid layout

Usage

organize_inputs(
  tag.list,
  id = NULL,
  title = NULL,
  tack = NULL,
  columns = NULL,
  rows = NULL
)

Arguments

Value

A Shiny tagList with inputs organized into a grid, optionally nested inside a tabsetPanel.

Author(s)

Jared Andrews

Examples

library(VizModules)
# Example 1: Basic usage with a simple grid
ui.inputs <- tagList(
  textInput("name", "Name"),
  numericInput("age", "Age", value = 30),
  selectInput("gender", "Gender", choices = c("Male", "Female", "Other"))
)
organize_inputs(ui.inputs, columns = 2, rows = 2)

# Example 2: Using a named list to create tabs
ui.inputs.tabs <- list(
  Personal = tagList(
    textInput("firstname", "First Name"),
    textInput("lastname", "Last Name")
  ),
  Settings = tagList(
    checkboxInput("newsletter", "Subscribe to newsletter", value = TRUE),
    sliderInput("volume", "Volume", min = 0, max = 100, value = 50)
  )
)
organize_inputs(ui.inputs.tabs, columns = 1)

# Example 3: Adding an additional UI element with 'tack'
additional.ui <- actionButton("submit", "Submit")
organize_inputs(ui.inputs, tack = additional.ui, columns = 3)

# Example 4: Handling a case with more inputs than grid cells
many.inputs <- tagList(replicate(10, textInput("input", "Input")))
organize_inputs(many.inputs, columns = 3) # Creates more than one row

Create an Interactive Parallel Coordinates Plot with plotly

Description

Generates a customizable interactive parallel coordinates plot using plotly, supporting dimension selection, color mapping, and font styling.

Usage

parallelCoordinatesPlot(
  data,
  dimensions,
  color.by = NULL,
  color.scale = "Viridis",
  line.opacity = 0.5,
  line.width = 1,
  show.colorbar = TRUE,
  label.font.size = 12,
  label.font.color = "black",
  label.font.family = "Arial",
  tick.font.size = 10,
  tick.font.color = "black",
  tick.font.family = "Arial",
  title.text = "",
  title.font.size = 16,
  title.font.family = "Arial",
  title.font.color = "black",
  bgcolor = "#FFFFFF"
)

Arguments

Value

A plotly object representing the interactive parallel coordinates plot.

Author(s)

Jacob Martin, Jared Andrews

Examples

fig <- parallelCoordinatesPlot(
    data = mtcars,
    dimensions = c("mpg", "cyl", "disp", "hp", "wt"),
    color.by = "mpg",
    color.scale = "Viridis",
    line.opacity = 0.6
)

Create an example Modular parallelCoordinatesPlot Shiny Application

Description

This function generates a Shiny application with modular parallelCoordinatesPlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive parallel coordinates plot.

Usage

parallelCoordinatesPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with gallery_sales as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

See Also

parallelCoordinatesPlot(), parallelCoordinatesPlotInputsUI(), parallelCoordinatesPlotOutputUI(), parallelCoordinatesPlotServer()

Examples

library(VizModules)
# Launch with default example data:
app <- parallelCoordinatesPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- parallelCoordinatesPlotApp(list("sales" = example_sales))
if (interactive()) runApp(app2)

Input UI components for the parallelCoordinatesPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the parallelCoordinatesPlotServer() and parallelCoordinatesPlotOutputUI() functions.

Usage

parallelCoordinatesPlotInputsUI(
  id,
  data,
  defaults = NULL,
  title = NULL,
  columns = 2
)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for parallelCoordinatesPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters and defaults

The following parallelCoordinatesPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• dimensions - Columns to use as axes (UI: "Select dimensions", multiple: TRUE)

• color.by - Column to color lines by (UI: "Color by", default: "")

• color.scale - Colorscale for lines (UI: "Color scale", default: "Viridis")

• line.opacity - Line opacity (UI: "Line opacity", default: 0.5)

• line.width - Line width (UI: "Line width", default: 1)

• show.colorbar - Show colorbar (UI: "Show colorbar", default: TRUE)

• label.font.size - Dimension label font size (UI: "Label font size", default: 12)

• label.font.color - Dimension label font color (UI: "Label font color", default: "black")

• label.font.family - Dimension label font family (UI: "Label font", default: "Arial")

• tick.font.size - Tick label font size (UI: "Tick font size", default: 10)

• tick.font.color - Tick label font color (UI: "Tick font color", default: "black")

• tick.font.family - Tick label font family (UI: "Tick font", default: "Arial")

• bgcolor - Plot background color (UI: "Background color", default: "#FFFFFF")

Author(s)

Jacob Martin, Jared Andrews

See Also

parallelCoordinatesPlot(), organize_inputs(), parallelCoordinatesPlotOutputUI(), parallelCoordinatesPlotServer(), parallelCoordinatesPlotApp()

Examples

library(VizModules)
parallelCoordinatesPlotInputsUI("parcoords", mtcars)

Output UI components for the parallelCoordinatesPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

parallelCoordinatesPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the parallelCoordinatesPlot

Author(s)

Jacob Martin, Jared Andrews

Server logic for parallelCoordinatesPlot module

Description

Server logic for parallelCoordinatesPlot module

Usage

parallelCoordinatesPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the parallelCoordinatesPlot module.

Author(s)

Jacob Martin, Jared Andrews

See Also

parallelCoordinatesPlot(), parallelCoordinatesPlotInputsUI(), parallelCoordinatesPlotOutputUI(), parallelCoordinatesPlotApp()

Create a plotly pie chart

Description

Create a plotly pie chart

Usage

piePlot(
  df,
  labels,
  values,
  colors = NULL,
  palette = NULL,
  hole = 0,
  textinfo = "label+percent",
  textposition = "auto",
  insidetextorientation = "auto",
  sort = TRUE,
  direction = "counterclockwise",
  rotation = 0,
  show.legend = TRUE,
  legend.orientation = "h",
  legend.x = 0.5,
  legend.y = -0.1,
  legend.font.family = "Arial",
  legend.font.size = 12,
  legend.font.color = "#000000",
  title.text = "",
  title.font.family = "Arial",
  title.font.size = 18,
  title.font.color = "#000000",
  title.x = 0.5,
  text.font.family = "Arial",
  text.font.size = 12,
  text.font.color = "#000000",
  slice.line.color = "#FFFFFF",
  slice.line.width = 0
)

Arguments

Value

A plotly object.

Author(s)

Jacob Martin, Jared Andrews

Examples

status_counts <- data.frame(
    status = c("Upregulated", "Downregulated", "Not significant"),
    n = c(12, 7, 3)
)

piePlot(
    df = status_counts,
    labels = "status",
    values = "n",
    palette = c("#1B9E77", "#D95F02", "#7570B3"),
    sort = FALSE,
    title.text = "Genes by status"
)

Create an example Modular piePlot Shiny Application

Description

This function generates a Shiny application with modular piePlot components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive pie plot.

Usage

piePlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with an aggregated example_sales dataset (revenue by product line). Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

See Also

piePlot(), piePlotInputsUI(), piePlotOutputUI(), piePlotServer()

Examples

library(VizModules)
# Launch with default example data:
app <- piePlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
sales_summary <- aggregate(revenue ~ product_line, example_sales, sum)
app2 <- piePlotApp(list("sales" = sales_summary))
if (interactive()) runApp(app2)

Input UI components for the piePlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the piePlotServer() and piePlotOutputUI() functions.

Usage

piePlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Provide summarized data (one row per slice) with columns for labels and aggregated values. Nearly all parameters for piePlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters and defaults

The following piePlot() parameters can be accessed via UI inputs and/or the defaults argument:

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• labels - Label column (UI: "Label column (summary data)", default: 2nd categorical column)

• values - Aggregated value column (UI: "Aggregated value column", default: 2nd numeric column)

• sort - Sort slices by value (UI: "Sort slices by value", default: TRUE)

• direction - Slice direction (UI: "Slice direction", default: "counterclockwise")

• rotation - Start angle in degrees (UI: "Start angle (degrees)", default: 0)

• hole - Center hole size for donut chart (UI: "Center hole size", default: 0)

• colors - Slice colors (UI: color picker, derived from palette)

• slice.line.color - Slice border color (UI: "Slice border color", default: "#FFFFFF")

• slice.line.width - Slice border width (UI: "Slice border width", default: 0)

• textinfo - Text to show on slices (UI: "Text to show on slices", default: c("label", "value", "percent"))

• textposition - Text position (UI: "Text position", default: "auto")

• insidetextorientation - Inside text orientation (UI: "Inside text orientation", default: "auto")

• text.font.size - Slice text size (UI: "Slice text size", default: 12)

• text.font.family - Slice text font (UI: "Slice text font", default: "Arial")

• text.font.color - Slice text color (UI: "Slice text color", default: "#000000")

• title.x - Title horizontal position (UI: "Title horizontal position", default: 0.5)

• show.legend - Show legend (UI: "Show legend", default: TRUE)

• legend.orientation - Legend orientation (UI: "Legend orientation", default: "h")

• legend.font.family - Legend font (UI: "Legend font", default: "Arial")

• legend.font.size - Legend font size (UI: "Legend font size", default: 12)

• legend.font.color - Legend font color (UI: "Legend font color", default: "#000000")

Author(s)

Jacob Martin, Jared Andrews

See Also

piePlot(), organize_inputs(), piePlotOutputUI(), piePlotServer(), piePlotApp()

Examples

library(VizModules)
pie_df <- as.data.frame(table(iris$Species))
names(pie_df) <- c("Species", "Count")
piePlotInputsUI("piePlot", pie_df)

Output UI components for the piePlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

piePlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the piePlot

Author(s)

Jacob Martin, Jared Andrews

Server logic for piePlot module

Description

Server logic for piePlot module

Usage

piePlotServer(id, data, hide.inputs = NULL, hide.tabs = NULL, defaults = NULL)

Arguments

Value

The moduleServer function for the piePlot module.

Author(s)

Jacob Martin, Jared Andrews

See Also

piePlot(), piePlotInputsUI(), piePlotOutputUI(), piePlotApp()

Create an example Modular AreaPlot Shiny Application

Description

This function generates a Shiny application with modular plotthis::AreaPlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive area plot.

Usage

plotthis_AreaPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with example_sales as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

Examples

library(VizModules)
# Launch with default example data:
app <- plotthis_AreaPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- plotthis_AreaPlotApp(list("sales" = example_sales))
if (interactive()) runApp(app2)

Input UI components for the AreaPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the plotthis_AreaPlotServer() and plotthis_AreaPlotOutputUI() functions.

Usage

plotthis_AreaPlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for plotthis::AreaPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters not implemented or with altered functionality

The following plotthis::AreaPlot() parameters are not available via UI inputs:

• xlab - X-axis label (plotly allows interactive editing)

• ylab - Y-axis label (plotly allows interactive editing)

• title - Plot title (plotly allows interactive editing)

• subtitle - Plot subtitle (not supported in plotly)

• aspect.ratio - Aspect ratio control (handled by plotly layout)

• legend.position - Legend positioning (plotly allows interactive repositioning)

• split_by - Split variable (returns a patchwork object, not supported in plotly), use facet_by instead

• design - Only applies if split_by is used

• split_by_sep - Only applies if split_by is used

• axes - Only applies if split_by is used

• axis_titles - Only applies if split_by is used

• guides - Only applies if split_by is used

• byrow - Only applies if split_by is used

• nrow - Only applies if split_by is used

• ncol - Only applies if split_by is used

• palette - Managed internally via the palette selection UI

• legend_direction - Managed position of legend however this can be handled via plotly

Plot parameters and defaults

The following plotthis::AreaPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• x - X-axis variable (UI: "X values", default: 2nd categorical variable)

• y - Y-axis variable (UI: "Y values", default: 2nd numeric variable)

• group_by - Grouping variable for area fill (UI: "Group by", default: 3rd categorical variable or "")

• facet_by - Faceting variable (UI: "Facet by", default: "")

• facet_scales - Facet scale behavior (UI: "Facet scale", default: "fixed")

• facet_ncol - Number of facet columns (UI: "Facet number of columns", default: NULL)

• facet_nrow - Number of facet rows (UI: "Facet number of rows", default: NULL)

• facet_byrow - Facet ordering direction (UI: "Facet by row", default: TRUE)

• palcolor - Custom color values (UI: palette picker, derived from palette)

• alpha - Area fill transparency (UI: "Alpha", default: 1)

• scale_y - Scale y-axis by total (UI: "Scale y-axis by total", default: FALSE)

Parameters controlling additional functionality

The following parameters implementing new functionality or controlling plotly-specific features are also available:

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show axis lines", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror axis lines", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X major gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y major gridlines", default: TRUE)

• axis.linecolor - Color of axis lines (UI: "Axis line color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis line width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick label size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick label color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick label font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X-axis tick label angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y-axis tick label angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick mark color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick mark length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick mark width", default: 1)

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• abline.intercepts - Y-intercepts for diagonal lines (UI: "Y-intercepts", default: "")

• abline.colors - Colors for diagonal lines (UI: "Colors", default: "#000000")

• abline.widths - Widths for diagonal lines (UI: "Widths", default: "1")

• abline.linetypes - Line types for diagonal lines (UI: "Line types", default: "dashed")

• abline.opacities - Opacities for diagonal lines (UI: "Opacities (0-1)", default: "1")

Author(s)

Jacob Martin, Jared Andrews

See Also

plotthis::AreaPlot(), organize_inputs(), plotthis_AreaPlotOutputUI(), plotthis_AreaPlotServer(), plotthis_AreaPlotApp()

Examples

library(VizModules)
# Needs at least 2 categorical variables for grouping and x-axis
mtcars$cyl <- as.factor(mtcars$cyl)
mtcars$gear <- as.factor(mtcars$gear)
plotthis_AreaPlotInputsUI("areaPlot", mtcars)

Output UI components for the AreaPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

plotthis_AreaPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the AreaPlot

Author(s)

Jacob Martin

Server logic for AreaPlot module

Description

Server logic for AreaPlot module

Usage

plotthis_AreaPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the AreaPlot module.

Author(s)

Jacob Martin, Jared Andrews

Create an example Modular BarPlot Shiny Application

Description

This function generates a Shiny application with modular plotthis::BarPlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive bar plot.

Usage

plotthis_BarPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with example_bar as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

Examples

library(VizModules)
# Launch with default example data:
app <- plotthis_BarPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- plotthis_BarPlotApp(list("Bar" = example_bar))
if (interactive()) runApp(app2)

Input UI components for the BarPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the plotthis_BarPlotServer() and plotthis_BarPlotOutputUI() functions.

Usage

plotthis_BarPlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for plotthis::BarPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters not implemented or with altered functionality

The following plotthis::BarPlot() parameters are not available via UI inputs:

• xlab - X-axis label (plotly allows interactive editing)

• ylab - Y-axis label (plotly allows interactive editing)

• title - Plot title (plotly allows interactive editing)

• subtitle - Plot subtitle (not supported in plotly)

• aspect.ratio - Aspect ratio control (handled by plotly layout)

• legend.position - Legend positioning (plotly allows interactive repositioning)

• position - Bar position (auto, stack, dodge, fill) (not yet implemented)

• position_dodge_preserve - Preserve bar width when dodging (not yet implemented)

• x_sep - Separator for multiple x columns (not yet implemented)

• group_by_sep - Separator for multiple group_by columns (not yet implemented)

• split_by_sep - Separator for multiple split_by columns (not yet implemented)

• flip - Flip axes (not yet implemented)

• fill_by_x_if_no_group - Fill bars by x values (not yet implemented)

• line_name - Name of line (not yet implemented)

• label - Bar labels on top (not yet implemented)

• label_nudge - Label nudge distance (not yet implemented)

• label_fg - Label foreground color (not yet implemented)

• label_size - Label size (not yet implemented)

• label_bg - Label background color (not yet implemented)

• label_bg_r - Label background radius (not yet implemented)

• group_name - Group legend name (not yet implemented)

• facet_args - Additional facet arguments (not yet implemented)

• add_bg - Add background stripes (not yet implemented)

• bg_palette - Background palette (not yet implemented)

• bg_palcolor - Background palette colors (not yet implemented)

• bg_alpha - Background alpha (not yet implemented)

• add_line - Add horizontal line (not yet implemented)

• line_color - Horizontal line color (not yet implemented)

• line_width - Horizontal line width (not yet implemented)

• line_type - Horizontal line type (not yet implemented)

• add_trend - Add trend line (not yet implemented)

• trend_color - Trend line color (not yet implemented)

• trend_linewidth - Trend line width (not yet implemented)

• trend_ptsize - Trend point size (not yet implemented)

• theme - ggplot2 theme (managed internally)

• theme_args - Theme arguments (not yet implemented)

• palette - Managed internally via the palette selection UI

• x_text_angle - X-axis text angle (handled by axis.tickangle.x)

• legend.direction - Legend orientation (plotly allows interactive adjustment)

• keep_empty - Keep empty factor levels (not yet implemented)

• keep_na - Keep NA values (not yet implemented)

• combine - Combine multiple plots (not applicable for plotly)

• nrow - Only applies if split_by is used with combine

• ncol - Only applies if split_by is used with combine

• byrow - Only applies if split_by is used with combine

• seed - Random seed (not applicable)

• axes - Only applies if split_by is used with combine

• axis_titles - Only applies if split_by is used with combine

• guides - Only applies if split_by is used with combine

• design - Only applies if split_by is used with combine

Plot parameters and defaults

The following plotthis::BarPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• x - X-axis variable (UI: "X values", default: 2nd categorical variable)

• y - Y-axis variable (UI: "Y values", default: 2nd numeric variable)

• group_by - Grouping variable for bar fill (UI: "Group by", default: 2nd categorical variable)

• split_by - Split variable for separate plots (UI: "Split by", default: "")

• facet_by - Faceting variable (UI: "Facet by", default: "")

• facet_scales - Facet scale behavior (UI: "Facet scale", default: "fixed")

• facet_ncol - Number of facet columns (UI: "Facet number of columns", default: NULL)

• facet_nrow - Number of facet rows (UI: "Facet number of rows", default: NULL)

• facet_byrow - Facet ordering direction (UI: "Facet by row", default: TRUE)

• palcolor - Custom color values (UI: palette picker, derived from palette)

• alpha - Bar fill transparency (UI: "Alpha", default: 1)

• width - Bar width (UI: "Width", default: NA)

• expand - Axis expansion values (UI: "Expand", default: "")

• y_min - Y-axis minimum value (UI: "Y-axis min", default: 0)

• y_max - Y-axis maximum value (UI: "Y-axis max", default: max of data)

Parameters controlling additional functionality

The following parameters implementing new functionality or controlling plotly-specific features are also available:

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show axis lines", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror axis lines", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X major gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y major gridlines", default: TRUE)

• axis.linecolor - Color of axis lines (UI: "Axis line color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis line width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick label size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick label color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick label font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X-axis tick label angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y-axis tick label angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick mark color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick mark length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick mark width", default: 1)

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• abline.intercepts - Y-intercepts for diagonal lines (UI: "Y-intercepts", default: "")

• abline.colors - Colors for diagonal lines (UI: "Colors", default: "#000000")

• abline.widths - Widths for diagonal lines (UI: "Widths", default: "1")

• abline.linetypes - Line types for diagonal lines (UI: "Line types", default: "dashed")

• abline.opacities - Opacities for diagonal lines (UI: "Opacities (0-1)", default: "1")

Author(s)

Jacob Martin, Jared Andrews

See Also

plotthis::BarPlot(), organize_inputs(), plotthis_BarPlotOutputUI(), plotthis_BarPlotServer(), plotthis_BarPlotApp()

Examples

library(VizModules)
data(mtcars)
plotthis_BarPlotInputsUI("BarPlot", mtcars)

Output UI components for the BarPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

plotthis_BarPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the BarPlot

Author(s)

Jacob Martin, Jared Andrews

Server logic for BarPlot module

Description

Server logic for BarPlot module

Usage

plotthis_BarPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the BarPlot module.

Author(s)

Jacob Martin, Jared Andrews

Create an example Modular BoxPlot Shiny Application

Description

This function generates a Shiny application with modular plotthis::BoxPlot() components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive box plot.

Usage

plotthis_BoxPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with example_demographics as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

Examples

library(VizModules)
# Launch with default example data:
app <- plotthis_BoxPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- plotthis_BoxPlotApp(list("demographics" = example_demographics))
if (interactive()) runApp(app2)

Input UI components for the BoxPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the plotthis_BoxPlotServer() and plotthis_BoxPlotOutputUI() functions.

Usage

plotthis_BoxPlotInputsUI(id, data, defaults = NULL, title = NULL, columns = 2)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for plotthis::BoxPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters not implemented or with altered functionality

The following plotthis::BoxPlot() parameters are not available via UI inputs:

• xlab - X-axis label (plotly allows interactive editing)

• ylab - Y-axis label (plotly allows interactive editing)

• title - Plot title (plotly allows interactive editing)

• subtitle - Plot subtitle (not supported in plotly)

• aspect.ratio - Aspect ratio control (handled by plotly layout)

• legend.position - Legend positioning (plotly allows interactive repositioning)

• x_sep - Separator for x columns (not applicable in UI context)

• in_form - Data input format (not applicable - always long form)

• split_by - Split variable (returns a patchwork object, not supported in plotly), use facet_by instead

• split_by_sep - Only applies if split_by is used

• symnum_args - Significance symbol arguments (not implemented)

• flip - Flip axes (not implemented in current UI)

• keep_empty - Keep empty values (not implemented)

• keep_na - Keep NA values (not implemented)

• group_by_sep - Separator for group columns (not applicable in UI context)

• group_name - Group legend name (handled by plotly)

• paired_by - Pairing variable for paired tests (not implemented)

• x_text_angle - X-axis text angle (handled by plotly axis settings)

• step_increase - Step increase for significance brackets (not implemented)

• fill_mode - Fill mode for grouped data (handled automatically)

• fill_reverse - Reverse fill order (not implemented)

• theme - ggplot2 theme (not applicable in plotly)

• theme_args - Theme arguments (not applicable in plotly)

• palette - Managed internally via the palette selection UI

• alpha - Alpha transparency (not implemented in UI)

• stack - Stack boxplots (not implemented)

• add_beeswarm - Add beeswarm points (not implemented in UI)

• beeswarm_method - Beeswarm arrangement method (not implemented)

• beeswarm_cex - Beeswarm point size factor (not implemented)

• beeswarm_priority - Beeswarm priority order (not implemented)

• beeswarm_dodge - Beeswarm dodge width (not implemented)

• add_trend - Add trend line (not implemented in UI)

• trend_color - Trend line color (not implemented)

• trend_linewidth - Trend line width (not implemented)

• trend_ptsize - Trend point size (not implemented)

• add_stat - Add statistical annotation (not implemented)

• stat_name - Statistical test name (not implemented)

• stat_color - Statistical annotation color (not implemented)

• stat_size - Statistical annotation size (not implemented)

• stat_stroke - Statistical annotation stroke (not implemented)

• stat_shape - Statistical annotation shape (not implemented)

• add_bg - Add background shading (not implemented)

• bg_palette - Background palette (not implemented)

• bg_palcolor - Background color (not implemented)

• bg_alpha - Background transparency (not implemented)

• add_line - Add horizontal line (not implemented in UI - use Lines tab)

• line_color - Line color (not implemented)

• line_width - Line width (not implemented)

• line_type - Line type (not implemented)

• comparisons - Group comparisons for significance tests (not implemented)

• ref_group - Reference group for comparisons (not implemented)

• pairwise_method - Pairwise test method (not implemented)

• multiplegroup_comparisons - Multiple group comparison flag (not implemented)

• multiple_method - Multiple group test method (not implemented)

• sig_label - Significance label format (not implemented)

• sig_labelsize - Significance label size (not implemented)

• hide_ns - Hide non-significant comparisons (not implemented)

• seed - Random seed (not applicable)

• combine - Only applies if split_by is used

• nrow - Only applies if split_by is used

• ncol - Only applies if split_by is used

• byrow - Only applies if split_by is used

• axes - Only applies if split_by is used

• axis_titles - Only applies if split_by is used

• guides - Only applies if split_by is used

• legend_direction - Managed position of legend however this can be handled via plotly

Plot parameters and defaults

The following plotthis::BoxPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• x - X-axis variable (UI: "X data", default: 2nd categorical variable)

• y - Y-axis variable (UI: "Y data", default: 2nd numeric variable)

• group_by - Grouping variable (UI: "Group by", default: "")

• sort_x - Sort X-axis by statistic (UI: "Sort X by", default: "")

• y_max - Maximum Y-axis value (UI: "Max Value of Y Axis", default: calculated)

• y_min - Minimum Y-axis value (UI: "Min Value of Y Axis", default: calculated)

• add_point - Add jitter points (UI: "Add Jitter Points", default: FALSE)

• pt_size - Point size (UI: "Point Size", default: 1)

• pt_alpha - Point transparency (UI: "Point Alpha", default: 1)

• jitter_width - Jitter width (UI: "Jitter Width", default: 0.3)

• pt_color - Point outline color (UI: "Point Outline Colour", default: "#000000")

• highlight - Highlight condition (UI: "Highlight", default: "")

• highlight_color - Highlight color (UI: "Highlight Colour", default: "#000000")

• highlight_size - Highlight size (UI: "Highlight Size", default: 1)

• highlight_alpha - Highlight transparency (UI: "Highlight Alpha", default: 1)

• facet_by - Faceting variable (UI: "Facet by", default: "")

• facet_scales - Facet scale behavior (UI: "Facet Scale", default: "fixed")

• facet_ncol - Number of facet columns (UI: "Columns", default: NULL)

• facet_nrow - Number of facet rows (UI: "Rows", default: NULL)

• facet_byrow - Facet ordering direction (UI: "Facet by Row", default: TRUE)

• palcolor - Custom color values (UI: palette picker, derived from palette)

Parameters controlling additional functionality

The following parameters implementing new functionality or controlling plotly-specific features are also available:

• boxplot.width - Width of boxplot (UI: "Boxplot Width", default: 0.8)

• show.outliers - Show outlier points (UI: "Show Outliers", default: TRUE)

• axis.title.font.size - Axis title font size (UI: "Axis title size", default: 18)

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show axis lines", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror axis lines", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X major gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y major gridlines", default: TRUE)

• axis.linecolor - Color of axis lines (UI: "Axis line color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis line width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick label size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick label color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick label font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X-axis tick label angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y-axis tick label angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick mark color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick mark length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick mark width", default: 1)

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• abline.intercepts - Y-intercepts for diagonal lines (UI: "Y-intercepts", default: "")

• abline.colors - Colors for diagonal lines (UI: "Colors", default: "#000000")

• abline.widths - Widths for diagonal lines (UI: "Widths", default: "1")

• abline.linetypes - Line types for diagonal lines (UI: "Line types", default: "dashed")

• abline.opacities - Opacities for diagonal lines (UI: "Opacities (0-1)", default: "1")

Author(s)

Jacob Martin, Jared Andrews

See Also

plotthis::BoxPlot(), organize_inputs(), plotthis_BoxPlotOutputUI(), plotthis_BoxPlotServer(), plotthis_BoxPlotApp()

Examples

library(VizModules)
data(mtcars)
plotthis_BoxPlotInputsUI("BoxPlot", mtcars)

Output UI components for the BoxPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

plotthis_BoxPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the boxPlot

Author(s)

Jacob Martin

Server logic for BoxPlot module

Description

Server logic for BoxPlot module

Usage

plotthis_BoxPlotServer(
  id,
  data,
  hide.inputs = NULL,
  hide.tabs = NULL,
  defaults = NULL
)

Arguments

Value

The moduleServer function for the BoxPlot module.

Author(s)

Jacob Martin, Jared Andrews

Create an example Modular DensityPlot Shiny Application

Description

This function generates a Shiny application with modular density plot components. The app features a Data Import section for uploading data, a Data Table for filtering the active dataset, and a Plot area for configuring and displaying an interactive density plot.

Usage

plotthis_DensityPlotApp(data_list = NULL)

Arguments

Details

When data_list is not provided (or NULL), the app launches with example_demographics as an example dataset. Uploaded data files are added to the available datasets and can be selected for plotting. If an uploaded file shares a name with an existing dataset, the existing one is overwritten with a warning.

This is a convenience wrapper around createModuleApp().

Value

A Shiny app object.

Author(s)

Jacob Martin, Jared Andrews

Examples

library(VizModules)
# Launch with default example data:
app <- plotthis_DensityPlotApp()
if (interactive()) runApp(app)

# Launch with custom data:
app2 <- plotthis_DensityPlotApp(list("demographics" = example_demographics))
if (interactive()) runApp(app2)

Input UI components for the DensityPlot module

Description

This should be placed in the UI where the inputs should be shown, with an id that matches the id used in the plotthis_DensityPlotServer() and plotthis_DensityPlotOutputUI() functions.

Usage

plotthis_DensityPlotInputsUI(
  id,
  data,
  defaults = NULL,
  title = NULL,
  columns = 2
)

Arguments

Details

The user inputs for this module are separated from the outputs to allow for more flexible UI design.

The inputs will automatically be organized into a grid layout via the organize_inputs() function, with columns controlling the number of columns in the grid.

Defaults can be set for each input by providing a named list of values to the defaults argument. Nearly all parameters for plotthis::DensityPlot() can be set via these inputs, so see the help for that function for an exhaustive list.

Value

A Shiny tagList containing the UI elements

Plot parameters not implemented or with altered functionality

The following plotthis::DensityPlot() parameters are not available via UI inputs:

• xlab - X-axis label (plotly allows interactive editing)

• ylab - Y-axis label (plotly allows interactive editing)

• title - Plot title (plotly allows interactive editing)

• subtitle - Plot subtitle (not supported in plotly)

• legend.position - Legend positioning (plotly allows interactive repositioning)

• group_by_sep - Separator for group columns (not applicable in UI context)

• group_name - Group legend name (handled by plotly)

• xtrans - X-axis transformation (not implemented in UI)

• ytrans - Y-axis transformation (not implemented in UI)

• split_by - Split variable (returns a patchwork object, not supported in plotly), use facet_by instead

• split_by_sep - Only applies if split_by is used

• flip - Flip axes (not implemented in current UI)

• theme - ggplot2 theme (not applicable in plotly)

• theme_args - Theme arguments (not applicable in plotly)

• palette - Managed internally via the palette selection UI

• expand - Axis expansion (not implemented)

• seed - Random seed (not applicable)

• combine - Only applies if split_by is used

• nrow - Only applies if split_by is used

• ncol - Only applies if split_by is used

• byrow - Only applies if split_by is used

• axes - Only applies if split_by is used

• axis_titles - Only applies if split_by is used

• guides - Only applies if split_by is used

• design - Only applies if split_by is used

• legend_direction - Managed position of legend however this can be handled via plotly

Plot parameters and defaults

The following plotthis::DensityPlot() parameters can be accessed via UI inputs and/or the defaults argument:

• x - X-axis variable (UI: "X Data", default: 2nd numeric variable)

• group_by - Grouping variable (UI: "Group By", default: "")

• position - Position adjustment (UI: "Position", default: "identity")

• alpha - Density fill transparency (UI: "Plot Alpha", default: 0.5)

• add_bars - Add rug plot (UI: "Add Rug Plot", default: FALSE)

• bar_height - Rug bar height (UI: "Rug Bar Height", default: 0.04)

• bar_alpha - Rug bar transparency (UI: "Rug Bar Alpha", default: 1)

• bar_width - Rug bar width (UI: "Rug Bar Width", default: 1)

• facet_by - Faceting variable (UI: "Facet By", default: "")

• facet_scales - Facet scale behavior (UI: "Facet Scale", default: "fixed")

• facet_ncol - Number of facet columns (UI: "Number of Columns", default: NULL)

• facet_nrow - Number of facet rows (UI: "Number of Rows", default: NULL)

• facet_byrow - Facet ordering direction (UI: "Facet by Row", default: TRUE)

• palcolor - Custom color values (UI: palette picker, derived from palette)

Parameters controlling additional functionality

The following parameters implementing new functionality or controlling plotly-specific features are also available:

• title.font.size - Plot title font size (UI: "Title Size", default: 26)

• title.font.family - Font family for title text (UI: "Title Font", default: "Arial")

• title.font.color - Color for plot title (UI: "Title Color", default: "#000000")

• axis.title.font.size - Axis title font size (UI: "Axis Title Size", default: 18)

• axis.title.font.color - Axis title font color (UI: "Axis Title Color", default: "#000000")

• axis.title.font.family - Axis title font family (UI: "Axis Title Font", default: "Arial")

• axis.showline - Show axis border lines (UI: "Show axis lines", default: TRUE)

• axis.mirror - Mirror axis lines on opposite side (UI: "Mirror axis lines", default: TRUE)

• show.grid.x - Show X-axis major gridlines (UI: "Show X major gridlines", default: TRUE)

• show.grid.y - Show Y-axis major gridlines (UI: "Show Y major gridlines", default: TRUE)

• axis.linecolor - Color of axis lines (UI: "Axis line color", default: "black")

• axis.linewidth - Width of axis lines (UI: "Axis line width", default: 0.5)

• axis.tickfont.size - Size of tick labels (UI: "Tick label size", default: 12)

• axis.tickfont.color - Color of tick labels (UI: "Tick label color", default: "black")

• axis.tickfont.family - Font family for tick labels (UI: "Tick label font", default: "Arial")

• axis.tickangle.x - Rotation angle for X-axis tick labels (UI: "X-axis tick label angle", default: 0)

• axis.tickangle.y - Rotation angle for Y-axis tick labels (UI: "Y-axis tick label angle", default: 0)

• axis.ticks - Position of tick marks (UI: "Tick position", default: "outside")

• axis.tickcolor - Color of tick marks (UI: "Tick mark color", default: "black")

• axis.ticklen - Length of tick marks (UI: "Tick mark length", default: 5)

• axis.tickwidth - Width of tick marks (UI: "Tick mark width", default: 1)

• hline.intercepts - Y-coordinates for horizontal reference lines (UI: "Y-intercepts", default: "")

• hline.colors - Colors for horizontal lines (UI: "Colors", default: "#000000")

• hline.widths - Widths for horizontal lines (UI: "Widths", default: "1")

• hline.linetypes - Line types for horizontal lines (UI: "Line types", default: "dashed")

• hline.opacities - Opacities for horizontal lines (UI: "Opacities (0-1)", default: "1")

• vline.intercepts - X-coordinates for vertical reference lines (UI: "X-intercepts", default: "")

• vline.colors - Colors for vertical lines (UI: "Colors", default: "#000000")

• vline.widths - Widths for vertical lines (UI: "Widths", default: "1")

• vline.linetypes - Line types for vertical lines (UI: "Line types", default: "dashed")

• vline.opacities - Opacities for vertical lines (UI: "Opacities (0-1)", default: "1")

• abline.slopes - Slopes for diagonal reference lines (UI: "Slopes", default: "")

• abline.intercepts - Y-intercepts for diagonal lines (UI: "Y-intercepts", default: "")

• abline.colors - Colors for diagonal lines (UI: "Colors", default: "#000000")

• abline.widths - Widths for diagonal lines (UI: "Widths", default: "1")

• abline.linetypes - Line types for diagonal lines (UI: "Line types", default: "dashed")

• abline.opacities - Opacities for diagonal lines (UI: "Opacities (0-1)", default: "1")

Author(s)

Jacob Martin, Jared Andrews

See Also

plotthis::DensityPlot(), organize_inputs(), plotthis_DensityPlotOutputUI(), plotthis_DensityPlotServer(), plotthis_DensityPlotApp()

Examples

library(VizModules)
data(mtcars)
plotthis_DensityPlotInputsUI("densityPlot", mtcars)

Output UI components for the DensityPlot module

Description

This should be placed in the UI where the plot should be shown.

Usage

plotthis_DensityPlotOutputUI(id)

Arguments

Value

A Shiny plotlyOutput for the DensityPlot

Author(s)

Jacob Martin

Density Plot Server Module