Efficient Boundary Extraction from Orthogonal Pseudo-Polytopes: An Approach Based on the 𝑛D-EVM

Abstract

This work is devoted to contribute with two algorithms for performing, in an efficient way, connected components labeling and boundary extraction from orthogonal pseudo-polytopes. The proposals are specified in terms of the extreme vertices model in the 𝑛-dimensional space (𝑛D-EVM). An overview of the model is presented, considering aspects such as its fundamentals and basic algorithms. The temporal efficiency of the two proposed algorithms is sustained in empirical way and by taking into account both lower dimensional cases (2D and 3D) and higher-dimensional cases (4D and 5D).

1. Introduction

The extreme vertices model in the 𝑛-dimensional space (𝑛D-EVM) is a representation scheme whose dominion is given by the 𝑛-dimensional orthogonal pseudo-polytopes, that is, polytopes that can be seen as a finite union of iso-oriented 𝑛D hyperboxes (e.g., hypercubes). The fundamental notions of the model, for representing 2D and 3D-OPPs, were originally established by Aguilera and Ayala in [1, 2]. Then, in [3], it was formally proved the model is capable of representing and manipulating 𝑛D-OPPs. The 𝑛D-EVM has a well-documented repertory of algorithms (see [1, 3–7]) for performing tasks such as Regularized Boolean operations, set membership classification, measure interrogations (content and boundary content), morphological operations (e.g., erosion and dilation), geometrical and topological interrogations (e.g., discrete compactness), among other algorithms currently being in development. Furthermore, conciseness, in terms of spatial complexity, is one the 𝑛D-EVM’s main properties, because the model only requires storing a subset of a polytope’s vertices, the extreme vertices, which finally provides efficient temporal complexity of our algorithms. Sections 2 and 3 are summaries of results originally presented in [1, 3]. For the sake of brevity, and because we aim for a self-contained paper, some propositions are only enunciated. Their corresponding proofs and more specific details can be found in [1, 3]. In Section 2, the main concepts and basic algorithms behind the 𝑛D-EVM are described, while Section 3 presents an algorithm for extracting forward and backward differences of an 𝑛D-OPP.

Section 4 presents the first main contribution of this work: An EVM-based algorithm for computing connected components labeling over an 𝑛D-OPP. It is well known connected components labeling is one of the most important tools in image processing and computer vision. The main idea is to assign labels to the pixels in an image such that all pixels that belong to a same connected component have the same label [8]. As pointed out by [9], it is essential for the specification of efficient methods that identify and label connected components in order to process them separately for the appropriate analysis and/or operations. Several approaches have been proposed in order to achieve such labeling, and some of them are applicable in multidimensional contexts (e.g., see [10, 11]), but there is a step that is commonly present in the majority of the methodologies: the scanning step [12]. Such a step determines a label for the current processed pixel via the examination of those neighbor pixels with an assigned label. Suzuki et al. group the methods for connected components labeling in four categories [13].(i)Methods that require multiple passes over the data: the scanning step is repeated successively until each pixel has a definitive label.(ii)Two-pass methods: they scan the image once to assign temporal labels. A second pass has the objective of assigning the final labels. They make use of lookup lists or tables in order to model relationships between temporal and/or equivalent labels [9]. (iii)Methods that use equivalent representations of the data: their strategy is based on using a more suitable representation based on hierarchical tree structures (quadtrees, octrees, etc.) instead of the image’s raw data in order to speed up the labeling [10, 14]. (iv)Parallel algorithms.

In [7], Rodríguez and Ayala describe an EVM-based algorithm for connected components labeling. It works specifically for 2D and 3D-OPPs. First, they obtain a particular partitioning from the 3D-EVM known as ordered union of disjoint boxes (OUODB), which is, in fact, a special kind of cell decomposition [7]. Then, once the OUODB partition has been achieved, it follows a process which is based in the two-pass approach. We take into account some ideas presented by Rodríguez and Ayala, but our proposal deals with a higher-dimensional context, that is, with 𝑛D-OPPs, and it works directly with their corresponding 𝑛D-EVM representations.

Section 5 describes the second contribution of this work: a methodology for extracting 𝑘D boundary elements from an 𝑛D-OPP represented through the 𝑛D-EVM. It is well known that a boundary model for a 3D solid object is a description of the faces, edges, and vertices that compose its boundary together with the information about the connectivity between those elements [15]. However, the boundary representations can be recursively applied not only to solids, surfaces, or segments but to 𝑛-dimensional polytopes [16]. For Putnam and Subrahmanyan, a polytope’s boundary representation can be seen as a boundary tree [17]. In the tree, each node is split into a component for each element that it bounds. An element (vertex, edge, etc.) will be represented several times inside the tree, one for each boundary that it belongs to. See Figure 1 for a cube’s boundary tree.

Figure 1 

The boundary tree associated to a 3D cube.

The way we extract 𝑘D boundary elements from an 𝑛D-OPP represented through the 𝑛D-EVM will be reminiscent to the reconstruction of the boundary tree associated with such 𝑛D-OPP. Moreover, our methodology is strongly sustained in the use of our proposed connected components labeling algorithm (Section 4) and the procedures described in Sections 2 and 3. Some study cases will be presented in order to appreciate the information our proposed procedure can share. Finally, in Section 6, we determine, in empirical way, the time complexity of the algorithm presented in Section 5 in order to provide evidence of its efficiency specifically when higher-dimensional 𝑛D-OPPs are considered.

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

In Section 2.1, some conventions and preliminary background related directly with orthogonal polytopes will be introduced. In Section 2.2, the foundations of the 𝑛D-EVM will be established. Section 2.3 presents some basic algorithms under the EVM.

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

The following definitions ((a) to (i)) belong to Spivak [18].(a)A singular 𝑛-dimensional hyperbox in ℝ^𝑛 is given by the continuous function 𝐼^𝑛∶[0,1]^𝑛→[0,1]^𝑛 such that 𝐼^𝑛(𝑥)=𝑥.(b)For all 𝑖, 1≤𝑖≤𝑛, if 𝑥∈[0,1]^𝑛−1, then the two singular (𝑛−1)D hyperboxes 𝐼^𝑛_(𝑖,0) and 𝐼^𝑛_(𝑖,1) are given by 𝐼^𝑛_()𝑖,0(𝑥)=𝐼^𝑛𝑥₁,…,𝑥_𝑖−1,0,𝑥_𝑖,…,𝑥_𝑛−1=𝑥₁,…,𝑥_𝑖−1,0,𝑥_𝑖,…,𝑥_𝑛−1,𝐼^𝑛_()𝑖,1(𝑥)=𝐼^𝑛𝑥₁,…,𝑥_𝑖−1,1,𝑥_𝑖,…,𝑥_𝑛−1=𝑥₁,…,𝑥_𝑖−1,1,𝑥_𝑖,…,𝑥_𝑛−1. (2.1)(c)A general singular 𝑘-dimensional hyperbox in the closed set 𝐴⊂ℝ^𝑛 is defined as the continuous function 𝑐∶[0,1]^𝑘→𝐴.(d)Given a general singular 𝑛D hyperbox 𝑐 the composition 𝑐_(𝑖,𝛼)=𝑐∘𝐼^𝑛_(𝑖,𝛼) defines an (𝑖,𝛼)-cell.(e)The orientation of an (𝑛−1)D cell 𝑐∘𝐼^𝑛_(𝑖,𝛼) is given by (−1)^𝛼+𝑖, while an (𝑛−1)D oriented cell is given by the scalar-function product (−1)^𝑖+𝛼⋅𝑐∘𝐼^𝑛_(𝑖,𝛼).(f)A formal linear combination of singular general 𝑘D hyperboxes, 1≤𝑘≤𝑛, for a closed set 𝐴 is called a 𝑘-chain. (g)Given a singular 𝑛D hyperbox 𝐼^𝑛, the (𝑛−1)-chain, called the boundary of 𝐼^𝑛, is defined as𝜕𝐼^𝑛=^𝑛_{𝑖=1𝛼=0,1}(−1)^𝑖+𝛼⋅𝐼^𝑛_()𝑖,𝛼. (2.2)(h)For a singular general 𝑛D hyperbox 𝑐, we define the (𝑛−1)-chain, called the boundary of 𝑐, by𝜕(𝑐)=^𝑛_{𝑖=1𝛼=0,1}(−1)^𝑖+𝛼⋅𝑐∘𝐼^𝑛_()𝑖,𝛼. (2.3)(i)The boundary of an 𝑛-chain ∑𝑐_𝑖, where each 𝑐_𝑖 is a singular general 𝑛D hyperbox, is given by𝜕𝑐_𝑖=𝜕𝑐_𝑖. (2.4)

Based on the above Spivak’s definitions, we have the elements to establish our own precise notion of orthogonal polytope. A collection 𝑐₁,𝑐₂,…,𝑐_𝑘,1≤𝑘≤2^𝑛, of general singular 𝑛D hyperboxes is a combination of 𝑛D hyperboxes if and only if^𝑘_𝛼=1𝑐_𝛼[0,1]^𝑛=0,…,0_𝑛∧∀𝑖,𝑗,𝑖≠𝑗,1≤𝑖,𝑗≤𝑘𝑐_𝑖[0,1]^𝑛≠𝑐_𝑗[0,1]^𝑛. (2.5)

The first part of the conjunction establishes that the intersection between all the 𝑛D general singular hyperboxes is the origin, while the second part establishes that there are not overlapping 𝑛D hyperboxes. Finally, we will say an 𝑛-dimensional orthogonal pseudopolytope 𝑝, or just an 𝑛D-OPP 𝑝, is an 𝑛-chain composed by 𝑛D hyperboxes arranged in such way that by selecting a vertex, in any of these hyperboxes, it describes a combination of 𝑛D hyperboxes composed up to 2^𝑛 hyperboxes.

2.2. 𝑛D-EVM’s Fundamentals

Let 𝑐 be a combination of hyperboxes in the 𝑛-dimensional space. An odd adjacency edge of 𝑐, or just an odd edge, will be an edge with an odd number of incident hyperboxes of 𝑐. Conversely, if an edge has an even number of incident hyperboxes of 𝑐, it will be called even adjacency edge or just an even edge. 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. By definition, every odd edge belongs to brinks, whereas every brink consists of 𝑚 edges, 𝑚≥1, and contains 𝑚+1 vertices. Two of these vertices are at either extreme of the brink and the remaining 𝑚−1 are interior vertices. The ending vertices of all the brinks in 𝑝 will be called extreme vertices of an 𝑛D-OPP 𝑝 and they are denoted as EV(𝑝). Finally, we have that any extreme vertex of an 𝑛D-OPP, 𝑛≥1, when is locally described by a set of surrounding 𝑛D hyperboxes, has exactly 𝑛 incident linearly independent odd edges.

Let 𝑝 be an 𝑛D-OPP. A 𝑘D extended hypervolume of 𝑝, 1<𝑘<𝑛, 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 𝜕(𝑝), that is, 𝑒₀∈𝜙𝑝⟺∃𝑐,𝑐belongsto𝜕𝑝𝑒₀[0,1]^𝑘⊆𝑐[0,1]^𝑛−1. (2.6)

Given an 𝑛D-OPP, we say the extreme vertices model of 𝑝, denoted by EVM_𝑛(𝑝), is defined as the model as only stores to all the extreme vertices of 𝑝. We have that 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_𝑛(𝑝), have a fixed coordinates ordering. Moreover, when an operation requires manipulating two EVMs, it is assumed both sets have the same coordinates ordering.

The projection operator for (𝑛−1)D cells, points, and sets of points is, respectively specified as follows.(i)Let 𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥))=(𝑥₁,…,𝑥_𝑛) be an (𝑛−1)D cell embedded in the 𝑛D space. 𝜋_𝑗(𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥))) will denote the projection of the cell 𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥)) onto an (𝑛−1)D space embedded in 𝑛D space whose supporting hyperplane is perpendicular to 𝑋_𝑗-axis; that is, 𝜋_𝑗(𝑐(𝐼^𝑛_(𝑖,𝛼)(𝑥)))=(𝑥₁,…,𝑥_𝑗,…,𝑥_𝑛).(ii)Let 𝑣=(𝑥₁,…,𝑥_𝑛) a point in ℝ^𝑛. The projection of that point in the (𝑛−1)D space, denoted by 𝜋_𝑗(𝑣), is given by 𝜋_𝑗(𝑣)=(𝑥₁,…,𝑥_𝑗,…,𝑥_𝑛). (iii)Let 𝑄 be a set of points in ℝ^𝑛. The projection of the points in 𝑄, denoted by 𝜋_𝑗(𝑄), is defined as the set of points in ℝ^𝑛−1 such that 𝜋_𝑗(𝑄)={𝑝∈ℝ^𝑛−1∶𝑝=𝜋_𝑗(𝑥),𝑥∈𝑄⊂ℝ^𝑛}.

In all the three above cases, 𝑥_𝑗 is the coordinate corresponding to 𝑋_𝑗-axis to be suppressed.

For an 𝑛D-OPP 𝑝, we will say that 𝑛𝑝_𝑖 denotes the number of distinct coordinates present in the vertices of 𝑝 along 𝑋_𝑖-axis, 1≤𝑖≤𝑛. Let Φ^𝑖_𝑘(𝑝) be the 𝑘th (𝑛−1)D extended hypervolume, or just a (𝑛−1)D Couplet, of 𝑝 which is perpendicular to 𝑋_𝑖-axis, 1≤𝑘≤𝑛𝑝_𝑖.

A slice is the region contained in an 𝑛D-OPP 𝑝 between two consecutive couplets of 𝑝. Slice^𝑖_𝑘(𝑝) will denote to the 𝑘th slice of 𝑝, which is bounded by Φ^𝑖_𝑘(𝑝) and Φ^𝑖_𝑘+1(𝑝), 1≤𝑘<𝑛𝑝_𝑖. A section is the (𝑛−1)D-OPP, 𝑛>1, resulting from the intersection between an 𝑛D-OPP 𝑝 and a (𝑛−1)D hyperplane perpendicular to the coordinate axis 𝑋_𝑖, 𝑛≥𝑖≥1, which dose not coincide with any (𝑛−1)D-couplet of 𝑝. 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≤𝑘<𝑛𝑝_𝑖. Moreover, 𝑆^𝑖₀(𝑝) and 𝑆^𝑖_𝑛𝑝𝑖(𝑝) will refer to the empty sections of 𝑝 before Φ^𝑖₁(𝑝) and after Φ^𝑖_𝑛𝑝𝑖(𝑝), respectively.

The projection of the set of (𝑛−1)D couplets, 𝜋_𝑖(Φ^𝑖_𝑘(𝑃)), 1≤𝑖≤𝑛, 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(𝑝))⊗^∗𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)),forall𝑘∈[1,𝑛𝑝_𝑖]. On the other hand, 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 𝜋_𝑖(Φ^𝑖_𝑘(𝑝)). Or, equivalently, by computing the regularized XOR of the projections of all the previous couplets; that is, 𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))=⊗^∗𝑘_𝑗=1𝜋_𝑖(Φ^𝑖_𝑗(𝑝)).

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

Let 𝑝 and 𝑞 be two 𝑛D-OPPs having their respective representations EVM_𝑛(𝑝) and EVM_𝑛(𝑞), then EVM_𝑛(𝑝⊗^∗𝑞)=EVM_𝑛(𝑝)⊗EVM_𝑛(𝑞). This result, combined with the procedures presented in the previous section for computing sections from couplets and vice versa, allows expressing a formula for computing them by means of their corresponding extreme vertices models. That is,(i)EVM_𝑛−1(𝜋_𝑖(Φ^𝑖_𝑘(𝑝)))=EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)))⊗EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))), (ii)EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)))=EVM_𝑛−1(𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)))⊗EVM_𝑛−1(𝜋_𝑖(Φ^𝑖_𝑘(𝑝))).

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

Let 𝑝 and 𝑞 be two 𝑛D-OPPs and 𝑟=𝑝𝑜𝑝^∗𝑞, where 𝑜𝑝^∗ is in {∪^∗,∩^∗,−^∗,⊗^∗}. Then, 𝜋_𝑖(𝑆^𝑖_𝑘(𝑟))=𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))𝑜𝑝^∗𝜋_𝑖(𝑆^𝑖_𝑘(𝑞)). This implies a regularized Boolean operation, 𝑜𝑝^∗, where 𝑜𝑝^∗∈{∪^∗,∩^∗,−^∗,⊗^∗}, over two 𝑛D-OPPs 𝑝 and 𝑞, both expressed in the 𝑛D-EVM, can be carried out by means of the same 𝑜𝑝^∗ applied over their own sections, expressed through their extreme vertices models, which are (𝑛−1)D-OPPs. This last property leads to a recursive process, for computing the regularized Boolean operations using the 𝑛D-EVM, which descends on the number of dimensions. The base or trivial case of the recursion is given by the 1D-Boolean operations which can be achieved using direct methods. The XOR operation can also be performed according to the result described in the above subsection.

2.3. Basic Algorithms for the 𝑛D-EVM

Before going any further, we say 𝑋_𝐴-axis is the 𝑛D space’s coordinate axis associated to the first coordinate present in the vertices of EVM_𝑛(𝑝). For example, given coordinates ordering 𝑋₁𝑋₂𝑋₃, for a 3D-OPP, then 𝑋_𝐴=𝑋₁.

The following primitive operations are, in fact, based in those originally presented in [1] see Algorithm 1.

Output: An empty 𝑛D-EVM. Procedure InitEVM( ) { Returns the empty set.                          } Input: An (𝑛−1)D-EVM hvl embedded in 𝑛D space. Input/Output: An 𝑛D-EVM 𝑝 Procedure PutHvl(EVM hvl, EVM 𝑝) { Appends an (𝑛−1)D couplet hvl, perpendicular to 𝑋𝐴-axis, to 𝑝.                 } Input:  An 𝑛D-EVM 𝑝 Output:  An (𝑛−1)D-EVM embedded in (𝑛−1)D space. Procedure ReadHvl(EVM 𝑝) { Extracts next (𝑛−1)D couplet perpendicular to 𝑋𝐴-axis from 𝑝.                  } Input: An 𝑛D-EVM 𝑝 Output: A Boolean. Procedure EndEVM(EVM 𝑝) { Returns true if the end of 𝑝 along 𝑋𝐴-axis has been reached.                 } Input/Output: An (𝑛−1)D-EVM 𝑝 embedded in (𝑛−1)D space. Input: A coordinate coord of type CoordType     (CoordType is the chosen type for the vertex coordinates) Procedure SetCoord(EVM 𝑝, CoordType coord) {  Sets the 𝑋𝐴-coordinate to coord on every vertex of the (𝑛−1)D couplet 𝑝. For coord = 0, it performs the projection 𝜋A(𝑝).                      } Input: An (𝑛−1)D-EVM 𝑝 embedded in 𝑛D space. Output: A CoordType Procedure GetCoord(EVM 𝑝) { Gets the common 𝑋𝐴 coordinate of the (𝑛−1)D couplet 𝑝.                 } Input: An 𝑛D-EVM 𝑝. Output: A CoordType Procedure GetCoordNextHvl(EVM 𝑝) { Gets the common 𝑋𝐴 coordinate of the next available (𝑛−1)D couplet of 𝑝.             } Input: Two 𝑛D-EVMs 𝑝 and 𝑞. Output: An 𝑛D-EVM Procedure MergeXor(EVM 𝑝, EVM 𝑞) { Applies the ordinary Exclusive OR operation to the vertices of 𝑝 and 𝑞 and returns the resulting set.                      } Input: An (𝑛−1)D-EVM corresponding to section 𝑆.    An (𝑛−1)D-EVM corresponding to couplet hvl.   Output: An (𝑛−1)D-EVM. Procedure GetSection(EVM S, EVM hvl) { return MergeXor(S, hlv)                           } Input: An (𝑛−1)D-EVM corresponding to section 𝑆𝑖. An (𝑛−1)D-EVM corresponding to section 𝑆𝑗. Output: An (𝑛−1)D-EVM. Procedure GetHvl(EVM 𝑆𝑖, EVM 𝑆𝑗) { return MergeXor (𝑆𝑖,𝑆𝑗)} Input: Two 𝑛D-EVMs 𝑝 and 𝑞.   The Boolean Operation op to apply over 𝑝 and 𝑞.   The number 𝑛 of dimensions. Output: An 𝑛D-EVM. Procedure BooleanOperation(EVM 𝑝, EVM 𝑞, BooleanOperator op, int 𝑛) { Returns as output an 𝑛D-OPP 𝑟, codified as an 𝑛D-EVM, such that 𝑟=𝑝op∗𝑞.                           }

Algorithm 1 

Basic procedures under the EVM.

As can be observed, algorithms MergeXor, GetSection, and GetHvl are clearly sustained in the results presented in Section 2.2. The algorithm GetSection, via MergeXor algorithm, returns the projection of the next section of an 𝑛D-OPP between its previous section and couplet [1, 3]. On the other hand, the algorithm GetHvl returns the projection of the couplet between consecutive input sections 𝑆_𝑖 and 𝑆_𝑗 [1, 3].

The algorithm BooleanOperation computes the resulting 𝑛D-OPP 𝑟=𝑝𝑜𝑝^∗𝑞, where 𝑜𝑝^∗ is in {∪^∗,∩^∗,−^∗,⊗^∗} (note that 𝑟=𝑝⊗^∗𝑞 can also be trivially performed using MergeXor function). The basic idea behind the procedure is the following.(i)The sequence of sections from 𝑝 and 𝑞, perpendicular to 𝑋_𝐴-axis, are obtained first. (ii)Then, every section of 𝑟 can recursively be computed as𝜋_𝑖𝑆^𝑖_𝑘(𝑟)=𝜋_𝑖𝑆^𝑖_𝑘𝑝𝑜𝑝^∗𝜋_𝑖𝑆^𝑖_𝑘𝑞. (2.7)(iii)Finally, 𝑟’s couplets can be obtained from its sequence of sections, perpendicular to 𝑋_𝐴-axis.

In fact, BooleanOperation can be implemented in a wholly merged form in which it only needs to store one section for each of the operands 𝑝 and 𝑞 (sP and sQ, resp.), and two consecutive sections for the result 𝑟 (sRprev and sRcurr) [1]. The idea is to consider a main loop that gets sections from 𝑝 and/or 𝑞, using function GetSection. These sections, sP and sQ, are recursively processed to compute the corresponding section of 𝑟, sRcurr. Since 𝑟’s two consecutive sections, sRprev and sRcurr, are kept, then the projection of the resulting couplet, is obtained by means of function GetHvl, and then, it is correctly positioned in 𝑟’s EVM by procedure SetCoord [1]. When the end of one of the polytopes 𝑝 or 𝑞 is reached, then the main loop finishes, and the remaining couplets of the other polytope are either appended or not to the resulting polytope 𝑟 depending on the Boolean operation considered. More specific details about this implementation of BooleanOperation algorithm can be found in [1] or [3].

3. Forward and Backward Differences of an 𝑛D-OPP

Because it is well known that regularized XOR operation over two sets 𝐴 and 𝐵 can be expressed as 𝐴⊗^∗𝐵=(𝐴−^∗𝐵)∪^∗(𝐵−^∗𝐴), then we have that given an 𝑛D-OPP 𝑝, and specifically one of its couplets𝜋_𝑖Φ^𝑖_𝑘𝑝=𝜋_𝑖𝑆^𝑖_𝑘−1𝑝⊗^∗𝜋_𝑖𝑆^𝑖_𝑘𝑝=𝜋_𝑖𝑆^𝑖_𝑘−1𝑝−^∗𝜋_𝑖𝑆^𝑖_𝑘𝑝∪^∗𝜋_𝑖𝑆^𝑖_𝑘𝑝−^∗𝜋_𝑖𝑆^𝑖_𝑘−1𝑝, (3.1) the expressions 𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝))−^∗𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)) and 𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))−^∗𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)) will be called forward and backward differences of the projection of two consecutive sections 𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)) and 𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)), and they will be denoted by FD^𝑖_𝑘(𝑝) and BD^𝑖_𝑘(𝑝), where 𝑋_𝑖-axis is perpendicular to them.

One interesting characteristic, described in [1], of forward and backward differences of a 3D-OPP, is that forward differences are the sets of faces, on a couplet, whose normal vectors point to the positive side of the coordinate axis perpendicular to such couplet. Similarly, backward differences are the sets of faces, on a couplet, whose normal vectors point to the negative side of the coordinate axis perpendicular to such couplet. By this way, it is provided a procedure for obtaining the correct orientation of faces in a 3D-OPP when it is converted from 3D-EVM to a boundary representation.

In the context of an 𝑛D-OPP 𝑝, there are methods to identify normal vectors in the (𝑛−1)D cells included in 𝑝’s boundary. For example, simplicial combinatorial topology provides methodologies assuming a polytope is represented under a simplexation. Such methods operate under the fact the 𝑛+1 vertices of an 𝑛D simplex are labeled and sorted. Such sorting corresponds to an odd or an even permutation. By taking 𝑛 vertices from the 𝑛+1 vertices of the 𝑛D simplex, we get the vertices corresponding to one of its (𝑛−1)D-cells. In this point, usually, a set of entirely arbitrary rules are given to determine the normal vector to such (𝑛−1)D cells; see for example, [19, 20]. Such rules establish, according to the parity of the permutation, if the assigned normal vector points towards the interior of the polytope or outside of it.

On the other hand, there are works that consider the determination of normal vectors by taking into account properties of the cross product and the vectors that compose the basis of 𝑛D space. For example, Kolcun [21] provides one of such methodologies; however, it is also dependent of polytopes are represented through a simplexation. In this last sense, forward and backward differences will provide us a powerful tool, because, in fact, given an 𝑛D-OPP 𝑝, forward differences FD^𝑖_𝑘(𝑝) are the sets of (𝑛−1)D cells lying on Φ^𝑖_𝑘(𝑝), whose normal vectors point to the positive side of the coordinate axis 𝑋_𝑖, while backward differences BD^𝑖_𝑘(𝑝) are the sets of (𝑛−1)D cells also lying on Φ^𝑖_𝑘(𝑝) but whose normal vectors point to the negative side of the coordinate 𝑋_𝑖-axis.

Figure 2 shows a 3D-OPP and its corresponding sets of 2D-couplets perpendicular to 𝑋₁, 𝑋₂, and 𝑋₃-axes (Figures 2(b), 2(c), 2(d)). According to Figure 2(a), the OPP has 5 non-extreme vertices which are marked in white. Three of them have four coplanar incident odd edges; another one has six incident odd edges, and the last one has exactly two incident collinear odd edges. The remaining vertices, actually the extreme vertices, have exactly three linearly independent odd edges. Table 1 shows the extraction, for the 3D-OPP shown in Figure 2(a), of its faces and their correct orientation through forward and backward differences. The first row shows sections perpendicular to 𝑋₁-axis. Through them, we compute forward differences FD¹₁(𝑝) to FD¹₃(𝑝) in order to obtain the faces whose normal vector points towards the positive side of 𝑋₁-axis. On the other hand, these same sections share us to compute backward differences BD¹₁(𝑝) to BD¹₃(𝑝), which are composed by the set of faces whose normal vector points towards the negative side of 𝑋₁-axis. In a similar way, the remaining two rows of Table 1 show sections perpendicular to 𝑋₂ and 𝑋₃-axes and their respective forward and backward differences.

Table 1 

Forward and backward differences of a 3D-OPP (see text for details).

(a)

(b)

(c)

(d)

Figure 2 

(a) A 3D-OPP with its extreme (black) and nonextreme vertices (white). (b) Couplets perpendicular to 𝑋1-axis. (c) Couplets perpendicular to 𝑋2-axis. (d) Couplets perpendicular to 𝑋3-axis.

An algorithm for computing forward and backward differences consists of obtaining projections of sections of the input polytope and processing them through BooleanOperation algorithm by computing regularized difference between two consecutive sections. Algorithm 2 implements these simple ideas in order to compute the forward and backward differences in an 𝑛D-OPP 𝑝 represented through the 𝑛D-EVM. Its output will consist of two sets: the first set FD contains the (𝑛−1)D-EVMs corresponding to forward differences in 𝑝, while the second set BD contains the (𝑛−1)D-EVMs corresponding to backward differences in 𝑝. Algorithm 2 will be useful when we describe our procedure for extracting 𝑘D boundary elements of an 𝑛D-OPP which is represented through the 𝑛D-EVM. Such procedure will be described in Section 5.

Input: An 𝑛D-EVM 𝑝.     The number 𝑛 of dimensions. Output : A set FD containing the (𝑛−1)D-EVMs of Forward Differences in 𝑝.      A set BD containing the (𝑛−1)D-EVMs of Backward Differences in 𝑝. Procedure GetForwardBackwardDifferences(EVM 𝑝, int 𝑛)     FD=∅  // FD will store (𝑛−1)D-EVMs corresponding to Forward Differences.     BD=∅  // BD will store (𝑛−1)D-EVMs corresponding to Backward Differences.    EVM hvl  // Current couplet.    EVM 𝑆𝑖,𝑆𝑗  // Previous and next sections about hvl.    EVM FDcurr  // Current Forward Difference.    EVM BDcurr  // Current Backward Difference.    hvl = InitEVM( )     𝑆𝑖 = InitEVM( )     𝑆𝑗 = InitEVM( )     while(Not(EndEVM(𝑝)))      hvl = ReadHvl(𝑝)// Read next couplet.      𝑆𝑗 = GetSection(𝑆𝑖, hvl)      FDcurr = BooleanOperation(𝑆𝑖,𝑆𝑗, Difference, 𝑛−1)      BDcurr = BooleanOperation(𝑆𝑗,𝑆𝑖, Difference, 𝑛−1)      FD = FD ∪ {FDcurr}// The new computed Forward Difference is added to FD.      BD = BD ∪ {BDcurr}// The new computed Backward Difference is added to BD.      𝑆𝑖=𝑆𝑗     end-of-while     return {FD, BD} end-of-procedure

Algorithm 2 

Computing forward and backward differences in a polytope 𝑝 represented through an 𝑛D-EVM.

4. A Connected Components Labeling Algorithm under the 𝑛D-EVM

Now, as one of the main contributions of this work, we will describe our proposed algorithm for performing connected components labeling in an 𝑛D-OPP 𝑝 expressed under the 𝑛D-EVM. We think our algorithm can be positioned in Suzuki’s second category (see Section 1), because it assigns temporal labels for elements embedded in the current processed slice of 𝑝, Slice^𝑖_𝑘(𝑝), but when the next slice is processed, Slice^𝑖_𝑘+1(𝑝), it is possible some of these labels change taking place a second pass over Slice^𝑖_𝑘(𝑝) which assigns new labels. Two properties of interest of our algorithm are pointed out.(i)It processes only two consecutive slices of 𝑝 at a time. In fact, such slices are not explicitly manipulated but their corresponding representative (𝑛−1)D sections.(ii)The algorithm descends recursively over the number of dimensions in such way that it is determined for each (𝑛−1)D section of 𝑝 its corresponding (𝑛−2)D components. By this way, the (𝑛−2)D components of two consecutive (𝑛−1)D sections are manipulated and used for determining the labels to assign.

The idea behind the proposed methodology considers to process sequentially each (𝑛−1)D section of 𝑝. Let 𝑆_𝑗 be the current processed section of 𝑝. We obtain, via a recursive call, its (𝑛−1)D components. Let 𝑆_𝑖 be the section before 𝑆_𝑗. For each (𝑛−1)D component 𝑐𝑆_𝑗 in 𝑆_𝑗 and for each (𝑛−1)D component 𝑐𝑆_𝑖 in 𝑆_𝑖, it is performed their regularized intersection 𝑐𝑆_𝑗∩^∗𝑐𝑆_𝑖. According to the result, one of three cases can arise.

Case 1. (i) If the intersection is not empty and 𝑐𝑆_𝑗 does not belong to any component of 𝑝, then 𝑐𝑆_𝑗 is added to the component of 𝑝, where the current component of 𝑆_𝑖, 𝑐𝑆_𝑖, belongs.

Case 2. (i) If the intersection is not empty but 𝑐𝑆_𝑗 is already associated to a component of 𝑝, then such component and the component where 𝑐𝑆_𝑖 is contained are united to form only one new component for 𝑝. It could be the case that both components to unite are, in fact, the same. In this situation, no action is performed. On the other hand, if the union is achieved, then all the references pointing to the original 𝑛D components where 𝑐𝑆_𝑖 and 𝑐𝑆_𝑗 belonged must be updated in order to point to the new component.

Case 3. (i) If the intersection with all components of 𝑆_𝑖 is empty, then 𝑐𝑆_𝑗 does not belong to any of the currently identified components of 𝑝. Therefore, 𝑐𝑆_𝑗 belongs to, and starts, a new 𝑛D component.

Tables 2 and 3 show an example where the above ideas are applied on a 2D-OPP. Such OPP is composed of 22 extreme vertices and has five internal sections which are perpendicular to 𝑋₁-axis. Once all sections are processed, it is determined the existence of two components.

Table 2 

Connected component labeling over a 2D-OPP (Part 1).

Table 3 

Connected component labeling over a 2D-OPP (Part 2).

A more specific implementation of our procedure is given in Algorithm 3. In order to distinguish between Cases 1 and 2, the algorithm uses a Boolean flag (withoutComponent). When Case 1 is achieved, then 𝑐𝑆_𝑗, the current component of section 𝑆_𝑗, is already associated to a component of 𝑝. Therefore, the flag’s value is inverted for indicating this last property and, for instance, sharing that only Case 2 could be reached in the subsequent iterations. If for all components of 𝑆_𝑖, the section before 𝑆_𝑗, the intersection with 𝑐𝑆_𝑗 was empty, then the flag never changed its original value. In this way, Case 3 can be identified.

Input: An 𝑛D-OPP 𝑝.     The number 𝑛 of dimensions. Output: A list containing the EVMs which describe the 𝑛D components of 𝑝. Procedure ConnectedComponentsLabeling(EVM 𝑝, int 𝑛)     if(𝑛=1) then      return ConnectedComponentsLabeling1D(𝑝) // Base case.     else      EVM hvl     // Current (𝑛−1)𝐷 couplet of p.      EVM 𝑆𝑖, 𝑆𝑗     // Previous and next (𝑛−1)𝐷 sections about hvl.      𝑆𝑖 = InitEVM( )      List components 𝑆𝑖 // The (𝑛−1)𝐷 components of section 𝑆𝑖.      List indexes 𝑆𝑖   // A list of indexes.      List components 𝑆𝑗  // The (𝑛−1)𝐷 components of section 𝑆𝑗.      List indexes 𝑆𝑗  // A list of indexes.      List componentsP // The 𝑛D components of input polytope p.      CoordType currCoord = getCoordNextHvl(𝑝)      hvl = ReadHvl(𝑝)      CoordType nextCoord = getCoordNextHvl(𝑝)      while(Not(EndEVM(𝑝)))        𝑆𝑗 = GetSection(𝑆𝑖, hvl)        components 𝑆𝑗 = ConnectedComponentsLabeling (𝑆𝑗,𝑛−1) // Recursive call.        for(int 𝑗=0, j < Size(components 𝑆𝑗), 𝑗=𝑗+1)          EVM 𝑐𝑆𝑗 = components 𝑆𝑗(𝑗)          boolean withoutComponent = true          for(int 𝑖=0, i < Size(components 𝑆𝑖), 𝑖=𝑖+1)            EVM 𝑐𝑆𝑖 = components 𝑆𝑖(𝑖)            EVM c = BooleanOperation(𝑐𝑆𝑗,𝑐𝑆𝑖, Intersection, 𝑛−1)            if(Not(IsEmpty(c)) and (withoutComponent = true)) then              // CASE 1              withoutComponent = false              List componentToUpdate = componentsP(indexes 𝑆𝑖(𝑖))              Append(componentToUpdate, {𝑐𝑆𝑗, currCood, nextCoord})              Append(indexes 𝑆𝑗, indexes 𝑆𝑖(𝑖))            else if(Not(IsEmpty(c)) and (withoutComponent = false)) then              // CASE 2              if(indexes 𝑆𝑖(𝑖)≠ indexes 𝑆𝑗(𝑗)) then                List component1 = componentsP(indexes 𝑆𝑖(𝑖))                List component2 = componentsP(indexes 𝑆𝑗(𝑗))                for(int 𝑘=0, k < Size(component1), 𝑘=𝑘+1)                  Append(component2, component1(𝑘))                end-of-for                Update(componentsP, indexes 𝑆𝑖(𝑖), NULL)                for(int 𝑘=0, k < Size(indexes 𝑆𝑖), 𝑘=𝑘+1)                  if(indexes 𝑆𝑖(𝑘) = indexes 𝑆𝑖(𝑖)) then                    Update(indexes 𝑆𝑖, k, indexes 𝑆𝑗(𝑗))                  end-of-if                end-of-for                for(int 𝑘=0, k < Size(indexes 𝑆𝑗), 𝑘=𝑘+1)                  if(indexes 𝑆𝑗(𝑘) = indexes 𝑆𝑖(𝑖)) then                    Update(indexes 𝑆𝑗, k, indexes 𝑆𝑗(𝑗))                  end-of-if                end-of-for                Update(indexes 𝑆𝑖, i, indexes 𝑆𝑗(𝑗))              end-of-if            end-of-if           end-of-for           if(withoutComponent = true) then             // CASE 3             List newComponent             Append(newComponent, {𝑐𝑆𝑗, currCoord, nextCoord})             Append(componentsP, newComponent)             Append(indexes 𝑆𝑗, Size(componentsP) - 1)           end-of-if          end-of-for          𝑆𝑖=𝑆𝑗          components 𝑆𝑖 = components 𝑆𝑗          indexes 𝑆𝑖 = indexes 𝑆𝑗          currCoord = GetCoordNextHvl(𝑝)          hvl = ReadHvl(𝑝) // Read next couplet. nextCoord = GetCoordNextHvl(𝑝) end-of-while // End of sections’ processing. int 𝑖=0 while(i < Size(componentsP))   if(componentsP(i) = NULL) then     Remove(componentsP, i)     𝑖=𝑖−1   else     List currentListOfSections = componentsP(i)     EVM evmComponent = getEVMforListOfSections(currentListOfSections, 𝑛)     Update(componentsP, 𝑖, evmComponent)   end-of-if   𝑖=𝑖+1   end-of-while   return componentsP  end-of-if end-of-procedure

Algorithm 3 

Connected component labeling over an 𝑛D-OPP expressed in the 𝑛D-EVM.

Our implementation considers the use of lists for controlling and manipulating references between (𝑛−1)D sections’ components and their associated 𝑛D components. We assume that such lists are manipulated and accessed through the following primitive functions.(i)Size (list): returns the number of elements in the list.(ii)List (i): returns the element at position i of the list, 0≤𝑖<𝑆𝑖𝑧𝑒(𝑙𝑖𝑠𝑡). (iii)Update (list, i, nV): the list is updated by substituting element in position i with the new element nV. (iv)Append (list, v): an element v is appended at the end of the list.(v)Insert (list, i, v): an element v is inserted at position i of the list. (vi)Remove (list, i): it is removed from the list the element at position i.(vii)IndexOf (list, v): returns a negative integer if v is not present in the list. Otherwise, an index between 0 and Size (list)-1 is returned indicating the first occurrence of v.(viii)DeleteAll (list): deletes all the elements contained in the list.

Algorithm 3 considers the use of five lists. (i)componentsSj (componentsSi): the (𝑛−1)D components of section 𝑆_𝑗(𝑆_𝑖). The (𝑛−1)D-EVM associated to the 𝑗th (𝑖th) component of section 𝑆_𝑗(𝑆_𝑖) is obtained via componentsSj( 𝑗) (componentsSi( 𝑖)).(ii)indexesSj (indexesSi): a list of indexes. 𝑘₁=𝑖𝑛𝑑𝑒𝑥𝑒𝑠𝑆𝑗(𝑗) (𝑘₂=𝑖𝑛𝑑𝑒𝑥𝑒𝑠𝑆𝑖(𝑖)) denotes the 𝑗th (𝑖th) component of section 𝑆_𝑗(𝑆_𝑖) belongs to the 𝑘₁th (𝑘₂th) component of 𝑛D-OPP 𝑝.(iii)componentsP: the components of input 𝑛D-OPP 𝑝. components( 𝑘) returns a list of (𝑛−1)D sections which describe the 𝑘th 𝑛D component of 𝑝.

Let 𝑐𝑆_𝑖 be the 𝑖th component of section 𝑆_𝑖 and 𝑐𝑆_𝑗 be the 𝑗th component of section 𝑆_𝑗. Both 𝑐𝑆_𝑖 and 𝑐𝑆_𝑗 were, respectively, obtained from componentsSi( 𝑖) and componentsSj( 𝑗). The lists are used and manipulated according the considered algorithm’s case.(i)In Case 1, componentsP(indexesSi( 𝑖)) returns the component of 𝑝, where 𝑐𝑆_𝑖 belongs. 𝑐𝑆_𝑗 is incorporated to such component by appending it in such list. Finally, via Append(indexesSj, indexesSi( 𝑖)), it is now established that 𝑐𝑆_𝑗 belongs to the same component than 𝑐𝑆_𝑖, because they have the same component’s index.(ii)In Case 2, we obtain the components, where 𝑐𝑆_𝑖 and 𝑐𝑆_𝑗 belong through componentsP(indexesSi(i)) and componentsP(indexesSj(j)) (if indexesSi(i) and indexesSj(j) are equal, then, as commented previously, no action is performed). All the elements in the first component are transferred to the second component. The position where the first component resided in the list componentsP is now updated to NULL. Via, Update(indexesSi, i, indexesSj(j)), it is established that 𝑐𝑆_𝑖 belongs to the same component like 𝑐𝑆_𝑗. Finally, it must be verified if there are (𝑛−1)D components of 𝑆_𝑖 and 𝑆_𝑗 whose value in indexesSi and indexesSj refers to the now nullified position in componentsP. If it is the situation, then their indexes must be updated with the value in indexesSj(j). (iii)In Case 3, a new component for 𝑛D-OPP 𝑝 is created. The new list, containing only to 𝑐𝑆_𝑗, is appended in list componentsP. The value given by the size of list componentsP minus one is appended in list indexesSj. Such value corresponds to the component’s index for 𝑐𝑆_𝑗.

When the algorithm finishes the processing of sections, each list in componentsP is a list of (𝑛−1)D sections or a NULL element. If a NULL element is found, then it must be removed. Otherwise, we obtain the corresponding 𝑛D-EVM, which at its time corresponds to a component of the input 𝑛D-OPP 𝑝. It is possible the (𝑛−1)D sections contained in a given list are not correctly ordered. With the purpose of determining the correct sequence, in Algorithm 3, when a (𝑛−1)D-OPP is appended, the common 𝑋_𝐴 coordinates of the previous and next couplets are also introduced with it.

Consider a 5D-OPP 𝑞 generated by the union of the following six 5D hypercubes:(i)𝐶₁=[0,1]×[0,1]×[0,1]×[0,1]×[0,1], (ii)𝐶₂=[0,1]×[1,2]×[0,1]×[0,1]×[0,1], (iii)𝐶₃=[0,1]×[2,3]×[0,1]×[0,1]×[0,1], (iv)𝐶₄=[1,2]×[2,3]×[0,1]×[0,1]×[0,1], (v)𝐶₅=[2,3]×[2,3]×[1,2]×[1,2]×[1,2], (vi)𝐶₆=[3,4]×[2,3]×[0,1]×[1,2]×[1,2].

Figure 3(a) shows 𝑞’s 5D-4D-3D-2D projection. Hypercubes 𝐶₅ and 𝐶₆ have a common (3D) volume; hypercube 𝐶₅ shares an edge with hypercube 𝐶₄, and hypercubes 𝐶₁ to 𝐶₄ compose a J-shaped form. Its representation via the 5D-EVM required 92 extreme vertices. Figures 3(b) and 3(c) show its 4D couplets and sections, perpendicular to 𝑋₁-axis, respectively. Each 4D section of 𝑞 is composed of only one component (this is determined via a recursive call of Algorithm 3). Remember that 𝑆¹₀(𝑞)=∅, hence, its intersection with section 𝑆¹₁(𝑞) is also empty and, therefore, 𝑆¹₁(𝑞) is associated to 5D component 0. Next, the regularized intersections between projections of sections 𝑆¹₁(𝑞) and 𝑆¹₂(𝑞) is also empty. This implies that 𝑆¹₂(𝑞) is associated with 5D component 1. The same result is obtained when computing regularized intersection between projections of sections 𝑆¹₂(𝑞) and 𝑆¹₃(𝑞). Component 2 has to 𝑆¹₃(𝑞). Finally, the intersection between 𝑆¹₃(𝑞) and 𝑆¹₄(𝑞) corresponds to a 4D hyperbox, which implies that 𝑆¹₄(𝑞) is also associated to component 2. As a final result, Algorithm 3 identified three 5D components in 𝑞.(i)Component 0 corresponds to hypercube 𝐶₆ (Figure 4(a)).(ii)Component 1 corresponds to hypercube 𝐶₅ (Figure 4(b)).(iii)Component 2 corresponds to the union of hypercubes 𝐶₁ to 𝐶₄ (Figure 4(c)).

(a)

(b)

(c)

Figure 3 

A 5D-OPP. (a) 5D-4D-3D-2D projection. (b) 4D Couplets perpendicular to 𝑋1-axis. (c) 4D Sections perpendicular to 𝑋1-axis.

(a) 5D Component 0

(b) 5D Component 1

(c) 5D Component 2

Figure 4 

The three components identified by applying Algorithm 3 over the 5D-OPP from Figure 3(a).

Previously, we mentioned hypercubes 𝐶₅ and 𝐶₆ shared a 3D volume. When computing regularized intersection between 𝑆¹₁(𝑞) and 𝑆¹₂(𝑞) (their corresponding sections in 𝑞) the result was the empty set. This is due to the use of regularized boolean operations: operations between 𝑛D polytopes must be dimensionally homogeneous; that is, they must produce as result another 𝑛D polytope or the null object [22]. Hypercubes 𝐶₅ and 𝐶₄ shared a (1D) edge, but the regularized intersection between their corresponding sections, in 𝑞, 𝑆¹₂(𝑞) and 𝑆¹₃(𝑞), also produced a null object. A distinct situation arises when the regularized intersection between 𝑆¹₃(𝑞) and 𝑆¹₄(𝑞) is analyzed: Algorithm 3 determined that they are associated with the same component.

The above example has illustrated a property of Algorithm 3. When the foundations behind our method were established, it was commented the algorithm process, not in an explicit way, consecutive slices of the input polytope 𝑝. Each 𝑛D slice of 𝑝 has its corresponding representative (𝑛−1)𝐷 section for which Algorithm 3 determines its corresponding (𝑛−1)D components. Let 𝑐₁ and 𝑐₂ be nonempty (𝑛−1)D components such that 𝑐₁ is associated to (𝑛−1)D section 𝑆^𝑖_𝑗(𝑝), while 𝑐₂ is associated to (𝑛−1)D section 𝑆^𝑖_𝑗+1(𝑝). The fact that 𝑐₁ and 𝑐₂ have empty regularized intersection implies (1) that their corresponding 𝑛D regions are disjoint and, therefore, they have null adjacencies, or (2) that some parts of its corresponding slices have a 𝑘D adjacency; that is, some 𝑘D elements, 𝑘=0,1,2,…,𝑛−2, are, completely or partially, shared. In both cases, Algorithm 3 uses this kind of adjacencies, via the result of regularized intersection between 𝑐₁ and 𝑐₂, for determining that the corresponding 𝑛D regions are disjoint and, for instance, associate them with different components. Hence, a 𝑛D component shared by Algorithm 3 corresponds to those parts of the input 𝑛D-OPP that are united via (𝑛−1)D adjacencies. The way Algorithm 3 breaks a polytope will be very useful in the following sections, specifically when we present our methodology for identifying 𝑘D boundary elements.

5. Extracting 𝑘D Boundary Elements from an 𝑛D-OPP

This section presents the second main contribution of this work. As commented in Section 1, the way we extract 𝑘D boundary elements from an 𝑛D-OPP represented through the 𝑛D-EVM will be reminiscent to the reconstruction of the boundary tree associated to such 𝑛D-OPP. According to Section 3, forward and backward differences can be computed through Algorithm 2. In fact, all FD^𝑖_𝑘(𝑝) and BD^𝑖_𝑘(𝑝) from an 𝑛D-OPP are (𝑛−1)D-OPPs embedded in (𝑛−1)D space, because the projection operator is used in their corresponding definitions: FD^𝑖_𝑘(𝑝)=𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝))−^∗𝜋_𝑖(𝑆^𝑖_𝑘(𝑝)) and BD^𝑖_𝑘(𝑝)=𝜋_𝑖(𝑆^𝑖_𝑘(𝑝))−^∗𝜋_𝑖(𝑆^𝑖_𝑘−1(𝑝)). If such forward and backward differences were computed through our proposed algorithm, then they are expressed as EVM_𝑛−1(FD^𝑖_𝑘(𝑝)) and EVM_𝑛−1(BD^𝑖_𝑘(𝑝)). If we apply again Algorithm 2 to such (𝑛−1)D-OPPs, we will get new forward and backward differences that correspond to the (𝑛−2)D oriented cells on the boundary of such (𝑛−1)D-OPPs. These new forward and backward differences are themselves (𝑛−2)D-OPPs represented through the EVM. Hence, by applying again Algorithm 2 to them, we obtain their associated (𝑛−3)D oriented cells grouped as forward and backward differences. This procedure generates a recursive process which descends in the number of dimensions. In each recursivity level, we obtain forward and backward differences associated to the input 𝑘D-OPPs, 1≤𝑘≤𝑛. The base case is reached when 𝑛=1. In this situation, the boundary of a 1D-OPP is described by the beginning and ending extreme vertices of each one of its composing segments.

Algorithm 4 implements the above-proposed ideas in order to identify and to extract 𝑘D boundary elements from a 𝑛D-OPP. Input parameters for our algorithm require the EVM associated with the input 𝑛D-OPP 𝑝, the number 𝑘 of dimensions, and a list, where the boundary elements of 𝑝 are going to be stored. Such a list, called boundaryElements, is assumed to be a list of lists such that boundaryElements( 𝑘) returns the list that contains the identified 𝑘D elements, 𝑘=0,1,2,…,𝑛−1. When 𝑘=𝑛, then we have the main call with 𝑛D-OPP 𝑝, 𝑛≥2, and list boundaryElements initialized with 𝑛 empty lists (if 𝑛=1, then the boundary elements of 𝑝 are precisely its extreme vertices which can be directly extracted from the EVM₁(𝑝)). When 2≤𝑘<𝑛, then the input OPP is, in fact, a 𝑘D boundary element of 𝑝 and boundaryElements contains the elements (vertices, edges, faces, etc.) discovered prior to such recursive call. In the algorithm’s basic case, when 𝑘=1, no action is performed, because the input 1D-OPP has only as boundary elements the vertices that bound its corresponding segment. The vertices in such 1D-OPP have been previously identified, because the algorithm always receives and uses a list of discovered vertices. Such a list is located in the input boundaryElements at position zero, and it is updated, as required, along main and all recursive calls.

Input:     An 𝑘D-OPP 𝑝    The number k of dimensions    A list boundaryElements containing 𝑛 lists.    A list previousCoordinates for completing the 𝑛 coordinates of  (𝑘−1)-coordinates points. Procedure GetBoundaryElements(EVM 𝑝,int k,List boundaryElements,List previousCoordinates)     if (𝑘≥2) then     EVM FDcurr, BDcurr     List v = GetSetVX1(𝑝)     List identifiedBoundaryElements = boundaryElements (𝑘−1)     List vertices = boundaryElements(0)     {FD, BD} = GetForwardBackwardDifferences(𝑝,𝑘)      for(int 𝑖=0,𝑖< Size(FD), 𝑖=𝑖+1)  // Forward Differences are processed.        EVM FDcurr = FD(i)        List compsFDcurr = ConnectedComponentsLabeling(FDcurr, 𝑘−1)        CoordType commonCoord = v(i)        for(int 𝑗=0,𝑗< Size(compsFDcurr), 𝑗=𝑗+1)          EVM currComp = compsFDcurr(j)          List verticesCurrComp          for each Extreme Vertex eV in currComp do            List point = getNdPoint(eV, commonCoord, previousCoordinates)            int index = IndexOf(vertices, point)            if(index < 0) then // A new point has been discovered.              Append(vertices, point)              index = Size(vertices) − 1              end-of-if              Append(verticesCurrComp, index)            end-of-for            int index = IndexOf(identifiedBoundaryElements, verticesCurrComp)            if(index < 0) then // A new (𝑘−1)𝐷 boundary element has been found.              Append(identifiedBoundaryElements, verticesCurrComp)            end-of-if            Append(previousCoordinates, commonCoord)            // Recursive call for identifying new (𝑘−2)𝐷 boundary elements.            GetBoundaryElements(currComp, 𝑘−1, boundaryElements, previousCoordinates)            Remove(previousCoordinates, Size(previousCoordinates) - 1)          end-of-for        end-of-for        for(int 𝑖=0,𝑖< Size(BD), 𝑖=𝑖+1)  // Backward differences are processed.          EVM BDcurr = BD(i)          List compsBDcurr = ConnectedComponentsLabeling(BDcurr, 𝑘−1)          CoordType commonCoord = v(i)          for(int 𝑗=0,𝑗< Size(compsBDcurr), 𝑗=𝑗+1)            EVM currComp = compsBDcurr(j)            List verticesCurrComp            for each Extreme Vertex eV in currComp do              List point = getNdPoint(eV, commonCoord, previousCoordinates)              int index = IndexOf(vertices, point)              if(index < 0) then // A new point has been discovered.                Append(vertices, point)                index = Size(vertices) − 1              end-of-if              Append(verticesCurrComp, index)            end-of-for            int index = IndexOf(identifiedBoundaryElements, verticesCurrComp)            if(index < 0) then // A new (𝑘−1)𝐷 boundary element has been found.              Append(identifiedBoundaryElements, verticesCurrComp)            end-of-if            Append(previousCoordinates, commonCoord)            // Recursive call for identifying new (𝑘−2)𝐷 boundary elements.            GetBoundaryElements(currComp, 𝑘−1, boundaryElements, previousCoordinates)            Remove(previousCoordinates, Size(previousCoordinates) - 1)          end-of-for        end-of-for      end-of-if     end-of-procedure

Algorithm 4 

Extracting 𝑘D boundary elements from an OPP expressed in the EVM.

Specifically, Algorithm 4 performs the discovery of 𝑘D boundary elements, for an input 𝑘D-OPP 𝑝, in the following way.(i)We obtain the list, where the discovered (𝑘−1)D boundary elements are going to be stored: boundaryElements (𝑘−1). We obtain the list of previously discovered vertices of 𝑝: boundaryElements(0).(ii)We compute, through Algorithm 2, 𝑝’s forward and backward differences perpendicular to 𝑋_𝐴-axis (the axis associated with the first coordinate of the vertices in the input EVM).(iii)For each element in the list of forward (backward) differences are computed, via Algorithm 3, its corresponding components. Each component is expressed as a (𝑘−1)D-EVM.

Now, each component in the currently processed forward (backward) difference is processed in the following way.(i)We initialize a list which will store the vertices that form the component (verticesCurrComp).(ii)Because the component is an OPP embedded in (𝑘−1)D space, the vertices in its EVM only contain 𝑘−1 coordinates. The points’ coordinates are completed first by incorporating them into the common 𝑋_𝐴 coordinate that the 𝑘-coordinates extreme vertices, that define the forward (backward) difference to which the component belongs, have. The remaining 𝑛−𝑘 coordinates are taken from the list previousCoordinates (such a list is received as input by the algorithm). The function GetNdPoint performs the completion of the points’ coordinates in such a way that we obtained vertices with 𝑛 coordinates.(iii)Each point (now with 𝑛 coordinates) from the component is evaluated in order to determine if it has been previously discovered. In this sense, it is verified if the point is present in the list of identified vertices. If function IndexOf returns a negative index, then it implies a new vertex has been discovered. In this case, the point is appended in the list of vertices. Its corresponding new index is given by the size of such a list minus one. In any case, the point’s index is inserted in the component’s list of vertices (verticesCurrComp). It is important to take into account that points listed in verticesCurrComp appear in the order they were discovered by our algorithm; hence, points’ ordering in such a list do not necessarily follow the orientation of the component they belong to.

Once all the points in the EVM of the current component have been processed, we continue, on one side, to determine if it has been previously discovered, and on the other side, to use it for the discovering of new (𝑘−2)D boundary elements. Both tasks are, respectively, achieved in the following way.(i)It is verified if the component’s list of vertices (verticesCurrComp) is an element of the list containing the previously identified (𝑘−1)D boundary elements. If the function IndexOf returns a negative index, then a new (𝑘−1)D boundary element has been discovered and list verticesCurrComp is appended in the list of (𝑘−1)D elements. (ii)It is performed a recursive call to the algorithm by using as input the component’s (𝑘−1)D-EVM. Such a recursive call will identify (𝑘−2)D boundary elements of 𝑛D-OPP 𝑝.

Consider the 3D-OPP 𝑝 shown in Figure 5. Suppose that the ordering of the coordinates of 3D-EVM of 𝑝 is 𝑋₁𝑋₂𝑋₃. All the vertices of 𝑝 are extreme except that with a dotted circle, because it has five incident edges and four of them are odd edges, while the fifth one, which is parallel to 𝑋₃-axis, is, in fact, an even edge; hence, it does not belong to any brink of 𝑝. There are another two even edges in 𝑝: one of them is parallel to 𝑋₁-axis while the other to 𝑋₂-axis. Tables 4 and 5 show the way Algorithm 4 discovers faces, perpendicular to 𝑋₁-axis, and vertices of 𝑝 (we recall that our algorithm lists boundary elements’ vertices in the order they are discovered). Table 4 corresponds to the processing of forward differences. FD¹₁(𝑝) is composed by only one component and its 2D-EVM shares the discovering of four vertices. Three of them correspond to projections of extreme vertices of 𝑝, because they have only 2 coordinates, while the fourth one precisely corresponds to the projection of the nonextreme vertex indicated in Figure 5. The vertices are completed, in order to have three coordinates, by annexing them the common coordinate of its corresponding forward difference FD¹₁(𝑝). By this way, vertices 𝑣₁, 𝑣₂, 𝑣₃, and 𝑣₄, and the face they define, are initially discovered. Via Algorithm 3, FD¹₂(𝑝) is separated in two components. Each component corresponds to a new face defined by four vertices. Both faces and the eight vertices are, respectively, added to the lists of discovered faces and vertices.

Table 4 

Identifying faces, of the 3D-OPP from Figure 5, through forward differences and Algorithm 4 (see text for details. Faces’ vertices are listed in the order they are discovered).

Table 5 

Identifying faces, of the 3D-OPP from Figure 5, through backward differences and Algorithm 4 (see text for details. Faces’ vertices are listed in the order they are discovered).

Figure 5 

A 3D-OPP. The dotted lines correspond to even edges. The vertex with the dotted circle is a nonextreme vertex.

Table 5 shows the processing of backward differences. BD¹₂(𝑝) corresponds to a 2D-OPP in which six of its seven vertices are extreme vertices. When applying Algorithm 3 over BD¹₂(𝑝), we obtained two components. The extreme vertices of BD¹₂(𝑝) are present in the components, but a new vertex appear which is product of the separation of the original face. Such a vertex (𝑣₂), in fact, was previously identified when processing FD¹₁(𝑝) (Table 4). nonextreme vertex 𝑣₁ is present in the second component: it was also identified when FD¹₁(𝑝) was processed. The remaining vertices in both components, and the faces they define, are appended to their corresponding lists.

Each one of the 2D components in the forward and backward differences of 𝑝 is used as input for the recursive calls of Algorithm 4. These calls have the objective of identifying edges perpendicular to 𝑋₂-axis. Table 6 presents the way Algorithm 4 discovers of some of these edges. When FD¹₁(𝑝) is sent as input its corresponding 1D forward and backward differences, perpendicular to 𝑋₂-axis, are computed. Two edges are identified: one is defined by vertices 𝑣₃ and 𝑣₄ (an odd edge), while the other is defined by vertices 𝑣₁ and 𝑣₂. Edge {𝑣₁,𝑣₂} is one of the three even edges that 3D-OPP 𝑝 has. According to previous sections, nonextreme vertices are ignored by the EVM. Moreover, when brinks are obtained from an EVM, even edges remain unidentified, because they are not part of brinks. Tables 4 and 6 exemplify situations where these types of former boundary elements are obtained after computing forward and backward differences.

Table 6 

Identifying some edges, of the 3D-OPP from Figure 5, through Algorithm 4 (see text for details).

When considering 𝑛D orthogonal polytopes, 𝑛≥4, Algorithm 4 is clearly capable of identifying nonextreme vertices and even edges. Furthermore, it is capable of discovering those 𝑘D boundary elements that cannot be described via brinks. Consider the 4D-OPP 𝑝 presented in Figure 6(a). Such polytope can be seen as two hypercubes sharing a face (which is shaded in gray). The face is composed by four nonextreme vertices and four even edges. When 𝑝’s brinks, parallel to 𝑋₁ to 𝑋₄-axes, are obtained (Figure 6(b)), the shared face’s elements are not present, because the 4D-EVM only stores extreme vertices which in time define brinks which are formed only by odd edges. Figure 6(c) presents the three 3D couplets, perpendicular to 𝑋₁-axis, of 𝑝. Each couplet is formed by a volume. The three volumes appear to intersect, but this is an effect of the 4D-3D-2D projections used. Figure 6(d) presents 𝑝’s two 3D forward differences perpendicular to 𝑋₁-axis. When processing FD¹₁(𝑝), Algorithm 4 detects a 3D boundary volume defined by eight vertices: four of them correspond to extreme vertices of 𝑝, while the other four correspond to the vertices of the shared face: such vertices did not belong to EVM₄(𝑝). These four vertices are detected again when processing backward difference BD¹₂(𝑝) (see Figure 6(e)). Three-dimensional forward difference FD¹₁(𝑝) is used, in a recursive call, as input for Algorithm 4 (see Figure 6(f)). When its 2D forward and backward differences, perpendicular to 𝑋₄-axis, are processed and specifically when processing its only backward difference, the shared face is formerly discovered and stored in the list of 𝑝’s boundary faces. The edges of such face are formerly discovered when this face is then sent as input, in a new recursive call, of Algorithm 4.

(a) A 4D-OPP 𝑝

(b) Brinks of 𝑝

(c) Φ11(𝑝),Φ12(𝑝),andΦ13(𝑝)

(d) FD11(𝑝)andFD12(𝑝)

(e) BD11(𝑝)BD12(𝑝)

(f) Processing 2D forward and backward differences of FD11(𝑝)

Figure 6 

Discovery of a specific face in a 4D-OPP via Algorithm 4 (see text for details).

We conclude this section by mentioning that it is important to take into account the coordinates ordering in an EVM determines which boundary elements are identified. Suppose that we use the sorting 𝑋₁𝑋₄𝑋₂𝑋₃. Algorithm 2 will extract forward and backward differences perpendicular to 𝑋₁-axis. Then, in turn, Algorithm 4 shares to identify 3D boundary volumes perpendicular precisely to 𝑋₁-axis (see Figures 6(d) and 6(e)). When each one of these volumes is sent as input in the corresponding recursive calls, we have input 3D-EVMs sorted as 𝑋₄𝑋₂𝑋₃. Hence, there are identified, again, because of the use of Algorithm 2, faces perpendicular to 𝑋₄-axis. In this phase, we are working with volumes embedded in a 3D space, because of the use of projection operator which has removed the 𝑋₁-coordinate. But, when the source 4D Space is taken into account, it can be determined, in fact, such faces are perpendicular to the plane described by 𝑋₁ and 𝑋₄ axes, because they precisely belong to volumes perpendicular to 𝑋₁-axis (see Figure 6(f)). When each face, expressed as a 2D-EVM, is sent again as input, we identify edges perpendicular to 𝑋₂-axis, formally, edges perpendicular to the 3D hyperplane described by 𝑋₁, 𝑋₄, and 𝑋₂ axes. Some applications could require to have access to boundary elements which cannot be identified via a given coordinates ordering. In this sense, a new sorting of the corresponding EVM is required, but it can be achieved in efficient time respect to the number of extreme vertices in the corresponding EVM. By this way, for example, coordinates sorting 𝑋₃𝑋₄𝑋₁𝑋₂ will share to identify 3D volumes perpendicular to 𝑋₃-axis, faces perpendicular to the plane 𝑋₃𝑋₄, and edges perpendicular to the 3D hyperplane 𝑋₃𝑋₄𝑋₁.

6. An Experimental Time Complexity Analysis for Boundary Extraction under the 𝑛D-EVM

The following key points define the conditions over which the execution time of Algorithm 4 was measured.(i)The units for the time measures are given in nanoseconds.(ii)The evaluations were performed with a CPU Intel Core Duo (2.40 GHz) and 2 Gigabytes in RAM. (iii)Our algorithms were implemented using the Java Programming Language under the Software Development Kit 1.6.0.(iv)Our testing consider 𝑛=2,3,4,5.(v)For each 𝑛, we have generated 10,000 random 𝑛D-OPPs. Each generated 𝑛D-OPP 𝑔 was, respectively, expressed as EVM_𝑛(𝑔) and sent as input to Algorithm 4.(vi)In the 2D, 3D, 4D, and 5D cases, the considered coordinates ordering were 𝑋₁𝑋₂, 𝑋₁𝑋₂𝑋₃, 𝑋₁𝑋₂𝑋₃𝑋₄, and 𝑋₁𝑋₂𝑋₃𝑋₄𝑋₅, respectively. This implies that, as specified in Section 5, we identified first (𝑛−1)D boundary elements perpendicular to 𝑋₁-axis, then we identified (𝑛−2)D boundary elements perpendicular to 𝑋₂-axis, and so on. (vii)Once the generation of 𝑛D-OPPs has finished and the algorithm was evaluated, we proceed with a statistical analysis in order to find a trendline of the form 𝑡=𝑎𝑥^𝑏, where 𝑥 = Card (EVM_𝑛(𝑔)), that fits as good as possible to our measures in order to provide an estimation of the temporal complexity of Algorithm 4 for each value of 𝑛. The quality of the approximation curve is assured by computing the coefficient of determination 𝑅².

Table 7 shows some statistics related to our generated polytopes. In Figure 7 the behavior of Algorithm 4 with our testing sets of 𝑛D-OPPs can be visualized. In the same chart the corresponding trendline for each value of 𝑛 whose associated equations are shown in Table 8 can be also appreciated.

Table 7 

Some statistical characteristics of the sets of random 𝑛D-OPPs for testing of Algorithm 4.

Table 8 

Equations associated to the trendlines that describe execution time of Algorithm 4 in the cases with 𝑛=2,3,4,5.

Figure 7 

Execution times of Algorithm 4 for 2D, 3D, 4D, and 5D-OPPs and their corresponding trendlines.

We can then observe in the obtained trendlines (Table 8) that the exponents associated with the number of vertices vary between 1 and 1.5. These experimentally identified complexities for our Algorithm 4 provide us elements to determine its temporal efficiency when we extract boundary elements from an 𝑛D-OPP expressed as an EVM.

7. Concluding Remarks and Future Work

In this work, we have provided two contributions: an algorithm for computing connected components labeling and an algorithm for extracting boundary elements. The procedures deal with the dominion of the 𝑛-dimensional orthogonal pseudo-polytopes, and they are specified in terms of the extreme vertices model in the 𝑛-dimensional space. As seen before, both algorithms are sustained in the basic methodologies provided by the 𝑛D-EVM. As commented in Section 2, some of such basic algorithms in time are sustained in the MergeXor algorithm. It computes the regularized XOR between two 𝑛D-OPPs expressed in the EVM but in terms of the ordinary XOR operation. This implies MergeXor, as its name indicates, is implemented as a merging procedure that only takes in account those extreme vertices present in the first or second input EVMs but not in both. Therefore, it can be specified as a merging-like procedure with an execution linear time given by the sum of the cardinalities of the input EVMs [1]. On one hand, this has as a consequence the temporal efficiency of the basic EVM algorithms. On the other hand, as seen in Section 6 and from an empirical point of view, we have elements to sustain the efficiency of the algorithms provided here.

As part of our future work, and particularly, immediate applications for Algorithms 3 and 4, we comment that we will attack the problem related to the automatic classification of video sequences. In [23], we describe a methodology for representing 2D color video sequences as 4D-OPPs embedded in a 4D color-space-time geometry. Our idea is the use of geometrical and topological properties, such as boundary descriptions, connected components, and discrete compactness, in order to determine similarities and differences between sequences and for instance to classify them. In [5], part of this work has been boarded using only discrete compactness, and the obtained results are promising. We are going to incorporate the information provided by Algorithms 3 and 4 in order to determine if they can contribute to enhance the results.