Main MRPT website > C++ reference for MRPT 1.5.7
CRandomFieldGridMap3D.cpp
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 
10 #include "maps-precomp.h" // Precomp header
11 
14 #include <mrpt/utils/CTicTac.h>
16 
17 #include <mrpt/config.h>
18 
19 #if MRPT_HAS_VTK
20  #include <vtkStructuredGrid.h>
21  #include <vtkDoubleArray.h>
22  #include <vtkPointData.h>
23  #include <vtkVersion.h>
24  #include <vtkCellArray.h>
25  #include <vtkPoints.h>
26  #include <vtkXMLStructuredGridWriter.h>
27  #include <vtkStructuredGrid.h>
28  #include <vtkSmartPointer.h>
29 #endif
30 
31 using namespace mrpt;
32 using namespace mrpt::maps;
33 using namespace mrpt::utils;
34 using namespace std;
35 
37 
38 /*---------------------------------------------------------------
39  Constructor
40  ---------------------------------------------------------------*/
42  double x_min, double x_max,
43  double y_min, double y_max,
44  double z_min, double z_max,
45  double voxel_size,
46  bool call_initialize_now
47 ) :
48  CDynamicGrid3D<TRandomFieldVoxel>( x_min,x_max,y_min,y_max, z_min, z_max, voxel_size /*xy*/, voxel_size /*z*/ ),
49  COutputLogger("CRandomFieldGridMap3D")
50 {
51  if (call_initialize_now)
52  this->internal_initialize();
53 }
54 
55 /** Changes the size of the grid, erasing previous contents */
57  const double x_min, const double x_max,
58  const double y_min, const double y_max,
59  const double z_min, const double z_max,
60  const double resolution_xy, const double resolution_z,
61  const TRandomFieldVoxel* fill_value)
62 {
63  MRPT_START;
64 
65  CDynamicGrid3D<TRandomFieldVoxel>::setSize(x_min, x_max, y_min, y_max, z_min, z_max, resolution_xy, resolution_z, fill_value);
66  this->internal_initialize();
67 
68  MRPT_END;
69 }
70 
72  double new_x_min, double new_x_max,
73  double new_y_min, double new_y_max,
74  double new_z_min, double new_z_max,
75  const TRandomFieldVoxel& defaultValueNewCells, double additionalMarginMeters)
76 {
77  MRPT_START;
78 
79  CDynamicGrid3D<TRandomFieldVoxel>::resize(new_x_min, new_x_max, new_y_min, new_y_max, new_z_min, new_z_max, defaultValueNewCells, additionalMarginMeters);
80  this->internal_initialize(false);
81 
82  MRPT_END;
83 }
84 
86 {
88  internal_initialize();
89 }
90 
91 void CRandomFieldGridMap3D::internal_initialize(bool erase_prev_contents)
92 {
93  if (erase_prev_contents)
94  {
95  // Set the gridmap (m_map) to initial values:
96  TRandomFieldVoxel def(0, 0); // mean, std
97  fill(def);
98  }
99 
100  // Reset gmrf:
101  m_gmrf.setVerbosityLevel(this->getMinLoggingLevel());
102  if (erase_prev_contents)
103  {
104  m_gmrf.clear();
105  m_mrf_factors_activeObs.clear();
106  }
107  else
108  {
109  // Only remove priors, leave observations:
110  m_gmrf.clearAllConstraintsByType_Binary();
111  }
112  m_mrf_factors_priors.clear();
113 
114  // Initiating prior:
115  const size_t nodeCount = m_map.size();
116  ASSERT_EQUAL_(nodeCount, m_size_x*m_size_y*m_size_z);
117  ASSERT_EQUAL_(m_size_x_times_y, m_size_x*m_size_y);
118 
119  MRPT_LOG_DEBUG_STREAM( "[internal_initialize] Creating priors for GMRF with " << nodeCount << " nodes." << std::endl);
120  CTicTac tictac;
121  tictac.Tic();
122 
123  m_mrf_factors_activeObs.resize(nodeCount); // Alloc space for obs
124  m_gmrf.initialize(nodeCount);
125 
126  ConnectivityDescriptor * custom_connectivity = m_gmrf_connectivity.pointer(); // Use a raw ptr to avoid the cost in the inner loops
127 
128  size_t cx = 0, cy = 0, cz = 0;
129  for (size_t j = 0; j<nodeCount; j++)
130  {
131  // add factors between this node and:
132  // 1) the right node: j +1
133  // 2) the back node: j+m_size_x
134  // 3) the top node: j+m_size_x*m_size*y
135  //-------------------------------------------------
136  const size_t c_idx_to_check[3] = { cx,cy,cz };
137  const size_t c_idx_to_check_limits[3] = { m_size_x - 1,m_size_y - 1,m_size_z - 1 };
138  const size_t c_neighbor_idx_incr[3] = { 1,m_size_x,m_size_x_times_y };
139 
140  for (int dir = 0; dir < 3; dir++)
141  {
142  if (c_idx_to_check[dir] >= c_idx_to_check_limits[dir])
143  continue;
144 
145  const size_t i = j + c_neighbor_idx_incr[dir];
146  ASSERT_(i<nodeCount);
147 
148  double edge_lamdba = .0;
149  if (custom_connectivity != NULL)
150  {
151  const bool is_connected = custom_connectivity->getEdgeInformation(
152  this,
153  cx, cy,cz,
154  cx + (dir == 0 ? 1 : 0), cy + (dir == 1 ? 1 : 0), cz+ (dir==2 ? 1:0),
155  edge_lamdba
156  );
157  if (!is_connected)
158  continue;
159  }
160  else
161  {
162  edge_lamdba = insertionOptions.GMRF_lambdaPrior;
163  }
164 
165  TPriorFactorGMRF new_prior(*this);
166  new_prior.node_id_i = i;
167  new_prior.node_id_j = j;
168  new_prior.Lambda = edge_lamdba;
169 
170  m_mrf_factors_priors.push_back(new_prior);
171  m_gmrf.addConstraint(*m_mrf_factors_priors.rbegin()); // add to graph
172  }
173 
174  // Increment coordinates:
175  if (++cx >= m_size_x) {
176  cx = 0;
177  if (++cy >= m_size_y) {
178  cy = 0;
179  cz++;
180  }
181  }
182  } // end for "j"
183 
184  MRPT_LOG_DEBUG_STREAM( "[internal_initialize] Prior built in " << tictac.Tac() << " s\n" << std::endl);
185 }
186 
187 /*---------------------------------------------------------------
188  TInsertionOptions
189  ---------------------------------------------------------------*/
191  GMRF_lambdaPrior ( 0.01f ), // [GMRF model] The information (Lambda) of fixed map constraints
192  GMRF_skip_variance (false)
193 {
194 }
195 
197 {
198  out.printf("GMRF_lambdaPrior = %f\n", GMRF_lambdaPrior);
199  out.printf("GMRF_skip_variance = %s\n", GMRF_skip_variance ? "true":"false");
200 }
201 
203  const mrpt::utils::CConfigFileBase &iniFile,
204  const std::string &section)
205 {
206  GMRF_lambdaPrior = iniFile.read_double(section.c_str(), "GMRF_lambdaPrior", GMRF_lambdaPrior);
207  GMRF_skip_variance = iniFile.read_bool(section.c_str(),"GMRF_skip_variance", GMRF_skip_variance);
208 }
209 
210 /** Save the current estimated grid to a VTK file (.vts) as a "structured grid". \sa saveAsCSV */
212 {
213 MRPT_START;
214 #if MRPT_HAS_VTK
215 
216  vtkStructuredGrid *vtkGrid = vtkStructuredGrid::New();
217  this->getAsVtkStructuredGrid(vtkGrid);
218 
219  // Write file
220  vtkSmartPointer<vtkXMLStructuredGridWriter> writer = vtkSmartPointer<vtkXMLStructuredGridWriter>::New();
221  writer->SetFileName( fil.c_str() );
222 
223 #if VTK_MAJOR_VERSION <= 5
224  writer->SetInput(vtkGrid);
225 #else
226  writer->SetInputData(vtkGrid);
227 #endif
228 
229  int ret = writer->Write();
230 
231  vtkGrid->Delete();
232 
233  return ret==0;
234 #else
235  THROW_EXCEPTION("This method requires building MRPT against VTK!");
236 #endif
237 MRPT_END
238 }
239 
240 
241 bool mrpt::maps::CRandomFieldGridMap3D::saveAsCSV(const std::string & filName_mean, const std::string & filName_stddev) const
242 {
243  CFileOutputStream f_mean, f_stddev;
244 
245  if (!f_mean.open(filName_mean)) {
246  return false;
247  } else {
248  f_mean.printf("x coord, y coord, z coord, scalar\n");
249  }
250 
251  if (!filName_stddev.empty()) {
252  if (!f_stddev.open(filName_stddev)) {
253  return false;
254  } else {
255  f_mean.printf("x coord, y coord, z coord, scalar\n");
256  }
257  }
258 
259  const size_t nodeCount = m_map.size();
260  size_t cx = 0, cy = 0, cz = 0;
261  for (size_t j = 0; j<nodeCount; j++)
262  {
263  const double x = idx2x(cx), y = idx2y(cy), z = idx2z(cz);
264  const double mean_val = m_map[j].mean_value;
265  const double stddev_val = m_map[j].stddev_value;
266 
267  f_mean.printf("%f, %f, %f, %e\n", x, y, z, mean_val);
268 
269  if (f_stddev.is_open())
270  f_stddev.printf("%f, %f, %f, %e\n", x, y, z, stddev_val);
271 
272  // Increment coordinates:
273  if (++cx >= m_size_x) {
274  cx = 0;
275  if (++cy >= m_size_y) {
276  cy = 0;
277  cz++;
278  }
279  }
280  } // end for "j"
281 
282  return true;
283 }
284 
286 {
287  ASSERTMSG_(!m_mrf_factors_activeObs.empty(), "Cannot update a map with no observations!");
288 
289  Eigen::VectorXd x_incr, x_var;
291 
292  ASSERT_(size_t(m_map.size()) == size_t(x_incr.size()));
293  ASSERT_(insertionOptions.GMRF_skip_variance || size_t(m_map.size()) == size_t(x_var.size()));
294 
295  // Update Mean-Variance in the base grid class
296  for (size_t j = 0; j<m_map.size(); j++)
297  {
298  m_map[j].mean_value += x_incr[j];
299  m_map[j].stddev_value = insertionOptions.GMRF_skip_variance ? .0 : std::sqrt(x_var[j]);
300  }
301 }
302 
304 {
305  m_gmrf_connectivity = new_connectivity_descriptor;
306 }
307 
309  const double sensorReading, //!< [in] The value observed in the (x,y,z) position
310  const double sensorVariance, //!< [in] The variance of the sensor observation
311  const mrpt::math::TPoint3D & point, //!< [in] The (x,y,z) location
312  const TVoxelInterpolationMethod method, //!< [in] Voxel interpolation method: how many voxels will be affected by the reading
313  const bool update_map //!< [in] Run a global map update after inserting this observatin (algorithm-dependant)
314 )
315 {
316  MRPT_START;
317 
318  ASSERT_ABOVE_(sensorVariance, .0);
319  ASSERTMSG_(m_mrf_factors_activeObs.size()==m_map.size(), "Trying to insert observation in uninitialized map (!)");
320 
321  const size_t cell_idx = cellAbsIndexFromCXCYCZ(x2idx(point.x), y2idx(point.y), z2idx(point.z));
322  if (cell_idx == INVALID_VOXEL_IDX)
323  return false;
324 
325  TObservationGMRF new_obs(*this);
326  new_obs.node_id = cell_idx;
327  new_obs.obsValue = sensorReading;
328  new_obs.Lambda = 1.0 / sensorVariance;
329 
330  m_mrf_factors_activeObs[cell_idx].push_back(new_obs);
331  m_gmrf.addConstraint(*m_mrf_factors_activeObs[cell_idx].rbegin()); // add to graph
332 
333  if (update_map)
334  this->updateMapEstimation();
335 
336  return true;
337 
338  MRPT_END;
339 }
340 
342 {
343  if (version)
344  *version = 0;
345  else
346  {
348 
349  // To assure compatibility: The size of each cell:
350  uint32_t n = static_cast<uint32_t>(sizeof(TRandomFieldVoxel));
351  out << n;
352 
353  // Save the map contents:
354  n = static_cast<uint32_t>(m_map.size());
355  out << n;
356 
357  // Save the "m_map": This requires special handling for big endian systems:
358 #if MRPT_IS_BIG_ENDIAN
359  for (uint32_t i = 0; i<n; i++)
360  {
361  out << m_map[i].mean_value << m_map[i].stddev_value;
362  }
363 #else
364  // Little endian: just write all at once:
365  out.WriteBuffer(&m_map[0], sizeof(m_map[0])*m_map.size());
366 #endif
367 
370  }
371 }
372 
374 {
375  switch (version)
376  {
377  case 0:
378  {
380 
381  // To assure compatibility: The size of each cell:
382  uint32_t n;
383  in >> n;
384 
385  ASSERT_EQUAL_(n, static_cast<uint32_t>(sizeof(TRandomFieldVoxel)));
386  // Load the map contents:
387  in >> n;
388  m_map.resize(n);
389 
390  // Read the note in writeToStream()
391 #if MRPT_IS_BIG_ENDIAN
392  for (uint32_t i = 0; i<n; i++)
393  in >> m_map[i].mean_value >> m_map[i].stddev_value;
394 #else
395  // Little endian: just read all at once:
396  in.ReadBuffer(&m_map[0], sizeof(m_map[0])*m_map.size());
397 #endif
400 
401  } break;
402  default:
404  };
405 
406 }
407 
408 void CRandomFieldGridMap3D::getAsVtkStructuredGrid(vtkStructuredGrid* output, const std::string &label_mean, const std::string &label_stddev ) const
409 {
410  MRPT_START;
411 #if MRPT_HAS_VTK
412 
413  const size_t nx = this->getSizeX(), ny = this->getSizeY(), nz = this->getSizeZ();
414 
415  const int num_values = nx*ny*nz;
416 
417  vtkPoints* newPoints = vtkPoints::New();
418 
419  vtkDoubleArray* newData = vtkDoubleArray::New();
420  newData->SetNumberOfComponents(3);
421  newData->SetNumberOfTuples(num_values);
422 
423  vtkDoubleArray* mean_arr = vtkDoubleArray::New();
424  mean_arr->SetNumberOfComponents(1);
425  mean_arr->SetNumberOfTuples(num_values);
426 
427  vtkDoubleArray* std_arr = vtkDoubleArray::New();
428  std_arr->SetNumberOfComponents(1);
429  std_arr->SetNumberOfTuples(num_values);
430 
431  vtkIdType numtuples = newData->GetNumberOfTuples();
432 
433  {
434  size_t cx = 0, cy = 0, cz = 0;
435  for (vtkIdType cc = 0; cc < numtuples; cc++)
436  {
437  const double x = idx2x(cx), y = idx2y(cy), z = idx2z(cz);
438 
439  newData->SetComponent(cc, 0, x);
440  newData->SetComponent(cc, 1, y);
441  newData->SetComponent(cc, 2, z);
442 
443  mean_arr->SetComponent(cc, 0, m_map[cc].mean_value);
444  std_arr->SetComponent(cc, 0, m_map[cc].stddev_value);
445 
446  // Increment coordinates:
447  if (++cx >= m_size_x) {
448  cx = 0;
449  if (++cy >= m_size_y) {
450  cy = 0;
451  cz++;
452  }
453  }
454  }
455  ASSERT_( size_t( m_map.size() ) == size_t( numtuples ) );
456  }
457 
458  newPoints->SetData(newData);
459  newData->Delete();
460 
461  output->SetExtent(0,nx-1, 0, ny-1, 0,nz-1);
462  output->SetPoints(newPoints);
463  newPoints->Delete();
464 
465  mean_arr->SetName(label_mean.c_str());
466  std_arr->SetName(label_stddev.c_str());
467  output->GetPointData()->AddArray(mean_arr);
468  output->GetPointData()->AddArray(std_arr);
469 
470  mean_arr->Delete();
471  std_arr->Delete();
472 
473 #else
474  THROW_EXCEPTION("This method requires building MRPT against VTK!");
475 #endif // VTK
476  MRPT_END;
477 }
478 
479 // ============ TObservationGMRF ===========
481 {
482  return m_parent->m_map[this->node_id].mean_value - this->obsValue;
483 }
485 {
486  return this->Lambda;
487 }
489 {
490  dr_dx = 1.0;
491 }
492 // ============ TPriorFactorGMRF ===========
494 {
495  return m_parent->m_map[this->node_id_i].mean_value - m_parent->m_map[this->node_id_j].mean_value;
496 }
498 {
499  return this->Lambda;
500 }
501 void CRandomFieldGridMap3D::TPriorFactorGMRF::evalJacobian(double &dr_dx_i, double &dr_dx_j) const
502 {
503  dr_dx_i = +1.0;
504  dr_dx_j = -1.0;
505 }
#define ASSERT_EQUAL_(__A, __B)
bool GMRF_skip_variance
(Default:false) Skip the computation of the variance, just compute the mean
void dumpToTextStream(mrpt::utils::CStream &out) const
See utils::CLoadableOptions.
bool read_bool(const std::string &section, const std::string &name, bool defaultValue, bool failIfNotFound=false) const
Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL.
Definition: zip.h:16
GLdouble GLdouble z
Definition: glext.h:3734
EIGEN_STRONG_INLINE void fill(const Scalar v)
Definition: eigen_plugins.h:38
#define ASSERT_ABOVE_(__A, __B)
mrpt::graphs::ScalarFactorGraph m_gmrf
double evaluateResidual() const MRPT_OVERRIDE
Return the residual/error of this observation.
std::vector< TRandomFieldVoxel > m_map
The cells.
The virtual base class which provides a unified interface for all persistent objects in MRPT...
Definition: CSerializable.h:39
size_t cellAbsIndexFromCXCYCZ(const int cx, const int cy, const int cz) const
Gets the absolute index of a voxel in the linear container m_map[] from its cx,cy,cz indices, or -1 if out of map bounds (in any dimension).
The contents of each voxel in a CRandomFieldGridMap3D map.
void writeToStream(mrpt::utils::CStream &out, int *getVersion) const
Introduces a pure virtual method responsible for writing to a CStream.
#define IMPLEMENTS_SERIALIZABLE(class_name, base, NameSpace)
This must be inserted in all CSerializable classes implementation files.
virtual bool getEdgeInformation(const CRandomFieldGridMap3D *parent, size_t icx, size_t icy, size_t icz, size_t jcx, size_t jcy, size_t jcz, double &out_edge_information)=0
Implement the check of whether node i=(icx,icy,icz) is connected with node j=(jcx,jcy,jcy).
double GMRF_lambdaPrior
The information (Lambda) of fixed map constraints.
#define THROW_EXCEPTION(msg)
GLenum GLsizei n
Definition: glext.h:4618
void WriteBuffer(const void *Buffer, size_t Count)
Writes a block of bytes to the stream from Buffer.
Definition: CStream.cpp:67
stlplus::smart_ptr< ConnectivityDescriptor > ConnectivityDescriptorPtr
void internal_initialize(bool erase_prev_contents=true)
Internal: called called after each change of resolution, size, etc.
bool open(const std::string &fileName, bool append=false)
Open the given file for write.
virtual void resize(double new_x_min, double new_x_max, double new_y_min, double new_y_max, double new_z_min, double new_z_max, const TRandomFieldVoxel &defaultValueNewvoxels, double additionalMarginMeters=2.0) MRPT_OVERRIDE
Changes the size of the grid, maintaining previous contents.
void dyngridcommon_writeToStream(mrpt::utils::CStream &out) const
Serialization of all parameters, except the contents of each voxel (responsability of the derived cla...
virtual void clear()
Erase the contents of all the cells, setting them to their default values (default ctor)...
STL namespace.
void clear() MRPT_OVERRIDE
Erases all added observations and start again with an empty gridmap.
double z
X,Y,Z coordinates.
A 3D rectangular grid of dynamic size which stores any kind of data at each voxel.
void Tic()
Starts the stopwatch.
Definition: CTicTac.cpp:77
GLfloat GLfloat nz
Definition: glext.h:5581
This class allows loading and storing values and vectors of different types from a configuration text...
ConnectivityDescriptorPtr m_gmrf_connectivity
Empty: default.
void loadFromConfigFile(const mrpt::utils::CConfigFileBase &source, const std::string &section)
See utils::CLoadableOptions.
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
Definition: CStream.h:38
#define MRPT_END
This CStream derived class allow using a file as a write-only, binary stream.
double Lambda
"Information" of the observation (=inverse of the variance)
#define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(__V)
For use in CSerializable implementations.
std::vector< std::deque< TObservationGMRF > > m_mrf_factors_activeObs
Vector with the active observations and their respective Information, for each map cell...
This class implements a high-performance stopwatch.
Definition: CTicTac.h:24
double Lambda
"Information" of the observation (=inverse of the variance)
double getInformation() const MRPT_OVERRIDE
Return the inverse of the variance of this constraint.
EIGEN_STRONG_INLINE void setSize(size_t row, size_t col)
Changes the size of matrix, maintaining its previous content as possible and padding with zeros where...
int version
Definition: mrpt_jpeglib.h:898
void evalJacobian(double &dr_dx) const MRPT_OVERRIDE
Returns the derivative of the residual wrt the node value.
GLsizei const GLchar ** string
Definition: glext.h:3919
void addConstraint(const UnaryFactorVirtualBase &listOfConstraints)
Insert constraints into the GMRF problem.
bool saveAsCSV(const std::string &filName_mean, const std::string &filName_stddev=std::string()) const
Save the current estimated mean values to a CSV file (compatible with Paraview) with fields x y z mea...
#define MRPT_START
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
CRandomFieldGridMap3D represents a 3D regular grid where each voxel is associated one real-valued pro...
GLfloat GLfloat GLfloat GLfloat nx
Definition: glext.h:5583
int x2idx(double x) const
Transform a coordinate values into voxel indexes.
double idx2x(int cx) const
Transform a voxel index into a coordinate value of the voxel central point.
virtual void setSize(const double x_min, const double x_max, const double y_min, const double y_max, const double z_min, const double z_max, const double resolution_xy, const double resolution_z=-1.0, const TRandomFieldVoxel *fill_value=NULL) MRPT_OVERRIDE
Changes the size of the grid, erasing previous contents.If resolution_z<0, the same resolution will b...
double read_double(const std::string &section, const std::string &name, double defaultValue, bool failIfNotFound=false) const
void setVoxelsConnectivity(const ConnectivityDescriptorPtr &new_connectivity_descriptor)
Sets a custom object to define the connectivity between voxels.
void getAsVtkStructuredGrid(vtkStructuredGrid *output, const std::string &label_mean=std::string("mean"), const std::string &label_stddev=std::string("stddev")) const
Returns the 3D grid contents as an VTK grid.
void dyngridcommon_readFromStream(mrpt::utils::CStream &in)
Serialization of all parameters, except the contents of each voxel (responsability of the derived cla...
void readFromStream(mrpt::utils::CStream &in, int version)
Introduces a pure virtual method responsible for loading from a CStream This can not be used directly...
bool saveAsVtkStructuredGrid(const std::string &fil) const
Save the current estimated grid to a VTK file (.vts) as a "structured grid".
GLuint in
Definition: glext.h:6301
double Tac()
Stops the stopwatch.
Definition: CTicTac.cpp:92
#define ASSERT_(f)
void evalJacobian(double &dr_dx_i, double &dr_dx_j) const MRPT_OVERRIDE
Returns the derivative of the residual wrt the node values.
void updateEstimation(Eigen::VectorXd &solved_x_inc, Eigen::VectorXd *solved_variances=NULL)
GLenum GLint GLint y
Definition: glext.h:3516
double getInformation() const MRPT_OVERRIDE
Return the inverse of the variance of this constraint.
double evaluateResidual() const MRPT_OVERRIDE
Return the residual/error of this observation.
bool insertIndividualReading(const double sensorReading, const double sensorVariance, const mrpt::math::TPoint3D &point, const TVoxelInterpolationMethod method, const bool update_map)
Direct update of the map with a reading in a given position of the map.
void updateMapEstimation()
Run the method-specific procedure required to ensure that the mean & variances are up-to-date with al...
GLenum GLint x
Definition: glext.h:3516
GLfloat ny
Definition: glext.h:5581
Lightweight 3D point.
bool is_open()
Returns true if the file was open without errors.
unsigned __int32 uint32_t
Definition: rptypes.h:49
#define MRPT_LOG_DEBUG_STREAM(__CONTENTS)
#define ASSERTMSG_(f, __ERROR_MSG)
virtual int printf(const char *fmt,...) MRPT_printf_format_check(2
Writes a string to the stream in a textual form.
Definition: CStream.cpp:507
Base class for user-supplied objects capable of describing voxels connectivity, used to build prior f...



Page generated by Doxygen 1.8.14 for MRPT 1.5.7 Git: 8277875f6 Mon Jun 11 02:47:32 2018 +0200 at lun oct 28 01:50:49 CET 2019