CListRecordECAT8_32bit.h

Go to the documentation of this file.

/*
    Copyright (C) 2003-2011 Hammersmith Imanet Ltd
    Copyright (C) 2013-2014 University College London
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0
 
    See STIR/LICENSE.txt for details
*/
 
#ifndef __stir_listmode_CListRecordECAT8_32bit_H__
#define __stir_listmode_CListRecordECAT8_32bit_H__
 
#include "stir/listmode/CListRecord.h"
#include "stir/listmode/ListAccumulatedSingles.h"
#include "stir/listmode/CListEventCylindricalScannerWithDiscreteDetectors.h"
#include "stir/ProjDataInfoCylindrical.h"
#include "stir/Succeeded.h"
#include "stir/ByteOrder.h"
#include "stir/ByteOrderDefine.h"
#include "stir/round.h"
#include "boost/static_assert.hpp"
#include "boost/cstdint.hpp"
#include "stir/DetectionPositionPair.h"
 
START_NAMESPACE_STIR
namespace ecat
{


class CListEventDataECAT8_32bit
{
public:
  /* 'delayed' bit:
      0 if event is delayed (it fell in delayed time window) */
 
#if STIRIsNativeByteOrderBigEndian
  unsigned type : 1; /* 0-coincidence event, 1-time tick */
  unsigned delayed : 1;
  unsigned offset : 30;
#else
  // Do byteswapping first before using this bit field.
  unsigned offset : 30;
  unsigned delayed : 1;
  unsigned type : 1; /* 0-coincidence event, 1-time tick */
 
#endif
}; /*-coincidence event*/


class CListEventECAT8_32bit : public CListEventCylindricalScannerWithDiscreteDetectors
{
private:
public:
  typedef CListEventDataECAT8_32bit DataType;
  DataType get_data() const { return this->data; }
 
public:
  CListEventECAT8_32bit(const shared_ptr<const ProjDataInfo>& proj_data_info_sptr);

  void get_detection_position(DetectionPositionPair<>&) const override;

  void set_detection_position(const DetectionPositionPair<>&) override;
 
  Succeeded init_from_data_ptr(const void* const ptr)
  {
    const char* const data_ptr = reinterpret_cast<const char* const>(ptr);
    std::copy(data_ptr, data_ptr + sizeof(this->raw), reinterpret_cast<char*>(&this->raw));
    return Succeeded::yes;
  }
  inline bool is_prompt() const override { return this->data.delayed == 1; }
  inline Succeeded set_prompt(const bool prompt = true) override
  {
    if (prompt)
      this->data.delayed = 1;
    else
      this->data.delayed = 0;
    return Succeeded::yes;
  }
 
private:
  BOOST_STATIC_ASSERT(sizeof(CListEventDataECAT8_32bit) == 4);
  union
  {
    CListEventDataECAT8_32bit data;
    boost::int32_t raw;
  };
  std::vector<int> segment_sequence;
  std::vector<int> timing_poss_sequence;
  std::vector<int> sizes;
};


class CListTimeDataECAT8_32bit
{
public:
#if STIRIsNativeByteOrderBigEndian
  unsigned type : 1;        /* 0-coincidence event, 1-time tick */
  unsigned deadtimeetc : 2; /* extra bits differentiating between timing or other stuff, zero if timing event */
  unsigned time : 29;       /* since scan start */
#else
  // Do byteswapping first before using this bit field.
  unsigned time : 29;       /* since scan start */
  unsigned deadtimeetc : 2; /* extra bits differentiating between timing or other stuff, zero if timing event */
  unsigned type : 1;        /* 0-coincidence event, 1-time tick */
#endif
};


class CListSinglesDataECAT8_32bit
{
public:
#if STIRIsNativeByteOrderBigEndian
  unsigned type : 1;     /* 1 = non-event */
  unsigned subtype : 2;  /* 0b10 = singles record */
  unsigned bucket : 10;  /* singles bucket index */
  unsigned singles : 19; /* singles count */
#else
  // Do byteswapping first before using this bit field.
  unsigned singles : 19; /* singles count */
  unsigned bucket : 10;  /* singles bucket index */
  unsigned subtype : 2;  /* 0b10 = singles record */
  unsigned type : 1;     /* 1 = non-event */
#endif
};


class CListDataAnyECAT8_32bit
{
public:
  Succeeded init_from_data_ptr(const void* const ptr)
  {
    const char* const data_ptr = reinterpret_cast<const char* const>(ptr);
    std::copy(data_ptr, data_ptr + sizeof(this->raw), reinterpret_cast<char*>(&this->raw));
    return Succeeded::yes;
  }
  bool is_time() const { return this->data.type == 1U && this->data.deadtimeetc == 0U; }
  bool is_other() const { return this->data.type == 1U && this->data.deadtimeetc != 0U; }
  bool is_event() const { return this->data.type == 0U; }
 
private:
  BOOST_STATIC_ASSERT(sizeof(CListTimeDataECAT8_32bit) == 4);
  union
  {
    CListTimeDataECAT8_32bit data;
    boost::int32_t raw;
  };
};


class CListTimeECAT8_32bit : public ListTime
{
public:
  Succeeded init_from_data_ptr(const void* const ptr)
  {
    const char* const data_ptr = reinterpret_cast<const char* const>(ptr);
    std::copy(data_ptr, data_ptr + sizeof(this->raw), reinterpret_cast<char*>(&this->raw));
    return Succeeded::yes;
  }
  bool is_time() const { return this->data.type == 1U && this->data.deadtimeetc == 0U; }
  inline unsigned long get_time_in_millisecs() const override { return static_cast<unsigned long>(this->data.time); }
  inline Succeeded set_time_in_millisecs(const unsigned long time_in_millisecs) override
  {
    this->data.time = ((1U << 30) - 1) & static_cast<unsigned>(time_in_millisecs);
    // TODO return more useful value
    return Succeeded::yes;
  }
 
private:
  BOOST_STATIC_ASSERT(sizeof(CListTimeDataECAT8_32bit) == 4);
  union
  {
    CListTimeDataECAT8_32bit data;
    boost::int32_t raw;
  };
};


class CListSinglesECAT8_32bit : public ListAccumulatedSingles
{
public:
  Succeeded init_from_data_ptr(const void* const ptr)
  {
    const char* const data_ptr = reinterpret_cast<const char* const>(ptr);
    std::copy(data_ptr, data_ptr + sizeof(this->raw), reinterpret_cast<char*>(&this->raw));
    return Succeeded::yes;
  }

  bool is_accumulated_singles() const { return this->data.type == 1U && this->data.subtype == 1U; }
 
  unsigned int get_bucket_index() const override { return this->data.bucket; }

  float get_singles_count() const override { return 8.F * static_cast<float>(this->data.singles); }
 
private:
  BOOST_STATIC_ASSERT(sizeof(CListSinglesDataECAT8_32bit) == 4);
  union
  {
    CListSinglesDataECAT8_32bit data;
    boost::int32_t raw;
  };
};


class CListRecordECAT8_32bit : public CListRecord // currently no gating yet
{
 
public:
  bool is_time() const override { return this->any_data.is_time(); }
  /*
  bool is_gating_input() const
  { return this->is_time(); }
  */
  bool is_event() const override { return this->any_data.is_event(); }
  CListEventECAT8_32bit& event() override { return this->event_data; }
  const CListEventECAT8_32bit& event() const override { return this->event_data; }
  CListTimeECAT8_32bit& time() override { return this->time_data; }
  const CListTimeECAT8_32bit& time() const override { return this->time_data; }
  bool is_accumulated_singles() const override { return this->singles_data.is_accumulated_singles(); }
  CListSinglesECAT8_32bit& accumulated_singles() override { return this->singles_data; }
  const CListSinglesECAT8_32bit& accumulated_singles() const override { return this->singles_data; }
 
  bool operator==(const CListRecord& e2) const
  {
    return dynamic_cast<CListRecordECAT8_32bit const*>(&e2) != 0 && raw == dynamic_cast<CListRecordECAT8_32bit const&>(e2).raw;
  }
 
public:
  CListRecordECAT8_32bit(const shared_ptr<const ProjDataInfo>& proj_data_info_sptr)
      : event_data(proj_data_info_sptr)
  {}
 
  virtual Succeeded init_from_data_ptr(const char* const data_ptr,
                                       const std::size_t
#ifndef NDEBUG
                                           size // only used within assert, so commented-out otherwise to avoid compiler warnings
#endif
                                       ,
                                       const bool do_byte_swap)
  {
    assert(size >= 4);
    std::copy(data_ptr, data_ptr + 4, reinterpret_cast<char*>(&raw));
    if (do_byte_swap)
      ByteOrder::swap_order(raw);
    this->any_data.init_from_data_ptr(&raw);
    // should in principle check return value, but it's always Succeeded::yes anyway
    if (this->any_data.is_time())
      return this->time_data.init_from_data_ptr(&raw);
    else if (this->any_data.is_event())
      return this->event_data.init_from_data_ptr(&raw);
    else if (this->any_data.is_other())
      return this->singles_data.init_from_data_ptr(&raw);
    else
      return Succeeded::yes;
  }
 
  virtual std::size_t
  size_of_record_at_ptr(const char* const /*data_ptr*/, const std::size_t /*size*/, const bool /*do_byte_swap*/) const
  {
    return 4;
  }
 
private:
  CListEventECAT8_32bit event_data;
  CListTimeECAT8_32bit time_data;
  CListDataAnyECAT8_32bit any_data;
  CListSinglesECAT8_32bit singles_data;
  boost::int32_t raw; // this raw field isn't strictly necessary, get rid of it?
};
 
} // namespace ecat
END_NAMESPACE_STIR
 
#endif