56 m_likelihoodCacheOutDated =
true;
60 robotPose2D =
CPose2D(*robotPose);
61 robotPose3D = (*robotPose);
69 const float maxCertainty = insertionOptions.maxOccupancyUpdateCertainty;
70 float maxFreeCertainty = insertionOptions.maxFreenessUpdateCertainty;
71 if (maxFreeCertainty == .0f) maxFreeCertainty = maxCertainty;
72 float maxFreeCertaintyNoEcho = insertionOptions.maxFreenessInvalidRanges;
73 if (maxFreeCertaintyNoEcho == .0f) maxFreeCertaintyNoEcho = maxCertainty;
76 std::max<cellType>(1, p2l(maxFreeCertainty));
77 cellType logodd_observation_occupied =
78 3 * std::max<cellType>(1, p2l(maxCertainty));
80 std::max<cellType>(1, p2l(maxFreeCertaintyNoEcho));
84 OCCGRID_CELLTYPE_MIN + logodd_observation_occupied;
86 OCCGRID_CELLTYPE_MAX -
87 std::max(logodd_noecho_free, logodd_observation_free);
97 CPose3D sensorPose3D = robotPose3D + o.sensorPose;
98 CPose2D laserPose(sensorPose3D);
103 o.isPlanarScan(insertionOptions.horizontalTolerance);
104 unsigned int decimation = insertionOptions.decimation;
107 if (insertionOptions.useMapAltitude &&
108 fabs(insertionOptions.mapAltitude - sensorPose3D.z()) > 0.001)
110 reallyInsert =
false;
116 bool sensorIsBottomwards =
124 int cx, cy, N = o.scan.
size();
129 const float maxDistanceInsertion =
130 insertionOptions.maxDistanceInsertion;
131 const bool invalidAsFree =
132 insertionOptions.considerInvalidRangesAsFreeSpace;
133 float new_x_max, new_x_min;
134 float new_y_max, new_y_min;
135 float last_valid_range = maxDistanceInsertion;
137 int K = updateInfoChangeOnly.enabled
138 ? updateInfoChangeOnly.laserRaysSkip
140 size_t idx, nRanges = o.scan.size();
147 #if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG) 153 if (!insertionOptions.wideningBeamsWithDistance)
166 float *scanPoint_x, *scanPoint_y;
168 if (o.rightToLeft ^ sensorIsBottomwards)
170 A = laserPose.
phi() - 0.5 * o.aperture;
171 dAK = K * o.aperture / N;
175 A = laserPose.
phi() + 0.5 * o.aperture;
176 dAK = -K * o.aperture / N;
179 new_x_max = -(numeric_limits<float>::max)();
180 new_x_min = (numeric_limits<float>::max)();
181 new_y_max = -(numeric_limits<float>::max)();
182 new_y_min = (numeric_limits<float>::max)();
184 for (idx = 0, scanPoint_x = scanPoints_x,
185 scanPoint_y = scanPoints_y;
186 idx < nRanges; idx += K, scanPoint_x++, scanPoint_y++)
188 if (o.validRange[idx])
190 curRange = o.scan[idx];
191 float R =
min(maxDistanceInsertion, curRange);
193 *scanPoint_x = px + cos(
A) *
R;
194 *scanPoint_y = py + sin(
A) *
R;
195 last_valid_range = curRange;
203 maxDistanceInsertion, 0.5f * last_valid_range);
204 *scanPoint_x = px + cos(
A) *
R;
205 *scanPoint_y = py + sin(
A) *
R;
216 new_x_max = max(new_x_max, *scanPoint_x);
217 new_x_min =
min(new_x_min, *scanPoint_x);
218 new_y_max = max(new_y_max, *scanPoint_y);
219 new_y_min =
min(new_y_min, *scanPoint_y);
223 float securMargen = 15 * resolution;
225 if (new_x_max > x_max - securMargen)
226 new_x_max += 2 * securMargen;
229 if (new_x_min < x_min + securMargen)
234 if (new_y_max > y_max - securMargen)
235 new_y_max += 2 * securMargen;
238 if (new_y_min < y_min + securMargen)
246 resizeGrid(new_x_min, new_x_max, new_y_min, new_y_max, 0.5);
250 unsigned theMapSize_x = size_x;
257 for (idx = 0; idx < nRanges; idx += K)
259 if (!o.validRange[idx] && !invalidAsFree)
continue;
266 int trg_cx = x2idx(scanPoints_x[idx]);
267 int trg_cy = y2idx(scanPoints_y[idx]);
271 static_cast<unsigned int>(trg_cx) < size_x &&
272 static_cast<unsigned int>(trg_cy) < size_y);
276 int Acx = trg_cx - cx;
277 int Acy = trg_cy - cy;
282 int nStepsRay = max(Acx_, Acy_);
283 if (!nStepsRay)
continue;
286 float N_1 = 1.0f / nStepsRay;
290 (Acx < 0 ? -1 : +1) *
round((Acx_ <<
FRBITS) * N_1);
292 (Acy < 0 ? -1 : +1) *
round((Acy_ <<
FRBITS) * N_1);
296 const auto logodd_free = o.validRange[idx]
297 ? logodd_observation_free
298 : logodd_noecho_free;
300 for (
int nStep = 0; nStep < nStepsRay; nStep++)
302 updateCell_fast_free(
303 cx, cy, logodd_free, logodd_thres_free, theMapArray,
317 if (o.validRange[idx] && o.scan[idx] < maxDistanceInsertion)
318 updateCell_fast_occupied(
319 trg_cx, trg_cy, logodd_observation_occupied,
320 logodd_thres_occupied, theMapArray, theMapSize_x);
334 if (o.rightToLeft ^ sensorIsBottomwards)
336 A = laserPose.
phi() - 0.5 * o.aperture;
337 dAK = K * o.aperture / N;
341 A = laserPose.
phi() + 0.5 * o.aperture;
342 dAK = -K * o.aperture / N;
345 new_x_max = -(numeric_limits<float>::max)();
346 new_x_min = (numeric_limits<float>::max)();
347 new_y_max = -(numeric_limits<float>::max)();
348 new_y_min = (numeric_limits<float>::max)();
350 last_valid_range = maxDistanceInsertion;
351 for (idx = 0; idx < nRanges; idx += K)
353 float scanPoint_x, scanPoint_y;
354 if (o.validRange[idx])
356 curRange = o.scan[idx];
357 float R =
min(maxDistanceInsertion, curRange);
359 scanPoint_x = px + cos(
A) *
R;
360 scanPoint_y = py + sin(
A) *
R;
361 last_valid_range = curRange;
369 maxDistanceInsertion, 0.5f * last_valid_range);
370 scanPoint_x = px + cos(
A) *
R;
371 scanPoint_y = py + sin(
A) *
R;
382 new_x_max = max(new_x_max, scanPoint_x);
383 new_x_min =
min(new_x_min, scanPoint_x);
384 new_y_max = max(new_y_max, scanPoint_y);
385 new_y_min =
min(new_y_min, scanPoint_y);
389 float securMargen = 15 * resolution;
391 if (new_x_max > x_max - securMargen)
392 new_x_max += 2 * securMargen;
395 if (new_x_min < x_min + securMargen)
400 if (new_y_max > y_max - securMargen)
401 new_y_max += 2 * securMargen;
404 if (new_y_min < y_min + securMargen)
412 resizeGrid(new_x_min, new_x_max, new_y_min, new_y_max, 0.5);
416 unsigned theMapSize_x = size_x;
425 if (o.rightToLeft ^ sensorIsBottomwards)
427 A = laserPose.
phi() - 0.5 * o.aperture;
428 dAK = K * o.aperture / N;
432 A = laserPose.
phi() + 0.5 * o.aperture;
433 dAK = -K * o.aperture / N;
441 last_valid_range = maxDistanceInsertion;
443 const double dA_2 = 0.5 * o.aperture / N;
444 for (idx = 0; idx < nRanges; idx += K,
A += dAK)
447 if (o.validRange[idx])
449 curRange = o.scan[idx];
450 last_valid_range = curRange;
451 theR =
min(maxDistanceInsertion, curRange);
459 maxDistanceInsertion, 0.5f * last_valid_range);
464 if (theR < resolution)
477 P1.
x = px + cos(
A - dA_2) * theR;
478 P1.
y = py + sin(
A - dA_2) * theR;
480 P2.
x = px + cos(
A + dA_2) * theR;
481 P2.
y = py + sin(
A + dA_2) * theR;
484 if (P2.
y < P1.
y) std::swap(P2, P1);
485 if (P2.
y < P0.
y) std::swap(P2, P0);
486 if (P1.
y < P0.
y) std::swap(P1, P0);
496 #if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG) 499 static_cast<unsigned int>(P0.
cx) < size_x &&
500 static_cast<unsigned int>(P0.
cy) < size_y);
502 static_cast<unsigned int>(P1.
cx) < size_x &&
503 static_cast<unsigned int>(P1.
cy) < size_y);
505 static_cast<unsigned int>(P2.
cx) < size_x &&
506 static_cast<unsigned int>(P2.
cy) < size_y);
516 if (P0.
cy == P2.
cy && P0.
cy == P1.
cy)
522 for (
int ccx = min_cx; ccx <= max_cx; ccx++)
523 updateCell_fast_free(
524 ccx, P0.
cy, logodd_observation_free,
525 logodd_thres_free, theMapArray, theMapSize_x);
533 (P1.
y - P0.
y) * (P2.
x - P0.
x) / (P2.
y - P0.
y);
535 P1b.
cx = x2idx(P1b.
x);
536 P1b.
cy = y2idx(P1b.
y);
541 const int Acx01 = P1.
cx - P0.
cx;
542 const int Acy01 = P1.
cy - P0.
cy;
543 const int Acx01b = P1b.
cx - P0.
cx;
547 const float inv_N_01 =
548 1.0f / (
max3(abs(Acx01), abs(Acy01), abs(Acx01b)) +
550 const int frAcx01 =
round(
551 (Acx01 <<
FRBITS) * inv_N_01);
552 const int frAcy01 =
round(
553 (Acy01 <<
FRBITS) * inv_N_01);
554 const int frAcx01b =
round(
555 (Acx01b <<
FRBITS) * inv_N_01);
565 int frAx_R1 = 0, frAx_R2 = 0;
566 int frAy_R1 = frAcy01;
596 int last_insert_cy = -1;
600 if (last_insert_cy !=
603 last_insert_cy = R1.cy;
606 for (
int ccx = R1.cx; ccx <= R2.cx; ccx++)
607 updateCell_fast_free(
608 ccx, R1.cy, logodd_observation_free,
609 logodd_thres_free, theMapArray,
620 }
while (R1.cy < P1.
cy);
629 const int Acx12 = P2.
cx - P1.
cx;
630 const int Acy12 = P2.
cy - P1.
cy;
631 const int Acx1b2 = P2.
cx - P1b.
cx;
635 const float inv_N_12 =
636 1.0f / (
max3(abs(Acx12), abs(Acy12), abs(Acx1b2)) +
638 const int frAcx12 =
round(
639 (Acx12 <<
FRBITS) * inv_N_12);
640 const int frAcy12 =
round(
641 (Acy12 <<
FRBITS) * inv_N_12);
642 const int frAcx1b2 =
round(
643 (Acx1b2 <<
FRBITS) * inv_N_12);
682 last_insert_cy = -100;
687 if (last_insert_cy !=
691 last_insert_cy = R1.cy;
692 for (
int ccx = R1.cx; ccx <= R2.cx; ccx++)
693 updateCell_fast_free(
694 ccx, R1.cy, logodd_observation_free,
695 logodd_thres_free, theMapArray,
706 }
while (R1.cy <= P2.
cy);
716 if (o.validRange[idx] && o.scan[idx] < maxDistanceInsertion)
720 P1.
x = px + cos(
A - dA_2) * theR;
721 P1.
y = py + sin(
A - dA_2) * theR;
723 P2.
x = px + cos(
A + dA_2) * theR;
724 P2.
y = py + sin(
A + dA_2) * theR;
731 #if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG) 734 static_cast<unsigned int>(P1.
cx) < size_x &&
735 static_cast<unsigned int>(P1.
cy) < size_y);
737 static_cast<unsigned int>(P2.
cx) < size_x &&
738 static_cast<unsigned int>(P2.
cy) < size_y);
742 if (P2.
cx == P1.
cx && P2.
cy == P1.
cy)
744 updateCell_fast_occupied(
745 P1.
cx, P1.
cy, logodd_observation_occupied,
746 logodd_thres_occupied, theMapArray,
754 const int AcxE = P2.
cx - P1.
cx;
755 const int AcyE = P2.
cy - P1.
cy;
758 const int nSteps = (max(abs(AcxE), abs(AcyE)) + 1);
759 const float inv_N_12 =
761 const int frAcxE =
round(
762 (AcxE <<
FRBITS) * inv_N_12);
763 const int frAcyE =
round(
764 (AcyE <<
FRBITS) * inv_N_12);
771 for (
int nStep = 0; nStep <= nSteps; nStep++)
773 updateCell_fast_occupied(
774 R1.cx, R1.cy, logodd_observation_occupied,
775 logodd_thres_occupied, theMapArray,
805 o.getSensorPose(spose);
806 CPose3D sensorPose3D = robotPose3D + spose;
807 CPose2D laserPose(sensorPose3D);
811 bool reallyInsert =
true;
812 unsigned int decimation = insertionOptions.decimation;
815 if (insertionOptions.useMapAltitude &&
816 fabs(insertionOptions.mapAltitude - sensorPose3D.z()) > 0.001)
818 reallyInsert =
false;
831 const float maxDistanceInsertion =
832 insertionOptions.maxDistanceInsertion;
833 const bool invalidAsFree =
834 insertionOptions.considerInvalidRangesAsFreeSpace;
835 float new_x_max, new_x_min;
836 float new_y_max, new_y_min;
837 float last_valid_range = maxDistanceInsertion;
839 int K = updateInfoChangeOnly.enabled
840 ? updateInfoChangeOnly.laserRaysSkip
842 size_t idx, nRanges = o.sensedData.size();
849 #if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG) 861 new_x_max = -(numeric_limits<float>::max)();
862 new_x_min = (numeric_limits<float>::max)();
863 new_y_max = -(numeric_limits<float>::max)();
864 new_y_min = (numeric_limits<float>::max)();
866 last_valid_range = maxDistanceInsertion;
868 for (idx = 0; idx < nRanges; idx += K)
870 float scanPoint_x, scanPoint_y;
871 if (o.sensedData[idx].sensedDistance < maxDistanceInsertion)
873 curRange = o.sensedData[idx].sensedDistance;
874 float R =
min(maxDistanceInsertion, curRange);
876 scanPoint_x = px + cos(
A) *
R;
877 scanPoint_y = py + sin(
A) *
R;
878 last_valid_range = curRange;
886 min(maxDistanceInsertion, 0.5f * last_valid_range);
887 scanPoint_x = px + cos(
A) *
R;
888 scanPoint_y = py + sin(
A) *
R;
899 new_x_max = max(new_x_max, scanPoint_x);
900 new_x_min =
min(new_x_min, scanPoint_x);
901 new_y_max = max(new_y_max, scanPoint_y);
902 new_y_min =
min(new_y_min, scanPoint_y);
906 float securMargen = 15 * resolution;
908 if (new_x_max > x_max - securMargen)
909 new_x_max += 2 * securMargen;
912 if (new_x_min < x_min + securMargen)
917 if (new_y_max > y_max - securMargen)
918 new_y_max += 2 * securMargen;
921 if (new_y_min < y_min + securMargen)
929 resizeGrid(new_x_min, new_x_max, new_y_min, new_y_max, 0.5);
933 unsigned theMapSize_x = size_x;
941 A = laserPose.
phi() - 0.5 * o.sensorConeApperture;
949 last_valid_range = maxDistanceInsertion;
951 const double dA_2 = 0.5 * o.sensorConeApperture;
952 for (idx = 0; idx < nRanges; idx += K,
A += dAK)
955 if (o.sensedData[idx].sensedDistance < maxDistanceInsertion)
957 curRange = o.sensedData[idx].sensedDistance;
958 last_valid_range = curRange;
959 theR =
min(maxDistanceInsertion, curRange);
967 min(maxDistanceInsertion, 0.5f * last_valid_range);
972 if (theR < resolution)
983 P1.
x = px + cos(
A - dA_2) * theR;
984 P1.
y = py + sin(
A - dA_2) * theR;
986 P2.
x = px + cos(
A + dA_2) * theR;
987 P2.
y = py + sin(
A + dA_2) * theR;
990 if (P2.
y < P1.
y) std::swap(P2, P1);
991 if (P2.
y < P0.
y) std::swap(P2, P0);
992 if (P1.
y < P0.
y) std::swap(P1, P0);
1000 P2.
cy = y2idx(P2.
y);
1002 #if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG) 1005 static_cast<unsigned int>(P0.
cx) < size_x &&
1006 static_cast<unsigned int>(P0.
cy) < size_y);
1008 static_cast<unsigned int>(P1.
cx) < size_x &&
1009 static_cast<unsigned int>(P1.
cy) < size_y);
1011 static_cast<unsigned int>(P2.
cx) < size_x &&
1012 static_cast<unsigned int>(P2.
cy) < size_y);
1022 if (P0.
cy == P2.
cy && P0.
cy == P1.
cy)
1028 for (
int ccx = min_cx; ccx <= max_cx; ccx++)
1029 updateCell_fast_free(
1030 ccx, P0.
cy, logodd_observation_free,
1031 logodd_thres_free, theMapArray, theMapSize_x);
1039 P0.
x + (P1.
y - P0.
y) * (P2.
x - P0.
x) / (P2.
y - P0.
y);
1041 P1b.
cx = x2idx(P1b.
x);
1042 P1b.
cy = y2idx(P1b.
y);
1047 const int Acx01 = P1.
cx - P0.
cx;
1048 const int Acy01 = P1.
cy - P0.
cy;
1049 const int Acx01b = P1b.
cx - P0.
cx;
1053 const float inv_N_01 =
1054 1.0f / (
max3(abs(Acx01), abs(Acy01), abs(Acx01b)) +
1060 const int frAcx01b =
1071 int frAx_R1 = 0, frAx_R2 = 0;
1072 int frAy_R1 = frAcy01;
1101 int last_insert_cy = -1;
1105 if (last_insert_cy !=
1108 last_insert_cy = R1.cy;
1111 for (
int ccx = R1.cx; ccx <= R2.cx; ccx++)
1112 updateCell_fast_free(
1113 ccx, R1.cy, logodd_observation_free,
1114 logodd_thres_free, theMapArray,
1122 R1.cx = R1.frX >>
FRBITS;
1123 R1.cy = R1.frY >>
FRBITS;
1124 R2.cx = R2.frX >>
FRBITS;
1125 }
while (R1.cy < P1.
cy);
1133 const int Acx12 = P2.
cx - P1.
cx;
1134 const int Acy12 = P2.
cy - P1.
cy;
1135 const int Acx1b2 = P2.
cx - P1b.
cx;
1139 const float inv_N_12 =
1140 1.0f / (
max3(abs(Acx12), abs(Acy12), abs(Acx1b2)) +
1146 const int frAcx1b2 =
1181 R1.frX = R1.cx <<
FRBITS;
1182 R1.frY = R1.cy <<
FRBITS;
1183 R2.frX = R2.cx <<
FRBITS;
1184 R2.frY = R2.cy <<
FRBITS;
1186 last_insert_cy = -100;
1191 if (last_insert_cy !=
1195 last_insert_cy = R1.cy;
1196 for (
int ccx = R1.cx; ccx <= R2.cx; ccx++)
1197 updateCell_fast_free(
1198 ccx, R1.cy, logodd_observation_free,
1199 logodd_thres_free, theMapArray,
1207 R1.cx = R1.frX >>
FRBITS;
1208 R1.cy = R1.frY >>
FRBITS;
1209 R2.cx = R2.frX >>
FRBITS;
1210 }
while (R1.cy <= P2.
cy);
1220 if (o.sensedData[idx].sensedDistance < maxDistanceInsertion)
1224 P1.
x = px + cos(
A - dA_2) * theR;
1225 P1.
y = py + sin(
A - dA_2) * theR;
1227 P2.
x = px + cos(
A + dA_2) * theR;
1228 P2.
y = py + sin(
A + dA_2) * theR;
1230 P1.
cx = x2idx(P1.
x);
1231 P1.
cy = y2idx(P1.
y);
1232 P2.
cx = x2idx(P2.
x);
1233 P2.
cy = y2idx(P2.
y);
1235 #if defined(_DEBUG) || (MRPT_ALWAYS_CHECKS_DEBUG) 1238 static_cast<unsigned int>(P1.
cx) < size_x &&
1239 static_cast<unsigned int>(P1.
cy) < size_y);
1241 static_cast<unsigned int>(P2.
cx) < size_x &&
1242 static_cast<unsigned int>(P2.
cy) < size_y);
1246 if (P2.
cx == P1.
cx && P2.
cy == P1.
cy)
1248 updateCell_fast_occupied(
1249 P1.
cx, P1.
cy, logodd_observation_occupied,
1250 logodd_thres_occupied, theMapArray, theMapSize_x);
1257 const int AcxE = P2.
cx - P1.
cx;
1258 const int AcyE = P2.
cy - P1.
cy;
1261 const int nSteps = (max(abs(AcxE), abs(AcyE)) + 1);
1262 const float inv_N_12 =
1271 R1.frX = R1.cx <<
FRBITS;
1272 R1.frY = R1.cy <<
FRBITS;
1274 for (
int nStep = 0; nStep <= nSteps; nStep++)
1276 updateCell_fast_occupied(
1277 R1.cx, R1.cy, logodd_observation_occupied,
1278 logodd_thres_occupied, theMapArray,
1283 R1.cx = R1.frX >>
FRBITS;
1284 R1.cy = R1.frY >>
FRBITS;
1322 considerInvalidRangesAsFreeSpace,
bool,
iniFile, section);
1335 std::ostream& out)
const 1338 "\n----------- [COccupancyGridMap2D::TInsertionOptions] ------------ " A compile-time fixed-size numeric matrix container.
Declares a class derived from "CObservation" that encapsules a single range measurement, and associated parameters.
constexpr matrix_size_t size() const
Get a 2-vector with [NROWS NCOLS] (as in MATLAB command size(x))
bool internal_insertObservation(const mrpt::obs::CObservation &obs, const mrpt::poses::CPose3D *robotPose=nullptr) override
Insert the observation information into this map.
Local stucture used in the next method (must be here for usage within STL stuff)
const T max3(const T &A, const T &B, const T &C)
void OnPostSuccesfulInsertObs(const mrpt::obs::CObservation &) override
See base class.
#define ASSERT_(f)
Defines an assertion mechanism.
This class allows loading and storing values and vectors of different types from a configuration text...
This base provides a set of functions for maths stuff.
#define MRPT_CHECK_NORMAL_NUMBER(v)
Throws an exception if the number is NaN, IND, or +/-INF, or return the same number otherwise...
This namespace contains representation of robot actions and observations.
string iniFile(myDataDir+string("benchmark-options.ini"))
#define IS_CLASS(obj, class_name)
True if the given reference to object (derived from mrpt::rtti::CObject) is of the given class...
double x() const
Common members of all points & poses classes.
GLsizei const GLchar ** string
#define mrpt_alloca(nBytes)
In platforms and compilers with support to "alloca", allocate a memory block on the stack; if alloca ...
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
#define LOADABLEOPTS_DUMP_VAR(variableName, variableType)
Macro for dumping a variable to a stream, within the method "dumpToTextStream(out)" (Variable types a...
#define MRPT_LOAD_CONFIG_VAR( variableName, variableType, configFileObject, sectionNameStr)
An useful macro for loading variables stored in a INI-like file under a key with the same name that t...
const T min3(const T &A, const T &B, const T &C)
void dumpToTextStream(std::ostream &out) const override
This method should clearly display all the contents of the structure in textual form, sending it to a std::ostream.
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
A "CObservation"-derived class that represents a 2D range scan measurement (typically from a laser sc...
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle...
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Declares a class that represents any robot's observation.
std::string format(const char *fmt,...) MRPT_printf_format_check(1
A std::string version of C sprintf.
const double & phi() const
Get the phi angle of the 2D pose (in radians)
void loadFromConfigFile(const mrpt::config::CConfigFileBase &source, const std::string §ion) override
This method load the options from a ".ini" file.
OccGridCellTraits::cellType cellType
The type of the map cells:
MATRIX44 getHomogeneousMatrixVal() const
Returns the corresponding 4x4 homogeneous transformation matrix for the point(translation) or pose (t...
#define MRPT_LOAD_CONFIG_VAR_DEGREES( variableName, configFileObject, sectionNameStr)
Loads a double variable, stored as radians but entered in the INI-file as degrees.
#define mrpt_alloca_free(mem_block)
This method must be called to "free" each memory block allocated with "system::alloca": If the block ...
int round(const T value)
Returns the closer integer (int) to x.