vignettes/processmapr.rmd
processmapr.rmdThe processmapR package provids functions for creating process maps and precedence diagrams. For more information, please check <www.bupar.net>.
+The processmapR package provids functions for creating process maps +and precedence diagrams. For more information, please check +<www.bupar.net>.
Gert Janssenswillen. Author, maintainer. +
+Gerard van Hulzen. Contributor. +
+Benoît Depaire. Contributor. +
+Felix Mannhardt. Contributor. +
+Thijs Beuving. Contributor. +
+urvikalia. Contributor. +
+DESCRIPTION
Gert Janssenswillen. Author, maintainer. -
-Benoît Depaire. Contributor. -
-Felix Mannhardt. Contributor. -
-Thijs Beuving. Contributor. -
-Janssenswillen G (2022). +processmapR: Construct Process Maps Using Event Data. +https://bupar.net/, https://github.com/bupaverse/processmapr/. +
+@Manual{,
+ title = {processmapR: Construct Process Maps Using Event Data},
+ author = {Gert Janssenswillen},
+ year = {2022},
+ note = {https://bupar.net/, https://github.com/bupaverse/processmapr/},
+}
Function to create a custom map profile based on some event log attribute.
-custom(FUN = mean, attribute, units = "", color_scale = "PuBu")- -
| FUN | -A summary function to be called on the provided event attribute, e.g. mean, median, min, max. na.rm = T by default. |
-
|---|---|
| attribute | -The name of the case attribute to visualize (should be numeric) |
-
| units | -Character to be placed after values (e.g. EUR for monitary euro values) |
-
| color_scale | -Name of color scale to be used for nodes. Defaults to PuBu. See `Rcolorbrewer::brewer.pal.info()` for all options. |
-
custom(
+ FUN = mean,
+ attribute,
+ units = "",
+ color_scale = "PuBu",
+ color_edges = "dodgerblue4"
+)If used for edges, it will show the attribute values which related to the out-going node of the edge.#'
- +A summary function to be called on the provided event attribute, e.g. mean, median, min, max. na.rm = T by default.
# NOT RUN { -library(eventdataR) -library(processmapR) -data(traffic_fines) -# make sure the amount attribute is propagated forward in each trace -# using zoo::na.locf instead of tidyr::fill since it is much faster -# still the whole pre-processing is still very slow -library(zoo) - -traffic_fines_prepared <- traffic_fines %>% -filter_trace_frequency(percentage = 0.8) %>% -group_by_case() %>% -mutate(amount = na.locf(amount, na.rm = F)) %>% -ungroup_eventlog() - -process_map(traffic_fines_prepared, type_nodes = custom(attribute = "amount", units = "EUR")) -# }--
The name of the case attribute to visualize (should be numeric)
Character to be placed after values (e.g. EUR for monitary euro values)
Name of color scale to be used for nodes. Defaults to PuBu. See `Rcolorbrewer::brewer.pal.info()` for all options.
The color used for edges. Defaults to dodgerblue4.
If used for edges, it will show the attribute values which related to the out-going node of the edge.#'
+if (FALSE) {
+library(eventdataR)
+library(processmapR)
+data(traffic_fines)
+# make sure the amount attribute is propagated forward in each trace
+# using zoo::na.locf instead of tidyr::fill since it is much faster
+# still the whole pre-processing is still very slow
+library(zoo)
+
+traffic_fines_prepared <- traffic_fines %>%
+filter_trace_frequency(percentage = 0.8) %>%
+group_by_case() %>%
+mutate(amount = na.locf(amount, na.rm = F)) %>%
+ungroup_eventlog()
+
+process_map(traffic_fines_prepared, type_nodes = custom(attribute = "amount", units = "EUR"))
+}
+
+Create a dotted chart to view all events in a glance
-dotted_chart(eventlog, x, sort, color, units, ...) ++-# S3 method for eventlog -dotted_chart(eventlog, x = c("absolute", "relative", - "relative_week", "relative_day"), sort = c("start", "end", "duration", - "start_week", "start_day"), color = NULL, units = c("weeks", "days", - "hours", "mins", "secs"), ...) ++idotted_chart(eventlog, plotly = FALSE) + +iplotly_dotted_chart(eventlog) + +plotly_dotted_chart( + eventlog, + x = c("absolute", "relative", "relative_week", "relative_day"), + sort = c("start", "end", "duration", "start_week", "start_day"), + color = NULL, + units = c("weeks", "days", "hours", "mins", "secs"), + ... +) + +dotted_chart( + log, + x = c("absolute", "relative", "relative_week", "relative_day"), + sort = NULL, + color = NULL, + units = NULL, + add_end_events = F, + eventlog = deprecated(), + ... +) + +# S3 method for eventlog +dotted_chart( + log, + x = c("absolute", "relative", "relative_week", "relative_day"), + sort = NULL, + color = NULL, + units = NULL, + add_end_events = F, + eventlog = deprecated(), + ... +) + +# S3 method for activitylog +dotted_chart( + log, + x = c("absolute", "relative", "relative_week", "relative_day"), + sort = NULL, + color = NULL, + units = NULL, + add_end_events = F, + eventlog = deprecated(), + ... +) + +# S3 method for grouped_eventlog +dotted_chart( + log, + x = c("absolute", "relative", "relative_week", "relative_day"), + sort = NULL, + color = NULL, + units = NULL, + add_end_events = F, + eventlog = deprecated(), + ... +) + +# S3 method for grouped_activitylog +dotted_chart( + log, + x = c("absolute", "relative", "relative_week", "relative_day"), + sort = NULL, + color = NULL, + units = NULL, + add_end_events = F, + eventlog = deprecated(), + ... +)+-Arguments
+
- eventlog
+- -# S3 method for grouped_eventlog -dotted_chart(eventlog, x = c("absolute", - "relative", "relative_week", "relative_day"), sort = c("start", "end", - "duration", "start_week", "start_day"), color = NULL, units = c("weeks", - "days", "hours", "mins", "secs"), ...) -idotted_chart(eventlog, plotly = FALSE) +
Deprecated. Use log instead.
- plotly
+- -iplotly_dotted_chart(eventlog) -plotly_dotted_chart(eventlog) - -
Return plotly object
Arguments
--
- -- - -eventlog -- Eventlog object
- -x -- Value for plot on x-axis: absolute time or relative time (since start, since start of week, since start of day)
- -sort -- Ordering of the cases on y-axis: start, end or duration
- -color -- Optional, variable to use for coloring dots. Default is the activity identifier. Use NA for no colors.
- -units -- Time units to use on x-axis in case of relative time.
- -... -- Deprecated arguments
- -plotly -- Return plotly object
Methods (by class)
+- x
+- -
Value for plot on x-axis: absolute time or relative time (since start, since start of week, since start of day)
-
- -- -
eventlog: Dotted chart for event log- -
grouped_eventlog: Dotted chart for grouped event log-+Contents
--
+- Arguments
- -- Methods (by class)
-sort ++ + + Ordering of the cases on y-axis: start, end or duration, start_week, start_day
color ++ + + Optional, variable to use for coloring dots. Default is the activity identifier. Use NA for no colors.
units ++ + + Time units to use on x-axis in case of relative time.
... ++ + + Deprecated arguments
log ++ + +
log: Object of classlogor derivatives (grouped_log,eventlog,activitylog, etc.).add_end_events ++ + Whether to add dots for the complete lifecycle event with a different shape.
+Methods (by class)
+ +
- +
eventlog: Create dotted chart for eventlog- +
activitylog: Create dotted chart for activitylog- +
grouped_eventlog: Create dotted chart for grouped eventlog- +
grouped_activitylog: Create dotted chart for grouped activitylog
These objects are imported from other packages. Follow the links +below to see their documentation.
+A graph object of class `dgr_graph`.
The name of the exported file (including it's extension).
The type of file to be exported. Options for graph files +are: `png`, `pdf`, `svg`, and `ps`.
An optional title for the output graph.
Output width in pixels or `NULL` for default. Only useful for +export to image file formats `png`, `pdf`, `svg`, and `ps`.
Output height in pixels or `NULL` for default. Only useful for +export to image file formats `png`, `pdf`, `svg`, and `ps`.
Function to create a frequency profile for a process map.
-frequency(value = c("absolute", "relative", "absolute_case", "relative_case"), - color_scale = "PuBu")- -
| value | -The type of frequency value to be used: -absolute, relative (percentage of activity instances) or relative_case (percentage of cases the activity occurs in). |
-
|---|---|
| color_scale | -Name of color scale to be used for nodes. Defaults to PuBu. See `Rcolorbrewer::brewer.pal.info()` for all options. |
-
frequency(
+ value = c("absolute", "relative", "absolute-case", "relative-case",
+ "relative-antecedent", "relative-consequent"),
+ color_scale = "PuBu",
+ color_edges = "dodgerblue4"
+)The type of frequency value to be used: +absolute, relative (percentage of activity instances) or relative_case (percentage of cases the activity occurs in).
Name of color scale to be used for nodes. Defaults to PuBu. See `Rcolorbrewer::brewer.pal.info()` for all options.
The color used for edges. Defaults to dodgerblue4.
R/get_meta_data.R
+ get_activities.RdGet data values for activities and flows from process map
+get_activities(process_map)
+
+get_flows(process_map)An object created using process_map function. Can both be a rendered or not rendered object.
- All functions+
| |||||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
+
|
+ Lined chart |
+ ||||||||||||||||||||||||||||||||||||||||||||
|
+
|
+ Dotted chart |
+ ||||||||||||||||||||||||||||||||||||||||||||
| + + | +Widget output function for use in Shiny |
+ ||||||||||||||||||||||||||||||||||||||||||||
| + + | +Widget render function for use in Shiny |
+ ||||||||||||||||||||||||||||||||||||||||||||
Configure layout parameters for process map
+layout_pm(fixed_positions = NULL, edge_weight = FALSE, edge_cutoff = 0)When specified as a data.frame with three columns 'act', 'x', and 'y' the position of nodes is fixed. Note that using this option switches to the 'neato' layout engine.
When `TRUE` then the frequency with which an edge appears in the process map has influence on the process map layout. Edges with higher frequency get higher priority in the layout algorithm, which increases the visibility of 'process highways'. Note that this has no effect when using the 'fixed_positions' parameters.
Edges that appear in the process map below this frequency are not considered at all when calculating the layout. This may create very long and complicated edge routings when choosen too high. Note that this has no effect when using the 'fixed_positions' parameters.
Create a lined chart to view all cases at a glance
+lined_chart(
+ log,
+ x = c("absolute", "relative"),
+ sort = NULL,
+ color,
+ units,
+ line_width = 2,
+ plotly,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for eventlog
+lined_chart(
+ log,
+ x = c("absolute", "relative"),
+ sort = NULL,
+ color = NULL,
+ units = c("weeks", "days", "hours", "mins", "secs"),
+ line_width = 2,
+ plotly = FALSE,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for activitylog
+lined_chart(
+ log,
+ x = c("absolute", "relative"),
+ sort = NULL,
+ color = NULL,
+ units = c("weeks", "days", "hours", "mins", "secs"),
+ line_width = 2,
+ plotly = FALSE,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for grouped_eventlog
+lined_chart(
+ log,
+ x = c("absolute", "relative"),
+ sort = NULL,
+ color = NULL,
+ units = c("weeks", "days", "hours", "mins", "secs"),
+ line_width = 2,
+ plotly = FALSE,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for grouped_activitylog
+lined_chart(
+ log,
+ x = c("absolute", "relative"),
+ sort = NULL,
+ color = NULL,
+ units = c("weeks", "days", "hours", "mins", "secs"),
+ line_width = 2,
+ plotly = FALSE,
+ eventlog = deprecated(),
+ ...
+)
+
+ilined_chart(eventlog, plotly = FALSE)
+
+iplotly_lined_chart(eventlog)
+
+plotly_lined_chart(eventlog, color = NULL, ...)log: Object of class log or derivatives (grouped_log, eventlog, activitylog, etc.).
Value for plot on x-axis: absolute time or relative time (since start, since start of week, since start of day)
Ordering of the cases on y-axis: start, end or duration, start_week, start_day
Optional. Should be a case attribute! No coloring applied by default.
Time units to use on x-axis in case of relative time.
The width of lines
Return plotly object
Eventlog object
Deprecated arguments
eventlog: Create lined chart for eventlog
activitylog: Create lined chart for activity log
grouped_eventlog: Create lined chart for grouped eventlog
grouped_activitylog: Create lined chart for grouped activitylog
Function to create a performance map profile to be used as the type of a process map. It results in a process map describing process time.
-performance(FUN = mean, units = "days", flow_time = c("idle_time", - "inter_start_time"), color_scale = "Reds")- -
| FUN | -A summary function to be called on the process time of a specific activity, e.g. mean, median, min, max |
-
|---|---|
| units | -The time unit in which processing time should be presented (mins, hours, days, weeks) |
-
| flow_time | -The time to depict on the flows: the inter start time is the time between the start timestamp of consecutive activity instances, -the idle time is the time between the end and start time of consecutive activity instances. |
-
| color_scale | -Name of color scale to be used for nodes. Defaults to Reds. See `Rcolorbrewer::brewer.pal.info()` for all options. |
-
A summary function to be called on the process time of a specific activity, e.g. mean, median, min, max
The time unit in which processing time should be presented (mins, hours, days, weeks, months, quarters, semesters, years. A month is defined as 30 days. A quarter is 13 weeks. A semester is 26 weeks and a year is 365 days
The time to depict on the flows: the inter start time is the time between the start timestamp of consecutive activity instances, +the idle time is the time between the end and start time of consecutive activity instances.
Name of color scale to be used for nodes. Defaults to Reds. See `Rcolorbrewer::brewer.pal.info()` for all options.
The color used for edges. Defaults to red4.
Additional arguments too FUN
Visualize a precendence matrix. A generic plot function for precedences matrices.
+# S3 method for process_matrix
+plot(x, ...)Precedence matrix
Additional paramters
A ggplot object, which can be customized further, if deemed necessary.
+Construct a precendence matrix, showing how activities are followed by each other.
- +`r lifecycle::badge("deprecated")`
+ This function is deprecated and replaced by the process_matrix function, which shared the same usage with process_map
precedence_matrix(eventlog, type = c("absolute", "relative", - "relative_antecedent", "relative_consequent", "relative_case"))- -
| eventlog | -The event log object to be used |
-
|---|---|
| type | -The type of precedence matrix, which can be absolulte, relative, relative_antecedent or relative_consequent. Absolute will return -a matrix with absolute frequencies, relative will return global relative frequencies for all antecedent-consequent pairs. -Relative_antecedent will return relative frequencies within each antecendent, i.e. showing the relative proportion of consequents within each antecedent. Relative_consequent will do the reverse. |
-
precedence_matrix(
+ eventlog,
+ type = c("absolute", "relative", "relative-antecedent", "relative-consequent",
+ "relative-case")
+)# NOT RUN { -library(eventdataR) -data(patients) -precedence_matrix(patients) -# }--
The event log object to be used
The type of precedence matrix, which can be absolulte, relative, relative-antecedent or relative-consequent. Absolute will return +a matrix with absolute frequencies, relative will return global relative frequencies for all antecedent-consequent pairs. +Relative-antecedent will return relative frequencies within each antecendent, i.e. showing the relative proportion of consequents within each antecedent. +Relative-consequent will do the reverse.
if (FALSE) {
+library(eventdataR)
+data(patients)
+precedence_matrix(patients)
+}
+Construct a precedence matrix, showing how activities are followed by each other.
+This function computes the precedence matrix directly in C++ for efficiency.
+Only the type `absolute` of (precedence_matrix) is supported.
precedence_matrix_absolute(eventlog, lead = 1)The event log object to be used.
The distance between activities following/preceding each other.
Widget output function for use in Shiny
+processMapOutput(outputId, width = "100%", heigth = "400px")Output variable to read from.
A valid CSS unit for the width or a number, +which will be coerced to a string and have px appended.
A valid CSS unit for the height or a number, +which will be coerced to a string and have px appended.
A function for creating a process map of an event log.
-process_map(eventlog, type = frequency("absolute"), type_nodes = type, - type_edges = type, rankdir = "LR", render = T, fixed_edge_width = F, - ...)- -
| eventlog | -The event log object for which to create a process map |
-
|---|---|
| type | -A process map type, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time. |
-
| type_nodes | -A process map type to be used for nodes only, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time. |
-
| type_edges | -A process map type to be used for edges only, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time. |
-
| rankdir | -The direction in which to layout the graph: "LR" (default),"TB", "BT", "RL", corresponding to directed graphs drawn from top to bottom, from left to right, from bottom to top, and from right to left, respectively. |
-
| render | -Whether the map should be rendered immediately (default), or rather an object of type dgr_graph should be returned. |
-
| fixed_edge_width | -If TRUE, don't vary the width of edges. |
-
| ... | -Deprecated arguments |
-
process_map(
+ log,
+ type = frequency("absolute"),
+ sec = NULL,
+ type_nodes = type,
+ type_edges = type,
+ sec_nodes = sec,
+ sec_edges = sec,
+ rankdir = "LR",
+ render = T,
+ fixed_edge_width = F,
+ layout = layout_pm(),
+ fixed_node_pos = NULL,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for eventlog
+process_map(
+ log,
+ type = frequency("absolute"),
+ sec = NULL,
+ type_nodes = type,
+ type_edges = type,
+ sec_nodes = sec,
+ sec_edges = sec,
+ rankdir = "LR",
+ render = T,
+ fixed_edge_width = F,
+ layout = layout_pm(),
+ fixed_node_pos = NULL,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for grouped_eventlog
+process_map(
+ log,
+ type = frequency("absolute"),
+ sec = NULL,
+ type_nodes = type,
+ type_edges = type,
+ sec_nodes = sec,
+ sec_edges = sec,
+ rankdir = "LR",
+ render = T,
+ fixed_edge_width = F,
+ layout = layout_pm(),
+ fixed_node_pos = NULL,
+ eventlog = deprecated(),
+ ...
+)
+
+# S3 method for activitylog
+process_map(
+ log,
+ type = frequency("absolute"),
+ sec = NULL,
+ type_nodes = type,
+ type_edges = type,
+ sec_nodes = sec,
+ sec_edges = sec,
+ rankdir = "LR",
+ render = T,
+ fixed_edge_width = F,
+ layout = layout_pm(),
+ fixed_node_pos = NULL,
+ eventlog = deprecated(),
+ ...
+)# NOT RUN { -library(eventdataR) -data(patients) -process_map(patients) -# }-
log: Object of class log or derivatives (grouped_log, eventlog, activitylog, etc.).
A process map type, which can be created with the functions frequency, performance and custom. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time. The third one allows custom attributes to be used.
A secondary process map type. Values are shown between brackets.
A process map type to be used for nodes only, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time.
A process map type to be used for edges only, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time.
A secondary process map type for nodes only.
A secondary process map type for edges only.
The direction in which to layout the graph: "LR" (default),"TB", "BT", "RL", corresponding to directed graphs drawn from top to bottom, from left to right, from bottom to top, and from right to left, respectively.
Whether the map should be rendered immediately (default), or rather an object of type dgr_graph should be returned.
If TRUE, don't vary the width of edges.
List of parameters influencing the (automatic) layout of the process map. Use layout_pm to create a suitable parameter list.
Deprecated, please use the 'layout' parameter instead.
Deprecated. Use log instead.
Deprecated arguments
eventlog: Process map for event log
grouped_eventlog: Process map for event log
activitylog: Process map for activitylog
if (FALSE) {
+library(eventdataR)
+data(patients)
+process_map(patients)
+}
+
+Create process matrix
+log: Object of class log or derivatives (grouped_log, eventlog, activitylog, etc.).
A process matrix type, which can be created with the functions frequency, performance and custom. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time. The third one allows custom attributes to be used.
Other arguments
Deprecated. Use log instead.
eventlog: Process matrix for event log
activitylog: Process matrix for activity log
This package provides several useful techniques process visualization.
-Widget render function for use in Shiny
+renderProcessMap(expr, env = parent.frame(), quoted = FALSE)an expression that generates a DiagrammeR graph.
the environment in which to evaluate expr.
is expr a quoted expression (with quote())? +This is useful if you want to save an expression in a variable.
A function for creating a resource map of an event log based on handover of work.
-resource_map(eventlog, type = frequency("absolute"), render = T, ...)- -
| eventlog | -The event log object for which to create a resource map |
-
|---|---|
| type | -A process map type, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time. |
-
| render | -Whether the map should be rendered immediately (default), or rather an object of type dgr_graph should be returned. |
-
| ... | -Deprecated arguments |
-
resource_map(log, type, render, ..., eventlog = deprecated())
+
+# S3 method for eventlog
+resource_map(
+ log,
+ type = frequency("absolute"),
+ render = T,
+ ...,
+ eventlog = deprecated()
+)
+
+# S3 method for activitylog
+resource_map(
+ log,
+ type = frequency("absolute"),
+ render = T,
+ ...,
+ eventlog = deprecated()
+)log: Object of class log or derivatives (grouped_log, eventlog, activitylog, etc.).
A process map type, which can be created with the functions frequency and performance. The first type focusses on the frequency aspect of a process, while the second one focussed on processing time.
# NOT RUN { -library(eventdataR) -data(patients) -resource_map(patients) -# }-
Whether the map should be rendered immediately (default), or rather an object of type dgr_graph should be returned.
Deprecated arguments
Deprecated. Use log instead.
eventlog: Create resource map for eventlog
activitylog: Create resource map for activity log
if (FALSE) {
+library(eventdataR)
+data(patients)
+resource_map(patients)
+}
+Construct a resource matrix, showing how work is handed over
-resource_matrix(eventlog, type = c("absolute", "relative", - "relative_antecedent", "relative_consequent"))- -
| eventlog | -The event log object to be used |
-
|---|---|
| type | -The type of resource matrix, which can be absolulte, relative, relative_antecedent or relative_consequent. Absolute will return +
+
+
+
+ Arguments+
|
-
# NOT RUN { -library(eventdataR) -data(patients) -precedence_matrix(patients) -# }--
eventlog: Resource matrix of event log
activitylog: Resource matrix of activity log
if (FALSE) {
+library(eventdataR)
+data(patients)
+precedence_matrix(patients)
+}
+
+Explore traces, ordered by relative trace frequency
-trace_explorer(eventlog, coverage = 0.2, type = c("frequent", "infrequent"), - .abbreviate = T, scale_fill = scale_fill_discrete(h = c(0, 360) + 15, l = - 40), raw_data = F)- -
| eventlog | -Eventlog object |
-
|---|---|
| coverage | -The percentage coverage of the trace to explore. Default is 20% most (in)frequent |
-
| type | -Frequent or infrequenct traces to explore |
-
| .abbreviate | -If TRUE, abbreviate activity labels |
-
| scale_fill | -Set color scale |
-
| raw_data | -Return raw data |
-
trace_explorer(
+ log,
+ coverage = NULL,
+ n_traces = NULL,
+ type = c("frequent", "infrequent"),
+ coverage_labels = c("relative", "absolute", "cumulative"),
+ .abbreviate = T,
+ show_labels = T,
+ label_size = 3,
+ scale_fill = processmapR:::scale_fill_discrete_bupaR(),
+ raw_data = F,
+ eventlog = deprecated()
+)
+
+# S3 method for eventlog
+trace_explorer(
+ log,
+ coverage = NULL,
+ n_traces = NULL,
+ type = c("frequent", "infrequent"),
+ coverage_labels = c("relative", "absolute", "cumulative"),
+ .abbreviate = T,
+ show_labels = T,
+ label_size = 3,
+ scale_fill = processmapR:::scale_fill_discrete_bupaR(),
+ raw_data = F,
+ eventlog = deprecated()
+)
+
+# S3 method for activitylog
+trace_explorer(
+ log,
+ coverage = NULL,
+ n_traces = NULL,
+ type = c("frequent", "infrequent"),
+ coverage_labels = c("relative", "absolute", "cumulative"),
+ .abbreviate = T,
+ show_labels = T,
+ label_size = 3,
+ scale_fill = processmapR:::scale_fill_discrete_bupaR(),
+ raw_data = F,
+ eventlog = deprecated()
+)
+
+plotly_trace_explorer(
+ eventlog,
+ coverage = NULL,
+ n_traces = NULL,
+ type = c("frequent", "infrequent"),
+ coverage_labels = c("relative", "absolute", "cumulative"),
+ .abbreviate = T,
+ show_labels = T,
+ label_size = 3,
+ scale_fill = processmapR:::scale_fill_discrete_bupaR(),
+ raw_data = F
+)log: Object of class log or derivatives (grouped_log, eventlog, activitylog, etc.).
The percentage coverage of the trace to explore. Default is 20% most (in)frequent
Instead of setting coverage, you can set an exact number of traces. Should be an integer larger than 0.
Frequent traces first, or infrequent traces first?
Change the labels to be shown on the right of the process variants. These can be relative frequency (default), absolute, or cumulative.
If TRUE, abbreviate activity labels
If False, activity labels are not shown.
Font size of labels
Set color scale
Return raw data
Deprecated. Use log instead.
eventlog: Trace explorer eventlog
activitylog: Trace explorer activity log