Go to the documentation of this file.
29 #include <Eigen/Dense>
49 const std::string& sectionNamePrefix)
56 insertionOpts.loadFromConfigFile(
57 source, sectionNamePrefix +
string(
"_insertOpts"));
58 likelihoodOpts.loadFromConfigFile(
59 source, sectionNamePrefix +
string(
"_likelihoodOpts"));
63 std::ostream&
out)
const
67 this->insertionOpts.dumpToTextStream(
out);
68 this->likelihoodOpts.dumpToTextStream(
out);
107 out << genericMapParams;
110 const uint32_t n = m_beacons.size();
113 for (
const auto& it : *
this)
out << it;
124 if (version >= 1) in >> genericMapParams;
135 for (i = 0; i < n; i++) in >> m_beacons[i];
175 for (
auto& it_obs : o.sensedData)
178 beac = getBeaconByID(it_obs.beaconID);
180 if (beac !=
nullptr && it_obs.sensedDistance > 0 &&
181 !std::isnan(it_obs.sensedDistance))
183 float sensedRange = it_obs.sensedDistance;
188 sensor3D = robotPose3D + it_obs.sensorLocationOnRobot;
198 CPointPDFParticles::CParticleList::const_iterator it;
206 itLW = logWeights.
begin(), itLL = logLiks.
begin();
208 ++it, ++itLW, ++itLL)
211 it->d->x, it->d->y, it->d->z);
218 (sensedRange - expectedRange) /
219 likelihoodOptions.rangeStd);
225 if (logWeights.
size())
227 logWeights, logLiks);
239 float varZ, varR =
square(likelihoodOptions.rangeStd);
249 float expectedRange =
267 -0.5 *
square(sensedRange - expectedRange) / varZ;
282 itLW = logWeights.
begin(), itLL = logLiks.
begin();
284 ++it, ++itLW, ++itLL)
288 varR =
square(likelihoodOptions.rangeStd);
289 double Ax = it->val.mean.x() - sensor3D.
x();
290 double Ay = it->val.mean.y() - sensor3D.
y();
291 double Az = it->val.mean.z() - sensor3D.z();
295 double expectedRange =
312 *itLL = -0.5 *
square(sensedRange - expectedRange) /
317 if (logWeights.
size())
331 if (o.maxSensorDistance != o.minSensorDistance)
333 log(1.0 / (o.maxSensorDistance - o.minSensorDistance));
365 robotPose2D =
CPose2D(*robotPose);
366 robotPose3D = (*robotPose);
393 for (
const auto& it : o.sensedData)
395 CPoint3D sensorPnt(robotPose3D + it.sensorLocationOnRobot);
396 float sensedRange = it.sensedDistance;
397 unsigned int sensedID = it.beaconID;
399 CBeacon* beac = getBeaconByID(sensedID);
409 newBeac.
m_ID = sensedID;
411 if (insertionOptions.insertAsMonteCarlo)
418 size_t numParts =
round(
419 insertionOptions.MC_numSamplesPerMeter *
422 insertionOptions.minElevation_deg <=
423 insertionOptions.maxElevation_deg);
425 DEG2RAD(insertionOptions.minElevation_deg);
427 DEG2RAD(insertionOptions.maxElevation_deg);
429 for (
auto& m_particle :
437 sensedRange, likelihoodOptions.rangeStd);
439 sensorPnt.
x() +
R * cos(th) * cos(el);
441 sensorPnt.
y() +
R * sin(th) * cos(el);
442 m_particle.d->z = sensorPnt.z() +
R * sin(el);
459 m_beacons.push_back(newBeac);
474 double maxW = -1e308, sumW = 0;
480 p.d->x, p.d->y, p.d->z);
483 (sensedRange - expectedRange) /
484 likelihoodOptions.rangeStd);
485 maxW = max(p.log_w, maxW);
486 sumW += exp(p.log_w);
492 if (insertionOptions.MC_performResampling)
500 vector<double> log_ws;
501 vector<size_t> indxs;
505 CParticleFilterCapable::computeResampling(
506 CParticleFilter::prSystematic, log_ws,
515 (insertionOptions.minElevation_deg ==
516 insertionOptions.maxElevation_deg);
519 .MC_afterResamplingNoise;
522 CPointPDFParticles::CParticleList::iterator
557 (maxW - insertionOptions
558 .MC_thresholdNegligible))
582 double D1 = sqrt(COV(0, 0));
583 double D2 = sqrt(COV(1, 1));
584 double D3 = sqrt(COV(2, 2));
586 double mxVar =
max3(D1, D2, D3);
588 if (mxVar < insertionOptions.MC_maxStdToGauss)
601 if (insertionOptions.minElevation_deg ==
602 insertionOptions.maxElevation_deg)
622 float varR =
square(likelihoodOptions.rangeStd);
634 float y = sensedRange - expectedRange;
682 float varR =
square(likelihoodOptions.rangeStd);
691 double expectedRange =
695 double y = sensedRange - expectedRange;
700 double Ax = (mode.val.mean.x() - sensorPnt.
x());
701 double Ay = (mode.val.mean.y() - sensorPnt.
y());
702 double Az = (mode.val.mean.z() - sensorPnt.z());
706 H.
asEigen() *= 1.0 / expectedRange;
715 mode.val.mean.x_incr(K(0, 0) * y);
716 mode.val.mean.y_incr(K(1, 0) * y);
717 mode.val.mean.z_incr(K(2, 0) * y);
719 mode.val.cov = (Eigen::Matrix3d::Identity() -
721 mode.val.cov.asEigen();
725 mode.log_w += -0.5 *
square(y) / varZ;
728 max_w = max(max_w, mode.log_w);
736 if (max_w - it_p->log_w >
737 insertionOptions.SOG_thresholdNegligible)
749 const auto [curCov, curMean] =
752 double D1 = sqrt(curCov(0, 0));
753 double D2 = sqrt(curCov(1, 1));
754 double D3 = sqrt(curCov(2, 2));
755 float maxDiag =
max3(D1, D2, D3);
800 CPose3D otherMapPose3D(otherMapPose);
804 const auto* otherMap2 =
dynamic_cast<const CBeaconMap*
>(otherMap);
805 vector<bool> otherCorrespondences;
811 computeMatchingWith3DLandmarks(
812 otherMap2, correspondences, extraResults.correspondencesRatio,
813 otherCorrespondences);
824 for (
auto& m_beacon : m_beacons)
825 m_beacon.changeCoordinatesReference(newOrg);
837 changeCoordinatesReference(newOrg);
846 vector<bool>& otherCorrespondences)
const
850 TSequenceBeacons::const_iterator thisIt, otherIt;
851 size_t nThis, nOther;
855 vector<bool> thisLandmarkAssigned;
858 nThis = m_beacons.size();
862 thisLandmarkAssigned.resize(nThis,
false);
865 correspondences.clear();
866 otherCorrespondences.clear();
867 otherCorrespondences.resize(nOther,
false);
868 correspondencesRatio = 0;
870 for (k = 0, otherIt = anotherMap->
m_beacons.begin();
871 otherIt != anotherMap->
m_beacons.end(); ++otherIt, ++k)
873 for (j = 0, thisIt = m_beacons.begin(); thisIt != m_beacons.end();
877 if ((otherIt)->m_ID == (thisIt)->m_ID)
881 if (!thisLandmarkAssigned[j])
883 thisLandmarkAssigned[j] =
true;
886 otherCorrespondences[k] =
true;
890 CPoint3D mean_j = m_beacons[j].getMeanVal();
894 match.
this_z = mean_j.z();
902 correspondences.push_back(match);
911 correspondencesRatio = 2.0f * correspondences.size() /
d2f(nThis + nOther);
920 const string& file, [[maybe_unused]]
const char* style,
921 [[maybe_unused]]
float confInterval)
const
924 if (!f)
return false;
928 f,
"%%-------------------------------------------------------\n");
929 os::fprintf(f,
"%% File automatically generated using the MRPT method:\n");
930 os::fprintf(f,
"%% 'CBeaconMap::saveToMATLABScript3D'\n");
934 f,
"%% Jose Luis Blanco Claraco, University of Malaga @ 2006\n");
937 f,
"%%-------------------------------------------------------\n\n");
941 std::vector<std::string> strs;
944 for (
const auto& m_beacon : m_beacons)
946 m_beacon.getAsMatlabDrawCommands(strs);
959 out <<
"\n----------- [CBeaconMap::TLikelihoodOptions] ------------ \n\n";
961 "rangeStd = %f\n", rangeStd);
971 rangeStd =
iniFile.read_float(section.c_str(),
"rangeStd", rangeStd);
976 out <<
"\n----------- [CBeaconMap::TInsertionOptions] ------------ \n\n";
979 "insertAsMonteCarlo = %c\n",
980 insertAsMonteCarlo ?
'Y' :
'N');
982 "minElevation_deg = %.03f\n", minElevation_deg);
984 "maxElevation_deg = %.03f\n", maxElevation_deg);
986 "MC_numSamplesPerMeter = %d\n",
987 MC_numSamplesPerMeter);
989 "MC_maxStdToGauss = %.03f\n", MC_maxStdToGauss);
991 "MC_thresholdNegligible = %.03f\n",
992 MC_thresholdNegligible);
994 "MC_performResampling = %c\n",
995 MC_performResampling ?
'Y' :
'N');
997 "MC_afterResamplingNoise = %.03f\n",
998 MC_afterResamplingNoise);
1000 "SOG_thresholdNegligible = %.03f\n",
1001 SOG_thresholdNegligible);
1003 "SOG_maxDistBetweenGaussians = %.03f\n",
1004 SOG_maxDistBetweenGaussians);
1006 "SOG_separationConstant = %.03f\n",
1007 SOG_separationConstant);
1024 MC_thresholdNegligible,
double,
iniFile, section.c_str());
1027 MC_afterResamplingNoise,
float,
iniFile, section.c_str());
1029 SOG_thresholdNegligible,
float,
iniFile, section.c_str());
1031 SOG_maxDistBetweenGaussians,
float,
iniFile, section.c_str());
1033 SOG_separationConstant,
float,
iniFile, section.c_str());
1044 const CPose3D& in_robotPose,
const CPoint3D& in_sensorLocationOnRobot,
1047 TSequenceBeacons::const_iterator it;
1053 point3D = in_robotPose + in_sensorLocationOnRobot;
1059 for (it = m_beacons.begin(); it != m_beacons.end(); ++it)
1061 it->getMean(beacon3D);
1078 out_Observations.
sensedData.push_back(newMeas);
1088 const string& filNamePrefix)
const
1093 string fil1(filNamePrefix +
string(
"_3D.m"));
1094 saveToMATLABScript3D(fil1);
1099 std::make_shared<opengl::CSetOfObjects>();
1101 getAs3DObject(obj3D);
1103 -100.0f, 100.0f, -100.0f, 100.0f, .0f, 1.f);
1108 string fil2(filNamePrefix +
string(
"_3D.3Dscene"));
1112 string fil3(filNamePrefix +
string(
"_covs.txt"));
1113 saveToTextFile(fil3);
1116 string fil4(filNamePrefix +
string(
"_population.txt"));
1118 FILE* f =
os::fopen(fil4.c_str(),
"wt");
1121 size_t nParts = 0, nGaussians = 0;
1123 for (
const auto& m_beacon : m_beacons)
1125 switch (m_beacon.m_typePDF)
1128 nParts += m_beacon.m_locationMC.size();
1131 nGaussians += m_beacon.m_locationSOG.size();
1140 f,
"%u %u",
static_cast<unsigned>(nParts),
1141 static_cast<unsigned>(nGaussians));
1156 if (!genericMapParams.enableSaveAs3DObject)
return;
1164 for (
const auto& m_beacon : m_beacons) m_beacon.getAs3DObject(outObj);
1197 otherMap =
dynamic_cast<const CBeaconMap*
>(otherMap2);
1199 if (!otherMap)
return 0;
1202 vector<bool> otherCorrespondences;
1203 float out_corrsRatio;
1209 computeMatchingWith3DLandmarks(
1210 &modMap, matchList, out_corrsRatio, otherCorrespondences);
1212 return out_corrsRatio;
1222 for (
const auto& m_beacon : m_beacons)
1223 if (m_beacon.m_ID ==
id)
return &m_beacon;
1232 for (
auto& m_beacon : m_beacons)
1233 if (m_beacon.m_ID ==
id)
return &m_beacon;
1249 for (
const auto& m_beacon : m_beacons)
1251 const auto [C, p] = m_beacon.getCovarianceAndMean();
1254 float D2 = C(0, 0) * C(1, 1) -
square(C(0, 1));
1256 f,
"%i %f %f %f %e %e %e %e %e %e %e %e\n",
1257 static_cast<int>(m_beacon.m_ID), p.x(), p.y(), p.z(), C(0, 0),
1258 C(1, 1), C(2, 2), D2, D3, C(0, 1), C(1, 2), C(1, 2));
void saveMetricMapRepresentationToFile(const std::string &filNamePrefix) const override
This virtual method saves the map to a file "filNamePrefix"+< some_file_extension >,...
Each one of the measurements.
TTypePDF m_typePDF
Which one of the different 3D point PDF is currently used in this object: montecarlo,...
float sensedDistance
The sensed range itself (in meters).
float compute3DMatchingRatio(const mrpt::maps::CMetricMap *otherMap, const mrpt::poses::CPose3D &otherMapPose, const TMatchingRatioParams ¶ms) const override
Computes the ratio in [0,1] of correspondences between "this" and the "otherMap" map,...
void clear()
Clear the contents of this container.
int void fclose(FILE *f)
An OS-independent version of fclose.
mrpt::math::CMatrixDouble33 cov
The 3x3 covariance matrix.
void setSize(size_t numberParticles, const mrpt::math::TPoint3Df &defaultValue=mrpt::math::TPoint3Df{0, 0, 0})
Erase all the previous particles and change the number of particles, with a given initial value
void serializeFrom(mrpt::serialization::CArchive &in, uint8_t serial_version) override
Pure virtual method for reading (deserializing) from an abstract archive.
std::shared_ptr< mrpt::opengl ::CSetOfObjects > Ptr
float minSensorDistance
Info about sensor.
void insert(const CRenderizable::Ptr &newObject, const std::string &viewportName=std::string("main"))
Insert a new object into the scene, in the given viewport (by default, into the "main" viewport).
typename vec_t::iterator iterator
const T max3(const T &A, const T &B, const T &C)
#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...
std::tuple< cov_mat_t, type_value > getCovarianceAndMean() const override
void normalizeWeights()
Normalize the weights in m_modes such as the maximum log-weight is 0.
void x_incr(const double v)
void setSize(size_t row, size_t col, bool zeroNewElements=false)
Changes the size of matrix, maintaining the previous contents.
A gaussian distribution for 3D points.
double x() const
Common members of all points & poses classes.
This class allows the user to create, load, save, and render 3D scenes using OpenGL primitives.
TSequenceBeacons m_beacons
The individual beacons.
void dumpToTextStream(std::ostream &out) const override
This method should clearly display all the contents of the structure in textual form,...
#define MAP_DEFINITION_REGISTER(_CLASSNAME_STRINGS, _CLASSNAME_WITH_NS)
Registers one map class into TMetricMapInitializer factory.
bool internal_insertObservation(const mrpt::obs::CObservation &obs, const mrpt::poses::CPose3D *robotPose=nullptr) override
Internal method called by insertObservation()
void y_incr(const double v)
Parameters for CMetricMap::compute3DMatchingRatio()
void getAs3DObject(mrpt::opengl::CSetOfObjects::Ptr &outObj) const override
Returns a 3D object representing the map.
mrpt::vision::TStereoCalibResults out
std::tuple< cov_mat_t, type_value > getCovarianceAndMean() const override
Functions for estimating the optimal transformation between two frames of references given measuremen...
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Virtual base for specifying the kind and parameters of one map (normally, to be inserted into mrpt::m...
void internal_clear() override
Internal method called by clear()
A structure for holding correspondences between two sets of points or points-like entities in 2D or 3...
void dumpToTextStream(std::ostream &out) const override
This method should clearly display all the contents of the structure in textual form,...
#define THROW_EXCEPTION(msg)
void serializeTo(mrpt::serialization::CArchive &out) const override
Pure virtual method for writing (serializing) to an abstract archive.
#define ASSERT_(f)
Defines an assertion mechanism.
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
double distanceTo(const CPoseOrPoint< OTHERCLASS, DIM2 > &b) const
Returns the Euclidean distance to another pose/point:
void changeCoordinatesReference(const mrpt::poses::CPose3D &newOrg)
Changes the reference system of the map to a given 3D pose.
This namespace contains representation of robot actions and observations.
#define MRPT_CHECK_NORMAL_NUMBER(v)
Throws an exception if the number is NaN, IND, or +/-INF, or return the same number otherwise.
Virtual base class for "archives": classes abstracting I/O streams.
std::deque< TMeasurement > sensedData
The list of observed ranges.
CMatrixDynamic< double > CMatrixDouble
Declares a matrix of double numbers (non serializable).
Declares a virtual base class for all metric maps storage classes.
virtual const mrpt::rtti::TRuntimeClassId * GetRuntimeClass() const override
Returns information about the class of an object in runtime.
return_t drawUniform(const double Min, const double Max)
Generate a uniformly distributed pseudo-random number using the MT19937 algorithm,...
A compile-time fixed-size numeric matrix container.
Declares a class derived from "CObservation" that represents one (or more) range measurements to labe...
Scalar det() const
Determinant of matrix.
int round(const T value)
Returns the closer integer (int) to x.
static Ptr Create(Args &&... args)
void loadFromConfigFile(const mrpt::config::CConfigFileBase &source, const std::string §ion) override
Initilization of default parameters.
This class allows loading and storing values and vectors of different types from a configuration text...
float stdError
The "sigma" of the sensor, assuming a zero-mean Gaussian noise model.
mrpt::poses::CPointPDFGaussian m_locationGauss
The individual PDF, if m_typePDF=pdfGauss (publicly accesible for ease of use, but the CPointPDF inte...
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle.
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
int32_t beaconID
The ID of the sensed beacon (or INVALID_BEACON_ID if unknown)
string iniFile(myDataDir+string("benchmark-options.ini"))
static void generateRingSOG(float sensedRange, mrpt::poses::CPointPDFSOG &outPDF, const CBeaconMap *myBeaconMap, const mrpt::poses::CPoint3D &sensorPnt, const mrpt::math::CMatrixDouble33 *covarianceCompositionToAdd=nullptr, bool clearPreviousContentsOutPDF=true, const mrpt::poses::CPoint3D ¢erPoint=mrpt::poses::CPoint3D(0, 0, 0), float maxDistanceFromCenter=0)
This static method returns a SOG with ring-shape (or as a 3D sphere) that can be used to initialize a...
void clear()
Clear all the particles (free memory)
size_t size(const MATRIXLIKE &m, const int dim)
mrpt::maps::CBeaconMap::TInsertionOptions insertionOpts
Observations insertion options.
float d2f(const double d)
shortcut for static_cast<float>(double)
mrpt::maps::CBeaconMap::TLikelihoodOptions likelihoodOpts
Probabilistic observation likelihood options.
mrpt::poses::CPointPDFSOG m_locationSOG
The individual PDF, if m_typePDF=pdfSOG (publicly accesible for ease of use, but the CPointPDF interf...
return_t square(const num_t x)
Inline function for the square of a number.
double internal_computeObservationLikelihood(const mrpt::obs::CObservation &obs, const mrpt::poses::CPose3D &takenFrom) override
Internal method called by computeObservationLikelihood()
void getWeights(std::vector< double > &out_logWeights) const
Returns a vector with the sequence of the logaritmic weights of all the samples.
static mrpt::maps::CMetricMap * internal_CreateFromMapDefinition(const mrpt::maps::TMetricMapInitializer &def)
constexpr double DEG2RAD(const double x)
Degrees to radians
mrpt::vision::TStereoCalibParams params
#define IMPLEMENTS_SERIALIZABLE(class_name, base, NameSpace)
To be added to all CSerializable-classes implementation files.
Parameters for the determination of matchings between point clouds, etc.
void saveToTextFile(const std::string &fil) const
Save a text file with a row per beacon, containing this 11 elements:
const CBeacon * getBeaconByID(CBeacon::TBeaconID id) const
Returns a pointer to the beacon with the given ID, or nullptr if it does not exist.
TBeaconID m_ID
An ID for the landmark (see details next...) This ID was introduced in the version 3 of this class (2...
size_type size() const
Get a 2-vector with [NROWS NCOLS] (as in MATLAB command size(x))
std::deque< TGaussianMode >::const_iterator const_iterator
bool saveToFile(const std::string &fil) const
Saves the scene to a 3Dscene file, loadable by the application SceneViewer3D.
CParticleList m_particles
The array of particles.
int fprintf(FILE *fil, const char *format,...) noexcept MRPT_printf_format_check(2
An OS-independent version of fprintf.
#define CLASS_ID(T)
Access to runtime class ID for a defined class name.
CSetOfObjects::Ptr CornerXYZ(float scale=1.0)
Returns three arrows representing a X,Y,Z 3D corner.
mrpt::poses::CPointPDFParticles m_locationMC
The individual PDF, if m_typePDF=pdfMonteCarlo (publicly accesible for ease of use,...
void performSubstitution(const std::vector< size_t > &indx) override
Replaces the old particles by copies determined by the indexes in "indx", performing an efficient cop...
EIGEN_MAP asEigen()
Get as an Eigen-compatible Eigen::Map object
CRandomGenerator & getRandomGenerator()
A static instance of a CRandomGenerator class, for use in single-thread applications.
void loadFromConfigFile(const mrpt::config::CConfigFileBase &source, const std::string §ion) override
This method load the options from a ".ini"-like file or memory-stored string list.
The namespace for Bayesian filtering algorithm: different particle filters and Kalman filter algorith...
MAT_C::Scalar multiply_HCHt_scalar(const VECTOR_H &H, const MAT_C &C)
r (scalar) = H*C*H^t (H: row vector, C: symmetric matrix)
A class for storing a map of 3D probabilistic beacons, using a Montecarlo, Gaussian,...
virtual const mrpt::rtti::TRuntimeClassId * GetRuntimeClass() const override
Returns information about the class of an object in runtime.
void dumpToTextStream_map_specific(std::ostream &out) const override
The class for storing individual "beacon landmarks" under a variety of 3D position PDF distributions.
void determineMatching2D(const mrpt::maps::CMetricMap *otherMap, const mrpt::poses::CPose2D &otherMapPose, mrpt::tfest::TMatchingPairList &correspondences, const TMatchingParams ¶ms, TMatchingExtraResults &extraResults) const override
Computes the matching between this and another 2D point map, which includes finding:
return_t drawGaussian1D(const double mean, const double std)
Generate a normally distributed pseudo-random number.
Declares a class that represents any robot's observation.
iterator erase(iterator i)
This base provides a set of functions for maths stuff.
void resize(const size_t N)
Resize the number of SOG modes.
FILE * fopen(const char *fileName, const char *mode) noexcept
An OS-independent version of fopen.
void simulateBeaconReadings(const mrpt::poses::CPose3D &in_robotPose, const mrpt::poses::CPoint3D &in_sensorLocationOnRobot, mrpt::obs::CObservationBeaconRanges &out_Observations) const
Simulates a reading toward each of the beacons in the landmarks map, if any.
A namespace of pseudo-random numbers generators of diferent distributions.
bool saveToMATLABScript3D(const std::string &file, const char *style="b", float confInterval=0.95f) const
Save to a MATLAB script which displays 3D error ellipses for the map.
double distance3DTo(double ax, double ay, double az) const
Returns the 3D distance from this pose/point to a 3D point.
A class used to store a 3D point.
#define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(__V)
For use in CSerializable implementations.
CPoint3D mean
The mean value.
int64_t TBeaconID
The type for the IDs of landmarks.
double averageLogLikelihood(const CVectorDouble &logLikelihoods)
A numerically-stable method to compute average likelihood values with strongly different ranges (unwe...
void stringListAsString(const std::vector< std::string > &lst, std::string &out, const std::string &newline="\r\n")
Convert a string list to one single string with new-lines.
mrpt::poses::CPoint3D sensorLocationOnRobot
Position of the sensor on the robot.
uint8_t serializeGetVersion() const override
Must return the current versioning number of the object.
size_t size() const
Returns the stored landmarks count.
void computeMatchingWith3DLandmarks(const mrpt::maps::CBeaconMap *otherMap, mrpt::tfest::TMatchingPairList &correspondences, float &correspondencesRatio, std::vector< bool > &otherCorrespondences) const
Perform a search for correspondences between "this" and another lansmarks map: Firsly,...
void loadFromConfigFile_map_specific(const mrpt::config::CConfigFileBase &source, const std::string §ionNamePrefix) override
Load all map-specific params.
double ESS() const override
Returns the normalized ESS (Estimated Sample Size), in the range [0,1].
std::string std::string format(std::string_view fmt, ARGS &&... args)
size_t size() const
Return the number of Gaussian modes.
bool isEmpty() const override
Returns true if the map is empty/no observation has been inserted.
Page generated by Doxygen 1.8.17 for MRPT 2.0.4 at Sat Jun 27 14:00:59 UTC 2020 | |