{'fraction_non_alphanumeric': 0.03937245133685543, 'fraction_numerical': 0.014423173499929692, 'mean_word_length': 4.3899956691208315, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 6, 'https://': 3, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A spiral-like method to place in the space (and interact with) too many values

Modern information systems have to support the user in managing, understanding and interacting with, more and more data. Visualization could help users comprehend information more easily and reach conclusions in relative shorter time. However, the bigger the data is, the harder the problem of visualizing it becomes. In this paper we focus on the problem of placing a set of values in the 2D (or 3D) space. We present a novel family of algorithms that produces spiral-like layouts where the biggest values are placed in the centre of the spiral and the smaller ones in the peripheral area, while respecting the relative sizes. The derived layout is suitable not only for the visualization of medium-sized collections of values, but also for collections of values whose sizes follow power-law distribution because it makes evident the bigger values (and their relative size) and it does not leave empty spaces in the peripheral area which is occupied by the majority of the values which are small. Therefore, the produced drawings are both informative and compact. The algorithm has linear time complexity (assuming the values are sorted), very limited main memory requirements, and produces drawings of bounded space, making it appropriate for interactive visualizations, and visual interfaces in general. We showcase the application of the algorithms in various domains and interactive interfaces.


Introduction
Visualization is important for understanding data, and this concerns almost every data management task: from schema visualization, to query answer visualization, analytics, data mining, data cleaning, and workload visualization. Moreover, modern information systems should enable the user to understand, and interact with larger number of objects than in the past (e.g. the results of summarization, sentiment analysis, dataset discovery and search, etc). However the bigger the data is, the more difficult it is to visualize and understand it. In this paper we focus on a fundamental problem: how to visualize a set of values in the 2D (or 3D) space. Quite often we have to visualize a function f , i.e. a set of (x, f (x)) pairs where x ranges a finite domain X, and commonly a plot is used where all x values are placed in the x-axis and f (x) are presented as dots in the (x, y) coordinate. If f represents functions like frequency, size, popularity, wealth, etc, then the (x, f (x)) pairs are ordered in descending order with respect to f (x) and then are plotted. However if X is big and f (x) follows power law then the resulting plot is not suitable for inspection by humans: its long heavy tail makes almost invisible the first points, i.e. the big elements (let alone the small elements). The commonly used approach for such cases is to make a plot in the log-log scale. In such cases the points tend to form a line and it can be approximated with various functions (Faloutsos et al., 1999). However such drawings are not convenient for interactive visualization systems: the user cannot easily inspect and interact with each value.
In this paper we introduce a complementary approach that is based on a circular drawing. We introduce the algorithm Concentric Spiral that yields a plot that is (a) more compact than a plain plot, and (b) more informative in comparison to a log-log plot. It is like "coiling" the big tail of the normal plot. To grasp the idea, Fig. 1 shows the populations of the 1000 biggest cities in descending order 1 in five forms: (a) normal plot, (b) log-log plot and (c) Concentric Spiral, (d) tree-maps and (e) sunburst diagrams. Notice that tree-maps and sunburst diagrams do not show each individual value (the small values are collapsed to continuous areas); in general they cannot scale to large numbers while showing each individual element (something that is important for inspection and interaction purposes).
The drawings produced by Concentric Spiral can be considered as aesthetically pleasing probably because (i) spiral is a very natural (frequently occurring) shape, and (ii) the drawing does not leave unnecessary blank spaces. Note that the derived spiral-like layout, is not the Archimedean spiral (where the distances between the turnings are constant), nor the logarithmic spiral (where the distances between the turnings increase in geometric progression); instead the spiral follows the variations of the data, i.e. the width of each "circle" of the spiral depends on the sizes of the objects that are placed in that circle. Another important merit of the algorithm is that it has linear time complexity (if the values are not sorted then we have to sort them first, i.e. O(n log n) in that case) and very limited main memory requirements, making it appropriate for the placement of too many objects in the space.
We build upon the preliminary ideas for the visualization of the Linked Open Data Cloud (Papadaki et al., 2018), and in this paper we refine and extend the algorithm, we introduce several extensions and variations of it that differ on how they manage the empty internal space, we analyze its properties, we show how to combine several such layouts for visualizing more than one functions, we propose extensions allowing the visualization of millions of objects, we elaborate on its suitability for visualizing values that follow power-law, we discuss efficiency and implementation, and finally we report feedback from users.
In a nutshell, the contribution of this paper is that it describes and analyzes a family of layout algorithms for producing compact circular diagrams, with linear time complexity (or n log n if the values are not sorted), minimal main memory requirements, subject to several variations. We prove that the algorithm yields drawings with no collision, and in case of power laws with exponent greater than one the occupied space is finite (even if the number of elements is infinite). Moreover the paper provides examples of applications from various domains. Overall, this layout can be exploited in a plethora of visualization cases and frameworks either static or interactive. The rest of this paper is organized as follows. Section 2 discusses requirements and background, Section 3 discusses related work, Section 4 presents the main algorithm, while Section 5 presents extensions, and Section 6 presents variations of the algorithm. Section 7 analyzes the space occupied by the produced diagrams, Section 8 demonstrates applications, and finally Section 9 concludes the paper.

Requirements
From our experience the last years in designing and building interactive information systems, that visualize values of various kinds as shapes in the 2D space, in environments that allow the user to interact with these shapes, we identified the following desired features, that we shall hereafter call basic requirements: (a) visualize values as distinct shapes, each with an area analogous to the corresponding value, enabling in this way the visual comparison of the values, (b) place bigger values at the centre for making them evident as well as their relative size, (c) collisions should never occur, (d) there should be no big empty spaces, (e) visualize thousands (or even millions) of values very fast, (f) visualize values with aspect ratio 1 for aiding readability and interaction (e.g. for building virtual 2D/3D VR or AR worlds where each value corresponds to an area/volume with which the user can further interact for getting more information or for performing a particular task).

Background: power-laws
Since we are interested in not only small or medium-sized collections, it is worth considering the distribution that a large number of datasets follow. 2 The distributions of a wide variety of physical, biological, and man-made phenomena approximately follow a power law over a wide range of magnitudes (Clauset et al., 2009), e.g. word frequencies (Zipf's law), city populations, wealth, the web (Adamic & Huberman, 2000), as well as Linked Data. As regards the latter, such distributions appear at schema level (as studied in Theoharis et al. (2008)), but also on data level (i.e. the sizes of datasets in RDF triples Mountantonakis and Tzitzikas 2016;Fernandez et al. 2017).
The most commonly used approach for visualizing a function that follows power-law, is to use a plot in the log-log scale. Indeed, this is the approach that is followed by papers that reveal and measure power-law distributions (e.g. see Gerlach and Altmann 2019) and such log-log plots are offered by software packages that assist revealing such distributions (like Bullmore and Plenz 2014). The reason is that in case of power-laws the points tend to form a line and can be approximated with various functions, as it is well elaborated in Faloutsos et al. (1999). Note that the identification of power laws, is also useful for graph drawing, e.g. Hussain et al. (2014) at first divides the nodes of a graph into power and non-power nodes and then it applies a force-directed placement algorithm that emphasizes the power nodes which results in establishing local neighborhood clusters among power nodes.
Formally, a power-law (Clauset et al., 2009) is a function f : X ⊆ R ≥0 → R ≥0 of the form: f (x) = αx −β , where α, β are constants, with α, β ∈ R ≥0 . This means that f (x) can be drawn as a line in the log-log scale with a slope equal to −β. Note that the above definition excludes the value β = 0, since in this case f (x) would be equal to α for all values of x, i.e. f would be constant. Loosely speaking, uniform distributions can be regarded as a trivial case of power-law distributions. Intuitively, the value of β is a measure of the skewness of the distribution, i.e. β = 0 implies no skewness. A well known example of power-law is the Zipf's law that states that given some corpus of natural language utterances, the frequency of any word is inversely proportional to its rank in the frequency table; here β = 1, i.e. f (x) = αx −1 , although values greater than 1 (for β) have been measured too.

Related work
In the context of Linked Data (see Mountantonakis and Tzitzikas 2019 for a survey) several methods have been proposed for the visualization of RDF graphs (i.e. the graph that is composed by a set of RDF triples) e.g. see Bikakis et al. (2015), as well as the surveys Bikakis and Sellis (2016) and Dadzie and Pietriga (2017). Visualization is also very important for data analysis (Andrienko et al., 2020) and there are various tools that offer visualizations for big data analytics (Spyratos et al., 2009;Jugel et al., 2014;Vartak et al., 2015;Wang et al., 2015;Godfrey et al., 2016). The more related visualizations to our work are described below.
There are several methods for producing circular-like diagrams, see Draper et al. (2009) for a survey of radial methods for information visualization. To start with, there are algorithms for circular drawings of graphs, like Six and Tollis (2006), where the graph nodes are placed in a circle and emphasis is given on reducing edge crossings, e.g. see Fig. 2(a). However in such algorithms the nodes are points, not shapes, therefore the notion of size is not supported. There are also algorithms for radial layouts, mainly for trees (Yee et al., 2001), e.g. see Fig. 2(b), which again do not support different sizes. From the survey (Ward, 2002), the most related visualization seems to be (Ward & Lipchak, 2000), a method for exploring multivariate data that may exhibit periodic behavior. However such drawings can host values with small variation and the number of objects in a circle is fixed, e.g. see Fig. 2(c), therefore they cannot host too many values, nor values that vary a lot. There are also spiral displays enhanced with coding and interaction like that in Tominski and Schumann (2008), however in that work every "concentric zone" has the same width, therefore one cannot visualize too many values especially if they vary a lot, since in that case the produced diagram would waste a lot of space unless colors are used to signify size (but in that case the correspondence between area and value is lost). These methods seem to be appropriate to identify periodic trends, not for visualizing values with big variations. For clustered bipartite graphs, Ito et al. (2010) proposes a multi-circular style, e.g. see Fig. 2(d), while for maps of data-intensive software ecosystems (by considering also clustering purposes) Kontogiannopoulou et al. (2014) proposes layout algorithms based on concentric circles, e.g. see Fig. 2(e). Such layouts usually contain only a few circles and there are rather big empty areas (in comparison to the algorithms presented in this paper). There are pixel-oriented visualization techniques for exploring large data bases, e.g. the snake-spiral technique (Keim, 1996), however that technique does not respect the relative sizes (all values are visualized with the Fig. 2 Related radial, spiral and tree-map visualizations: (a) circular drawings of graphs (Six & Tollis, 2006), (b) dynamic graphs with radial layout (Yee et al., 2001), (c) exploratory analysis of cyclic multivariate data (Ward & Lipchak, 2000), (d) clustered bipartite graphs in multi-circular style (Ito et al., 2010), (e) visual maps for data-intensive ecosystems (Kontogiannopoulou et al., 2014), (f) snake-spiral visualization (Keim, 1996), (g) visualization of serial periodic data (Carlis & Konstan, 1998), (h) tree-maps (Johnson & Shneiderman, 1991), (i) spiral tree maps (Tu & Shen, 2007), (k) spiral visualization for time series (Weber et al., 2001) same size), e.g. see Fig. 2(f). The same is true for the visualization method for serial periodic data (Carlis & Konstan, 1998): it does not respect the sizes, it adopts the Archimedean spiral, e.g. see Fig. 2(g). With respect to tree-maps (Johnson & Shneiderman, 1991), e.g. see Fig. 2(h), and squarified tree maps (Bruls et al., 2000), which are usually applied for the visualization of hierarchical information structures, they do respect the sizes, they fill entirely the available rectangular region, however it is difficult to achieve a small aspect ratio (the ideal is one since regions with a small aspect ratio, i.e. fat objects, are easier to perceive); and it is also difficult to preserve some sense of the ordering of the input data. Even though, several improvements of tree-map representations have been proposed, like circle packing (Wang et al., 2006), Squarified Treemaps (Bruls et al., 2000), Quantum Treemaps (Bederson et al., 2002), treemaps with bounded aspect ratio (de Berg et al., 2014), Stable Treemaps (Sondag et al., 2017) Bubble Treemaps (Görtler et al., 2017), Voronoi Treemaps (Balzer et al., 2005) or GosperMap (Auber et al., 2013), see Fig. 3, a few limitations among them are that (i) relative ordering may be lost (Wang et al., 2006;Bruls et al., 2000), (ii) changes in the data set can cause dramatic discontinuous changes in the layouts (Bruls et al., 2000) (iii) efficiency may be decreased (Sondag et al., 2017;Görtler et al., 2017) and (iv) in some cases no guarantees on the aspect ratio is given (Balzer et al., 2005). For instance, Bubble Treemaps (Görtler et al., 2017) (Fig. 3.o) achieve aspect ratio 1 (as it uses circles), however it does not respect the absolute ordering and its time complexity is quadratic. There are algorithms that produce spiral treemap layouts for visualizing changes of hierarchical data, e.g. Tu and Shen (2007), however these algorithms seem applicable only on small number of objects, e.g. see Fig. 2(i), and we have not seen them being applied on real data. A spiral visualization for time series is proposed in Weber et al. (2001), however it is not appropriate for values that variate a lot, e.g. see Fig. 2 As regards, circle packing, the method described in Wang et al. (2006) groups values in circles, while we use the sectors of a circle. That method seems to be suitable for cases of hierarchical data sets where users are more interested in the relationships between them. In contrary, our algorithms are also appropriate for sets of values that vary a lot (i.e. power-law) emphasizing the biggest/most important values of a data set. We also preserve the ordering, while that work does not. In general circle packing aims at minimizing the area, but the resulting diagrams do not respect the rank of the objects, i.e. the exact rank of an object is not at all obvious, nor which is its predecessor and successor in the rank. The corresponding decision problems (i.e. whether a given set of circles can be packed in a particular bin) are NP-hard, however various approximate algorithms exist. From that point of view, we could say that our algorithm could be considered as an approximate algorithm for packing squares  (Bruls et al., 2000), (m) Stable Treemap (Sondag et al., 2017), (n) Voronoi Treemap (Balzer et al., 2005), (o) Bubble-Treemap (Görtler et al., 2017), (p) Gospermap (Auber et al., 2013) in a circle that fully preserves the ranking of the objects and has linear complexity (if the values are sorted).
Overall, no radial, spiral or tree-map layout can tackle all requirements that we listed earlier (in Section 2.1). In brief, the radial layouts do not show/respect sizes and their ability to show many values is limited. The tree-map algorithms although they leverage all the available space, it is difficult to achieve a good aspect ratio and at the same time respect the ranking of the objects. The algorithm that we will present gives always aspect ratio 1 (square shapes), it fully respects the ranking of objects, and it tries not to waste space, while providing an aesthetically pleasing (rounded) layout. From a circle-packing point of view, we could say that our algorithm can be considered as an approximate algorithm for packing squares in a circle that fully preserves the ranking of the objects and has linear complexity (if the values are sorted).

The algorithm concentric spiral
Let f be the function that we want to visualize, i.e. a set of (x, f (x)) pairs where x ranges a finite domain X, and let Y denote the range of the function, i.e. Y = { f (x i ) | x i ∈ X} (we shall use Y desc to denote Y sorted in descending order). Each y ∈ Y will be visualized by a square shape, specifically with a square having side length √ y, implying that its area equals y. We consider square shapes, since for a given perimeter, square is the rectangular shape with the maximum area. 3 Based on the requirements listed in Section 2.1, we present a new 2D placement algorithm that we call Concentric Spiral. The exact steps of the algorithm are shown in Algorithm 1. The algorithm takes as input a series of numbers in descending order (i.e. Y desc ) and a number (ringGap) that specifies the desired minimum gap between the rings. The idea of the placement is the following. Each number of the input is represented as a square shape. The shapes are placed in concentric rings. The radius of the first, smallest, ring is the size of the biggest number. The placement of the subsequent shapes is done as follows. We compute a chord that ensures no collisions based on the sizes of the current (to be placed) and the previous shape. We set this to be equal to the side of the current shape plus the size of the previous shape. Based on that chord we compute the corresponding angle, and we place the new shape at the corresponding spot of the ring. This is illustrated in Fig. 4. Suppose that A is the centre of the first shape, and B is the centre of the next shape that we want to place. The figure illustrates why the sought angle is: θ = 2 arcsin( chord 2·radius ) for a given chord denoted by χ in the figure, and radius ρ. This is what, in Algorithm 1, degreesOf Chor(χ, ρ) computes.
The algorithm continues to place the rest of the shapes in that manner and just before we reach 2π, we start the next bigger ring whose radius is the radius of the previous ring increased by the size of the biggest shape in the previous ring, plus a number accounting for the extra empty space that we want to leave between the rings (this is the input ringGap of the algorithm). This is illustrated in Fig. 5. This method ensures no collisions between the shapes (as we shall prove). It is not hard to see that as the shapes get smaller, the concentric rings become denser avoiding in this way unnecessary empty spaces. In addition, as the rings become denser the empty spaces between the shapes decrease as well. Notice that Algorithm 1 refers to the len (length) of shapes. This corresponds to the side length of the squares. Even if it corresponded to their area, this distinction would not be important for power-laws: if area follows power-law with β = β area , then the side also follows power-law with β = β area /2. Time Complexity. It is straightforward that Algorithm 1 has O(n) time complexity (n is the number of shapes). Experimental measurements are given in subsequent sections (Section 8.1).

Proposition 1 Algorithm 1 (a) always terminates, and (b) it yields a drawing with no collision.
Proof (a) holds since the algorithm just consumes the input by scanning it once. (b) holds because of the way we compute chords (sum of the sides of the neighboring shapes) and due to the distance of the successive rings. Specifically, the maximum distance between the centres of two squares that intersect, is the half of the sum of their diameters (if bigger then Fig. 4 The angle that determines the position of the next shape it is impossible to intersect). Specifically, if the first square has side a and the second has side b, then this distance is 1 2 (a Since the centres of two successively placed (intra-ring) squares by the algorithm is a + b (since it is the sum of the length of the previous and to be placed shape), no collision is possible between squares of the same ring. Since the distance between two successive rings is the maximum size of the shapes in the previous ring, say a, plus the size of the first shape of the new ring, say b, it is guaranteed that no collisions are possible between shapes of neighboring rings (since a+b > a+b √ 2 ).

Concentric spiral in small sets of values
To understand the behavior of the algorithm for small numbers of n, Fig. 6 shows the visualization of only 100 synthetically generated values where the first (maximum) value is the

Configuration parameters and their impact
There are some parameters that affect the way the layout looks like, and can be exploited for getting a layout that facilitates others tasks that we may like to carry out.
The first is the scaling, i.e. the min and max size of the shapes in the visualization. This choice depends on the resolution of the canvas, but also on other aspects. For instance, if we want every shape to be clearly visible we may define as min size not only 1 pixel but more pixels. Although any scaling of the range [Y n , Y 1 ] to [ShapeSize min , ShapeSize max ] can be considered as a valid scaling, if ShapeSize min is more than 1 pixel, then the illustration of the relative sizes will not be very accurate. For instance, Fig. 7 shows three different visualizations of the same dataset (the population of the 1000 biggest cities): the first uses for [ShapeSize min , ShapeSize max ] the interval [1, 40], the second the interval [5,40], and the last the interval [10, 40]. We will revisit the notion of scaling, for the case of very big datasets, later in Section 7.1.
The second parameter is the parameter ring gap (ringGap). If we decide to reduce it as the shapes become smaller, then that would harm the readability of the diagram and the visibility of the outer rings. For this reason in the algorithms we keep it stable from the first up to the last ring.
Axes Normal and log-log plots have an X-axis and a Y -axis: the values at the right side of X allow us to see at a glance how many points are visualized, while the values in the upper (resp. lower) parts of Y allow to see the biggest (resp. smallest value(s) of f (x)). The minimum enrichment of a Concentric Spiral-based drawing for conveying this information, is to enrich it with three values: the numbers of values, the maximum value and the minimum number. For example, the diagram in Fig. 1   (and how many would fall in each order of magnitude of the X-axis of a traditional loglog plot), we enrich the diagram with concentric axes drawn in the following manner: after placing 10 i shapes in the drawing, we plot a cycle with thickness analogous to i. For example, Fig. 8(a-b) shows the axis-enriched drawing of the 1000 biggest cities, as well as the drawing of 23,113 values (frequency of words from Shakespeare). In one glance we can understand that the first has 3 orders of magnitude, and the second 4. Analogously, we can use concentric axes for showing the information related to the Y axis, specifically by using concentric axes (with color different than the those for the X axis) at the radii where the values y i change magnitude. Labels As regards labels, various options are supported for what to show inside the square: (i) the value y i , (ii) the value/label x i , (iii) the rank of y i in Y desc , i.e. i, (iv) any combination of them. The labels are enclosed in the squares, enabling in this way to inspect more clearly the top-K (say 5-10) elements without overloading the diagram. Note that the labels do not affect the size of the squares, since the font size of the labels adapts to the size of the squares. For example Fig. 8(c-d) shows the frequency of the 26 letters in English, without labels and with labels (x i and y i ).

Pie chart-like extension
Apart from visualizing one set of values Y desc we may want to visualize m sets (for a small m value), i.e. a family of sets Y 1 , . . . , Y m , each being a set of values ordered in descending order. This can be achieved by extending Algorithm 1 so that instead of using all angles in the range [0, 2π], to take as input the desired angle range. Then the range [0, 2π ] can be partitioned into m angle ranges, one for each of the m sets. We can use then Concentric Spiral for placing the shapes of each set at the corresponding slice defined by the angle interval [θ min , θ max ]: we just have to use θ min to determine where to place the first shape and θ max to determine when to change ring (the exact steps of the extended algorithm are given in Section 6.5). For example, Fig. 9(a) shows the visualization of 3 sets each having 2,000 values, (b) shows 9 sets each having 200 values, and (c) shows 9 sets each having unequal number of values (from 10 to 2,000). It is not hard to see that we can use this angle-restricted extension not with the entire range [0, 2π ] but with an angle range based on our preference. For example we can use the angle range [0, π] for getting a visualization that resembles the seats of a parliament as illustrated in Fig. 9(bottom) that shows 8 slices in [0, π].
Overall, the pie chart-like extension of Concentric Spiral can be useful for (a) visually inspecting/comparing more than one datasets, and (b) for clustering the values of a dataset according to one criterion.

On visualizing more than one function
So far we have focused on how to visualize one function f , specifically its value set Y , ordered in descending order, i.e. Y desc . Now suppose that we have another function g over Fig. 9 Pie-chart like extension of Concentric Spiral X, i.e. g : X → Z. Here we describe how we can visualize both f (x) and g(x). If the range of g is small (i.e. |Z| is small), say 2 ≤ |Z| ≤ 5, then apart from the pie charlike extension described in Section 5.1, we can extend the previous visualization and make clear the g(x) by drawing the shape corresponding to f (x) with a different shape type, e.g. square, triangle, oval, etc., or a different color. Both of them (i.e. shapes and colors) can be combined for visualizing three functions in total: f by the size of the shape, g by the shape type, and h by the color. As we shall see in Section 8, we can also employ 3D and use the third dimension for visualizing an additional function, i.e. 4 functions in total. In that case, since the volume (and not the area) of the shape should correspond to f (x), if we employ cubes then the edge length should be set to 3 √ f (x) so that the volume of the cube is equal to f (x). Overall, by considering also the slice-based extensions (of Section 5.1), we can reach 5 functions in total: one "dominant" i.e. the one that follows the power-law distribution, and 4 whose range is small.

Variations of concentric spiral
Below we introduce three variations of the core algorithm, all having linear time complexity, that can reduce the internal free space at the center of the drawing, if that is required. Specifically Section 6.1 presents a ring variation, Section 6.2 presents a theater-like variation, and Section 6.3 presents a variation that mixes the above two. Then Section 6.4 compares these variations, and finally Section 6.5 presents the general algorithm that can produce any of these variations.

Concentric spiral Ring
The basic idea is the following: Instead of increasing the radius after the completion of the first circle, based on the largest shape placed in that circle (at line 10 of Algorithm 1), we can increase the radius just by the ringGap for getting a denser layout. However we have to check whether that position is free for avoiding collisions with the shapes that have already been placed. Note that this is not required in Concentric Spiral because the radius is increased based on the largest shape placed in that circle. We can check whether a position is free before placing a shape (at line 28 of Algorithm 1) by checking the colors of the canvas pixels. Since shapes are placed in descending order of size, it is enough to check the color only of the four corners of the candidate position for the placement. This algorithm produces layouts with less empty space between the core of big shapes and the periphery of small shapes. For the case of 5,000 shapes, Fig. 10(a) shows the layout produced by the Concentric Spiral, while Fig. 10(b) shows the layout produced by the Concentric Spiral Ring .

Concentric spiral Theater
If we would like to leverage the internal space between the big shapes then we could use a variant of Concentric Spiral that we call Concentric Spiral T heater : after the completion of the ring (that contains the biggest shapes), instead of increasing the radius (at line 10 of Algorithm 1), as it is done in Concentric Spiral and Concentric Spiral Ring , we decrease it by the width of the ringGap. In this way the biggest datasets form the big circle and the small ones then fill the internal space. This algorithm derives a more dense drawing resembling an ancient Greek theater, as shown in Fig. 10(c). However it is not guaranteed that the internal space will be enough for hosting all small shapes, an issue that is tackled by the algorithm presented next, in Section 6.3.

Mixing concentric spiral Ring and concentric spiral Theater
Concentric Spiral Ring and Concentric Spiral T heater can be combined: we can start as in Concentric Spiral T heater and if the internal space is completely filled before placing all shapes, we can continue by placing the remaining shapes in the peripheral area, as in the Concentric Spiral Ring . This is shown in the diagrams of the third column of Fig. 11 that visualizes 10,000 values. Alternatively one could use the Concentric Spiral T heater with a bigger initial radius but that would require estimating which radius is adequate. Instead, by mixing the two algorithms, there is no need for any estimation; a single pass is enough for drawing all shapes.

Concentric spiral vs concentric spiral Ring vs concentric spiral Theater
To better understand how the skewness of the distribution of data affects the produced layouts, Fig. 11 shows Concentric Spiral, Concentric Spiral Ring and Concentric Spiral T heater over three versions of a dataset with 10,000 values. Each version has the same maximum value, however each version has different reduction rate, specifically in the 1st row β = 1/2, in the 2nd β = 1, and in the third row β = 2. The same scale has been used for all 12 diagrams. We observe that the diagrams of Concentric Spiral Ring and Concentric Spiral T heater occupy less space than those of Concentric Spiral, however Concentric Spiral better reveals the relative sizes of the middle-sized elements.

The generalized algorithm
The generalized algorithm that supports all previously described extensions and variations is given in Algorithm 2. Apart from the list of values in decreasing order, it takes as input a parameter mode (ranging ExpandSpiral, ExpandRing, and Shrink) that determines which layout (either Concentric Spiral, Concentric Spiral Ring , or Concentric Spiral T heater respectively) should be produced. In addition it takes as input an angle range [θ min , θ max ] for producing the pie chart-based extension. Note however that the check at line 27 of the algorithm is redundant for the Concentric Spiral (since the condition will always be true). The small size of the algorithm facilitates its implementation in the existing visualization frameworks.

Analyzing the occupied space
Let's further analyze the space occupied by the diagrams produced by Concentric Spiral. The area of the ring defined by the radii R 2 and R 1 (where R 2 > R 1 ) is A R 1 ,R 2 = π(R 2 2 − R 2 1 ). Since the values are decreasing, also R 2 − R 1 and consequently A R 1 ,R 2 , are decreasing too. The more values we have to visualize, the bigger the radius becomes, and the more the occupation of space tends to be collinear, as shown in Fig. 12, occupying the minimum space. Therefore the percentage of empty/filled area is reducing.
Let's now focus on data that follows power-law. Let Filled Area, for short FA be the area occupied by the shapes only. Let Y 1 , . . . , Y n be the n values to be visualized. If this Fig. 12 Occupied space as the number of values increases series follows power-law then we can write Y i = Y 1 /i β (using the notations of Section 2.2: i p , converges for all p > 1 and diverges for all p ≤ 1 (note that if p > 1 then the sum of the p-series is ζ(p), i.e., the Riemann zeta function evaluated at p). The key point is that for β > 1 the area of the visualized shapes is bounded, independently of how big n is (even if n was infinite).
Let's now estimate the empty area, denoted by EA, i.e. the area that falls within the outer circle of the diagram but is not occupied by any shape of the diagram.

Proposition 2 The area that falls within the outer circle of the diagram but is not occupied by any shape of the diagram, is less than 3 times the filled area by the shapes (FA).
Proof Let Z be the number of the concentric rings of the diagram (obviously Z ≤ n). Let EA i be the empty space within ring i. Since certainly at least one shape is placed in each ring, e.g. in the first ring it will occupy one of the four quadrants, it holds that EA i ≤ 3FA i , i.e. EA i cannot be 3 times more than the filled part of ring i. Therefore, EA ≤ 3FA.
Obviously this bound is very pessimistic. However the point is that if FA is bounded, then the same holds for EA. To summarize we have seen that if Y follows power-law and β > 1 then the entire diagram is finitely bounded in normal scale (not log-log scale) even if the number of n is infinite. In the proof of Proposition 1 (in Section 4) we have seen that a+b √ 2 is the minimum chord that guarantees no collisions. Concentric Spiral uses a + b, i.e. a larger distance. The reason is that with a + b the diagram looks better (to the authors), however the theoretically minimum chord can be used as well. As regards the three variations of the algorithm, Concentric Spiral T heater with the minimum chord is the variation of the algorithm that has the minimal empty space between the shapes.

Very large datasets
In the previous drawings, we have used minimum size 1 (i.e. 1 pixel) for making each point visible. However if the dataset is too big, then the canvas could become extremely big. Moreover, this causes problems with the bounding of the drawing: the min size 1 does not allow us to achieve a drawing of bounded size, since even if the values are extremely small they always occupy at least one pixel in the drawing space.
If we want to tackle this problem we can use 0 as min size, i.e. 0 pixels. However, whenever the algorithm reaches a point whose shape should have 0 as rounded integer value, it stops drawing points, and enters into a different mode. Specifically let Y 1 , . . . , Y n be the values to be visualized and let Y k (1 < k ≤ n) be the first value whose re-scaled rounding is 0. In that case the values Y k , . . . , Y n are visualized differently: a filled ring is added with area equal to S = n i=k Y i (after normalizing S in consistency with the normalization of the max value Y 1 ). This approach allows producing a more compact drawing, compliant with the theoretical bounds, that also preserves the relative sizes of all the visualized values. The size of the ring is computed as follows: Let R k be the radius when Y k was about to be drawn. The algorithm in that case stops drawing shapes and instead fills a ring starting from the radius R k = R k + slen max + ringGap up to the radius needed for having area equal to (the normalized) S. The outer radius R x of that ring is computed as follows To achieve the above, Algorithm 2 just needs one line at the beginning (line 4) that checks if χ = 0, i.e. if the integer rounded size is 0 pixels (that is less than 0.5 pixels), and if yes, it calls a method with the current index i and the radius from which the ring should start, i.e. the exact line is "if (χ = 0) then f illRing(i, ρ + slen max + ringGap); break". An excerpt from the visualization of 10 millions values in this way is shown in Fig. 13 (it is a synthetic dataset with max value 4000, min value 10, 20% percentage reduction between two consecutive values, and scaling interval [0, 50]). The axes allow to understand that we have 7 orders of magnitude (the axes in the filled ring are distributed uniformly in [R k , R x ] for aiding readability). Although our algorithm can show more small objects in comparison to tree-map and sunburst (as we have seen in Fig. 1), if rings are adopted, then zoom-in on the rings cannot offer more information. To "analyze" a ring to individual shapes we can either (a) increase the size of the canvas, (b) click on the ring the visualize the subset of objects that belong to that ring (and that could be done recursively as many times as the user wishes to), or (c) enable the visualization of any subset of the values of the ring specified by their rank (e.g. all values with rank i up to rank j ). As regards option (a), i.e. the usage of a very large canvas that does not require using any ring, the user can still locate the desired object(s) through search; this functionality (i.e. search and locate) is supported by our implementations that are described in Section 8.3, i.e. by the produced drawing in SVG, as well as by the interactive 3D system. All these are aligned with Cota et al. (2017) that stresses that for visualizing massive data it is important to support selection, zooming, and filtering, and exploiting the rotation capabilities of 3D (examples of 3D are given in in Section 8.3). Finally, we have to note that if a very large canvas is selected to be used, even though our algorithm that produces the coordinates of the objects will run fast, the visualization of the produced raster image could require a lot of memory to load or transfer; such cases can be handled by loading the data/image to a GIS and we have already tested that scenario using GeoServer, 4 moreover one can exploit methods for visualizing images of very big resolution like those derived by modern scanning approaches like the one described in Zabulis et al. (2021).

Application
Concentric Spiral and its variations can be applied in a plethora of cases. We have focused mainly on the layout, not on other aspects, i.e. on colors, interactivity, etc, since the latter depend on the application context. Section 8.1 discusses efficiency, Section 8.2 provides various indicative cases, and Section 8.3 describes current implementations. Finally, Section 8.4 presents some preliminary feedback from users.

Efficiency
We have implemented the algorithms using Java 1.8.0 51. In our experiments we measure the time required by the layout algorithm to fill a N × N java array of pixels each having a color (we did not count the time of the windowing system, e.g. for creating the JFrame). With a laptop with rather low computational power (Core i5-3320M CPU, 4 GB RAM, running Windows 10), Concentric Spiral needs only 30-40 milliseconds to compute all pixels of a 1000x1000 canvas for 100,000 (filled with blue) shapes. The other two variations are more expensive since they have to check for free spaces, therefore the elapsed time is more. For all the diagrams shown in this paper, these two variations were never more than 3 times slower than Concentric Spiral. In general, all visualizations shown in this paper (except from the one with the millions of shapes) require less than 120 milliseconds to be computed. For datasets with millions of objects, roughly it takes 15 secs per million of objects (where each object is visualized). If however the scaling interval includes 0, then with the method presented in Section 7.1 the visualization of 10 million objects takes 17 secs.

Examples
Here we provide various examples.
Word Frequencies. Figure 14 shows the frequency of 23,113 words in Shakespeare 5 in the three plots (normal, log-log and Concentric Spiral).
Cities Population. Figure 15 shows the populations of the 1000 biggest cities in 3D, where each color represents a different continent, and the volume of each cube corresponds to the population of the corresponding city. The figure includes visualization with the Concentric Fig. 15 The 1000 biggest cities clustered by continent Spiral layout, and with the pie chart-like extension for clustering (using the same angle range for each slice, although any range can be used). Shots from different angles in 3D visualization system are also shown, as well as one case (at the bottom right of Fig. 15) where instead of cubes we use cuboids, where all cubes have the same width (in this case the width of the smallest cube) for comparing the values more easily based on only their heights. Figure 16 shows in 3D all covid-19 cases, recovered cases and deaths on May 8, 2020: the bottom cubes represent the total cases detected with covid-19, the intermediate correspond to the recovered cases while the upmost to the total deaths. The above (and some more examples) are available at the webpage https://rb.gy/d2impg.

Implementations
We have already two implementations of the algorithms in two different settings. The first is a stand-alone application (that we call "CoSpi") that allows the user to load a csv file and interactively select the desired version of the algorithms and parameter values enabling to derive the desired drawing(s) and save them as images or SVG files, as shown in Fig. 17. The first version of this application has just been released publicly (available at https://rb. gy/oogsld). The second implementation, is within a Web-based visualization system that exploits the algorithm for producing interactive 3D visualizations (that system was used for producing Figs. 15 and 16).

Feedback from users
In order to understand whether users would like, or prefer, this kind of visualization, we conducted a small-scale evaluation mainly with students. Since not all users are familiar with systems that produce plots and visualizations, and for excluding the interactive functionalities (that depend on the particular system), we selected two easy to grasp datasets, specifically the populations of the 1000 largest cities, and the populations of all countries. For each dataset we produced one pdf that contained visualizations of: (1) normal plot, (2) log-plot, (3) tree-map, (4) sunburst, and (5) CoSpi. Among the various options that are possible with these types of diagrams (relating to sizes, labels, axes, etc), we selected only two indicative ones for each kind. Then we asked the participants to inspect these visualizations and then to express their preference. No particular task was given to the users, because we did not want to include interactivity, since there is no single system that supports all these visualizations. We also have to mention, that the resolution of the pdf was low because it was produced by screenshots, so the users could not fully read all labels and zoom-in, however, they could get clearly the general idea. We invited by email various persons to participate in the evaluation voluntarily. No training material was given to them, and the participation to this evaluation was optional (invitation by email). Eventually, 28 persons participated (from Dec 10, 2020 to Dec 24, 2020).
In numbers, the participants were 32.1% female and 67.9% male, with ages ranging from 19 to 55 years; Fig. 18 shows the histograms of the ages of the participants. As regards occupation and skills, 71.4% were computer science students (undergraduate and graduate) and 28.6% of them professionals (mainly engineers). The task description is shown next: "At first download the zip file X that contains two excel sheets: one with the populations of the 235 countries and another one with the populations of the 1000 largest cities. Now suppose that you would like to prepare a presentation of these two datasets. Open the two pdf files (that you can find in the zip file) that contain 5 different types of visualization of these two datasets. Please have a look and then fill the small questionnaire that you can find below. Please ignore the low resolution, i.e. do not judge the diagrams based on their resolution".
The questionnaire comprised questions of the form: "How would you rate the X Plots: Very Useful, Useful, Little Useful, Not Useful". The results are visualized in Fig. 18. By inspecting the results it is clear that users did not like much the classical normal or log plots for the task at hand, instead they preferred tree-map, sunburst and CoSpi. Between the last three, no clear conclusion can be drawn, given the low resolution and the non-interactive nature of the task. They keypoint is that users considered CoSpi as an acceptable method, since it achieved preferences quite close with the other well-established methods.

Concluding remarks
The visualization of medium and large number of values that exhibit big variations is a challenging task. We presented a novel family of algorithms that places objects in the 2D space (in a spiral-like layout), and satisfies a set of requirements that are not supported by the existing methods. One merit of the core algorithm (Concentric Spiral) is that it derives layouts that are suitable for collections of values whose sizes follow power-law because it makes evident the bigger values and it does not leave empty spaces in the peripheral area which is occupied by the majority of the values which are small, thus the produced drawings are both informative and compact, and the aspect ratio of all visualized shapes is 1. The algorithm has linear time complexity (if the values are sorted) and very limited main memory requirements, making it appropriate for very big collections of values (a few seconds are enough for producing the layout of millions of objects). For power laws with an exponent greater than one, it is proved that the occupied space is finite, even if the number of elements is infinite, and we have seen that the enrichment of Concentric Spiral with filled areas is compliant with the theoretical bounds and preserves the relative sizes of all the visualized values. Apart from the core algorithm, we investigated variations of the algorithm that can further reduce the empty space between the big values (if that is required), as well as extensions for showing and comparing more than one sets of values. We proved the feasibility and demonstrated the efficiency of the algorithm by providing two different implementations in different contexts. Finally we showcased applications of the algorithms in various datasets. 6 The proposed method can enrich existing visualization frameworks and interactive visualizations in general. In future it is worth investigating automatic methods for tuning the parameters of the algorithms, based on the characteristics of the dataset and the available size of the canvas, for suggesting configurations to the user and plugging the visualization to an engine for analytic queries for investigating various kinds of interactivity.

Data Availability Statement
The datasets visualized during the current study are available in the webpage of the system http://www.ics.forth.gr/ ∼ tzitzik/demos/cospi, specifically the file with the windows executable client contains a folder with the dataset with the city populations, country populations, city populations and continents, and Shakespeare word frequencies.
The various synthetically produced datasets generated and visualized during the current study are not publicly available since they do not have any distinctive characteristic; they were used for measuring efficiency (the latter can be measured by any dataset of that size), but are available from the corresponding author on reasonable request.
The source code of the client is available at https://github.com/YannisTzitzikas/cospiral.