Main MRPT website > C++ reference for MRPT 1.5.6
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
size_t ReadBuffer(void *Buffer, size_t Count)
Reads a block of bytes from the stream into Buffer On any error, or if ZERO bytes are read...
Definition: CStream.cpp:45
GLint GLint GLint GLint GLint GLint y
Definition: glew.h:1166
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).
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
The contents of each voxel in a CRandomFieldGridMap3D map.
bool saveAsVtkStructuredGrid(const std::string &fil) const
Save the current estimated grid to a VTK file (.vts) as a "structured grid".
#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)
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.
GLhalf GLhalf nz
Definition: glew.h:8038
virtual void clear()
Erase the contents of all the cells, setting them to their default values (default ctor)...
void clear() MRPT_OVERRIDE
Erases all added observations and start again with an empty gridmap.
void dumpToTextStream(mrpt::utils::CStream &out) const
See utils::CLoadableOptions.
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
GLhalf ny
Definition: glew.h:8038
GLuint in
Definition: glew.h:7146
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.
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
GLsizei n
Definition: glew.h:5051
#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)
GLfloat GLfloat GLfloat GLfloat nx
Definition: glew.h:10079
GLint GLint GLint GLint GLint x
Definition: glew.h:1166
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
double read_double(const std::string &section, const std::string &name, double defaultValue, bool failIfNotFound=false) const
void evalJacobian(double &dr_dx) const MRPT_OVERRIDE
Returns the derivative of the residual wrt the node value.
void addConstraint(const UnaryFactorVirtualBase &listOfConstraints)
Insert constraints into the GMRF problem.
#define MRPT_START
GLdouble GLdouble z
Definition: glew.h:1464
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...
GLsizei const GLcharARB ** string
Definition: glew.h:3293
CRandomFieldGridMap3D represents a 3D regular grid where each voxel is associated one real-valued pro...
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...
void setVoxelsConnectivity(const ConnectivityDescriptorPtr &new_connectivity_descriptor)
Sets a custom object to define the connectivity between voxels.
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...
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.
double idx2x(int cx) const
Transform a voxel index into a coordinate value of the voxel central point.
void updateEstimation(Eigen::VectorXd &solved_x_inc, Eigen::VectorXd *solved_variances=NULL)
void dyngridcommon_writeToStream(mrpt::utils::CStream &out) const
Serialization of all parameters, except the contents of each voxel (responsability of the derived cla...
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...
bool read_bool(const std::string &section, const std::string &name, bool defaultValue, bool failIfNotFound=false) const
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)
void writeToStream(mrpt::utils::CStream &out, int *getVersion) const
Introduces a pure virtual method responsible for writing to a CStream.
int x2idx(double x) const
Transform a coordinate values into voxel indexes.
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...
GLdouble GLdouble GLdouble GLdouble GLdouble GLdouble f
Definition: glew.h:5092



Page generated by Doxygen 1.8.6 for MRPT 1.5.6 Git: 4c65e84 Tue Apr 24 08:18:17 2018 +0200 at mar abr 24 08:26:17 CEST 2018