Line data    Source code

       1             : /**
       2             :    Bojan Nikolic <b.nikolic@mrao.cam.ac.uk>, <bojan@bnikolic.co.uk>
       3             :    Initial version March 2010.
       4             :    Maintained by ESO since 2013.
       5             : 
       6             :    This file is part of LibAIR and is licensed under GNU Public
       7             :    License Version 2
       8             : 
       9             :    \file segmentation.cpp
      10             :    Renamed segmentation.cc 2023
      11             : 
      12             : */
      13             : 
      14             : #include "segmentation.h"
      15             : 
      16             : namespace LibAIR2 {
      17             : 
      18           0 :   void fieldSegments(const std::vector<double> &time,
      19             :                      const std::vector<int> &fieldID,
      20             :                      std::vector<std::pair<double, double> > &res)
      21             :   {
      22           0 :     res.clear();
      23           0 :     std::pair<double, double> cp;
      24           0 :     cp.first=time[0];
      25           0 :     int cf=fieldID[0];
      26           0 :     for(size_t i=1; i<fieldID.size(); ++i)
      27             :     {
      28           0 :       if (fieldID[i]!=cf)
      29             :       {
      30           0 :         cp.second=time[i-1];
      31           0 :         res.push_back(cp);
      32           0 :         cp.first=time[i];
      33           0 :         cf=fieldID[i];
      34             :       }
      35             :     }
      36           0 :     cp.second=time[fieldID.size()-1];
      37           0 :     res.push_back(cp);
      38           0 :   }
      39             : 
      40          57 :   bool areTied(const std::vector<std::set<size_t> > &tied,
      41             :                size_t i,
      42             :                size_t j)
      43             :   {
      44          63 :     for(size_t k=0; k<tied.size(); ++k)
      45             :     {
      46           9 :       if (tied[k].count(i) && tied[k].count(j))
      47             :       {
      48             :         // i and j are in the same set, therefore not a transition
      49           3 :         return true;
      50             :       }
      51             :     }
      52          54 :     return false;
      53             :   }
      54          19 :   void fieldSegmentsTied(const std::vector<double> &time,
      55             :                          const std::vector<int> &fieldID,
      56             :                          const std::vector<std::set<size_t> > &tied,
      57             :                          std::vector<std::pair<double, double> > &res)
      58             :   {
      59          19 :     res.clear();
      60          19 :     std::pair<double, double> cp;
      61          19 :     cp.first=time[0];
      62          19 :     int cf=fieldID[0];
      63      510409 :     for(size_t i=1; i<fieldID.size(); ++i)
      64             :     {
      65      510390 :       if (fieldID[i]!=cf)
      66             :       {
      67          57 :         if (not areTied(tied, fieldID[i], cf))
      68             :         {
      69          54 :           cp.second=time[i-1];
      70          54 :           res.push_back(cp);
      71          54 :           cp.first=time[i];
      72             :         }
      73          57 :         cf=fieldID[i];
      74             :       }
      75             :     }
      76          19 :     cp.second=time[fieldID.size()-1];
      77          19 :     res.push_back(cp);
      78          19 :   }
      79             : 
      80           1 :   void fieldTimes(const std::vector<double> &time,
      81             :                   const std::vector<int> &fieldID,
      82             :                   const std::vector<size_t> &spw,
      83             :                   const std::set<size_t>  &fieldselect,
      84             :                   size_t spwselect,
      85             :                   std::vector<std::pair<double, double> > &res)
      86             :   {
      87           1 :     res.resize(0);
      88           1 :     size_t b=0;
      89           1 :     size_t l=0;
      90           1 :     bool infield=false;
      91         613 :     for (size_t i=0; i<time.size(); ++i)
      92             :     {
      93             :       // Skip all rows which are not in our SPW
      94         612 :       if (spw[i] !=spwselect)
      95           0 :         continue;
      96             : 
      97         612 :       if ( (not infield) && fieldselect.count(fieldID[i]))
      98             :       {
      99           1 :         infield=true;
     100           1 :         b=i;
     101             :       }
     102             :       
     103         612 :       if (infield && ( (not fieldselect.count(fieldID[i]))  || (i==time.size()-1)))
     104             :       {
     105           1 :         infield=false;
     106           1 :         res.push_back(std::pair<double, double>(time[b], time[l]));
     107             :       }
     108             :       // Keep the time of last iteration
     109         612 :       l=i;
     110             :     }
     111           1 :   }
     112             : 
     113             : }