resample()

ts::TDsfftimeseries ts::ipo::resample	(	const Interpolator &	ip,
		const libtime::TAbsoluteTime &	first,
		const libtime::TRelativeTime &	dt,
		const int &	n,
		const bool &	shrink = false
	)

resample a time series

function to resample data

This function provides resampling on the base of a reference to an instance of an interpolator class (containing the input time series) and a definition of sampling in terms of the time of the first sample, a sampling interval and the desired number of samples.

Optionally this function adjusts the time window for which resampling is done to a time span inside the time window for which input data is available. In this case the time of the first sample is adjusted such that it is offset from the originally requested time by an integer number of sampling intervals.

If the option shrink is not used, exception ipo::ExceptionTimeWindowOutside will be thrown if not all of the requested sample values are within the time window of the original series.

Parameters

ip	reference to a waveform interpolator
first	time of first sample in new time series
dt	sampling interval of new time series
n	number of samples in new time series
shrink	if true, shrink time window such, that input data is available for the whole window

Returns

resampled time series with time header fields adjusted

Definition at line 72 of file ipo.cc.

References ts::ipo::Interpolator::debug(), ts::seife::first(), ts::ipo::Interpolator::header(), TSXX_debug, and TSXX_Xassert.

    {
      typedef Interpolator::Ttimeseries Ttimeseries;
      typedef Ttimeseries::Theader Theader;
      typedef Ttimeseries::Tseries Tseries;
      using libtime::TAbsoluteTime;
      using libtime::TRelativeTime;
      using libtime::TRange;
      Theader hd=ip.header();
      TAbsoluteTime old_first=hd.date;
      TAbsoluteTime old_last=sff::wid2lastsample(hd);
      TAbsoluteTime new_first=first;
      TAbsoluteTime new_last=new_first+(n-1)*dt;
      int nsamples=n;
      // if requested, shrink time window to available data
      if (shrink)
      {
        if (old_first > new_first)
        {
          int noff=(old_first-new_first)/dt;
          new_first += (dt*noff);
          nsamples -= noff;
          while (new_first < old_first) { new_first += dt; nsamples--; }
        }
        if (old_last < new_last)
        {
          int noff=(new_last-old_last)/dt;
          new_last -= (dt*noff);
          nsamples -= noff;
          while (new_last > old_last) { new_last -= dt; nsamples--; }
        }
        TSXX_Xassert(nsamples > 0,
                    "new time window is empty",
                    ExceptionTimeWindowEmpty);
      }
      TSXX_debug(ip.debug(), "resample",
                 "window covered by input series:\n         " 
                 << old_first.timestring() << " - "
                 << old_last.timestring());
      TSXX_debug(ip.debug(), "resample",
                 "window requested for output series:\n         " 
                 << new_first.timestring() << " - "
                 << new_last.timestring());
      TRange inputwindow(old_first, old_last);
      TRange outputwindow(new_first, new_last);
      TSXX_Xassert((inputwindow.includes(outputwindow)),
                  "new time span is outside time series",
                  ExceptionTimeWindowOutside);
      Ttimeseries retval=Ttimeseries(Tseries(nsamples), hd);
      retval.header.date=new_first;
      retval.header.nsamples=nsamples;
      retval.header.dt=libtime::time2double(dt);
      TAbsoluteTime it=new_first;
      for (int i=0; i<nsamples; ++i) { retval(i)=ip(it); it += dt; }
      return(retval);
    } // ts::TDsfftimeseries resample(...)

Here is the call graph for this function: