/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          https://www.mrpt.org/                         |
   |                                                                        |
   | Copyright (c) 2005-2022, Individual contributors, see AUTHORS file     |
   | See: https://www.mrpt.org/Authors - All rights reserved.               |
   | Released under BSD License. See: https://www.mrpt.org/License          |
   +------------------------------------------------------------------------+ */

#include "nav-precomp.h"  // Precomp header
//
#include <mrpt/core/round.h>
#include <mrpt/math/geometry.h>
#include <mrpt/math/ops_containers.h>
#include <mrpt/nav/holonomic/CHolonomicND.h>
#include <mrpt/serialization/CArchive.h>

using namespace mrpt;
using namespace mrpt::math;
using namespace mrpt::nav;
using namespace std;

IMPLEMENTS_SERIALIZABLE(CLogFileRecord_ND, CHolonomicLogFileRecord, mrpt::nav)
IMPLEMENTS_SERIALIZABLE(
	CHolonomicND, CAbstractHolonomicReactiveMethod, mrpt::nav)

/**  Initialize the parameters of the navigator, from some
 *    configuration file, or default values if filename is set to NULL.
 */
CHolonomicND::CHolonomicND(const mrpt::config::CConfigFileBase* INI_FILE)
	: CAbstractHolonomicReactiveMethod("CHolonomicND"),
	  m_last_selected_sector(std::numeric_limits<unsigned int>::max())
{
	if (INI_FILE != nullptr) initialize(*INI_FILE);
}

void CHolonomicND::initialize(const mrpt::config::CConfigFileBase& INI_FILE)
{
	options.loadFromConfigFile(INI_FILE, getConfigFileSectionName());
}
void CHolonomicND::saveConfigFile(mrpt::config::CConfigFileBase& c) const
{
	options.saveToConfigFile(c, getConfigFileSectionName());
}

/*---------------------------------------------------------------
						Navigate
  ---------------------------------------------------------------*/
void CHolonomicND::navigate(const NavInput& ni, NavOutput& no)
{
	const auto ptg = getAssociatedPTG();
	const double ptg_ref_dist = ptg ? ptg->getRefDistance() : 1.0;

	TGapArray gaps;
	TSituations situation;
	unsigned int selectedSector;
	double riskEvaluation;
	double evaluation;

	// Create a log record for returning data.
	CLogFileRecord_ND::Ptr log = std::make_shared<CLogFileRecord_ND>();
	no.logRecord = log;

	// Search gaps:
	gaps.clear();
	ASSERT_(!ni.targets.empty());
	const auto trg = *ni.targets.rbegin();

	gapsEstimator(ni.obstacles, trg, gaps);

	// Select best gap:
	searchBestGap(
		ni.obstacles, 1.0 /* max obs range*/, gaps, trg, selectedSector,
		evaluation, situation, riskEvaluation, *log);

	if (situation == SITUATION_NO_WAY_FOUND)
	{
		// No way found!
		no.desiredDirection = 0;
		no.desiredSpeed = 0;
	}
	else
	{
		// A valid movement:
		no.desiredDirection = CParameterizedTrajectoryGenerator::index2alpha(
			selectedSector, ni.obstacles.size());

		// Speed control: Reduction factors
		// ---------------------------------------------
		const double targetNearnessFactor = m_enableApproachTargetSlowDown
			? std::min(
				  1.0,
				  trg.norm() /
					  (options.TARGET_SLOW_APPROACHING_DISTANCE / ptg_ref_dist))
			: 1.0;

		const double riskFactor =
			std::min(1.0, riskEvaluation / options.RISK_EVALUATION_DISTANCE);
		no.desiredSpeed =
			ni.maxRobotSpeed * std::min(riskFactor, targetNearnessFactor);
	}

	m_last_selected_sector = selectedSector;

	// LOG --------------------------
	if (log)
	{
		// gaps:
		{
			int i, n = gaps.size();
			log->gaps_ini.resize(n);
			log->gaps_end.resize(n);
			for (i = 0; i < n; i++)
			{
				log->gaps_ini[i] = gaps[i].ini;
				log->gaps_end[i] = gaps[i].end;
			}
		}
		// Selection:
		log->selectedSector = selectedSector;
		log->evaluation = evaluation;
		log->situation = situation;
		log->riskEvaluation = riskEvaluation;
	}
}

/*---------------------------------------------------------------
				Find gaps in the obtacles (Beta version)
  ---------------------------------------------------------------*/
void CHolonomicND::gapsEstimator(
	const std::vector<double>& obstacles, const mrpt::math::TPoint2D& target,
	TGapArray& gaps_out)
{
	const size_t n = obstacles.size();
	ASSERT_(n > 2);

	// ================ Parameters ================
	const int GAPS_MIN_WIDTH = ceil(n * 0.01);	// was: 3
	const double GAPS_MIN_DEPTH_CONSIDERED = 0.6;
	const double GAPS_MAX_RELATIVE_DEPTH = 0.5;
	// ============================================

	// Find the maximum distances to obstacles:
	// ----------------------------------------------------------
	double overall_max_dist = std::numeric_limits<float>::min(),
		   overall_min_dist = std::numeric_limits<float>::max();
	for (size_t i = 1; i < (n - 1); i++)
	{
		mrpt::keep_max(overall_max_dist, obstacles[i]);
		mrpt::keep_min(overall_min_dist, obstacles[i]);
	}
	double max_depth = overall_max_dist - overall_min_dist;

	//  Build list of "GAPS":
	// --------------------------------------------------------
	TGapArray gaps_temp;
	gaps_temp.reserve(150);

	for (double threshold_ratio = 0.95; threshold_ratio >= 0.05;
		 threshold_ratio -= 0.05)
	{
		const double dist_threshold = threshold_ratio * overall_max_dist +
			(1.0f - threshold_ratio) *
				min(target.norm(), GAPS_MIN_DEPTH_CONSIDERED);

		bool is_inside = false;
		size_t sec_ini = 0, sec_end = 0;
		double maxDist = 0.;

		for (size_t i = 0; i < n; i++)
		{
			if (!is_inside && (obstacles[i] >= dist_threshold))	 // A gap begins
			{
				sec_ini = i;
				maxDist = obstacles[i];
				is_inside = true;
			}
			else if (
				is_inside &&
				(i == (n - 1) || obstacles[i] < dist_threshold))  // A gap ends
			{
				if (obstacles[i] < dist_threshold) sec_end = i - 1;
				else
					sec_end = i;

				is_inside = false;

				if ((sec_end - sec_ini) >= (size_t)GAPS_MIN_WIDTH)
				{
					// Add new gap:
					gaps_temp.resize(gaps_temp.size() + 1);
					TGap& newGap = *gaps_temp.rbegin();

					newGap.ini = sec_ini;
					newGap.end = sec_end;
					newGap.minDistance =
						min(obstacles[sec_ini], obstacles[sec_end]);
					newGap.maxDistance = maxDist;
				}
			}

			if (is_inside) maxDist = std::max(maxDist, obstacles[i]);
		}
	}

	// Start to filter the gap list
	//--------------------------------------------------------------

	const size_t nTempGaps = gaps_temp.size();

	std::vector<bool> delete_gaps;
	delete_gaps.assign(nTempGaps, false);

	// First, remove redundant gaps
	for (size_t i = 0; i < nTempGaps; i++)
	{
		if (delete_gaps[i] == 1) continue;

		for (size_t j = i + 1; j < nTempGaps; j++)
		{
			if (gaps_temp[i].ini == gaps_temp[j].ini ||
				gaps_temp[i].end == gaps_temp[j].end)
				delete_gaps[j] = true;
		}
	}

	// Remove gaps with a big depth
	for (size_t i = 0; i < nTempGaps; i++)
	{
		if (delete_gaps[i] == 1) continue;

		if ((gaps_temp[i].maxDistance - gaps_temp[i].minDistance) >
			max_depth * GAPS_MAX_RELATIVE_DEPTH)
			delete_gaps[i] = true;
	}

	// Delete gaps which contain more than one other gaps
	for (size_t i = 0; i < nTempGaps; i++)
	{
		if (delete_gaps[i]) continue;

		unsigned int inner_gap_count = 0;

		for (unsigned int j = 0; j < nTempGaps; j++)
		{
			if (i == j || delete_gaps[j]) continue;

			// j is inside of i?
			if (gaps_temp[j].ini >= gaps_temp[i].ini &&
				gaps_temp[j].end <= gaps_temp[i].end)
				if (++inner_gap_count > 1)
				{
					delete_gaps[i] = true;
					break;
				}
		}
	}

	// Delete gaps included in other gaps
	for (size_t i = 0; i < nTempGaps; i++)
	{
		if (delete_gaps[i]) continue;

		for (unsigned int j = 0; j < nTempGaps; j++)
		{
			if (i == j || delete_gaps[j]) continue;
			if (gaps_temp[i].ini <= gaps_temp[j].ini &&
				gaps_temp[i].end >= gaps_temp[j].end)
				delete_gaps[j] = true;
		}
	}

	// Copy as result only those gaps not marked for deletion:
	// --------------------------------------------------------
	gaps_out.clear();
	gaps_out.reserve(nTempGaps / 2);
	for (size_t i = 0; i < nTempGaps; i++)
	{
		if (delete_gaps[i]) continue;

		// Compute the representative direction ("sector") for this gap:
		calcRepresentativeSectorForGap(gaps_temp[i], target, obstacles);

		gaps_out.push_back(gaps_temp[i]);
	}
}

/*---------------------------------------------------------------
						Search the best gap.
  ---------------------------------------------------------------*/
void CHolonomicND::searchBestGap(
	const std::vector<double>& obstacles, const double maxObsRange,
	const TGapArray& in_gaps, const mrpt::math::TPoint2D& target,
	unsigned int& out_selDirection, double& out_selEvaluation,
	TSituations& out_situation, double& out_riskEvaluation,
	CLogFileRecord_ND& log)
{
	// For evaluating the "risk":
	unsigned int min_risk_eval_sector = 0;
	unsigned int max_risk_eval_sector = obstacles.size() - 1;
	const unsigned int target_sector =
		direction2sector(atan2(target.y, target.x), obstacles.size());
	const double target_dist = std::max(0.01, target.norm());
	// (Risk is evaluated at the end, for all the situations)

	// D1 : Straight path?
	// --------------------------------------------------------
	const int freeSectorsNearTarget = ceil(0.02 * obstacles.size());
	bool theyAreFree = true, caseD1 = false;
	if (target_sector > static_cast<unsigned int>(freeSectorsNearTarget) &&
		target_sector <
			static_cast<unsigned int>(obstacles.size() - freeSectorsNearTarget))
	{
		const double min_free_dist =
			std::min(1.05 * target_dist, 0.95 * maxObsRange);
		for (int j = -freeSectorsNearTarget;
			 theyAreFree && j <= freeSectorsNearTarget; j++)
			if (obstacles[(int(target_sector) + j) % obstacles.size()] <
				min_free_dist)
				theyAreFree = false;
		caseD1 = theyAreFree;
	}

	if (caseD1)
	{
		// S1: Move straight towards target:
		out_selDirection = target_sector;

		// In case of several paths, the shortest:
		out_selEvaluation =
			1.0 + std::max(0.0, (maxObsRange - target_dist) / maxObsRange);
		out_situation = SITUATION_TARGET_DIRECTLY;
	}
	else
	{
		// Evaluate all gaps (if any):
		std::vector<double> gaps_evaluation;
		int selected_gap = -1;
		double selected_gap_eval = -100;

		evaluateGaps(
			obstacles, maxObsRange, in_gaps, target_sector, target_dist,
			gaps_evaluation);

		log.gaps_eval = gaps_evaluation;

		// D2: is there any gap "beyond" the target (and not too far away)?
		// (Not used)
		// ----------------------------------------------------------------

		// unsigned int dist;
		// for ( unsigned int i=0;i<in_gaps.size();i++ )
		//{
		//	dist = mrpt::abs_diff(target_sector,
		// in_gaps[i].representative_sector );
		//	if (dist > 0.5*obstacles.size())
		//		dist = obstacles.size() - dist;
		//
		//	if ( in_gaps[i].maxDistance >= target_dist && dist <=
		//(int)floor(options.MAX_SECTOR_DIST_FOR_D2_PERCENT * obstacles.size())
		//)
		//
		//		if ( gaps_evaluation[i]>selected_gap_eval )
		//		{
		//			selected_gap_eval = gaps_evaluation[i];
		//			selected_gap = i;
		//		}
		//}

		// Keep the best gaps (if none was picked up to this point)
		if (selected_gap == -1)
			for (unsigned int i = 0; i < in_gaps.size(); i++)
				if (gaps_evaluation[i] > selected_gap_eval)
				{
					selected_gap_eval = gaps_evaluation[i];
					selected_gap = i;
				}

		//  D3: Wasn't a good enough gap (or there were none)?
		// ----------------------------------------------------------
		if (selected_gap_eval <= 0)
		{
			// S2: No way found
			// ------------------------------------------------------
			out_selDirection = 0;
			out_selEvaluation = 0.0;  // Worst case
			out_situation = SITUATION_NO_WAY_FOUND;
		}
		else
		{
			// The selected gap:
			const TGap& gap = in_gaps[selected_gap];

			const unsigned int sectors_to_be_wide =
				round(options.WIDE_GAP_SIZE_PERCENT * obstacles.size());

			out_selDirection = in_gaps[selected_gap].representative_sector;
			out_selEvaluation = selected_gap_eval;

			// D4: Is it a WIDE gap?
			// -----------------------------------------------------
			if ((gap.end - gap.ini) < sectors_to_be_wide)
			{
				// S3: Narrow gap
				// -------------------------------------------
				out_situation = SITUATION_SMALL_GAP;
			}
			else
			{
				// S4: Wide gap
				// -------------------------------------------
				out_situation = SITUATION_WIDE_GAP;
			}

			// Evaluate the risk only within the gap:
			min_risk_eval_sector = gap.ini;
			max_risk_eval_sector = gap.end;
		}
	}

	// Evaluate short-term minimum distance to obstacles, in a small interval
	// around the selected direction:
	const unsigned int risk_eval_nsectors =
		round(options.RISK_EVALUATION_SECTORS_PERCENT * obstacles.size());
	const unsigned int sec_ini = std::max(
		min_risk_eval_sector,
		risk_eval_nsectors < out_selDirection
			? out_selDirection - risk_eval_nsectors
			: 0);
	const unsigned int sec_fin =
		std::min(max_risk_eval_sector, out_selDirection + risk_eval_nsectors);

	out_riskEvaluation = 0.0;
	for (unsigned int i = sec_ini; i <= sec_fin; i++)
		out_riskEvaluation += obstacles[i];
	out_riskEvaluation /= (sec_fin - sec_ini + 1);
}

/*---------------------------------------------------------------
	Fills in the representative sector
		field in the gap structure:
  ---------------------------------------------------------------*/
void CHolonomicND::calcRepresentativeSectorForGap(
	TGap& gap, const mrpt::math::TPoint2D& target,
	const std::vector<double>& obstacles)
{
	int sector;
	const unsigned int sectors_to_be_wide =
		round(options.WIDE_GAP_SIZE_PERCENT * obstacles.size());
	const unsigned int target_sector =
		direction2sector(atan2(target.y, target.x), obstacles.size());

	if ((gap.end - gap.ini) <
		sectors_to_be_wide)	 // Select the intermediate sector
	{
#if 1
		sector = round(0.5f * gap.ini + 0.5f * gap.end);
#else
		float min_dist_obs_near_ini = 1, min_dist_obs_near_end = 1;
		int i;
		for (i = gap.ini; i >= max(0, gap.ini - 2); i--)
			min_dist_obs_near_ini = min(min_dist_obs_near_ini, obstacles[i]);
		for (i = gap.end; i <= min((int)obstacles.size() - 1, gap.end + 2); i++)
			min_dist_obs_near_end = min(min_dist_obs_near_end, obstacles[i]);
		sector = round(
			(min_dist_obs_near_ini * gap.ini +
			 min_dist_obs_near_end * gap.end) /
			(min_dist_obs_near_ini + min_dist_obs_near_end));
#endif
	}
	else  // Select a sector close to the target but spaced
	// "sectors_to_be_wide/2" from it
	{
		unsigned int dist_ini = mrpt::abs_diff(target_sector, gap.ini);
		unsigned int dist_end = mrpt::abs_diff(target_sector, gap.end);

		if (dist_ini > 0.5 * obstacles.size())
			dist_ini = obstacles.size() - dist_ini;
		if (dist_end > 0.5 * obstacles.size())
			dist_end = obstacles.size() - dist_end;

		int dir;
		if (dist_ini < dist_end)
		{
			sector = gap.ini;
			dir = +1;
		}
		else
		{
			sector = gap.end;
			dir = -1;
		}

		sector = sector + dir * static_cast<int>(sectors_to_be_wide) / 2;
	}

	keep_max(sector, 0);
	keep_min(sector, static_cast<int>(obstacles.size()) - 1);

	gap.representative_sector = sector;
}

/*---------------------------------------------------------------
						Evaluate each gap
  ---------------------------------------------------------------*/
void CHolonomicND::evaluateGaps(
	const std::vector<double>& obstacles, const double maxObsRange,
	const TGapArray& gaps, const unsigned int target_sector,
	const float target_dist, std::vector<double>& out_gaps_evaluation)
{
	out_gaps_evaluation.resize(gaps.size());

	const double targetAng = CParameterizedTrajectoryGenerator::index2alpha(
		target_sector, obstacles.size());
	const double target_x = target_dist * cos(targetAng);
	const double target_y = target_dist * sin(targetAng);

	for (unsigned int i = 0; i < gaps.size(); i++)
	{
		// Short cut:
		const TGap* gap = &gaps[i];

		const float d = min3(
			obstacles[gap->representative_sector], maxObsRange,
			0.95 * target_dist);

		// The TP-Space representative coordinates for this gap:
		const double phi = CParameterizedTrajectoryGenerator::index2alpha(
			gap->representative_sector, obstacles.size());
		const double x = d * cos(phi);
		const double y = d * sin(phi);

		// Factor #1: Maximum reachable distance with this PTG:
		// -----------------------------------------------------
		// It computes the average free distance of the gap:
		float meanDist = 0.f;
		for (unsigned int j = gap->ini; j <= gap->end; j++)
			meanDist += obstacles[j];
		meanDist /= (gap->end - gap->ini + 1);

		double factor1;
		if (mrpt::abs_diff(gap->representative_sector, target_sector) <= 1 &&
			target_dist < 1)
			factor1 = std::min(target_dist, meanDist) / target_dist;
		else
			factor1 = meanDist;

		// Factor #2: Distance to target in "sectors"
		// -------------------------------------------
		unsigned int dif =
			mrpt::abs_diff(target_sector, gap->representative_sector);

		// Handle the -PI,PI circular topology:
		if (dif > 0.5 * obstacles.size()) dif = obstacles.size() - dif;

		const double factor2 = exp(-square(dif / (obstacles.size() * 0.25)));

		// Factor #3: Punish paths that take us far away wrt the target:  **** I
		// don't understand it *********
		// -----------------------------------------------------
		double closestX, closestY;
		double dist_eucl = math::minimumDistanceFromPointToSegment(
			target_x, target_y,	 // Point
			0, 0, x, y,	 // Segment
			closestX, closestY	// Out
		);

		const float factor3 =
			(maxObsRange - std::min(maxObsRange, dist_eucl)) / maxObsRange;

		// Factor #4: Stabilizing factor (hysteresis) to avoid quick switch
		// among very similar paths:
		// ------------------------------------------------------------------------------------------
		double factor_AntiCab;

		if (m_last_selected_sector != std::numeric_limits<unsigned int>::max())
		{
			unsigned int dist = mrpt::abs_diff(
				m_last_selected_sector, gap->representative_sector);

			if (dist > unsigned(0.1 * obstacles.size())) factor_AntiCab = 0.0;
			else
				factor_AntiCab = 1.0;
		}
		else
		{
			factor_AntiCab = 0;
		}

		ASSERT_(options.factorWeights.size() == 4);

		if (obstacles[gap->representative_sector] <
			options.TOO_CLOSE_OBSTACLE)	 // Too close to obstacles
			out_gaps_evaluation[i] = 0;
		else
			out_gaps_evaluation[i] =
				(options.factorWeights[0] * factor1 +
				 options.factorWeights[1] * factor2 +
				 options.factorWeights[2] * factor3 +
				 options.factorWeights[3] * factor_AntiCab) /
				(math::sum(options.factorWeights));
	}  // for each gap
}

unsigned int CHolonomicND::direction2sector(
	const double a, const unsigned int N)
{
	const int idx = round(0.5 * (N * (1 + mrpt::math::wrapToPi(a) / M_PI) - 1));
	if (idx < 0) return 0;
	else
		return static_cast<unsigned int>(idx);
}

uint8_t CLogFileRecord_ND::serializeGetVersion() const { return 1; }
void CLogFileRecord_ND::serializeTo(mrpt::serialization::CArchive& out) const
{
	out << gaps_ini << gaps_end << gaps_eval;
	out << selectedSector << evaluation << riskEvaluation
		<< (uint32_t)situation;
}

void CLogFileRecord_ND::serializeFrom(
	mrpt::serialization::CArchive& in, uint8_t version)
{
	switch (version)
	{
		case 0:
		{
			int32_t n;

			in >> n;
			gaps_ini.resize(n);
			gaps_end.resize(n);
			in.ReadBuffer(&(*gaps_ini.begin()), sizeof(gaps_ini[0]) * n);
			in.ReadBuffer(&(*gaps_end.begin()), sizeof(gaps_end[0]) * n);

			in >> n;
			gaps_eval.resize(n);
			in.ReadBuffer(&(*gaps_eval.begin()), sizeof(gaps_eval[0]) * n);

			in >> selectedSector >> evaluation >> riskEvaluation >> n;

			situation = (CHolonomicND::TSituations)n;
		}
		break;
		case 1:
		{
			uint32_t n;
			in >> gaps_ini >> gaps_end >> gaps_eval;
			in >> selectedSector >> evaluation >> riskEvaluation >> n;
			situation = (CHolonomicND::TSituations)n;
		}
		break;
		default: MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version);
	};
}

/*---------------------------------------------------------------
						TOptions
  ---------------------------------------------------------------*/
CHolonomicND::TOptions::TOptions() : factorWeights{1.0, 0.5, 2.0, 0.4} {}
void CHolonomicND::TOptions::loadFromConfigFile(
	const mrpt::config::CConfigFileBase& source, const std::string& section)
{
	MRPT_START

	// Load from config text:
	MRPT_LOAD_CONFIG_VAR(WIDE_GAP_SIZE_PERCENT, double, source, section);
	MRPT_LOAD_CONFIG_VAR(
		MAX_SECTOR_DIST_FOR_D2_PERCENT, double, source, section);
	MRPT_LOAD_CONFIG_VAR(
		RISK_EVALUATION_SECTORS_PERCENT, double, source, section);
	MRPT_LOAD_CONFIG_VAR(RISK_EVALUATION_DISTANCE, double, source, section);
	MRPT_LOAD_CONFIG_VAR(TOO_CLOSE_OBSTACLE, double, source, section);
	MRPT_LOAD_CONFIG_VAR(
		TARGET_SLOW_APPROACHING_DISTANCE, double, source, section);

	source.read_vector(
		section, "factorWeights", std::vector<double>(), factorWeights, true);
	ASSERT_(factorWeights.size() == 4);

	MRPT_END
}

void CHolonomicND::TOptions::saveToConfigFile(
	mrpt::config::CConfigFileBase& c, const std::string& s) const
{
	MRPT_START
	const int WN = mrpt::config::MRPT_SAVE_NAME_PADDING(),
			  WV = mrpt::config::MRPT_SAVE_VALUE_PADDING();

	MRPT_SAVE_CONFIG_VAR_COMMENT(WIDE_GAP_SIZE_PERCENT, "");
	MRPT_SAVE_CONFIG_VAR_COMMENT(MAX_SECTOR_DIST_FOR_D2_PERCENT, "");
	MRPT_SAVE_CONFIG_VAR_COMMENT(RISK_EVALUATION_SECTORS_PERCENT, "");
	MRPT_SAVE_CONFIG_VAR_COMMENT(
		RISK_EVALUATION_DISTANCE, "In normalized ps-meters [0,1]");
	MRPT_SAVE_CONFIG_VAR_COMMENT(TOO_CLOSE_OBSTACLE, "For stopping gradually");
	MRPT_SAVE_CONFIG_VAR_COMMENT(
		TARGET_SLOW_APPROACHING_DISTANCE, "In normalized ps-meters");

	ASSERT_EQUAL_(factorWeights.size(), 4);
	c.write(
		s, "factorWeights",
		mrpt::format(
			"%.2f %.2f %.2f %.2f", factorWeights[0], factorWeights[1],
			factorWeights[2], factorWeights[3]),
		WN, WV,
		"[0]=Free space, [1]=Dist. in sectors, [2]=Closer to target "
		"(Euclidean), [3]=Hysteresis");

	MRPT_END
}

uint8_t CHolonomicND::serializeGetVersion() const { return 0; }
void CHolonomicND::serializeTo(mrpt::serialization::CArchive& out) const
{
	// Params:
	out << options.factorWeights << options.MAX_SECTOR_DIST_FOR_D2_PERCENT
		<< options.RISK_EVALUATION_DISTANCE
		<< options.RISK_EVALUATION_SECTORS_PERCENT
		<< options.TARGET_SLOW_APPROACHING_DISTANCE
		<< options.TOO_CLOSE_OBSTACLE << options.WIDE_GAP_SIZE_PERCENT;
	// State:
	out << m_last_selected_sector;
}
void CHolonomicND::serializeFrom(
	mrpt::serialization::CArchive& in, uint8_t version)
{
	switch (version)
	{
		case 0:
		{
			// Params:
			in >> options.factorWeights >>
				options.MAX_SECTOR_DIST_FOR_D2_PERCENT >>
				options.RISK_EVALUATION_DISTANCE >>
				options.RISK_EVALUATION_SECTORS_PERCENT >>
				options.TARGET_SLOW_APPROACHING_DISTANCE >>
				options.TOO_CLOSE_OBSTACLE >> options.WIDE_GAP_SIZE_PERCENT;
			// State:
			in >> m_last_selected_sector;
		}
		break;
		default: MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version);
	};
}
