An introduction to FITSWebQL

TL;DR

FITSWebQL is an upgraded web service and standalone application that enables interactive visualization of large FITS data cubes with real-time spectrum analysis, predictive latency handling, and multi-file viewing capabilities.

Contribution

This paper introduces new features like multi-file RGB composite viewing, latency prediction with Kalman filters, and a Rust-based backend for improved stability in FITSWebQL.

Findings

Supports viewing of 100GB FITS files in browsers

Implements latency prediction to enhance user experience

Enables multi-file RGB composite visualization

Abstract

The JVO ALMA WebQL web service - available through the JVO ALMA FITS archive - has been upgraded to include legacy data from other telescopes, for example Nobeyama NRO45M in Japan. The updated server software has been renamed FITSWebQL. In addition, a standalone desktop version supporting Linux, macOS and Windows 10 Linux Subsystem (Bash on Windows) is also available for download from http://jvo.nao.ac.jp/~chris/ . The FITSWebQL server enables viewing of even 100GB-large FITS files in a web browser running on a PC with a limited amount of RAM. Users can interactively zoom-in to selected areas of interest with the corresponding frequency spectrum being calculated on the server in near real-time. The client (a browser) is a JavaScript application built on WebSockets, HTML5, WebGL and SVG. There are many challenges when providing a web browser-based real-time FITS data cube preview service over high-latency low-bandwidth network connections. The upgraded version tries to overcome the latency issue by predicting user mouse movements with a Kalman Filter in order to speculatively deliver the real-time spectrum data at a point where the user is likely to be looking at. The new version also allows one to view multiple FITS files simultaneously in an RGB composite mode (NRO45M FUGIN only), where each dataset is assigned one RGB channel to form a colour image. Spectra from multiple FITS cubes are shown together too. The paper briefly describes main features of FITSWebQL. We also touch on some of the recent developments, such as an experimental switch from C/C++ to Rust (see https://www.rust-lang.org/) for improved stability, better memory management and fearless concurrency, or attempts to display FITS data cubes in the form of interactive on-demand video streams in a web browser.

Tables

Table 1. Table 1. : A side-by-side comparison of Google’s VP9 and HEVC video codecs together with their corresponding C API libraries.

Google’s VP9 (libvpx)	HEVC (x265)
libvpx library: both an encoder and decoder	x265 library: only an encoder
	(search the Internet for a decoder
	to suit your task)
slower, less efficient encoding,	faster than libvpx, more efficient
inferior multithreading	(bandwidth-friendly), scales well
	across all CPU cores
no greyscale (an overhead of handling	YUV 4:0:0 support (server-encode as
redundant RGB/YUV channels)	greyscale, add colour in the client)
an easy API, trivial to compile the	extreme difficulty finding a suitable
decoder into WebAssembly	JavaScript decoder (DIY: FFmpeg C
	API compiled to WebAssembly)

Full text

The FITSWebQL server enables viewing of even 100GB-large FITS files in a web browser running on a PC with a limited amount of RAM. Users can interactively zoom-in to selected areas of interest with the corresponding frequency spectrum being calculated on the server in near real-time. The client (a browser) is a JavaScript application built on WebSockets, HTML5, WebGL and SVG.

There are many challenges when providing a web browser-based real-time FITS data cube preview service over high-latency low-bandwidth network connections. The upgraded version tries to overcome the latency issue by predicting user mouse movements with a Kalman Filter in order to speculatively deliver the real-time spectrum data at a point where the user is likely to be looking at. The new version also allows one to view multiple FITS files simultaneously in an RGB composite mode (NRO45M FUGIN only), where each dataset is assigned one RGB channel to form a colour image. Spectra from multiple FITS cubes are shown together too.

The paper briefly describes main features of FITSWebQL. We also touch on some of the recent developments, such as an experimental switch from C/C++ to Rust (see https://www.rust-lang.org/) for improved stability, better memory management and fearless concurrency, or attempts to display FITS data cubes in the form of interactive on-demand video streams in a web browser.

1 Introduction

Historically the ALMA WebQL service offered by the Japanese Virtual Observatory dates back at least to the year 2012 when it was presented during the ADASS XXII Conference (Eguchi et al. 2013). Afterwards, in order to keep up with ever growing FITS file sizes coming out of the ALMA observatory and also to offer improved functionality, newer versions have been released on a regular basis. For example, released in 2017, version 3 introduced an experimental 3D view of FITS data cubes. In 2018 the current version 4 — completely re-written from scratch in the Rust programming language — features real-time streaming videos of individual frequency channels in the FITS data cubes. The service can be accessed from the JVO Portal, found at https://jvo.nao.ac.jp/portal/top-page.do . The latest version 4 of the software (which includes the standalone desktop edition) is freely available from the following GitHub repository: https://github.com/jvo203/fits_web_ql . The unchanging motivation behind this web service is to provide a FITS file preview (quick look) and cut-out capability through a web browser. The service allows end users to view over 100GB-large FITS files in a web browser without ever having to download the underlying FITS files. After previewing FITS files users may choose to download interesting FITS files either in whole or to stream a partial region-of-interest (cut-out) from the JVO server to their own computers.

2 Architecture

The new version 4 initially started as a small feasibility study to find how easy it would be to re-implement the server part of FITSWebQLv3 in Rust. There are good reasons for switching from C/C++ to a new systems programming language such as Rust as it brings important benefits such as memory safety (no memory leaks), thread safety (no data races), better (smoother) multithreading compared with OpenMP in C/C++ and a complete lack of segmentation faults (no crashes) due to inherent safety measures built into the Rust language. It is certainly possible to write C/C++ programs that are free of memory leaks and do not crash but from a programmer’s standpoint Rust makes accomplishing these tasks much easier, all without sacrificing performance. In addition, Rust has an integrated HTTP/WebSockets networking library: actix-web that compares favourably with the previously used disparate mix of C libmicrohttpd and C++ $\mu$WebSockets.

With the Rust port under-way work had also been progressing on adding streaming video capability to the main v3 C/C++ codebase. However, once all the bottlenecks with Rust have been identified and dealt with, another benefit has come to light: the original C/C++ codebase has become rather complex and adding new functionality has turned into an error-prone process running the risk of introducing memory leaks and bugs. Hence a decision has been taken to complete the switch from C/C++ to Rust and add streaming video functionality to the new version v4, of which the full client-server architecture can be seen in Figures 1- 2.

A two-way communication between the client (a web browser) and the Rust server occurs over WebSockets, which halve the network latency and are more efficient in handling small messages compared to traditional AJAX HTTP requests. On the server side, the Rust language binds together various C/C++ libraries for which there is no high-performance 100% pure-Rust implementation available. In particular, the computation-intensive parts are SIMD-parallelised using the Intel SPMD Program Compiler.111The open-source Intel SPMD compiler (see https://ispc.github.io) should not be confused with the paid-for Intel C/C++/Fortran compiler suite. Unfortunately the no-crash guarantees do not extend to external non-Rust libraries which may leak memory and may contain segmentation fault-causing bugs. One needs to be very careful when choosing which C/C++ libraries to call from Rust.

On the client side we have taken advantage of the latest developments in browser technologies: the widespread adoption of WebAssembly (Wasm) that allows developers to compile C/C++ code to a binary Wasm stack machine code executed at a near-native speed inside a web browser.222https://webassembly.org In particular the CPU-intensive parts: real-time decoding of HEVC video frames and the application of a user-specified colourmap to greyscale video frames have been greatly accelerated with WebAssembly.

2.1 VP9 vs. HEVC comparison

During the initial development originally the author intended to use the HEVC (via its x265 encoder library) codec to handle real-time video streams. However, finding a suitable JavaScript and/or Wasm decoder has proved impossible. The resources freely available on the Internet did not meet our requirements. They were too outdated; they did not support the latest HEVC specification. As an alternative, after exploring other codecs i.e. Cisco’s Thor, initially we integrated Google’s VP9 libvpx library into our project. However, due to inferior multithreading capabilities of libvpx and codec inefficiencies compared with a superior HEVC solution, we decided to return to using HEVC/x265. Since there was no suitable off-the-shelf HEVC browser decoder available, we were forced to adapt the HEVC decoding part from the FFmpeg C library and compile it to WebAssembly for fast native execution in a web browser.

As a result of this somewhat convoluted development process, as of now the VP9 library is still used to compress FITS 2D images (as VP9 still keyframes) for display in a browser whilst the more capable HEVC x265 library handles real-time video streaming. Table 1 shows the main pros and cons of the two codec formats.

3 Conclusions

Based on our experience at JVO Rust has largely lived up to its promises. Not only did performance not deteriorate, in a few places it has actually improved compared to the C/C++. The only disadvantage of Rust seems to be its steep learning curve.

4 References