lasp_pyindatahandler.cpp

Go to the documentation of this file.

/* #define DEBUGTRACE_ENABLED */
#include "arma_npy.h"
#include "debugtrace.hpp"
#include "lasp_clip.h"
#include "lasp_daq.h"
#include "lasp_daqdata.h"
#include "lasp_ppm.h"
#include "lasp_rtaps.h"
#include "lasp_rtsignalviewer.h"
#include "lasp_streammgr.h"
#include "lasp_threadedindatahandler.h"
#include <armadillo>
#include <atomic>
#include <chrono>
#include <pybind11/pybind11.h>
 
using namespace std::literals::chrono_literals;
using std::cerr;
using std::endl;
 
namespace py = pybind11;
 
template <typename T, bool copy = false>
py::array_t<T> getPyArrayNoCpy(const DaqData &d) {
  // https://github.com/pybind/pybind11/issues/323
  //
  // When a valid object is passed as 'base', it tells pybind not to take
  // ownership of the data, because 'base' will own it. In fact 'packet' will
  // own it, but - psss! - , we don't tell it to pybind... Alos note that ANY
  // valid object is good for this purpose, so I choose "str"...
 
  py::str dummyDataOwner;
  /*
   * Signature:
   array_t(ShapeContainer shape,
   StridesContainer strides,
   const T *ptr = nullptr,
   handle base = handle());
   */
 
  return py::array_t<T>(
      py::array::ShapeContainer({d.nframes, d.nchannels}), // Shape
 
      py::array::StridesContainer( // Strides
          {sizeof(T),
           sizeof(T) * d.nframes}), // Strides (in bytes) for each index
 
      reinterpret_cast<T *>(
          const_cast<DaqData &>(d).raw_ptr()), // Pointer to buffer
 
      dummyDataOwner // As stated above, now Numpy does not take ownership of
                     // the data pointer.
  );
}
 
template <typename T, bool copy = false>
py::array_t<d> dmat_to_ndarray(const DaqData &d) {
  // https://github.com/pybind/pybind11/issues/323
  //
  // When a valid object is passed as 'base', it tells pybind not to take
  // ownership of the data, because 'base' will own it. In fact 'packet' will
  // own it, but - psss! - , we don't tell it to pybind... Alos note that ANY
  // valid object is good for this purpose, so I choose "str"...
 
  py::str dummyDataOwner;
  /*
   * Signature:
   array_t(ShapeContainer shape,
   StridesContainer strides,
   const T *ptr = nullptr,
   handle base = handle());
   */
 
  return py::array_t<T>(
      py::array::ShapeContainer({d.nframes, d.nchannels}), // Shape
 
      py::array::StridesContainer( // Strides
          {sizeof(T),
           sizeof(T) * d.nframes}), // Strides (in bytes) for each index
 
      reinterpret_cast<T *>(
          const_cast<DaqData &>(d).raw_ptr()), // Pointer to buffer
 
      dummyDataOwner // As stated above, now Numpy does not take ownership of
                     // the data pointer.
  );
}
 
class PyIndataHandler : public ThreadedInDataHandler<PyIndataHandler> {
  py::function cb, reset_callback;
 
public:
  PyIndataHandler(SmgrHandle mgr, py::function cb, py::function reset_callback)
      : ThreadedInDataHandler(mgr), cb(cb), reset_callback(reset_callback) {
 
    DEBUGTRACE_ENTER;
    py::gil_scoped_release release;
    startThread();
  }
  ~PyIndataHandler() {
    DEBUGTRACE_ENTER;
    py::gil_scoped_release release;
    stopThread();
  }
  void reset(const Daq *daq) {
    DEBUGTRACE_ENTER;
    try {
      py::gil_scoped_acquire acquire;
      if (daq) {
        reset_callback(daq);
      } else {
        reset_callback(py::none());
      }
    } catch (py::error_already_set &e) {
      cerr << "*************** Error calling reset callback!\n";
      cerr << e.what() << endl;
      cerr << "*************** \n";
      abort();
      /* throw std::runtime_error(e.what()); */
    } catch (std::exception &e) {
      cerr << "Caught unknown exception in reset callback:" << e.what() << endl;
      abort();
    }
  }
 
  void inCallback(const DaqData &d) {
 
    /* DEBUGTRACE_ENTER; */
 
    using DataType = DataTypeDescriptor::DataType;
 
    try {
      py::gil_scoped_acquire acquire;
      py::object bool_val;
      switch (d.dtype) {
      case (DataType::dtype_int8): {
        bool_val = cb(getPyArrayNoCpy<int8_t>(d));
      } break;
      case (DataType::dtype_int16): {
        bool_val = cb(getPyArrayNoCpy<int16_t>(d));
      } break;
      case (DataType::dtype_int32): {
        bool_val = cb(getPyArrayNoCpy<int32_t>(d));
      } break;
      case (DataType::dtype_fl32): {
        bool_val = cb(getPyArrayNoCpy<float>(d));
      } break;
      case (DataType::dtype_fl64): {
        bool_val = cb(getPyArrayNoCpy<double>(d));
      } break;
      default:
        throw std::runtime_error("BUG");
      } // End of switch
 
      bool res = bool_val.cast<bool>();
    } catch (py::error_already_set &e) {
      cerr << "ERROR: Python raised exception from callback function: ";
      cerr << e.what() << endl;
      abort();
    } catch (py::cast_error &e) {
      cerr << e.what() << endl;
      cerr << "ERROR: Python callback does not return boolean value." << endl;
      abort();
    } catch (std::exception &e) {
      cerr << "Caught unknown exception in Python callback:" << e.what()
           << endl;
      abort();
    }
  }
};
 
void init_datahandler(py::module &m) {
 
  py::class_<PyIndataHandler> pyidh(m, "InDataHandler");
  pyidh.def(py::init<SmgrHandle, py::function, py::function>());
 
  py::class_<PPMHandler> ppm(m, "PPMHandler");
  ppm.def(py::init<SmgrHandle, const d>());
  ppm.def(py::init<SmgrHandle>());
 
  ppm.def("getCurrentValue", [](const PPMHandler &ppm) {
    std::tuple<vd, arma::uvec> tp;
    {
      py::gil_scoped_release release;
      tp = ppm.getCurrentValue();
    }
 
    return py::make_tuple(ColToNpy<d>(std::get<0>(tp)),
                          ColToNpy<arma::uword>(std::get<1>(tp)));
  });
 
  py::class_<ClipHandler> clip(m, "ClipHandler");
  clip.def(py::init<SmgrHandle>());
 
  clip.def("getCurrentValue", [](const ClipHandler &clip) {
    arma::uvec cval;
    {
      py::gil_scoped_release release;
      cval = clip.getCurrentValue();
    }
 
    return ColToNpy<arma::uword>(cval); // something goes wrong here
  });
 
  py::class_<RtAps> rtaps(m, "RtAps");
  rtaps.def(py::init<SmgrHandle,               // StreamMgr
                     Filter *const,            // FreqWeighting filter
                     const us,                 // Nfft
                     const Window::WindowType, // Window
                     const d,                  // Overlap percentage 0<=o<100
 
                     const d // Time constant
                     >(),
            py::arg("streammgr"), // StreamMgr
            py::arg("preFilter").none(true),
 
            py::arg("nfft") = 2048,                           //
            py::arg("windowType") = Window::WindowType::Hann, //
            py::arg("overlap_percentage") = 50.0,             //
            py::arg("time_constant") = -1                     //
  );
 
  rtaps.def("getCurrentValue", [](RtAps &rt) {
    ccube val;
    {
      py::gil_scoped_release release;
      val = rt.getCurrentValue();
    }
    return CubeToNpy<c>(val);
  });
 
  py::class_<RtSignalViewer> rtsv(m, "RtSignalViewer");
  rtsv.def(py::init<SmgrHandle, // StreamMgr
                    const d,    // Time history
                    const us,   // Resolution
                    const us    // Channel number
                    >());
 
  rtsv.def("getCurrentValue", [](RtSignalViewer &rt) {
    dmat val;
    {
      py::gil_scoped_release release;
      val = rt.getCurrentValue();
    }
    return MatToNpy<d>(val);
  });
}