TRIK feature: Add a metric system (trikset#1959)

* Add a metric system
* Implicitly set default unit in twoDModelWidget
* Change precision for Pixels in Cm spinbox
* Fix clazy warnings
* Fix Vera issues
* Fix all clazy warnings
---------

Co-authored-by: iakov <iakov@users.noreply.github.com>

---------
This `pull request` is one of many proposed ones and is the first step towards updating `twoDModel`. This `pull request` does not address issues related to the `physical parameters` of `world items` or (for example) the ability to resize objects (unless this is already implemented in the previous version).

1. Add the `sizeUnit`(`mm`, `m`, `cm`) field to the <settings> tag in the `WorldModel xml` to specify units of measurement when working with items.
2. Thus, the `coordinates`, `starting position`, and `sizes` for all objects specified in `WorldModel xml` (`robot`, `sensor`, `ball`, `region`, ...) will be interpreted based on the value of the 'sizeUnit` field (pixels by default).
3. The user interface for selecting units of measurement is located in the panel on the bottom right. Changing the unit of measurement implies changing the `Grid` (as well as loading the `WorldModel`) and also affects the further serialization of objects.

<img width="1481" height="913" alt="image" src="https://github.com/user-attachments/assets/f9f6286c-7e0b-46e5-a402-8ea3355f874d" />

4. This functionality is only used for `TRIK twoDModel`. When using the `sizeUnit` field with older `TRIK Studio` versions, all values will be interpreted by default (`pixels`).
5. Add unit tests for `WorldModel` deserialization.
6. Also, in the future, it is necessary to consider the possibility of changing parameters in the `UI` with `PopupItem` in the current units of measurement, as well as making the `Pixels in cm` field editable (part of the next pull request).

Author: MinyazevR

plugins/robots/common/kitBase/include/kitBase/robotModel/configuration.h

@@ -42,11 +42,11 @@ class ROBOTS_KIT_BASE_EXPORT Configuration : public ConfigurationInterface
 
 	void clearDevice(const PortInfo &port) override;
 
-signals:
+Q_SIGNALS:
 	/// Emitted when all pending devices are configured (or failed to configure).
 	void allDevicesConfigured();
 
-private slots:
+private Q_SLOTS:
 	/// Called when some device is finished configuring.
 	/// @param success - true if configuration was successful.
 	void onDeviceConfigured(bool success);

plugins/robots/common/kitBase/include/kitBase/robotModel/configurationInterface.h

@@ -53,7 +53,7 @@ class ROBOTS_KIT_BASE_EXPORT ConfigurationInterface : public QObject
 	/// Removes device on a given port from configuration.
 	virtual void clearDevice(const PortInfo &port) = 0;
 
-signals:
+Q_SIGNALS:
 	/// Emitted when some device is ready to be used.
 	void deviceConfigured(robotParts::Device *device);
 };

plugins/robots/common/kitBase/include/kitBase/robotModel/portInfo.h

@@ -97,7 +97,7 @@ inline bool operator !=(const PortInfo &left, const PortInfo &right)
 	return !(left == right);
 }
 
-inline uint qHash(const PortInfo &key)
+inline size_t qHash(const PortInfo &key)
 {
 	return qHash(key.name()) ^ qHash(QString(key.direction() == input ? "input" : "output"));
 }

plugins/robots/common/kitBase/include/kitBase/robotModel/robotModelInterface.h

@@ -180,11 +180,11 @@ class ROBOTS_KIT_BASE_EXPORT RobotModelInterface : public QObject
 	///       failures in common code.
 	virtual utils::TimelineInterface &timeline() = 0;
 
-public slots:
+public Q_SLOTS:
 	/// Called each time when interpretation starts its work. Implementation must reset robot to its default state.
 	virtual void onInterpretationStarted() = 0;
 
-signals:
+Q_SIGNALS:
 	/// Emitted when model is connected to a robot. If there is no need to connect (for example, 2d model), emitted
 	/// immediately after connectToRobot() call.
 	/// @param success - true, if connected successfully.

plugins/robots/common/kitBase/include/kitBase/robotModel/robotParts/device.h

@@ -54,7 +54,7 @@ class ROBOTS_KIT_BASE_EXPORT Device : public QObject
 	/// Configure device.
 	void configure();
 
-signals:
+Q_SIGNALS:
 	/// Emitted when device finished its configuration, successfully or by failure. Note that configuration can be
 	/// synchronous or asynchronous for various devices (configure() can be in a stack when this signal is emitted).
 	/// Shall not be emitted directly from descendants, use configurationCompleted() instead due to timeout handling
@@ -73,7 +73,7 @@ class ROBOTS_KIT_BASE_EXPORT Device : public QObject
 	/// Concrete devices shall call this method when they finish their configuration.
 	void configurationCompleted(bool success);
 
-private slots:
+private Q_SLOTS:
 	/// Called when configuration takes more than timeout time. Note that if configuration is done synchronously,
 	/// timer signal will never be emitted and this slot will not be called.
 	void configurationTimerTimeoutSlot();

plugins/robots/common/twoDModel/include/twoDModel/engine/model/metricCoordinateSystem.h

@@ -0,0 +1,55 @@
+/* Copyright 2025 CyberTech Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. */
+
+#pragma once
+#include <QObject>
+#include <QPointer>
+#include <qrutils/graphicsUtils/abstractCoordinateSystem.h>
+
+namespace twoDModel {
+
+namespace model {
+
+class SizeUnit;
+
+/// The metric system, which is an implementation of the qrutils
+/// AbstractCoordinateSystem interface for using the metric system in 2D model items
+class MetricCoordinateSystem: public graphicsUtils::AbstractCoordinateSystem
+{
+	Q_OBJECT
+public:
+	explicit MetricCoordinateSystem(twoDModel::model::SizeUnit *metricSystem,
+					QObject* parent = nullptr);
+
+	~MetricCoordinateSystem();
+
+	/// Conversе of units of measurement into pixels
+	qreal toPx(const qreal size) const override;
+
+	/// Conversе of QPointF into pixels
+	QPointF toPx(const QPointF &size) const override;
+
+	/// Converting pixels to units of measurement
+	qreal toUnit(const qreal size) const override;
+
+	/// Converting pixels to QPointF
+	QPointF toUnit(const QPointF &size) const override;
+private:
+	// Doesn't take ownership, ownership is twoDModel::model::Settings.
+	// The lifetime of this object is greater than MetricCoordinateSystem (see Model.h)
+	QPointer<twoDModel::model::SizeUnit> mMetricSystem;
+};
+
+}
+}

plugins/robots/common/twoDModel/include/twoDModel/engine/model/metricSystem.h

@@ -0,0 +1,76 @@
+/* Copyright 2025 CyberTech Labs Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License. */
+
+#pragma once
+
+#include <QtCore/QObject>
+#include "constants.h"
+#include "twoDModel/twoDModelDeclSpec.h"
+
+class QDomElement;
+
+namespace twoDModel {
+namespace model {
+
+/// Incapsulates size unit settings used by 2D model.
+class TWO_D_MODEL_EXPORT SizeUnit : public QObject
+{
+	Q_OBJECT
+
+public:
+	/// Possible units of measurement
+	enum class Unit {
+		Pixels
+		, Centimeters
+		, Meters
+		, Millimeters
+	};
+
+	SizeUnit() = default;
+
+	/// The current pixel value in centimeters
+	qreal pixelsInCm() const;
+
+	/// Serialize the sizeUnit in the WorldModel
+	void serialize(QDomElement &parent) const;
+
+	/// Derialize the sizeUnit in the WorldModel
+	void deserialize(const QDomElement &parent);
+
+	/// Set the current unit of measurement
+	void setUnit(twoDModel::model::SizeUnit::Unit unit);
+
+	/// Multiplier for conversion to pixels
+	qreal countFactor() const;
+
+	/// Convert size from WorldModel to pixels
+	qreal toPx(const qreal size) const;
+
+	std::map<QString, Unit> currentValues() const;
+
+	Unit defaultUnit() const;
+
+Q_SIGNALS:
+	/// Emit when the sizeUnit is serialized
+	void sizeUnitChanged(const twoDModel::model::SizeUnit::Unit &unit);
+
+private:
+	Unit mSizeUnit { Unit::Pixels };
+	qreal mPixelsInCm { twoDModel::pixelsInCm };
+};
+
+}
+}
+
+Q_DECLARE_METATYPE(twoDModel::model::SizeUnit::Unit)

plugins/robots/common/twoDModel/include/twoDModel/engine/model/model.h

@@ -18,6 +18,7 @@
 #include "robotModel.h"
 #include "timeline.h"
 #include "settings.h"
+#include "metricCoordinateSystem.h"
 #include <twoDModel/robotModel/twoDRobotModel.h>
 
 #include "twoDModel/twoDModelDeclSpec.h"
@@ -39,14 +40,20 @@ class ConstraintsChecker;
 
 namespace model {
 
+namespace physics {
+class PhysicsEngineFactory;
+}
+
 /// A main class managing model part of 2D emulator. Creates and maintains different parts
 /// such as world map, robot model, timelines and physical engines.
 class TWO_D_MODEL_EXPORT Model : public QObject
 {
 	Q_OBJECT
 
 public:
-	explicit Model(QObject *parent = nullptr);
+	/// Dependency injection for the physics engine
+	explicit Model(physics::PhysicsEngineFactory *engineFactory,
+	               QObject *parent = nullptr);
 	~Model();
 
 	void init(qReal::ErrorReporterInterface &errorReporter
@@ -65,6 +72,9 @@ class TWO_D_MODEL_EXPORT Model : public QObject
 	/// Returns a reference to a 2D model`s settings storage.
 	Settings &settings();
 
+	/// Metric coordinate system for usage in twoDModelWidget
+	MetricCoordinateSystem &coordinateMetricSystem();
+
 	/// Returns a pointer to an object that reports system errors.
 	qReal::ErrorReporterInterface *errorReporter();
 
@@ -74,7 +84,7 @@ class TWO_D_MODEL_EXPORT Model : public QObject
 	/// Add new robot model
 	/// @param robotModel Model to be added
 	/// @param pos Initial positon of robot model
-	void addRobotModel(robotModel::TwoDRobotModel &robotModel, const QPointF &pos = QPointF());
+	void addRobotModel(robotModel::TwoDRobotModel &robotModel, QPointF pos = QPointF());
 
 	/// Remove robot model
 	void removeRobotModel();
@@ -88,7 +98,7 @@ class TWO_D_MODEL_EXPORT Model : public QObject
 	/// Activates or deactivates constraints checker.
 	void setConstraintsEnabled(bool enabled);
 
-signals:
+Q_SIGNALS:
 	/// Emitted each time when some user actions lead to world model modifications
 	/// @param xml World model description in xml format
 	void modelChanged(const QDomDocument &xml);
@@ -99,28 +109,30 @@ class TWO_D_MODEL_EXPORT Model : public QObject
 
 	/// Emitted after new robot model added
 	/// @param robotModel Pointer to robot model which was removed
-	void robotAdded(RobotModel *robotModel);
+	void robotAdded(twoDModel::model::RobotModel *robotModel);
 
 	/// Emitted after robot model removed
 	/// @param robotModel Pointer to robot model which was added
-	void robotRemoved(RobotModel *robotModel);
+	void robotRemoved(twoDModel::model::RobotModel *robotModel);
 
-private slots:
+private Q_SLOTS:
 	void resetPhysics();
 	void recalculatePhysicsParams();
 
 private:
 	void initPhysics();
 
-	Settings mSettings;
+	QPointer<Settings> mSettings; //Has ownership
+	QPointer<MetricCoordinateSystem> mMetricCoordinateSystem; //Has ownership
 	WorldModel mWorldModel;
 	Timeline mTimeline;
 	QScopedPointer<constraints::ConstraintsChecker> mChecker;
 	RobotModel * mRobotModel {}; //Has ownership
 	qReal::ErrorReporterInterface *mErrorReporter;  // Doesn`t take ownership.
 	qReal::LogicalModelAssistInterface *mLogicalModel;  // Doesn`t take ownership.
-	physics::PhysicsEngineBase *mRealisticPhysicsEngine;  // Takes ownership.
-	physics::PhysicsEngineBase *mSimplePhysicsEngine;  // Takes ownership.
+	QScopedPointer<physics::PhysicsEngineFactory> mEngineFactory;
+	physics::PhysicsEngineBase *mRealisticPhysicsEngine {};  // Takes ownership.
+	physics::PhysicsEngineBase *mSimplePhysicsEngine {};  // Takes ownership.
 	quint64 mStartTimestamp {0};
 };
 

plugins/robots/common/twoDModel/include/twoDModel/engine/model/robotModel.h

@@ -35,6 +35,7 @@ class StartPosition;
 
 namespace model {
 
+class MetricCoordinateSystem;
 class Settings;
 namespace physics {
 class PhysicsEngineBase;
@@ -76,7 +77,9 @@ class TWO_D_MODEL_EXPORT RobotModel : public QObject
 	};
 
 	RobotModel(twoDModel::robotModel::TwoDRobotModel &robotModel
-			, const Settings &settings, QObject *parent = nullptr);
+		   , Settings *settings
+		   , twoDModel::model::MetricCoordinateSystem *metricSystem
+	           , QObject *parent = nullptr);
 
 	~RobotModel();
 
@@ -104,7 +107,7 @@ class TWO_D_MODEL_EXPORT RobotModel : public QObject
 	Q_INVOKABLE void resetEncoder(const kitBase::robotModel::PortInfo &port);
 
 	QPointF position() const;
-	void setPosition(const QPointF &newPos);
+	void setPosition(QPointF newPos);
 
 	qreal rotation() const;
 	void setRotation(qreal angle);
@@ -126,6 +129,7 @@ class TWO_D_MODEL_EXPORT RobotModel : public QObject
 	void onRobotReturnedOnGround();
 
 	void setMotorPortOnWheel(WheelEnum wheel, const kitBase::robotModel::PortInfo &port);
+	kitBase::robotModel::PortInfo getPortInfoOnWheel(WheelEnum wheel) const;
 
 	QRectF sensorRect(const kitBase::robotModel::PortInfo &port, const QPointF sensorPos) const;
 	QPainterPath sensorBoundingPath(const kitBase::robotModel::PortInfo &port) const;
@@ -186,7 +190,8 @@ public slots:
 	void playingSoundChanged(bool playing);
 
 	/// Emitted when left or right wheel was reconnected to another port.
-	void wheelOnPortChanged(WheelEnum wheel, const kitBase::robotModel::PortInfo &port);
+	void wheelOnPortChanged(twoDModel::model::RobotModel::WheelEnum wheel,
+				const kitBase::robotModel::PortInfo &port);
 
 private:
 	QVector2D robotDirectionVector() const;
@@ -218,10 +223,11 @@ public slots:
 	/// Describes which wheel is driven by which motor.
 	QHash<WheelEnum, kitBase::robotModel::PortInfo> mWheelsToMotorPortsMap;
 	QHash<kitBase::robotModel::PortInfo, kitBase::robotModel::PortInfo> mMotorToEncoderPortMap;
-
-	const Settings &mSettings;
+	// Doesn't take ownership, ownership is twoDModel::model::Model.
+	QPointer<Settings> mSettings;
 	twoDModel::robotModel::TwoDRobotModel &mRobotModel;
-	SensorsConfiguration mSensorsConfiguration;
+	// Takes ownership.
+	QPointer<SensorsConfiguration> mSensorsConfiguration;
 
 	QPointF mPos { 0, 0 };
 	qreal mAngle { 0 };
@@ -238,6 +244,8 @@ public slots:
 	physics::PhysicsEngineBase *mPhysicsEngine {};  // Does not take ownership
 
 	QPointer<items::StartPosition> mStartPositionMarker;
+	// Doesn't take ownership, ownership is twoDModel::model::Model.
+	QPointer<twoDModel::model::MetricCoordinateSystem> mMetricSystem;
 };
 
 }