Fips: an OpenGL based FITS viewer

TL;DR

Fips is an open-source, cross-platform FITS viewer that leverages GPU-accelerated OpenGL rendering to enable efficient visual inspection of astronomical data, marking a novel use of GPU technology in FITS visualization.

Contribution

This paper introduces Fips, the first FITS viewer primarily implemented on GPU using OpenGL, enhancing image rendering efficiency for astronomical data inspection.

Findings

GPU-based rendering improves performance

Fips is cross-platform and open source

Demonstrates effective use of GPU in FITS visualization

Abstract

FITS (Flexible Image Transport System) is a common format for astronomical data storage. It was first standardised in the early 1980s. Even though astronomical data is now processed mostly using software, visual data inspection by a human is still important during equipment or software commissioning and while observing. We present Fips, a cross-platform FITS file viewer open source software. To the best of our knowledge, it is for the first time that the image rendering algorithms are implemented mostly on GPU (graphics processing unit). We show that it is possible to implement a fully-capable FITS viewer using OpenGL interface. We also emphasise the advantages of using GPUs for efficient image handling.

Figures

Tables

Table 1. Table 1: Support matrix. Here, the specific values of n 𝑛 n from Eq. ( 2 ) are presented for different possible cases. N = 𝙱𝙸𝚃𝙿𝙸𝚇 𝑁 𝙱𝙸𝚃𝙿𝙸𝚇 N=\mathtt{BITPIX} for integer formats, negative 𝙱𝙸𝚃𝙿𝙸𝚇 𝙱𝙸𝚃𝙿𝙸𝚇 \mathtt{BITPIX} denotes floating point numbers. The case n = N 𝑛 𝑁 n=N , when no colour trick is used, is denoted as ‘native’. † single precision floating point textures are supported in OpenGL 2.1 via extensions but cannot be used in Fips due to Qt framework limitations. ∗ double precision floating point values must be unpacked from two 32-bit unsigned integers using ARB_gpu_shader_fp64 extension.

FITS $\mathrm{𝙱𝙸𝚃𝙿𝙸𝚇}$	OpenGL 2.1	OpenGL 3
$8$	$n=8$ (native)	$n=8$ (native)
$16$	$n=8$ (Luminance, Alpha)	$n=16$ (native)
$32$	$n=8$ (RGBA)	$n=16$ (Red, Green)
$64$	$n=16$ (RGBA)	$n=16$ (RGBA)
$-32$	not supported†	native
$-64$	not supported	native via the extension∗

Equations

$$physical\_value=\mathtt{BSCALE}\cdot array\_value+\mathtt{BZERO},$$

$$t_i=\frac{\{y{\}}_i^{(n)}}{2^n-1},i=\mathrm{0...}\left(\frac{N}{n}-1\right),$$

$$y=\sum _{i=0}^{\frac{N}{n}-1}{2}^{N-(i+1)n}\left(2^n-1\right)\cdot t_i.$$

$$t_0\leftarrow t_0-\frac{2^n}{2^n-1}\text{mbox}if{t}_0>\frac{1}{2}.$$

$$g=\frac{\mathtt{BSCALE}}{M-m}\sum _{i=0}^{\frac{N}{n}-1}{2}^{N-(i+1)n}\left(2^n-1\right)\cdot t_i+\frac{\mathtt{BZERO}-m}{M-m},$$

$$g=\left(\mathbf{c},\mathbf{t}-\mathbf{z}\right),$$

$$\mathbf{f}=\left(1-g\right){\mathbf{f}}_0+g{\mathbf{f}}_1,$$

$$g=\frac{\mathtt{BSCALE}}{M-m}y+\frac{\mathtt{BZERO}-m}{M-m},$$

$$x_1=\lfloor x_{2}W\rfloor ,y_1=\lfloor y_{2}H\rfloor ,$$

$$x_2=\frac{x_3}{2Wf}+\frac{1}{2},y_2=\frac{y_3}{2Hf}+\frac{1}{2}.$$

$$x_4=x_3\cos \alpha +y_3\sin \alpha ,y_4=-x_3\sin \alpha +y_3\cos \alpha .$$

$$x_4=x_{4\mathrm{r}}+x_5\frac{W_{\mathrm{r}}}{2},y_4=y_{4\mathrm{r}}-y_5\frac{H_{\mathrm{r}}}{2},$$

$$x_5=\frac{2x_6-\left(w-1\right)}{w},y_5=\frac{2y_6-\left(h-1\right)}{h},$$

Full text

††journal: Astronomy and Computing

1 Introduction

FITS (Flexible Image Transport System), a famous image format, was first introduced a few decades ago, in the early 1980s [1]. Since that time, it has become the most popular format to store astronomical optical observations. Now, in 2019, FITS looks like a legacy format rather than a modern technology item [4]. For instance, it uses the big-endian storage format, while most current server, desktop and mobile processors use little-endian storage format [5, 6, 7]; moreover, FITS relies internally on a 2880-byte-alignment structure [1]. Whereas it was a natural choice for tape-based storage media, modern file systems on hard drives and solid state drives operate with pages of $2^{N}$ size. For some upcoming projects, it is the JPEG 2000 [8] data format that is being discussed now by the astronomical community [9].

However, there are two main things that make us believe that FITS will continue be used for decades to come. First, bulk of astronomical data in the world is stored in FITS format. Second, astronomical data acquisition software or data processing software are mostly FITS-centric. As long as visual human inspection of raw or processed astronomical image data is still an important part in algorithm and software troubleshooting procedures, as well as in hardware alignment and commissioning, it would be helpful to have yet another FITS image viewer software.

There is, of course, a lot of available software doing this work well, among them SAO DS9 [10], Ginga [11, 12], etc. All these solve the same problems while rendering data from a file to the user screen. An application has to parse and read the data from the file. Then, it has to make geometric transformations for scale, pan, rotation, etc. After that, colour maps are applied in order to narrow down the FITS range of values to the 8 bit colour depth.

In this paper we concentrate on how these tasks may be offloaded to the GPU (graphics processing unit). Modern GPUs have many hard-wired features accelerating typical 2D and 3D-rendering tasks. These advantages are employed by a wide variety of desktop applications such as web-browsers [13, 14] and even graphical terminal emulators [15, 16]. We propose a FITS viewer software implementation based on the GPU acceleration. After a raw FITS file data loaded into the GPU memory, the geometric and colour transformations are handled by GPU.

It is widely believed by the developer community that software generally should use a minimal amount of the computational resources while keeping its source code simple, clear, and easily maintainable.222Many recognised experts in computer science often note this. For instance, Cormen et al. ([17], § I.2) say: “If computers were infinitely fast, any correct method for solving a problem would do. You would probably want your implementation to be within the bounds of good software engineering practice…”; or Knuth ([18], § 1.1) says: “In practice we not only want algorithms, we want good algorithms in some loosely-defined aesthetic sense. One criterion of goodness is the length of time taken to perform the algorithm… Other criteria are the adaptability of the algorithm to computers, its simplicity and elegance, etc.”. The GPU-based end-to-end rendering of the raw FITS file data fulfils both of this conditions. The specific dedicated design of modern GPUs provides an opportunity to render graphics in energy and computationally efficient way. GPU programming interfaces such as OpenGL, Direct X, or Vulkan allow a programmer to describe the high-level geometric and colour characteristics of the scene. In our case, only a few lines of high-level source code are required to program GPU.

In this paper we prove that the end-to-end OpenGL rendering of FITS file data can be practically implemented as software application. This proof of concept application is called Fips. It is a cross-platform open-source graphical user interface software. The application main window is shown in Fig. 1.

The outline of the paper is as follows. Section 2 explains briefly how modern graphics processing units operate and how one could control them using the OpenGL interface. Section 3 describes the essence of the FITS format and how it can interoperate with the OpenGL. Then, in Section 4, we demonstrate how the FITS data may be transformed into a coloured image displayed by Fips. The software evaluation and testing are described in Section 5. In the Discussion section, we highlight further possible applications of the techniques described here. Finally, we summarise the advantages of the GPU use in the Conclusion. A describes how the FITS and OpenGL coordinate systems are connected to each other.

2 Brief Introduction to OpenGL

General-purpose graphics processing units are widely used in modern astronomy for solving visualisation problems [20] and computational linear algebra problems [21, 22], with the latter seemingly more widespread. Thus, it makes sense to briefly introduce the graphics pipeline here. A more comprehensive OpenGL description can be found in its specification [3]. In what follows, only details that are important for current work will be highlighted.

OpenGL is essentially a programming interface, i.e. a library with a standardised set of functions available on different platforms or operating systems. It is assumed (although not required) that the library functions should be implemented using the graphics processing unit hardware, which is capable to perform a limited set of the most frequently required graphics rendering operations.

Generally, the programming work that uses the GPU with OpenGL does not resemble conventional programming; instead, one may substitute routines of some kinds into the predefined data processing pipeline and operate with the predefined types of data objects.

In an OpenGL application, different kinds of objects may exist. A point in 3D space that belongs to a geometric object is called a vertex. In typical 3D applications, geometric objects normally consist of hundreds and thousands of vertices; however, for our purposes, it is sufficient to have four vertices forming a rectangular plane in our application. The plane is used to draw picture on its surface. Arrays of vertex attributes (coordinates) are transferred from CPU to GPU.

It is usually convenient to define vertex coordinates in an object-centric coordinate system. However we need to place each object at its desired place in order to form the world scene. This is the reason for vertex shaders. These are GPU-side routines (functions) performing an arbitrary geometric transformation of vertex coordinates. The shaders are designed to process only one vertex at a time. Since there is no concurrence that allows engaging in parallel as many shader units during the execution as are available at one particular hardware. They are usually used to transform vertex coordinates from the local object coordinate system to the camera coordinate system. The transformation is often defined as a matrix-vector operation; these transformations may be of various kinds: we can translate, rotate, scale or distort an object. In fact, what the user can see at the display is a world projection onto the xy coordinate plane.

Graphical memory fragments that contain raster pictures are called textures. They are similar to traditional uncompressed bitmap images and FITS images. The texture content also may be transferred between CPU and GPU in both directions. The possible ways to arrange the pixel colours in texture memory are given in the OpenGL specification [3]. For instance, one may store a colour picture as an array of usual RGB triplets and a monochromatic image as an array of single channel pixels. The process of transforming FITS images into OpenGL for all possible formats will be discussed in Section 4.

Texture data are accessed via samplers. A sampler can be thought of as the C operator [] indexed by a real value coordinate rather than by an integer index. Among other things, samplers perform the interpolation before returning a value. There may be two kinds of interpolation: the nearest neighbour interpolation and the linear interpolation. Although we use the nearest neighbour interpolation, the returned result is always normalised to $[0;1]$ range independently of the data storage format.333OpenGL 3.0 and later versions support the access to an normalised raw value. As we see later in Section 4, this does not give us a great advantage For instance, the standard 8-bit colour channel value $255$ stored in a texture will be returned as $1.0$ by a sampler.

Vertices form the edges and faces of geometric objects, and textures can be drawn on these faces. At the same time, the orientation between the surface and the camera is also taken into account; for instance, the hidden parts of objects are not rendered at all.

Fragment shaders are GPU routines that are used to colourise sides of geometric objects. Formally, this can be considered as the mapping between fragment coordinates and their required colour, where each fragment is a tiny piece of the scene seen by the user. In our simple case, the fragment shader prescribes that the hardware would draw the texture containing the image onto a singleton rectangular plane without distortion.

After everything is loaded to the graphics memory and preconfigured, an application would trigger the drawing, and the user would be able to see 3D scene snapshot at the screen. In case the objects are to be rearranged, altered vertex shaders parameters are loaded and the drawing is performed again. In modern 3D professional software and games, it is usually required to perform multiple renderings to achieve realistic light distribution over the single frame. For this purpose, depth textures and stencils are used.

3 FITS Rendering Implementation

Our goal could be achieved by performing two tasks. First, we need to load a FITS image to the graphics memory. Second, we should render the image using the required orientation, magnification, colour-mapping, etc.

If any transformation between the FITS image memory representation and GPU texture representation is needed, it would use additional CPU-based calculations. This is why we focus on cases where byte-representations are similar at CPU (FITS) and GPU (texture) sides. For instance, a 16-bit FITS image is an array of subsequent 16-bit integers. A monochrome 16-bit texture is also an array of subsequent 16-bit integers. Since it is monochrome (i.e. single-channel), a single integer represents a whole single pixel. This means that memory representations of the 16-bit FITS image and the 16-bit single channel texture should be identical except for the byte order (see below). Unfortunately, this is not always the case. For instance, if we have a 64-bit integer FITS image, we cannot just specify that the texture should have a single 64-bit channel, because there are no 64-bit integer textures in OpenGL [3]. To overcome this difficulty, we just set the OpenGL texture format for the image memory so that it still has 64-bit per pixel and, at the same time, multiple colour channels (for instance, 16-bit RGBA). This approach hinders, to some extent, the data access by GPU, but we will show how to deinterleave colour channels to obtain the initial value in Section 4.

Note, that the endianness is also accounted by OpenGL. FITS stores its data in 8-bit bytes using the big-endian format [23]. On the other hand, OpenGL uses the machine-specific byte ordering [3]. Today, the vast majority of workstations use the little-endian format, e.g. x86/x86-64 [5], ARM machines with Windows [6], iOS [7], and almost all Linux-based operating systems with very few exceptions. Fortunately, we do not need to explicitly handle the FITS endianness. It is sufficient to specify that the data are big-endian on CPU when calling the OpenGL data transport function. Although it is not strictly specified, the byte swapping may be even performed in the graphics processing unit hardware if this is required while texture storing.

Since the GPU has an access to the FITS data, the image can be easily transformed and rendered. Note also that the following two tasks are completely separated when programming OpenGL. The first task is the geometric transformation of 3D space objects. Assume that we have a rectangular plane has the same aspect ratio as the initial FITS image has. A broad variety of geometric transformations may be applied to the plane independently of what is going to be drawn on this plane. This is how the pan, scale and rotation are implemented. One only needs to carefully program straightforward transformation formulae given in A.

The second task is rendering the texture onto the plane. This is always performed in the local plane coordinates independently of the final plane orientation and the scale. The task that is handled in the fragment shader is essentially the mapping between a local plane coordinate and its visible colour. Specific coordinates are implicitly determined by OpenGL and the colours are evaluated simultaneously.

4 Fragment Shader Organisation

The fragment shader is a place where colour transformations are performed. Let us describe the tasks to be solved in the shader code:

FITS format requires the following transformation to be applied to the data stored in the file:

[TABLE]

where $\mathtt{BZERO}$ and $\mathtt{BSCALE}$ are stored in the FITS header, $\mathtt{physical\_value}$ is a ‘true’ value, and $\mathtt{array\_value}$ is a byte-representation stored in the file. Since we load the whole file into the graphics memory, we have to handle this equation using the GPU as well.

• 2.

Astronomical data usually have a greater number of bits per colour than modern screens have or human eye can distinguish. In common modern operating systems, 8-bit colours are used, whereas astronomical data coming from CCD are likely to contain 16-bit (or even greater) ones. This is why we prefer to adjust minimal and maximal levels to give an image more contrast in order to see all interesting details.

• 3.

Different colour mapping schemes should be applied to data. In FITS files, we usually have single-channel colour formats. Each pixel is described by a single value. In optical astronomy, it is usually expressed in ADU units (analogue-digital units) coming from a CCD (charge-coupled device). [24] So it is natural to represent the data as greyscale pixels. However, we could use any other colour instead of white to represent the brightest image pixels.

• 4.

The last but not the least is format converting. FITS supports different data storage bit depths specified by the $\mathtt{BITPIX}$ header value: up to 64-bit integer and floating point numbers.444The following FITS data formats exist: 8-bit unsigned integers ($\mathtt{BITPIX}=8$), 16-, 32-, 64-bit signed integers ($\mathtt{BITPIX}=16,32,64$), single and double precision floating point numbers ($\mathtt{BITPIX}=-32,-64$). The challenge here is that earlier OpenGL versions allow using only 8 or 16 bits per colour channel, and even the latest OpenGL does not support 64-bit textures.

To solve this last task, we use the process of deinterleaving colours. First, we are going to describe how the data are transformed in a forward way in the example shown in Fig. 2. After that, we will construct the inverse transformation. At the top level of Fig. 2, three consecutive pixels of a 64-bit FITS image are shown. The middle level presents the same data loaded into the little-endian GPU. Since there is no option to specify its real 64-bit format in OpenGL, the pixel is considered to have four subsequent 16-bit channels. The bottom level displays what we may obtain when accessing the texture by the sampler. These are four floating point numbers to represent a pair of bytes each. To summarise, each texture pixel for the $i$-th colour channel ($t_{i}$) may be expressed as follows:

[TABLE]

where $y$ is the initial value; $N$ is the real bit size of the input FITS pixel ($64$ in Fig. 2); $n$ is the bit size of the colour channel ($16$ in Fig. 2); $\{\cdot\}_{i}^{(n)}$ denotes the $i$-th $n$-bit word of $\cdot$ value  (the $i$-th colour channel in Fig. 2); $i=0$ corresponds to the most significant word. Since the sampler returns the normalised value, we have $2^{n}-1$ in the denominator, while $t_{i}\in[0;1]$. Note that Eq. (2) is still valid when $N=n$ and no colour transformation is performed.

The expression for the $\mathtt{array\_value}$ $y$ may be written as follows:

[TABLE]

Since the internal texture representation is unsigned, the following substitution should be done for the signed integer ($\mathtt{BITPIX}=16,32,64$):

[TABLE]

Using Eq. (1) and the linear normalisation transformation, we obtain the following expression:

[TABLE]

where $m$ and $M$ are the minimal and maximal physical values set by user, respectively, according to Eq. (1). If a $\mathtt{physical\_value}\in[m;M]$, then $g\in[0;1]$, otherwise $g$ is clamped to this interval.

Equation (5) may be rewritten in the following convenient inner product form:

[TABLE]

where $\mathbf{t}$ is the vector of $t_{i}$ values, $\mathbf{c}$ and $\mathbf{z}$ are vector functions of $\mathtt{BSCALE}$, $\mathtt{BZERO}$, $m$, and $M$. The vectors $\mathbf{c}$ and $\mathbf{z}$ are constant for every image pixel, so they can be precalculated on the CPU. OpenGL allows us to efficiently calculate inner products on the GPU. Note that by construction, $\left|z_{i}\right|<1$ for every $i$, what ensures that the precision is not lost in numerical operations.

The final fragment colour is the $\mathbf{f}$ vector consisting of four normalised components: red, green, blue, and alpha. To represent the data in user colours, we may calculate the fragment colour as follows:

[TABLE]

since $g$ is implicitly clamped to the $[0;1]$ interval after using Eq. (6). This linear interpolation is implicitly performed by the sampler of special one-dimensional texture consisting of two-colour pixels (the interpolation node) that store the $\mathbf{f_{0}}$ and $\mathbf{f_{1}}$ colour constants. Further generalisation may be achieved if additional interpolation nodes are added to the colour map texture, allowing an easy implementation of multi-colour maps such as ‘black–blue–yellow‘.

In Table 1 we present particular values for $n$ in different possible cases. Note that the following equation should be used instead of (5) for floating point formats:

[TABLE]

because the sampler output $y$ is not normalised for floating point textures, and the colour trick is not used in this specific case of floating point number representation in memory. In order to handle double precision floating point FITS files, ARB_gpu_shader_fp64 extension should be used [25]. In this case the internal representation of GPU data is set up to two-channel 32-bit unsigned integers. After that, the sampler output in the fragment shader is subjected to the action of a specific built-in magic function. The function performs reinterpretation cast, taking a pair of 32-bit unsigned integers obtained from the texture, and returns the double precision floating point value.

5 Software Evaluation and Validation

Users expect modern applications to provide responsive user interface. Interface responsiveness gives a user ability to immediately see the results of user actions. For instance, it is important when touch-pad gestures are employed as a part of user interface requiring continuous user actions to be handled with low possible latency. In our case the following user actions trigger the image redrawing: changing the cut levels, switching colour maps, zooming, panning, and rotating the image. We measured the time required to redraw the image under these typical actions.

Three hardware setups have been tested with the laptop PC. The software rendering was performed using Mesa llvmpipe555https://www.mesa3d.org/llvmpipe.html driver with Intel Core i7-3520M CPU, the hardware rendering was performed using integrated Intel HD Graphics 4000, and the hardware rendering was performed using discrete NVidia GeForce GT 635M. We considered two image geometry sizes: $800\times 448$ pixels and $4096\times 4096$ pixels, with all six bit depths, twelve image files in total. In all cases the application ran in full screen mode at $1980\times 1080$ resolution. This allowed us to examine two cases: when the image was stretched for the small images and shrunk for the large images. For each case, a few hundreds of drawings were carried out.

We found that the image rotation rendering is the most expensive of all operations, so expenses for it may be considered as an upper bound estimate compared to other expenses. The obtained results are given in Fig. 3 and Fig. 4. The following specific features can be seen in the figures. One may see that Intel hardware behaves similarly to NVidia hardware. Note that the required memory size is proportional to the image bit depth. In Fig. 3, one can see that the rendering time for the $4096\times 4096$ pixels image depends almost linearly on the bit depth. In this case, the performance seems to be limited mainly by the memory bandwidth. At the same time, the $800\times 448$ pixels image is small enough to fit into modern memory caches and therefore no dependence on the bit depth is revealed in all these three rendering engines. Also in the case when the double precision floating point image is formed on the NVidia GPU, some specific additional overheads appear.

The same kind of measurements were carried out for panning. We found that the rendering time doesn’t depend on the image bit depth. It is approximately the same as the time for rotating the 8-bit image. It seems that the time depends only on the visible image size.

The llvmpipe renderer is considerably slower as compared to the hardware cases. Note that the llvmpipe produces just-in-time compiled code highly optimised for using CPU vector instructions. Hence, the llvmpipe rendering time is considered as a lower bound estimate for any CPU-based implementation. However, we were able to see some glitches during llvmpipe rendering for all considered actions. The glitches look like vertical synchronisation issues: the top and bottom parts of the picture correspond to the different subsequent frames. This is in agreement with Fig. 4. Indeed, it may take more than $30$ ms to render the $4096\times 4096$ pixels image which corresponds to $\approx 30$ frames per second, given that the measurements were carried out on an unloaded CPU. The measuring data strongly indicate that the GPU-based implementation is more efficient.

Functional testing of the graphic user interface application is a more challenging task than to test the server application. This is explained by the fact that automatic unit tests cannot be applied to the application graphic interface parts. Therefore, we use the unit testing where it is possible, such as parsing the FITS files, or assessing the coefficients in Eq. (6). The integration of Travis CI and GitHub allows us to easily check the application for a wide range of compilers and Qt framework versions.

To ensure validity of the algorithm described in Section 4, we may either render the image to a texture framebuffer, extracting pixel numeric values, or we may use the system colour picker application to see pixel values on the screen. We used the latter approach since our key interest is to find out what the user can actually see on the screen. A simple greyscale gradient testing image allows us to perform this kind of end-to-end manual testing.

6 Discussion

The OpenGL application may be helpful for astronomical purposes not only due to its ability to perform simple FITS image rendering. The so-called texture arrays available with OpenGL 3 may be properly used to support 3D FITS data. A 3D data cube stored in GPU video memory in the form of texture array representation may give us an opportunity to implement efficient GPU video playback. The representation of data cubes in the form of a video is currently implemented in e.g. Ginga and FITSWebQL FITS viewers [11, 26].

Since OpenGL is capable to support the opacity, we may use another interesting option; namely, to draw multiple FITS images as semi-transparent colour layers, differently placed and differently orientated. This option would be helpful for applications similar to those in which the blinking technique in astronomy is currently used: the manual transient object search. A similar technique is widely adopted by amateur astronomers [27, 28]. However, in this case, a nonlinear geometric transformation of the image is ordinarily required to compensate for third order aberrations. This may be easily done using the expansion of a current four-vertex-rectangle plane to a triangle mesh, a common technique employed in the 3D computing world.

Note also that embedding such a geometric transformation engine into the astronomical image processing pipeline considerably increases the processing rate. This property is very valuable when looking for asteroids using robotic observatories. The technology incorporating OpenGL into the head-less server application is called EGL (Embedded GL); it uses a texture attached to a frame buffer object instead of the hardware display that performs scene rendering [29]. Thus, the rendering output may be downloaded to the CPU after the render operation is performed.

One challenge for upcoming extra-large survey projects, such as LSST [30], is to increase the astronomical image processing cadence. When using OpenGL computing shaders (available with OpenGL 4.3) or OpenCL/OpenGL integration, a full stack of the common astronomical pipeline may be implemented: from bias subtraction and flat fielding to pixel clustering for star extraction, as it has been proposed e.g. by Warner, et al. [31].

Many of the techniques we have described could be applied to WebGL-based FITS image rendering [32]. WebGL is a standard programming interface for modern web browsers that allows OpenGL programming in JavaScript. Several years ago, there was some publication of plans for the implementation of telescope control system interfaces and astronomical data archives in the form of web applications. This approach has many advantages. For example, web applications scale well for any OS and any platform, they do not require installation and may be easily run on a guest-observer laptop [33, 34, 26]. A possibility to render an initial data image acquired from the hardware is also of importance here. These are most important cases when the implementation of WebGL-based application techniques may prove very helpful.

7 Conclusion

In this paper we have introduced new software for rendering astronomical data in the form of FITS images. The major design novelty is using GPU acceleration: the image geometry and colour transformation are programmed in GPU using the OpenGL programming interface. It turns out that the full processing stack, starting with loading bytes from a FITS file into the GPU memory, to rendering the picture on the user screen, may be implemented by applying all necessary data transformations in the GPU.

OpenGL provides basically two main features: it increases processing speed using hardware specially designed for geometric and colour image transformations, and simplifies programming such transformations in case the developer needs them.

The proposed design may clearly have some important effects for astronomy. For example, a decrease in the required CPU load would obviously improve the experience of the end user. Some other opportunities that may arise when using OpenGL to process astronomical data are yet to be investigated. Fips source codes are available at the GitHub web site, so we hope that other open source developers will join the efforts for further software improvement. Prebuilt binary packages are available for Windows, openSUSE 15.1+, Fedora 30+, Homebrew Caskroom macOS package manager, and Flatpak Linux package manager.

Acknowledgements

Authors thank the referees for the constructive comments which helped to improve the paper. We also thank Ivan Migalev from Polzunov Altai State Technical University (Barnaul, Russia) for the preparation of Fips Windows package, and our colleague Maria Pruzhinskaya for useful discussions on the paper. The study was partially supported by RBFR grants 18-32-00426 (when preparing the paper) and 18-32-00553 (when verifying the fragment shader equations).