Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
       4             : // This program and the accompanying materials are made available under the
       5             : // terms of the Eclipse Public License 2.0 which is available at
       6             : // https://www.eclipse.org/legal/epl-2.0/
       7             : // This Source Code may also be made available under the following Secondary
       8             : // Licenses when the conditions for such availability set forth in the Eclipse
       9             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10             : // or later which is available at
      11             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13             : /****************************************************************************/
      14             : /// @file    TrackerValueDesc.cpp
      15             : /// @author  Daniel Krajzewicz
      16             : /// @author  Jakob Erdmann
      17             : /// @author  Michael Behrisch
      18             : /// @author  Laura Bieker
      19             : /// @date    Sept 2002
      20             : ///
      21             : // Storage for a tracked value
      22             : /****************************************************************************/
      23             : #include <config.h>
      24             : 
      25             : #include <string>
      26             : #include <vector>
      27             : #include <utils/common/RGBColor.h>
      28             : #include <utils/gui/globjects/GUIGlObject.h>
      29             : #include "TrackerValueDesc.h"
      30             : 
      31             : 
      32             : // ===========================================================================
      33             : // method definitions
      34             : // ===========================================================================
      35           0 : TrackerValueDesc::TrackerValueDesc(const std::string& name,
      36             :                                    const RGBColor& col,
      37             :                                    SUMOTime recordBegin,
      38           0 :                                    double aggregationSeconds)
      39           0 :     : myName(name), myActiveCol(col), myInactiveCol(col),
      40           0 :       myMin(0), myMax(0),
      41           0 :       myAggregationInterval(MAX2(1, (int)(TIME2STEPS(aggregationSeconds) / DELTA_T))),
      42           0 :       myInvalidValue(INVALID_DOUBLE),
      43           0 :       myValidNo(0),
      44           0 :       myRecordingBegin(recordBegin), myTmpLastAggValue(0) {}
      45             : 
      46             : 
      47           0 : TrackerValueDesc::~TrackerValueDesc() {
      48             :     // just to quit cleanly on a failure
      49           0 :     if (myLock.locked()) {
      50           0 :         myLock.unlock();
      51             :     }
      52           0 : }
      53             : 
      54             : 
      55             : void
      56           0 : TrackerValueDesc::addValue(double value) {
      57           0 :     if (myValues.size() == 0) {
      58           0 :         myMin = value;
      59           0 :         myMax = value;
      60             :     } else {
      61           0 :         myMin = value < myMin ? value : myMin;
      62           0 :         myMax = value > myMax ? value : myMax;
      63             :     }
      64           0 :     FXMutexLock locker(myLock);
      65           0 :     myValues.push_back(value);
      66           0 :     if (value != myInvalidValue) {
      67           0 :         myTmpLastAggValue += value;
      68           0 :         myValidNo++;
      69             :     }
      70           0 :     const double avg = myValidNo == 0 ? static_cast<double>(0) : myTmpLastAggValue / static_cast<double>(myValidNo);
      71           0 :     if (myAggregationInterval == 1 || myValues.size() % myAggregationInterval == 1) {
      72           0 :         myAggregatedValues.push_back(avg);
      73             :     } else {
      74           0 :         myAggregatedValues.back() = avg;
      75             :     }
      76           0 :     if (myValues.size() % myAggregationInterval == 0) {
      77           0 :         myTmpLastAggValue = 0;
      78           0 :         myValidNo = 0;
      79             :     }
      80           0 : }
      81             : 
      82             : 
      83             : double
      84           0 : TrackerValueDesc::getRange() const {
      85           0 :     return myMax - myMin;
      86             : }
      87             : 
      88             : 
      89             : double
      90           0 : TrackerValueDesc::getMin() const {
      91           0 :     return myMin;
      92             : }
      93             : 
      94             : 
      95             : double
      96           0 : TrackerValueDesc::getMax() const {
      97           0 :     return myMax;
      98             : }
      99             : 
     100             : 
     101             : double
     102           0 : TrackerValueDesc::getYCenter() const {
     103           0 :     return (myMin + myMax) / 2.0f;
     104             : }
     105             : 
     106             : 
     107             : const RGBColor&
     108           0 : TrackerValueDesc::getColor() const {
     109           0 :     return myActiveCol;
     110             : }
     111             : 
     112             : 
     113             : const std::vector<double>&
     114           0 : TrackerValueDesc::getValues() {
     115           0 :     myLock.lock();
     116           0 :     return myValues;
     117             : }
     118             : 
     119             : 
     120             : const std::vector<double>&
     121           0 : TrackerValueDesc::getAggregatedValues() {
     122           0 :     myLock.lock();
     123           0 :     return myAggregatedValues;
     124             : }
     125             : 
     126             : 
     127             : const std::string&
     128           0 : TrackerValueDesc::getName() const {
     129           0 :     return myName;
     130             : }
     131             : 
     132             : void
     133           0 : TrackerValueDesc::unlockValues() {
     134           0 :     myLock.unlock();
     135           0 : }
     136             : 
     137             : 
     138             : void
     139           0 : TrackerValueDesc::setAggregationSpan(SUMOTime as) {
     140           0 :     FXMutexLock locker(myLock);
     141           0 :     if (myAggregationInterval != as / DELTA_T) {
     142           0 :         myAggregationInterval = (int)(as / DELTA_T);
     143             :         // ok, the aggregation has changed,
     144             :         //  let's recompute the list of aggregated values
     145           0 :         myAggregatedValues.clear();
     146             :         std::vector<double>::const_iterator i = myValues.begin();
     147           0 :         while (i != myValues.end()) {
     148           0 :             myTmpLastAggValue = 0;
     149           0 :             myValidNo = 0;
     150           0 :             for (int j = 0; j < myAggregationInterval && i != myValues.end(); j++, ++i) {
     151           0 :                 if ((*i) != myInvalidValue) {
     152           0 :                     myTmpLastAggValue += (*i);
     153           0 :                     myValidNo++;
     154             :                 }
     155             :             }
     156           0 :             if (myValidNo == 0) {
     157           0 :                 myAggregatedValues.push_back(0);
     158             :             } else {
     159           0 :                 myAggregatedValues.push_back(myTmpLastAggValue / static_cast<double>(myValidNo));
     160             :             }
     161             :         }
     162             :     }
     163           0 : }
     164             : 
     165             : 
     166             : SUMOTime
     167           0 : TrackerValueDesc::getAggregationSpan() const {
     168           0 :     return myAggregationInterval * DELTA_T;
     169             : }
     170             : 
     171             : 
     172             : SUMOTime
     173           0 : TrackerValueDesc::getRecordingBegin() const {
     174           0 :     return myRecordingBegin;
     175             : }
     176             : 
     177             : 
     178             : /****************************************************************************/