R

RCura

@RCura·73 public vizzes

Loading thumbnail…

Gist c11433a697bc7660ed4cde37278fb580

This example demonstrates how to query a DuckDB database from R using the `dbplyr` and `duckdb` packages, showing the results of a simple aggregation of railway station data grouped by country. The code first creates an in-memory DuckDB connection, defines a view over a CSV file containing station information, and registers it as a tibble. It then performs a grouped count operation using dplyr verbs, which is lazily translated to SQL, and finally materializes the result locally with `collect()`. The output displays the number of stations per country, revealing a clear geographic distribution across European nations.

Loading thumbnail…

OSM download

This example maps individual trees in a Brussels area by querying OpenStreetMap data through the Overpass API. The R script constructs an Overpass query for nodes tagged `natural=tree`, retrieves the JSON response, and uses `jsonlite` and `purrr` to extract the elements. It then converts the longitude and latitude coordinates into a simple features object with `st_as_sf`, projecting them to EPSG 4326 for spatial handling. The resulting data is ready for plotting as point geometries.

Loading thumbnail…

Densité des Comtés US

This visualization maps the population density of US counties, with color intensity representing inhabitants per square kilometer. Built using R with the `tidyverse` and `sf` libraries, it downloads county boundaries from the US Census TIGER/Line shapefile and joins them with population estimates from the Census Bureau’s 2018 county data. The `st_area` function computes each county’s area, then divides total population by area to derive density values, resulting in a choropleth map displayed via geographic rendering.

Loading thumbnail…

test calendar

This example displays a year of tide predictions for L’Herbaudière as an interactive calendar. It maps each day to a grid cell, with the timing of high and low tides encoded as positioned marks that trace the rhythmic progression through the months. The visualization processes an ICS file containing hourly tide coefficients and event descriptions from the French hydrographic service (SHOM). It uses d3.timeFormat and d3.scaleTime to parse dates and position events, while d3.select and SVG rect elements render the calendar cells and tide markers.

Loading thumbnail…

logos trivial pursuit

This visualization recreates the classic Trivial Pursuit board game, showing six category wedges—arts, divertissement, geography, history, science, and sport—arranged in a circular layout. Each category is represented by a distinct SVG icon and a larger background variant, all rendered with the same blue circular token and pie-piece shapes. The SVG files are created with Inkscape, using precise path data and transform matrices to position each element. The display combines individual category icons with their corresponding background panels, offering a complete visual reference for the game’s components.

Loading thumbnail…

encadre_latex.tex

This example defines a reusable LaTeX environment for creating formatted text boxes, or “encadrés,” within a thesis document. It uses the `tcolorbox` package to draw a framed box with a white background and a black border, and integrates with the `cleveref` package through `\crefformat` and `\Crefformat` to generate cross-references. The code shows how to customize the box’s appearance, such as removing rounded corners and setting title styling, and includes commented usage instructions for creating labeled boxes and citing them in the text. The source is a gist by RCura.

Loading thumbnail…

sector-ize a circle

This example shows how to partition a circle into equal-area sectors by generating a Voronoi diagram from points sampled along the circle’s perimeter. The R code uses the `sf` package to create a buffered point as the base circle, then samples 72 evenly spaced points via `st_line_sample`. A Voronoi tessellation is computed with `st_voronoi`, clipped to the circle’s boundary using `st_intersection`, and rendered with `plot`. The technique demonstrates a geometric method for dividing a polygon into radial segments without angular math.

Loading thumbnail…

Parcoords : rotate axis title + wrap long titles

This example demonstrates an interactive parallel coordinates plot where each dimension’s axis title is rotated and wrapped onto multiple lines using a custom `wrap` function. The visualization uses D3 v3 to render SVG paths for car data from “cars.csv,” with grey background lines for context and steelblue foreground lines that can be filtered by brushing each axis. Users can drag axes to reorder dimensions via `d3.behavior.drag`, and the code applies a transition animation on drag end. The implementation relies on `d3.svg.axis`, `d3.svg.line`, and ordinal/linear scales.

Loading thumbnail…

Connexion à PostgreSQL + histogramme avec ggplot2

This example demonstrates how to create a histogram directly from a PostgreSQL database table using R. The code first establishes a database connection with the `DBI` and `RPostgreSQL` packages, then uses `dplyr` and `dbplyr` to query the table as a remote data frame. The `ggplot2` library renders the histogram via `geom_histogram`, mapping a specified column to the aesthetic. Finally, the connection is explicitly closed with `dbDisconnect`. The code illustrates a workflow for plotting distributed data without loading it entirely into local memory.

Loading thumbnail…

Gist dc8496d6b8cca60c4b5adb58c173b1d6

This example demonstrates the initial data-wrangling steps for a visualization of a Cape Town flight dataset. It shows how raw, comma-delimited text data is read into R and then split into separate data frames based on a record-type code in the first column. The code uses the `readr` package’s `read_delim` function to ingest the file, and the `dplyr` package’s `filter`, `mutate`, and `select` verbs to isolate rows with codes 3, 4, and 5, adding a sequential ID and retaining specific column subsets for each code type. The resulting tidy data frames are primed for subsequent plotting or analysis.

Loading thumbnail…

test

This slide deck is a presentation on the history of cartography. It introduces the speaker and topic with a title slide and a second slide demonstrating the use of the Gaia theme's centering feature for slides containing only headings. The code builds its slides using the Marp Markdown format, incorporating elements like `gaia` and `template` directives, as well as an embedded GIF image. The presentation is generated from a plain text file, with each slide’s content defined by Markdown syntax and metadata in the YAML header.

Loading thumbnail…

Comparing the performances of various DBMS using dplyr for large-ish data

This example compares the execution times of data manipulation operations across different database management systems using the `dplyr` and `dbplyr` R packages. It benchmarks a `group_by` with `summarise` and a `left_join` with `mutate` on a 50-million-row tibble, running the same queries against in-memory data frames, SQLite databases (in-memory and file-based), and PostgreSQL. The code uses `system.time` to measure the elapsed user and system times for each operation, recording results in a benchmark summary table. The visualization highlights performance differences across database backends for typical data wrangling tasks.

Loading thumbnail…

Gist 294bf474d3283271f3e967f4e15f0d03

This example runs a sensitivity analysis on a GAMA agent-based model, testing a wide range of parameter values to assess their influence on simulation outcomes. It defines dozens of parameter ranges (e.g., distances, probabilities, counts) via R’s `seq()` function, then generates an XML experiment plan for headless GAMA simulations, launched in parallel across 24 cores using a Bash script with `taskset`. The visualization itself is not produced here; the code focuses on experimental setup and parameter sampling.

Loading thumbnail…

Exemple simple d'analyse de la base SIRENE

This example analyzes the French SIRENE business registry to show the evolution of company creation rates per department over time. It highlights how the proportion of new companies varies across regions, with each department plotted as its own colored line. Using R and the tidyverse suite, the code reads a zipped CSV file via `read_csv2` and `read_csv2_chunked`, filtering for Île-de-France businesses before aggregating counts by year and department with dplyr verbs. The final ggplot2 chart uses `geom_smooth` to display smoothed trends, scaled as percentages.

Loading thumbnail…

Benchmarking leaflet.extras::addHeatmap vs leaflet.extras::addWebGLHeatmap

This example benchmarks the performance of two Leaflet heatmap rendering methods, `addHeatmap` and `addWebGLHeatmap`, across point datasets of increasing size from 10,000 to 2 million points. Using R’s `microbenchmark` package, it compares the time to load pages containing these visualizations in the browser, with results showing the standard heatmap consistently outperforms the WebGL version for all tested dataset sizes. The rendered output uses Leaflet and the `leaflet.extras` package, with the analysis displayed via R markdown and `ggplot2`.

Loading thumbnail…

Gist 03036b5ca710d61f0c01100a46ef7c7f

This WebGL heatmap displays the spatial density of 500,000 randomly generated geographical points centered on Paris, using a dark CartoDB basemap. The visualization shows how point density concentrates toward the city center, with the heatmap intensity representing the Gaussian-distributed sample data. The example demonstrates the `addWebGLHeatmap` function from the `leaflet.extras` package, which relies on the Leaflet mapping library and WebGL rendering for GPU-accelerated heatmap visualization, with size and unit parameters controlling the point radius in pixels.

Loading thumbnail…

Gist 8f728d205de3c03b7c142233a826e3ab

This example displays a WebGL heatmap of a large simulated point cloud centered on Paris, using 100,000 generated longitude and latitude coordinates. It shows density distribution through a glowing overlay on a dark CartoDB.DarkMatter tile map. The visualization is rendered with the `leaflet` and `leaflet.extras` R packages, specifically `addWebGLHeatmap`, which leverages WebGL for efficient GPU-accelerated rendering. The data is produced via `rnorm` and `sample_n` from `dplyr`, highlighting performance with large spatial datasets.

Loading thumbnail…

Gist cf5cdef5ed7f63fb3d441e306d7febe3

A heatmap of 500,000 simulated points clusters in Paris, displayed as a WebGL layer over a dark CartoDB map. The visualization samples 10,000 points, using leaflet and leaflet.extras to render the heatmap with pixel-based sizes. The data is randomly generated from a normal distribution around Paris's geographic center, and the rendering leverages WebGL for performance. The basemap and heatmap are combined using the `addProviderTiles` and `addWebGLHeatmap` functions.

Loading thumbnail…

Gist 8bd1d36a9319f79fcf719eda3682b1d1

This example visualizes 500,000 randomly generated geographic points centered on Paris as a density heatmap. The code uses the `leaflet` package with the `addHeatmap` function to render the distribution, displaying points over a CartoDB DarkMatter tile layer. Data is synthesized using `rnorm` and sampled into smaller sets with `dplyr`’s `sample_n`. The visualization shows how a large point cloud condenses into a bright core with fading edges, demonstrating leaflet’s heatmap capabilities for large datasets.

Loading thumbnail…

Gist a45ccfaa221afabc16fb47a80eaca35e

This visualization displays a heatmap of simulated GPS point density across Paris, generated from a normally distributed sample of 500,000 coordinates. The map uses the `leaflet` R package’s `addHeatmap` function, which renders point intensity using a radius of 10 and full opacity, over a CartoDB DarkMatter tile layer. The data is drawn from a subset of 100,000 points, plotted via the Leaflet JavaScript library’s heatmap extension. The visualization reveals the spatial clustering of the synthetic data around the city center, with density fading toward the outskirts.

Loading thumbnail…

Gist 200bd2c1c57a4ce6cd078df504f0f65b

This example demonstrates a heatmap overlay on a dark CartoDB basemap, showing the density of simulated point data concentrated around a central Paris location. The visualization is created with R, using the `leaflet` and `leaflet.extras` packages, specifically the `addHeatmap` function with a fixed radius and intensity. The code generates three normally distributed random samples (500k, 100k, and 10k points) with `rnorm`, but displays only the small sample. The rendering relies on Leaflet’s tile-based map and heatmap smoothing, with point aggregation creating a glowing density surface over the geographic area.

Loading thumbnail…

Latex to md

This example demonstrates the conversion of a LaTeX document into GitHub-flavored Markdown using the command-line tool `pandoc`, with the output being a structured text file containing statistical data and tables. The converted content describes a data visualization application for analyzing census data, including univariate and bivariate statistics, typologies, segregation indices, and trajectories. The document lists data sources from the US Bureau of Census and GeoLytics, and includes tables detailing variables such as ethno-racial composition, age, education, and income, along with tables of variable identifiers and descriptions. The conversion preserves the original document’s headings, tables, and emphasis formatting while adapting it to Markdown syntax.

Loading thumbnail…

Gist c79174d3aea74aceb6f8c93df6bb7332

This gallery example presents a LaTeX table that documents the data sources for four statistical variables—ethno-racial belonging, age, education level, and income—across four census years (1980, 1990, 2000, 2010). The table, defined using the `tabular` environment with `p{}` column specifications, cites specific U.S. Census files and American Community Survey datasets for each variable and year. It highlights the evolution of data collection methodologies, such as the shift from decennial census short-form and long-form data to the 5-year ACS estimates, showing how source provenance changes over time. The rendering relies on standard LaTeX table formatting (`\hline`, `\caption`) to structure the metadata clearly.

Loading thumbnail…

Code_folding not working

This example demonstrates a failure of code folding in an R Markdown document rendered with the `rmdformats::readthedown` output format. The page displays a simple R chunk computing `1 + 1`, but the `code_folding: hide` option in the YAML header does not hide the source code as intended. The document is generated via `knitr` and Pandoc, using the `rmdformats` package with the `kate` highlight style, producing a static HTML report.

Loading thumbnail…

Gist 2e92f7659a37c0aad9b95cd210fa517e

This Shiny app displays two ggplot2 scatterplots of the mtcars dataset, comparing engine cylinders and weight against miles per gallon, with point size controlled by a slider. The plot’s color scale represents weight (wt) as a continuous variable, and a shared legend is extracted and repositioned using a custom grid_arrange_shared_legend function built with grid and gridExtra. The server renders both plots inside a single output, pulling the legend from a grob via ggplotGrob. The UI uses a sidebar slider to adjust the point size interactively.

Loading thumbnail…

Gist 05f4cffac50217bd0c33a538cb013563

This example visualizes geographic routing and geocoding workflows in R, showing how spatial data can be processed and mapped. It installs and loads packages for text mining, word clouds, and interactive map viewing, including `ggplot2`, `tm`, `wordcloud`, and `RColorBrewer` for static and corpus-based visualizations. The code also integrates the `photon` and `osrm` packages via `devtools` to access geocoding and routing APIs, enabling point-and-route calculations. The visualization pipeline combines spatial operations with text analytics, demonstrating a multi-step data enrichment and mapping process.

Loading thumbnail…

test R animation

This animated R plot builds a starfield-like scene on a dark blue canvas, where 30 white points cascade downward row by row while a single colored point traces a random walk across the space. Two rotating labels—"Joyeux Anniversaire" and "Paul"—spin around the center, with their hue and size shifting over time. The animation uses the `animation` package’s `ani.options` and `ani.pause` to control frames, with base R graphics for drawing points, text, and axes. Random values come from `runif` and `sample`, and colors are generated via `rainbow`.

Loading thumbnail…

fresh block

A world map of countries is rendered as SVG paths using D3's `d3.geo.equirectangular` projection and `d3.geo.path` tool, colored light gray except for those with authority data, which are filled with a lighter orange. Clicking a country zooms in via a D3 transition on the `g` group, and a text zone updates with the country's name, linking to its grid authority URL if available. The interaction relies on `d3.behavior.zoom` to handle pan and zoom, with the map data sourced from an external `grid_countries.txt` file containing GeoJSON.

Loading thumbnail…

clem2

This interactive meta-analysis dashboard visualizes 1,135 Zipf’s law coefficient estimates from 61 studies, covering over 80 countries and 400 years. Users explore how the estimated slope varies by territory, specification, and publication source through summary tables, scatterplots, and histograms. Built with R Shiny, the interface uses `selectInput`, `conditionalPanel`, and `dataTableOutput` to filter and display results, drawing from a GitHub-hosted dataset by Clémentine Cottineau. The app supports switching between Lotka and Pareto regression forms and includes a literature overview with top journals, authors, and country-level dispersion metrics.

Loading thumbnail…

tooltip examples

This example demonstrates three ways to attach explanatory tooltips to Shiny input widgets within a single user interface. Using `shinyBS`, it shows a basic tooltip on a numeric input, a tooltip initialized with the `tipify` function, and an explicitly defined tooltip triggered with a `bsTooltip` call. The Shiny app also renders a histogram of the Old Faithful geyser eruption data, with the plot output reacting to the numeric inputs. The tooltips clarify the meaning of the income-related input fields.

Loading thumbnail…

correction du script d'Hélène

The visualization maps the proximity and connectivity between towboat trajectories, showing clusters of vessels that travel within 250 meters of each other. The R script uses the `igraph` library to construct a directed graph from pairwise Euclidean distances, calculating out-degree and identifying connected components. It also relies on `reshape2`'s `melt` function to reshape the distance matrix into long format for temporal filtering. The display focuses on the network structure of close encounters, with cluster sizes and node connectivity derived from the graph analysis.

Loading thumbnail…

Gist de70ab070f96fd7c413f

This GAMA model benchmarks four spatial query methods—`closestTo`, `optimClosestTo`, `minDistance`, and `basicClosestTo`—across varying agent population sizes and geometry usage. It compares execution times for high- and low-caller/called agent counts, with optional circular geometries for agents, using `machine_time` for timing. The simulation outputs performance ratios per cycle, demonstrating how each method scales under different spatial configurations and query loads.

Loading thumbnail…

Wrong performances of the closest_to operator in Gama 1.7 (dev)

This example benchmarks the performance of three different methods for finding the nearest neighbor among agents in the Gama 1.7 platform: the built-in `closest_to` operator, an optimized variant using `at_distance`, and a manual `minDistance` calculation via distance collection. It measures execution time across four population-size scenarios, from 100 to 10,000 calling and called agents, writing the results to the console. The code uses Gama’s agent-based modeling API, including `create`, `ask`, `machine_time`, and spatial queries like `closest_to` and `at_distance`. The visualization demonstrates how algorithmic choice and agent density affect computational performance.

Loading thumbnail…

circularbrush.filter

This radial chart uses a D3.js circular brush to filter daily weather data for New York City. The chart displays temperature ranges across the year with color-coded bands for records, averages, and current year values. Users can interactively resize a circular brush overlay to select specific date ranges, and the `d3.svg.circularbrush` API's `filter` method efficiently returns only the data points falling within the brushed arc. The visualization is rendered as an SVG using D3's projection and scaling utilities.

Loading thumbnail…

Gama : batch mode errors

This example compares two GAMA batch-mode experiments, “Bugged” and “Working,” that simulate a simple infection spreading among 300 moving people. It shows how a subtle output error—plotting the count of immune agents instead of infected ones—yields a misleading chart, while the corrected version tracks the actual infection count. Both experiments use GAMA’s `chart` display with a series type and `value:` data source, repeated five times with fixed seeds. The model relies on GAMA’s `people` species with `skills:[moving]` and the `wander` reflex for spatial dynamics.

Loading thumbnail…

Patch for Issue #1268 of Gama

This patch for Gama issue #1268 shows the addition of four feature definitions to the Eclipse RCP product configuration: `ummisco.gama.feature.models`, `ummisco.gama.feature.dependencies`, `ummisco.gama.feature.opengl.jogl2`, and `ummisco.gama.feature.core`. The diff modifies the product file `gama1.7.Eclipse3_8_2.product` to include these features, which bundle dependencies and core GAMA modules. It also trims the `feature.xml` for dependencies by removing redundant plugin declarations and metadata from the feature manifest. The change becomes visible through the modified product and feature XML structures.

Loading thumbnail…

Gist 574dec8723e067b3b901

This visualization displays the ideological positions of legislators based on their voting records, projected into a two-dimensional coordinate space. Using R with the `rollcall` and `oc` functions, it performs optimal classification to map legislators onto two dimensions. The output shows each legislator's coordinates and volume measures, revealing clusters of similar voting behavior. The underlying data comes from 9 votes, with coordinates calculated through multidimensional scaling, enabling viewers to identify political groupings and outliers.

Loading thumbnail…

OC bug

This example visualizes legislative voting patterns by plotting legislators in a two-dimensional coordinate space based on their roll-call votes. The chart reveals how legislators cluster or diverge, with varying point sizes and colors indicating their voting volume and alignment on yea/nay issues. The underlying data comes from a small voting matrix processed through the `rollcall` and `oc` functions in R’s `pscl` and `oc` packages, which perform optimal classification scaling. The gist outputs the computed coordinates (`coord1D`, `coord2D`) and vote statistics, while the plot itself is rendered from that tabular result.

Loading thumbnail…

ggvis issue - multiple layers on different dataset

This example shows a correspondence analysis of three random normal variables, with points colored by cluster and overlaid with 70% confidence ellipses. It first builds the analysis in R using `ade4`'s `dudi.coa`, then computes clusters via `hclust` and ellipses with the `ellipse` package. The visualization attempts to combine both layers in `ggvis`, using `layer_points` for the observations and `layer_paths` for the ellipses, but reveals a known issue where `group_by` on the path layer is not respected when mixing data frames, leaving the ellipses ungrouped in the final plot.

Loading thumbnail…

Gist f3b3c7d224f1701a9d7f

This Shiny application lets a user upload a CSV file of XY coordinates, which are then read with the built-in `read.table` function and converted into a spatial points object using `SpatialPointsDataFrame` from the `sp` package. The app renders a basic scatterplot of these points via `plot()` and offers a download button that exports the coordinates as an ESRI Shapefile using `writeOGR` from `rgdal`, zipping the resulting files for delivery. The interface is built with `bootstrapPage` and `fileInput`, and it validates that data has been selected before plotting.

Loading thumbnail…

Shiny : Bug with updateSliderInput()

This Shiny application demonstrates a bug in dynamic tab creation where `updateSliderInput()` fails to properly synchronize the displayed value. It shows an interactive interface with a sidebar for adding “select” or “slider” tabs, each containing an input and a reactive text output. The code uses Shiny’s `renderUI`, `observe`, `reactiveValues`, and `updateSliderInput`/`updateSelectInput` APIs, along with `tabsetPanel` and `tabPanel`, to manage dynamically generated tabs whose settings are stored per-tab. The bug manifests when a slider tab’s value is changed, as the renderUI does not reflect the update.

Loading thumbnail…

Shiny / R : csv to shapefile

This Shiny/R application demonstrates a straightforward conversion of CSV point data into an interactive map and downloadable ESRI shapefile. Users upload a CSV file, which is read via `read.table` and converted into a spatial points data frame using `SpatialPointsDataFrame` from the `sp` package, with optional CRS assignment commented out. The coordinates are plotted using base R’s `plot` function, while the `writeOGR` function from `rgdal` exports the data as a shapefile, which is then zipped and served through a `downloadButton` wrapped in a `downloadHandler`.

Loading thumbnail…

Shp download

This example demonstrates a Shiny app feature that lets users download the current map view as a Shapefile and CSV. It shows how an interactive R-based mapping interface can package its underlying geographic data for external use. The code defines a `downloadHandler` that cleans up old temporary files, uses `writeOGR` from the `rgdal` library to create the Shapefile, writes a CSV with `write.csv`, and compresses everything into a ZIP archive with the `zip` function. The handler dynamically generates the download by referencing the `getGeoContent()` object, which contains both spatial and attribute data.

Loading thumbnail…

Gist 9622037

This interactive Shiny application plots geographic data onto a web map, scaling point markers according to a selected attribute. Users choose latitude and longitude columns to position points and adjust the maximum point size via a slider. The interface is built with Shiny widgets, including selectInput and sliderInput, while the map itself is rendered using an HTML output that likely integrates a JavaScript mapping library. A secondary plot, generated with ggplot2, is also included. The code relies on Shiny's server-side plotting and reactive input handling to update both the interactive map and the static plot.

Loading thumbnail…

Gist 9587685

This example maps user-uploaded shapefiles by plotting their polygon boundaries in a main panel. It uses R’s `shiny` framework with `server.R` and `ui.R` files, relying on the `maptools` library’s `readShapePoly` function to load the spatial data. A reactive `uploadShpfile` expression handles file renaming and directory switching for multiple uploaded components, while `renderPlot` and `plotOutput` display the resulting map. The interface provides a sidebar `fileInput` for selecting shapefiles and a central plot area for visualization.

Loading thumbnail…

Gist 9496726

This example displays a MapBox base map using a GDAL WMS configuration that defines a TMS service, projecting the entire world in EPSG:3857 with tile levels up to 18. The XML file specifies the server URL, data window boundaries, and 256x256 pixel blocks with three color bands, effectively rendering satellite or street imagery as a raster layer. The visualization relies on GDAL’s WMS driver to fetch tiles from MapBox’s servers, with a cache enabled for performance. It does not use JavaScript libraries like d3 or Three.js, focusing instead on a server-side tile definition for seamless map display.

Loading thumbnail…

Align table and buttons in Shiny

This example demonstrates how to align a table with columns of action buttons inside a Shiny app. It uses the `shinyUI` and `shinyServer` functions from the Shiny package, with `renderUI` and `renderTable` to dynamically generate a numeric table and vertical button groups. The `uiOutput` elements are placed side-by-side using inline CSS styling and Bootstrap `span` classes, allowing the plus and minus buttons to align vertically with each row of the table. The number of rows is controlled by a `numericInput`.

Loading thumbnail…

Gist 6112949

This interactive map displays U.S. state data, with each state represented as a point whose radius encodes the Murder rate and whose fill color is assigned via a gradient. Clicking a feature opens a popup table listing all attributes, including population, income, and life expectancy. Built with R Shiny, the UI integrates OpenLayers and OpenStreetMap scripts via HTML tags, while the embedded JavaScript vector layer reads inline GeoJSON-like feature data.

Loading thumbnail…

Gist 6105613

This example demonstrates a common error-handling scenario in R’s `brew` templating system, where a template is processed into a text connection. The code attempts to render a map template by calling `brew(mapTemplate, output=textConnection("outputObj"))`, but it fails because the output connection is not writeable. The visualization shows the resulting error message, which indicates that `textConnection()` must be opened in write mode. The example uses the `brew` package’s API to highlight how improper connection handling leads to runtime failures in R’s templating workflow.

Loading thumbnail…

Gist 6105524

This interactive map displays U.S. state-level statistics from the `states` dataset, with circle size scaled by murder rate and color encoding each state. Built with OpenLayers, it uses a WMS base layer and a vector layer with fixed point features. Selecting a point opens a framed cloud popup listing attributes like population, income, and life expectancy, using the `OpenLayers.Popup.FramedCloud` API and a select control.

Loading thumbnail…

Gist 6105510

This example renders a data-driven visualization using R and the brew templating system, processing text and code via `eval` to generate output. It demonstrates programmatic document composition, where the `brew.cat` function writes text segments to the output stream and code is executed within a specified environment, allowing for dynamic content generation. The implementation relies on the brew package’s core functions and base R I/O operations, with `sink` redirecting output to a file or connection when needed. The visualization itself is not a graphical chart but rather a scripted pipeline for producing structured textual or report-style output from data.

Loading thumbnail…

NetLogo A* implementation on nodes and links

This example demonstrates the A* pathfinding algorithm operating on a network of nodes and links within NetLogo. It shows how the algorithm computes the shortest path between a designated start and end node by assigning each node g-cost, h-cost, and f-cost values based on link distances and a heuristic. The implementation uses NetLogo’s breeds, nodes-own variables, and link-neighbors queries to manage open and closed lists, iteratively spreading from the start node until the end node is reached. It then traces the path backward via owner pointers, marking path? nodes, and utilizes constructs like min-one-of and while loops.

Loading thumbnail…

drge

This example demonstrates a simple interactive color-changing rectangle inside a ScalaFX application. It shows a basic JavaFX scene with a green background and a square that toggles between red and green when the mouse hovers over it. The code uses ScalaFX’s `JFXApp`, `Scene`, and `Rectangle` APIs, along with a binding expression (`fill <== when(hover)`) to trigger the color change. The rectangle is drawn directly as a shape node, with no external data source.

Loading thumbnail…

Gist b272bcf056720b0031d3

This R script generates a sequence of ten PNG images, each displaying an evolving line plot of randomly generated numeric data. At each step, it appends ten new random values to the existing vector and redraws the plot with an updated title. The code uses the base R `plot()`, `title()`, and `runif()` functions, saving each frame with `png()` and closing it with `dev.off()`. It demonstrates a simple iterative animation workflow, writing files to a local folder with sequentially numbered names.

Loading thumbnail…

Gist 745c7c03b5bf6b6f59d9

This example splits a single ESRI Shapefile into multiple new Shapefiles, one for each unique value found in a specified attribute field. It demonstrates how to use the OGR library from GDAL to read the original dataset, extract all distinct attribute values, and then create filtered copies. The process first enumerates unique values, then iterates through them to create new Shapefile layers, applies an SQL attribute filter to exclude features not matching the current value, and deletes the remaining unwanted features.

Loading thumbnail…

tmp

This example demonstrates an interactive XY line chart that visualizes multivariate data arrays, mapping X, Y, and Z coordinates while allowing users to apply range filters to specific data columns. The implementation uses Scala with JavaFX collections (FXCollections) for managing dynamic filter lists and processing data through custom variable handling. The visualization relies on the OpenMOLE framework's Variable and VariableData APIs to concatenate streaming data arrays. Filtering operations transpose the data table and apply minimum/maximum bounds to selected columns, producing filtered arrays for rendering. The example also uses spray.json for JSON serialization of coordinate data with color assignments.

Loading thumbnail…

Gist 4953443

This example shows how to prepare and filter variable columns from a dataset for visualization, dynamically building a list of column names based on mapped X and Y variables and additional filter variables. It retrieves each column’s numeric values as an `Array[Double]` from a data structure using `get` and `getVariableFromColumn`, then stores them in a `Map` keyed by column name. The code relies on Scala collections like `ListBuffer` and `mutable.Map`, with error handling via `UserBadDataError` when a column is not of the expected type.

Loading thumbnail…

Gist 4945314

This example demonstrates a simple yet effective visualization of data transformation in Scala, highlighting implicit conversions between mutable and immutable collection types. The code creates a mutable `ListBuffer[Double]`, appends two numeric values, and then passes it to a function expecting an immutable `List`. Through an implicit conversion, the `ListBuffer` is seamlessly converted to a `List`, allowing the operation to succeed. The visualization maps the underlying mechanics of this type conversion, showing the relationship between the original buffer and its converted form. It leverages Scala’s standard collection library and implicit resolution to illustrate the flow of data between collection types.

Loading thumbnail…

Gist 4945102

The visualization filters a dataset by dynamically building a column list from user-selected variables, then renders the resulting points in a scatterplot. It constructs the filtered data structure using Scala’s mutable `ListBuffer` and appends arrays for both X and Y value variables alongside each chosen filter column. The code retrieves column values via a helper `getVariableFromColumn` and casts them to `Array[Double]`, throwing a `UserBadDataError` if the type mismatches. The example relies on the Scala collections API for data manipulation, though the rendering layer itself is not shown in the provided snippet.

Loading thumbnail…

Gist 4753564

This example demonstrates a JavaFX-based interactive scene builder where users can configure a custom table view and slider controls. The code constructs a UI using `javafx.scene.layout`, `javafx.scene.control`, and a custom `JFXTableView`, while binding data through `ObservableList` and `FXCollections`. It integrates a `DoubleSlider` and `DoubleTextField` for precise numeric input, with event handling via `EventHandler` and property binding through `javafx.beans.binding`. The rendering relies on JavaFX's scene graph, and the simulation is defined in Scala with `scala.collection.JavaConversions` for interoperability.

Loading thumbnail…

JavaFX et typage

This JavaFX application displays a line chart tracking population evolution for selected French cities from 1954 to 2006, with data read from a CSV file. A slider controls how many city series are shown, dynamically updating the chart. The UI includes a quit button and uses JavaFX’s `LineChart`, `NumberAxis`, `Slider`, and `Button` components within a Scala-based `Application` class. The code also demonstrates event handling with `EventHandler` for slider mouse clicks and button actions, all rendered in a `Scene` with a `Group` root.

Loading thumbnail…

test javafx

This example shows a JavaFX line chart rendered inside a Scala application, displaying 21 randomly generated x- and y-coordinate pairs on a shared axis. The chart uses `javafx.scene.chart.LineChart` with `NumberAxis` for both axes, while the UI includes a styled "Quitter" button that closes the primary stage when clicked. The data is produced with Scala’s `util.Random` and added to an `XYChart.Series`, though the series data is commented out, so the chart renders empty. The scene is set to 800 by 400 pixels with a whitesmoke background, demonstrating basic JavaFX stage, scene, and control setup from Scala.

Loading thumbnail…

subprocess / gdalwarp error

This example shows a failed attempt to crop a population raster to a polygon boundary using the GDAL command-line tool, invoked through Python’s `subprocess` module. The code constructs a list of arguments for `gdalwarp`, including the cutline shapefile, crop-to-cutline flag, output format `GTiff`, and input/output GeoTIFF paths, then calls it with `subprocess.call(argsSub, shell=True)`. The commented command line above indicates the intended successful shell operation, while the scripted version likely fails due to the misuse of `shell=True` with a list of arguments.

Loading thumbnail…

Ogr split by attribute

This example splits a road shapefile into multiple new shapefiles based on unique values in a chosen attribute field. Using the OGR library from GDAL, it first iterates through all features to collect distinct attribute values from the specified field (e.g., "Type"). For each unique value, it creates a new shapefile via `CreateDataSource` and `CopyLayer`, then applies an attribute filter with `SetAttributeFilter` to identify and delete all features that do not match that value. The result is one separate shapefile per attribute category, demonstrating a straightforward spatial data partitioning workflow.

Loading thumbnail…

Stats zonales

This example uses QGIS’s `QgsZonalStatistics` API to compute zonal statistics from a population raster (`popgrid.tif`) over vector polygons representing urban morphological zones (`UMZ_2000.shp`). It loads the vector layer via `QgsVectorLayer`, prompts the user for confirmation, then runs the calculation with a `ZS_` prefix for new attribute columns. The script prints the layer’s name, feature count, geometry type, and EPSG code before timing the operation, demonstrating a straightforward batch workflow for enriching polygon attributes with raster data.

Loading thumbnail…

Script Python (pour Emeric) pour supprimer une colonne d'un CSV

This example shows a Python script that removes a specified column from a CSV file, using the file path, separator, and column name defined at the top of the script. It first reads the header row to locate the column index, then copies all rows into a temporary CSV file while omitting that column via `pop()`. The process relies on the `csv` module’s `reader` and `writer` classes with a semicolon delimiter, and includes commented code for deleting the original file and renaming the temporary output using `os.remove` and `os.rename`.

Loading thumbnail…

Gist 3900523

This example demonstrates a geometric self-intersection detection routine for polyline coordinates. It iterates through each pair of non-adjacent line segments defined by the input x and y arrays, constructing segment geometries via `guilabs.createGeometry` and testing their intersection with the `Intersect` method. The visualization highlights the result of the intersection check, returning the final intersection geometry. The code is written in Python, relying on the `guilabs` library’s geometric primitives, and is intended to be run on coordinate sets containing at least three distinct points.

Loading thumbnail…

Gist 3744189

This example shows a JavaScript function that merges two Google Visualization DataTables into a single table, combining rows from both inputs and filling missing columns with the string “nop.” The code uses the Google Visualization API, specifically `DataTable` methods like `addColumn`, `addRows`, `getColumnIndex`, and `setValue`. It iterates over a provided list of column names, checks whether each table contains those columns, and copies values when present. The resulting table preserves the union of columns and concatenates all rows, making it useful for comparing or unifying datasets in a charting context.

Loading thumbnail…

Gist 3742319

This example is a simple HTML form that displays a static text string, “ABC,” in a div, with a button labeled “TEST.” The page’s JavaScript defines a variable, `testvar`, with a value of `JIHIBNBUI`, and a `test()` function that assigns that variable to the div’s `innerHTML` property when the button is clicked. The code uses no external libraries or data sources, relying solely on plain JavaScript and the Document Object Model (DOM) to update the content. It demonstrates a basic event-handling interaction without any visualization or charting.

Loading thumbnail…

Gist 3742279

This example builds a small HTML form to trigger an interactive test of Google's Visualization API, version 1. The code defines a data table (`gAxesTable`) with three fictional axes, each given an id, label, title, and type. When the user clicks the "TEST" button, the script populates the page’s `result` div with the table’s JSON representation via `google.visualization.DataTable` and its `toJSON()` method. The demonstration focuses on how to initialize the API and serialize structured data for display.

Loading thumbnail…

Gist 3742278

This example demonstrates a minimal web-based test harness for the Google Visualization API. It defines a data table with three axes, each containing an identifier, display text, title, and type, and renders a simple form with a submit button. When the button is clicked, the `test()` function calls `init()`, then displays the table’s JSON representation in a `div` element via `innerHTML`. The code relies on `google.load("visualization", "1")` and the `google.visualization.DataTable` class to structure the data, though no actual chart or graphical output is generated.

Loading thumbnail…

Gist 3738160

This visualization shows a network of nodes connected by seven links, with the entire graph laid out using a force-directed algorithm. The node positions and connections are defined in the JavaScript data structures `linksTable` and `linksTable2`, which are passed to Google’s `google.visualization.arrayToDataTable` for formatting. The graph is rendered as an interactive force simulation, allowing nodes to repel and links to attract, producing a stable, organic layout. The example relies on the `d3.forceSimulation` engine to compute the physics, while the static node and edge geometry is drawn via standard D3 rendering. The data itself is hard-coded in the `gistfile1.js` file.

Loading thumbnail…

script de correction des tableaux

This script corrects malformed CSV traffic tables from network simulations, ensuring every row has a uniform length of 21 columns. It reads input files named with network and simulation indices, processes rows that are either too long or too short, and writes corrected versions. For short rows, it pads missing values with "NA" while preserving the row’s name and trailing data. Using Python’s `csv.reader` and `csv.writer` with `QUOTE_NONNUMERIC`, it overwrites the original files after cleaning. The code demonstrates a batch-processing workflow for raw simulation output across multiple networks.