refs #796, started to move rendering distance/max.aircraft to CInterpolationAndRenderingSetup

(this will allow to remove a lot of signatures in context/simulator interface)

src/blackmisc/interpolationsetup.cpp

@@ -10,11 +10,93 @@
 #include "blackmisc/interpolationsetup.h"
 #include "stringutils.h"
 
+using namespace BlackMisc::PhysicalQuantities;
+
 namespace BlackMisc
 {
     CInterpolationAndRenderingSetup::CInterpolationAndRenderingSetup()
     { }
 
+    int CInterpolationAndRenderingSetup::InfiniteAircraft()
+    {
+        return 100;
+    }
+
+    bool CInterpolationAndRenderingSetup::isRenderingEnabled() const
+    {
+        if (m_maxRenderedAircraft < 1)  { return false; }
+        if (!isMaxDistanceRestricted()) { return true; }
+        return m_maxRenderedDistance.isPositiveWithEpsilonConsidered();
+    }
+
+    int CInterpolationAndRenderingSetup::getMaxRenderedAircraft() const
+    {
+        return (m_maxRenderedAircraft <= InfiniteAircraft()) ? m_maxRenderedAircraft : InfiniteAircraft();
+    }
+
+    bool CInterpolationAndRenderingSetup::setMaxRenderedAircraft(int maxRenderedAircraft)
+    {
+        if (maxRenderedAircraft == m_maxRenderedAircraft) { return false; }
+        if (maxRenderedAircraft < 1)
+        {
+            // disable, we set both values to 0
+            m_maxRenderedAircraft = 0;
+            m_maxRenderedDistance = CLength(0.0, CLengthUnit::NM()); // real 0
+        }
+        else if (maxRenderedAircraft >= InfiniteAircraft())
+        {
+            m_maxRenderedAircraft = InfiniteAircraft();
+        }
+        else
+        {
+            m_maxRenderedAircraft = maxRenderedAircraft;
+        }
+        return true;
+    }
+
+    bool CInterpolationAndRenderingSetup::setMaxRenderedDistance(const CLength &distance)
+    {
+
+        if (distance == m_maxRenderedDistance) { return false; }
+        if (distance.isNull() || distance.isNegativeWithEpsilonConsidered())
+        {
+            m_maxRenderedDistance = CLength(0.0, CLengthUnit::nullUnit());
+        }
+        else if (distance.isZeroEpsilonConsidered())
+        {
+            // zero means disabled, we disable max aircraft too
+            this->m_maxRenderedAircraft = 0;
+            this->m_maxRenderedDistance = CLength(0.0, CLengthUnit::NM()); // real 0
+        }
+        else
+        {
+            Q_ASSERT(!distance.isNegativeWithEpsilonConsidered());
+            m_maxRenderedDistance = distance;
+        }
+        return true;
+    }
+
+    void CInterpolationAndRenderingSetup::disableMaxRenderedDistance()
+    {
+        this->setMaxRenderedDistance(CLength(0.0, CLengthUnit::nullUnit()));
+    }
+
+    bool CInterpolationAndRenderingSetup::isMaxAircraftRestricted() const
+    {
+        return m_maxRenderedAircraft < InfiniteAircraft();
+    }
+
+    void CInterpolationAndRenderingSetup::deleteAllRenderingRestrictions()
+    {
+        this->m_maxRenderedDistance = CLength(0, CLengthUnit::nullUnit());
+        this->m_maxRenderedAircraft = InfiniteAircraft();
+    }
+
+    bool CInterpolationAndRenderingSetup::isMaxDistanceRestricted() const
+    {
+        return !m_maxRenderedDistance.isNull();
+    }
+
     QString CInterpolationAndRenderingSetup::convertToQString(bool i18n) const
     {
         Q_UNUSED(i18n);
@@ -24,6 +106,10 @@ namespace BlackMisc
         s += boolToYesNo(this->m_interpolatorDebugMessage);
         s += " force full interpolation: ";
         s += boolToYesNo(this->m_forceFullInterpolation);
+        s += " max.aircraft:";
+        s += QString::number(m_maxRenderedAircraft);
+        s += " max.distance:";
+        s += m_maxRenderedDistance.valueRoundedWithUnit(CLengthUnit::NM(), 2);
         return s;
     }
 
@@ -39,6 +125,10 @@ namespace BlackMisc
             return CVariant::fromValue(m_simulatorDebugMessages);
         case IndexForceFullInterpolation:
             return CVariant::fromValue(m_forceFullInterpolation);
+        case IndexMaxRenderedAircraft:
+            return CVariant::fromValue(m_maxRenderedAircraft);
+        case IndexMaxRenderedDistance:
+            return CVariant::fromValue(m_maxRenderedDistance);
         default:
             return CValueObject::propertyByIndex(index);
         }
@@ -63,6 +153,12 @@ namespace BlackMisc
         case IndexForceFullInterpolation:
             this->m_forceFullInterpolation = variant.toBool();
             break;
+        case IndexMaxRenderedAircraft:
+            this->m_maxRenderedAircraft = variant.toInt();
+            break;
+        case IndexMaxRenderedDistance:
+            this->m_maxRenderedDistance = variant.value<CLength>();
+            break;
         default:
             CValueObject::setPropertyByIndex(index, variant);
             break;

src/blackmisc/interpolationsetup.h

@@ -9,9 +9,10 @@
 
 //! \file
 
-#ifndef BLACKMISC_INTERPOLATION_SETUP_H
-#define BLACKMISC_INTERPOLATION_SETUP_H
+#ifndef BLACKMISC_INTERPOLATION_RENDERING_SETUP_H
+#define BLACKMISC_INTERPOLATION_RENDERING_SETUP_H
 
+#include "blackmisc/pq/length.h"
 #include "blackmisc/blackmiscexport.h"
 #include "blackmisc/propertyindex.h"
 #include "blackmisc/valueobject.h"
@@ -31,12 +32,17 @@ namespace BlackMisc
         {
             IndexInterpolatorDebugMessages = BlackMisc::CPropertyIndex::GloablIndexInterpolatorSetup,
             IndexSimulatorDebugMessages,
-            IndexForceFullInterpolation
+            IndexForceFullInterpolation,
+            IndexMaxRenderedAircraft,
+            IndexMaxRenderedDistance
         };
 
         //! Constructor.
         CInterpolationAndRenderingSetup();
 
+        //! Considered as "all aircraft"
+        static int InfiniteAircraft();
+
         //! Debugging messages
         bool showInterpolatorDebugMessages() const { return m_interpolatorDebugMessage; }
 
@@ -50,11 +56,38 @@ namespace BlackMisc
         void setDriverDebuggingMessages(bool debug) { m_simulatorDebugMessages = debug; }
 
         //! Full interpolation
-        bool forceFullInterpolation() const { return m_forceFullInterpolation; }
+        bool isForcingFullInterpolation() const { return m_forceFullInterpolation; }
 
         //! Force full interpolation
         void setForceFullInterpolation(bool force) { m_forceFullInterpolation = force; }
 
+        //! Max. number of aircraft rendered
+        int getMaxRenderedAircraft() const;
+
+        //! Max. number of aircraft rendered
+        bool setMaxRenderedAircraft(int maxRenderedAircraft);
+
+        //! Max. distance for rendering
+        bool setMaxRenderedDistance(const BlackMisc::PhysicalQuantities::CLength &distance);
+
+        //! Disable
+        void disableMaxRenderedDistance();
+
+        //! Rendering enabled
+        bool isRenderingEnabled() const;
+
+        //! Max. distance for rendering
+        BlackMisc::PhysicalQuantities::CLength getMaxRenderedDistance() const { return m_maxRenderedDistance; }
+
+        //! Restricted by distance?
+        bool isMaxDistanceRestricted() const;
+
+        //! Restricted by quantity?
+        bool isMaxAircraftRestricted() const;
+
+        //! Disable all render restrictions
+        void deleteAllRenderingRestrictions();
+
         //! \copydoc BlackMisc::Mixin::String::toQString
         QString convertToQString(bool i18n = false) const;
 
@@ -68,12 +101,16 @@ namespace BlackMisc
         bool m_interpolatorDebugMessage = false;  //! Debug messages in interpolator
         bool m_simulatorDebugMessages = false;    //! Debug messages of simulator (aka plugin)
         bool m_forceFullInterpolation = false;    //! always do a full interpolation, even if aircraft is not moving
+        int  m_maxRenderedAircraft = InfiniteAircraft(); //!< max.rendered aircraft
+        BlackMisc::PhysicalQuantities::CLength m_maxRenderedDistance { 0.0, BlackMisc::PhysicalQuantities::CLengthUnit::nullUnit()}; //!< max.distance for rendering
 
         BLACK_METACLASS(
             CInterpolationAndRenderingSetup,
             BLACK_METAMEMBER(interpolatorDebugMessage),
             BLACK_METAMEMBER(simulatorDebugMessages),
-            BLACK_METAMEMBER(forceFullInterpolation)
+            BLACK_METAMEMBER(forceFullInterpolation),
+            BLACK_METAMEMBER(maxRenderedAircraft),
+            BLACK_METAMEMBER(maxRenderedDistance)
         );
     };
 } // namespace

src/blackmisc/interpolatorlinear.cpp

@@ -132,7 +132,7 @@ namespace BlackMisc
                                                + oldAlt,
                                                oldAlt.getReferenceDatum()));
 
-        if (!setup.forceFullInterpolation() && !vtolAiracraft && newVec == oldVec && oldAlt == newAlt)
+        if (!setup.isForcingFullInterpolation() && !vtolAiracraft && newVec == oldVec && oldAlt == newAlt)
         {
             // stop interpolation here, does not work for VTOL aircraft. We need a flag for VTOL aircraft
             return currentSituation;