N

Npfn

@Npfn·36 public vizzes

Loading thumbnail…

Gist 6b30d347b0402263522888c0a96653ad

This histogram visualizes the distribution of sequence lengths from Oxford Nanopore sequencing data, comparing 1D+2D and 2D reads of *Silene latifolia* DNA. The chart shows how many reads fall into each length bin, highlighting the range and frequency of fragment sizes for both datasets. The underlying shell script uses `bioawk` with the `fastx` input mode to extract the `length()` of each sequence, writing the resulting measurements to separate text files before plotting. The visualization relies on the bioawk library’s FASTA/FASTQ parsing capabilities to generate the raw length counts.

Loading thumbnail…

Gist 3d7c2ec8630fd8451ee2b2ed513c2c4a

This example documents the assembly of a microbial genome from paired-end Illumina sequencing data. It shows the command-line workflow that converts raw FASTQ files to FASTA format and then performs a de novo assembly using the IDBA-UD software. The script demonstrates the use of the `fq2fa` utility to merge and convert paired reads, followed by an `idba_ud` assembly run with a single thread. The final assembly output is moved to a dedicated directory for further analysis, illustrating a typical bioinformatics pipeline for genomic sequence reconstruction.

Loading thumbnail…

Gist ac0e4a9bdb2f03d365c4402d04ecba09

This example shows a command-line workflow for detecting genetic variants from sequencing reads mapped to a reference genome. It first uses `samtools mpileup` to generate a binary call format (BCF) file, then `bcftools call` to produce a VCF file of variants. A second, independent variant call is made using `freebayes` with a ploidy setting of one, outputting its own VCF. The script processes all sorted BAM files in a mapping directory, using the NC_012967.fas reference, demonstrating two standard variant-calling pipelines for haploid samples.

Loading thumbnail…

Gist 39d6a8d17d83eb8f17c0926e30809957

This example shows a variant-filtering pipeline for genomic data, using bcftools to process VCF files from two different callers (samtools mpileup and freebayes). The script applies quality and proximity filters, including minimum QUAL scores, distance to indels, and indel cluster thresholds, via the bcftools filter command with options like `-i'%QUAL>10'`, `-g3`, and `-G10`. The output writes filtered VCF files with a LOWQUAL annotation for variants that fail the criteria. The code relies on the bcftools command-line API rather than a visualization library, and the data source is the initial VCF files in the variants directory.

Loading thumbnail…

Gist d5a955d9a667be4ff4afe7064affbb31

This example demonstrates a bioinformatics mapping workflow for processing sequencing reads. The shell script uses the BWA alignment tool to map trimmed FASTQ files from multiple clones against a reference genome (NC_012967.fas). It first indexes the reference with `bwa index`, then iterates through a list of runs from `fastq/list_run`, performing alignment with `bwa aln` using four threads and converting the results to SAM format with `bwa samse` while adding read-group metadata via the `-r` flag. The script outputs aligned SAM files into the `mapping` directory.

Loading thumbnail…

Gist 6cde24482216f46654efb9e0cef0f166

This example shows a Unix shell script for assembling and evaluating MinION nanopore sequencing data. It configures environment variables for Java, Perl, and the Canu assembler, then runs Canu with parameters for a 10kb genome, specifying an error rate and corrected nanopore reads as input. The script uses the `assembly-stats` tool to generate statistics for the resulting contigs and unassembled sequences, printing summary metrics to the console. The code relies on the Canu command-line interface, the `assembly-stats` binary, and shell environment exports for dependency management.

Loading thumbnail…

Gist 6344d0fe9ded24d86cd9e580c72e7101

This visualization compares read-length distributions before and after error correction of MinION long reads from Silene latifolia. The code uses the LoRDEC tool to correct and trim reads, then assembly-stats to generate summary statistics, likely producing histograms or cumulative frequency plots. The rendering relies on command-line output from assembly-stats, displaying changes in sequence length and count across three datasets: raw, corrected, and trimmed reads.

Loading thumbnail…

Gist b503b3f905281f7da44c76ba5ed1d8d9

This example demonstrates a Bash script that trims raw FASTQ sequencing reads using the `fastq-mcf` tool from the ea-utils package. It shows how to process multiple paired-end files in a batch, reading a list of sample identifiers from `fastq/list_run` and applying a quality cutoff of Q20. The script iterates over each sample, takes the forward read file (`${i}_1.fastq.gz`), and generates a trimmed output file (`${i}_1_trim.fastq`) in the same directory. Adapter sequences are specified in `$TPDIR/misc/adap_illumina.fas`, and the output is written to the project’s fastq folder.

Loading thumbnail…

Gist aa8c974207019f98e6d45a49488b2c4b

This visualization shows the process of generating pileup files from sequenced reads for a set of 29 samples. The Bash script iterates through a list of sample identifiers, using the `samtools mpileup` command to produce alignment summaries for each sample against a reference genome. The script relies on the command-line APIs of `samtools` for pileup generation, operating on sorted BAM files. The output from this script would be a text-based pileup format, which is not a graphical visualization but a data-preparation step for subsequent analysis. The code references a reference file and a list of SRR accession numbers, indicating the source is genomic sequencing data.

Loading thumbnail…

Gist 454d4384d1fd704c8d1933b01d2c2af4

This example shows a batch processing workflow for sequencing alignment files, automating the conversion of SAM files into sorted, indexed BAM files. The shell script iterates over a list of run identifiers, using the `samtools view` command to filter out unmapped reads with the `-F 4` flag, then pipes the output to `samtools sort` to create order-preserved BAM output. Each resulting file is indexed with `samtools index` for downstream genomic analysis. The script operates within a directory structure defined by the `$TPRESEQ` environment variable.

Loading thumbnail…

Gist 9a3defa4596db38a11fc0ec9549b4834

This example demonstrates a preprocessing workflow for raw paired-end Illumina sequencing data. It shows the trimming of low-quality bases and removal of adapter sequences using the `fastq-mcf` tool from the ea-utils suite, followed by quality control reporting with `FastQC`. The script runs `fastq-mcf` with parameters for a minimum quality score of 20, a mean quality threshold, and a 150-base pair read length, producing trimmed FASTQ files. These outputs are then processed by `FastQC` to generate quality assessment reports for both the forward and reverse reads, illustrating a standard bioinformatics pipeline for high-throughput sequence data preparation.

Loading thumbnail…

Gist 4d45fd0aa5761530e461fa7a84197fe3

This example filters a Perl script that parses a CSV-formatted matrix (`matrice_para.csv`) to extract gene names with no paralogs across 11 species. It writes matching identifiers to a text file (`genes_with_no_para.txt`). The Perl script uses a regular expression to match lines with eleven consecutive zero values, then outputs the first field. The process relies on standard Perl file-handling and pattern-matching operations rather than a visualization library.

Loading thumbnail…

Gist 4127915bd94a1fc0518bb0cceea3b612

This example shows a Perl script that filters complete CEGs (Core Eukaryotic Genes) from a CEGMA output FASTA file, extracting only sequences corresponding to KOG identifiers not listed as missing in the completeness report. It reads three input files—the CEGMA FASTA, a completeness cutoff table, and the completeness report—then writes a new FASTA file. The script uses Perl’s built-in file handling and regular expression matching to parse KOG IDs, track a flag for sequence inclusion, and output the selected sequences.

Loading thumbnail…

Gist 431bee0f995b471c4febe9e74accbdea

This example shows a list of KOG identifiers that were missed by the CEGMA completeness report, paired with their corresponding functional descriptions from a separate KOG ID file. The Perl script parses the CEGMA output to detect the section listing missing proteins, then extracts each KOG ID and cross-references it against the KOG ID data file to append the matching description to the output file. The script uses regular expressions to identify KOG IDs and relies on file handles to read and write the text-based data.

Loading thumbnail…

Gist ccffb77a3cba5716d7a983e6c009de95

This example shows a Perl script that extracts protein IDs and functional information from CEGMA output files by matching KOG identifiers. The code reads two input files, parses each line with regular expressions, and writes matching KOG entries with their descriptions to a new output file. The implementation relies on standard Perl file handling and pattern matching with the `/KOG\d{4}/` and `/^\[.+\]\s(KOG\d{4})\s(.*)$/` regex patterns, without using any external visualization libraries or APIs.

Loading thumbnail…

Gist f919aa6a77ff3feb4d8a6d77af5dee85

This example computes the number and length distribution of contiguous sequences from a FASTA file, then writes the results to a tab-delimited text file. It uses Perl’s `Math::Complex` module for mathematical operations, though only basic arithmetic appears. The script reads `gapCloserMinia.break.broken_assembly.fasta`, tracks sequence lengths via regex matching for `[ACTGN]+` lines, and outputs a numbered list of contig sizes, along with the mean and standard deviation. The visualization shows a histogram or table of contig lengths, derived directly from the computed file `tailles_contigues.txt`. There is no graphical rendering; the output is purely textual.

Loading thumbnail…

Gist babdf0de5f2b986506f621199e6a642d

This Perl script calculates the total length of a genome assembly by reading a FASTA file named `gapCloserMinia.break.broken_assembly.fasta`. It iterates line by line, summing the number of nucleotide characters (A, C, T, G) found on each line, ignoring headers and other non-sequence content. The script uses a simple regex match to detect sequence lines and accumulates the total count, printing the final genome size in base pairs to standard output. The computation is performed entirely with Perl's built-in file handling and string operators, requiring no external libraries or modules.

Loading thumbnail…

Gist e3718d6464d2ba18e5a08233edd0aeb1

This Perl script splits a multi-sequence FASTA file into individual FASTA files, one per sequence. It reads the input file line by line, opens a new output file whenever a header line starting with `>` is encountered, and writes the header and subsequent sequence lines to that file. The code uses the `open`, `close`, and `shift` built-in functions to manage up to 248 output files named `CEG0.fasta` through `CEG247.fasta`. The script demonstrates a simple file-parsing and output-splitting workflow for bioinformatics sequence data.

Loading thumbnail…

Gist fb39aee08b636aec6b8a68d4011241cf

This visualization counts the number of contigs in a genome assembly file. It parses the FASTA-formatted file `gapCloserMinia.break.broken_assembly.fasta` using a Perl script, incrementing a counter each time a line starts with the `>` header character. The final count is printed as a plain integer to the terminal. The script relies solely on Perl's built-in file-handling and regular-expression capabilities, with no external visualization libraries, and does not generate any graphical output.

Loading thumbnail…

Gist 143778d0c50388a317ebc30c0ec5de86

This Perl-based command-line tool calculates GC content and nucleotide percentages from a FASTA file. It reads the input file line by line, skipping headers, and tallies counts of G, C, A, T, and N bases. The output prints GC%, individual base percentages, and the N count, using basic string operations and conditional logic rather than external visualization libraries. The script demonstrates a simple text-based data summary workflow for bioinformatics sequence analysis.

Loading thumbnail…

Gist c994b5a229194ab2c98a8580d48f54ef

This example shows a Perl script that corrects FASTA sequence headers by replacing pipe characters with hyphens, making the files compatible with the CEGMA genome analysis tool. The script reads an input FASTA file and writes the corrected output to a second file. It uses the standard Perl file I/O operations `open`, `close`, and the regex substitution operator to modify only the header lines that begin with `>[A-Z]{3}`. The script also checks for an existing output file to prevent accidental overwriting, and it prints a usage message if the correct number of arguments is not provided.

Loading thumbnail…

Gist 4f72b1c54e9f05af3e88d9e0ca702760

This Perl script calculates the total number of nucleotides in a FASTA file. It reads the input file line by line, skipping lines that begin with the ">" character (sequence headers), and sums the length of every remaining line after removing newline characters. The script uses core Perl functionality, including the `-s` flag for optional switch parsing, the `shift` and `@ARGV` array for command-line arguments, and a standard file handle opened with `open`. It prints the final nucleotide count to standard output. The example demonstrates a simple command-line bioinformatics utility for sequence statistics.

Loading thumbnail…

Gist 776981b42d618f2717fb986bbf501186

This example counts the number of sequences in a FASTA file, displaying the total as a plain numeric output. It reads the file line by line and increments a counter whenever a line begins with the `>` character, which marks a new sequence header. The tool is a Perl script that relies on the standard Perl file-handling and regular-expression capabilities rather than any external visualization library. The output is a single integer representing the number of contigs, scaffolds, or genes, depending on the input file's content. The approach is purely computational, with no graphical rendering involved.

Loading thumbnail…

DataViz of Freight Transport around Europe

An animated, tile-based map visualizes freight transport volumes among European countries from 2010 onward. The visualization toggles between a traditional geographic projection and a grid layout where each nation becomes a rectangle. It renders country boundaries from GeoJSON data and animates transitions between the two modes. The project uses D3.js v4 for SVG rendering and animations, along with the geo2rect library to compute the rectangular tile positions, and loads trade data from a JSON file.

Loading thumbnail…

Europe geo to square tiles animation with geo2rect

This example animates a geographic map of Europe into a square tile grid, using the geo2rect library to morph each country’s polygon into a rectangle positioned at a custom grid location. The visualization loads Natural Earth-derived GeoJSON, simplifies multipolygons and holes, and uses D3 v4 with SVG paths and a Mercator projection. Clicking the toggle button switches between the original geo layout and the tiled arrangement, with a 2000-millisecond transition animating the transformation. The grid positions are manually defined in a configuration object, and the code relies on geo2rect’s internal computation of closest corner points to map each shape.

Loading thumbnail…

TP4

A choropleth map of French regions shows the weekly incidence of influenza-like illnesses during 2014, with a slider to step through the year and a tooltip on hover. The map uses d3.geoConicConformal and d3.geoPath to render region boundaries, while a d3.scaleQuantize maps case counts to a five-color scale. Data is loaded from a CSV and joined to GeoJSON features, with the legend displayed as colored rectangles.

Loading thumbnail…

TP4

A choropleth map of French administrative regions shows weekly influenza case counts from 2014, aggregated by region. A slider lets viewers scrub through the 52 weeks of the year, updating the map’s fill colors. Built with D3 v4, it uses `d3.geoConicConformal` for projection, `d3.geoPath` for rendering GeoJSON regions, and `d3.scaleQuantize` for color encoding. Data is loaded from a CSV file, with weekly values parsed via `d3.timeParse` and hover tooltips displaying the region’s name and current value.

Loading thumbnail…

Gist 5fd28a5383eb7254b2ac93e71b7d357d

This choropleth map visualizes the weekly incidence of influenza-like illness across French regions for 2014, using a green color scale to encode the cumulative case totals for November. A slider allows users to scrub through the 55 weeks of data, updating a displayed date label. The visualization merges CSV data with GeoJSON region boundaries, rendering the regions as SVG paths using `d3.geoPath` with a conic conformal projection. Color mapping is handled by `d3.scaleQuantize`, and a tooltip displays region names and values on mouseover.

Loading thumbnail…

[animated charts] stocks from dataset

This animated visualization cycles through five chart types—area, empty area, multiple line, stacked, and stream—to display monthly stock prices for Microsoft, Amazon, and IBM from a CSV dataset. The sequence begins with a single area chart, then empties it to an outline, followed by a multi-line chart, a stacked area chart, and finally a streamgraph. Built with D3 v4, the code uses `d3.area`, `d3.nest`, and `d3.scaleOrdinal` to structure and render the data as SVG paths, with a `transition().duration()` driving the sequential playback.

Loading thumbnail…

fresh block

This visualization shows the monthly stock prices of Microsoft, Amazon, and IBM from January 2000 to March 2010 as multi-series line charts. The chart uses a filled area beneath each line to emphasize price trends over time, with the data nested by company symbol. Built with D3 v4, it employs `d3.nest()`, `d3.scaleTime()`, `d3.scaleLinear()`, and `d3.line()` with a basis curve, rendering to SVG. The data is loaded from a local CSV file via `d3.dsvFormat`.

Loading thumbnail…

loading multiple stock data from dataset

This visualization shows monthly stock price trends for Microsoft, Amazon, and IBM from 2000 to 2010, with each company’s data plotted as a distinct colored line and identified in a legend. The code loads a comma-separated dataset, uses `d3.nest()` to group rows by symbol, and applies `d3.timeParse` and `d3.axisBottom`/`d3.axisLeft` for time and price scaling. It renders lines with `d3.line` and `d3.curveBasis`, and computes per-symbol maximum and sum values. The SVG is generated via D3 v4, with data sourced from a local CSV file.

Loading thumbnail…

loading multiple stock data from dataset

This example shows monthly stock prices for Microsoft, Amazon, and IBM from a CSV dataset. It draws multi-series line charts in SVG, then transitions each series into a stacked area chart with a smooth animation. The code uses d3.nest to group data by symbol, d3.line and d3.area for geometry, and d3.transition with a delay to sequence the morphing effect. Colors are assigned via d3.scaleOrdinal with d3.schemeCategory10.

Loading thumbnail…

D3 Show Reel

The D3 Show Reel cycles through ten chart types—lines, horizons, areas, stacked areas, streamgraph, overlapping areas, grouped bars, stacked bars, bars, and donut—using seamless transitions. It renders real monthly stock closing prices for Microsoft, Amazon, and IBM over ten years as animated SVG paths and shapes. The code uses d3.svg.line, d3.svg.area, d3.nest, d3.time.scale, and d3.timer to coordinate the morphing sequences, with color scales and clip paths for the horizon chart.

Loading thumbnail…

loading multiple stock data from dataset

This example displays monthly stock prices for Microsoft, Amazon, and IBM from January 2000 through March 2010, using a multi-line chart where each company’s price history is drawn as a colored line. The data is loaded from a CSV file containing symbol, date, and price columns, then grouped by symbol using `d3.nest()`. The visualization uses `d3.line()` with a basis curve, `d3.scaleTime()` for the x-axis, and `d3.scaleLinear()` for the y-axis, with an ordinal color scale for the three series. The chart is rendered as an SVG, with axes and a legend prepared via `d3.axisBottom` and `d3.axisLeft`.

Loading thumbnail…

fresh block

A single black line chart plots monthly values from a small JSON dataset, with light gray circles marking each data point. Hovering a circle turns it red, displays the exact value above it, and draws a dashed vertical guide line to the baseline. The visualization uses D3 v4 with SVG rendering, applying `d3.scaleTime`, `d3.scaleLinear`, and `d3.line` for the chart, plus mouseover handlers to toggle the interactive details. Axis labels show abbreviated month-year formats, with the final value annotated in larger monospace text.

Loading thumbnail…

simple line chart from dataset

A simple line chart renders twelve monthly data points from a local JSON dataset, plotting values over time. The SVG visualization uses D3 v4’s `d3.scaleTime`, `d3.scaleLinear`, and `d3.line` to draw the black line, with light gray circles for each point. Hovering over a circle triggers `handleMouseOver` and `handleMouseOut`, turning the circle red, displaying its value as text, and adding a dashed vertical guide line. The chart also labels each month along the bottom and shows the last value prominently on the right.