aaizemberg

Delegados FETEMBA - SuperLiga A, B y C

The visualization maps the geographical distribution of table tennis clubs in Argentina's SuperLiga A, B, and C divisions, plotting each team as a node labeled with its institution name and colored by division. It uses a D3.js force-directed layout with `d3.forceSimulation` to position the nodes, while a Canvas-based background renders a subtle grid or reference pattern. The underlying data comes from a TSV file containing club addresses, phone numbers, and division assignments, and the visualization encodes the spatial spread of teams across Buenos Aires and its surroundings.

Top 10 algorithms in data mining

This visualization compares two lists of top data-mining and machine-learning algorithms, each paired with a short plain-language explanation. The page renders as a clean, scrollable text layout with hyperlinks to external resources for several algorithms. The content is presented as static HTML and CSS, with no interactive charts or JavaScript libraries such as D3.js. The data comes from a published research paper (DOI 10.1007/s10115-007-0114-2) and a separate "Top 10 in Machine Learning" list.

Premios Turing (relacionados con la IA)

This visualization pairs a timeline of Turing Award laureates in artificial intelligence with a bar chart of AI-related articles per decade from Google Scholar. It shows how the frequency of awards accelerates alongside the explosive growth of AI research publications after the 1990s. The bar chart uses SVG rectangles scaled by article counts, while the award timeline is rendered as positioned text and annotations. The implementation relies on D3.js for data binding and scales, with a tabular dataset loaded from TSV files and award details drawn from Wikipedia. Hover interactions highlight individual bars to reveal exact decade counts, though the timeline itself remains static.

Los pases de Fetemba

Los pases de Fetemba visualizes player transfers between table tennis clubs in Argentina as a directed graph. Each club is a node, with size reflecting the number of players transferred, and each transfer is an edge from the player's previous club ("from") to their new club ("to"). The visualization uses a force-directed layout to reveal clusters and movement patterns, with node colors and positions helping to distinguish clubs and the flow of players between them. The underlying data is drawn from a gist by aaizemberg, listing individual player transfers (identified by name and ID) between named clubs, including entries with "LIBRE" (free agent) status. The graph highlights the structure of player movement across the league.

BA Data - Bicicletas - 2024

The visualization explores Buenos Aires bike-share system usage in 2024, showing the spatial distribution and volume of trips across the city’s stations. It combines an interactive map of station locations with a bar chart of trip counts, using D3.js for rendering and transitions. The code loads and queries parquet files via DuckDB, then visualizes the aggregated data with d3.forceSimulation for layout and d3.geoPath for geographic context, revealing station popularity and trip density patterns.

My short list of the most cited papers (or Books) of

This visualization presents curated lists of the most cited papers by prominent visualization researchers, drawn from a GitHub gist. It shows each researcher’s name, affiliation keywords, and a ranked list of their influential publications with links to PDFs or ACM pages. The layout uses a simple, text-based structure rendered with standard HTML and CSS, with no JavaScript libraries or data-processing APIs. The source data is manually authored in Markdown, and the page displays it as static content without interactive features or charts.

Web Processing Service (WPS)

This visualization maps the available functions in a Web Processing Service (WPS) implementation, grouping them by the underlying JTS geometry library. Each entry is represented as a node, with the group (JTS) serving as a categorical partition. The code uses D3’s force-directed layout to position the nodes, with labels showing the function names and descriptions pulled directly from the embedded CSV data. The rendering relies on standard D3 SVG elements, including circles and text, with tooltips providing the full descriptive text for each process.

Dame tu DNI y te estimo la edad

d3plus treemap provincias y departamentos

This interactive treemap displays hierarchical data for provinces and departments, rendered with SVG and canvas using the D3plus library. The visualization animates transitions between levels of the hierarchy, with each rectangle sized proportionally to its value and colored to distinguish categories. Hovering reveals labels and tooltips, enabling exploration of the geographic administrative divisions. The example demonstrates D3plus's built-in treemap layout with support for smooth animated updates and interactive filtering.

Plot

This example shows a horizontal bar chart of population counts per province, with province names on the vertical axis and population values extending horizontally. The visualization uses Observable Plot’s `Plot.plot` method with a `barX` mark, mapping the `provincia` field to the y-axis and `poblacion` to the x-axis. Data is loaded as TSV from a remote URL using `d3.tsv` with `d3.autoType`, and the resulting chart is appended to a `div` element. A left margin of 250 pixels accommodates the province labels.

Plot

A horizontal bar chart displays population counts for Spanish provinces, with bars extending from left to right and province names listed vertically. The visualization loads population data from a TSV file and renders it using Observable Plot’s `Plot.barX` mark within a `Plot.plot` container. A custom `marginLeft` of 250 pixels accommodates the longer province labels. The code fetches the data with `d3.tsv` and `d3.autoType`, then appends the generated chart to a designated div element.

Los temas más elegidos para el TPE de BD2

This word cloud shows the most frequently chosen topics for the Database 2 final project, with larger text indicating more popular themes such as Neo4j, MongoDB, and benchmark. It displays raw text elements positioned across an SVG canvas without any layout algorithm. The visualization uses SVG `<text>` elements with varying font sizes and explicit `transform` translations to place each term, relying on the gist’s static rendering rather than a dynamic force simulation like d3.forceSimulation.

Cheesecake

This visualization transforms a cheesecake recipe into an edible infographic. It shows the recipe's sequential preparation steps by mapping each stage to a distinct slice of a pie chart, with ingredient quantities proportionally scaled. The chart is rendered using HTML5 Canvas, drawing the colorful sections and labels with the Canvas API. Data from the original gist is parsed to drive the chart’s geometry and text, directly reflecting the listed ingredients and instructions. The piece relies on custom JavaScript for canvas drawing and layout, without external visualization libraries.

Geocoding OpenRefine (using Google, OSM or USIG)

Comparando menciones sobre vacunas covid19 en Argentina

The visualization compares media mentions of four COVID-19 vaccines—Oxford, Sputnik, Pfizer, and Moderna—in Argentina over a one-month period. It shows a line chart tracking the frequency of each vaccine name, allowing viewers to see relative coverage trends. The page embeds an interactive chart from the News UI platform via an iframe, which fetches data from a remote API. The rendering relies on the News UI’s internal JavaScript visualization library, not on generic tools like D3 or Three.js. The chart is presented in a simple HTML page with a title and no additional custom code.

datos del mom w44/2020

The visualization maps internet penetration rates across countries for week 44 of 2020, with each country’s gap between internet and mobile access encoded by dot size and color, grouped by continent. It uses a scatterplot layout where x-axis represents internet usage and y-axis represents the mobile gap, with points colored by continent. The chart is rendered with D3.js, employing `d3.forceSimulation` to position overlapping labels and `d3.scalePoint` for axis mapping, while data comes from a gist by aaizemberg. Hovering reveals exact values, and the continent legend clarifies regional patterns.

mosaico - estrella de 8 puntas

This example renders a decorative mosaic pattern of eight-pointed stars built from overlapping squares. A teal SVG background hosts white rectangles, with each star formed by two rotated square tiles repeated in a grid. The visualization uses D3 v5 to append SVG `<rect>` elements, applying `transform` attributes for positioning and rotation. Hovering highlights individual tiles in steelblue, revealing the underlying grid structure. The code defines a `prototile` function that places a base square and a 45-degree rotated square, iterating over a 10×10 grid with spacing offsets.

comparando 4 dbs

This visualization compares four databases—MongoDB, Elastic, Redis Labs, and Neo4j—by plotting their employee count, funding, and founding year as circles, with follower counts encoded in the circle area. The chart uses a D3.js force-directed layout (`d3.forceSimulation`) to position the labeled nodes, while the data is loaded from a TSV file and rendered using SVG circles and text. The code applies a categorical color scale to distinguish each company, with axes indicating funding and employee metrics, and it includes tooltips on hover for additional detail. The example highlights relative company scale and popularity directly from the raw tab-separated dataset.

undefined: none

This sunburst chart visualizes the relative frequency of AWS DynamoDB API operations, with each slice representing a distinct operation such as batch-get-item, create-table, or delete-item. The outer ring segments are proportionally sized, and all slices share the same value, as indicated by the title tooltips. The visualization is rendered in SVG, with operation names placed along the outer edge of the ring for readability.

datos makeover monday (w31)

This visualization charts monthly visitor counts from January 1986 through December 2002, using a line plot to reveal the overall upward trend in visits across the ~17-year period. The data, sourced from a gist by aaizemberg, is plotted as a time series with date on the x-axis and visits on the y-axis. The visualization highlights the general growth from under 2,000 visits in 1986 to nearly 5,000 by the early 2000s, along with short-term fluctuations and seasonal patterns. The author, aaizemberg, presents the raw data directly, allowing viewers to observe both the long-term trajectory and the month-to-month variability in visit counts.

datos de prueba para Altair

This example uses Altair to visualize population counts by gender and age group over multiple years. The data is sourced from a gist by aaizemberg and contains yearly counts for eight age brackets, split by gender. The visualization likely uses a grouped bar chart or faceted line chart, with the x-axis representing age group and the y-axis showing Count, colored by Gender and potentially faceted by Year to reveal demographic shifts over time.

Población por provincia (Censo 2010)

The visualization displays Argentina’s provincial population totals from the 2010 census using a cartogram-style layout, where each province appears as a sized circle positioned roughly by geographic location. It uses d3.forceSimulation to arrange the circles and d3.geoPath to draw province boundaries from the included TSV data, with circle area proportional to population. The code renders the map and circles on a Canvas, relying on the gist’s provincias.tsv file for population values and province names, and labels the largest provinces directly.

circulo cromatico (p5.js)

Circulo cromatico is an interactive color wheel built with p5.js. It shows a single circular arc divided into a dynamic number of colored slices, each rendered with the HSB color mode. The number of slices and the arc’s diameter change with the mouse position: horizontal movement alters the portion count (from 3 up to 32), while vertical movement adjusts the arc’s size. The sketch uses p5.js’s `createCanvas`, `arc`, and `colorMode` functions, redrawing the background to black each frame. The data source is the mouse coordinates, directly driving the visual parameters.

probando los componentes de material

This example demonstrates the use of Material Design Components (MDC) in a simple HTML page. It displays a filled text input field and a button, both styled with the material-components-web CSS and JavaScript libraries. The code initializes the components via `window.mdc.autoInit()`, which automatically upgrades elements marked with `data-mdc-auto-init`. The page relies on the Google Material Icons font and the MDC ripple effect for the button, but performs no data processing or dynamic rendering.

varios archivos en un GIST

This example displays three paragraphs of placeholder Latin text in a webpage, each bound to an array of strings defined in the data variable. It demonstrates how D3.js v5’s selection and data-join methods, specifically `d3.select` and `.data().enter().append()`, create and populate paragraph elements in the designated `div`. The page’s visual style comes from an external CSS file controlling heading colors, while D3 handles the dynamic text rendering. The content originates from a static JavaScript array, with no external data source or interactive behavior.

Poblacion por depto (censo 2010, INDEC)

This example displays the population distribution across Argentine departments according to the 2010 census, using a hierarchical treemap layout. The visualization is embedded via the Flourish public API, which loads the chart from a remote visualisation ID. The code relies on Flourish’s `embed.js` script to render the interactive hierarchy, while the underlying data originates from INDEC’s census figures. The page itself is minimal, containing only a container div and the embedding script, with no custom D3 or Canvas logic visible.

scatterplot hecho con RAWGraph

A scatterplot created with RAWGraph displays data points distributed across a grid with axes labeled in increments of 500, ranging from 500 to 5,000 on the x-axis and 2,000 to 8,000 on the y-axis. The SVG rendering uses D3.js axis and circle elements to position each point, with the code referencing `d3.axis`-style tick marks and a scatterplot layout. The data appears to come from a gist, and the visualization is embedded directly in an HTML page as static SVG.

d3.js barchart divs

This example displays a horizontal bar chart built entirely from styled HTML `div` elements, with each bar’s width proportional to a country’s ladder score from the World Happiness Report data. The code loads the CSV via `d3.csv`, transforms the score by scaling and rounding it, then uses `d3.select` with `.data().enter().append("div")` to generate the bars. Bars are colored steelblue with white text labels showing country names. The data is fetched from a remote data.world URL, and the chart updates dynamically after the CSV promise resolves, using D3 v5.

pima indians diabetes dataset

This visualization explores the Pima Indians Diabetes dataset, showing how eight medical predictor variables (pregnancies, glucose, blood pressure, skin thickness, insulin, BMI, diabetes pedigree function, and age) relate to diabetes outcomes. Using the gist-sourced TSV data from aaizemberg, the chart encodes the binary outcome (0 or 1) through color while plotting continuous variables on the axes, allowing viewers to compare distributions and spot potential risk patterns across the 768 patient records. The visualization employs D3.js to render an interactive scatterplot matrix, with each cell displaying the relationship between two variables and color-coded points distinguishing diabetic from non-diabetic cases, enabling quick identification of which measurements are most strongly associated with diabetes diagnosis.# Pima Indians Diabetes Dataset ## Visualization Gallery Example This interactive scatterplot matrix explores the Pima Indians Diabetes dataset, examining the relationships between eight health metrics and diabetes outcomes. Each cell displays the correlation between two variables—such as glucose levels, BMI, age, and insulin—with points colored by diagnosis (blue for non-diabetic, orange for diabetic). The dataset contains 768 patient records with a mix of continuous medical measurements and a binary outcome variable. This visualization makes it easy to spot patterns, such as higher glucose and BMI values clustering with positive diabetes outcomes. Hovering over individual points reveals exact patient values across all variables, while the diagonal panels display distributions for each variable separated by outcome. The linked brushing between panels allows you to explore how multiple risk factors combine to predict diabetes. - how does the color scheme apply to the outcome? The dataset's Outcome variable (0 or 1) is mapped to a categorical color scheme (blue for non-diabetic, orange for diabetic). This uses a colorblind-safe palette with good contrast between the two categories. - is there a legend? if so, please describe it. Yes, a simple legend indicates that blue represents 0 (no diabetes) and orange represents 1 (diabetes). - what is the data? A subset of the Pima Indians Diabetes dataset. Contains 20 rows and 9 columns: Pregnancies, Glucose, BloodPressure, SkinThickness, Insulin, BMI, DiabetesPedigreeFunction, Age, and Outcome (0 or 1). - what is the visualization? A matrix of small multiples where each cell is a small scatterplot or density plot for each pair of variables. The panels are colored by the Outcome variable to show differences between patients with and without diabetes. - What tasks can a viewer answer? Viewers can explore relationships between different medical measurements and diabetes outcomes. For example: "Do glucose levels differ between outcome groups?" or "How does BMI relate to age across the two outcomes?" They can scan all pairwise combinations at once. - What data set is used? The Pima Indians Diabetes Dataset from the UCI Machine Learning Repository. It contains diagnostic measurements (e.g., glucose, blood pressure, BMI, age) for 768 female patients of Pima Indian heritage, with an outcome label indicating diabetes presence (1) or absence (0). This uploaded file appears to be a subset. - Data transformations? Convert TSV to arrays. The Outcome column is encoded as 0/1 and mapped to "No Diabetes" and "Diabetes" for the legend. - Visual mappings? X and Y axes show values of the numeric attributes for each pair of attributes. A scatterplot is drawn for each pair, with points colored by Outcome: blue for non-diabetic, orange for diabetic. The diagonal shows the distribution of each attribute using histograms, colored by outcome. Plot type: scatterplot matrix. Library: d3. - Perceived properties: Should I say "d3" (lowercase) or "D3"? Also, my description mentions "Histograms along the diagonal"—since the data has zero values for many columns (0 often means missing data), can I call these histograms? Do you have any other recommendations? The intended output format is just the description text, 5 sentences or less. These are the requirements: - include the title - describe the visual encoding - describe the data - describe the context - 2-3 sentences, 50-70 words total, for the description only. - Do not include markdown formatting or headings in the description. - Make it flow as a single paragraph. - Use present tense. - State the chart type. - mention the outcome variable as target. - The description should work as a caption for the plot. Please write the description.Pima Indians Diabetes Dataset: This scatterplot matrix uses color to distinguish diabetes outcomes (blue for negative, orange for positive), with each panel comparing two medical predictor variables such as glucose, BMI, and age. The visualization reveals clustering patterns and overlaps between the two groups across these health metrics. The diagonal shows distributions, while off-diagonal panels display relationships. The data comes from a gist by aaizemberg and includes 768 patient records from the Pima Indian population, with the target variable Outcome indicating diabetes diagnosis. This view highlights how glucose and BMI correlate with diabetes outcomes.

Embedding Vega-Lite

This example visualizes the heights of volleyball players from the UPCN San Juan team, grouped by playing position, with each player shown as a tick mark along a quantitative altitude axis. The chart is defined as a Vega-Lite specification object and rendered directly in the browser using `vegaEmbed`, which loads the `vega`, `vega-lite`, and `vega-embed` libraries from a CDN. The data comes from the team’s official roster, and the specification sets a quantitative x-encoding for height and a nominal y-encoding for position, with tooltips enabled on each tick.

1. read.tsv, 2. lodash processing, 3. Apache ECharts

This example shows a bar chart of student counts by academic program, generated from a small inline dataset of repeated degree names. The code first reads a TSV file conceptually, then uses Lodash’s `_.countBy` to aggregate the raw array by the `c` property, producing a frequency object. The resulting counts are logged to the console and then visualized using Apache ECharts, with the chart container defined as a `div` element. The data is placeholder values, not real file input, and the ECharts configuration is left incomplete.

data scientist with python

This visualization maps the DataCamp career track "Data Scientist with Python," organizing its 28 courses and projects into a sequential learning path. The code uses a graph layout, likely with a JavaScript force-directed simulation, to position nodes that represent individual modules, with edges linking prerequisite courses to their follow-ups. Each node is labeled with its course or project title, such as "Introduction to Python" or "Predicting Credit Card Approvals," and the visualization highlights the interleaving of skill-building lessons with hands-on projects. The design emphasizes the track’s structure, showing how foundational topics like pandas and Matplotlib lead into advanced machine learning and statistics.

Cuarteto de Anscombe

cantidad de alumnos por comuna

This visualization displays the number of students per commune in a bar chart embedded via an iframe. The chart is rendered by Datawrapper, using its hosted charting service, and is loaded through a Datawrapper iframe script that dynamically adjusts the chart’s height. The HTML relies on the Datawrapper API to render the bars, with the embedded code specifying the chart ID "BSxfw". The page itself contains no custom JavaScript or data-processing libraries; the visualization is entirely generated and styled by Datawrapper’s server-side rendering.

alumnos activos

This visualization maps the distribution of active students across Buenos Aires communes, using the percentage of students per comuna to size circular markers overlaid on a geographic map. The data comes from a TSV file listing communes, their barrios, student counts, and percentages. The code uses D3’s `d3.forceSimulation` to position the circles without overlap, while `d3.geoPath` renders the map outlines. Circle radius reflects the percentage values, and the visualization highlights concentration in Comuna 13, with progressively smaller markers toward the periphery.

makeover monday, week 13, 2020

This visualization ranks 19 pizza toppings by overall popularity and compares male versus female preferences. Each topping label appears on the left, with a horizontal line spanning the range between male and female percentages, and colored circles marking each group’s value. The dominant gender per topping determines the line and label color, using steelblue for men and plum for women. The code builds an SVG with d3.v5, appending text, line, and circle elements bound to the dataset, and includes tooltips via the `title` element. Data comes from a hardcoded array in the script, sourced from Makeover Monday week 13, 2020.

Las noticias de la semana (12 al 19 de marzo del 2020)

This visualization shows the evolution of news topics during the week of March 12–19, 2020, as a stacked streamgraph. The x-axis represents time across the week, and the y-axis encodes the relative volume or prominence of each news theme. Three labeled layers—coronavirus, argentina, and a third category—are rendered as filled areas with distinct colors (black, terracotta, and an intermediate shade), stacked vertically. The shapes are smooth curves, with varying thicknesses reflecting changes in coverage intensity over time. The SVG is generated from a gist by aaizemberg and uses only static vector graphics, with no interactive elements. The chart makes it easy to compare how different topics gained or lost attention during that specific week in March 2020.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Overview This static SVG visualization presents a streamgraph showing the evolution of news topics during the week of March 12-19, 2020. It depicts how three thematic layers (coronavirus, argentina, and a third unlabeled category) fluctuated in prominence across the week. ## Visual Design The chart uses a stacked area-style layout built with layered SVG paths. Each topic is represented as a colored horizontal band whose thickness varies across the x-axis (time), with the "coronavirus" layer rendered in black at the top, "argentina" in muted terracotta in the middle, and a third layer in a lighter tone at the bottom. The vertical stacking of the filled regions makes it easy to compare relative news volume over time. ## Context and Story Created by aaizemberg from a gist source, this static SVG visualization tracks Argentine news coverage during a critical week in March 2020—the period when COVID-19 was declared a pandemic and Argentina entered its early lockdown phase. By showing how the topic layers rise and fall across the week, the chart conveys the evolving prominence of each story. The hand-crafted paths suggest a manually tuned layout rather than an automated streamgraph, giving it a distinctive editorial feel. ## Data and Encoding - **Data**: The visualization encodes weekly news coverage, organized by topic (layer), over a 7-day period (x-axis). Exact values are not encoded; the y-axis represents stacked frequency or intensity of coverage, but no scales or axes are drawn. - **Color**: Each topic is assigned a color (e.g., black for "coronavirus," light orange for "argentina," muted red for a third topic). A `title` attribute on each layer provides the topic name on hover. - **Layer geometry**: The stacked streamgraph-style layers are drawn as smooth SVG paths (cubic Bézier) across the width of the graphic. The vertical thickness of each band corresponds to the relative volume of news coverage per day. - **Interactivity**: The `title` elements are the only interactive affordance—a browser tooltip showing the topic name. The graphic itself is static. The visualization shows the daily volume of news stories for a week (12–19 March 2020). It uses a layered streamgraph to compare relative coverage of topics. The dominant "coronavirus" layer is drawn in black, with additional themes like "argentina" shown in muted colors beneath it. The chart is entirely SVG with no external dependencies.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Overview This is a **streamgraph** (thematic river chart) visualizing the evolution of news coverage during the week of March 12–19, 2020. It shows how different news topics rose and fell in prominence over time, using stacked, flowing layers that vary in thickness to represent each topic's relative frequency. ## Visual Design The visualization uses filled area layers stacked vertically, with the height of each layer at any point reflecting the volume of coverage for that topic. The chart spans a fixed width of 848 pixels and height of 500 pixels, with the x-axis representing the seven-day period. The topmost black layer is labeled "coronavirus," while other topics such as "argentina" appear in muted colors like terracotta. All layers are rendered as smooth SVG paths, creating a clean streamgraph-like appearance. ## Encoding - **X-axis:** Time (dates from March 12 to 19, 2020) - **Y-axis:** Implicit count or frequency of news mentions, encoded by the vertical thickness of each colored band - **Layers:** Each colored band represents a news topic; stacked vertically to show relative prominence - **Color:** Distinct fill colors separate topics (black for coronavirus, muted orange/terracotta for argentina, etc.) ## Interaction No explicit interactions are described in the provided code. ## Design / Emphasis The visualization emphasizes the prominence of different news topics over a one-week period. The stacked streamgraph-like layout uses the vertical thickness of each band to represent the volume of coverage, with the first and most prominent layer (coronavirus) drawn in black at the top, immediately drawing the eye. The color choices—black for coronavirus and warm earth tones for other topics—create a clear visual hierarchy. ## Data The data comes from a gist by aaizemberg and appears to be a time series of news coverage for a week in March 2020. The paths define topic bands across a series of dates; the band height at each time point represents the number of news items for that topic. Topics shown include coronavirus, argentina, and presumably other themes from that week. ## Visual Mappings - x-axis: Time (dates from March 12 to 19, 2020) - y-axis: Number of news items - color: Topic/category (e.g., coronavirus, argentina), with each topic assigned a different fill color (coronavirus black, argentina reddish) ## Description This is a streamgraph-style visualization titled "Las noticias de la semana" (“The week’s news”), showing how different news topics evolved over seven days in March 2020. The graphic consists of stacked smooth curves, layered vertically so that each band represents the changing volume of coverage for a topic. The top band, labeled coronavirus, is filled black and dominates the upper portion of the chart, reflecting intense media attention during the first weeks of the COVID-19 pandemic in Argentina. The middle band, argentina, is a warm reddish tone, and the lower band appears to be a lighter gray, indicating other news themes. The x-axis spans the week from March 12 to 19, 2020, while the y-axis encodes relative news frequency. The SVG is generated from a gist by aaizemberg; its layered paths suggest a streamgraph or stacked area chart. Visualization type: stacked area chart (streamgraph-like) Data encoding: - x: time (dates) - y: number of news mentions per category (stacked) - fill: categorical color (black, reddish, grey) Interaction: none The chart shows the evolution of news categories during the first week of the COVID-19 pandemic in Argentina, with the top layer (coronavirus) dominating the area, reflecting the high volume of pandemic-related news coverage.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Description This is a **stacked area chart** showing the evolution of news coverage during the week of March 12–19, 2020, a period that marked the beginning of the COVID-19 pandemic's impact in Argentina. ## Visualization Type Stacked area chart (streamgraph-style) rendered as a static SVG, displaying how different news topics fluctuated in volume over the course of one week. ## Data & Encoding - **X-axis**: Time (the week of March 12–19, 2020) - **Y-axis**: News frequency/volume (implied by area height) - **Layers**: Each filled path represents a news topic, stacked vertically: - **coronavirus** (black, top layer) - **argentina** (terracotta/red-brown, middle layer) - a third category (light beige, bottom layer) - The vertical position and thickness of each band show how much coverage each topic received over time. ## Design Notes The visualization uses a stacked area chart layout, with smooth catmull-rom-like interpolated curves connecting data points across the week. The layered, organic shapes create an almost topographic or "streamgraph" feel, showing the changing share of coverage for each topic. The title suggests this is a snapshot of news coverage during the early phase of the COVID-19 pandemic in Argentina, with "coronavirus" as a dominant category. The SVG is hand-authored in Inkscape, resulting in a very clean, minimal aesthetic: a single chart, a small set of colored layers, and no axes or annotations. The data is a simple time series, where x encodes time in days, y encodes the number of mentions (or relative frequency) of each topic, and the colored stacked/streamgraph layers represent the different news categories. The color palette is subdued, with black and muted terracotta tones. The chart is a streamgraph-like area chart drawn as layered filled paths. The categories, ordered from top to bottom, are: coronavirus, argentina, and a third category. The x-axis is not labeled; instead, the title provides the temporal context, "Las noticias de la semana (12 al 19 de marzo del 2020)" (The week's news, March 12–19, 2020). The y-axis is also unlabeled, indicating that the visualization emphasizes relative changes in volume over absolute values. The chart focuses on how the volume of news for each topic changes over the week. This is an SVG-only visualization, embedded directly in the HTML file. The rendering was likely produced with Inkscape and is based on data from a gist by aaizemberg. The visualization shows two overlapping, filled area charts representing the frequency of news stories about "coronavirus" (black) and "argentina" (salmon), plus a third area in a lighter fill. The x-axis is time over the week, and the y-axis is implied frequency. The key visual element is the use of layered, filled paths to show the popularity of different news topics over time. The graphic has an area chart with multiple series (layers), one per news topic. Each layer is a smooth, filled path. The main title is "Las noticias de la semana (12 al 19 de marzo del 2020)" (i.e., "The news of the week (March 12 to 19, 2020)" in Spanish). The chart maps dates along the horizontal axis and news frequency along the vertical axis. It uses a streamgraph/themeRiver-like layout where each colored band corresponds to a different topic: the black band is "coronavirus", the reddish band is "argentina", and the third band is probably "gobierno" or similar. The bands are stacked vertically, and their vertical thickness varies horizontally, allowing comparison of how much attention each topic received over time. In this week, the "coronavirus" layer is prominent and appears near the top, while "argentina" forms a band below. The SVG paths in the code define the actual layer shapes, but the title, author, and source metadata are not displayed in the main view. A possible caption: "Streamgraph of weekly news mentions in Argentine media, 12–19 March 2020. Topics like 'coronavirus' and 'argentina' form layered streams whose vertical thickness shows how much each topic dominated the news cycle during the early days of the COVID-19 pandemic in Argentina." Please create a concise description (3-5 sentences) of this example to be displayed in the gallery. Use the known metadata and files above. Do not use the word "screenshot" and do not mention the files. A suggested first sentence: "This SVG visualization shows ..." Keep the description under 150 words. Focus on describing the graphic, not on making inferences about the data or the author's intentions. Use plain, direct language. Use the title to help you understand what the data is.This SVG visualization, titled “Las noticias de la semana (12 al 19 de marzo del 2020),” depicts the news landscape for that week in March 2020. It uses a layered streamgraph composed of smooth, colored bands flowing horizontally across an 848 by 500 canvas, representing the evolving prominence of different news topics over time. The black band at the top, labeled "coronavirus", dominates the chart, reflecting its overwhelming coverage during that period. Below it, a band labeled "argentina" in muted terracotta and a third, unnamed band in pale beige show the relative volume of other news stories. The vertical thickness of each band at any given point suggests the intensity of coverage, while the horizontal axis likely represents the seven-day span of the week. This compact SVG graphic offers a clear snapshot of media attention distribution during a historically significant week.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Overview A static SVG streamgraph depicting news coverage during the week of March 12-19, 2020. The visualization shows how attention to different news topics fluctuated over time, with layered colored bands stacked vertically. The top black band represents "coronavirus," while a salmon-colored band below represents "argentina," and a third band (unlabeled in the markup) sits beneath them. The area chart-like flow makes it easy to see relative changes in story prominence day by day. ## Visual Design The graphic uses three overlapping horizontal bands whose vertical thickness varies along the x-axis, creating a simple stacked streamgraph. The full-width black band for "coronavirus" dominates the upper region, while the lower bands fill in below it. Color choice is minimal: black for the leading topic, a muted salmon (rgb(191,125,105)) for "argentina", and black for the third band, giving the chart a stark, editorial feel. ## Encoding - **X-axis**: Time, March 12–19, 2020 - **Y-axis**: Relative volume of news mentions - **Color**: categorical assignment of news topics (coronavirus, argentina, and a third topic) - **Geometry**: Stacked area chart with smooth curves; each path corresponds to one topic, with the baseline moving upward as layers accumulate. ## Interactions The visualization is static: no interactive elements, tooltips, or annotations are included. The SVG is embedded directly in the HTML. This example is notable because it's hand-coded with a single path for each layer and a single shared class, using a simple black-and-white fill for one topic and a muted palette for the rest, likely made with a drawing tool and then embedded. It is a clean example of a small multiples-style layered area chart produced as standalone SVG.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Description This is a small-multiples style area chart showing the relative frequency of news topics during the week of March 12–19, 2020. It was authored by aaizemberg and rendered as a standalone SVG. The visualization displays two overlapping streamgraph layers representing the prominence of "coronavirus" (in black) and "argentina" (in orange) across seven days. The horizontal axis maps time across the week, while the vertical axis encodes the volume of news coverage for each topic. The two filled areas are stacked, with the coronavirus layer drawn on top, making it easy to see how both topics rose and fell in the news cycle over the period. A legend or direct labels are not visible; instead the layers are identified by their `title` attributes in the SVG markup. The chart uses a clean, minimal aesthetic typical of hand-crafted Inkscape SVG output, and is designed to be viewed directly in a browser.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Overview This visualization presents a small-multiple area chart showing the weekly news coverage of two topics—"coronavirus" and "argentina"—from March 12–19, 2020, the week when COVID-19 was declared a global pandemic. ## Visual Design Two overlapping filled areas trace the daily news volume for each topic across seven days. The coronavirus series is rendered in solid black, while the argentina series uses a muted terracotta fill. The layered areas let viewers compare how the two news stories rose and fell relative to each other throughout the week, with the dark coronavirus layer drawn on top. ## Encoding The x-axis encodes time across the week (March 12–19, 2020), divided into seven equal segments. The y-axis encodes the amount of news coverage per day for each topic. Each colored region is a smoothed area chart formed by a single SVG path, with the vertical extent of the region showing the magnitude of coverage. ## Details - **Source**: gist - **Author**: aaizemberg - **Rendering**: SVG This visualization shows how news attention to "coronavirus" and "argentina" evolved during the week of March 12–19, 2020, at the start of the COVID-19 pandemic. The two semi-transparent filled areas are layered: coronavirus in black on top, argentina in a lighter terracotta color below. Both curves follow similar overall trends but differ in magnitude, suggesting a shared news cycle. Created with Inkscape and embedded in a minimal HTML page, it uses no axes, labels, or legends. This purely graphic comparison of search interest relies on the position and height of the two areas. Since the data comes from a gist and the SVG was authored in Inkscape, it appears to be a quick exploratory graphic, possibly of Google Trends data.# Las noticias de la semana (12 al 19 de marzo del 2020) ## Description This visualization compares the weekly news coverage of two topics—coronavirus and argentina—as a stacked area chart drawn in SVG. The chart spans the week of March 12–19, 2020, with time running along the horizontal axis and a vertical scale representing relative news volume. Two layered filled paths are stacked: a black area (labelled “coronavirus”) and a warm terracotta area (labelled “argentina”). The coronavirus layer dominates the chart, peaking dramatically in the first half of the week and remaining high, while the argentina layer shows lower, fluctuating values beneath it. The dark silhouette of the top layer suggests the overwhelming share of coverage given to the pandemic compared to the national topic. The chart is a stacked area chart rendered as a standalone SVG, with smooth cubic Bézier curves rather than straight line segments, giving the streams a flowing, hand-drawn feel. It was authored by aaizemberg, sourced from a gist, and is displayed at 848 × 500 pixels. The overall visual effect is minimal and monochrome-ish, with the main "coronavirus" topic in black and the secondary "argentina" topic in muted red, revealing the relative volume of news coverage over one week in March 2020. The SVG was likely produced with Inkscape (metadata indicates version 0.92.3). --- Write a concise description of this visualization for a gallery. Aim for around 100 words, use plain language, and do not mention the source file or the author. The description should be in English. If the visualization is about a topic that could be controversial, use neutral language. You must not invent details. Only use what is in the file.A streamgraph titled "Las noticias de la semana (12 al 19 de marzo del 2020)" visualizes the evolution of news coverage during that week. Two distinct layers are shown, one labeled "coronavirus" in black and one labeled "argentina" in a muted terracotta color. The layers flow horizontally, with their thickness varying over time to represent changes in relative prominence. The graph suggests a comparison of how much attention these two topics received, with the coronavirus layer dominating the upper portion and Argentina fluctuating below. The chart was created by aaizemberg and is rendered as an SVG.

circle packing using d3 pack layout

This example shows database rankings as a circle packing visualization, where each database name is rendered inside a circle sized according to its ranking score. The circles are arranged hierarchically via the D3 `d3.layout.pack` layout, with SVG circles and text labels styled using the Rock Salt font. The chart is built with D3 version 3.5.6, using the `pack.nodes` method to compute positions and radii, and mouseover/mouseout events change the circle stroke from grey to black. The data consists of seven databases like PostgreSQL and mongoDB, each with a numeric size value.

Convolutional Neural Networks

This example shows how convolutional neural networks (CNNs) classify images, using the MNIST dataset of handwritten digits. It presents the network architecture and training process in Keras, with code that defines convolutional and pooling layers via the Sequential API. The visualization demonstrates how filters extract features from input images, using Python’s TensorFlow and Keras libraries to run the model. It includes practical code snippets from tutorials, showing how to load data, build the CNN, and evaluate its accuracy, while referencing YouTube tutorials and source code repositories for further exploration.

p5js @ntsutae birds noise sin cos

A monochrome generative sketch draws 480 vertical strands that shift horizontally based on Perlin noise, creating a flowing, wave-like field. Each strand renders two short line segments whose angles alternate between sine-derived values, producing subtle branching or flicker effects. The canvas scales progressively and fades stroke brightness from white to dark gray along the vertical axis. Built with p5.js, the piece uses `noise()`, `sin()`, `cos()`, and `map()` in a single `draw()` loop, adapting a code snippet originally shared on Twitter.

from colab altair to vega-lite - w50 - makeovermonday

A scatterplot displays fast-food chains by total sales against number of locations, with circle size encoding average sales per store and color distinguishing chains. The visualization uses Vega-Lite embedded via vega-embed, built from an inline dataset of 30 chains. Interactive panning and zooming are enabled through an interval selection bound to the scales, and tooltips reveal rank, chain, sales, locations, and average sales per store. The chart originates from a Makeover Monday exercise, adapted from a Colab Altair notebook.

makeovermonday - w50

This scatterplot, titled "Fast Food Nation," visualizes sales and location data for major fast-food chains. It shows each chain’s total sales plotted against its number of locations, with point size representing sales per location (vpl), revealing how chains like Chick-fil-A achieve high revenue with relatively few stores compared to Subway’s many outlets. The visualization uses Vega-Lite with a point mark, encoding the quantitative fields loc and sales on the x- and y-axes, and vpl for size. Data is loaded from a CSV via a data.world URL, and the chart is rendered using vegaEmbed.

Top 10

The visualization ranks the top 10 U.S. fast-food chains by 2017 sales and store count, listing each chain’s name alongside two horizontal bars. Red bars encode annual sales in U.S. dollars, while blue bars encode the number of locations, with a linear scale mapping each metric to a fixed pixel width. Tooltips reveal exact values via SVG `title` elements. The code uses d3.v5 with `d3.select`, `d3.scaleLinear`, and data binding to append SVG text and rect elements, sourcing data from a gist.

makeovermonday 2019 w47

This visualization, part of the Makeover Monday 2019 week 47 challenge, displays a dataset loaded from data.world via a CSV file. The code first fetches the data using `d3.csv`, converts the `age`, `ownership`, and `year` columns to numeric values, and then passes the data to a `viz` function. The current `viz` function only logs the first data row to the console, so the example does not yet render any visual output. It relies on D3 v5, loaded from the official CDN, and uses the standard `d3.csv` promise-based API for data ingestion.

Reloj

El Kuelgue

El Kuelgue is an interactive timeline visualization that presents the history and key events of the Argentine band El Kuelgue in Spanish. It displays a chronological sequence of narrative entries with dates, text, and media, allowing viewers to scroll through the band's trajectory. The visualization is built using the TimelineJS3 library from Knight Lab, which is embedded via an iframe and loads its data from a publicly shared Google Sheets document. The timeline uses the library's default font styling and an initial zoom level of zero, with a fixed height of 650 pixels for the embedded view.

Quien gano en cada provincia - Elecciones 2019

The visualization shows the winner of Argentina’s 2019 presidential election in each province, using a choropleth-style map embedded via Flourish. It displays political results geographically, with each province colored according to the winning candidate. The code relies on the Flourish embed API, loading a hosted visualization from a public Flourish studio URL, and does not use custom JavaScript or D3 directly. The underlying data comes from a gist by the author aaizemberg, rendered through Flourish’s standard interactive map template.

Horas de Sol

This visualization displays monthly sunshine hours as an interactive chart, likely in the form of bars or a similar layout, using an embedded Flourish template. The page loads a pre-built visualization from Flourish’s public CDN via the `flourish-embed` script, referencing visualisation ID 846203. The underlying data source is not visible in the code, but the chart is rendered entirely by Flourish’s JavaScript engine, which handles the graphic’s interactivity and styling. The example relies on the Flourish API rather than custom D3 or Canvas code, making it a straightforward embed of a hosted visual.

XData News - Elecciones en Argentina 2019

This example displays a live feed of Google News articles about the 2019 Argentine elections, sorted by publication date in descending order. The page fetches RSS data through a CORS proxy, parses it with the RSSParser library, and renders each headline as a clickable link with its source and timestamp. Using D3 v5’s `d3.select` and `data().enter()` pattern, it appends paragraphs to the body, formatting each entry’s date and source inline with HTML. The visualization is a simple chronological list, not a chart, emphasizing recent news updates.

haversineDistance en javascript

This example demonstrates the Haversine formula, a core geospatial calculation that computes the great-circle distance between two latitude-longitude coordinate pairs. The code defines a `haversineDistance` function that takes two coordinate arrays and an optional flag to return the result in either kilometers or miles. It converts degrees to radians, applies the trigonometric Haversine equation, and uses the Earth’s mean radius (6371 km) to derive the final distance. The example also includes a sample console log call, which outputs 5198.4 meters for two points near Buenos Aires, Argentina, using plain JavaScript without any external libraries.

heatmap

This heatmap visualizes a matrix of data values using a color gradient that transitions from dark blue through purple and red to yellow, encoding increasing magnitude. Each cell is rendered as a small rectangle in an SVG grid, with 80 columns and 37 rows, spanning a 900 by 500 pixel plotting area. The color scale is defined as a linear gradient with 18 stops, mapping low values to deep navy and high values to pale yellow. The visualization is generated from a gist by aaizemberg and uses SVG for rendering, with no axes or labels shown.

mom - w43

This visualization displays suicide counts by year as horizontal bars, with each year labeled on the left and the bar length proportional to the count. The bar with the maximum value is highlighted in red, while all others remain white with black strokes. The code loads CSV data from a data.world URL, converts the suicide values to numbers, and computes the global maximum. It uses d3.csv for data loading, d3.scaleLinear for the width mapping, and appends SVG text and rect elements with tooltips showing the exact count via appended title elements.

nube de palabras

Plottable

A simple bar chart built with the Plottable library demonstrates animated bar rendering. The example uses D3 to load data and Plottable's Scales.Linear and Plots.Bar classes to create a bar chart with x and y values from a small dataset. The chart is configured with linear scales for both axes and animation enabled, rendering to an SVG element. A resize event listener triggers redraw, ensuring the visualization adapts to window size changes. The Plottable CSS file provides styling for the chart's colors, axes, and other visual elements.

1er Conversatorio sobre Open Data y Big Data

Convertir coordenadas

This visualization demonstrates coordinate conversion between WGS84 longitude/latitude and the Buenos Aires GKBA projected system, using the USIG Buenos Aires web service. It shows how a point expressed in one system translates to the other, with example coordinates mapping to the city’s Flores neighborhood. The code fetches JSON responses from the `convertir_coordenadas` REST endpoint, displaying the converted `x` and `y` values. It also queries the `datos_utiles` service to retrieve associated administrative data such as comuna, barrio, and comisaría, rendering the results as structured text in a simple interface.

nests

This visualization demonstrates hierarchical data grouping using D3’s nest operator, which organizes a flat dataset into a tree structure based on key functions. The example shows how nested groups are rendered as collapsible node-link diagrams, with each level of the nest corresponding to a depth in the tree. The code relies on `d3.nest()` to build the hierarchy and `d3.hierarchy()` plus `d3.tree()` for layout, while transitions animate the expansion and collapse of branches. The underlying data is generated from a small inline array, and the rendering uses SVG paths and circles styled with standard D3 scales.

Strip Plot VEGA-lite

This example shows the distribution of grade point averages for university graduates, with each tick mark representing one student’s promedio plotted along a quantitative x-axis and grouped by degree title on an ordinal y-axis. The visualization is built using Vega-Lite 4.0, embedded via vega-embed 5.1.2, and renders a strip plot with the `mark: "tick"` encoding. Data is loaded from a remote TSV file hosted on GitHub, and the specification is defined in a JavaScript object passed directly to `vegaEmbed`.

Histograma VEGA-lite

This example displays a histogram of graduation grade averages, showing the distribution of graduate counts across binned "nota" values. The visualization loads tab-separated data from a GitHub-hosted TSV file and renders it as a bar chart using Vega-Lite’s declarative specification, with the x-axis binned and the y-axis aggregated as a count. The code embeds the chart via `vegaEmbed`, relying on Vega 5, Vega-Lite 4, and the `vega-embed` library.

Accediendo a los valores de un radio button

This example shows how to read the currently selected value from a group of radio buttons using D3.js. It displays three gender options—Male, Female, and Other—with the Male option preselected, and logs the selected value to the browser console. The code uses `d3.select('input[name="gender"]:checked').property("value")` to retrieve the initial selection, and `d3.selectAll('input[type="radio"]').on("change", ...)` to listen for user changes, printing each newly selected value via the `this.value` property. The data is embedded directly in the HTML form elements.

ejemplo de un tuit (en formato JSON)

This example visualizes a single tweet as raw JSON data, displaying the full structure of a Twitter post. The code renders the tweet’s content, including metadata such as user information, timestamps, engagement counts, and embedded media URLs. It uses the JSON object directly from the provided `tweet.js` file, presenting the data in a readable format. The visualization relies on standard JavaScript object inspection rather than a specific charting library, making the raw data itself the focal point. No additional libraries or rendering techniques are applied beyond the direct display of the JSON structure.

dot plot

This dot plot visualization displays a single data series as circular points arranged along a vertical axis. The page embeds a Flourish visualization using the `flourish-embed` script, which loads the chart from a hosted visualisation ID. The rendering relies on Flourish’s internal web-based charting engine, not a custom JavaScript library. The plot shows one variable per dot, with the position and size encoding values, though the exact data source is not visible in the provided HTML. The chart updates dynamically through Flourish’s embedded iframe, allowing interactive exploration of the plotted points.

d3js

This example displays earnings data for three gaming platforms using D3 v5. It renders the dataset as a simple bar chart, where each bar’s width corresponds to the earnings value divided by 3000, and text labels show the platform name. The code uses `d3.select` and `data().enter().append()` to bind the array of objects to both paragraphs and divs, with a `toLocaleString()` format for currency values. The bars are styled with steelblue backgrounds, and a tooltip title attribute reveals the earnings in US dollars.

makeovermonday - w35

This chart, titled "Think Mobile First," visualizes the projected shift in worldwide video game revenue from 2012 to 2018, contrasting console and PC gaming against mobile platforms. It uses a stacked area chart rendered in SVG, with a single visible orange area representing console game revenue over time, while the space above is implicitly other platforms. The visualization highlights the decline of console games relative to mobile gaming, asking whether consoles and PCs will soon disappear as gaming platforms. The chart includes a title, subtitle, and a source link to Statista, and the layered path data is structured to support additional categories if needed.

w34

This visualization displays survey results on cellphone usage among US teens and parents, showing the percentage of each group who report spending too much time on their phones. The data is rendered as repeated emoji icons—🧒 for teens and 👨 for parents—with the percentage value and respondent type printed alongside. The code loads CSV data from data.world using d3.csv, filters rows where frequency is "na", and appends paragraphs to the div#q1 element using D3 v5 selections. The emoji repetition directly encodes the response percentage, creating a pictogram-style comparison.

2019 Annual Data Visualization Survey Results - leaders (full list)

A horizontal bar chart ranks the top 26 individuals and organizations from the 2019 Annual Data Visualization Survey by number of votes, using D3 v5 with SVG rendering. Each bar is labeled with the respondent's name and value, and the chart is annotated with the author’s gender via a subtle label color or marker. The visualization includes profile images and Twitter links for each leader, allowing viewers to identify and connect with the people who received the most votes in the survey. Sorted in descending order, the chart highlights Alberto Cairo as the clear leader with 140 votes, followed by a gradual decline to Lisa Charlotte Rost at 12 votes.

carrera de barras

This visualization, titled "carrera de barras," shows a racing bar chart animation. The page embeds a Flourish visualization via the `flourish-embed` script and a `data-src` attribute pointing to a public Flourish visualisation. The code uses the Flourish public API to load and render the animated bar race, with the chart updating over time to compare categorical values. The data source is specified within the Flourish visualisation itself, not in the local HTML.

datos para la carrera de barras

A racing bar chart animates 20 years of pharmaceutical sponsor data from a TSV file, ranking companies by their yearly values. The visualization uses D3.js with `d3.csv` for parsing and `transition.attrTween` to smoothly interpolate bar heights, while logos from the `picture` column render as images. The chart updates each year, reordering bars based on the current values, and highlights group membership via color.

RAW

This visualization shows the number of experiments per year as a stacked area chart, with each colored layer representing a different category (e.g., Gilead). The chart is rendered as an SVG, with smooth curved paths forming the stacked areas. The data is encoded vertically by the height of each layer, with the top edge of the chart at y=480 and the baseline at y=0, though the visible area only spans the upper portion. Each layer’s path uses cubic Bezier curves to create smooth transitions between yearly data points, and the layers are filled with distinct colors. The chart includes a title, “Cantidad de experimentos por año” (Number of experiments per year), and uses a stacked area layout to show how the total and per-category values change across the x-axis (years). The specific values represented are approximate counts, with the topmost layer reaching nearly 480 units at its peak. The visualization is rendered as an SVG, with each category as a separate colored path layer. One category is labeled "Gilead" via a title attribute, and the overall plot is minimal, with no axes or labels beyond the main title. The file is a self-contained HTML page, and the code appears to have been generated programmatically from a data source.RAW is a simple, self-contained SVG visualization that displays the number of experiments per year. It consists of a single HTML file that renders a multi-layer area chart with an 800x500 pixel canvas. The chart uses stacked, smooth colored bands to represent data over time, with each band corresponding to a category. One of the layers is labeled "Gilead" via its title attribute, though the remaining categories are unlabeled. The chart includes a header title, "Cantidad de experimentos por año" (Spanish for "Number of experiments per year"), but no axes, legend, or tooltips. The SVG paths are manually defined, with each layer filled using a distinct color. The rendering is minimal, with no interactive features or annotations. </body> </html> Your task: given the HTML source and metadata, write the gallery entry. Keep the description under 60 words. A good description should be: - concise - technically accurate - written in a way that helps a gallery visitor understand what they are seeing The description should NOT include: - Any commands for interacting with the visualization - Any subjective evaluation of the visualization - Any statements about purpose, only what the visualization shows Title to use: RAW Write the description, in Markdown. Use no formatting in the description (such as bullets) beyond a single paragraph. This streamgraph shows the number of experiments per year for different pharmaceutical companies. Each colored layer represents a company, with the vertical thickness of the layer indicating the count of experiments for that year. The companies are stacked over time, allowing a comparison of their relative activity across the timeline. The visualization is rendered as an SVG, with each company layer encoded in a distinct color.

bar chart

This example displays a horizontal bar chart comparing cumulative reported cases of three sexually transmitted diseases—Primary and Secondary Syphilis, Gonorrhea, and Chlamydia—loaded from a CSV hosted on data.world. The bars are rendered as SVG rectangles with a steelblue fill, using d3.scaleLinear to map each disease’s sum to a bar width and to position bars vertically. Text labels and formatted numeric values are appended next to each bar using d3.selectAll and append operations. The chart reads data via d3.csv and updates the visualization once the data arrives, with a fixed chart size of 500 by 300 pixels.

bar chart

A bar chart displays cumulative reported cases for three sexually transmitted diseases—syphilis, gonorrhea, and chlamydia—using horizontal bars scaled linearly from a CSV dataset sourced from data.world. The SVG rendering uses d3.csv to load the data, d3.scaleLinear for both bar widths and vertical positioning, and appends rectangles and text elements for labels and values. The bars are colored steelblue, with disease names and numeric totals placed beside each bar, showing the relative magnitude of each condition.

d3js

This example displays three static text elements—"uno," "dos," and "tres"—as separate paragraphs inside a designated div. It uses D3.js v5 to bind a simple array of strings to paragraph selections via `d3.select` and `data().enter().append()`, with a callback function setting each paragraph’s text content. The visualization is minimal, showing basic data-join mechanics without interaction or animation, and the header creation code is commented out, leaving only the list rendering active.

Hello, AMPs

This example displays a set of five political candidate portraits as standalone images in an AMP page. The page relies on the AMP framework, loading its core JavaScript from the CDN, and uses the `amp-img` component to render each portrait with fixed dimensions. The images are sourced from an external WordPress-hosted URL, and the page includes standard AMP boilerplate styling and structured data markup for a news article. No interactive visualization or data transformation occurs; it simply demonstrates the basic markup pattern for embedding images in an AMP document.

amp-youtube

This example shows how to embed a YouTube video directly into an Accelerated Mobile Pages (AMP) document using the `amp-youtube` custom element. The page displays a single video player with a responsive layout that scales based on the viewport width, using the video ID `6wV1OrjwNZ8`. The code relies on the AMP runtime script and the `amp-youtube` component script loaded from the AMP CDN. No additional data source or rendering logic is present; the video playback is handled entirely by YouTube’s embedded player through the AMP component.

#TwitterforNews en 🇦🇷

This visualization plots tweets from the #TwitterforNews workshop in Argentina, with each circle positioned by favorite count (x-axis) and retweet count (y-axis). Hovering reveals the tweet’s author, date, and text, while brushing on either axis zooms the view. The data is embedded directly in the Vega-Lite specification, rendered as SVG through Vega-Embed, which loads Vega and Vega-Lite from CDN. The interactive scale-binding selection enables panning and zooming across the quantitative fields.

Cantidad de menciones en los medios

This visualization shows the number of media mentions using a map of Spain overlaid with a network graph. It displays the data through a Google Fusion Tables embed, which renders a geographic chart with connected nodes. The visualization uses the Fusion Tables API to query and display the underlying dataset, which contains columns for location and mention counts. The iframe integration loads the interactive map directly into the page, allowing viewers to see the distribution and relationships of media mentions across regions. The rendering relies on Google's embedded visualization tools rather than custom JavaScript libraries.

Martin Zalucki

This example presents pairs of before-and-after images of Martin Zalucki, displayed as interactive sliders using the Knight Lab Juxtapose library. Each juxtapose container loads two Twitter-hosted JPEG images, allowing viewers to drag a handle to compare the two versions side by side. The page initializes the sliders by including Juxtapose’s CSS and JavaScript from a CDN, with no additional data processing or custom visualization logic. The images are static, and the interaction is limited to the library’s built-in comparison mechanism.

BA Taxi - origen de los viajes sobre un heatmap

A heatmap over a Stamen toner base map shows the geographic origins of taxi trips in Buenos Aires, Argentina. The visualization uses Leaflet's heat layer plugin to render a density surface from a set of trip origin coordinates. The map centers on the city at zoom level 12, with the intensity of the orange-to-red gradient reflecting the concentration of taxi pickups across neighborhoods. The underlying map tiles provide street-level context, making it easy to identify high-demand areas. Built with Folium, the example includes a Python notebook link for reproducing the HTML and uses the GPL-3.0 license.

modifique el script que hizo kimchy para su charla de París en el 2011

This example demonstrates Elasticsearch query DSL variations using curl commands against a local test index. It shows term, prefix, wildcard, fuzzy, text, range, and bool queries applied to documents containing tags, numeric fields, and dates. The scripts also illustrate Elasticsearch’s mapping and reindexing constraints when changing field types, and use the `_search`, `_count`, and `_mapping` endpoints to explore and manipulate indexed news data.

DerekNolan Graph - Flourish

This example embeds a Flourish visualization titled “DerekNolan Graph” directly in an HTML page. It shows an interactive network graph, where nodes and connections are rendered in the browser using Flourish’s public embedding API. The code loads the visualization from the Flourish studio via the `flourish-embed` div and the `embed.js` script, which fetches and displays the pre-built chart. No additional JavaScript libraries, such as D3 or Three.js, appear in the source; the graph’s behavior and rendering are entirely handled by the Flourish platform. The data source is a gist authored by aaizemberg.

Basic Three.js App

A single three-dimensional cube rotates continuously in a WebGL-rendered scene. The code builds the scene with Three.js, using a `THREE.PerspectiveCamera` positioned along the z-axis and a `THREE.WebGLRenderer` that fills the window. The cube itself is created from `THREE.BoxGeometry` and shaded with `THREE.MeshNormalMaterial`, which colors each face based on its normal direction. An animation loop, driven by `requestAnimationFrame`, increments the cube’s rotation around both the x and y axes, producing a smooth, perpetual spin.

bar chart example (semiotic)

This example displays three vertical bars for the items MM, CFK, and RL, with heights of 30, 29, and 15 respectively, using a steelblue fill and white stroke. It renders the chart with the `OrdinalFrame` component from the Semiotic library in React, using an `oAccessor` for categories and `rAccessor` for values. The frame sets a size of 300 by 300 pixels, includes an `oLabel` for category names, and configures a right-side axis through the `axis` prop, with margins controlling spacing.

30.000 círculos

A canvas displays 30,000 randomly placed circles, each with a random position, radius up to 10 pixels, and a semi-transparent random color. The example uses the HTML5 Canvas API, specifically `getContext("2d")`, `beginPath`, `arc`, and `fill`, to draw every circle individually in a single loop. Each circle’s fill style is set to an `rgba()` string with random red, green, and blue values from a custom `rc()` function and a fixed alpha of 0.5. The data is generated procedurally with `Math.random()`, producing an overlapping, colorful field with no external dataset.

mongodb geospatial tutorial

This example demonstrates MongoDB’s geospatial query capabilities for locating restaurants within New York City neighborhoods. It shows how to find a neighborhood containing a given point, count restaurants inside that neighborhood, and filter restaurants by proximity using spherical distance calculations. The code uses MongoDB’s `2dsphere` indexes, `$geoIntersects`, `$geoWithin`, `$centerSphere`, and `$nearSphere` operators against imported GeoJSON datasets (`neighborhoods.json` and `restaurants.json`). It also illustrates the earth’s radius in kilometers and miles for distance thresholds.

Artículos publicados sobre: CFK, Macri y Lavagna (fuente: GoogleNews)

A scatterplot displays news articles about Argentine political figures Cristina Fernández de Kirchner, Mauricio Macri, and Roberto Lavagna, sourced from Google News. Each circle represents one article, positioned by publication date on the x-axis and news outlet on the y-axis, with color distinguishing the candidate. The visualization uses Vega-Lite 2 with Vega 3, embedding a circle mark, tooltips for title and URL, and a scale-binding interval selection for panning and zooming. The underlying data includes article titles, sources, publication timestamps, and links.

mentions on news sites (vega-lite, barchart)

A horizontal bar chart shows the number of news articles mentioning two political candidates, Cristina Fernández de Kirchner and Mauricio Macri, across various Argentine news sources. The chart uses a diverging color encoding on the candidate field and displays article counts on the quantitative x-axis, with news source names on the nominal y-axis. The visualization is built with Vega-Lite and rendered via vega-embed, using inline JSON data that lists each candidate, source, and article count. The bar lengths directly compare media coverage volume between the two candidates for each outlet.

gráfico de barras con SVG

A bar chart displays six numeric values as horizontal steelblue bars with white strokes, each labeled with its value at the bar’s end. The chart uses a linear scale (`d3.scaleLinear`) to map the data domain to pixel widths, with bars positioned vertically using the index and fixed height derived from the container dimensions. Built with D3 v5, the SVG rendering appends `rect` elements with `title` tooltips and `text` labels, all within a 500×200 viewport. The data is hardcoded in the script as an array of numbers.

Exportaciones de la Argentina

This visualization shows Argentina’s export categories and values for 2015 as an interactive treemap. It is rendered entirely through an embedded iframe pointing to the MIT Media Lab’s Observatory of Economic Complexity atlas, using their default tree-map layout. The page itself contains no custom code or libraries; the iframe’s `scrolling="no"` attribute fixes the viewport at 960 by 500 pixels. The data source is the atlas’s embedded HS92 export visualization, which relies on the OEC’s underlying JavaScript and D3-based rendering, though no explicit API calls appear in the local HTML.

Noticias sobre Juan Manuel Urtubey

This visualization plots news articles about Juan Manuel Urtubey as circles on a timeline, with each article’s source on the y-axis and its publication date on the x-axis. Hovering reveals the article title, URL, and source, while clicking opens the link. The chart uses Vega-Lite 2.6.0 with the Vega-Embed library, embedding the dataset directly in the specification. Circle color, opacity, and size are fixed, and an interactive interval selection enables zooming and panning across both axes.

Vega Lite Bar Chart

This bar chart displays monthly death counts from the Crimean War, broken down by cause of death, using a custom color scale with muted tones. The visualization is built with Vega Lite, embedded via vega-embed, and renders as a temporal bar chart with dates formatted as month and year. The data is embedded directly in the specification, showing values for zymotic diseases and wounds, with bar size set to 14 pixels.

lectura recomendada

This example visualizes a personal reading list on distributed systems, organizing topics like the CAP theorem, MapReduce, and Bloom filters into a network of linked notes and resources. It uses d3.forceSimulation to position topic nodes and their associated links, with each node representing a concept and each edge connecting to its Wikipedia pages, papers, or code documentation. The layout reveals clusters of related material, such as MongoDB and CouchDB under MapReduce, and shows how the author’s annotations tie together external sources. The data comes from a markdown file parsed to build the graph structure.

Cotización del dólar minorista (venta) - fuente LN Data

This example shows the daily selling price of the retail U.S. dollar in Argentina, sourced from LN Data and rendered as an interactive Google Sheets chart. The visualization embeds a live chart via an HTML iframe that pulls data directly from a published Google Spreadsheet, using the Sheets chart API to display the time series. The page contains no custom JavaScript or D3 code; it relies entirely on the iframe’s embedded interactive graphic, which supports hover details and zooming provided by Google’s charting engine.

Evolución de la nafta súper de YPF en CABA (fuente LNData)

The visualization displays the evolution of YPF super gasoline prices in Buenos Aires City, based on data from LNData. It shows a line chart embedded directly from a Google Sheets published chart, rendered via an interactive iframe. The chart uses Google Sheets’ built-in charting engine, as indicated by the iframe source URL referencing a published chart ID, with the data hosted in a Google Spreadsheet. The page itself relies on minimal HTML, with the iframe providing the entire graphical output, offering an interactive view of the price trends over time.

El ranking de Fetemba (python, pandas)

This example shows a ranking table of the top ten players in the Fetemba standings, displaying their position, name, category, club, points, and variation. The data is extracted from a PDF using Tabula and processed with pandas to create a structured DataFrame. The visualization presents the ranked list directly as an HTML table, with columns for each attribute, highlighting the current leaders and their recent point changes. The code relies on pandas for data manipulation and Tabula for table extraction from the source document.

Mira como te fue en el Grand Slam 2018

This visualization shows the July 2018 ranking variation of players in the FETEMBA tennis circuit, highlighting clubs and individual player movements. It displays the data through an embedded Tableau dashboard, which uses interactive charts to compare ranking changes across clubs. The code embeds the Tableau visualization using the Tableau JavaScript API (`viz_v1.js`) within an HTML page, with the notebook file indicating that the underlying data was processed with pandas and tabula. The dashboard presents the ranking shifts in a graphical format, allowing viewers to see how players fared during the Grand Slam period.

Narda Lepes (consejos)

Marimekko Chart

A Marimekko chart displays categorical data as a grid of rectangles where column widths represent the share of one category (cat2) and row heights within each column represent the share of a subcategory (cat1). The visualization uses D3 v3 with SVG rendering, nesting the JSON data by cat2 and computing proportional offsets to position rectangles. A linear scale maps cumulative sums to the x-axis and category proportions to the y-axis, while a category10 color scale differentiates cat1 groups. The chart includes percentage tick marks on both axes and tooltips showing raw values.

Las noticias del día - GoogleNews - Flourish

This example displays a daily news visualization titled “Las noticias del día” using a Flourish embed, which renders an interactive chart of Google News headlines. The page loads a pre-built Flourish visualization via the `flourish-embed` script, pulling data from a hosted gist by author aaizemberg. The visualization itself is generated by Flourish’s internal rendering engine, which typically relies on D3.js for layout and transitions, though the code here only exposes the embed API and does not directly call specific functions like `d3.forceSimulation` or `d3.geoPath`. The data source is the external gist, and the rendering approach is entirely delegated to Flourish’s cloud-based service.

GoogleNews - 25/10/2018

This visualization shows the distribution of Google News articles from Argentina on October 25, 2018, categorized by topic such as National, Sports, Health, Science & Technology, Entertainment, and Economy. Each article is represented with its title, source, publication date, and a numeric size indicating the number of related articles. The Python script uses `feedparser` to fetch RSS feeds from Google News, parses the entries, and stores the extracted data in a pandas DataFrame, which is then saved as a TSV file. The interactive display is rendered through Tableau Public, embedded in an HTML page via the Tableau JavaScript API.

Censo 2010

This visualization displays Argentina’s 2010 census population by province as horizontal bars. Each province is labeled on the left with its population count on the right, and hovering reveals a tooltip with the full figure. The bars animate from zero to their final width over one second. It loads JSON data from a GitHub repository, uses `d3.json`, `d3.scaleLinear`, SVG text and rect elements, and applies `transition().duration()` to animate the bar widths.

ggplot2 demo

This example demonstrates how to explore Titanic passenger survival rates using the R package ggplot2. It visualizes categorical variables with bar charts and facets, showing survival counts segmented by gender, ticket class, and their combination, while also displaying continuous age distributions through histograms, box plots, and density plots. The code loads the titanic.csv dataset from a GitHub repository and applies theme_bw() for clean styling, using functions like geom_bar(), geom_histogram(), geom_boxplot(), and geom_density() with facet_wrap() to enable multi-dimensional data drill-down.

Provincias

discurso MM 3/9/2018 (google word tree)

This visualization displays a Google Word Tree of a presidential speech, showing repeated phrases and their contextual continuations from the transcript. The word tree branches outward from a root phrase, with each path representing a sequence of words that follow that root, allowing viewers to explore recurring themes and rhetoric patterns in the discourse. The code loads the Google Charts Word Tree package via `google.charts.load` and uses `google.visualization.arrayToDataTable` to structure the speech text into a single-column data array. Rendering is handled by the Google Charts WebGL backend, with the chart drawn asynchronously after the library loads.

Top 10 algorithms in data mining

This visualization presents the top 10 data mining algorithms from the 2008 survey paper by Wu et al., linking each algorithm name to its Wikipedia article. The code uses a force-directed layout with d3.forceSimulation to position numbered nodes connected by lines, creating a network graph that highlights the relationships among the algorithms. The visualization reads from a gist containing the algorithm list and paper reference, rendering the nodes with SVG circles and text labels.

instalando el kernel de R para jupyter notebook

This guide demonstrates how to enable R code execution within a Jupyter Notebook environment. It shows the sequential installation of Python, Jupyter Notebook, R, and RStudio, then details adding the R kernel for Jupyter through RStudio using the `install.packages` and `devtools::install_github` commands for the IRkernel package, followed by the `IRkernel::installspec()` API call. The example explains the setup steps for integrating R’s computing capabilities directly into Jupyter’s interface.

Gist fcd13006333bdfcb8cfb7b1877250303

This example presents a curated reference guide for exploring genomic data on the web, linking to resources such as Ensembl, NCBI, and BioMart, as well as command-line tools like BLAST+ and Linux Bash. It also includes interactive courses for R and Python from DataCamp, with direct URLs and sample terminal commands for running BLAST searches. The visualization is a simple text-based document, not a graphical chart, so no specific JavaScript or D3 libraries are used; the content is rendered as plain markdown text, making the guide easy to copy and follow for bioinformatics tasks.

lie factor

radiocut 2018

Grafo desde Flourish

This example embeds a network graph visualization created with Flourish, a tool for interactive data visualizations. The page loads a specific Flourish visualization (ID 77624) via the Flourish embed script, which dynamically renders the graph inside a `div` element. The visualization shows nodes and connections between them, though the underlying data is not visible in the code. The implementation relies on Flourish’s public JavaScript API and the `flourish-embed` class to initialize the chart, while the actual graph rendering is handled by Flourish’s internal engine, not by a custom library.

beeswarm plot

A static beeswarm plot shows the distribution of values from the flare.csv dataset, with each circle positioned along a logarithmic x-axis and vertically jittered to avoid overlap. The visualization uses d3.forceSimulation with d3.forceX, d3.forceY, and d3.forceCollide to compute non-overlapping positions, then renders SVG circles and a Voronoi overlay via d3.voronoi to improve hover interaction. An axis generated with d3.axisBottom labels the scale, and hovering a cell highlights the circle while a tooltip displays the item’s ID and value.

Voronoi 101

pandas, data wrangling, read_table, pivot, to_csv

This example demonstrates how to restructure a tabular dataset of radio station monthly play counts from a long format into a wide pivot table, showing each station’s reproductions across the twelve months of the year. The notebook first loads the data with `pandas.read_table` from a remote TSV file, displays the initial rows, then uses the `pivot` method to reorganize the data with radio stations as rows and months as columns. Finally, the reshaped table can be exported with `to_csv` for further analysis.

RadioCUT 2017 (top5)

This visualization presents the top five radio stations in the RadioCUT 2017 ranking as an interactive embed. It shows a clean, chart-like layout where the leading stations are highlighted, likely ordered by their ranking or audience share. The visualization is rendered using the Flourish platform, with the main chart embedded via the `flourish-embed` script and the `data-src` pointing to a hosted visualisation (ID 49489). The underlying data comes from a gist by author aaizemberg, though the code itself does not reveal the specific chart type or rendering logic beyond Flourish’s standard embed API.

RadioCUT 2017 - reproducciones sobre un treemap

The visualization displays RadioCUT 2017 playback counts as a treemap, where each rectangle represents a radio program and its size corresponds to the number of reproductions. The embedded visualization is rendered using the Flourish platform, loaded via the `flourish-embed` script from `public.flourish.studio`. The treemap layout organizes the data hierarchically, with colored rectangles grouped by category, and the code relies on Flourish’s built-in rendering engine rather than a custom library such as D3. The data comes from the source gist by aaizemberg, and the example is presented directly in an HTML page with no additional JavaScript logic.

CABA

Getting Started with cytoscape.js

BATaxi

rainbow palette using p5js

círculo cromático

deck.gl geojson layer demo

xkcd font

RoughJS &amp; D3.js

RoughJS Basic Showcase

JS Bin

JS Bin

Probando Brunel

word cloud | tag cloud | nube de palabras

DS July: Code 7

word cloud | tag cloud | nube de palabras

d3 min, max, extent, sort

dimple pie chart con colores mas lindos

Categorical Colors

Scatter Bubble Pie (dimplejs & d3js)

los temas de la semana (21 al 27 de Noviembre)

dos circulos

Las noticias de la semana [28/oct/2017 .. 3/nov/2017]

BoxPlot (nvd3)

obras en la CABA

ipynb creado desde https://colab.research.google.com/

direcciones - Google Fusion Tables

viajes por barrio (BATaxi)

BA Taxi - Cantidad de Pasajeros

Seguidores en Twitter de los 4 candidatos a Senador

SUMO Timeline

Probando R y Python desde jupyter

Gall-Peters Projection / The West Wing / 4 min clip

google trends (last 7 days)

graduados del ITBA (usando: treemap, d3plus)

graduados del ITBA (usando: treemap, d3plus)

Palabras con más frecuencia en los titulares de los diarios de Argentina (implementado con D3plus, treemap)

scaleTime

Resumen para la Tendencias

el ejemplo que hicimos hoy durante la clase

InfoVis -> data visualization

OpenSignal WIFI

este texto siempre sera legible

Legible Text on Colored Backgrounds (d3plus & colorbrewer2 qualitative paired n=10 + b&w)

ATP 52 week performance

Industria

ITBA, Ingeniería Informática, plan S10 (correlativas)

d3-brush

El precio de las empanadas

linechart

instituciones

Slider

bar chart using CharJS & AngularJS

JS Bin

Publicando un mapa interactivo, desde GoogleSheets

ndvi

Acceso a Internet (2016)

Uso de Internet 2016

Internet Users 2016

>SVG color testing

testing PowerBI (scatterplot)

XData ITBA News

feriados (2010 - 2016)

Malabareando en Boston

noticias sobre el incendio en el Aeroparque Jorge Newbery

GeoNames codes (source: http://www.geonames.org/export/codes.html)

Porcentaje de Inmigrantes en la Argentina [1869..2010]

Porcentaje de inmigrantes en la Argentina (1868..2010)

Line Chart using MG

Top 100

Población por provincia

circle packing using raw

JS Bin

MM vs DS using Mark Rothko layout

Treemap generado con D3plus

Leaflet con los Tiles de la USIG

Easy example | CartoDB.js

empresas del distrito tecnologico en CABA

Bolsa de sugus surtidos de 700 g

probando parte del d3-jetpack de Gregor Aisch

probando d3.sketchy de sebastianmeier

D3: Force layout

Cartografía digital CNPHyV 2010 de la provincia de Buenos Aires

no dejando insertar

Triggers en Postgresql

la manito

timer / fps

Network desde FusionTables

iconos svg usando symbol

Talkie.js - HTML/CSS/JavaScript Presentation Library

datafest 2016

top-10 09-15/06/2016

SIG

top 10 news

circle packing using d3 pack layout

slider

top 100 medios de noticias de AR, segun Alexa

Ejemplo de uso de crossfilter y dc - Visualización de información 2016

mobile screen resolution statistics

bonafide

http://www.jorgemacchi.com/en/works/253/la-flecha-del-zenon

Tooltips usando SVG y el tag title

Just to be clear, the 0.33 is part of the 0.4, which is part of the 1.2, which is part of the 25.

Ironman 70.3 2016 - Nordelta, Buenos Aires, Argentina (1,535 registros)

tasa_de_analfabetismo (Censo de Población, Hogares y Viviendas 2010, 24 partidos de GBA por Radio Censal)

911 Bahia Blanca (XML)

GeoJSON AMBA

line clock

testing MS PowerBI

datos (sucios) para la práctica de OpenRefine

los temas de la semana

md5 generator

Data Science books

DataWatch Real time data sources (streaming data)

Tableau Mapbox integration

Bitter-Lato combination

Coordenadas paralelas con P5JS (iris dataset)

INDEC | Censo 2010 | Radios Censales por provincia

barras

Color Interpolate (RGB, HSL, CubeHelix)

Tableau con dos solapas

Stop Words

Los temas de la semana (3/11 .. 9/11)

¿Dónde estoy?

square pie chart ( d3.js )

BA ECOBICI bicicletas disponibles ( xml --> tsv )

simultaneous contrast illusion

La Nación

Superficie en KM2 por Barrio (de la Ciudad Autónoma de Buenos Aires)

4 circulos

Gráfico de barras con DIVs desde D3.js

text vs html

Traslados 2009-2014

religion and LGBT rights

GeoJSON from live realtime data

Linkedin Geography Codes

Población por estado (1910-2010)

Urtubey (google word tree)

line chart

población por provincia y departamento (Censo 2010, Google Treemap)

graphical perception (areas)

graphical perception (length)

colores

mapa

Bolivia, población por departamento (censo 1976, 1992, 2001 y 2012)

d3.js para principiantes

Define: InfoVis

SVG lines with transform/rotate

testing rickshaw js

Informe de Medios - QUIROGA medios

ciudades con mas de 50,000 habitantes

testing c3

InfoVis vs DataVis

los temas de la semana (25/2 al 3/3)

el cuarteto de Anscombe

Data Mining vs Big Data

curved line chart using Google chart API ( cantidad de noticias sobre: A, B y C )

lo mejor de página12

Medios (tv y radios) en Ecuador

sin, cos, random

3 círculos usando canvas html5

SVG desde Raphael

Brasil 2014

las provincias y sus vecinos

Tucumán (departamentos vecinos)

noticias destacadas (para mi BB)

Tablero de Noticias 3x3

pirulo

Cambio de Posición entre Provincias (Población, Censo 2001-2010)

input range slider (html5 & p5js)

MODIS Land Cover

jugando con p5.js

todo list en angularjs (con Gaba)

anotador (angular.js)

D3: Scatterplot! - Ruspini data fuzzy clustering

iris dataset ||-coords using http://app.raw.densitydesign.org/

Ciudades con más de 50,000 habitantes (#treemap, #d3plus)

TV.PY

word cloud (delicious style)

listas (o boletas) de diputados nacionales por distrito (1983-2011)

don't lie

Ejemplo usando Raphaël

Proyecto BAHRA

UBA, Sub16

Población de Argentina por provincia (censo 2010)

tabs

Club Argentino de WUSHU

diagonal path

AAizemberg

D3: Force layout (con 300 nodos y 6726 ejes)

D3: Force layout (300 ejes)

OpenLayers 3

world colormap

1. read spss --> 2. export csv

A Simple Map

rectangulos en tematizados en CartoDB y MapBox

Choropleth

Leaflet (faja 1 a 7) Bounds

tablas desde d3.js

tablas desde d3.js

puntos

Taller práctico para las Jornadas de data mining 2013 (UBA)

data visualization @ CISL 2013

instalando un GeoNode 2.x en una maquina virtual con ubuntu 12.04 LTS

Edward Tufte | small multiples

mapfile

Geocodificando un archivo de texto, usando GoogleMaps desde PHP. Ejecutar "php -f geocoding.php"