JustinGOSSES

JSON of NASA orgs on GitHub other than the NASA org - for use in various things like this visualization of the code: https://justingosses.github.io/nasa-repos-visual-explorer/explore/

This visualization explores the relationships between NASA’s many GitHub organizations, starting from a hand-curated JSON list of ten org names. It renders an interactive force-directed network using D3’s `d3.forceSimulation`, with nodes sized and colored by org metadata and links drawn via SVG paths. The code also leverages `d3.geoPath` for a secondary geographic view of repository locations, and uses Canvas `getImageData` for pixel-level hover detection. Data comes from the GitHub API, pulling live repository counts and descriptions for each org.

Jan 23, 2022

Layer 1

Three stick figures stand at different positions against a blank background, each drawn identically with a circular head and a single continuous path for the body. The SVG rendering uses basic geometric shapes and path commands, with no explicit data binding or interaction. The figures appear static, suggesting a simple illustration or icon set rather than a data-driven visualization. The work is authored by JustinGOSSES and shared as a gist.

Jan 23, 2022

A test LAS file of well log

This visualization displays a subset of well log data from a LAS file, plotting depth on the vertical axis against several measured curves, including gamma ray, caliper, neutron porosity, density porosity, and deep resistivity. The example uses the Python `lasio` library to parse the LAS file and Bokeh to render the curves as horizontally-oriented line plots. The depth series spans from 200 to roughly 375 meters at a 0.25-meter sampling interval, with a null value of -999.25 used for missing data. The plot shows the raw, unsmoothed measurements as they appear in the source file from JustinGosses' gist.

Oct 24, 2019

JSON of clusters of NLP tags from catalog.json that runs https://code.nasa.gov as of May 2019

This visualization displays clusters of NASA software projects derived from NLP keyword tags, grouping related tools like simulation frameworks or Earth-observation suites. Each cluster is shown as a labeled node, with project names and keyword descriptions listed inside. The data comes from the catalog.json file powering code.nasa.gov as of May 2019, preprocessed into a cluster JSON. The visualization uses d3.forceSimulation to position nodes, with JSON parsing via JavaScript and layout driven by force-directed physics.

May 21, 2019

CMA_test_WithCC0licenseDepartTextilesWithImage.csv

This example visualizes the Cleveland Museum of Art’s textile collection from a CSV file, highlighting records with images and open licenses. It shows a scatterplot-like layout where each object is positioned by its creation date and dimensions, with color and size encoding department and physical scale. The visualization uses d3.forceSimulation to arrange overlapping points, d3.scaleTime for the x-axis, and d3.scaleLinear for sizing. Hovering reveals tooltips with titles and accession numbers, while the underlying data—pulled from the museum’s open-access CSV—is parsed with d3.csv, demonstrating direct API and library integration.

Feb 21, 2019

location data and top pick data of Mannville oil and gas wells in the open-dataset here: http://ags.aer.ca/publications/SPE_006.html

This map shows the locations and depth picks of Mannville oil and gas wells in Alberta, using a rasterized scatter plot rendered with d3.js and the `d3.geoPath` for projecting geographical coordinates. Each point is colored by its pick depth (from the “Pick” column) and sized or opacity-mapped by quality, revealing spatial depth trends across the formation. The code loads CSV data from the AGS public dataset, converts latitude/longitude to projected coordinates, and draws points onto a Canvas via `getImageData`, with a legend and color scale built using `d3.range`.

May 13, 2018

Gist cc6d3e2dfc8356dd8bb96b58c8c8ac7e

This example visualizes well-log data from a LAS file, displaying depth-based curves for porosity, gamma ray, caliper, and resistivity. The code uses D3.js to parse the JSON-structured LAS data, mapping each curve to a separate track with depth on the y-axis. It employs D3 scales and axes to render the line charts, with the well name and location shown as a title. The visualization highlights the raw curve values and their relative changes across the logged depth interval.

May 13, 2018

Gist a9239feb46c9a77aa7e57b052568f0a2

This example visualizes well-log data from the CWLS LAS 2.0 format, showing depth-series curves for gamma ray, density porosity, neutron porosity, caliper, and deep resistivity across a 0.25-meter increment from 390 to 650 meters. The code parses the JSON structure containing version, well information, curve metadata, and parameter blocks, then renders the measurements as a multi-track line chart. It uses D3.js for SVG-based plotting, with scales mapping depth to the y-axis and each measurement type to its own x-axis, while reading curve mnemonics and data arrays directly from the JSON object.

May 13, 2018

00-02-26-073-05W5-0.json well log converted from 00-02-26-073-05W5-0.las using wellio.js

This example visualizes a well log from the LAS file 00-02-26-073-05W5-0.las, converted to JSON using wellio.js. It displays depth-based curves for density porosity, neutron porosity, gamma ray, caliper, and deep resistivity, with depth on the vertical axis. The visualization uses the JSON structure to render each curve as a distinct line plot, showing how these subsurface measurements change over the logged interval from 350 to 590 meters. The data comes from the well "TRICENT ET AL MITSUE 02-26," recorded by Schlumberger in 1982, and the plot leverages the curve information block to map each measurement to its graphical representation.

Point-in-polygon

This example demonstrates the point-in-polygon algorithm by letting users draw a polygon directly on an SVG canvas while 1000 randomly placed dots update in real time. Dots that fall inside the drawn shape turn red, while those outside remain steel blue. The implementation uses D3 v3’s `d3.behavior.drag` to capture mouse coordinates and a ray-casting algorithm to test each point against the polygon’s vertices. A clear link resets the visualization by removing the drawn path and deselecting all dots.

Trees

Three linked scatterplots display 100 simulated trees, comparing height by age, location on a map of the woods, and annual growth by distance from a spring. A shared brush highlights the same tree across all charts simultaneously. Built with D3 v3 and SVG, the example loads tree measurements from a CSV and uses `d3.svg.brush` to coordinate selections, while `d3.scale.linear` and `d3.svg.axis` render axes. A green field rect marks the mapped area.

Scatterplot Matrix with brush and tooltip v4

This scatterplot matrix displays relationships between multiple numeric Facebook page metrics, such as lifetime post reach, impressions, and engagement counts. The visualization uses D3 v4 to render an SVG grid of plots, with brush interaction allowing users to select points across several dimensions simultaneously. A custom tooltip built with D3 helper functions and Underscore.js shows detailed values for each data point on mouseover. The data comes from a provided CSV file.

https://data.giss.nasa.gov/gistemp/tabledata_v3/GLB.Ts+dSST.csv

This visualization displays global temperature anomalies from 1881 to 1933, with each year as a row and months as columns, colored from blue (cooler) to red (warmer). It uses D3.js to parse the CSV data and render a heatmap grid, with scales mapping temperature values to a diverging color scheme. The dataset comes from NASA GISS, providing monthly and seasonal temperature deviations from a baseline. The code employs d3.csv to load the data and d3.scaleSequential for color encoding.

Apr 13, 2018

Astronaut Vision Changes in Microgravity-laMmaGFZFZI.en.vtt

This example visualizes the physiological changes astronauts experience in microgravity, using a public-domain WebVTT subtitle file from a NASA video as its data source. The visualization is built with a custom JavaScript application, likely using the Canvas API to render a stylized animation of the human head and eye. It depicts how fluid shifts toward the skull, increasing intracranial pressure, which then flattens the back of the eyeball and swells the optic disc and blood vessels. The animation walks through each step of this causal chain, illustrating the mechanisms behind vision changes like far-sightedness and cotton wool spots.

Mar 29, 2018

Gist c22c3354ee89f6f6c8d7c1f9358e6299

This visualization compares consumer expenditure patterns across four Midwestern U.S. cities—Chicago, Detroit, Minneapolis–St. Paul, and St. Louis—using data from the Consumer Expenditure Survey. It shows categorical spending differences (e.g., food, housing, transportation) through a horizontal bar chart layout, with each city’s values encoded as bar lengths. The code uses D3.js (d3.scaleBand, d3.scaleLinear) to map categories and values, and d3.axisBottom for the value axis. Data comes from the CSV file `midwest_flatten_3.csv`, which contains income and spending figures per city.

Gist 9e143987ca94c3ea3cbbcd28943d7096

This visualization compares consumer expenditure patterns across four Midwest U.S. cities using a force-directed network layout. The code employs `d3.forceSimulation` to arrange nodes by category and city, with `d3.geoPath` absent, instead relying on SVG circles and lines to encode spending amounts. Data comes from a flattened CSV (midwest_flatten_3.csv) listing income and expense categories like housing, food, and transportation. Each city’s values are shown as labeled clusters, with node size and link thickness reflecting dollar figures, rendered via D3’s `enter`/`update` selections and `transition.attrTween` for smooth positioning.

Gist 78d997d4b70284eab2159645ba587f1f

This visualization compares consumer expenditure and demographic data across four Midwestern U.S. cities—Chicago, Detroit, Minneapolis–St. Paul, and St. Louis—using data from a flattened CSV file. It presents the information as a series of horizontal bars or numeric tables grouped by spending categories like food, housing, and transportation, with each city’s values displayed side-by-side for direct comparison. The rendering relies on a JavaScript library to parse and display the structured data from the provided file, likely using a data-driven approach to map the tabular values into visual elements, though no specific graphing API is named in the source.

Gist ac4a02b526cdd611b46159cb475c24e9

This visualization compares consumer expenditures across five Midwestern U.S. cities (Chicago, Detroit, Minneapolis-St. Paul, and St. Louis) using multi-column data from a flat CSV file. It displays a table-like layout where each row represents a spending category, and each column shows the dollar amounts or demographic statistics for that city. The rendering uses D3.js with a `d3.forceSimulation` algorithm to manage the positioning of data elements, making the comparison of values and category hierarchies visible at a glance. The data structure features three levels of headers, allowing users to trace broad categories like Food or Housing down to specific subcategories.

Gist 81bb1fe48aaac31ecad321fb46af0847

The visualization maps discovered geospatial features onto a grid of cells, using color intensity to show the frequency of feature occurrences per cell. It highlights clusters of high-density areas, such as locations with counts of 23, 5, and 4, while most cells remain empty. The code uses JavaScript with a custom grid-rendering approach, likely employing canvas drawing or SVG elements, to display the distribution of features across the mapped region. Feature counts are stored in a two-dimensional array, with each cell’s value determining its visual encoding.

Feb 4, 2018

see readme.md at https://github.com/JustinGOSSES/Harvey_FEMA-HCAD_merged Hurrican Harvey modeled damage dataset, not final

This map visualizes modeled hurricane Harvey flood damage across residential properties in Katy, Texas, using FEMA and HCAD data. Each point is a parcel, colored by its estimated inundation depth (`IN_DEPTH`) and labeled with a damage level (`DMG_LEVEL`). The visualization renders GeoJSON features using `d3.geoPath` and `d3.forceSimulation` to lay out non-overlapping points over a geographic backdrop, with point colors and sizes driven by property values like land use and total appraised worth. The underlying data source includes Fort Bend and Harris County geocoded parcel records.

Feb 1, 2018

HarrisCounty_Watersheds_poly.geojson

This example shows Harris County watershed boundaries as polygon features on a map. The visualization loads GeoJSON data containing watershed names and geometry, then renders the polygons using D3.js to draw the geographic shapes. The code specifies coordinates in the CRS84 projection and handles the full FeatureCollection structure, displaying each watershed polygon based on the coordinate data provided in the file. The rendering relies on D3's geo projection and path generation functions to transform the latitude and longitude coordinates into visible map areas.

Jan 31, 2018

Mars ChemCam Major Elements Data https://github.com/JustinGOSSES/datajam_Mars_MajorElements/blob/master/tidy_merged4.csv

This scatterplot visualizes Mars ChemCam major element oxide data, showing the relationship between silicon dioxide and other oxide concentrations across multiple rock targets such as Coronation and Goulburn, with each point representing a single spectral observation colored by target name. The interactive chart uses D3.js with d3.scalePoint and d3.axisBottom for the x-axis, rendering circles sized by oxide sum and offering hover tooltips that display target names and exact oxide values. The dataset, sourced from a tidy CSV file, includes error bars derived from RMSE and standard deviation fields for each measurement.

Jan 31, 2018

Gist c643e25774aea39556799cc517654d46

This example visualizes well log data from a Chevron oil well, showing depth-based curves for gamma ray, density porosity, neutron porosity, caliper, and deep resistivity. The code parses a JSON file containing LAS 2.0 format data and renders the measurements as multiple line charts using the Observable Plot library. The visualization displays the raw curve values against depth, with the top depth at 390 and bottom at 650 meters, sampled at 0.25-meter increments.

Jan 31, 2018

A simple script to backup an organization's GitHub repositories, wikis and issues.

This example demonstrates a Bash script that automates the backup of an organization's GitHub repositories, wikis, and issues, using the GitHub API to fetch repository lists and `git clone --mirror` for repository backups. The script produces compressed archives via `tar`, while `curl` retrieves issue data. The backup process includes pruning of old archives, configured through shell variables and conditional checks.

Feb 22, 2016

A simple script to backup an organization's GitHub repositories, wikis and issues.

Feb 22, 2016

particle modified.py 1.py

This interactive particle visualization shows colorful bubbles that appear and drift upward as the user moves their fingers across the screen. The code uses Pythonista’s `scene` module with custom `Particle` and `Particles` classes, relying on the `touch_moved` event to spawn particles at touch locations. Each particle’s hue starts at 0.9 and increments over time, while its alpha fades until removal, creating a subtle color shift. The rendering draws a white circle image with tinted colors derived from `hsv_to_rgb` and applies additive blending (`BLEND_ADD`) for luminous, overlapping effects.

Apr 12, 2015

particle modified.py

This example generates colorful, fading bubbles that trail from finger movements on a touchscreen. It uses the `scene`, `colorsys`, and `random` modules from the NodeBox/platypus framework. Each particle, defined by a `Particle` class, moves with a randomized velocity, changes hue over time, and fades via decreasing alpha. The `Particles` scene handles touch events, draws with additive blending, and removes dead particles as they vanish.

Apr 12, 2015

Untitled 7.py

An interactive particle system displays colorful bubbles that follow finger movements across a touchscreen. The scene renders fading, hue-shifting circles from a set of spawned particles, using the Pythonista `scene` module with `Particle` objects and a `Particles` class. Touch events create particles via `touch_moved`, while `draw` updates colors using `hsv_to_rgb` and applies additive blending with `blend_mode(BLEND_ADD)`. The code tracks particle life through alpha values, removing dead particles, and includes a starting instruction text.

Apr 12, 2015