MRPT  1.9.9
COccupancyGridMap3D.cpp
Go to the documentation of this file.
1 /* +------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | https://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2019, Individual contributors, see AUTHORS file |
6  | See: https://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See: https://www.mrpt.org/License |
8  +------------------------------------------------------------------------+ */
9 
10 #include "maps-precomp.h" // Precomp header
11 
16 #include <mrpt/poses/CPose3D.h>
18 
19 using namespace mrpt;
20 using namespace mrpt::maps;
21 
22 // =========== Begin of Map definition ============
24 
26 
29 {
30  using namespace std::string_literals;
31 
32  // [<sect>+"_creationOpts"]
33  const auto sSectCreation = sect + "_creationOpts"s;
34  MRPT_LOAD_CONFIG_VAR(min_x, float, source, sSectCreation);
35  MRPT_LOAD_CONFIG_VAR(max_x, float, source, sSectCreation);
36  MRPT_LOAD_CONFIG_VAR(min_y, float, source, sSectCreation);
37  MRPT_LOAD_CONFIG_VAR(max_y, float, source, sSectCreation);
38  MRPT_LOAD_CONFIG_VAR(min_z, float, source, sSectCreation);
39  MRPT_LOAD_CONFIG_VAR(max_z, float, source, sSectCreation);
40  MRPT_LOAD_CONFIG_VAR(resolution, float, source, sSectCreation);
41 
42  // [<sectionName>+"_occupancyGrid_##_insertOpts"]
43  insertionOpts.loadFromConfigFile(source, sect + "_insertOpts"s);
44 
45  // [<sectionName>+"_occupancyGrid_##_likelihoodOpts"]
46  likelihoodOpts.loadFromConfigFile(source, sect + "_likelihoodOpts"s);
47 }
48 
50  std::ostream& out) const
51 {
59 
62 }
63 
66 {
67  auto& def = dynamic_cast<const COccupancyGridMap3D::TMapDefinition&>(_def);
68  auto* obj = new COccupancyGridMap3D(
69  mrpt::math::TPoint3D(def.min_x, def.min_y, def.min_z),
70  mrpt::math::TPoint3D(def.max_x, def.max_y, def.max_z), def.resolution);
71  obj->insertionOptions = def.insertionOpts;
72  obj->likelihoodOptions = def.likelihoodOpts;
73  return obj;
74 }
75 // =========== End of Map definition Block =========
76 
78 
79 // Static lookup tables for log-odds
81 
84 {
85  return logodd_lut;
86 }
87 
89  const mrpt::math::TPoint3D& corner_min,
90  const mrpt::math::TPoint3D& corner_max, float resolution)
91 {
93  setSize(corner_min, corner_max, resolution, 0.5f);
94  MRPT_END
95 }
96 
98  const mrpt::math::TPoint3D& cmin, const mrpt::math::TPoint3D& cmax,
99  float res, float default_value)
100 {
101  MRPT_START
102 
103  ASSERT_ABOVE_(res, 0.0f);
104  ASSERT_ABOVE_(cmax.x, cmin.x);
105  ASSERT_ABOVE_(cmax.y, cmin.y);
106  ASSERT_ABOVE_(cmax.z, cmin.z);
107  ASSERT_ABOVEEQ_(default_value, 0.0f);
108  ASSERT_BELOWEQ_(default_value, 1.0f);
109 
110  const auto def_value = p2l(default_value);
111  m_grid.setSize(
112  cmin.x, cmax.x, cmin.y, cmax.y, cmin.z, cmax.z, res, res, &def_value);
113 
114  // m_likelihoodCacheOutDated = true;
115  m_is_empty = true;
116 
117  MRPT_END
118 }
119 
121  const mrpt::math::TPoint3D& cmin, const mrpt::math::TPoint3D& cmax,
122  float new_cells_default_value)
123 {
124  MRPT_START
125 
126  const auto def_value = p2l(new_cells_default_value);
127  const double additionalMargin = .0;
128  m_grid.resize(
129  cmin.x, cmax.x, cmin.y, cmax.y, cmin.z, cmax.z, def_value,
130  additionalMargin);
131 
132  // m_likelihoodCacheOutDated = true;
133  m_is_empty = true;
134 
135  MRPT_END
136 }
137 
139 {
140  TMapDefinition md;
141 
142  setSize(
146 
147  // m_likelihoodCacheOutDated = true;
148  m_is_empty = true;
149 }
150 
151 void COccupancyGridMap3D::fill(float default_value)
152 {
153  const voxelType defValue = p2l(default_value);
154  m_grid.fill(defValue);
155  // m_likelihoodCacheOutDated = true;
156 }
157 
158 void COccupancyGridMap3D::updateCell(int x, int y, int z, float v)
159 {
160  if (m_grid.isOutOfBounds(x, y, z)) return;
161 
162  // Get the current contents of the cell:
163  auto* cp = m_grid.cellByIndex(x, y, z);
164  ASSERT_(cp != nullptr);
165  voxelType& theCell = *cp;
166 
167  // Compute the new Bayesian-fused value of the cell:
168  // The observation: will be >0 for free, <0 for occupied.
169  const voxelType obs = p2l(v);
170  if (obs > 0)
171  {
172  // Saturate
173  if (theCell > (CLogOddsGridMap3D<voxelType>::CELLTYPE_MAX - obs))
175  else
176  theCell += obs;
177  }
178  else
179  {
180  // Saturate
181  if (theCell < (CLogOddsGridMap3D<voxelType>::CELLTYPE_MIN - obs))
183  else
184  theCell += obs;
185  }
186 }
187 
189  const mrpt::maps::CMetricMap* otherMap2,
190  const mrpt::poses::CPose2D& otherMapPose_,
191  mrpt::tfest::TMatchingPairList& correspondences,
193  mrpt::maps::TMatchingExtraResults& extraResults) const
194 {
195  MRPT_START
196 
197  THROW_EXCEPTION("Implement me!");
198 
199  MRPT_END
200 }
201 
202 bool COccupancyGridMap3D::isEmpty() const { return m_is_empty; }
203 
205  const mrpt::maps::CMetricMap* otherMap,
206  const mrpt::poses::CPose3D& otherMapPose,
207  const TMatchingRatioParams& params) const
208 {
209  MRPT_UNUSED_PARAM(otherMap);
210  MRPT_UNUSED_PARAM(otherMapPose);
212  THROW_EXCEPTION("Implement me!");
213  return 0;
214 }
215 
217  mrpt::opengl::COctoMapVoxels& gl_obj) const
218 {
219  MRPT_START
220 
221  using mrpt::img::TColor;
222  using mrpt::img::TColorf;
223  using namespace mrpt::opengl;
224 
225  const size_t N = m_grid.getSizeX() * m_grid.getSizeY() * m_grid.getSizeZ();
226  const TColorf general_color = gl_obj.getColor();
227  const TColor general_color_u(
228  general_color.R * 255, general_color.G * 255, general_color.B * 255,
229  general_color.A * 255);
230 
231  gl_obj.clear();
232  gl_obj.resizeVoxelSets(2); // 2 sets of voxels: occupied & free
234 
235  gl_obj.showVoxels(
238  gl_obj.showVoxels(
240 
243 
244  const mrpt::math::TPoint3D bbmin(
246  const mrpt::math::TPoint3D bbmax(
248  const auto inv_dz = 1.0 / (bbmax.z - bbmin.z + 0.01);
249  const double L = 0.5 * m_grid.getResolutionZ();
250 
251  for (size_t cz = 0; cz < m_grid.getSizeZ(); cz++)
252  {
253  // voxel center coordinates:
254  const double z = m_grid.idx2z(cz) + m_grid.getResolutionZ() * 0.5;
255  for (size_t cy = 0; cy < m_grid.getSizeY(); cy++)
256  {
257  const double y = m_grid.idx2y(cy) + m_grid.getResolutionXY() * 0.5;
258  for (size_t cx = 0; cx < m_grid.getSizeX(); cx++)
259  {
260  const double x =
261  m_grid.idx2x(cx) + m_grid.getResolutionXY() * 0.5;
262  const float occ = 1.0f - this->getCellFreeness(cx, cy, cz);
263  const bool is_occupied = occ > 0.501f;
264  const bool is_free = occ < 0.499f;
265  if ((is_occupied && renderingOptions.generateOccupiedVoxels) ||
267  {
268  mrpt::img::TColor vx_color;
269  double coefc, coeft;
270  switch (gl_obj.getVisualizationMode())
271  {
272  case COctoMapVoxels::FIXED:
273  vx_color = general_color_u;
274  break;
275  case COctoMapVoxels::COLOR_FROM_HEIGHT:
276  coefc = 255 * inv_dz * (z - bbmin.z);
277  vx_color = TColor(
278  coefc * general_color.R,
279  coefc * general_color.G,
280  coefc * general_color.B,
281  255.0 * general_color.A);
282  break;
283 
284  case COctoMapVoxels::COLOR_FROM_OCCUPANCY:
285  coefc = 240 * (1 - occ) + 15;
286  vx_color = TColor(
287  coefc * general_color.R,
288  coefc * general_color.G,
289  coefc * general_color.B,
290  255.0 * general_color.A);
291  break;
292 
293  case COctoMapVoxels::TRANSPARENCY_FROM_OCCUPANCY:
294  coeft = 255 - 510 * (1 - occ);
295  if (coeft < 0)
296  {
297  coeft = 0;
298  }
299  vx_color = TColor(
300  255 * general_color.R, 255 * general_color.G,
301  255 * general_color.B, coeft);
302  break;
303 
304  case COctoMapVoxels::TRANS_AND_COLOR_FROM_OCCUPANCY:
305  coefc = 240 * (1 - occ) + 15;
306  vx_color = TColor(
307  coefc * general_color.R,
308  coefc * general_color.G,
309  coefc * general_color.B, 50);
310  break;
311 
312  case COctoMapVoxels::MIXED:
313  coefc = 255 * inv_dz * (z - bbmin.z);
314  coeft = 255 - 510 * (1 - occ);
315  if (coeft < 0)
316  {
317  coeft = 0;
318  }
319  vx_color = TColor(
320  coefc * general_color.R,
321  coefc * general_color.G,
322  coefc * general_color.B, coeft);
323  break;
324 
325  default:
326  THROW_EXCEPTION("Unknown coloring scheme!");
327  }
328 
329  const size_t vx_set =
330  is_occupied ? VOXEL_SET_OCCUPIED : VOXEL_SET_FREESPACE;
331 
332  gl_obj.push_back_Voxel(
333  vx_set,
335  mrpt::math::TPoint3D(x, y, z), 2 * L, vx_color));
336  }
337 
339  {
340  // Not leaf-nodes:
341  const mrpt::math::TPoint3D pt_min(x - L, y - L, z - L);
342  const mrpt::math::TPoint3D pt_max(x + L, y + L, z + L);
343  gl_obj.push_back_GridCube(
344  COctoMapVoxels::TGridCube(pt_min, pt_max));
345  }
346  }
347  }
348  } // end for each voxel
349 
350  // if we use transparency, sort cubes by "Z" as an approximation to
351  // far-to-near render ordering:
352  if (gl_obj.isCubeTransparencyEnabled()) gl_obj.sort_voxels_by_z();
353 
354  // Set bounding box:
355  gl_obj.setBoundingBox(bbmin, bbmax);
356 
357  MRPT_END
358 }
359 
361  mrpt::opengl::CSetOfObjects::Ptr& outObj) const
362 {
363  auto gl_obj = mrpt::opengl::COctoMapVoxels::Create();
364  this->getAsOctoMapVoxels(*gl_obj);
365  outObj->insert(gl_obj);
366 }
367 
368 uint8_t COccupancyGridMap3D::serializeGetVersion() const { return 0; }
370 {
371 // Version 2: Save OCCUPANCY_GRIDMAP_CELL_SIZE_8BITS/16BITS
372 #ifdef OCCUPANCY_GRIDMAP_CELL_SIZE_8BITS
373  out << uint8_t(8);
374 #else
375  out << uint8_t(16);
376 #endif
377 
378  // Save grid dimensions:
380 
381 #ifdef OCCUPANCY_GRIDMAP_CELL_SIZE_8BITS
382  out.WriteBuffer
383 #else
385 #endif
386  (m_grid.cellByIndex(0, 0, 0), sizeof(cell_t) * m_grid.getSizeX() *
387  m_grid.getSizeY() *
388  m_grid.getSizeZ());
389 
390  // insertionOptions:
395 
396  // Likelihood:
405 
406  out << genericMapParams;
407 
409 }
410 
412  mrpt::serialization::CArchive& in, uint8_t version)
413 {
414  m_is_empty = false;
415 
416  switch (version)
417  {
418  case 0:
419  {
420  uint8_t bitsPerCellStream;
421  in >> bitsPerCellStream;
422 
423 #ifdef OCCUPANCY_GRIDMAP_CELL_SIZE_8BITS
424  ASSERT_(bitsPerCellStream == 8);
425 #else
426  ASSERT_(bitsPerCellStream == 16);
427 #endif
428 
429  // Save grid dimensions:
431 
432 #ifdef OCCUPANCY_GRIDMAP_CELL_SIZE_8BITS
433  in.ReadBuffer
434 #else
435  in.ReadBufferFixEndianness
436 #endif
437  (m_grid.cellByIndex(0, 0, 0),
438  sizeof(cell_t) * m_grid.getSizeX() * m_grid.getSizeY() *
439  m_grid.getSizeZ());
440 
441  // insertionOptions:
447 
448  // Likelihood:
449  in.ReadAsAndCastTo<int32_t, TLikelihoodMethod>(
451 
459 
460  in >> genericMapParams;
461 
463  }
464  break;
465  default:
467  };
468 }
469 
472 {
473  const int8_t version = 0;
474  out << version;
475  out << generateGridLines << generateOccupiedVoxels << visibleOccupiedVoxels
476  << generateFreeVoxels << visibleFreeVoxels;
477 }
478 
481 {
482  int8_t version;
483  in >> version;
484  switch (version)
485  {
486  case 0:
487  {
488  in >> generateGridLines >> generateOccupiedVoxels >>
489  visibleOccupiedVoxels >> generateFreeVoxels >>
490  visibleFreeVoxels;
491  }
492  break;
493  default:
495  }
496 }
497 
499  const std::string& filNamePrefix) const
500 {
501  using namespace std::string_literals;
502  const auto fil = filNamePrefix + ".txt";
503  // todo
504 }
void showVoxels(unsigned int voxel_set, bool show)
Shows/hides the voxels (voxel_set is a 0-based index for the set of voxels to modify, e.g.
Virtual base for specifying the kind and parameters of one map (normally, to be inserted into mrpt::m...
Parameters for CMetricMap::compute3DMatchingRatio()
void reserveVoxels(const size_t set_index, const size_t nVoxels)
#define MRPT_START
Definition: exceptions.h:241
GLdouble GLdouble z
Definition: glext.h:3879
double x
X,Y,Z coordinates.
Definition: TPoint3D.h:83
void getAs3DObject(mrpt::opengl::CSetOfObjects::Ptr &outObj) const override
Returns a 3D object representing the map.
void loadFromConfigFile(const mrpt::config::CConfigFileBase &source, const std::string &section) override
This method load the options from a ".ini" file.
uint32_t LF_decimation
[LikelihoodField] The decimation of the points in a scan, default=1 == no decimation ...
void determineMatching2D(const mrpt::maps::CMetricMap *otherMap, const mrpt::poses::CPose2D &otherMapPose, mrpt::tfest::TMatchingPairList &correspondences, const TMatchingParams &params, TMatchingExtraResults &extraResults) const override
See docs in base class: in this class this always returns 0.
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:67
static CLogOddsGridMapLUT< COccupancyGridMap3D::voxelType > logodd_lut
#define IMPLEMENTS_SERIALIZABLE(class_name, base, NameSpace)
To be added to all CSerializable-classes implementation files.
void dyngridcommon_writeToStream(ARCHIVE &out) const
Serialization of all parameters, except the contents of each voxel (responsability of the derived cla...
void fill(const T &value)
Fills all the cells with the same value.
float getCellFreeness(unsigned int cx, unsigned int cy, unsigned int cz) const
Read the real valued [0,1] (0:occupied, 1:free) contents of a voxel, given its index.
static CLogOddsGridMapLUT< voxelType > & get_logodd_lut()
Lookup tables for log-odds.
uint16_t decimation
Decimation for insertPointCloud() or 2D range scans (Default: 1)
void setBoundingBox(const mrpt::math::TPoint3D &bb_min, const mrpt::math::TPoint3D &bb_max)
Manually changes the bounding box (normally the user doesn&#39;t need to call this)
void WriteBufferFixEndianness(const T *ptr, size_t ElementCount)
Writes a sequence of elemental datatypes, taking care of reordering their bytes from the running arch...
Definition: CArchive.h:133
void reserveGridCubes(const size_t nCubes)
void loadFromConfigFile_map_specific(const mrpt::config::CConfigFileBase &source, const std::string &sectionNamePrefix) override
Load all map-specific params.
void WriteAs(const TYPE_FROM_ACTUAL &value)
Definition: CArchive.h:162
float LF_stdHit
[LikelihoodField] The laser range "sigma" used in computations; Default value = 0.35
void WriteBuffer(const void *Buffer, size_t Count)
Writes a block of bytes to the stream from Buffer.
Definition: CArchive.cpp:49
coord_t idx2x(int cx) const
Transform a voxel index into a coordinate value of the voxel central point.
void loadFromConfigFile(const mrpt::config::CConfigFileBase &source, const std::string &section) override
This method load the options from a ".ini" file.
void clear()
Clears everything.
mrpt::maps::COccupancyGridMap3D::TInsertionOptions insertionOpts
Observations insertion options.
uint16_t decimation_3d_range
Specify the decimation of 3D range scans.
TInsertionOptions insertionOptions
With this struct options are provided to the observation insertion process.
GLdouble s
Definition: glext.h:3682
GLsizei GLsizei GLuint * obj
Definition: glext.h:4085
void writeToStream(mrpt::serialization::CArchive &out) const
Binary dump to stream.
bool LF_useSquareDist
[LikelihoodField] (Default:false) Use exp(dist^2/std^2) instead of exp(dist^2/std^2) ...
mrpt::maps::TMapGenericParams genericMapParams
Common params for all maps: These are automatically set in TMetricMapTypesRegistry::factoryMapObjectF...
#define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(__V)
For use in CSerializable implementations.
Definition: exceptions.h:97
A flexible renderer of voxels, typically from a 3D octo map (see mrpt::maps::COctoMap).
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:120
void push_back_GridCube(const TGridCube &c)
This class allows loading and storing values and vectors of different types from a configuration text...
Additional results from the determination of matchings between point clouds, etc., apart from the pairings themselves.
OccGridCellTraits::cellType cell_t
The type of cells.
virtual void resize(coord_t new_x_min, coord_t new_x_max, coord_t new_y_min, coord_t new_y_max, coord_t new_z_min, coord_t new_z_max, const T &defaultValueNewCells, coord_t additionalMarginMeters=2)
Changes the size of the grid, maintaining previous contents.
bool isOutOfBounds(const int cx, const int cy, const int cz) const
void updateCell(int cx_idx, int cy_idx, int cz_idx, float v)
Performs the Bayesian fusion of a new observation of a cell.
float maxDistanceInsertion
Largest distance at which voxels are updated (Default: 15 meters)
bool generateOccupiedVoxels
Generate voxels for the occupied volumes (Default=true)
void readFromStream(mrpt::serialization::CArchive &in)
Binary dump to stream.
A list of TMatchingPair.
Definition: TMatchingPair.h:70
int32_t rayTracing_decimation
[rayTracing] One out of "rayTracing_decimation" rays will be simulated and compared only: set to 1 to...
bool visibleOccupiedVoxels
Set occupied voxels visible (requires generateOccupiedVoxels=true) (Default=true) ...
float compute3DMatchingRatio(const mrpt::maps::CMetricMap *otherMap, const mrpt::poses::CPose3D &otherMapPose, const TMatchingRatioParams &params) const override
See docs in base class: in this class this always returns 0.
void internal_clear() override
Clear the map: It set all voxels to their default occupancy value (0.5), without changing the resolut...
constexpr auto sect
T * cellByIndex(unsigned int cx, unsigned int cy, unsigned int cz)
Returns a pointer to the contents of a voxel given by its voxel indexes, or nullptr if it is out of t...
bool m_is_empty
True upon construction; used by isEmpty()
void resizeGrid(const mrpt::math::TPoint3D &corner_min, const mrpt::math::TPoint3D &corner_max, float new_voxels_default_value=0.5f)
Change the size of gridmap, maintaining previous contents.
void serializeTo(mrpt::serialization::CArchive &out) const override
Pure virtual method for writing (serializing) to an abstract archive.
virtual void dumpToTextStream(std::ostream &out) const
This method should clearly display all the contents of the structure in textual form, sending it to a std::ostream.
__int32 int32_t
Definition: glext.h:3455
static Ptr Create(Args &&... args)
static mrpt::maps::CMetricMap * internal_CreateFromMapDefinition(const mrpt::maps::TMetricMapInitializer &def)
#define ASSERT_ABOVEEQ_(__A, __B)
Definition: exceptions.h:167
GLsizei const GLchar ** string
Definition: glext.h:4116
void getAsOctoMapVoxels(mrpt::opengl::COctoMapVoxels &gl_obj) const
mrpt::maps::COccupancyGridMap3D::TLikelihoodOptions likelihoodOpts
Probabilistic observation likelihood options.
The info of each grid block.
void push_back_Voxel(const size_t set_index, const TVoxel &v)
#define LOADABLEOPTS_DUMP_VAR(variableName, variableType)
Macro for dumping a variable to a stream, within the method "dumpToTextStream(out)" (Variable types a...
float maxFreenessUpdateCertainty
A value in the range [0.5,1] for updating a free voxel.
A 3D occupancy grid map with a regular, even distribution of voxels.
void serializeFrom(mrpt::serialization::CArchive &in, uint8_t serial_version) override
Pure virtual method for reading (deserializing) from an abstract archive.
#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...
bool visibleFreeVoxels
Set free voxels visible (requires generateFreeVoxels=true) (Default=true)
The info of each of the voxels.
const GLdouble * v
Definition: glext.h:3684
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
#define MAP_DEFINITION_REGISTER(_CLASSNAME_STRINGS, _CLASSNAME_WITH_NS)
Registers one map class into TMetricMapInitializer factory.
TLikelihoodMethod
The type for selecting a likelihood computation method.
Virtual base class for "archives": classes abstracting I/O streams.
Definition: CArchive.h:54
uint8_t serializeGetVersion() const override
Must return the current versioning number of the object.
Declares a virtual base class for all metric maps storage classes.
Definition: CMetricMap.h:52
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle...
Definition: CPose2D.h:39
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Definition: CPose3D.h:84
void resizeVoxelSets(const size_t nVoxelSets)
void fill(float default_value=0.5f)
Fills all the voxels with a default value.
bool isEmpty() const override
Returns true upon map construction or after calling clear(), the return changes to false upon success...
float maxOccupancyUpdateCertainty
A value in the range [0.5,1] used for updating voxel with a Bayesian approach (default 0...
bool generateGridLines
Generate grid lines for all octree nodes, useful to draw the "structure" of the octree, but computationally costly (Default: false)
#define ASSERT_ABOVE_(__A, __B)
Definition: exceptions.h:155
#define MRPT_END
Definition: exceptions.h:245
mrpt::img::TColorf getColor() const
Returns the object color property as a TColorf.
A RGB color - floats in the range [0,1].
Definition: TColor.h:77
visualization_mode_t getVisualizationMode() const
GLuint in
Definition: glext.h:7391
COccupancyGridMap3D(const mrpt::math::TPoint3D &corner_min={-5.0f, -5.0f, -5.0f}, const mrpt::math::TPoint3D &corner_max={5.0f, 5.0f, 5.0f}, float resolution=0.25f)
Constructor.
TLikelihoodMethod likelihoodMethod
The selected method to compute an observation likelihood.
The namespace for 3D scene representation and rendering.
Definition: CGlCanvasBase.h:15
GLsizei GLsizei GLchar * source
Definition: glext.h:4097
float min_x
See COccupancyGridMap3D::COccupancyGridMap3D.
virtual void setSize(const coord_t x_min, const coord_t x_max, const coord_t y_min, const coord_t y_max, const coord_t z_min, const coord_t z_max, const coord_t resolution_xy, const coord_t resolution_z_=-1.0, const T *fill_value=nullptr)
Changes the size of the grid, ERASING all previous contents.
GLenum GLint GLint y
Definition: glext.h:3542
A generic provider of log-odds grid-map maintainance functions.
static voxelType p2l(const float p)
Scales a real valued probability in [0,1] to an integer representation of: log(p)-log(1-p) in the val...
void saveMetricMapRepresentationToFile(const std::string &f) const override
This virtual method saves the map to a file "filNamePrefix"+< some_file_extension >...
#define ASSERT_BELOWEQ_(__A, __B)
Definition: exceptions.h:161
GLuint res
Definition: glext.h:7385
A RGB color - 8bit.
Definition: TColor.h:20
GLenum GLint x
Definition: glext.h:3542
Lightweight 3D point.
Definition: TPoint3D.h:90
float rayTracing_stdHit
[rayTracing] The laser range sigma.
Parameters for the determination of matchings between point clouds, etc.
void setSize(const mrpt::math::TPoint3D &corner_min, const mrpt::math::TPoint3D &corner_max, float resolution, float default_value=0.5f)
Change the size of gridmap, erasing all its previous contents.
bool isCubeTransparencyEnabled() const
GLenum const GLfloat * params
Definition: glext.h:3538
void dyngridcommon_readFromStream(ARCHIVE &in)
Serialization of all parameters, except the contents of each voxel (responsability of the derived cla...
OccGridCellTraits::cellType voxelType
The type of the map voxels:
void dumpToTextStream_map_specific(std::ostream &out) const override
One static instance of this struct should exist in any class implementing CLogOddsGridMap2D to hold t...
bool generateFreeVoxels
Generate voxels for the freespace (Default=true)
#define MRPT_UNUSED_PARAM(a)
Determines whether this is an X86 or AMD64 platform.
Definition: common.h:186



Page generated by Doxygen 1.8.14 for MRPT 1.9.9 Git: abb8b1a1e Fri Oct 18 14:19:12 2019 +0200 at vie oct 18 14:20:13 CEST 2019