ChristosT

@ChristosT·16 public vizzes

Read triangular/tetrahedral mesh saved as vtk unstructured grid in python/ C++

This example demonstrates how to read triangular or tetrahedral mesh data from a VTK unstructured grid file. It shows the mesh’s number of points and elements, iterates through cell connectivity, and retrieves a per-point “weights” array. The Python version uses the `vtkUnstructuredGridReader` from the VTK library, and also illustrates two additional access methods: converting the raw data into NumPy arrays via `GetPoints()` and `GetCells()`, and using the `dataset_adapter` wrapper for direct array-like access. A C++ implementation relies on VTK’s `vtkUnstructuredGridReader`, `vtkPoints`, and `vtkCellIterator` APIs.

Dec 6, 2019

Loading thumbnail…

Convert powerpoint slides to images in VBA

This example shows how to batch-convert every slide in a PowerPoint presentation into JPEG images. The VBA macro iterates through all slides in the active presentation, exporting each one with a fixed output size of 2667 by 1500 pixels. The code uses the `Slide.Export` method, which is part of the PowerPoint object model, and references the `ActivePresentation` object. The filenames include a zero-padded slide index to preserve order. The macro relies on the built-in VBA `For Each` loop and the `Format` function to generate sequential names, with the output directory hardcoded as "Z:\". This approach automates slide-to-image conversion without manual screen captures.

Jun 3, 2019

Loading thumbnail…

Support CMAKE_CXX_STANDARD in older cmake versions

This example shows how to set the C++ standard in CMake while maintaining compatibility with older versions of the tool. It checks `CMAKE_VERSION` against version 3.1 and, for older versions, appends the `-std=c++11` flag to `CMAKE_CXX_FLAGS`. For newer versions, it uses the more modern `CMAKE_CXX_STANDARD` variable set to 11. The code references a Stack Overflow answer as its source, illustrating a common conditional pattern for cross-version build configuration.

May 3, 2019

Loading thumbnail…

Speedup a video x2 using ffmpeg

This example demonstrates a shell script that doubles the playback speed of a video file using ffmpeg. It shows how the ffmpeg command-line tool manipulates video timing through the `setpts` filter, which adjusts presentation timestamps by multiplying them by 0.5. The script takes a filename as input, extracts the file extension, and constructs a new output filename with an `_x2` suffix. It uses bash scripting with `set -u` and `set -e` for error handling, and relies on standard shell utilities like `basename` and parameter expansion to process the filename.

Apr 29, 2019

Loading thumbnail…

Convert jupyter notebooks to python scripts

This example demonstrates a Python script that converts Jupyter notebook files (`.ipynb`) into plain Python scripts (`.py`). It shows how to parse notebook JSON structures and extract code cells while preserving cell boundaries as comments. The script reads the input file using Python's built-in `json` library and writes the output with a standard shebang line. It handles both notebook format versions 4 and earlier, iterating through `cells` or `worksheets[0].cells` accordingly. The code relies on straightforward file I/O operations and conditional logic to accommodate schema differences, making it a practical utility for version control or code review workflows.

Apr 14, 2019

Loading thumbnail…

Sample VIM config file

This sample VIM config file demonstrates how to customize the Vim text editor for Fortran and C/C++ development, focusing on indentation, folding, and key mappings. It shows how to save and restore folds automatically via `autocmd BufWinLeave` and `BufWinEnter`, and sets Fortran-specific options like `fortran_free_source`, `fortran_fold`, and `fortran_do_enddo`. The configuration also disables arrow keys in normal and insert modes using `no <down>` and `ino <down>`, and binds `F9` to toggle spell checking with `:setlocal spell`. The file originates from a GitHub gist by ChristosT and includes commented-out lines for potential plugin usage via `pathogen#infect()`.

Sep 5, 2018

Loading thumbnail…

Sample tmux config file

This sample tmux configuration file demonstrates a customized terminal multiplexer setup, rebinding the default prefix key to Ctrl+A and remapping common commands for vi-style navigation. The config uses tmux’s built-in `bind-key`, `set-option`, and `setw` commands to adjust pane splitting, window management, and copy-paste behavior, such as `bind-key | split-window -h` and `bind -t vi-copy`. It also shows commented-out lines for optional features like system clipboard integration via `xclip` and focus events, with settings for pane border colors and history limits visible in the source.

Jul 31, 2017

Loading thumbnail…

Contigious States of US

This visualization uses an adjacency matrix to display the contiguity of the 48 contiguous US states (plus Washington, D.C.). Each cell in the matrix is colored to indicate whether two states share a border (dark) or are connected via a path of length two (lighter), with state ordering toggleable alphabetically or by neighbor count using D3's ordinal scale. Built with D3 v3, it renders as an SVG with mouseover highlighting of rows and columns, and includes interactive controls to reorder rows and columns and to toggle display of two-hop connections.

Mar 16, 2016

Loading thumbnail…

State-Adjacency

This force-directed graph maps the adjacency relationships between U.S. states and the District of Columbia, using a node-link layout to reveal geographic connectivity as a graph structure. Each state is represented by a node, and links indicate shared borders. The visualization makes it easy to spot Maine (ME) as the only state with a single connection, while Florida, South Carolina, DC, and Washington each connect to just two others. New York emerges as the critical hub, linking Vermont, Massachusetts, Connecticut, and other New England states, and the layout’s physical simulation pushes boundary states to the edges.

Mar 13, 2016

Loading thumbnail…

CS 725 Information Visualization - VI5

This example presents animated pie charts that cycle through workforce gender data for seven tech companies, contrasting against a static stacked bar chart rendering of the same dataset. The pie chart animation relies on button clicks to advance through companies, forcing users to rely on memory for comparisons. The stacked bar chart uses `barplot` in R to enable direct, length-based comparisons with lower cognitive load. Data originates from a USA Today report on Apple's diversity statistics, and the code utilizes D3.js for the SVG pie chart and R for the bar chart.

Feb 22, 2016

Loading thumbnail…

IV4

This block, forked from ChristosT’s VI3 example, presents two side-by-side D3.js visualizations: an animated scatterplot of gold prices (2005–2011) and a static stacked bar chart of U.S. wireless carrier market share. The scatterplot encodes time on the x-axis and price on the y-axis, with circles transitioning from the bottom to their mapped positions to emphasize the rising trend. The stacked bar chart uses area and color hue to represent the proportional shares of five carriers. Both are rendered with SVG and animation in d3.v3, with data from public sources and original code adapted from referenced examples.

Feb 17, 2016

Loading thumbnail…

CS 725 Information Visualization - VI3

This example shows how interactive buttons control two distinct D3.js visualizations on a single page: a scatterplot and a polygon. The scatterplot initially displays data points as circles, and clicking a button triggers a transition that enlarges their radii and applies color based on the data values. A separate button animates the polygon’s shape, position, and fill color, with a circle appearing at the end of the transition. The code uses D3’s `transition.attr` and `style` methods, alongside scale functions (`d3.scale.linear` and `d3.scale.ordinal`), to drive the animations.

Feb 10, 2016

Loading thumbnail…

CS 725 Information Visualization - VI2

This example demonstrates a bar chart for a dataset of 20 numeric values, with each bar’s height and color intensity proportional to its value. The chart is rendered as an SVG using D3.js (version 3.5.5), where `d3.select` appends an SVG element, and `selectAll("rect")` with `data()` and `enter()` creates the bars. Text labels are positioned at each bar’s top using an inverted coordinate system, where `y` is calculated from the height. The source code is a standalone HTML file, and the dataset is hardcoded as an array. The rendering uses basic D3 APIs such as `attr` for styling and `text-anchor` for label alignment.

Feb 3, 2016

Loading thumbnail…

Generate 25 Random number in the interval 0-30

This example shows a static bar chart of 25 randomly generated numbers between 0 and 30, with each bar’s height proportional to its value. The visualization uses D3.js (version 3.5.5) to bind the dataset to `div` elements, setting each bar’s height via `.style("height", ...)` and styling them with the CSS class `bar` (teal, fixed width, inline-block). The data are generated on the fly using `Math.random()*30` in a loop, while the original R code uses `runif(25, 0, 30)` to produce the same distribution. The chart intentionally omits axes, focusing solely on relative bar lengths for comparison.

Jan 31, 2016

Loading thumbnail…

D3 tutorial

This example shows a scatterplot of 50 randomly generated data points, with each point’s position and radius mapped using linear scales. The visualization demonstrates how D3.js 3.5.5 creates axes and scales for dynamic data, drawing circles as SVG elements. The x- and y-axes are rendered using `d3.svg.axis`, with tick formatting applied as percentages on the x-axis. The code uses `d3.scale.linear` for positioning and radius, and the data is generated on the fly with `Math.random`. The tutorial source is from alignedleft.com, and the SVG rendering approach is explicit in the markup.

Jan 23, 2016

Loading thumbnail…

use make to build Latex/Xelatex documents. Biblatex support included.

This makefile example demonstrates how to automate the compilation of LaTeX and XeLaTeX documents, including full bibliography support through BibLaTeX and biber. It shows separate build targets for standard LaTeX and XeLaTeX workflows, each with and without bibliography processing, as well as a clean target to remove auxiliary files. The makefile uses the `pdflatex` and `xelatex` commands with specific flags for synctex and nonstopmode, while managing build artifacts in a hidden `.build` directory. It copies source and `.bib` files into the build directory before running the appropriate compiler sequence, then moves the final PDF back to the project root. The code relies on standard Unix utilities like `mkdir`, `cp`, `mv`, and `rm` within Make’s recipe syntax.

Feb 21, 2015