Computing the Discrete Compactness of Orthogonal Pseudo-Polytopes via Their 𝑛D-EVM Representation

Abstract

This work is devoted to present a methodology for the computation of Discrete Compactness in 𝑛-dimensional orthogonal pseudo-polytopes. The proposed procedures take in account compactness' definitions originally presented for the 2D and 3D cases and extend them directly for considering the 𝑛D case. There are introduced efficient algorithms for computing discrete compactness which are based on an orthogonal polytopes representation scheme known as the Extreme Vertices Model in the 𝑛-Dimensional Space (𝑛D-EVM). It will be shown the potential of the application of Discrete Compactness in higher-dimensional contexts by applying it, through EVM-based algorithms, in the classification of video sequences, associated to the monitoring of a volcano's activity, which are expressed as 4D orthogonal polytopes in the space-color-time geometry.

1. Introduction

In areas such as image processing, pattern recognition, and computer vision, there is required to characterize for a given object its topological and geometrical factors. They have a paramount role in more elaborated tasks such as those related to classification, indexing, or comparison. Some of these factors describe the shape of an object. One of them, and one of the most used, is the shape compactness [1]. The shape compactness of an object refers to a measure between the object and an ideal object [2]. In the 2D euclidean space, shape compactness is usually computed via the well-known ratio𝑃𝐶=²,4𝜋𝐴 (1.1) where 𝑃 is the perimeter of an object and A its area. Such ratio has its origins in the isoperimetric inequality:𝑃²≥4𝜋𝐴. (1.2) It is actually the solution to the isoperimetric problem which states the question related to find the simple closed curve that maximizes the area of its enclosed region [3]. The equality is obtained when the considered curve is a circle. Hence, as pointed out in [1], the ratio for shape compactness is in effect comparing an object with a circle. In the 3D space the isoperimetric inequality is given by𝐴³≥36𝜋𝑉², (1.3) where 𝐴 is the area of the boundary of a 3D object while V is its volume. Hence, the ratio𝐴𝐶=³36𝜋𝑉² (1.4) denotes shape compactness of a 3D object, and it effectively is comparing such object with a sphere.

As [1, 4] point out, these classical ratios are very sensitive to variations in the shape of an object. Moreover, they point out, when the above definitions are applied to objects defined via pixelizations (in the 2D case) or voxelizations (3D case), that small changes in the final object’s boundary produce more important variations in the computed values. Consider, for example, the sets of boxes presented in Figure 1. The square described by the union of the boxes shown in Figure 1(a) has a perimeter of 32 u while its area is 64 𝑢². Figure 1(b) shows a polygon that can be seen as a modified version (because of noise, artifacts, digitalization scheme, etc.) of the previous one. Its perimeter is given by 58 u. Both polygons have the same area, but their shapes have some slight differences. Shape compactness for the first polygon is given by 1.2732 while for the second is 4.1827. These values are significantly distinct, and by considering shape compactness as a rule for classification, this could imply that they are very different objects.

(a) Perimeter: 32 u, Area: 64 u2

(b) Perimeter: 58 u, Area: 64 u2

Figure 1 

Polygons defined by the union of 64 unitary boxes.

In order to provide a solution to the above problem, Bribiesca, in [1, 5], defined the Discrete Compactness. It has its foundation on the notion of counting the number of edges (in the 2D case) and faces (in the 3D case) which are shared between pixels or voxels, according to the case, that define an object. Discrete Compactness is given by the following expression [1, 5]:𝐶_𝐷𝐿(𝑝)=^𝐶(𝑝)−𝐿_𝐶min𝐿_𝐶max−𝐿_𝐶min, (1.5)

where(i)𝐿_𝐶(𝑝) is the number of shared edges (faces) within an object 𝑝 consisting of m pixels (voxels) (ii)𝐿_𝐶maxis the the maximum number of shared edges (faces) achieved with an object consisting of m pixels (voxels)(iii)𝐿_𝐶minis the minimum number of shared edges (faces) achieved with an object consisting of m pixels (voxels)(iv)𝐶_𝐷(𝑝)∈[0,1].

In [1] there are used, for the 2D case, 𝐿_𝐶max=2(𝑚−√𝑚) and 𝐿_𝐶min=𝑚−1, which, respectively, describe the maximum and minimum number of internal contacts (shared edges) between the m pixels forming a squared object. It is clear, in this case, when 𝐶_𝐷(𝑝)=1 the object 𝑝 corresponds to a square of sides √𝑚, and when 𝐶_𝐷(𝑝)=0 it corresponds to a rectangle with base of length 1 and height m. For example, considering again the polygons presented in Figure 1, we have 𝐿_𝐶=112 for that shown in Figure 1(a), while 𝐿_𝐶=99 for the polygon in Figure 1(b). In both cases m = 64, hence, 𝐿_𝐶max=112 and 𝐿_𝐶min=63. Then, discrete compactness for the polygon in Figure 1(a) is given by 𝐶_𝐷=1 while the other has 𝐶_𝐷=0.7346. In [4] it is established that 𝐿_𝐶min=0. Hence, if 𝐶_𝐷(𝑝)=0, then the object corresponds to a chain of pixels such that no edges, and only vertices, are shared. By considering 𝐿_𝐶min=0 then discrete compactness for the polygons in Figures 1(a) and 1(b) are 1 and 0.8839, respectively. It both cases, it is clear that discrete compactness provides us a more robust criterion for objects’ comparison/classification/description of shapes under the advantage it is much less sensitive to variations in their shape. For the 3D case, in [1] it is used 𝐿_𝐶max=3(𝑚−𝑚^2/3). If m is a power of 3, then the given 𝐿_𝐶max provides the number of shared faces in an array of voxels that correspond to a cube of edges of length √³𝑚. By using 𝐿_𝐶min=𝑚−1 then it is defined a stack of m voxels [1].

2. Problem Statement

An 𝑛-dimensional Euclidean polytope Π_𝑛 is defined as a finite region of 𝑛-dimensional Euclidean space enclosed by a finite number of (𝑛-1)-dimensional hyperplanes [6]. The finiteness of the region implies that the number N_𝑛-1 of bounding hyperplanes satisfies the inequality N_𝑛−1>𝑛. The part of the polytope that lies on one of these hyperplanes is called a cell. Each cell of a Π_n is an (𝑛-1)-Dimensional polytope, Π_𝑛−1. The cells of a Π_𝑛−1 are Π_𝑛−2's, and so on; thus it is obtained a descending sequence of elements Π_𝑛−3, Π_𝑛-4,…, Π₃ (a volume), Π₂ (a polygon), Π₁ (an edge), Π₀ (a vertex).

The representation of a polytope through a scheme of hyperspatial occupancy enumeration is essentially a list of identical hyperspatial cells occupied by the polytope. Specific types of cells, called hypervoxels [7], are hyper-boxes (hypercubes, for example) of a fixed size that lie in a fixed grid in the 𝑛-dimensional Space. By instantiation, it is well known that a 2D hypervoxel is a pixel while a 3D hypervoxel is a voxel; the term rexel is suggested for referencing a 4D hypervoxel [7]. The collection of hyperboxes can be codified as an 𝑛-Dimensional array 𝐶_{𝑥1,𝑥2,…,𝑥𝑛}. The array will represent the coloration of each hypervoxel. If 𝐶_{𝑥1,𝑥2,…,𝑥𝑛}=0, the white hypervoxel 𝐶_{𝑥1,𝑥2,…,𝑥𝑛} represents an unoccupied region from the 𝑛-Dimensional space. If 𝐶_{𝑥1,𝑥2,…,𝑥𝑛}=1, then the black hypervoxel 𝐶_{𝑥1,𝑥2,…,𝑥𝑛} represents a used region from the 𝑛-Dimensional space. Hence, the set of black cells defines a polytope whose vertices coincide with some of the occupied cells’ vertices.

It is clear that Bribiesca’s definition of Discrete Compactness can be extended for considering 𝑛-Dimensional polytopes, and in the particular dominion of this work, 𝑛-Dimensional Orthogonal Pseudo-Polytopes (𝑛D-OPPs). We will consider those 𝑛D-OPPs that can be seen as the result of a hypervoxelization such that hypervoxels are unit 𝑛D hypercubes with integer coordinates. It is well known that an 𝑛D hypercube has 2𝑛 boundary (𝑛-1)D cells [8]: 2 vertices in a segment, 4 edges in a square, 6 faces in a cube, 8 volumes in a 4D hypercube, and so on. Hence, 𝐿_𝐶(𝑝) denotes the number of shared (𝑛-1)D cells within polytope 𝑝 consisting of m hypervoxels while 𝐿_𝐶max and 𝐿_𝐶min correspond, respectively, to the maximum and minimum number of shared (𝑛-1)D cells achieved with objects composed by m hypervoxels.

When using hypervoxelizations for representing and manipulating 𝑛D polytopes some compromises should be taken in account. In particular is the one related to the representation’s spatial complexity. It is well known that spatial complexity of a hypervoxelization is at least^𝑛_𝑖=1𝑚_𝑖, (2.1) where 𝑚_𝑖,1≤𝑖≤𝑛, is the length of the grid along X_i-axis. For example, a 4D grid with 𝑚₁ = 𝑚₂ = 𝑚₃ = 𝑚₄ = 1,000 is required to store 1 trillion (1×10¹²) hypervoxels. For that reason, in this work we will concentrate on expressing 𝑛D-OPPs via a polytopes’ concise representation scheme known as the Extreme Vertices Model in the 𝑛-Dimensional Space (𝑛D-EVM). The EVM is a model originally established by Aguilera and Ayala in [9, 10] for representing 1D, 2D, and 3D-OPPs. In [11], EVM’s properties in the 𝑛-Dimensional Euclidean Space were formally proved, leading to characterize it as a complete representation scheme for 𝑛D-OPPs. In [10, 11] there are described efficient algorithms for performing some of the most used operations in solid and polytopes modeling such as regularized boolean operations, set membership classification, and measure queries. The conciseness of the EVM lies in the fact it only stores some specific vertices of a polytope: the Extreme Vertices. Via such subset of the polytope’s vertices, it is possible to obtain much geometrical and topological information about the polytope and to perform operations as the ones previously mentioned. Now, returning to the question related to hypervoxelizations’ complexity, we commented before that in a hypervoxelization the set of black hypervoxels defines a polytope, actually an 𝑛D-OPP. The hypervoxels in such set can be seen as a set of quasidisjoint 𝑛D-OPPs. Based on this observation, we will describe a straight methodology for converting a hypervoxelization to a concise EVM representation. In Section 3 we will describe formally to 𝑛D-OPPs (Section 3.1), and we will present a summary of the foundations behind the 𝑛D-EVM (Section 3.2). Section 3.3 presents basic algorithms under the 𝑛D-EVM while Section 3.4 deals with two algorithms for interrogating and manipulating 𝑛D-OPPs represented via the 𝑛D-EVM: the first one computes the 𝑛D content of an OPP while the second corresponds to computation of regularized boolean operations between OPPs. Finally, Section 3.5 presents the procedure for hypervoxelizations to 𝑛D-EVM conversion.

The main contribution of this work is the specification of efficient procedures that provide us a way to infer the number of hypervoxels that originally composed an 𝑛D-OPP. In this sense, we assume that such OPP fits exactly in a hypervoxelization, where hypervoxels are unit 𝑛D hypercubes whose vertices have integer coordinates. More specifically, given an EVM we will determine the number of internals contacts, that is, the number of shared (𝑛-1)D cells, that took place between the hypervoxels that originally defined the polytope. By this way, we will present in Section 4 an EVM-based algorithm for determining 𝐿_𝐶(𝑝) for a given 𝑛D-OPP p. Such algorithm will lead to the specification of a procedure for computing the Discrete Compactness of an 𝑛D-OPP. After that, in Section 5, it will be described a methodology, originally presented in [11, 12], for representing and manipulating color 2D animations via EVM-modeled polytopes embedded in 4D space-color-time geometry. Then, in Section 6, we will describe an application of our proposed EVM-based algorithms for computing Discrete Compactness. Specifically, we present an application oriented to classification of image sequences which correspond to a volcano’s activity. It will be seen how the obtained results provide experimental evidence about the applicability of Discrete Compactness in higher dimensional contexts.

3. The Extreme Vertices Model in the 𝑛-Dimensional Space (𝑛D-EVM)

This section is a summary of results originally presented in [10, 11]. For the sake of brevity, some propositions are only enunciated. Their corresponding proofs can be found in the two aforementioned references.

3.1. The n-Dimensional Orthogonal Pseudo-Polytopes (𝑛D-OPPs)

Definition 3.1 (see [13]). A Singular n-dimensional hyper-box in ℝ^𝑛 is given by the continuous function 𝐼^𝑛∶[0,1]^𝑛→[0,1]^𝑛,𝑥∼𝐼^𝑛(𝑥)=𝑥. (3.1) A general singular k-dimensional hyper-box in the closed set 𝐴⊂ℝ^𝑛 is the continuous function 𝑐∶[0,1]^𝑘→𝐴. (3.2)

Definition 3.2 (see [13]). For all i, 1≤ i ≤n, the two singular(𝑛-1)D hyper-boxes 𝐼^𝑛_(𝑖,0) and 𝐼^𝑛_(𝑖,1) are defined as follows. If 𝑥∈[0,1]^𝑛−1, then 𝐼^𝑛_(𝑖,0)(𝑥)=(𝑥₁,…,𝑥_𝑖−1,0,𝑥_𝑖,…,𝑥_𝑛−1) and 𝐼^𝑛_(𝑖,1)(𝑥)=(𝑥₁,…,𝑥_𝑖−1,1,𝑥_𝑖,…,𝑥_𝑛−1).

Definition 3.3 (see [13]). The orientation of an (𝑛-1)D cell 𝑐∘𝐼^𝑛_(𝑖,𝛼) is given by(−1)^𝛼+𝑖. It is said cell 𝑐∘𝐼^𝑛_(𝑖,𝛼) is oriented when it is expressed by the scalar-function product (−1)^𝑖+𝛼⋅𝑐∘𝐼^𝑛_(𝑖,𝛼).

Definition 3.4 (see [13]). A formal linear combination of general singular 𝑘D hyper-boxes, 1 ≤𝑘≤ n, for a closed set A is called a k-chain.

Definition 3.5 (see [13]). The boundary of an n-chain ∑𝑐_𝑗, where each 𝑐_𝑗 is a general singular 𝑛D hyper-box, is given by 𝜕(𝑐_𝑗)=𝜕(𝑐_𝑗)=(^𝑛_𝑖=1(_𝛼=0,1(−1)^𝑖+𝛼⋅𝑐_𝑗∘𝐼^𝑛_(𝑖,𝛼))). (3.3)

Definition 3.6. A collection c₁, c₂, …, c_k, 1 ≤𝑘≤ 2ⁿ, of general singular 𝑛D hyper-boxes is a combination of 𝑛D hyper-boxes if and only if [^𝑘_𝛼=1𝑐_𝛼([0,1]^𝑛)=(0,…,0_𝑛)]∧[(∀𝑖,𝑗,𝑖≠𝑗,1≤𝑖,𝑗≤𝑘)(𝑐_𝑖([0,1]^𝑛)≠𝑐_𝑗([0,1]^𝑛))]. (3.4)

In the above definition the first part of the conjunction establishes that the intersection between all the 𝑛D general singular hyper-boxes is the origin, while the second part establishes that there are not overlapping 𝑛D hyper-boxes.

Definition 3.7. An n-dimensional orthogonal pseudo-polytope𝑝, or just an nD-OPPp, is an 𝑛-chain composed by 𝑛D hyper-boxes arranged in such way that by selecting a vertex, in any of these hyper-boxes, it describes a combination of 𝑛D hyper-boxes (Definition 3.6) composed up to 2ⁿ hyper-boxes.

3.2. 𝑛D-EVM’s Fundamentals

Definition 3.8. Let c be a combination of hyper-boxes in the 𝑛-Dimensional space. An Odd Adjacency Edge of c, or just an Odd Edge, is an edge with an odd number of incident hyper-boxes of c. Conversely, if an edge has an even number of incident hyper-boxes of c, it is called Even Adjacency Edge, or just Even Edge.

Definition 3.9. A brink or extended edge is the maximal uninterrupted segment, built out of a sequence of collinear and contiguous odd edges of an 𝑛D-OPP.

From the above definition, every even edge of an 𝑛D-OPP does not belong to brinks. On the other hand, every brink consists of m odd edges, m ≥ 1, and contains m + 1 vertices. Two of these vertices are at either extreme of the brink and the remaining m-1 are interior vertices.

Definition 3.10. The ending vertices of all the brinks in 𝑝 will be called Extreme Vertices of an nD-OPP p. EV(𝑝) will denote to the set of Extreme Vertices of 𝑝.

Property 3.11. Any extreme vertex of an n D-OPP, n ≥ 1, when is locally described by a set of surrounding n D hyper-boxes, has exactly n incident linearly independent odd edges.

Figure 2 shows an example of a 3D-OPP p. Vertices v₁ and v₂ are nonextreme vertices because, in the case of v₁, it has six incident odd edges, while vertex v₂ has four incident coplanar odd edges (see Property 3.11). In the figure can be also appreciated that exactly three linearly independent odd edges are incident to the remaining vertices, actually, the Extreme Vertices of p.

Figure 2 

Example of a 3D-OPP and its set of Extreme Vertices (Continuous lines indicate odd edges, dotted lines indicate even edges, black points correspond to extreme vertices, and white points correspond to non extreme vertices).

The brinks in an 𝑛D-OPP 𝑝 can be classified according to the main axis to which they are parallel. Since the extreme vertices mark the end of brinks in the 𝑛 orthogonal directions, is that any of the 𝑛 possible sets of brinks parallel to X_i-axis, 1 ≤i ≤𝑛, produce to the same set EV(𝑝). See in Figure 3(a) the brinks parallel to X₂-axis for the 3D-OPP originally presented in Figure 2.

(a)

(b)

(c)

(d)

(e)

(f)

Figure 3 

Illustrating some EVM concepts over a 3D-OPP (See text for details).

Definition 3.12. Let 𝑝 be an 𝑛D-OPP. A kD extended hypervolume of 𝑝, 1 <𝑘< n, denoted by 𝜙(𝑝), is the maximal set of 𝑘D cells of 𝑝 that lies in a 𝑘D space, such that a 𝑘D cell 𝑒₀ belongs to a 𝑘D extended hypervolume if and only if 𝑒₀ belongs to an (𝑛-1)D cell present in ∂(𝑝) (see Definition 3.5), that is, (𝑒₀∈𝜙(𝑝))⇔(∃𝑐,𝑐belongsto𝜕(𝑝))(𝑒₀([0,1]^𝑘)⊆𝑐([0,1]^𝑛−1)). (3.5)

Definition 3.13. Let 𝑝 be an 𝑛D-OPP. The Extreme Vertices Model of 𝑝, denoted by EVM_𝑛(𝑝), is defined as the model as only stores to all the extreme vertices of 𝑝.

Let Q be a finite set of points in ℝ³. In [10] was defined the ABC-sorted set of Q as the set resulting from sorting Q according to coordinate A, then to coordinate B, and then to coordinate C. For instance, a set Q can be ABC-sorted in six different ways. Now, let 𝑝 be a 3D-OPP. According to [10] the Extreme Vertices Model of 𝑝, EVM₃(𝑝), denotes the ABC sorted set of the extreme vertices of 𝑝. Then EVM₃(𝑝) = EV(𝑝) except by the fact that coordinates of points in EV(𝑝) are not necessarily sorted. In general, it is always assumed that coordinates of extreme vertices in the Extreme Vertices Model of an 𝑛D-OPP 𝑝, EVM_n(𝑝), have a fixed coordinates ordering. Moreover, when an operation requires manipulating two EVMs, it is assumed that both sets have the same coordinates ordering.

Definition 3.14. The Projection Operator for (𝑛-1)D cells, points, and set of points is, respectively, defined as follows.(i)Let 𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥))=(𝑥₁,…,𝑥_𝑛) be an (𝑛-1)D cell embedded in the 𝑛D space. Let 𝜋_𝑗(𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥))) denote the projection of the cell 𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥)) onto an (𝑛-1)D space embedded in 𝑛D space whose supporting hyperplane is perpendicular to X_j-axis 𝜋_𝑗(𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥)))=(𝑥₁,…,𝑥_𝑗,…,𝑥_𝑛). (3.6)(ii)Let 𝑣=(𝑥₁,…,𝑥_𝑛) a point in ℝ^𝑛. The projection of that point in the (𝑛-1)D space, denoted by 𝜋_𝑗(𝑣), is given by: 𝜋_𝑗(𝑣)=(𝑥₁,…,𝑥_𝑗,…,𝑥_𝑛). (3.7)(iii)Let Q be a set of points in ℝ^𝑛. The projection of the points in Q, denoted by 𝜋_𝑗(𝑄), is defined as the set of points in ℝ^𝑛−1 such that𝜋_𝑗(𝑄)={𝑝∈ℝ^𝑛−1∶𝑝=𝜋_𝑗(𝑥),𝑥∈𝑄⊂ℝ^𝑛}, (3.8) In all the cases 𝑥_𝑗 is the coordinate corresponding to X_j-axis to be suppressed.

Definition 3.15. Consider an 𝑛D-OPP 𝑝 as follows.(i)Let 𝑛𝑝_𝑖 be the number of distinct coordinates present in the vertices of 𝑝 along X_i-axis, 1 ≤ i ≤ n. (ii)Let Φ^𝑖_𝑘(𝑝) be the 𝑘th (𝑛-1)D extended hypervolume, or just a (n-1)D couplet, of 𝑝 which is perpendicular to X_i-axis, 1 ≤𝑘≤ np_i.

See in Figure 3(b) the set of 2D-couplets perpendicular to X₂-axis for the 3D-OPP presented in Figure 2.

Definition 3.16. A slice is the region contained in an 𝑛D-OPP 𝑝 between two consecutive couplets of p. Slice^𝑖_𝑘(𝑝) will denote to the 𝑘th slice of 𝑝 which is bounded by Φ^𝑖_𝑘(𝑝)andΦ^𝑖_𝑘+1(𝑝), 1 ≤ k <𝑛𝑝_𝑖.

Definition 3.17. A section is the (𝑛-1)D-OPP, n > 1, resulting from the intersection between an 𝑛D-OPP 𝑝 and an (𝑛-1)D hyperplane perpendicular to the coordinate axis X_i, n ≥ i ≥ 1, which does not coincide with any (𝑛-1)D-couplet of p. A section will be called external or internal section of 𝑝 if it is empty or not, respectively. 𝑆^𝑖_𝑘(𝑝) will refer to the 𝑘th section of 𝑝 between Φ^𝑖_𝑘(𝑝) and Φ^𝑖_𝑘+1(𝑝), 1 ≤𝑘< np_i. Moreover, 𝑆^𝑖₀(𝑝) and𝑆^𝑖_𝑛𝑝𝑖(𝑝) will refer to the empty sections of 𝑝 before Φ^𝑖₁(𝑝) and after ofΦ^𝑖_𝑛𝑝𝑖(𝑝), respectively.

Property 3.18. Let 𝑝 be an n D-OPP. All the (n -1)D hyperplanes perpendicular to X_i -axis, 1 ≤i ≤n, which intersect to Slice^𝑖_𝑘(𝑝) give the same section 𝑆^𝑖_𝑘(𝑝).

The Figures 3(c), 3(d), and 3(e) show the slices for a 3D-OPP (originally presented in Figure 2) according to the supporting planes of its 2D-couplets perpendicular to X₂-axis. Figure 3(f) presents its corresponding set of internal sections perpendicular to X₂-axis.

3.2.1. A Note about Regularized Boolean Operations

Independently of the scheme we consider for the representation of 𝑛D polytopes, it should be feasible to combine them in order to compose new objects [14]. One of the most common methods to combine polytopes is the set theoretical Boolean operations, as the Union, Difference, Intersection, and Exclusive OR. However, the application of an ordinary set theoretical Boolean operation on two polytopes does not necessarily produce a polytope. For example, the ordinary intersection between two cubes with only a common vertex is a point. Instead of using ordinary set theoretical Boolean operators, the Regularized Boolean Operators [15, 16] will be used. The practical purpose of regularization of polytope models is to make them dimensionally homogeneous [17]. The regularization operation can be defined as Regularized(S) = Closure(Interior(S)) which results in a closed regular set. Each regularized Boolean operator is defined in function of an ordinary operator in the following way:Aop^∗B=Closure(Interior(AopB)). (3.9) These operators are defined as the closure of the interior of the corresponding set theoretical Boolean operation [16, 18]. In this way, the regularized operations between polytopes always will generate polytopes or a null object (the empty set) [17].

3.2.2. Computing Couplets from Sections

Theorem 3.19. The projection of the set of (n -1)D couplets, 𝜋_𝑖(Φ^𝑖_𝑘(𝑝)), 1 ≤i ≤𝑛, of an 𝑛D-OPP 𝑝, can be obtained by computing the regularized XOR (⊗∗) between the projections of its previous 𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)) and next 𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)) sections, that is, 𝜋_𝑖(Φ^𝑖_𝑘(𝑝))=𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝))⊗∗𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)), for all 𝑘∈[1,𝑛𝑝_𝑖].

3.2.3. Computing Sections from Couplets

Theorem 3.20. The projection of any section, 𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)), of an 𝑛D-OPP𝑝, can be obtained by computing the regularized XOR between the projection of its previous section, 𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)), and the projection of its previous couplet 𝜋_𝑖(Φ^𝑖_𝑘(𝑝)): 𝑆^𝑖₀𝜋(𝑝)=∅,_𝑖(𝑆^𝑖_𝑘(𝑝))=𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝))⊗∗𝜋_𝑖(Φ^𝑖_𝑘(𝑝)),∀𝑘∈[1,𝑛𝑝_𝑖]. (3.10)

3.2.4. The Regularized XOR Operation on the 𝑛D-EVM

Theorem 3.21. Let 𝑝 and 𝑞 be two 𝑛D-OPPs having EVM_𝑛(𝑝) and EVM_𝑛(𝑞) as their respective Extreme Vertices Models in 𝑛D space, then EVM_𝑛(𝑝⊗∗𝑞)=EVM_𝑛(𝑝)⊗EVM_𝑛(𝑞).

This result allows expressing formulae for computing 𝑛D-OPPs sections from couplets and viceversa by means of their corresponding Extreme Vertices Models. They are obtained by combining Theorem 3.21 with Theorem 3.19 and Theorem 3.21 with Theorem 3.20, respectively.

Corollary 3.22. One has that EVM_𝑛−1(𝜋_𝑖(Φ^𝑖_𝑘(𝑝)))=EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)))⊗EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))).

Corollary 3.23. One has that EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)))=EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)))⊗EVM_𝑛−1(𝜋_𝑖(Φ^𝑖_𝑘(𝑝))).

3.2.5. The Regularized Boolean Operations on the 𝑛D-EVM

Corollary 3.24. Let 𝑝 and 𝑞 be two 𝑛D-OPPs and 𝑟 = 𝑝 op*𝑞, where op* is in {∪^∗,∩^∗,-^∗,⊗^∗}. Then 𝜋_𝑖(𝑆^𝑖_𝑘(𝑟))=𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))op^∗𝜋_𝑖(𝑆^𝑖_𝑘(𝑞)). Moreover, if all these sections lie in the same (n -1)D hyperplane then 𝑆^𝑖_𝑘(𝑟)=𝑆^𝑖_𝑘(𝑝)op^∗𝑆^𝑖_𝑘(𝑞).

Now we present the following.

Theorem 3.25. A regularized Boolean operation, op*, where op*∈{∪^∗,∩^∗,-^∗,⊗^∗}, over two 𝑛D-OPPs 𝑝 and 𝑞, both expressed in the 𝑛D-EVM, can be carried out by means of the same op* applied over their own sections, expressed through their Extreme Vertices Models, which are (n-1)D-OPPs.

This result leads into a recursive process for computing the Regularized Boolean operations using the 𝑛D-EVM, which descends on the number of dimensions [10]. The base or trivial case of the recursion corresponds to the 1D-Boolean operations which can be performed using direct methods. In Section 3.4.2 will be described an algorithm for performing Regularized Boolean operations under the 𝑛D-EVM which implements the above results.

3.3. Basic Algorithms for the 𝑛D-EVM

Now, we introduce some primitive operations which are in fact based on those originally presented in [10]. When an operation requires manipulating two EVMs, it is assumed that both sets have the same coordinates ordering. In the following, 𝑋_𝐴-axis refers to the 𝑛D space’s coordinate axis associated to the first coordinate present in the vertices of EVM_𝑛(p). For example, given coordinates ordering 𝑋₁𝑋₂𝑋₃, for a 3D-OPP, then 𝑋_𝐴=𝑋₁. (i)InitEVM( ): returns the empty set.(ii)PutHvl(EVM hvl, EVM p): appends and (𝑛-1)D couplet hvl, embedded in 𝑛D space and perpendicular to X_A-axis, to the 𝑛D-EVM 𝑝.(iii)ReadHvl(EVM p): extracts and returns the next (𝑛-1)D couplet perpendicular to X_A-axis from 𝑝.(iv)EndEVM(EVM p): returns true if the end of 𝑝 along X_A-axis has been reached, otherwise, returns false.(v)SetCoord(EVM hvl, CoordType coord): sets the X_A-coordinate to coord on every vertex of the (𝑛-1)D couplet hvl. For coord = 0, it performs the projection 𝜋_𝐴(𝑝).CoordType is the chosen type for the vertex coordinates. (vi)GetCoord(EVM hvl): returns the common X_A-coordinate of the (𝑛-1)D couplet hvl. (vii)GetCoordNextHvl(EVM p): returns the common X_A-coordinate of the next available (𝑛-1)D couplet, perpendicular to X_A-axis, from 𝑝.(viii)MergeXor(EVM p, EVM q): applies the Exclusive OR operation to the vertices of 𝑝 and 𝑞 and returns the resulting EVM.

Since the EVM is a sorted model, MergeXor function consists in a simple merging-like algorithm, and therefore, it runs on linear time [10]. Its complexity is given by O(Card(EVM_n(p)) + Card(EVM_n(q))) because each vertex from EVM_n(p) and EVM_n(q) needs to be processed just once. Moreover, according to Theorem 3.21, the resulting set corresponds to the regularized XOR operation between 𝑝 and q.

From the above primitive operations, and specifically MergeXor, the following pair of algorithms can be easily derived ([10, 11]).(i)GetHvl(EVM S_i, EVM S_j): implements Corollary 3.22, and returns the projection of the couplet between consecutive sections S_i and S_j.(ii)GetSection(EVM S, EVM hvl): implements Corollary 3.23, and returns the projection of the next section of an 𝑛D-OPP whose previous section is S.

the Algorithm 1 computes the sequence of sections of an 𝑛D-OPP 𝑝 from its 𝑛D-EVM using the previous functions [10, 11]. It sequentially reads the projections of the (𝑛-1)D couplets hvl of the polytope 𝑝. Then it computes the sequence of sections using function GetSection. Each pair of sections S_i and S_j (the previous and next sections about the current hvl) is processed by a generic processing procedure (called Process), which performs the desired actions upon S_i and S_j (note that some processes may only need one of such sections).

Input: An $n$D-EVM p. Procedure EVM_to_SectionSequence(EVM p)       EVM hvl // Current couplet.       EVM Si, Sj// Previous and next sections about hvl.       hvl = InitEVM( )       Si = InitEVM( )       Sj = InitEVM( )       hvl = ReadHvl(p)       while (Not(EndEVM(p)))           Sj = GetSection(Si, hvl)           Process(Si, Sj)           Si = Sj           hvl = ReadHvl(p) // Read next couplet.       end-of-while end-of-procedure

Algorithm 1 

Computing the sequence of sections from an $n$D-OPP p.

3.4. Interrogating and Manipulating 𝑛D-OPPs Represented via the 𝑛D-EVM

3.4.1. Computing the Content of an 𝑛D-OPP

An 𝑛D hyperprism can be generated by the parallel motion of an (𝑛-1)D polytope; it is bounded by the (𝑛-1)D polytope in its initial and final positions and by several (𝑛-1)D hyperprisms [19]. Consider an 𝑛D hyperprism P_n whose base is an (𝑛-1)D polytope P_𝑛-1 of content C_n-1. If h_n is the distance between its bases, that is, the height of the hyperprism, then its content is given by [19]Content(P_𝑛)=Content(P_𝑛−1)⋅ℎ_𝑛=𝐶_𝑛−1⋅ℎ_𝑛. (3.11)

If it is the case where P_𝑛-1 is an (𝑛-1)D hyperprism with height h_n-1 generated by the parallel motion of an (𝑛-2)D polytope P_𝑛-2, then C_n-1 is given by the expression C_n-1 = C_n-2·h_n-1, where C_n-2 is the content of P_𝑛-2. This last expression yields to rewrite the above equation asContent(P_𝑛)=(Content(P_𝑛−2)⋅ℎ_𝑛−1)⋅ℎ_𝑛=(𝐶_𝑛−2⋅ℎ_𝑛−1)⋅ℎ_𝑛. (3.12)

By considering that each (𝑛-𝑘)D hyperprism P_𝑛-𝑘 is generated by the parallel motion of an (𝑛-𝑘-1)D hyperprism P_𝑛-𝑘-1, where 𝑘 = 0, 1, 2, …, 𝑛-1, then we have that the content of P_n can be computed according to the formulaContent(𝑃_𝑛ℎ)=¹,𝑛=1,Content(𝑃_𝑛−1)⋅ℎ_𝑛,𝑛>1, (3.13) where h_n is the height of hyperprism P_n. In the base case, where 𝑛 = 1, the content of a segment is given directly by its “height”, that is, the distance between its two boundary points.

The previous idea is extended in order to compute the content of 𝑛D space enclosed by an 𝑛D-OPP. In this case we will consider the partition induced by its slices (Definition 3.16). A slice can be seen as a set of one or more disjoint 𝑛D hyperprisms whose (𝑛-1)D base is the slice’s section. As pointed out in [10] the volume of a 3D-OPP 𝑝 can be computed as the sum of the volumes of its 3D slices, where the volume of a Slice^𝑖_𝑘(𝑝), is given by the product between the area of its respective section 𝑆^𝑖_𝑘(𝑝) (the 2D base of Slice^𝑖_𝑘(𝑝)) and the distance between Φ^𝑖_𝑘(𝑝) and Φ^𝑖_𝑘+1(𝑝) (the height of the 3D prism Slice^𝑖_𝑘(𝑝)). Now let 𝑞 = 𝑆^𝑖_𝑘(𝑝). The area of the 2D-OPP 𝑞 (see Figure 4 for an example) can be computed as the sum of the areas of its 2D slices, where the area of a Slice^𝑖_𝑘(𝑞), is given by the product between the length of its respective section 𝑆^𝑖_𝑘(𝑞) (the 1D base of Slice^𝑖_𝑘(𝑞)) and the distance between Φ^𝑖_𝑘(𝑞) and Φ^𝑖_𝑘+1(𝑞) (the height of the “2D prism” Slice^𝑖_𝑘(𝑝)). Finally let 𝑟 = 𝑆^𝑖_𝑘(𝑞). In the basic case the length of the 1D-OPP 𝑟 is computed as the sum of the lengths of its brinks.

Figure 4 

A 2D-OPP $q$ whose area is being computed (see text for details).

Let 𝑝 be an 𝑛D-OPP. The 𝑛D space enclosed by 𝑝, denoted by Content_(𝑛)(𝑝), can be computed as the sum of the contents of its 𝑛D slices [11]Content_(𝑛)(𝑝)=Length(𝑝)𝑛=1,_{𝑛𝑝𝑖−1𝑘=1}Content_(𝑛−1)(𝑆^𝑖_𝑘(𝑝))⋅dist(Φ^𝑖_𝑘(𝑝),Φ^𝑖_𝑘+1(𝑝))𝑛>1. (3.14) Algorithm 2 implements the above equation in order to compute the content of 𝑛D space enclosed by an 𝑛D-OPP 𝑝 expressed through the 𝑛D-EVM [10, 11].

Input: An $n$D-EVM p.      The number n of dimensions. Output: The content of nD space enclosed by p. Procedure Content(EVM p, int n)        real cont = 0.0// The content of nD space enclosed by p.        EVM hvl1, hvl2// Consecutive couplets perpendicular to XA-axis.        EVM s// Current section of p.        if (n = 1) then return Length(p) // Base case: p is a 1D-OPP.        else           s = InitEVM( )           hvl1 = ReadHvl(p)           while (Not(EndEVM(p)))                    hvl2 = ReadHvl(p)                     s = GetSection(s, hvl1)                     cont = cont + Content(s, n-1) * dist(hvl1, hvl2)                     hvl1 = hvl2           end-of-while           return cont        end-of-else end-of-procedure

Algorithm 2 

Computing the content of $n$D space enclosed by an OPP.

3.4.2. The Boolean Operations Algorithm for the 𝑛D-EVM

Let 𝑝 and 𝑞 be two 𝑛D-OPPs represented through the 𝑛D-EVM, and let op* be a regularized Boolean operator in {∪^∗,∩^∗,-^∗,⨂^∗}. The algorithm, originally presented in [10] and based on Theorem 3.25, computes the resulting 𝑛D-OPP 𝑟 = p op* q. Note that 𝑟 = p ⊗*𝑞 can also be trivially performed using Theorem 3.21 [10]. The idea behind the algorithm is the following.(i)The sequence of sections from 𝑝 and 𝑞, perpendicular to X_A-axis, is obtained first, based on Theorem 3.20. (ii)Then, according to Corollary 3.24, every section of 𝑟 can recursively be computed as 𝑆^𝐴_𝑘(𝑟)=𝑆^𝐴_𝑘(𝑝)op^∗𝑆^𝐴_𝑘(𝑞). (3.15)(iii)Finally, 𝑟 can be obtained from its sequence of sections, perpendicular to X_A-axis, according to Theorem 3.19.

Nevertheless, Algorithm 3 does not work in this sequential form. It actually works in a wholly merged form in which it only needs to store one section for each of the operands 𝑝 and 𝑞 and two consecutive sections for the result r.

Input: The nD-OPPs $p$ and $q$ expressed in the $n$D-EVM.          The number n of dimensions and regularized Boolean operation op. Output: The output nD-OPP r, such that r = $p$ op*$q$, codified as an $n$D-EVM. Procedure BooleanOperation(EVM p, EVM q, BooleanOperator op, int n)        EVM sP, sQ // Current sections of p and q respectively.        EVM hvl // I/O couplet.        boolean fromP, fromQ // flags for the source of the couplet hvl.        CoordType coord // the common coordinate of couplets.        EVM r, sRprev, sRcurr // nD-OPP r and two of its sections.        if (n = 1) then // Base case          return BooleanOperation1D(p, q, op)        else          n = n $-$ 1          sP = InitEVM( )          sQ = InitEVM( )          sRcurr = InitEVM( )          NextObject(p, q, coord, fromP, fromQ)          while (Not(EndEVM(p)) and Not(EndEVM(q)))                 if (fromP = true) then                       hvl = ReadHvl(p)                       sP = GetSection(sP, hvl)                 end-of-if                if (fromQ = true) then                       hvl = ReadHvl(q)                       sQ = GetSection(sQ, hvl)                end-of-if                sRprev = sRcurr                sRcurr = BooleanOperation(sP,sQ,op,n) // Recursive call                hvl = GetHvl(sRprev, sRcurr)                SetCoord(hvl, coord)                PutHvl(hvl, r)                NextObject(p, q, coord, fromP, fromQ)          end-of-while          while (Not(EndEVM(p)))                hvl = ReadHvl(p)                PutBool(hvl, r, op)          end-of-while          while (Not(EndEVM(q)))                hvl = ReadHvl(q)                PutBool(hvl, r, op)          end-of-while          return r        end-of-if end-of-procedure

Algorithm 3 

Computing regularized Boolean operations on the EVM.

The following are some functions present in Algorithm 3 but not defined previously.(i)Function BooleanOperation1D performs 1D Boolean operations between 𝑝 and 𝑞 that are two 1D-OPPs.(ii)Procedure NextObject considers both input objects 𝑝 and 𝑞 and returns the common coord value of the next hvl to process, using function GetCoord. It also returns two flags, fromP and fromQ, which signal from which of the operands (both inclusive) is the next hvl to come.(iii)The main loop of procedure BooleanOperation gets couplets from 𝑝 and/or 𝑞, using function GetSection. These sections are recursively processed to compute, according to Corollary 3.24, the corresponding section of 𝑟, sRcurr. Since two consecutive sections, sRprev and sRcurr, are kept, then the projection of the resulting hvl, is obtained by means of function GetHvl, and then, it is correctly positioned by procedure SetCoord.

When the end of one of the polytopes 𝑝 or 𝑞 is reached then the main iteration finishes, and the remaining couplets of the other polytope are either appended or not to the resulting polytope depending on the Boolean operation considered. Procedure PutBool performs this appending process.

3.5. Hypervoxelizations to 𝑛D-EVM Conversion

First, consider the following.

Corollary 3.26 (see [10, 11]). Let 𝑝 and 𝑞 be two disjoint or quasi disjoint 𝑛D-OPPs having EVM_n (𝑝) and EVM_n (𝑞) as their respective Extreme Vertices Models, then EVM_𝑛(𝑝∪𝑞)=EVM_𝑛(𝑝)⊗EVM_𝑛(𝑞).

As previously commented in the introduction of this paper, a hypervoxelization is a set of quasi-disjoint black and white hypervoxels each one being a convex orthogonal polytope. Since the set of black hypervoxels represents an 𝑛D-OPP 𝑝 we have [10]𝑝=_𝜆𝐵𝑙𝑎𝑐𝑘𝐻𝑦𝑝𝑒𝑟𝑣𝑜𝑥𝑒𝑙_𝜆. (3.16) For each black hypervoxel it should be possible to generate a list of its 2ⁿ vertices. Because all of these 2ⁿ vertices are Extreme Vertices, and by considering Corollary 3.26, all we have to do is [10]EVM_𝑛(𝑝)=EVM_𝑛(_𝜆𝐵𝑙𝑎𝑐𝑘𝐻𝑦𝑝𝑒𝑟𝑣𝑜𝑥𝑒𝑙_𝜆)=⊗_𝜆EVM_𝑛(𝐵𝑙𝑎𝑐𝑘𝐻𝑦𝑝𝑒𝑟𝑣𝑜𝑥𝑒𝑙_𝜆). (3.17) This provides a straight and simple method for converting a hypervoxelization to the 𝑛D-EVM.

4. Computing Discrete Compactness for an 𝑛D-OPP Expressed in the 𝑛D-EVM

In the following it is assumed an 𝑛D-OPP fits exactly in a hypervoxelization, where hypervoxels are unit 𝑛D hypercubes whose vertices have integer coordinates. Given a polytope 𝑝 expressed in the 𝑛D-EVM, and in order to compute 𝐿_𝐶(𝑝), that is, the number of shared (𝑛-1)D cells between the m hypervoxels that originally described 𝑝, we start by processing its (𝑛-1)D sections perpendicular to X_A-axis. By considering a section, it can be determined the number of hypervoxels that originally described its corresponding slice. Furthermore, it is possible to obtain information about internal contacts, perpendicular to X_A-axis, between the hypervoxels that described such 𝑛D slice. Let 𝑆_𝑗 be the section associated to Slice^𝐴_𝑗(𝑝). Then, the following steps are performed.(i)Let c₁ and c₂ be the common 𝑋_𝐴 coordinates of previous and next couplets, perpendicular to X_A-axis, about section S_j. Let nCoords = c₂ – c₁ – 1 be the number of integer coordinates between c₁ and c₂. In fact, nCoords = Card({c₁ + 1, c₁ + 2, …, c₂ – 1}). (ii)Because of 𝑝’s assumed original representation, it is clear by computing the 𝑛D content of Slice^𝐴_𝑗(𝑝) that it is obtained the number of black 𝑛D hypervoxels that originally defined it. Now, let H be an (𝑛-1)D hyperplane perpendicular to X_A-axis such that it intersects Slice^𝐴_𝑗(𝑝) and does not coincide with the supporting hyperplanes of the previous and next couplets about section 𝑆_𝑗. Assuming the common X_A-coordinate of the points in H is in {c₁ + 1, c₁ + 2, …, c₂ – 1}, and by computing the (𝑛-1)D content of the projection of section 𝑆_𝑗, there is obtained the number of those hypervoxels which have an (𝑛-1)D boundary cell embedded in hyperplane H. (iii)Finally, the number of internal contacts, perpendicular to X_A-axis, between the hypervoxels that originally defined Slice^𝐴_𝑗(𝑝), is given by the product of nCoords (the number of integer coordinates between the previous and next couplets about S_j) and the (𝑛-1)D content of S_j.

The above procedure determines the number of internal contacts, perpendicular to X_A-axis, between the hypervoxels that originally composed to Slice^𝐴_𝑗(𝑝). Now, we must determine the number of internal contacts ((𝑛-1)D adjacencies) between those hypervoxels that belong to Slice^𝐴_𝑗(𝑝) with hypervoxels in the next slice, that is, Slice^𝐴_𝑗+1(𝑝). Those shared cells are embedded in the supporting (𝑛-1)D hyperplane of the couplet between sections 𝑆_𝑗 and 𝑆_𝑗+1. (i)The projections of consecutive sections 𝑆_𝑗 and 𝑆_𝑗+1 are intersected in such way that it is obtained an (𝑛-1)D-OPP 𝑆_int. (ii)The number of those (𝑛-1)D boundary cells, embedded in the supporting (𝑛-1)D hyperplane of the couplet between 𝑆_𝑗 and 𝑆_𝑗+1, is given by computing the (𝑛-1)D content of 𝑆_int. If 𝑆_int is empty then it implies that (1) one of the sections, 𝑆_𝑗 or 𝑆_𝑗+1, is empty or (2) projections of 𝑆_𝑗 and 𝑆_𝑗+1 are disjoint or quasi-disjoint. In both cases no (𝑛-1)D contact occurs between Slice^𝐴_𝑗(𝑝) and Slice^𝐴_𝑗+1(𝑝).

Algorithm 4 implements the above procedures.

Input:   An $n$D-EVM $p$ and the number $n$ of dimensions. Output:  The number of internal contacts, perpendicular to the XA-axis, between      the hypervoxels that originally composed p. Procedure  InternalContacts(EVM p, int n)       EVM hvl// Current couplet of p.       EVM ${\text{S}}_{\text{i}}$, ${\text{S}}_{\text{j}}$// Previous and next sections about hvl.       EVM ${\text{S}}_{\mathrm{int}\hspace{0.17em}}$// The result of intersecting the projections of Si and Sj.       int c1// Common XA-coordinate of couplet hvl.       int c2// Common XA-coordinate of couplet next to hvl.       int nCoords// Number of integer coordinates between c1 and c2.       int L = 0// Number of internal contacts ((n-1)D adjacencies).       Si = InitEVM( )       c1 = GetCoordNextHvl(p)       hvl = ReadHvl(p)       while (Not(EndEVM(p)))      Sj = GetSection(Si, hvl)      c2 = GetCoordNextHvl(p)      nCoords = ${\text{c}}_2-{\text{c}}_1-1$      L = L + nCoords * Content(Sj, n $-$ 1)      Sint = BooleanOperation(${\text{S}}_{\text{i}}$, ${\text{S}}_{\text{j}}$, Intersection, n $-$ 1)      L = L + Content(${\text{S}}_{\mathrm{int}\hspace{0.17em}}$, n $-$ 1)      Si = Sj      c1 = c2      hvl = ReadHvl(p)// Read next couplet.      end-of-while      return L end-of-procedure

Algorithm 4 

Computing the number of ($n$-1)D adjacencies between the hypervoxels that originally defined an $n$D-OPP p.

We will clarify the way Algorithm 4 works with the following example. Consider the object defined by the 3D boxes presented in Figure 5(a). The 3D grid where the object is embedded has dimensions 8×8×8. The coordinates of all the boxes’ vertices are in the set {0,1,…,8}³. When the boxes are united, according to the procedure described in Section 3.5, it is obtained the 3D-OPP 𝑝 shown, as a wireframe model, in Figure 5(b). Its 3D-EVM is composed by 14 extreme vertices. Figure 5(c) shows 𝑝’s three couplets perpendicular to X₁-axis, while Figure 5(d) presents its pair of internal sections, 𝑆¹₁(𝑝) and 𝑆¹₂(𝑝), also perpendicular to X₁-axis. 2D section 𝑆¹₁(𝑝) is associated to Slice¹₁(𝑝) (see Figure 5(e)), while 𝑆¹₂(𝑝) is associated to Slice¹₂(𝑝) (Figure 5(f)). Suppose that 2D couplets Φ¹₁(𝑝), Φ¹₂(𝑝), and Φ¹₃(𝑝) have common X₁ coordinates given by 0, 4, and 8, respectively. Hence, the number of integer coordinates, along X₁-axis, between couplets Φ¹₁(𝑝) and Φ¹₂(𝑝) is 3. Such coordinates are 1, 2, and 3. Now, consider the projection of section 𝑆¹₁(𝑝) (Figure 5(g)). Because the boxes in the original voxelization were unitary, then the area of 𝑆¹₁(𝑝), 64 u², corresponds to the number of faces embedded in a plane intersecting Slice¹₁(𝑝) which does not coincide with Φ¹₁(𝑝) nor Φ¹₂(𝑝), and whose common X₁ coordinate is in {1,2,3}. Therefore, the number of internal contacts (face adjacencies), between the boxes that originally composed to Slice¹₁(𝑝) is given by the product 3 · 64 = 192.

(a)

(b)

(c)

(d)

(e)

(f)

(g) π1(S11(p)), Area: 64 u2

(h) π1(S21(p)), Area: 48 u2

(i) Sint =π1(S11(p))∩*π1(S21(p)) Area: 48 u2

Figure 5 

Computing the number of face adjacencies, perpendicular to X1-axis, between the voxels that originally defined a 3D-OPP now expressed with a 3D-EVM (see text for details).

Now, we proceed to determine the number of internal contacts in Slice¹₂(𝑝). The number of integer coordinates, along X₁-axis, between couplets Φ¹₂(𝑝) and Φ¹₃(𝑝) is 3. Such coordinates are 5, 6, and 7. Consider the projection of section 𝑆¹₂(𝑝) (Figure 5(h)). The area of 𝑆¹₂(𝑝) is 48 u². It corresponds to the number of faces embedded in a plane intersecting Slice¹₂(𝑝) which does not coincide with Φ¹₂(𝑝) nor Φ¹₃(𝑝), and whose common X₁ coordinate is in {5,6,7}. The number of internal contacts (face adjacencies), between the boxes that originally composed to Slice¹₂(𝑝) is given by the product 3 · 48 = 144. Finally, we compute the regularized intersection between projections of sections 𝑆¹₁(𝑝) and 𝑆¹₂(𝑝), that is, 𝑆_int=𝜋₁(𝑆¹₁(𝑝))∩∗𝜋₁(𝑆¹₂(𝑝)). See Figure 5(i). The area of 2D-OPP S_int is 48 u². This number corresponds to the number of faces, in the original voxelization, embedded in the supporting plane of couplet Φ¹₂(𝑝). Each one of these faces implies a face adjacency between a voxel that belongs to Slice¹₁(p) and a voxel in Slice¹₂(𝑝). Finally, the number of face adjacencies, perpendicular to X₁-axis, between the boxes in p’s original voxelization, is 384. Because of p’s symmetry, it can be easily verified that the number of face adjacencies perpendicular to X₂-axis and X₃-axis is also 384. Therefore, 𝐿_𝐶(𝑝)=384+384+384=1,152.

As seen, Algorithm 4 extracts those sections of 𝑛D-OPP p which are perpendicular to X_A-axis which implies that it only counts internal contacts perpendicular to this same coordinate axis. Suppose that the coordinates ordering in EVM_n(p) is given by 𝑋₁𝑋₂…𝑋_𝑛−1𝑋_𝑛. Each one of the coordinates orderings in the set {𝑋₁𝑋₂…𝑋_𝑛−1𝑋_𝑛,𝑋₂𝑋₃…𝑋_𝑛𝑋₁,𝑋₃𝑋₄…𝑋₁𝑋₂,…,𝑋_𝑛𝑋₁…𝑋_𝑛−2𝑋_𝑛−1} is now used for sorting EVM_n(p). Such sorting is performed by calling a procedure SortEVM. Given a permutation X_𝛼1X_𝛼2⋯X_𝛼n, the function sorts the extreme vertices of p first according to coordinate X_𝛼1, after according to coordinate X_𝛼2, and so on until p is sorted according to coordinate X_𝛼n. Next, it is performed a calling to Algorithm 4. By this way, it is computed the number of contacts perpendicular to each one of the axes in 𝑛D space. The sum of all contacts perpendicular to all coordinate axes leads to determine 𝐿_𝐶(𝑝). Algorithm 5 implements this procedure.

Input:   An $n$D-EVM p and the number n of dimensions. Output: The number of internal contacts, perpendicular to Xi-axis,          i=1,2,…,n, between the hypervoxels that originally composed p. Procedure TotalInternalContacts(EVM p, int n)       int Lc = 0        for each sorting in $\{$X1X2$\dots$Xn-1Xn,X2X3$\dots$XnX1,X3X4$\dots$X1X2,$\dots$,XnX1$\dots$Xn-2Xn-1$\}$  do          SortEVM(p, n, sorting)          Lc = Lc + InternalContacts(p, n) // Call to Algorithm 4.        end-of-for        return Lc end-of-procedure

Algorithm 5 

Computing L_C(p) for an $n$D-OPP expressed in the EVM.

5. Representing Color 2D-Animations through 4D-OPPs and the EVM

The procedure described in [10] for processing black and white 2D animations can be directly extended to control colored frames through a 4D-OPP represented through the EVM. This methodology was originally presented in [11, 12]. In Figure 6 an example of a simple color 2D animation composed by four frames whose resolution is 9 × 9 pixels is shown. In each frame can be identified white, red, blue, gray, and cyan regions. We will use this simple animation to exemplify our procedure. We will label each colored frame in the animation as f_k and m will be the number of such frames.

(a)

(b)

(c)

(d)

Figure 6 

Example of a simple color 2D-animation.

A color animation can be handled as a 4D-OPP in the following way [11, 12].

(a) The Red-Green-Blue (RGB) components of each pixel will be integrated into a single value. Such value represents the RGB components as an integer with 32 bits. Bits 0–7 correspond to the blue value, bits 8-15 correspond to the green value, bits 16–23 correspond to the red value, and bits 24–31 to the alpha (transparency) value. Each pixel will now be extruded towards the third dimension, where the value integrating its RGB components will now be considered as its X₃ coordinate (coordinates X₁ and X₂ correspond to the original pixels' coordinates). See Figure 7.

Figure 7 

The 3D space defined for the extrusion of color 2D-pixels.

Let us call 𝑥𝑓_𝑘 to the set composed by the rectangular prisms (the extruded pixels) of each extruded frame f_k. It is very important to avoid the zero value in the X₃ coordinate because a pixel could not be extruded, and therefore its associated prism (a 3D-OPP) will not be obtained. See Figure 8.

(a)

(b)

(c)

(d)

Figure 8 

The sets of prisms resulting of the extrusion of the frames of an animation (presented in Figure 6).

(b) Let prism_i be a prism in 𝑥𝑓_𝑘 and npr the number of prisms in that set. Due to all the prisms in 𝑥𝑓_𝑘 are quasi disjoint 3D-OPPs, we can easily obtain the final 3D-OPP and its respective 3D-EVM of the whole 3D frame via Corollary 3.26 (all the vertices in a prism_i are extreme vertices)EVM₃(𝐹_𝑘)=⊗^𝑛𝑝𝑟_𝑖=1EVM₃(prism_𝑖∈𝑥𝑓_𝑘), (5.1) where F_k is the 3D frame (a 3D-OPP) that represents the union of all the prisms in xf_k. See Figure 9.

(a)

(b)

(c)

(d)

Figure 9 

The 3D frames that represent a 2D colored animation (presented in Figure 6; Some of their extreme vertices are shown).

(c) Let us extrude 𝐹_𝑘 into the fourth dimension and thus obtain a 4D hyperprism_k whose bases are 𝐹_𝑘 and its length is proportional to the time 𝑓_𝑘 is to be displayed. The new fourth dimension will measure and represent the time. See Figure 10.

Figure 10 

The process of extrusion of a 3D frame in order to obtain a hyperprism (some of its extreme vertices are shown).

(d) Let p be the 4D-OPP that represents the given color 2D-animation. Polytope p is defined by 𝑝=^𝑚_𝑘=1hyperprism_𝑘. (5.2)

Due to all the m hyperprisms are quasi disjoint 4D-OPPs, then the 4D-EVM for p can be obtained byEVM₄(𝑝)=⊗^𝑚_𝑘=1EVM₄(hyperprism_𝑘). (5.3)

By representing a given color 2D-animation using a 4D-OPP p and its 4D-EVM, we have the following characteristics [11, 12].(i)The sequence of the projections of sections in p corresponds to the sequence of 3D frames, that is, 𝜋₄(𝑆⁴_𝑘(𝑝))=𝐹_𝑘.(ii)Computation of 3D frames: by Corollary 3.23 the 3D-EVM of the frame F_k is computed by EVM₃(𝐹_𝑘)=EVM₃(𝐹_𝑘−1)⊗EVM₃(𝜋₄(Φ⁴_𝑘(𝑝))).(iii)Displaying the 2D colored animation: each couplet perpendicular to the X₃ axis in each 3D frame F_k contains the polygons to display. The colors to apply to those polygons are referred through the X₃ coordinate that contains the integrated RGB components.

6. Discrete Compactness of 4D-OPPs: An Application

In this section there will be described our first steps towards an application of Discrete Compactness in a higher dimensional context, via the algorithms presented in Section 4, in the classification and indexing of video sequences. In the previous section, it was presented a methodology for representing color 2D animations through 4D-OPPs and the EVM. In the case to be boarded now, we will consider image sequences associated to the Popocatépetl volcano which is located in the Mexican State of Puebla. The images were obtained from the CENAPRED web site [20]. The CENAPRED is a Mexican research center which has as one of its functions monitoring the volcano’s activity.

Each sequence presents the volcano’s activity along four consecutive days. The sequences are then composed by 4 images, or frames, each one taken each day. All the images were captured in the time range comprehended from 10 AM to 2 PM We have a set of 521 images which correspond to dates between January 1, 2007 and June 4, 2008. They have resolution 640 × 480 under the color model RGB. In a preprocessing phase, images were scaled to the new resolution 320 × 240, and the color model was changed to grayscale. Moreover, a multilevel threshold was applied in order to eliminate noise (specifically we applied some procedures defined in [21]). There were generated 520 sequences to which was applied the procedure described in previous section in such way that for each one was generated its corresponding 4D polytope: two geometrical dimensions (X₁ and X₂), one color dimension (X₃), and one dimension associated to time (X₄). Consequently, the obtained 4D polytopes were expressed in the EVM.

For each 4D polytope it was computed its Discrete Compactness. It is clear each generated polytope is embedded in a hyper-box with main diagonal defined by the pair of points (0,0,0,0) and (321,241,256,4). Such hyper-box will be called 𝐻_max, and it corresponds to a sequence composed by 4 white frames. On the other hand, let 𝐻_min be the hyper-box described by the main diagonal with start and end points given, respectively, by (0,0,0,0) and (321,241,1,4). It corresponds to a sequence where all the frames are black. The required values 𝐿_𝐶max and 𝐿_𝐶min are computed through Algorithm 5 by using as input the EVMs associated to hyper-boxes 𝐻_max and 𝐻_min, respectively. That is, 𝐿_𝐶max=𝐿_𝐶(𝐻_max) and 𝐿_𝐶min=𝐿_𝐶(𝐻_min).

The 520 sequences were sorted according to the discrete compactness of their corresponding 4D polytope. Compactness’ maximum obtained value was 0.8367 while the minimum was given by 0.7236. Sequences were grouped in 12 classes (see Tables 1 and 2). Each class contains sequences whose discrete compactness is inside an arbitrarily defined range. The classes 1 to 4 group sequences with compactness major or equal to 0.72 and more minor than 0.76. These classes have 1, 3, 1, and 16 members respectively and they have as an interesting characteristic the fact that some of their members are sequences that describe intense volcanic activity. See for example the representative sequences for classes 1, 2, and 3 (Table 1). They describe the same event: an eruption which took place in December 1, 2007 [20].

Table 1 

Using discrete compactness for classifying 4D-OPPs associated to images sequences (Part 1).

Table 2 

Using Discrete Compactness for classifying 4D-OPPs associated to images sequences (Part 2).

Classes 5 to 8 group sequences with discrete compactness inside the range [0.76,0.80). The majority of these sequences describe volcanic activity that goes from null to moderate. The classes 9 to 12 (Table 2) have as members sequences whose 4D polytopes have Discrete Compactness in the range [0.80,0.84). In this case, a great part of these sequences have the property that they correspond to days where the visibility towards the volcano was minimized by clouds or even was null. All the sequences in classes 9, 10, and 11 have cloudy days with low visibility. Moreover, there are also sequences in which the number of days with null visibility oscillated between 1 and 3. Class 12 is the only one where there are sequences such that all four days had null visibility.

The above results are promising in the sense that discrete compactness could be applied as a mechanism for indexing/classification/comparison of 𝑛-Dimensional Polytopes. In our example, we have obtained preliminary results that allow classifying 4D objects which in time describe image sequences. We implemented the algorithms and procedures described in this paper in the Java Language (Java Development Kit version 1.6). They were executed in a computer with an Intel Processor Core 2 Duo, 2.40 GHz, and 2 Gigabytes in RAM. In Tables 1 and 2 can be appreciated, for each class, the average processing time required for computing discrete compactness for our 4D polytopes. These time measures provide experimental evidence of efficiency in Discrete Compactness’ computation via the EVM. Another provided data are the referent to the average number of extreme vertices required for representing sequences. A 4D polytope that corresponds to the representation of a sequence of images could be also represented and manipulated via a 4D hypervoxelization. As described previously, all our polytopes are embedded in a 4D hyper-box with main diagonals defined by points (0,0,0,0) and (321,241,256,4). In fact, the required 4D grid for representing our polytopes through a hypervoxelization should be at least of size 320 × 240 × 256 × 4. This implies to store 78,643,200 4D hypervoxels. The average number of extreme vertices, required for representing the sequences contained in class 3, is 388,512. In fact, this is the maximum average from the 12 proposed classes. The ratio 78,643,200388,512=202.4215 (6.1) clearly shows how the EVM is effectively a suitable representation for these sequences because its memory requirements are much less when compared with a hypervoxelization scheme.

7. Concluding Remarks

Nowadays it is common to find applications where the search of results and properties is more suitable to be performed in hyperspaces. On one side, this implies that the representations to use must be powerful enough in the sense that conciseness, efficiency, and robustness are mandatory characteristics to be taken in account. On the other side, we consider that the notion of Discrete Compactness in higher dimensional contexts plays a fundamental role in tasks related to classification, description, and indexing of 𝑛D polytopes. In such sense, this paper has been devoted to present a set of methodologies that allow the efficient computation of Discrete Compactness of those 𝑛D-OPPs whose original representation was based on a hypervoxelization. In Section 3 we described the Extreme Vertices Model in the 𝑛-Dimensional space which represents concisely 𝑛D-OPPs. It was described a straight method for conversion of hypervoxelizations to the 𝑛D-EVM. By expressing a polytope via the EVM, we have, on one hand, the important advantage related to the fact that EVM’s storing requirements are much less than those required by a hypervoxelization model. On the other hand, it is available a set of EVM-based algorithms that allow the manipulation and querying of polytopes represented under our model. As commented in the previous sections, the EVM of a polytope is in fact a subset of its vertices. However, the algorithms presented in Section 3 obtain, from such subset of vertices, useful topological and geometrical information. Supported in those algorithms, we have proposed, specifically in Section 4, methodologies for performing the computation of Discrete Compactness. We have extended, in direct way, concepts presented by Bribiesca in [1, 5], in order to apply them on 𝑛D-OPPs expressed under the EVM.

In Section 6 we presented how by using our EVM-based implementation of Discrete Compactness it was possible to classify in efficient way images sequences associated to Popocatépetl volcano. They were grouped according to the value of their corresponding compactness. Informally, we saw how sequences with visual common properties have near compactness values. On the other hand, currently we are working in procedures for extracting the number of 𝑘D elements on the boundary, 𝑘=0,1,2,…,𝑛−1, of an 𝑛D-OPP expressed in the EVM. Such counts by themselves are geometrical factors describing the polytope, but they can also be useful for determining, for example, topological factors such as the well-known Euler characteristic. The first steps presented in this paper, the obtained results and observations, and the new methodologies we are defining for extracting another geometrical and topological factors, encourage us to concentrate our efforts towards the following main idea. we want to determine how factors, such as Discrete Compactness, Euler characteristic, boundary elements counts, and so forth, that describe a higher dimensional polytope representing a sequence, can be used for a specification for indexing and classification of video sequences. Moreover, we will investigate if such factors, that provide us descriptive information about a higher dimensional object, can be used to infer properties and relations about the events taking place in the video sequences under consideration. The 𝑛D-EVM will play a paramount role because it is expected to take full advantage of its storage requirements and its algorithms’ efficiency.

Finally, we conclude by commenting the 𝑛D-EVM is a model that has been successfully applied in tasks such as (1) image comparison by enhanced image-based reasoning, (2) collision detection of 2D and 3D objects whose trajectories are, respectively, modeled as 3D and 4D-OPPs, (3) concise representation and efficient querying of volume datasets, (4) morphological operations on binary images, and (5) connected components labeling. Applications 1, 2, and 3 are appropriately developed in [11] while applications 4 and 5 are presented in [22, 23]. In [9–11, 23] there are described algorithms based on the 𝑛D-EVM, besides the ones described in this paper, which are useful and efficient for performing other interrogations and manipulations on 𝑛D-OPPs.