1 /*
2 Copyright (c) 2013 Khaled Mammou - Advanced Micro Devices, Inc.
3 
4 Permission is hereby granted, free of charge, to any person obtaining a copy
5 of this software and associated documentation files (the "Software"), to deal
6 in the Software without restriction, including without limitation the rights
7 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 copies of the Software, and to permit persons to whom the Software is
9 furnished to do so, subject to the following conditions:
10 
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13 
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 THE SOFTWARE.
21 */
22 
23 
24 #pragma once
25 #ifndef O3DGC_ADJACENCY_INFO_H
26 #define O3DGC_ADJACENCY_INFO_H
27 
28 #include "o3dgcCommon.h"
29 
30 namespace o3dgc
31 {
32     const long O3DGC_MIN_NEIGHBORS_SIZE     = 128;
33     const long O3DGC_MIN_NUM_NEIGHBORS_SIZE = 16;
34     //!
35     class AdjacencyInfo
36     {
37     public:
38         //! Constructor.
39                                 AdjacencyInfo(long numNeighborsSize = O3DGC_MIN_NUM_NEIGHBORS_SIZE,
40                                               long neighborsSize    = O3DGC_MIN_NUM_NEIGHBORS_SIZE)
41                                 {
42                                     m_numElements      = 0;
43                                     m_neighborsSize    = neighborsSize;
44                                     m_numNeighborsSize = numNeighborsSize;
45                                     m_numNeighbors     = new long [m_numNeighborsSize];
46                                     m_neighbors        = new long [m_neighborsSize   ];
47                                 };
48         //! Destructor.
~AdjacencyInfo(void)49                                 ~AdjacencyInfo(void)
50                                 {
51                                     delete [] m_neighbors;
52                                     delete [] m_numNeighbors;
53                                 };
Allocate(long numNeighborsSize,long neighborsSize)54         O3DGCErrorCode          Allocate(long numNeighborsSize, long neighborsSize)
55                                 {
56                                     m_numElements = numNeighborsSize;
57                                     if (neighborsSize > m_neighborsSize)
58                                     {
59                                         delete [] m_numNeighbors;
60                                         m_neighborsSize    = neighborsSize;
61                                         m_numNeighbors     = new long [m_numNeighborsSize];
62                                     }
63                                     if (numNeighborsSize > m_numNeighborsSize)
64                                     {
65                                         delete [] m_neighbors;
66                                         m_numNeighborsSize = numNeighborsSize;
67                                         m_neighbors        = new long [m_neighborsSize];
68                                     }
69                                     return O3DGC_OK;
70                                 }
AllocateNumNeighborsArray(long numElements)71         O3DGCErrorCode          AllocateNumNeighborsArray(long numElements)
72                                 {
73                                     if (numElements > m_numNeighborsSize)
74                                     {
75                                         delete [] m_numNeighbors;
76                                         m_numNeighborsSize = numElements;
77                                         m_numNeighbors = new long [m_numNeighborsSize];
78                                     }
79                                     m_numElements = numElements;
80                                     return O3DGC_OK;
81                                 }
AllocateNeighborsArray()82         O3DGCErrorCode          AllocateNeighborsArray()
83                                 {
84                                     for(long i = 1; i < m_numElements; ++i)
85                                     {
86                                         m_numNeighbors[i] += m_numNeighbors[i-1];
87                                     }
88                                     if (m_numNeighbors[m_numElements-1] > m_neighborsSize)
89                                     {
90                                         delete [] m_neighbors;
91                                         m_neighborsSize = m_numNeighbors[m_numElements-1];
92                                         m_neighbors = new long [m_neighborsSize];
93                                     }
94                                     return O3DGC_OK;
95                                 }
ClearNumNeighborsArray()96         O3DGCErrorCode          ClearNumNeighborsArray()
97                                 {
98                                     memset(m_numNeighbors, 0x00, sizeof(long) * m_numElements);
99                                     return O3DGC_OK;
100                                 }
ClearNeighborsArray()101         O3DGCErrorCode          ClearNeighborsArray()
102                                 {
103                                     memset(m_neighbors, 0xFF, sizeof(long) * m_neighborsSize);
104                                     return O3DGC_OK;
105                                 }
AddNeighbor(long element,long neighbor)106         O3DGCErrorCode          AddNeighbor(long element, long neighbor)
107                                 {
108                                     assert(m_numNeighbors[element] <= m_numNeighbors[m_numElements-1]);
109                                     long p0 = Begin(element);
110                                     long p1 = End(element);
111                                     for(long p = p0; p < p1; p++)
112                                     {
113                                         if (m_neighbors[p] == -1)
114                                         {
115                                             m_neighbors[p] = neighbor;
116                                             return O3DGC_OK;
117                                         }
118                                     }
119                                     return O3DGC_ERROR_BUFFER_FULL;
120                                 }
Begin(long element)121         long                    Begin(long element) const
122                                 {
123                                     assert(element < m_numElements);
124                                     assert(element >= 0);
125                                     return (element>0)?m_numNeighbors[element-1]:0;
126                                 }
End(long element)127         long                    End(long element) const
128                                 {
129                                     assert(element < m_numElements);
130                                     assert(element >= 0);
131                                     return m_numNeighbors[element];
132                                 }
GetNeighbor(long element)133         long                    GetNeighbor(long element) const
134                                 {
135                                     assert(element < m_neighborsSize);
136                                     assert(element >= 0);
137                                     return m_neighbors[element];
138                                 }
GetNumNeighbors(long element)139         long                    GetNumNeighbors(long element)  const
140                                 {
141                                     return End(element) - Begin(element);
142                                 }
GetNumNeighborsBuffer()143         long *                  GetNumNeighborsBuffer() { return m_numNeighbors;}
GetNeighborsBuffer()144         long *                  GetNeighborsBuffer()    { return m_neighbors;}
145 
146     private:
147         long                    m_neighborsSize;    // actual allocated size for m_neighbors
148         long                    m_numNeighborsSize; // actual allocated size for m_numNeighbors
149         long                    m_numElements;      // number of elements
150         long *                  m_neighbors;        //
151         long *                  m_numNeighbors;     //
152     };
153 }
154 #endif // O3DGC_ADJACENCY_INFO_H
155 
156