Method process

src/cpu_depth_packet_processor.cpp:879–976

* Process a packet. * @param packet Packet to process. */

 * @param packet Packet to process.
 */
void CpuDepthPacketProcessor::process(const DepthPacket &packet)
{
  if(listener_ == 0) return;

  impl_->startTiming();

  impl_->ir_frame->timestamp = packet.timestamp;
  impl_->depth_frame->timestamp = packet.timestamp;
  impl_->ir_frame->sequence = packet.sequence;
  impl_->depth_frame->sequence = packet.sequence;

  Mat<Vec<float, 9> >
      m(424, 512),
      m_filtered(424, 512)
  ;
  Mat<unsigned char> m_max_edge_test(424, 512);

  float *m_ptr = (m.ptr(0, 0)->val);

  for(int y = 0; y < 424; ++y)
    for(int x = 0; x < 512; ++x, m_ptr += 9)
    {
      impl_->processPixelStage1(x, y, packet.buffer, m_ptr + 0, m_ptr + 3, m_ptr + 6);
    }

  // bilateral filtering
  if(impl_->enable_bilateral_filter)
  {
    float *m_filtered_ptr = (m_filtered.ptr(0, 0)->val);
    unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);

    for(int y = 0; y < 424; ++y)
      for(int x = 0; x < 512; ++x, m_filtered_ptr += 9, ++m_max_edge_test_ptr)
      {
        bool max_edge_test_val = true;
        impl_->filterPixelStage1(x, y, m, m_filtered_ptr, max_edge_test_val);
        *m_max_edge_test_ptr = max_edge_test_val ? 1 : 0;
      }

    m_ptr = (m_filtered.ptr(0, 0)->val);
  }
  else
  {
    m_ptr = (m.ptr(0, 0)->val);
  }

  Mat<float> out_ir(424, 512, impl_->ir_frame->data), out_depth(424, 512, impl_->depth_frame->data);

  if(impl_->enable_edge_filter)
  {
    Mat<Vec<float, 3> > depth_ir_sum(424, 512);
    Vec<float, 3> *depth_ir_sum_ptr = depth_ir_sum.ptr(0, 0);
    unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);

    for(int y = 0; y < 424; ++y)
      for(int x = 0; x < 512; ++x, m_ptr += 9, ++m_max_edge_test_ptr, ++depth_ir_sum_ptr)
      {
        float raw_depth, ir_sum;