Main MRPT website > C++ reference for MRPT 1.9.9
CWirelessPowerGridMap2D.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-2018, 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/system/os.h>
15 #include <mrpt/core/round.h>
16 #include <mrpt/system/CTicTac.h>
17 #include <mrpt/img/color_maps.h>
20 
21 using namespace mrpt;
22 using namespace mrpt::maps;
23 using namespace mrpt::obs;
24 using namespace mrpt::poses;
25 using namespace std;
26 
27 // =========== Begin of Map definition ============
29  "CWirelessPowerGridMap2D,wifiGrid", mrpt::maps::CWirelessPowerGridMap2D)
30 
32  : min_x(-2),
33  max_x(2),
34  min_y(-2),
35  max_y(2),
36  resolution(0.10f),
37  mapType(CWirelessPowerGridMap2D::mrKernelDM)
38 {
39 }
40 
43  const std::string& sectionNamePrefix)
44 {
45  // [<sectionNamePrefix>+"_creationOpts"]
46  const std::string sSectCreation =
47  sectionNamePrefix + string("_creationOpts");
48  MRPT_LOAD_CONFIG_VAR(min_x, double, source, sSectCreation);
49  MRPT_LOAD_CONFIG_VAR(max_x, double, source, sSectCreation);
50  MRPT_LOAD_CONFIG_VAR(min_y, double, source, sSectCreation);
51  MRPT_LOAD_CONFIG_VAR(max_y, double, source, sSectCreation);
52  MRPT_LOAD_CONFIG_VAR(resolution, double, source, sSectCreation);
54  sSectCreation, "mapType", mapType);
55 
56  insertionOpts.loadFromConfigFile(
57  source, sectionNamePrefix + string("_insertOpts"));
58 }
59 
61  std::ostream& out) const
62 {
63  out << mrpt::format(
64  "MAP TYPE = %s\n",
67  .c_str());
68  LOADABLEOPTS_DUMP_VAR(min_x, double);
69  LOADABLEOPTS_DUMP_VAR(max_x, double);
70  LOADABLEOPTS_DUMP_VAR(min_y, double);
71  LOADABLEOPTS_DUMP_VAR(max_y, double);
72  LOADABLEOPTS_DUMP_VAR(resolution, double);
73 
74  this->insertionOpts.dumpToTextStream(out);
75 }
76 
80 {
82  *dynamic_cast<const CWirelessPowerGridMap2D::TMapDefinition*>(&_def);
84  def.mapType, def.min_x, def.max_x, def.min_y, def.max_y,
85  def.resolution);
86  obj->insertionOptions = def.insertionOpts;
87  return obj;
88 }
89 // =========== End of Map definition Block =========
90 
93 
94 /*---------------------------------------------------------------
95  Constructor
96  ---------------------------------------------------------------*/
98  TMapRepresentation mapType, double x_min, double x_max, double y_min,
99  double y_max, double resolution)
100  : CRandomFieldGridMap2D(mapType, x_min, x_max, y_min, y_max, resolution),
101  insertionOptions()
102 {
103  // Set the grid to initial values (and adjusts the KF covariance matrix!)
104  // Also, calling clear() is mandatory to end initialization of our base
105  // class (read note in CRandomFieldGridMap2D::CRandomFieldGridMap2D)
107 }
108 
109 CWirelessPowerGridMap2D::~CWirelessPowerGridMap2D() {}
110 /*---------------------------------------------------------------
111  clear
112  ---------------------------------------------------------------*/
114 {
115  // Just do the generic clear:
117 
118  // Anything else special for this derived class?
119  // ...
120 }
121 
122 /*---------------------------------------------------------------
123  insertObservation
124  ---------------------------------------------------------------*/
126  const CObservation* obs, const CPose3D* robotPose)
127 {
128  MRPT_START
129 
130  CPose2D robotPose2D;
131  CPose3D robotPose3D;
132 
133  if (robotPose)
134  {
135  robotPose2D = CPose2D(*robotPose);
136  robotPose3D = (*robotPose);
137  }
138  else
139  {
140  // Default values are (0,0,0)
141  }
142 
144  {
145  /********************************************************************
146  OBSERVATION TYPE: CObservationWirelessPower
147  ********************************************************************/
148  const CObservationWirelessPower* o =
149  static_cast<const CObservationWirelessPower*>(obs);
150  float sensorReading;
151 
152  // Compute the 3D sensor pose in world coordinates:
153  CPose2D sensorPose = CPose2D(robotPose3D + o->sensorPoseOnRobot);
154 
155  sensorReading = o->power;
156 
157  // Normalization:
158  sensorReading = (sensorReading - insertionOptions.R_min) /
160 
161  // Update the gross estimates of mean/vars for the whole reading history
162  // (see IROS2009 paper):
164  (sensorReading +
168  (square(sensorReading - m_average_normreadings_mean) +
172 
173  // Finally, do the actual map update with that value:
175  sensorReading,
176  mrpt::math::TPoint2D(sensorPose.x(), sensorPose.y()));
177 
178  return true; // Done!
179 
180  } // end if "CObservationWirelessPower"
181 
182  return false;
183 
184  MRPT_END
185 }
186 
187 /*---------------------------------------------------------------
188  computeObservationLikelihood
189  ---------------------------------------------------------------*/
191  const CObservation* obs, const CPose3D& takenFrom)
192 {
193  MRPT_UNUSED_PARAM(obs);
194  MRPT_UNUSED_PARAM(takenFrom);
195 
196  THROW_EXCEPTION("Not implemented yet!");
197 }
198 
202 {
204 
205  // To ensure compatibility: The size of each cell:
206  uint32_t n = static_cast<uint32_t>(sizeof(TRandomFieldCell));
207  out << n;
208 
209  // Save the map contents:
210  n = static_cast<uint32_t>(m_map.size());
211  out << n;
212 
213 // Save the "m_map": This requires special handling for big endian systems:
214 #if MRPT_IS_BIG_ENDIAN
215  for (uint32_t i = 0; i < n; i++)
216  {
217  out << m_map[i].kf_mean << m_map[i].dm_mean << m_map[i].dmv_var_mean;
218  }
219 #else
220  // Little endian: just write all at once:
221  out.WriteBuffer(
222  &m_map[0],
223  sizeof(m_map[0]) * m_map.size()); // TODO: Do this endianness safe!!
224 #endif
225 
226  // Version 1: Save the insertion options:
227  out << uint8_t(m_mapType) << m_cov << m_stackedCov;
228 
235 
236  // New in v3:
239 
240  out << genericMapParams; // v4
241 }
242 
243 // Aux struct used below (must be at global scope for STL):
245 {
246  float mean, std;
247  float w, wr;
248 };
249 
252 {
253  switch (version)
254  {
255  case 0:
256  case 1:
257  case 2:
258  case 3:
259  case 4:
260  case 5:
261  {
262  dyngridcommon_readFromStream(in, version < 5);
263 
264  // To ensure compatibility: The size of each cell:
265  uint32_t n;
266  in >> n;
267 
268  if (version < 2)
269  { // Converter from old versions <=1
270  ASSERT_(
271  n == static_cast<uint32_t>(sizeof(TOldCellTypeInVersion1)));
272  // Load the map contents in an aux struct:
273  in >> n;
274  vector<TOldCellTypeInVersion1> old_map(n);
275  in.ReadBuffer(&old_map[0], sizeof(old_map[0]) * old_map.size());
276 
277  // Convert to newer format:
278  m_map.resize(n);
279  for (size_t k = 0; k < n; k++)
280  {
281  m_map[k].kf_mean =
282  (old_map[k].w != 0) ? old_map[k].wr : old_map[k].mean;
283  m_map[k].kf_std =
284  (old_map[k].w != 0) ? old_map[k].w : old_map[k].std;
285  }
286  }
287  else
288  {
290  n, static_cast<uint32_t>(sizeof(TRandomFieldCell)));
291  // Load the map contents:
292  in >> n;
293  m_map.resize(n);
294 
295 // Read the note in writeToStream()
296 #if MRPT_IS_BIG_ENDIAN
297  for (uint32_t i = 0; i < n; i++)
298  in >> m_map[i].kf_mean >> m_map[i].dm_mean >>
299  m_map[i].dmv_var_mean;
300 #else
301  // Little endian: just read all at once:
302  in.ReadBuffer(&m_map[0], sizeof(m_map[0]) * m_map.size());
303 #endif
304  }
305 
306  // Version 1: Insertion options:
307  if (version >= 1)
308  {
309  uint8_t i;
310  in >> i;
312 
313  in >> m_cov >> m_stackedCov;
314 
322  }
323 
324  if (version >= 3)
325  {
326  uint64_t N;
330  }
331 
332  if (version >= 4) in >> genericMapParams;
333 
335  }
336  break;
337  default:
339  };
340 }
341 
344  std::ostream& out) const
345 {
346  out << mrpt::format(
347  "\n----------- [CWirelessPowerGridMap2D::TInsertionOptions] "
348  "------------ \n\n");
349  internal_dumpToTextStream_common(
350  out); // Common params to all random fields maps:
351 
352  out << mrpt::format("\n");
353 }
354 
355 /*---------------------------------------------------------------
356  loadFromConfigFile
357  ---------------------------------------------------------------*/
359  const mrpt::config::CConfigFileBase& iniFile, const std::string& section)
360 {
361  // Common data fields for all random fields maps:
362  internal_loadFromConfigFile_common(iniFile, section);
363 }
364 
365 /*---------------------------------------------------------------
366  getAs3DObject
367 ---------------------------------------------------------------*/
369  mrpt::opengl::CSetOfObjects::Ptr& outObj) const
370 {
371  MRPT_START
374  MRPT_END
375 }
n
GLenum GLsizei n
Definition: glext.h:5074
os.h
mrpt::maps::CRandomFieldGridMap2D::getAs3DObject
virtual void getAs3DObject(mrpt::opengl::CSetOfObjects::Ptr &outObj) const override
Returns a 3D object representing the map (mean)
Definition: CRandomFieldGridMap2D.cpp:1615
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::mapType
mrpt::maps::CWirelessPowerGridMap2D::TMapRepresentation mapType
The kind of map representation (see CWirelessPowerGridMap2D::CWirelessPowerGridMap2D)
Definition: CWirelessPowerGridMap2D.h:90
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::dumpToTextStream_map_specific
void dumpToTextStream_map_specific(std::ostream &out) const override
Definition: CWirelessPowerGridMap2D.cpp:60
mrpt::maps::CWirelessPowerGridMap2D::internal_CreateFromMapDefinition
static mrpt::maps::CMetricMap * internal_CreateFromMapDefinition(const mrpt::maps::TMetricMapInitializer &def)
Definition: CWirelessPowerGridMap2D.cpp:78
mrpt::maps::CWirelessPowerGridMap2D::insertionOptions
mrpt::maps::CWirelessPowerGridMap2D::TInsertionOptions insertionOptions
mrpt::maps::CWirelessPowerGridMap2D::internal_clear
void internal_clear() override
Erase all the contents of the map.
Definition: CWirelessPowerGridMap2D.cpp:113
mrpt::maps::CRandomFieldGridMap2D::m_mapType
TMapRepresentation m_mapType
The map representation type of this map, as passed in the constructor.
Definition: CRandomFieldGridMap2D.h:500
mrpt::obs::CObservationWirelessPower
This represents a measurement of the wireless strength perceived by the robot.
Definition: CObservationWirelessPower.h:29
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::loadFromConfigFile_map_specific
void loadFromConfigFile_map_specific(const mrpt::config::CConfigFileBase &source, const std::string &sectionNamePrefix) override
Load all map-specific params.
Definition: CWirelessPowerGridMap2D.cpp:41
mrpt::maps::CWirelessPowerGridMap2D::TInsertionOptions::dumpToTextStream
void dumpToTextStream(std::ostream &out) const override
This method should clearly display all the contents of the structure in textual form,...
Definition: CWirelessPowerGridMap2D.cpp:343
mrpt::containers::clear
void clear()
Clear the contents of this container.
Definition: ts_hash_map.h:188
mrpt::maps::CWirelessPowerGridMap2D::TInsertionOptions::TInsertionOptions
TInsertionOptions()
Default values loader.
Definition: CWirelessPowerGridMap2D.cpp:342
ASSERT_EQUAL_
#define ASSERT_EQUAL_(__A, __B)
Assert comparing two values, reporting their actual values upon failure.
Definition: exceptions.h:153
mrpt::maps::CRandomFieldGridMap2D::m_stackedCov
mrpt::math::CMatrixD m_stackedCov
The compressed band diagonal matrix for the KF2 implementation.
Definition: CRandomFieldGridMap2D.h:512
mrpt::maps::CWirelessPowerGridMap2D::CWirelessPowerGridMap2D
CWirelessPowerGridMap2D(TMapRepresentation mapType=mrKernelDM, double x_min=-2, double x_max=2, double y_min=-2, double y_max=2, double resolution=0.1)
Constructor.
MRPT_LOAD_CONFIG_VAR
#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...
Definition: config/CConfigFileBase.h:282
mrpt::maps::TMapGenericParams::enableSaveAs3DObject
bool enableSaveAs3DObject
(Default=true) If false, calling CMetricMap::getAs3DObject() will have no effects
Definition: metric_map_types.h:95
CSetOfObjects.h
CWirelessPowerGridMap2D.h
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::KF_observationModelNoise
float KF_observationModelNoise
The sensor model noise (in normalized concentration units).
Definition: CRandomFieldGridMap2D.h:278
color_maps.h
mrpt::maps::CRandomFieldGridMap2D::m_average_normreadings_var
double m_average_normreadings_var
Definition: CRandomFieldGridMap2D.h:520
MAP_DEFINITION_REGISTER
#define MAP_DEFINITION_REGISTER(_CLASSNAME_STRINGS, _CLASSNAME_WITH_NS)
Registers one map class into TMetricMapInitializer factory.
Definition: TMetricMapTypesRegistry.h:91
obj
GLsizei GLsizei GLuint * obj
Definition: glext.h:4070
MRPT_UNUSED_PARAM
#define MRPT_UNUSED_PARAM(a)
Determines whether this is an X86 or AMD64 platform.
Definition: common.h:186
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::R_min
float R_min
Limits for normalization of sensor readings.
Definition: CRandomFieldGridMap2D.h:262
CObservationWirelessPower.h
mrpt::maps::CRandomFieldGridMap2D::m_hasToRecoverMeanAndCov
bool m_hasToRecoverMeanAndCov
Only for the KF2 implementation.
Definition: CRandomFieldGridMap2D.h:514
mrpt::maps::CRandomFieldGridMap2D::insertIndividualReading
void insertIndividualReading(const double sensorReading, const mrpt::math::TPoint2D &point, const bool update_map=true, const bool time_invariant=true, const double reading_stddev=.0)
Direct update of the map with a reading in a given position of the map, using the appropriate method ...
Definition: CRandomFieldGridMap2D.cpp:2502
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CKalmanFilterCapable.h:30
w
GLubyte GLubyte GLubyte GLubyte w
Definition: glext.h:4178
mrpt::maps::TMetricMapInitializer
Virtual base for specifying the kind and parameters of one map (normally, to be inserted into mrpt::m...
Definition: TMetricMapInitializer.h:34
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::insertionOpts
mrpt::maps::CWirelessPowerGridMap2D::TInsertionOptions insertionOpts
Definition: CWirelessPowerGridMap2D.h:91
uint8_t
unsigned char uint8_t
Definition: rptypes.h:41
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::max_y
double max_y
Definition: CWirelessPowerGridMap2D.h:87
mrpt::maps::CMetricMap::genericMapParams
TMapGenericParams genericMapParams
Common params to all maps.
Definition: CMetricMap.h:282
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::KF_covSigma
float KF_covSigma
The "sigma" for the initial covariance value between cells (in meters).
Definition: CRandomFieldGridMap2D.h:272
THROW_EXCEPTION
#define THROW_EXCEPTION(msg)
Definition: exceptions.h:41
ASSERT_
#define ASSERT_(f)
Defines an assertion mechanism.
Definition: exceptions.h:113
mrpt::maps::CWirelessPowerGridMap2D::serializeGetVersion
uint8_t serializeGetVersion() const override
Must return the current versioning number of the object.
Definition: CWirelessPowerGridMap2D.cpp:199
mrpt::square
T square(const T x)
Inline function for the square of a number.
Definition: core/include/mrpt/core/bits_math.h:18
mrpt::poses
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
Definition: CHierarchicalMapMHPartition.h:25
mrpt::containers::CDynamicGrid< TRandomFieldCell >::m_map
std::vector< TRandomFieldCell > m_map
The cells
Definition: CDynamicGrid.h:42
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::KF_initialCellStd
float KF_initialCellStd
The initial standard deviation of each cell's concentration (will be stored both at each cell's struc...
Definition: CRandomFieldGridMap2D.h:276
mrpt::obs
This namespace contains representation of robot actions and observations.
Definition: CParticleFilter.h:17
mrpt::serialization::CArchive
Virtual base class for "archives": classes abstracting I/O streams.
Definition: CArchive.h:48
source
GLsizei GLsizei GLchar * source
Definition: glext.h:4082
mrpt::maps::CWirelessPowerGridMap2D
CWirelessPowerGridMap2D represents a PDF of wifi concentrations over a 2D area.
Definition: CWirelessPowerGridMap2D.h:35
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::sigma
float sigma
The sigma of the "Parzen"-kernel Gaussian.
Definition: CRandomFieldGridMap2D.h:258
mrpt::maps::CRandomFieldGridMap2D::internal_clear
virtual void internal_clear() override
Erase all the contents of the map.
Definition: CRandomFieldGridMap2D.cpp:87
mrpt::maps::CWirelessPowerGridMap2D::internal_computeObservationLikelihood
double internal_computeObservationLikelihood(const mrpt::obs::CObservation *obs, const mrpt::poses::CPose3D &takenFrom) override
Internal method called by computeObservationLikelihood()
Definition: CWirelessPowerGridMap2D.cpp:190
mrpt::maps::CMetricMap
Declares a virtual base class for all metric maps storage classes.
Definition: CMetricMap.h:56
mrpt::serialization::CArchive::WriteBuffer
void WriteBuffer(const void *Buffer, size_t Count)
Writes a block of bytes to the stream from Buffer.
Definition: CArchive.cpp:48
mrpt::poses::CPoseOrPoint::y
double y() const
Definition: CPoseOrPoint.h:144
mrpt::maps::CWirelessPowerGridMap2D::serializeFrom
void serializeFrom(mrpt::serialization::CArchive &in, uint8_t serial_version) override
Pure virtual method for reading (deserializing) from an abstract archive.
Definition: CWirelessPowerGridMap2D.cpp:250
MRPT_START
#define MRPT_START
Definition: exceptions.h:262
mrpt::config::CConfigFileBase
This class allows loading and storing values and vectors of different types from a configuration text...
Definition: config/CConfigFileBase.h:44
mrpt::format
std::string format(const char *fmt,...) MRPT_printf_format_check(1
A std::string version of C sprintf.
Definition: format.cpp:16
mrpt::poses::CPose2D
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle.
Definition: CPose2D.h:40
mrpt::poses::CPoseOrPoint::x
double x() const
Common members of all points & poses classes.
Definition: CPoseOrPoint.h:140
mrpt::poses::CPose3D
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
Definition: CPose3D.h:88
mrpt::maps::CRandomFieldGridMap2D::TMapRepresentation
TMapRepresentation
The type of map representation to be used, see CRandomFieldGridMap2D for a discussion.
Definition: CRandomFieldGridMap2D.h:175
iniFile
string iniFile(myDataDir+string("benchmark-options.ini"))
IS_CLASS
#define IS_CLASS(ptrObj, class_name)
Evaluates to true if the given pointer to an object (derived from mrpt::rtti::CObject) is of the give...
Definition: CObject.h:103
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::max_x
double max_x
Definition: CWirelessPowerGridMap2D.h:87
uint64_t
unsigned __int64 uint64_t
Definition: rptypes.h:50
mrpt::typemeta::TEnumType
A helper class that can convert an enum value into its textual representation, and viceversa.
Definition: config/CConfigFileBase.h:24
round.h
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::KF_W_size
uint16_t KF_W_size
[mrKalmanApproximate] The size of the window of neighbor cells.
Definition: CRandomFieldGridMap2D.h:282
mrpt::maps::CWirelessPowerGridMap2D::getAs3DObject
void getAs3DObject(mrpt::opengl::CSetOfObjects::Ptr &outObj) const override
Returns a 3D object representing the map
Definition: CWirelessPowerGridMap2D.cpp:368
mrpt::obs::CObservationWirelessPower::power
double power
The power or signal strength as sensed by the Wifi receiver (In percentage: [0-100])
Definition: CObservationWirelessPower.h:39
mrpt::math::TPoint2D
Lightweight 2D point.
Definition: lightweight_geom_data.h:42
mrpt::maps::CRandomFieldGridMap2D::m_average_normreadings_mean
double m_average_normreadings_mean
Definition: CRandomFieldGridMap2D.h:520
LOADABLEOPTS_DUMP_VAR
#define LOADABLEOPTS_DUMP_VAR(variableName, variableType)
Macro for dumping a variable to a stream, within the method "dumpToTextStream(out)" (Variable types a...
Definition: config/CLoadableOptions.h:103
mrpt::opengl::CSetOfObjects::Ptr
std::shared_ptr< CSetOfObjects > Ptr
Definition: CSetOfObjects.h:30
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::R_max
float R_max
Definition: CRandomFieldGridMap2D.h:262
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::resolution
double resolution
Definition: CWirelessPowerGridMap2D.h:87
mrpt::containers::CDynamicGrid< TRandomFieldCell >::dyngridcommon_writeToStream
void dyngridcommon_writeToStream(STREAM &out) const
Definition: CDynamicGrid.h:343
mrpt::maps::CWirelessPowerGridMap2D::internal_insertObservation
bool internal_insertObservation(const mrpt::obs::CObservation *obs, const mrpt::poses::CPose3D *robotPose=nullptr) override
Internal method called by insertObservation()
Definition: CWirelessPowerGridMap2D.cpp:125
mrpt::containers::CDynamicGrid< TRandomFieldCell >::dyngridcommon_readFromStream
void dyngridcommon_readFromStream(STREAM &in, bool cast_from_float=false)
Definition: CDynamicGrid.h:351
CTicTac.h
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition
Definition: CWirelessPowerGridMap2D.h:85
maps-precomp.h
mrpt::maps::CRandomFieldGridMap2D
CRandomFieldGridMap2D represents a 2D grid map where each cell is associated one real-valued property...
Definition: CRandomFieldGridMap2D.h:152
mrpt::maps::CWirelessPowerGridMap2D::serializeTo
void serializeTo(mrpt::serialization::CArchive &out) const override
Pure virtual method for writing (serializing) to an abstract archive.
Definition: CWirelessPowerGridMap2D.cpp:200
mean
EIGEN_STRONG_INLINE double mean() const
Computes the mean of the entire matrix.
Definition: eigen_plugins.h:427
MRPT_END
#define MRPT_END
Definition: exceptions.h:266
mrpt::obs::CObservation
Declares a class that represents any robot's observation.
Definition: CObservation.h:43
in
GLuint in
Definition: glext.h:7274
string
GLsizei const GLchar ** string
Definition: glext.h:4101
mrpt::maps::TRandomFieldCell
The contents of each cell in a CRandomFieldGridMap2D map.
Definition: CRandomFieldGridMap2D.h:40
mrpt::maps::CWirelessPowerGridMap2D::TInsertionOptions::loadFromConfigFile
void loadFromConfigFile(const mrpt::config::CConfigFileBase &source, const std::string &section) override
This method load the options from a ".ini"-like file or memory-stored string list.
Definition: CWirelessPowerGridMap2D.cpp:358
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::min_y
double min_y
Definition: CWirelessPowerGridMap2D.h:87
mrpt::maps
Definition: CBeacon.h:24
mrpt::obs::CObservationWirelessPower::sensorPoseOnRobot
mrpt::poses::CPose3D sensorPoseOnRobot
The location of the sensing antenna on the robot coordinate framework.
Definition: CObservationWirelessPower.h:41
TOldCellTypeInVersion1
Definition: CGasConcentrationGridMap2D.cpp:343
mrpt::maps::CRandomFieldGridMap2D::m_cov
mrpt::math::CMatrixD m_cov
The whole covariance matrix, used for the Kalman Filter map representation.
Definition: CRandomFieldGridMap2D.h:504
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::cutoffRadius
float cutoffRadius
The cutoff radius for updating cells.
Definition: CRandomFieldGridMap2D.h:260
CArchive.h
MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION
#define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(__V)
For use in CSerializable implementations.
Definition: exceptions.h:90
mrpt::maps::CWirelessPowerGridMap2D::TMapDefinition::min_x
double min_x
See CWirelessPowerGridMap2D::CWirelessPowerGridMap2D.
Definition: CWirelessPowerGridMap2D.h:87
uint32_t
unsigned __int32 uint32_t
Definition: rptypes.h:47
mrpt::maps::CRandomFieldGridMap2D::m_average_normreadings_count
size_t m_average_normreadings_count
Definition: CRandomFieldGridMap2D.h:521
IMPLEMENTS_SERIALIZABLE
IMPLEMENTS_SERIALIZABLE(CWirelessPowerGridMap2D, CRandomFieldGridMap2D, mrpt::maps) CWirelessPowerGridMap2D
Definition: CWirelessPowerGridMap2D.cpp:91
mrpt::maps::CRandomFieldGridMap2D::TInsertionOptionsCommon::KF_defaultCellMeanValue
float KF_defaultCellMeanValue
The default value for the mean of cells' concentration.
Definition: CRandomFieldGridMap2D.h:280



Page generated by Doxygen 1.8.17 for MRPT 1.9.9 Git: ad3a9d8ae Tue May 1 23:10:22 2018 -0700 at miƩ 12 jul 2023 10:03:34 CEST