GridMapCacheArray.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
//=================================================================================================
// Copyright (c) 2011, Stefan Kohlbrecher, TU Darmstadt
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the Simulation, Systems Optimization and Robotics
// group, TU Darmstadt nor the names of its contributors may be used to
// endorse or promote products derived from this software without
// specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//=================================================================================================
#ifndef __GridMapCacheArray_h_
#define __GridMapCacheArray_h_
#include <Eigen/Core>
class CachedMapElement
{
public:
float val;
int index;
};
/**
* Caches filtered grid map accesses in a two dimensional array of the same size as the map.
*/
class GridMapCacheArray
{
public:
/**
* Constructor
*/
GridMapCacheArray()
: cacheArray(0)
, arrayDimensions(-1,-1)
{
currCacheIndex = 0;
}
/**
* Destructor
*/
~GridMapCacheArray()
{
deleteCacheArray();
}
/**
* Resets/deletes the cached data
*/
void resetCache()
{
currCacheIndex++;
}
/**
* Checks wether cached data for coords is available. If this is the case, writes data into val.
* @param coords The coordinates
* @param val Reference to a float the data is written to if available
* @return Indicates if cached data is available
*/
bool containsCachedData(int index, float& val)
{
const CachedMapElement& elem (cacheArray[index]);
if (elem.index == currCacheIndex) {
val = elem.val;
return true;
} else {
return false;
}
}
/**
* Caches float value val for coordinates coords.
* @param coords The coordinates
* @param val The value to be cached for coordinates.
*/
void cacheData(int index, float val)
{
CachedMapElement& elem (cacheArray[index]);
elem.index = currCacheIndex;
elem.val = val;
}
/**
* Sets the map size and resizes the cache array accordingly
* @param sizeIn The map size.
*/
void setMapSize(const Eigen::Vector2i& newDimensions)
{
setArraySize(newDimensions);
}
protected:
/**
* Creates a cache array of size sizeIn.
* @param sizeIn The size of the array
*/
void createCacheArray(const Eigen::Vector2i& newDimensions)
{
arrayDimensions = newDimensions;
int sizeX = arrayDimensions[0];
int sizeY = arrayDimensions[1];
int size = sizeX * sizeY;
cacheArray = new CachedMapElement [size];
for (int x = 0; x < size; ++x) {
cacheArray[x].index = -1;
}
}
/**
* Deletes the existing cache array.
*/
void deleteCacheArray()
{
delete[] cacheArray;
}
/**
* Sets a new cache array size
*/
void setArraySize(const Eigen::Vector2i& newDimensions)
{
if (this->arrayDimensions != newDimensions) {
if (cacheArray != 0) {
deleteCacheArray();
cacheArray = 0;
}
createCacheArray(newDimensions);
}
}
protected:
CachedMapElement* cacheArray; ///< Array used for caching data.
int currCacheIndex; ///< The cache iteration index value
Eigen::Vector2i arrayDimensions; ///< The size of the array
};
#endif
| cs |
class CachedMapElement
{
public:
float val;
int index;
};
cache는 고속 기억 장치를 의미한다.
일단 이 부분은 간단한 클래스 정의이다.
/**
* Caches filtered grid map accesses in a two dimensional array of the same size
as the map.
as the map.
*/
class GridMapCacheArray
{
주석을 보면 해당 Class는 map과 똑같은 사이즈의 2차원 배열인 Caches filered grid map 을 의미한다고 한다.
protected:
CachedMapElement* cacheArray; ///< Array used for caching data.
int currCacheIndex; ///< The cache iteration index value
Eigen::Vector2i arrayDimensions; ///< The size of the array
일단 변수들을 살펴보면
CachedMapElement* cacheArray; ///< Array used for caching data.
CachedMapElement Class 형태를 갖는 cacheArray 객체는 chaching data를 위해 쓰이는 배열이라고 한다.
int currCacheIndex; ///< The cache iteration index value
currCacheIndex는 cache iteration index value, 즉, cache 작업을 반복하는 인덱스 값인 것이다. 자세한 내용은 알고리즘들을 봐야 알겠다.
Eigen::Vector2i arrayDimensions; ///< The size of the array
Dimensions는 면적이다. Eigen::Vector2i 는 2개의 값을 갖는 벡터일 텐데 이 두 값에 array의 x축 길이와 y축 길이가 존재하는 것이다.
/**
* Constructor
*/
GridMapCacheArray()
: cacheArray(0)
, arrayDimensions(-1,-1)
{
currCacheIndex = 0;
}
생성자에서 chcheArray는 0으로
arrayDimensions는 (-1,-1)로
currCacheIndex는 0으로 초기화한다.
/**
* Destructor
*/
~GridMapCacheArray()
{
deleteCacheArray();
}
소멸자에서는 deleteCacheArray() 함수를 이용해 cache array의 memory를 비워준다.
/**
* Deletes the existing cache array.
*/
void deleteCacheArray()
{
delete[] cacheArray;
}
/**
* Resets/deletes the cached data
*/
void resetCache()
{
currCacheIndex++;
}
cache를 reset하는데 왜 currCacheIndex를 증가시키지?
/**
* Checks wether cached data for coords is available.
* If this is the case, writes data into val.
* If this is the case, writes data into val.
* @param coords The coordinates
* @param val Reference to a float the data is written to if available
* @return Indicates if cached data is available
*/
bool containsCachedData(int index, float& val)
{
const CachedMapElement& elem (cacheArray[index]);
if (elem.index == currCacheIndex) {
val = elem.val;
return true;
} else {
return false;
}
}
coordinates를 위한 cached data가 available한지 확인한 후,
available 하다면 val에 data를 써준다.
const CachedMapElement& elem (cacheArray[index]);
먼저 cacheArray[index] 의 데이터를 가져와 CachedMapElement 클래스를 갖는 elem이란 객체를 만들어준다.
if (elem.index == currCacheIndex) {
val = elem.val;
return true;
} else {
return false;
}
만일 elem의 index가 currCacheIndex와 같다면
파라미터로 받은 val의 값에 elem.val 의 값을 넣어준다.
그리고 true를 return한다.
만약 elem의 index가 currCacheIndex와 다르다면 false를 return한다.
/**
* Caches float value val for coordinates coords.
* @param coords The coordinates
* @param val The value to be cached for coordinates.
*/
void cacheData(int index, float val)
{
CachedMapElement& elem (cacheArray[index]);
elem.index = currCacheIndex;
elem.val = val;
}
흠... 이 cacheData란 함수에서는 elem이라는 객체를 cacheArray[index]의 데이터를 받아 생성하고 현재 currCacheIndex 값을 elem.index에 담고, 매개변수로 받은 val를 elem.val에 담은다.
즉
cacheData( 1, 5 )
라고 한다면
1번 인덱스의 cacheArray를 가져와 index값은 현재 인덱스인 currCacheIndex로,
값은 내가 주어준 값인 val로 바꾸는 것이다.
/**
* Sets the map size and resizes the cache array accordingly
* @param sizeIn The map size.
*/
void setMapSize(const Eigen::Vector2i& newDimensions)
{
setArraySize(newDimensions);
}
주어진 파라미터인 newDimensions 값을 이용해 setArraySize 함수를 이용한다.
/**
* Sets a new cache array size
*/
void setArraySize(const Eigen::Vector2i& newDimensions)
{
if (this->arrayDimensions != newDimensions) {
if (cacheArray != 0) {
deleteCacheArray();
cacheArray = 0;
}
createCacheArray(newDimensions);
}
}
if (this->arrayDimensions != newDimensions) {
만약 파라미터로 받은 newDimensions 가 현재 GridMapCacheArray 형태의 객체의 arrayDimensions와 다른 값을 지닌다면,
cache array size를 Set해준다.
if (cacheArray != 0) {
deleteCacheArray();
cacheArray = 0;
}
cacheArray 가 0이 아니라면 memory를 비워준 뒤 0으로 초기화해준다.
createCacheArray(newDimensions);
그리고 위 함수를 이용해 CacheArray를 생성한다.
/**
* Creates a cache array of size sizeIn.
* @param sizeIn The size of the array
*/
void createCacheArray(const Eigen::Vector2i& newDimensions)
{
arrayDimensions = newDimensions;
int sizeX = arrayDimensions[0];
int sizeY = arrayDimensions[1];
int size = sizeX * sizeY;
cacheArray = new CachedMapElement [size];
for (int x = 0; x < size; ++x) {
cacheArray[x].index = -1;
}
}
arrayDimensions = newDimensions;
파라미터로 받은 newDimensions 값을
객체의 arrayDimensions 값에 넣는다.
int sizeX = arrayDimensions[0];
int sizeY = arrayDimensions[1];
X축 사이즈와 Y축 사이즈를 받아온다.
int size = sizeX * sizeY;
두 값을 곱해 전체 사이즈를 구한다.
cacheArray = new CachedMapElement [size];
cacheArray에 memory를 할당하기 위해
CachedMapElement 클래스 크기만큼 [size] 개수로 메모리를 할당한다.
for (int x = 0; x < size; ++x) {
cacheArray[x].index = -1;
}
index에는 모두 -1을 담아준다.
으음... 어떤 구조인지는 인지하겠는데 "왜" 존재하는지는 확실히 모르겠다...
차후에 다른 소스에서 사용되는 부분에서 확인해보자.
댓글 없음:
댓글 쓰기