La vidéo suivante montre CUBR-CORE, la brique technologique développée par CUBR, en pleine action pour la visualisation de séquences.

Elle montre d’une part l’utilisation de l’API R permettant d’utiliser CUBR-CORE au travers d’une interface R Shiny, et d’autre part illustre la puissance de traitement de CUBR-CORE pour générer des visualisations de séquences, de la même manière que le font les outils TraMineR et EventFlow.

On y voit notamment la capacité de CUBR-CORE à gérer des volumétries de données importantes que les autres outils ne permettent pas d’atteindre, et cela en des temps de traitement très rapides.

Et voici le code R nécessaire pour cette application R Shiny.

On observera notamment (en vert dans le code) les appels aux web services CUBR qui sont effectués dans la partie serveur de l’application.

library(shiny)
library(shinyWidgets)
library(cubr)

###############################################################################
# UI
###############################################################################
ui = fluidPage (

    titlePanel ("CUBR-CORE : integration with R Shiny for sequences visualization"),

    sidebarPanel (width = 2,

        uiOutput ("sources"),

        pickerInput ("selectVariables", 
            h3("variables"), 
            choices  = c(), 
            options  = list(`actions-box` = TRUE), 
            multiple = T
        ),

        radioButtons ("visumode", 
            h3("visualization mode"), 
            selected="traminer", 
            c("TraMineR" = "traminer", "EventFlow" = "eventflow" )
        ),

        verbatimTextOutput ("logs"),
    ),

    mainPanel (width = 6, imageOutput("graphic") )
)

###############################################################################
# SERVER
###############################################################################
buildImage = function(input, output, cubr, variables)
{
    # we update the image
    renderImage (
    {
        width  = 1500
        height = 1000
        svg    = paste ("<svg width='", width, "px' height='", height, "'></svg>")

       # we call the required CUBR function ('traminer' or 'eventflow')
        result = cubr$seqviz (
            mode      = input$visumode, 
            variables = variables, 
            width     = width, 
            height    = height, 
            output    = "svg"
        )

        # the svg is received encoded in base64, so we decode it now
        svg = jsonlite::base64_dec (result$svg)

        # we display some information about the execution 
        output$logs = renderText (
            jsonlite::toJSON(result$stats,auto_unbox=TRUE,pretty=TRUE)
        )

        # we create a temporary file for the svg 
        outfile <- tempfile(fileext='.svg')

        # we save the svg into a file
        writeBin (svg, con = outfile)

        list (src = normalizePath(outfile), 
            contentType = 'image/svg+xml', 
            width       = width, 
            height      = height
        )
    },
    deleteFile=TRUE)
}

server = function(input, output, session)
{
    # we instanciate the Cubr class
    cubr = Cubr$new (server="http://someaddress:7080")

    # we update the SelectInput with the found databases
    output$sources <- renderUI (
    {   
        selectInput('sourcesSelect', 
            label   = h3('input'),  
            choices = cubr$databases)   
    })

    observe(
    {
        source <- input$sourcesSelect

        if (is.null(source)==FALSE && source!="")
        {
            # we open the selected data source
            result = cubr$open (source)

            # we update the variables selectInput with the found variables
            updatePickerInput (
                session, 
                "selectVariables", 
                choices  = result$variables, 
                selected = result$variables
            )

            # we update the image
            output$graphic = buildImage (
                input, 
                output, 
                cubr, 
                result$variables
            )
        }
    })

    observe(
    {
        if (is.null(input$selectVariables)==FALSE)   
        {  
            output$graphic = buildImage (
                input, 
                output, 
                cubr, 
                input$selectVariables
            )  
        }
    })
}


###############################################################################
# RUN
###############################################################################
runApp (shinyApp(ui = ui, server = server), port=7575);