STIR 6.5.0
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
 CSPECTUB::angle_typeStructure to store angles values, indices and ratios
 Cstir::ArcCorrectionA class to arc-correct projection data
 Cstir::ArrayFunctionObject< num_dimensions, elemT >A class for operations on n-dimensional Arrays
  Cstir::ArrayFunctionObject_2ArgumentImplementation< 1, elemT >
   Cstir::ArrayFilter1DUsingConvolution< elemT >This class implements convolution of a 1D array with an arbitrary (i.e. potentially non-symmetric) kernel
   Cstir::ArrayFilter1DUsingConvolutionSymmetricKernel< elemT >This class implements convolution of a 1D array with a symmetric kernel
  Cstir::ArrayFunctionObject_2ArgumentImplementation< 2, elemT >
  Cstir::ArrayFunctionObject_2ArgumentImplementation< 3, elemT >
   Cstir::GammaArrayFilter2D< elemT >Gamma correction filter for 2D slices in a 3D volume
   Cstir::MaximalArrayFilter3D< elemT >Implements erosion on 3D arrays
   Cstir::MedianArrayFilter3D< elemT >Implements median filtering on 3D arrays
   Cstir::MinimalArrayFilter3D< elemT >Implements erosion on 3D arrays
   Cstir::WienerArrayFilter2D< elemT >Applies a 2D Wiener filter on a 3D input array, slice by slice
  Cstir::ArrayFunctionObject_1ArgumentImplementation< num_dimensions, elemT >A convenience class for children of ArrayFunctionObject. It implements the 2 argument operator() in terms of the in-place version
   Cstir::SeparableArrayFunctionObject< num_dimensions, elemT >This class implements an n -dimensional ArrayFunctionObject whose operation is separable
    Cstir::SeparableGaussianArrayFilter< num_dimensions, elemT >Separable Gaussian filtering in n - dimensions
    Cstir::SeparableGaussianArrayFilter< num_dimensions, elemT >Separable Gaussian filtering in n - dimensions
    Cstir::SeparableMetzArrayFilter< num_dimensions, elemT >Separable Metz filtering in n - dimensions
  Cstir::ArrayFunctionObject_2ArgumentImplementation< num_dimensions, elemT >A convenience class for children of ArrayFunctionObject. It implements the in-place operator() in terms of the 2 argument version
   Cstir::ArrayFilterUsingRealDFTWithPadding< num_dimensions, elemT >This class implements convolution of an array of real numbers with an arbitrary (i.e. potentially non-symmetric) kernel using DFTs
   Cstir::SeparableArrayFunctionObject2< num_dimensions, elemT >This class implements an n -dimensional ArrayFunctionObject whose operation is separable
 Cstir::ArrayFunctionObject< num_dimensions, float >
  Cstir::ArrayFunctionObject_2ArgumentImplementation< 3, float >
  Cstir::ArrayFunctionObject_2ArgumentImplementation< num_dimensions, float >
   Cstir::ArrayFilterUsingRealDFTWithPadding< 2, float >
    Cstir::ColsherFilterThis class contains the Colsher filter used for 3D-PET reconstruction
   Cstir::ArrayFilterUsingRealDFTWithPadding< 1, float >
    Cstir::RampFilterThe ramp filter used for (2D) FBP
 CSPECTUB::attpth_typeStructure for attenuation calculus
 Cstd::basic_string< Char >STL class
  Cstd::stringSTL class
   Cstir::LineA class used by the Interfile parser
 Cstir::BeginEndAllFunction< TopLevelIterT, RestIterT >Helper class for NestedIterator when the 1st level iterator refers to a stir full iterator for the 2nd level iterator
  Cstir::ConstBeginEndAllFunction< TopLevelIterT, RestIterT >Convenience class where the 2nd level iterator is a const_full_iterator
 Cstir::BeginEndFunction< TopLevelIterT, RestIterT >Helper class for NestedIterator when the 1st level iterator refers to an ordinary iterator for the 2nd level iterator
  Cstir::ConstBeginEndFunction< TopLevelIterT, RestIterT >Convenience class where the 2nd level iterator is a const_iterator
 CSPECTUB::bin_typeStructure for bin information
 Cstir::BinAndCorrA small bundle of a Bin and its additive correction value
 Cstir::BloodFrameDataA class for storing plasma samples of a single study
 Cstir::BoundaryConditionsPreliminary class to specify boundary conditions for filters
 Cstir::BSpline::BSplines1DRegularGrid< out_elemT, in_elemT, constantsT >Temporary class for 1D B-splines
 Cstir::BSpline::BSplinesRegularGrid< num_dimensions, out_elemT, in_elemT, constantsT >A class for n-dimensional BSpline interpolation when the input samples are on a regular grid
 Cstir::ByteOrderThis class provides member functions to find out what byte-order your machine is and to swap numbers
 Cstir::GE::RDF_HDF5::detail::CListAnyRecordDataGEHDF5Class for finding out what the event/size-type is in a GE RDF9 listmode file
 Cstir::ecat::CListDataAnyECAT8_32bitA class for decoding a raw "other" word (neither time nor coincidence) from the ECAT 8_32bit listmode stream
 Cstir::ecat::CListEventDataECAT8_32bitClass for decoding storing and using a raw coincidence event from a listmode file from the ECAT 966 scanner
 Cstir::ecat::ecat7::CListEventDataECAT962Class for storing and using a coincidence event from a listmode file
 Cstir::ecat::ecat7::CListEventDataECAT966Class for decoding storing and using a raw coincidence event from a listmode file from the ECAT 966 scanner
 Cstir::GE::RDF_HDF5::detail::CListEventDataGEHDF5Class for storing and using a coincidence event from a GE RDF9 listmode file
 Cstir::CListEventDataLMFClass for storing and using a coincidence event from a listmode file
 Cstir::CListEventDataNeuroLFClass for record with coincidence data using NeuroLF bitfield definition
 Cstir::CListEventDataSAFIRClass for record with coincidence data using SAFIR bitfield definition
 Cstir::ecat::CListSinglesDataECAT8_32bitBit-field struct for the PETLINK singles word (type=1, deadtimeetc=2)
 Cstir::ecat::CListTimeDataECAT8_32bitA class for decoding a raw events that is neither time or coincidence in a listmode file from the ECAT 8_32bit scanner Bit-field struct for the PETLINK time marker word (type=1, deadtimeetc=0)
 Cstir::ecat::ecat7::CListTimeDataECAT962A class for storing and using a timing 'event' from a listmode file
 Cstir::ecat::ecat7::CListTimeDataECAT966A class for decoding a raw timing 'event' from a listmode file from the ECAT 966 scanner
 Cstir::CListTimeDataLMFA class for storing and using a timing 'event' from a listmode file
 Cstir::CListTimeDataSAFIRClass for record with time data using SAFIR bitfield definition
 CSPECTUB::collim_typeCollimator parameters structure
 Clist< T >::const_iteratorSTL iterator class
 Cmap< K, T >::const_iteratorSTL iterator class
 CSPECTUB::string::const_iteratorSTL iterator class
 CSPECTUB_mph::string::const_iteratorSTL iterator class
 Cstring::const_iteratorSTL iterator class
 Cvector< T >::const_iteratorSTL iterator class
 Clist< T >::const_reverse_iteratorSTL iterator class
 Cmap< K, T >::const_reverse_iteratorSTL iterator class
 CSPECTUB::string::const_reverse_iteratorSTL iterator class
 CSPECTUB_mph::string::const_reverse_iteratorSTL iterator class
 Cstring::const_reverse_iteratorSTL iterator class
 Cvector< T >::const_reverse_iteratorSTL iterator class
 Cstir::CopyFill< T >Helper class for stir::copy_to and stir::fill_from
 Cstir::CopyFill< Array< num_dimensions, elemT > >Helper class for stir::copy_to and stir::fill_from
 Cstir::CopyFill< DynamicProjData >Copy all bins to a range specified by an iterator
 Cstir::CopyFill< MultipleProjData >Copy all bins to a range specified by an iterator
 Cstir::CopyFill< ProjData >Helper class for stir::copy_to and stir::fill_from
 Cstir::DataSymmetriesForDenselsA class for encoding/finding symmetries common to the geometry of the projection data and the discretised density
  Cstir::DataSymmetriesForDensels_PET_CartesianGridSymmetries appropriate for a (cylindrical) PET scanner, and a discretised density on a Cartesian grid
 Cstir::DataSymmetriesForViewSegmentNumbersA class for encoding/finding symmetries. Works only on ViewSegmentNumbers (instead of Bin)
  Cstir::DataSymmetriesForBinsA class for encoding/finding symmetries common to the geometry of the projection data and the discretised density
   Cstir::DataSymmetriesForBins_PET_CartesianGridSymmetries appropriate for a (cylindrical) PET scanner, and a discretised density on a Cartesian grid
   Cstir::TrivialDataSymmetriesForBinsA class derived from DataSymmetriesForBins that says that there are no symmetries at all
  Cstir::TrivialDataSymmetriesForViewSegmentNumbersA class for encoding/finding NO symmetries. Works only on ViewSegmentNumbers (instead of Bin)
 Cstir::DataWithProjDataInfoBase class for data objects such as ProjData etc
  Cstir::RelatedViewgrams< float >
  Cstir::StorageOrder< elemT >
  Cstir::Viewgram< float >
  Cstir::ListModeDataThe base class for reading list mode data
   Cstir::CListModeDataThe base class for reading PET (i.e. coincidence) list mode data
    Cstir::CListModeDataLMFA class that reads the listmode data from an LMF file
    Cstir::CListModeDataPENNBase class for listmode data for PENNPET Explorer scanner
    Cstir::CListModeDataROOTClass that reads ROOT files, generated by GATE, as listmode data
    Cstir::GE::RDF_HDF5::CListModeDataGEHDF5A class that reads the listmode data for GE scanners using the RDF9 format
    Cstir::ecat::CListModeDataECAT8_32bitA class that reads the listmode data for Siemens scanners
    Cstir::ecat::ecat7::CListModeDataECAT< CListRecordT >A class that reads the listmode data for ECAT scanners
   Cstir::ListModeData_dummyA class to trick the Objective function that we have list mode data, when we only have cache
   Cstir::SPECTListModeDataThe base class for reading SPECT list mode data
  Cstir::ProjDataThe (abstract) base class for the projection data
   Cstir::GE::RDF_HDF5::ProjDataGEHDF5A class which reads projection data from a GE HDF5 sinogram file
   Cstir::ProjDataFromStreamA class which reads/writes projection data from/to a (binary) stream
    Cstir::ProjDataInterfileA class which reads/writes projection data from/to a (binary) stream, but creates the corresponding Interfile header
   Cstir::ProjDataInMemoryA class which reads/writes projection data from/to memory
  Cstir::RelatedViewgrams< elemT >A class for storing viewgrams which are related by symmetry
  Cstir::Segment< elemT >An (abstract base) class for storing 3d projection data
   Cstir::SegmentByView< elem_type >
   Cstir::SegmentBySinogram< elemT >A class for storing (3d) projection data with fixed SegmentIndices
   Cstir::SegmentByView< elemT >A class for storing (3d) projection data with fixed SegmentIndices
  Cstir::Sinogram< elemT >A class for 2d projection data
  Cstir::Viewgram< elemT >A class for 2d projection data
 Cstir::DateTimeStringsA simple structure to hold 2 strings (date and time)
 Cstir::DetectionPositionPair< coordT >A class for storing 2 coordinates-sets of a detection, together with a timing-position index (for TOF), as suitable for PET
 Cstir::DetectorCoordinateMap
  Cstir::GeometryBlocksOnCylindricalA helper class to build the crystal map based on scanner info
 CSPECTUB::discrf_typeStructure for distribution function information
 Cstir::DistributedCachingInformationThis class implements the logic needed to support caching in a distributed manner
 Cboost::detail::empty_baseBoost class for chaining of operators (see operators.hpp)
 Cboost::equality_comparable< T, B >Boost class to define operator!= in terms of operator== (see operators.hpp)
 Cstir::ExamDataBase class for data objects such as ProjData etc
  Cstir::DiscretisedDensity< 3, float >
  Cstir::DiscretisedDensity< 3, elemT >
  Cstir::DiscretisedDensity< 3, CartesianCoordinate3D< float > >
  Cstir::DiscretisedDensity< num_dimensions, float >
  Cstir::DiscretisedDensity< num_dimensions, elemT >This abstract class is the basis for all image representations
   Cstir::DiscretisedDensityOnCartesianGrid< 3, elemT >
    Cstir::VoxelsOnCartesianGrid< elemT >This class is used to represent voxelised densities on a cuboid grid (3D)
     Cstir::ParametricDiscretisedDensity< VoxelsOnCartesianGrid< elemT > >
   Cstir::DiscretisedDensityOnCartesianGrid< 2, elemT >
    Cstir::PixelsOnCartesianGrid< elemT >This class is used to represent pixelised densities on a rectangular grid (2D)
   Cstir::DiscretisedDensityOnCartesianGrid< num_dimensions, elemT >This abstract class is the basis for images on a Cartesian grid
    Cstir::VoxelsOnCartesianGrid< KineticParameters< 2, float > >
     Cstir::ParametricDiscretisedDensity< ParametricVoxelsOnCartesianGridBaseType >
    Cstir::VoxelsOnCartesianGrid< float >
    Cstir::VoxelsOnCartesianGrid< CartesianCoordinate3D< float > >
  Cstir::DynamicDiscretisedDensityClass of multiple image frames, one for each time frame Each time frame is a DiscretisedDensity<3,float>
  Cstir::ListModeDataThe base class for reading list mode data
  Cstir::ProjDataThe (abstract) base class for the projection data
 Cstir::ExamInfoClass for storing information about 1 exam (or scan)
 Cstir::ExpandedDetectionBinLessComparator for ordering petsird::ExpandedDetectionBin in std::map
 Cstir::FactoryRegistry< Key, Factory, Compare >This class can be used to store 'factories' and their corresponding keys. It is essentially a map, but with some extra embelishments
 Cstir::FilePathThe FilePath class
 Cstir::FileSignatureA class to read/store the file signature
 Cstir::ProjDataInfo::Float1Float2Struct which holds two floating numbers
 Cstir::FrameSinglesRatesA single frame of singles information
 CfstreamSTL class
 Cstir::FullArrayIterator< topleveliterT, restiterT, elemT, _Ref, _Ptr >Class FullArrayIterator implements (forward) iterators that go through all elements of an Array
 Cstir::GatedDiscretisedDensityClass of multiple image gates
 Cstir::GE::RDF_HDF5::GEHDF5WrapperA class that extracts and reads the necessary data from GE HDF5 input files
 Cstir::GeneralisedPoissonNoiseGeneratorGenerates noise realisations according to Poisson statistics but allowing for scaling
 Cstir::has_full_iterator< T, typename >Helper to check if a type has a full_iterator typedef (e.g. Array<2,int>)
 Cstir::has_iterator< T, typename >Helper to check if a type has an iterator typedef
 Cstir::has_iterator_and_no_full_iterator< T >Helper to check if the type has an iterator but no full_iterator typedef (e.g. std::vector<int>)
 Cstir::HigherPrecision< T >Helper class to get a type with higher precision
 Cstir::HighResWallClockTimerHigh-resolution timer
 CifstreamSTL class
 CImageReading and writing gipl files
 Cstir::ImagingModalityClass for encoding the modality
 Cstir::InputFileFormat< DataT >Base-class for file-formats for reading
  Cstir::ITKImageInputFileFormat< STIRImageType >Class for reading images using ITK
 Cstir::InputFileFormat< DiscretisedDensity< 3, float > >
  Cstir::InterfileImageInputFileFormatClass for reading images in Interfile file-format
  Cstir::ecat::ecat6::ECAT6ImageInputFileFormatClass for reading images in ECAT6 file-format
  Cstir::ecat::ecat7::ECAT7ImageInputFileFormatClass for reading images in ECAT7 file-format
 Cstir::InputFileFormat< DynamicDiscretisedDensity >
  Cstir::InterfileDynamicDiscretisedDensityInputFileFormatClass for reading images in Interfile file-format
  Cstir::MultiDynamicDiscretisedDensityInputFileFormatClass for reading images in Multi file-format
  Cstir::ecat::ecat7::ECAT7DynamicDiscretisedDensityInputFileFormatClass for reading images in ECAT7 file-format
 Cstir::InputFileFormat< ListModeData >
  Cstir::GE::RDF_HDF5::GEHDF5ListmodeInputFileFormatClass for being able to read list mode data from the GE Signa PET/MR scanner via the listmode-data registry
  Cstir::PENNListmodeInputFileFormatBase class for PENN listmode file format support
  Cstir::PETSIRDCListmodeInputFileFormatClass for reading PETSIRD coincidence listmode data
  Cstir::ROOTListmodeInputFileFormatThe ROOTListmodeInputFileFormat class
  Cstir::SAFIRCListmodeInputFileFormat< EventDataType >Class for reading SAFIR coincidence listmode data
  Cstir::ecat::ECAT8_32bitListmodeInputFileFormatClass for being able to read list mode data from the ECAT 8_32bit scanner via the listmode-data registry
  Cstir::ecat::ecat7::ECAT962ListmodeInputFileFormatClass for reading list mode data from the ECAT 962 scanner
  Cstir::ecat::ecat7::ECAT966ListmodeInputFileFormatClass for reading list mode data from the ECAT 966 scanner
 Cstir::InputFileFormat< ParametricVoxelsOnCartesianGrid >
  Cstir::InterfileParametricDiscretisedDensityInputFileFormatClass for reading images in Interfile file-format
  Cstir::MultiParametricDiscretisedDensityInputFileFormatClass for reading images in Multi file-format
 Cstir::InputFileFormatRegistry< DataT >A class for registering (and finding) all input file formats
 Cstir::InputStreamWithRecords< RecordT, OptionsT >A helper class to read data from a (presumably binary) stream
 Cstir::GE::RDF_HDF5::InputStreamWithRecordsFromHDF5< RecordT >A helper class to read data from a hdf5 file
 Cstir::interfile_lessA function object that compares Interfile keywords
 Cstir::InvertAxisUtility class to "invert" an axis
 CiosSTL class
 Cstir::detail::is_1dClass used to signify it's a 1D array
  Cstir::detail::test_if_1d< 1 >1D specialisation of a templated class used to check if it's a 1D array or not
 Cstir::detail::is_not_1dClass used to signify it's not a 1D array
  Cstir::detail::test_if_1d< 1 >1D specialisation of a templated class used to check if it's a 1D array or not
  Cstir::detail::test_if_1d< Num_dimensions >Templated class used to check if it's a 1D array or not This class only exists to allow a work-around for older compilers (such as VC 6.0) that do not implement partial ordering of function templates or partial template specialisation
 CistreamSTL class
 CistringstreamSTL class
 Clist< T >::iteratorSTL iterator class
 Cmap< K, T >::iteratorSTL iterator class
 CSPECTUB::string::iteratorSTL iterator class
 CSPECTUB_mph::string::iteratorSTL iterator class
 Cstring::iteratorSTL iterator class
 Cvector< T >::iteratorSTL iterator class
 Cstir::JacobianForIntBPThe next class is used in BackProjectorByBinUsingInterpolation to take geometric things into account. It also includes some normalisation. (internal use only)
 Cstir::KeyArgumentA class that enumerates the possible types that can be used to store parsed values. Used (only) by KeyParser
 Cstir::KeyParserA class to parse Interfile headers
  Cstir::MinimalInterfileHeaderMinimal class for Interfile keywords (and parsing) common to all types of data
   Cstir::InterfileHeaderClass for Interfile keywords (and parsing) common to all types of data
    Cstir::InterfileHeaderSiemensClass for Interfile keywords (and parsing) common to all types of data
     Cstir::InterfileRawDataHeaderSiemensClass for Interfile keywords (and parsing) specific to Siemens PET projection, list mode data or norm data
      Cstir::InterfileListmodeHeaderSiemensClass for Interfile keywords (and parsing) specific to Siemens listmode data (in PETLINK format)
      Cstir::InterfileNormHeaderSiemensClass for Interfile keywords (and parsing) specific to Siemens (component-based) normalisation data
      Cstir::InterfilePDFSHeaderSiemensClass for Interfile keywords (and parsing) specific to projection data (i.e. ProjDataFromStream) for Siemens PET scanners
    Cstir::InterfileImageHeaderClass for Interfile keywords (and parsing) specific to images
    Cstir::InterfilePDFSHeaderClass for Interfile keywords (and parsing) specific to projection data (i.e. ProjDataFromStream)
    Cstir::InterfilePDFSHeaderSPECTClass for Interfile keywords (and parsing) specific to SPECT projection data
 Clist< T >STL class
 Cstir::ListAccumulatedSinglesClass for an accumulated singles record in a listmode file
  Cstir::ecat::CListSinglesECAT8_32bitA class for storing and using a singles bucket record from a listmode file from the ECAT 8_32bit scanner
 Cstir::ListEventClass for storing and using gamma events from a list mode file
  Cstir::CListEventClass for storing and using a coincidence event from a list mode file
   Cstir::CListEventSAFIR< CListRecordSAFIR< DataType > >
    Cstir::CListRecordSAFIR< DataType >Class for general SAFIR record, containing a union of data, time and raw record and providing access to certain elements
   Cstir::CListEventSAFIR< Derived >
   Cstir::CListEventScannerWithDiscreteDetectorsBaseBase-class for storing and using a coincidence event for a list-mode file that uses detector indices
    Cstir::CListEventScannerWithDiscreteDetectors< ProjDataInfoCylindricalNoArcCorr >
     Cstir::CListEventCylindricalScannerWithDiscreteDetectorsClass for storing and using a coincidence event from a list mode file for a cylindrical scanner
      Cstir::CListEventCylindricalScannerWithViewTangRingRingEncoding< CListEventECAT966 >
       Cstir::ecat::ecat7::CListEventECAT966Class for storing and using a coincidence event from a listmode file from the ECAT 966 scanner
      Cstir::CListEventCylindricalScannerWithViewTangRingRingEncoding< CListRecordECAT962 >
       Cstir::ecat::ecat7::CListRecordECAT962A class for a general element of a listmode file
      Cstir::CListEventCylindricalScannerWithViewTangRingRingEncoding< Derived >Helper class for listmode events when using 2d sinograms and ring-pairs is most efficient
      Cstir::CListEventPENNClass for handling PENNPet Explorer events
      Cstir::GE::RDF_HDF5::CListRecordGEHDF5A class for a general element (or "record") of a GE RDF9 listmode file
      Cstir::ecat::CListEventECAT8_32bitClass for storing and using a coincidence event from a listmode file from Siemens scanners using the ECAT 8_32bit format
    Cstir::CListEventScannerWithDiscreteDetectors< ProjDataInfoPETScannerWithDiscreteDetectors >
    Cstir::CListEventScannerWithDiscreteDetectors< ProjDataInfoT >Class for coincidence events from a list-mode file that uses detector indices and a specific type of ProjDataInfo
   Cstir::CListRecordLMFA class for a general element of a listmode file
  Cstir::SPECTListEventClass for storing and using gamma events from a SPECT List mode file
 Cstir::ListGatingInputA class recording external input to the scanner (normally used for gating)
  Cstir::ecat::ecat7::CListRecordECAT962A class for a general element of a listmode file
  Cstir::ecat::ecat7::CListTimeECAT966A class for storing and using a timing 'event' from a listmode file from the ECAT 966 scanner
 Cstir::ListRecordA class for a general element of a list mode file
  Cstir::CListRecordClass for records in a PET list mode file
   Cstir::CListRecordLMFA class for a general element of a listmode file
   Cstir::CListRecordPETSIRDListmode record for PETSIRD coincidence events
   Cstir::CListRecordROOTA class for a general element of a listmode file for a Siemens scanner using the ROOT files
   Cstir::CListRecordSAFIR< DataType >Class for general SAFIR record, containing a union of data, time and raw record and providing access to certain elements
   Cstir::GE::RDF_HDF5::CListRecordGEHDF5A class for a general element (or "record") of a GE RDF9 listmode file
   Cstir::ecat::CListRecordECAT8_32bitA class for a general element of a listmode file for a Siemens scanner using the ECAT8 32bit format
  Cstir::SPECTListRecordA class for a general element of a list mode file
 Cstir::ListTimeA class for storing and using a timing record from a listmode file
  Cstir::CListRecordLMFA class for a general element of a listmode file
  Cstir::CListRecordSAFIR< DataType >Class for general SAFIR record, containing a union of data, time and raw record and providing access to certain elements
  Cstir::CListTimeROOTA class for storing and using a timing 'event' from a listmode file from the ECAT 8_32bit scanner
  Cstir::GE::RDF_HDF5::CListRecordGEHDF5A class for a general element (or "record") of a GE RDF9 listmode file
  Cstir::ecat::CListTimeECAT8_32bitA class for storing and using a timing 'event' from a listmode file from the ECAT 8_32bit scanner
  Cstir::ecat::ecat7::CListRecordECAT962A class for a general element of a listmode file
  Cstir::ecat::ecat7::CListTimeECAT966A class for storing and using a timing 'event' from a listmode file from the ECAT 966 scanner
 Cstir::GE::RDF_HDF5::detail::ListTimeDataGEHDF5A class for storing and using a timing 'event' from a GE RDF9 listmode file
 Cstir::LmToProjDataBootstrap< LmToProjDataT >Class for binning list mode data into projection data using the bootstrap procedure
 Cstir::LmToProjDataWithRandomRejection< LmToProjDataT >Class for binning list mode data into projection data using the bootstrap procedure
 Cstir::LOR< coordT >A base class for specifying an LOR with geometric coordinates
  Cstir::LORAs2Points< coordT >A class for LORs
  Cstir::LORInAxialAndNoArcCorrSinogramCoordinates< coordT >A class for LORs
  Cstir::LORInAxialAndSinogramCoordinates< coordT >A class for LORs
  Cstir::LORInCylinderCoordinates< coordT >A class for LORs
 Cstir::LOR< float >
  Cstir::LORAs2Points< float >
 Cstir::LORCylindricalCoordinates_z_and_radius< coordT >An internal class for LORs. Do not use
  Cstir::LORInAxialAndNoArcCorrSinogramCoordinates< coordT >A class for LORs
  Cstir::LORInAxialAndSinogramCoordinates< coordT >A class for LORs
 Cmap< K, T >STL class
 Cstir::map_elementClass to store the Interfile keywords and their actions
 Cstir::MaskingParametersA struct to hold the parameters for image masking
 Cstir::ModelMatrix< num_param >A helper class to store the model matrix for a linear kinetic model
 Cstir::NestedIterator< topleveliterT, GetRestRangeFunctionT >Class NestedIterator implements a (forward) iterator using a pair of 'nested' iterators
 Cstir::NiftyPETHelperHelper class for the wrapped NiftyPET projectors
 Cstir::NormSquared< T >A helper class that computes the square of the norm of numeric data
 Cstir::NumericInfo< NUMBER >Class NumericInfo<NUMBER> defines properties for the type NUMBER
 Cstir::NumericInfo< double >Basic properties of double
 Cstir::NumericInfo< float >Basic properties of float
 Cstir::NumericInfo< signed char >Basic properties of signed char
 Cstir::NumericInfo< signed int >Basic properties of signed int
 Cstir::NumericInfo< signed long >Basic properties of signed long
 Cstir::NumericInfo< signed short >Basic properties of signed short
 Cstir::NumericInfo< unsigned char >Basic properties of unsigned char
 Cstir::NumericInfo< unsigned int >Basic properties of unsigned int
 Cstir::NumericInfo< unsigned long >Basic properties of unsigned long
 Cstir::NumericInfo< unsigned short >Basic properties of unsigned short
 Cstir::NumericTypeNames for some numeric types and methods for finding their properties
 CofstreamSTL class
 CostreamSTL class
 CostringstreamSTL class
 Cpair< T1, T2 >STL class
 Cstir::detail::ParallelprojHelperHelper class for Parallelproj's projectors
 Cstir::Parametric2Single< DiscDensT >A helper class to find the type of a 'single' image for a corresponding parametric image
 Cstir::ParametricDiscretisedDensity< DiscDensT >Class to store parametric images
 Cstir::ParseAndCreateFrom< OutputT, InputT, ParserT >Template for adding keywords to a parser and creating an object
 Cstir::ParseDiscretisedDensityParametersClass for adding parameters relevant to DiscretisedDensity to a parser
  Cstir::ParseAndCreateFrom< DiscretisedDensity< 3, elemT >, ExamDataT >Parse keywords for creating a VoxelsOnCartesianGrid from ProjData etc
  Cstir::ParseAndCreateFrom< ParametricDiscretisedDensity< VoxelsOnCartesianGrid< elemT > >, ExamDataT >Parse keywords for creating a parametric VoxelsOnCartesianGrid from DynamicProjData etc
 Cstir::ParsingObjectA base class for objects that want to be able to parse parameter files
  Cstir::CorrectProjDataApplicationClass to do precorrections
  Cstir::CreateTailMaskFromACFsThe CreateTailMaskFromACFs class
  Cstir::FindMCNormFactorsClass to compute 'time-efficiency' factors for motino corrected projection data
  Cstir::LmToProjDataAbstractThis class is the abstract base class fir binning listmode data to projection data, i.e. (3d) sinograms
   Cstir::LmToProjDataThis class is used to bin listmode data to projection data, i.e. (3d) sinograms
    Cstir::LmToProjDataWithMCClass for binning list mode files with motion correction
  Cstir::MatchTrackerAndScannerA class for finding the coordinate transformation between tracker and scanner coordinate systems
  Cstir::MyAppA class for moving an image according to average motion in the frame
  Cstir::PrepareProjDataA preliminary class to prepare files for iterative reconstruction
  Cstir::RegisteredObjectBaseBase class for all classes that can parse .par files (and more?)The only reason that this class exists is such that KeyParser can store different types of objects, and get some basic info from it
   Cstir::RegisteredObject< AbsTimeInterval >
    Cstir::AbsTimeIntervalBase class for specifying a time interval (in absolute time)
     Cstir::RegisteredParsingObject< AbsTimeIntervalFromDynamicData, AbsTimeInterval, AbsTimeInterval >
      Cstir::AbsTimeIntervalFromDynamicDataClass for specifying a time interval via a dynamic scan
     Cstir::RegisteredParsingObject< AbsTimeIntervalFromECAT7ACF, AbsTimeInterval, AbsTimeInterval >
      Cstir::AbsTimeIntervalFromECAT7ACFClass for specifying a time interval via an ECAT7 .a file
     Cstir::RegisteredParsingObject< AbsTimeIntervalWithParsing, AbsTimeInterval, AbsTimeInterval >
      Cstir::AbsTimeIntervalWithParsingClass for specifying a time interval via parsing of explicit times
   Cstir::RegisteredObject< Reconstruction< DiscretisedDensity< 3, float > > >
    Cstir::Reconstruction< DiscretisedDensity< 3, float > >
     Cstir::AnalyticReconstructionBase class for all analytic reconstruction algorithmsThis class provides extra functinoality (compared to Reconstruction) as it assumes that the TargetT is really a VoxelsOnCartesianGrid
      Cstir::RegisteredParsingObject< DDSR2DReconstruction, Reconstruction< DiscretisedDensity< 3, float > >, AnalyticReconstruction >
      Cstir::RegisteredParsingObject< FBP2DReconstruction, Reconstruction< DiscretisedDensity< 3, float > >, AnalyticReconstruction >
       Cstir::FBP2DReconstructionReconstruction class for 2D Filtered Back Projection
      Cstir::RegisteredParsingObject< FBP3DRPReconstruction, Reconstruction< DiscretisedDensity< 3, float > >, AnalyticReconstruction >
       Cstir::FBP3DRPReconstructionThis class contains the implementation of the FBP3DRP algorithm
      Cstir::RegisteredParsingObject< GRD2DReconstruction, Reconstruction< DiscretisedDensity< 3, float > >, AnalyticReconstruction >
      Cstir::RegisteredParsingObject< SRT2DReconstruction, Reconstruction< DiscretisedDensity< 3, float > >, AnalyticReconstruction >
       Cstir::SRT2DReconstructionReconstruction class for 2D Spline Reconstruction Technique
      Cstir::RegisteredParsingObject< SRT2DSPECTReconstruction, Reconstruction< DiscretisedDensity< 3, float > >, AnalyticReconstruction >
       Cstir::SRT2DSPECTReconstructionReconstruction class for 2D Spline Reconstruction Technique
   Cstir::RegisteredObject< OutputFileFormat< DiscretisedDensity< 3, float > > >
    Cstir::OutputFileFormat< DiscretisedDensity< 3, float > >
     Cstir::RegisteredParsingObject< ECAT6OutputFileFormat, OutputFileFormat< DiscretisedDensity< 3, float > >, OutputFileFormat< DiscretisedDensity< 3, float > > >
      Cstir::ecat::ecat6::ECAT6OutputFileFormatImplementation of OutputFileFormat paradigm for the ECAT6 format
     Cstir::RegisteredParsingObject< ECAT7OutputFileFormat, OutputFileFormat< DiscretisedDensity< 3, float > >, OutputFileFormat< DiscretisedDensity< 3, float > > >
      Cstir::ecat::ecat7::ECAT7OutputFileFormatImplementation of OutputFileFormat paradigm for the ECAT7 format
     Cstir::RegisteredParsingObject< InterfileOutputFileFormat, OutputFileFormat< DiscretisedDensity< 3, float > >, OutputFileFormat< DiscretisedDensity< 3, float > > >
      Cstir::InterfileOutputFileFormatImplementation of OutputFileFormat paradigm for the Interfile format
     Cstir::RegisteredParsingObject< ITKOutputFileFormat, OutputFileFormat< DiscretisedDensity< 3, float > >, OutputFileFormat< DiscretisedDensity< 3, float > > >
      Cstir::ITKOutputFileFormatImplementation of OutputFileFormat paradigm using the ITK library for writing
   Cstir::RegisteredObject< DataProcessor< DiscretisedDensity< 3, float > > >
    Cstir::DataProcessor< DiscretisedDensity< 3, float > >
   Cstir::RegisteredObject< BackProjectorByBin >
    Cstir::BackProjectorByBinAbstract base class for all back projectors
     Cstir::RegisteredParsingObject< BackProjectorByBinNiftyPET, BackProjectorByBin >
      Cstir::BackProjectorByBinNiftyPETClass for NiftyPET's GPU back projector
     Cstir::RegisteredParsingObject< BackProjectorByBinParallelproj, BackProjectorByBin >
      Cstir::BackProjectorByBinParallelprojClass for Parallelproj's back projector
     Cstir::RegisteredParsingObject< BackProjectorByBinUsingInterpolation, BackProjectorByBin >
      Cstir::BackProjectorByBinUsingInterpolationDoes backprojection by interpolating between the bins
     Cstir::RegisteredParsingObject< BackProjectorByBinUsingProjMatrixByBin, BackProjectorByBin >
      Cstir::BackProjectorByBinUsingProjMatrixByBinThis implements the BackProjectorByBin interface, given any ProjMatrixByBin object
     Cstir::RegisteredParsingObject< BackProjectorByBinUsingSquareProjMatrixByBin, BackProjectorByBin >
      Cstir::BackProjectorByBinUsingSquareProjMatrixByBinThis implements the BackProjectorByBin interface, given any ProjMatrixByBin object
     Cstir::RegisteredParsingObject< PostsmoothingBackProjectorByBin, BackProjectorByBin >
      Cstir::PostsmoothingBackProjectorByBinA very preliminary class that first smooths the image, then back projects
   Cstir::RegisteredObject< BinNormalisation >
    Cstir::BinNormalisationAbstract base class for implementing bin-wise normalisation of data
     Cstir::RegisteredParsingObject< BinNormalisationFromAttenuationImage, BinNormalisation >
      Cstir::BinNormalisationFromAttenuationImageA BinNormalisation class that gets attenuation correction factors from an attenuation image
     Cstir::RegisteredParsingObject< BinNormalisationFromML2D, BinNormalisation >
      Cstir::BinNormalisationFromML2DA BinNormalisation class that gets the normalisation factors from the files output by find_ML_normfactors
     Cstir::RegisteredParsingObject< BinNormalisationFromProjData, BinNormalisation >
      Cstir::BinNormalisationFromProjDataA BinNormalisation class that gets the normalisation factors from a ProjData object
     Cstir::RegisteredParsingObject< BinNormalisationSinogramRescaling, BinNormalisation >
      Cstir::BinNormalisationSinogramRescalingGets normaliastion factors by dividing forward projection of the fitted cyl. to the precorrecred data
     Cstir::RegisteredParsingObject< BinNormalisationUsingProfile, BinNormalisation >
     Cstir::RegisteredParsingObject< ChainedBinNormalisation, BinNormalisation >
      Cstir::ChainedBinNormalisationA BinNormalisation class that simply multiplies the factors given by 2 BinNormalisation objects
     Cstir::RegisteredParsingObject< TrivialBinNormalisation, BinNormalisation >
      Cstir::TrivialBinNormalisationTrivial class which does not do any normalisation whatsoever
     Cstir::BinNormalisationPETFromComponentsA BinNormalisation class that uses component-based normalisation for PET
     Cstir::BinNormalisationWithCalibration
      Cstir::RegisteredParsingObject< BinNormalisationFromPETSIRD, BinNormalisation, BinNormalisationWithCalibration >
      Cstir::RegisteredParsingObject< BinNormalisationSPECT, BinNormalisation, BinNormalisationWithCalibration >
      Cstir::RegisteredParsingObject< BinNormalisationFromGEHDF5, BinNormalisation, BinNormalisationWithCalibration >
       Cstir::GE::RDF_HDF5::BinNormalisationFromGEHDF5A BinNormalisation class that gets the normalisation factors from an GEHDF5 3D normalisation file
      Cstir::RegisteredParsingObject< BinNormalisationFromECAT8, BinNormalisation, BinNormalisationWithCalibration >
       Cstir::ecat::BinNormalisationFromECAT8A BinNormalisation class that gets the normalisation factors from an ECAT8 3D normalisation file. Note that you have to point it to the "Interfile" header
      Cstir::RegisteredParsingObject< BinNormalisationFromECAT7, BinNormalisation, BinNormalisationWithCalibration >
       Cstir::ecat::ecat7::BinNormalisationFromECAT7A BinNormalisation class that gets the normalisation factors from an ECAT7 3D normalisation file
   Cstir::RegisteredObject< DataProcessor< DataT > >
    Cstir::DataProcessor< DataT >Base class that defines an interface for classes that do data processing
     Cstir::RegisteredParsingObject< ChainedDataProcessor< DataT >, DataProcessor< DataT >, DataProcessor< DataT > >
      Cstir::ChainedDataProcessor< DataT >A class in the DataProcessor hierarchy that calls 2 DataProcessors in sequence
     Cstir::RegisteredParsingObject< SeparableConvolutionImageFilter< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
      Cstir::SeparableConvolutionImageFilter< elemT >A class derived from DataProcessor for performing separable non-periodic convolutions
     Cstir::RegisteredParsingObject< SeparableGaussianImageFilter< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
      Cstir::SeparableGaussianImageFilter< elemT >A class in the DataProcessor hierarchy that implements Gaussian filtering
      Cstir::SeparableGaussianImageFilter< elemT >A class in the DataProcessor hierarchy that implements Gaussian filtering
     Cstir::RegisteredParsingObject< ThresholdMinToSmallPositiveValueDataProcessor< DataT >, DataProcessor< DataT >, DataProcessor< DataT > >
      Cstir::ThresholdMinToSmallPositiveValueDataProcessor< DataT >A class in the DataProcessor hierarchy for making sure all elements are strictly positive
     Cstir::RegisteredParsingObject< ModifiedInverseAveragingImageFilterAll< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
     Cstir::RegisteredParsingObject< ModifiedInverseAverigingImageFilter< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
     Cstir::RegisteredParsingObject< NonseparableSpatiallyVaryingFilters< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
     Cstir::RegisteredParsingObject< NonseparableSpatiallyVaryingFilters3D< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
     Cstir::RegisteredParsingObject< SeparableLowPassImageFilter< elemT >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > >, DataProcessor< DiscretisedDensity< num_dimensions, elemT > > >
   Cstir::RegisteredObject< ForwardProjectorByBin >
    Cstir::ForwardProjectorByBinAbstract base class for all forward projectors
     Cstir::RegisteredParsingObject< ForwardProjectorByBinNiftyPET, ForwardProjectorByBin >
      Cstir::ForwardProjectorByBinNiftyPETClass for NiftyPET's GPU forward projector
     Cstir::RegisteredParsingObject< ForwardProjectorByBinParallelproj, ForwardProjectorByBin >
      Cstir::ForwardProjectorByBinParallelprojClass for Parallelproj's forward projector
     Cstir::RegisteredParsingObject< ForwardProjectorByBinUsingProjMatrixByBin, ForwardProjectorByBin >
      Cstir::ForwardProjectorByBinUsingProjMatrixByBinThis implements the ForwardProjectorByBin interface, given any ProjMatrixByBin object
     Cstir::RegisteredParsingObject< ForwardProjectorByBinUsingRayTracing, ForwardProjectorByBin >
      Cstir::ForwardProjectorByBinUsingRayTracingThis class implements forward projection using Siddon's algorithm for ray tracing. That is, it computes length of intersection with the voxels
     Cstir::RegisteredParsingObject< PostsmoothingForwardProjectorByBin, ForwardProjectorByBin >
      Cstir::PostsmoothingForwardProjectorByBinA very preliminary class that first forward projects, and then smooths the viewgrams
     Cstir::RegisteredParsingObject< PresmoothingForwardProjectorByBin, ForwardProjectorByBin >
      Cstir::PresmoothingForwardProjectorByBinA very preliminary class that first smooths the image, then forward projects
   Cstir::RegisteredObject< GeneralisedObjectiveFunction< TargetT > >
    Cstir::GeneralisedObjectiveFunction< TargetT >A base class for 'generalised' objective functions, i.e. objective functions for which at least a 'gradient' is defined
     Cstir::PoissonLogLikelihoodWithLinearModelForMean< TargetT >Base class for LogLikelihood of independent Poisson variables where the mean values are linear combinations of the parameters
      Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearKineticModelAndDynamicProjectionData< TargetT >, GeneralisedObjectiveFunction< TargetT >, PoissonLogLikelihoodWithLinearModelForMean< TargetT > >
       Cstir::PoissonLogLikelihoodWithLinearKineticModelAndDynamicProjectionData< TargetT >Base class for LogLikelihood of independent Poisson variables where the mean values are linear combinations of the kinetic parameters
      Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion< TargetT >, GeneralisedObjectiveFunction< TargetT >, PoissonLogLikelihoodWithLinearModelForMean< TargetT > >
       Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion< TargetT >Base class for LogLikelihood of independent Poisson variables where the mean values are linear combinations of the gated images
      Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndProjData< TargetT >, GeneralisedObjectiveFunction< TargetT >, PoissonLogLikelihoodWithLinearModelForMean< TargetT > >
       Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndProjData< TargetT >An objective function class appropriate for PET emission data
      Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndDynamicProjData< TargetT >, GeneralisedObjectiveFunction< TargetT >, PoissonLogLikelihoodWithLinearModelForMean< TargetT > >
       Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndDynamicProjData< TargetT >Base class for LogLikelihood of independent Poisson variables where the mean values are linear combinations of the frames
      Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndListModeData< TargetT >An objective function class appropriate for PET list mode data
       Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin< TargetT >, GeneralisedObjectiveFunction< TargetT >, PoissonLogLikelihoodWithLinearModelForMeanAndListModeData< TargetT > >
        Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin< TargetT >Class for PET list mode data from static images for a scanner with discrete detectors
     Cstir::SumOfGeneralisedObjectiveFunctions< ObjFuncT, TargetT, ParentT >A base class for sums of 'generalised' objective functions, i.e. objective functions for which at least a 'gradient' is defined
      Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion< TargetT >, GeneralisedObjectiveFunction< TargetT >, SumOfGeneralisedObjectiveFunctions< PoissonLogLikelihoodWithLinearModelForMeanAndProjData< TargetT >, TargetT, PoissonLogLikelihoodWithLinearModelForMean< TargetT > > >
       Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndGatedProjDataWithMotion< TargetT >Base class for LogLikelihood of independent Poisson variables where the mean values are linear combinations of the gated images
   Cstir::RegisteredObject< GeneralisedPrior< DataT > >
    Cstir::GeneralisedPrior< DataT >A base class for 'generalised' priors, i.e. priors for which at least a 'gradient' is defined
     Cstir::RegisteredParsingObject< FilterRootPrior< DataT >, GeneralisedPrior< DataT >, GeneralisedPrior< DataT > >
      Cstir::FilterRootPrior< DataT >A class in the GeneralisedPrior hierarchy. This implements 'generalised' priors a la the Median Root Prior (which was invented by Sakari Alenius)
   Cstir::RegisteredObject< OutputFileFormat< DynamicDiscretisedDensity > >
    Cstir::OutputFileFormat< DynamicDiscretisedDensity >
     Cstir::RegisteredParsingObject< ECAT7DynamicDiscretisedDensityOutputFileFormat, OutputFileFormat< DynamicDiscretisedDensity >, OutputFileFormat< DynamicDiscretisedDensity > >
      Cstir::ecat::ecat7::ECAT7DynamicDiscretisedDensityOutputFileFormatImplementation of OutputFileFormat paradigm for the ECAT7 format
     Cstir::RegisteredParsingObject< InterfileDynamicDiscretisedDensityOutputFileFormat, OutputFileFormat< DynamicDiscretisedDensity >, OutputFileFormat< DynamicDiscretisedDensity > >
      Cstir::InterfileDynamicDiscretisedDensityOutputFileFormatImplementation of OutputFileFormat paradigm for the Interfile format
     Cstir::RegisteredParsingObject< MultiDynamicDiscretisedDensityOutputFileFormat, OutputFileFormat< DynamicDiscretisedDensity >, OutputFileFormat< DynamicDiscretisedDensity > >
      Cstir::MultiDynamicDiscretisedDensityOutputFileFormatImplementation of OutputFileFormat paradigm for the Multi format
   Cstir::RegisteredObject< OutputFileFormat< ParametricVoxelsOnCartesianGrid > >
    Cstir::OutputFileFormat< ParametricVoxelsOnCartesianGrid >
   Cstir::RegisteredObject< InputStreamFromROOTFile >
    Cstir::InputStreamFromROOTFileA helper class to read data from a ROOT file Generated by GATE simulation toolkit
     Cstir::RegisteredParsingObject< InputStreamFromROOTFileForCylindricalPET, InputStreamFromROOTFile, InputStreamFromROOTFile >
      Cstir::InputStreamFromROOTFileForCylindricalPETDeclaration of class stir::InputStreamFromROOTFileForCylindricalPET
     Cstir::RegisteredParsingObject< InputStreamFromROOTFileForECATPET, InputStreamFromROOTFile, InputStreamFromROOTFile >
      Cstir::InputStreamFromROOTFileForECATPETDeclaration of class stir::InputStreamFromROOTFileForECATPET
   Cstir::RegisteredObject< InputStreamWithRecordsFromUPENN >
    Cstir::InputStreamWithRecordsFromUPENNBase class for reading listmode files from the PENNPet Explorer scanner
     Cstir::RegisteredParsingObject< InputStreamWithRecordsFromUPENNbin, InputStreamWithRecordsFromUPENN, InputStreamWithRecordsFromUPENN >
      Cstir::InputStreamWithRecordsFromUPENNbinClass for reading binary listmode files from the PENNPet Explorer scanner
     Cstir::RegisteredParsingObject< InputStreamWithRecordsFromUPENNtxt, InputStreamWithRecordsFromUPENN, InputStreamWithRecordsFromUPENN >
      Cstir::InputStreamWithRecordsFromUPENNtxtClass for reading listmode files in text format from the PENNPet Explorer scanner
   Cstir::RegisteredObject< KineticModel >
    Cstir::KineticModelBase class for all kinetic models
     Cstir::RegisteredParsingObject< PatlakPlot, KineticModel >
      Cstir::PatlakPlotPatlak kinetic model
   Cstir::RegisteredObject< ObjectTransformation< num_dimensions, elemT > >
    Cstir::ObjectTransformation< 3, elemT >
    Cstir::ObjectTransformation< num_dimensions, elemT >Base-class for performing (potentially non-rigid) object transformations
     Cstir::RegisteredParsingObject< NonRigidObjectTransformationUsingBSplines< num_dimensions, elemT >, ObjectTransformation< num_dimensions, elemT >, ObjectTransformation< num_dimensions, elemT > >
      Cstir::NonRigidObjectTransformationUsingBSplines< num_dimensions, elemT >Class to perform non-rigid object transformations in arbitrary dimensions
   Cstir::RegisteredObject< OutputFileFormat< DataT > >
    Cstir::OutputFileFormat< DataT >Base class for classes that create output files
     Cstir::RegisteredParsingObject< ECAT7ParametricDensityOutputFileFormat< DiscretisedDensityT >, OutputFileFormat< ParametricDiscretisedDensity< DiscretisedDensityT > >, OutputFileFormat< ParametricDiscretisedDensity< DiscretisedDensityT > > >
      Cstir::ecat::ecat7::ECAT7ParametricDensityOutputFileFormat< DiscretisedDensityT >Implementation of OutputFileFormat paradigm for the ECAT7 format
     Cstir::RegisteredParsingObject< InterfileParametricDiscretisedDensityOutputFileFormat< DiscDensityT >, OutputFileFormat< ParametricDiscretisedDensity< DiscDensityT > >, OutputFileFormat< ParametricDiscretisedDensity< DiscDensityT > > >
      Cstir::InterfileParametricDiscretisedDensityOutputFileFormat< DiscDensityT >Implementation of OutputFileFormat paradigm for the Interfile format
     Cstir::RegisteredParsingObject< MultiParametricDiscretisedDensityOutputFileFormat< DiscDensityT >, OutputFileFormat< ParametricDiscretisedDensity< DiscDensityT > >, OutputFileFormat< ParametricDiscretisedDensity< DiscDensityT > > >
      Cstir::MultiParametricDiscretisedDensityOutputFileFormat< DiscDensityT >Implementation of OutputFileFormat paradigm for the Multi format
   Cstir::RegisteredObject< GeneralisedPrior< TargetT > >
    Cstir::GeneralisedPrior< TargetT >
     Cstir::PriorWithParabolicSurrogate< TargetT >This class implements priors with a parabolic surrogate curvature
      Cstir::RegisteredParsingObject< LogcoshPrior< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, PriorWithParabolicSurrogate< DiscretisedDensity< 3, elemT > > >
       Cstir::LogcoshPrior< elemT >A class in the GeneralisedPrior hierarchy. This implements a logcosh Gibbs prior
      Cstir::RegisteredParsingObject< QuadraticPrior< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, PriorWithParabolicSurrogate< DiscretisedDensity< 3, elemT > > >
       Cstir::QuadraticPrior< elemT >A class in the GeneralisedPrior hierarchy. This implements a quadratic Gibbs prior
      Cstir::RegisteredParsingObject< ParametricQuadraticPrior< TargetT >, GeneralisedPrior< TargetT >, PriorWithParabolicSurrogate< TargetT > >
       Cstir::ParametricQuadraticPrior< TargetT >A class in the GeneralisedPrior hierarchy. This implements a quadratic Gibbs prior
   Cstir::RegisteredObject< ProjDataRebinning >
    Cstir::ProjDataRebinningBase class for all rebinning algorithms for 3D PET data
     Cstir::RegisteredParsingObject< FourierRebinning, ProjDataRebinning, ProjDataRebinning >
      Cstir::FourierRebinningClass for Serial FORE Reconstruction
   Cstir::RegisteredObject< ProjMatrixByBin >
    Cstir::ProjMatrixByBinThis is the (abstract) base class for all projection matrices which are organised by 'bin'
     Cstir::RegisteredParsingObject< ProjMatrixByBinFromFile, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinFromFileReads/writes a projection matrix from/to file
     Cstir::RegisteredParsingObject< ProjMatrixByBinPinholeSPECTUB, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinPinholeSPECTUBGenerates projection matrix for pinhole SPECT studies
     Cstir::RegisteredParsingObject< ProjMatrixByBinSPECTUB, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinSPECTUBGenerates projection matrix for SPECT studies
     Cstir::RegisteredParsingObject< ProjMatrixByBinSinglePhoton, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinSinglePhoton'projection matrix' to implement a model for a single photon acquisition in terms of the detector efficiencies
     Cstir::RegisteredParsingObject< ProjMatrixByBinUsingInterpolation, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinUsingInterpolationComputes projection matrix elements for VoxelsOnCartesianGrid images by using an interpolation model
     Cstir::RegisteredParsingObject< ProjMatrixByBinUsingRayTracing, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinUsingRayTracingComputes projection matrix elements for VoxelsOnCartesianGrid images by using a Length of Intersection (LOI) model
     Cstir::RegisteredParsingObject< ProjMatrixByBinUsingSolidAngle, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinUsingSolidAngleComputes projection matrix elements for VoxelsOnCartesianGrid images by using a Solid Angle model
     Cstir::RegisteredParsingObject< ProjMatrixByBinWithPositronRange, ProjMatrixByBin, ProjMatrixByBin >
      Cstir::ProjMatrixByBinWithPositronRangeComputes projection matrix elements for VoxelsOnCartesianGrid images by using a Solid Angle model
   Cstir::RegisteredObject< ProjMatrixByDensel >
    Cstir::ProjMatrixByDenselThis is the (abstract) base class for all projection matrices which are organised by 'Densel'
     Cstir::ProjMatrixByDenselOnCartesianGridUsingElementComputes projection matrix elements for VoxelsOnCartesianGrid images by using a Length of Intersection (LOI) model
      Cstir::RegisteredParsingObject< ProjMatrixByDenselUsingRayTracing, ProjMatrixByDenselOnCartesianGridUsingElement >
       Cstir::ProjMatrixByDenselUsingRayTracingComputes projection matrix elements for VoxelsOnCartesianGrid images by using a Length of Intersection (LOI) model
   Cstir::RegisteredObject< ProjectorByBinPair >
    Cstir::ProjectorByBinPairAbstract base class for all projector pairs
     Cstir::RegisteredParsingObject< ProjectorByBinPairUsingNiftyPET, ProjectorByBinPair, ProjectorByBinPair >
      Cstir::ProjectorByBinPairUsingNiftyPETA projector pair based on NiftyPET projectors
     Cstir::RegisteredParsingObject< ProjectorByBinPairUsingParallelproj, ProjectorByBinPair, ProjectorByBinPair >
      Cstir::ProjectorByBinPairUsingParallelprojA projector pair based on Parallelproj projectors
     Cstir::RegisteredParsingObject< ProjectorByBinPairUsingProjMatrixByBin, ProjectorByBinPair, ProjectorByBinPair >
      Cstir::ProjectorByBinPairUsingProjMatrixByBinA projector pair based on a single matrix
     Cstir::RegisteredParsingObject< ProjectorByBinPairUsingSeparateProjectors, ProjectorByBinPair, ProjectorByBinPair >
      Cstir::ProjectorByBinPairUsingSeparateProjectorsA projector pair based on a single matrix
   Cstir::RegisteredObject< Reconstruction< TargetT > >
    Cstir::Reconstruction< TargetT >Base class for all ReconstructionsAs there is not a lot of commonality between different reconstruction algorithms, this base class is rather basic. It essentially takes care of constructing a target image, calls the virtual reconstruct() function, and writes the result to file
     Cstir::IterativeReconstruction< TargetT >Base class for iterative reconstruction objects
      Cstir::RegisteredParsingObject< OSMAPOSLReconstruction< TargetT >, Reconstruction< TargetT >, IterativeReconstruction< TargetT > >
       Cstir::OSMAPOSLReconstruction< TargetT >Implementation of the Ordered Subsets version of Green's MAP One Step Late algorithm
        Cstir::RegisteredParsingObject< KOSMAPOSLReconstruction< TargetT >, Reconstruction< TargetT >, OSMAPOSLReconstruction< TargetT > >
         Cstir::KOSMAPOSLReconstruction< TargetT >A reconstructor class appropriate for emission data
      Cstir::RegisteredParsingObject< OSSPSReconstruction< TargetT >, Reconstruction< TargetT >, IterativeReconstruction< TargetT > >
       Cstir::OSSPSReconstruction< TargetT >Implementation of the relaxed Ordered Subsets Separable Paraboloidal Surrogate ( OSSPS)
   Cstir::RegisteredObject< RigidObject3DMotion >
    Cstir::RigidObject3DMotionBase class for 3D rigid motion
     Cstir::RegisteredParsingObject< RigidObject3DMotionFromPolaris, RigidObject3DMotion, RigidObject3DMotion >
      Cstir::RigidObject3DMotionFromPolarisA class for handling motion information from the Polaris tracker
   Cstir::RegisteredObject< ObjectTransformation< num_dimensions, float > >
    Cstir::ObjectTransformation< 3, float >
     Cstir::RegisteredParsingObject< RigidObject3DTransformation, ObjectTransformation< 3, float >, ObjectTransformation< 3, float > >
      Cstir::RigidObject3DTransformationClass to perform rigid object transformations in 3 dimensions
   Cstir::RegisteredObject< ScatterSimulation >
    Cstir::ScatterSimulationSimulate the scatter probability using a model-based approach
     Cstir::RegisteredParsingObject< SingleScatterSimulation, ScatterSimulation, ScatterSimulation >
      Cstir::SingleScatterSimulationPET single scatter simulation
   Cstir::RegisteredObject< Shape3D >
    Cstir::Shape3DThe base class for all 3 dimensional shapes
     Cstir::RegisteredParsingObject< CombinedShape3D, Shape3D, Shape3D >
      Cstir::CombinedShape3D< operation >A class that allows combining several shapes using logical operations
     Cstir::RegisteredParsingObject< DiscretisedShape3D, Shape3D, Shape3D >
      Cstir::DiscretisedShape3DA class for shapes that have been discretised as a volume
     Cstir::Shape3DWithOrientationClass for shapes with orientation
      Cstir::RegisteredParsingObject< Box3D, Shape3D, Shape3DWithOrientation >
       Cstir::Box3DThree-dimensional cuboid box
      Cstir::RegisteredParsingObject< Ellipsoid, Shape3D, Shape3DWithOrientation >
       Cstir::EllipsoidThree-dimensional ellipsoid
      Cstir::RegisteredParsingObject< EllipsoidalCylinder, Shape3D, Shape3DWithOrientation >
       Cstir::EllipsoidalCylinderThree-dimensional ellipsoidal cylinder
   Cstir::RegisteredObject< SinglesRates >
    Cstir::SinglesRatesThe base-class for using singles info
     Cstir::SinglesRatesForTimeFramesA class for singles rates that are recorded in time frames
      Cstir::RegisteredParsingObject< SinglesRatesFromJSON, SinglesRates, SinglesRatesForTimeFrames >
       Cstir::SinglesRatesFromJSONA class that gets the singles rates of the singles units ("buckets") from a JSON file
      Cstir::RegisteredParsingObject< SinglesRatesFromECAT7, SinglesRates, SinglesRatesForTimeFrames >
       Cstir::ecat::ecat7::SinglesRatesFromECAT7A class that extracts singles info from an ECAT7 sinogram file
     Cstir::SinglesRatesForTimeSlicesA class for singles that are recorded at equal time intervals
      Cstir::RegisteredParsingObject< SinglesRatesFromGEHDF5, SinglesRates, SinglesRatesForTimeSlices >
       Cstir::GE::RDF_HDF5::SinglesRatesFromGEHDF5A class for reading singles over the number of time samples from an GE HDF5 .BLF listmode file format
      Cstir::RegisteredParsingObject< SinglesRatesFromSglFile, SinglesRates, SinglesRatesForTimeSlices >
       Cstir::ecat::ecat7::SinglesRatesFromSglFileA class for reading/writing singles from an ECAT7 .sgl file
   Cstir::RegisteredObject< SpatialTransformation >
    Cstir::SpatialTransformationBase class for any type of motion fieldsAt present very basic. It just provides the parsing mechanism
     Cstir::RegisteredParsingObject< GatedSpatialTransformation, SpatialTransformation >
      Cstir::GatedSpatialTransformationClass for spatial transformations for gated images
   Cstir::RegisteredObject< DataProcessor< stir::DiscretisedDensity< 3, float > > >
    Cstir::DataProcessor< stir::DiscretisedDensity< 3, float > >
   Cstir::RegisteredObject< Reconstruction< stir::DiscretisedDensity< 3, float > > >
    Cstir::Reconstruction< stir::DiscretisedDensity< 3, float > >
   Cstir::RegisteredObject< OutputFileFormat< stir::DiscretisedDensity< 3, float > > >
    Cstir::OutputFileFormat< stir::DiscretisedDensity< 3, float > >
   Cstir::RegisteredObject< GeneralisedPrior< stir::DiscretisedDensity< 3, float > > >
    Cstir::GeneralisedPrior< stir::DiscretisedDensity< 3, float > >
   Cstir::RegisteredObject< OutputFileFormat< A > >
    Cstir::OutputFileFormat< A >
   Cstir::RegisteredObject< DataProcessor< TargetT > >
    Cstir::DataProcessor< TargetT >
     Cstir::RegisteredParsingObject< HUToMuImageProcessor< TargetT >, DataProcessor< TargetT >, DataProcessor< TargetT > >
      Cstir::HUToMuImageProcessor< TargetT >A class in the DataProcessor hierarchy that convert from Hounsfield Units to mu-values
   Cstir::RegisteredObject< OutputFileFormat< DiscretisedDensityType > >
    Cstir::OutputFileFormat< DiscretisedDensityType >
   Cstir::RegisteredObject< GeneralisedObjectiveFunction< stir::DiscretisedDensity< 3, float > > >
    Cstir::GeneralisedObjectiveFunction< stir::DiscretisedDensity< 3, float > >
     Cstir::PoissonLogLikelihoodWithLinearModelForMean< stir::DiscretisedDensity< 3, float > >
      Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndListModeData< stir::DiscretisedDensity< 3, float > >
       Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin< stir::DiscretisedDensity< 3, float > >, GeneralisedObjectiveFunction< stir::DiscretisedDensity< 3, float > >, PoissonLogLikelihoodWithLinearModelForMeanAndListModeData< stir::DiscretisedDensity< 3, float > > >
        Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin< stir::DiscretisedDensity< 3, float > >
      Cstir::RegisteredParsingObject< PoissonLogLikelihoodWithLinearModelForMeanAndProjData< stir::DiscretisedDensity< 3, float > >, GeneralisedObjectiveFunction< stir::DiscretisedDensity< 3, float > >, PoissonLogLikelihoodWithLinearModelForMean< stir::DiscretisedDensity< 3, float > > >
       Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndProjData< stir::DiscretisedDensity< 3, float > >
   Cstir::RegisteredObject< GeneralisedPrior< DiscretisedDensity< 3, float > > >
    Cstir::GeneralisedPrior< DiscretisedDensity< 3, float > >
     Cstir::PriorWithParabolicSurrogate< DiscretisedDensity< 3, float > >
      Cstir::RegisteredParsingObject< QuadraticPrior< float >, GeneralisedPrior< DiscretisedDensity< 3, float > >, PriorWithParabolicSurrogate< DiscretisedDensity< 3, float > > >
       Cstir::QuadraticPrior< float >
   Cstir::RegisteredObject< OutputFileFormat< TargetT > >
    Cstir::OutputFileFormat< TargetT >
   Cstir::RegisteredObject< Root >Helper class to provide registry mechanisms to a Base class
    Cstir::DataProcessor< DiscretisedDensity< 3, elemT > >
     Cstir::RegisteredParsingObject< GammaImageFilter2D< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::GammaImageFilter2D< elemT >A class in the ImageProcessor hierarchy that implements gamma correction filtering
     Cstir::RegisteredParsingObject< MaximalImageFilter3D< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::MaximalImageFilter3D< elemT >A class in the ImageProcessor hierarchy that implements maximal filtering
     Cstir::RegisteredParsingObject< MedianImageFilter3D< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::MedianImageFilter3D< elemT >A class in the ImageProcessor hierarchy that implements median filtering
     Cstir::RegisteredParsingObject< MinimalImageFilter3D< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::MinimalImageFilter3D< elemT >A class in the ImageProcessor hierarchy that implements minimal filtering
     Cstir::RegisteredParsingObject< NonseparableConvolutionUsingRealDFTImageFilter< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::NonseparableConvolutionUsingRealDFTImageFilter< elemT >A class derived from DataProcessor for performing separable periodic convolutions with an array kernel
     Cstir::RegisteredParsingObject< SeparableCartesianMetzImageFilter< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::SeparableCartesianMetzImageFilter< elemT >A class in the DataProcessor hierarchy that implements Metz filtering (which includes Gaussian filtering)
     Cstir::RegisteredParsingObject< TruncateToCylindricalFOVImageProcessor< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::TruncateToCylindricalFOVImageProcessor< elemT >A class in the DataProcessor hierarchy that sets voxels to 0 outside a given radius
     Cstir::RegisteredParsingObject< WienerImageFilter2D< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::WienerImageFilter2D< elemT >A class in the ImageProcessor hierarchy that implements wiener filtering
     Cstir::RegisteredParsingObject< multiply_plane_scale_factorsImageProcessor< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::multiply_plane_scale_factorsImageProcessor< elemT >Simply multiplies each plane in an image with a scale factor
     Cstir::RegisteredParsingObject< DAVImageFilter3D< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
     Cstir::RegisteredParsingObject< Transform3DObjectImageProcessor< elemT >, DataProcessor< DiscretisedDensity< 3, elemT > >, DataProcessor< DiscretisedDensity< 3, elemT > > >
      Cstir::Transform3DObjectImageProcessor< elemT >A class in the ImageProcessor hierarchy that performs movement by reinterpolation
    Cstir::GeneralisedPrior< DiscretisedDensity< 3, elemT > >
     Cstir::GibbsPenalty< elemT, PotentialT >
      Cstir::CudaGibbsPenalty< elemT, PotentialT >A base class with CUDA-accelerated implementation of the GibbsPenalty class
     Cstir::RegisteredParsingObject< PLSPrior< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, GeneralisedPrior< DiscretisedDensity< 3, elemT > > >
      Cstir::PLSPrior< elemT >A class in the GeneralisedPrior hierarchy. This implements the anatomical penalty function, Parallel Level Sets (PLS), also sometimes called Directional TV, proposed by Matthias J. Ehrhardt et. al in "PET Reconstruction With an Anatomical MRI Prior Using Parallel Level Sets", IEEE Trans. med. Imag., vol. 35, no. 9, Sept. 2016. https://doi.org/10.1109/TMI.2016.2549601 Note that PLS becomes smoothed TV when an uniform anatomical image is provided
     Cstir::RegisteredParsingObject< RelativeDifferencePrior< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, GeneralisedPrior< DiscretisedDensity< 3, elemT > > >
      Cstir::RelativeDifferencePrior< elemT >A class in the GeneralisedPrior hierarchy. This implements a Relative Difference prior
       Cstir::RegisteredParsingObject< CudaRelativeDifferencePrior< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, RelativeDifferencePrior< elemT > >
        Cstir::CudaRelativeDifferencePrior< elemT >CUDA implementation of the Relative Difference prior
     Cstir::GibbsPenalty< elemT, potentialT >A base class for Gibbs type penalties in the GeneralisedPrior hierarchy
      Cstir::RegisteredParsingObject< GibbsQuadraticPenalty< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, GibbsPenalty< elemT, QuadraticPotential< elemT > > >
       Cstir::GibbsQuadraticPenalty< elemT >Multithreaded CPU Implementation of the Quadratic Gibbs prior
      Cstir::RegisteredParsingObject< GibbsRelativeDifferencePenalty< elemT >, GeneralisedPrior< DiscretisedDensity< 3, elemT > >, GibbsPenalty< elemT, RelativeDifferencePotential< elemT > > >
       Cstir::GibbsRelativeDifferencePenalty< elemT >Multithreaded CPU Implementation of the Relative Difference penalty
  Cstir::SAFIRCListmodeInputFileFormat< EventDataType >Class for reading SAFIR coincidence listmode data
  Cstir::ScatterEstimationEstimate the scatter probability using a model-based approach
  Cstir::SqrtHessianRowSum< TargetT >Implementations of two square root Hessian row sum computation methods, as proposed by Tsai et al. (2020)
  Cstir::TimeFrameMotionA class for encoding average motion in the frames
   Cstir::MoveImageA class for moving an image according to average motion in the frame
   Cstir::MoveProjDataA class for moving projection data according to average motion in the frame
   Cstir::ReportMovementA class for reporting the movement within the frame w.r.t. to the reference position
 Cboost::partially_ordered< T, B >Boost class to define all comparison operators given only 2 (see operators.hpp)
  Cstir::BasicCoordinate< num_dimensions, T >
  Cstir::BasicCoordinate< 1, T >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, Array< num_dimensions, elemT > >, boost::equality_comparable< BasicCoordinate< num_dimensions, Array< num_dimensions, elemT > > > >
  Cstir::BasicCoordinate< num_dimensions, Array< num_dimensions, elemT > >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, BSplineType >, boost::equality_comparable< BasicCoordinate< num_dimensions, BSplineType > > >
  Cstir::BasicCoordinate< num_dimensions, BSplineType >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, coordT >, boost::equality_comparable< BasicCoordinate< num_dimensions, coordT > > >
  Cstir::BasicCoordinate< 2, coordT >
   Cstir::Coordinate2D< coordT >Templated class for 2-dimensional coordinates
    Cstir::CartesianCoordinate2D< coordT >Templated class for 2-dimensional coordinates
  Cstir::BasicCoordinate< 3, coordT >
   Cstir::Coordinate3D< coordT >Templated class for 3-dimensional coordinates
    Cstir::CartesianCoordinate3D< coordT >Templated class for 3-dimensional coordinates
  Cstir::BasicCoordinate< 4, coordT >
   Cstir::Coordinate4D< coordT >Templated class for 4-dimensional coordinates
  Cstir::BasicCoordinate< num_dimensions, coordT >Class BasicCoordinate<int num_dimensions, typename coordT> defines num_dimensions -dimensional coordinates
   Cstir::Coordinate2D< int >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, elemT >, boost::equality_comparable< BasicCoordinate< num_dimensions, elemT > > >
  Cstir::BasicCoordinate< num_param, elemT >
  Cstir::BasicCoordinate< num_dimensions, elemT >
  Cstir::BasicCoordinate< 3, elemT >
   Cstir::Coordinate3D< elemT >
    Cstir::CartesianCoordinate3D< elemT >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, float >, boost::equality_comparable< BasicCoordinate< num_dimensions, float > > >
  Cstir::BasicCoordinate< num_dimensions, float >
  Cstir::BasicCoordinate< 3, float >
   Cstir::Coordinate3D< float >
    Cstir::CartesianCoordinate3D< float >
  Cstir::BasicCoordinate< 4, float >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, int >, boost::equality_comparable< BasicCoordinate< num_dimensions, int > > >
  Cstir::BasicCoordinate< num_dimensions, int >
  Cstir::BasicCoordinate< 3, int >
   Cstir::Coordinate3D< int >
    Cstir::CartesianCoordinate3D< int >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, out_elemT >, boost::equality_comparable< BasicCoordinate< num_dimensions, out_elemT > > >
  Cstir::BasicCoordinate< num_dimensions, out_elemT >
 Cboost::partially_ordered< BasicCoordinate< num_dimensions, stir::BSpline::BSplinesRegularGrid< num_dimensions, elemT, elemT > >, boost::equality_comparable< BasicCoordinate< num_dimensions, stir::BSpline::BSplinesRegularGrid< num_dimensions, elemT, elemT > > > >
  Cstir::BasicCoordinate< num_dimensions, stir::BSpline::BSplinesRegularGrid< num_dimensions, elemT, elemT > >
 Cboost::partially_ordered< DetectionPosition< unsigned int >, boost::equality_comparable< DetectionPosition< unsigned int > > >
  Cstir::DetectionPosition< unsigned int >
  Cstir::DetectionPosition< coordT >A class for storing coordinates of a detection
 Cstir::PatientPosition
 Cstir::PETSIRDInfoClass to hold PETSIRD-related information for STIR and do any necessary conversions
 Cstir::PlasmaDataA class for storing plasma and blood samples of a single study
 Cstir::PlasmaSample
 Cstir::PointOnCylinder< coordT >A class for a point on a cylinder
 Cstir::Polaris_MT_FileClass for parsing .mt files output by the Polaris software
 CSPECTUB::proj_typeStructure for projection information
 Cstir::ProjDataInfoAn (abstract base) class that contains information on the projection data
  Cstir::ProjDataInfoCylindricalProjection data info for data corresponding to a 'cylindrical' sampling
   Cstir::ProjDataInfoCylindricalArcCorrProjection data info for arc-corrected data
   Cstir::ProjDataInfoCylindricalNoArcCorrProjection data info for data which are not arc-corrected
    Cstir::ProjDataInfoGenericNoArcCorrProjection data info for data for a scanner with discrete detectors
     Cstir::ProjDataInfoBlocksOnCylindricalNoArcCorrProjection data info for data from a scanner with discrete dtectors organised by blocks
  Cstir::ProjDataInfoSubsetByViewProjection data info for data corresponding to a subset sampling by views
 Cstir::ProjMatrixElemsForOneBinThis stores the non-zero projection matrix elements for every 'densel' that contributes to a given bin
 Cstir::ProjMatrixElemsForOneBinValueStores voxel coordinates and the value of the matrix element
 Cstir::ProjMatrixElemsForOneDenselThis stores the non-zero projection matrix elements for every 'voxel'
 CSPECTUB::psf1d_typeStructure for PSF information
 CSPECTUB::psf2da_typeStructure for distribution function information
 Cstir::PtrBeginEndAllFunction< TopLevelIterT, RestIterT >Helper class for NestedIterator when the 1st level iterator refers to a pointer to a stir full iterator for the 2nd level iterator
 Cstir::PtrBeginEndAllFunction< TopLevelIterT, boost::pointee< boost::iterator_value< TopLevelIterT >::type >::type::const_full_iterator >
  Cstir::ConstPtrBeginEndAllFunction< TopLevelIterT >Convenience class where the 2nd level iterator is a const_full_iterator
 Cstir::PtrBeginEndFunction< TopLevelIterT, RestIterT >Helper class for NestedIterator when the 1st level iterator refers to pointers to an ordinary iterator for the 2nd level iterator
 Cstir::PtrBeginEndFunction< TopLevelIterT, boost::pointee< boost::iterator_value< TopLevelIterT >::type >::type::const_iterator >
  Cstir::ConstPtrBeginEndFunction< TopLevelIterT >Convenience class where the 2nd level iterator is a const_iterator
 Cstir::PullLinearInterpolator< elemT >A function object to pull interpolated values from the input array into the grid points of the output array
 Cstir::PullNearestNeighbourInterpolator< elemT >A function object to pull interpolated values from the input array into the grid points of the output array
 Cstir::PushNearestNeighbourInterpolator< elemT >A function object to push values at the grid of the input array into the output array
 Cstir::PushTransposeLinearInterpolator< elemT >A function object to push values at the grid of the input array into the output array
 Cstir::QuadraticPotential< elemT >Implementation of the Quadratic penalty potential
 Cstir::RadionuclideA class for storing radionuclide information
 Cstir::RegisteredParsingObject< Derived, Base, Parent >Parent class for all leaves in a RegisteredObject hierarchy that do parsing of parameter files
  Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndProjData< DiscretisedDensity< 3, float > >
 Cstir::RegisterInputFileFormat< Format >A helper class to allow automatic registration to the default InputFileFormatRegistry
 Cstir::RegisteredParsingObject< Derived, Base, Parent >::RegisterItA helper class to allow automatic registration
 Cstir::RelatedBinsThis class contains all information about a set of bins related by symmetry
 Cstir::RelatedDenselsThis class contains all information about a set of densels related by symmetry
 Cstir::RelativeDifferencePotential< elemT >Implementation of the Relative Difference penalty potential
 Cstir::ResolutionIndex< num_dimensions, elemT >Structure that is used to hold the output of the function find_fwhm_in_image
 Clist< T >::reverse_iteratorSTL iterator class
 Cmap< K, T >::reverse_iteratorSTL iterator class
 CSPECTUB::string::reverse_iteratorSTL iterator class
 CSPECTUB_mph::string::reverse_iteratorSTL iterator class
 Cstring::reverse_iteratorSTL iterator class
 Cvector< T >::reverse_iteratorSTL iterator class
 Cstir::ROIValuesA class to store and get results of an ROI calculation
 Cstir::RunTestsA base class for making test classes
  Cstir::IOTests< DiscretisedDensity< 3, float > >
   Cstir::IOTests_DiscretisedDensityA simple class to test the OutputFileFormat function
  Cstir::IOTests< DynamicDiscretisedDensity >
   Cstir::IOTests_DynamicDiscretisedDensityA simple class to test the OutputFileFormat function
  Cstir::IOTests< ParametricVoxelsOnCartesianGrid >
   Cstir::IOTests_ParametricDiscretisedDensityA simple class to test the OutputFileFormat function
  Cstir::ObjectiveFunctionTests< GeneralisedPrior< DiscretisedDensity< 3, float > >, DiscretisedDensity< 3, float > >
   Cstir::GeneralisedPriorTestsTest class for QuadraticPrior, RelativeDifferencePrior, CudaRelativeDifferencePrior and LogcoshPrior
    Cstir::LogCoshPriorTestsTests for LogCoshPrior
    Cstir::PLSPriorTestsTests for PLSPrior
    Cstir::QuadraticPriorTestsTests for QuadraticPrior
    Cstir::RelativeDifferencePriorTests< RDP >Tests for RelativeDifferencePrior
  Cstir::ObjectiveFunctionTests< PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin< DiscretisedDensity< 3, float > >, DiscretisedDensity< 3, float > >
   Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBinTestsTest class for PoissonLogLikelihoodWithLinearModelForMeanAndListModeDataWithProjMatrixByBin
  Cstir::ObjectiveFunctionTests< PoissonLogLikelihoodWithLinearModelForMeanAndProjData< DiscretisedDensity< 3, float > >, DiscretisedDensity< 3, float > >
   Cstir::PoissonLogLikelihoodWithLinearModelForMeanAndProjDataTestsTest class for PoissonLogLikelihoodWithLinearModelForMeanAndProjData
  Cstir::ReconstructionTests< target_type >
   Cstir::PoissonLLReconstructionTests< target_type >
    Cstir::TestOSMAPOSLTest class for OSMAPOSL
   Cstir::TestFBP2DTest class for FBP2D
   Cstir::TestFBP3DRPTest class for FBP3DRP
  Cstir::ArcCorrectionTestsTest class for ArcCorrection
  Cstir::ArrayFilterTestsTests Array functionality
  Cstir::ArrayTestsTests Array functionality
  Cstir::BSpline::BSplinesRegularGrid1D_TestsA simple class to test the BSplinesRegularGrid class for 1D arrays
  Cstir::BSpline::BSplinesRegularGrid_TestsA simple class to BSplinesRegularGrid for 2D arrays
  Cstir::BSpline::BSplines_TestsA simple class to test the BSplines function
  Cstir::BlocksTestsTest class for Blocks
  Cstir::ByteOrderTestsTest class for ByteOrder and the preprocessor defines from ByteOrderDefine.h
  Cstir::CUDACXXTestsTests cuda_utilities functionality without CUDA
  Cstir::DataSymmetriesForBins_PET_CartesianGridTestsTest class for DataSymmetriesForBins_PET_CartesianGrid
  Cstir::DateTimeTestClass with tests for date time functions
  Cstir::DetectionPosMapTestsTest class for Blocks
  Cstir::DetectionPosition_TestsClass with tests for DetectionPosition
  Cstir::FilenameTestsTest class for filename functions defined in utility.h
  Cstir::FourierTestsA simple class to test the erf and erfc functions
  Cstir::GeneralisedPoissonNoiseGeneratorTestsTests GeneralisedPoissonNoiseGenerator functionalityCurrently contains only simple tests to check mean and variance
  Cstir::GeometryBlocksOnCylindricalTestsTest class for BlocksOnCylindrical geometry
  Cstir::IOTests< A >A simple class to test the OutputFileFormat function
  Cstir::IOTests_ITKMulticomponentA simple class to test the reading of multicomponent ITK images
  Cstir::IR_filterTestsA simple class to test the IIR_filter and FIR_filter function
  Cstir::ImagingModalityTestsTest class for ImagingModality
  Cstir::IndexRange_TestsClass with tests for IndexRange, IndexRange3D
  Cstir::KeyParserTestsTest class for KeyParser
  Cstir::ML_normTestsTest class for ML_norm.h functions
  Cstir::MatrixTestsTests MatrixFunction.h functionality
  Cstir::MultipleProjDataTestsTest class for MultipleProjData
  Cstir::NestedIteratorTestsTests NestedIterator functionality
  Cstir::ObjectiveFunctionTests< ObjectiveFunctionT, TargetT >Test class for GeneralisedObjectiveFunction and GeneralisedPrior
  Cstir::OutputFileFormatTestsA simple class to test the OutputFileFormat function
  Cstir::ProjDataInMemoryTestsTest class for ProjDataInMemory
  Cstir::ProjDataInMemoryTestsTest class for ProjDataInMemory
  Cstir::ProjDataInfoTestsTest class for ProjDataInfo
   Cstir::ProjDataInfoCylindricalTestsTest class for ProjDataInfoCylindrical
    Cstir::ProjDataInfoCylindricalArcCorrTestsTest class for ProjDataInfoCylindricalArcCorr
    Cstir::ProjDataInfoCylindricalNoArcCorrTestsTest class for ProjDataInfoCylindricalNoArcCorr
  Cstir::ProjDataTestsTest class for ProjData and ProjDataInMemory
  Cstir::ProjMatrixByBinUsingInterpolationTestsTest class for ProjMatrixByBinUsingInterpolation
  Cstir::QuaternionTestsTest class for Quaternion
  Cstir::ROITestsTest class for compute_ROI_values and Shape3D hierarchy
  Cstir::RadionuclideTestClass with tests for stir::RadionuclideDB and stir::Radionuclide
  Cstir::ReconstructionTests< TargetT >Base class for simple test on reconstruction
   Cstir::PoissonLLReconstructionTests< TargetT >Base class for tests for iterative reconstruction that use PoissonLogLikelihoodWithLinearModelForMeanAndProjData
  Cstir::RigidObject3DTransformationTestsVarious tests on RigidObject3DTransformation
  Cstir::ScannerTestsTest class for Scanner
  Cstir::ScatterSimulationTestsTest class for ScatterSimulation
  Cstir::SeparableGaussianArrayFilterTestsTests SeparableGaussianArrayFilter functionality
  Cstir::SeparableMetzArrayFilterTestsTests SeparableMetzArrayFilter functionality
  Cstir::TOF_TestsTest class for Time Of Flight
  Cstir::TestBSplineTransformationTest class for Transformations
  Cstir::TestDataProcessorProjectorsTest class for GPU projectors
  Cstir::TestGPUProjectorsTest class for GPU projectors
  Cstir::TestProjDataInfoSubsetsTest class for subsets in ProjDataInfo
  Cstir::TestProjDataInfoSubsetsSPECTUBTest class for subsets in ProjDataInfo for SPECT data
  Cstir::VectorWithOffsetTestsTest class for VectorWithOffset
  Cstir::VoxelsOnCartesianGridTestsTest class for VoxelsOnCartesianGrid and image hierarchy
  Cstir::convert_array_TestsTests convert_array functionality
  Cstir::coordinateTestsClass with tests for BasicCoordinate, Coordinate3D et al
  Cstir::erfTestsA simple class to test the erf and erfc functions
  Cstir::find_fwhm_in_imageTestsA simple class to test the find_fwhm_in_image function
  Cstir::integrate_discrete_functionTestsA simple class to test the integrate_discrete_function function
  Cstir::linear_regressionTestsA simple class to test the linear_regression function
  Cstir::modellingTestsA simple class to test modelling functions
  Cstir::overlap_interpolateTestsTest class for stir::overlap_interpolate
  Cstir::stir_mathTestsTest class for the stir_math utility
  Cstir::warp_imageTestsClass with tests for warp_image functions
  Cstir::zoom_imageTestsTest class for zoom_image (and centre_of_gravity)
 Cstir::ecat::ecat6::ScanInfoRecECAT 6 CTI scanner parameters
 Cstir::ScannerA class for storing some info on the scanner
 Cstir::SegmentIndicesA very simple class to store segment numbers and any other indices that define a segment
  Cstir::SinogramIndicesA very simple class to store all dincies to get a (2D) Sinogram
  Cstir::ViewgramIndicesA very simple class to store all dincies to get a (2D) Viewgram
   Cstir::BinA class for storing coordinates and value of a single projection bin
    Cstir::ProjMatrixElemsForOneDenselValueStores voxel coordinates and the value of the matrix element
   Cstir::ViewSegmentNumbersAlias for ViewgramIndices
 Cboost::shared_ptr< T >A smart pointer class: multiple shared_ptr's refer to one object
 Cstir::shared_ptr< T >STL class
 CstringstreamSTL class
 Cstir::SucceededClass containing an enumeration type that can be used by functions to signal successful operation or not
 Cstir::SumOfGeneralisedObjectiveFunctions< ObjFuncT, TargetT, ParentT >
 Cstir::SymmetryOperationEncodes symmetry operation on image coordinates and projection data coordinates
  Cstir::TrivialSymmetryOperationA class implementing the trivial case where the symmetry operation does nothing at all
 Cstir::TimedBlock< TimerT=Timer >Helper class for measuring execution time of a block of code
 Cstir::TimedObjectBase class for all objects which need timers. At the moment, there's only a CPU timer
  Cstir::DataProcessor< DiscretisedDensity< 3, elemT > >
  Cstir::DataProcessor< DiscretisedDensity< 3, float > >
  Cstir::DataProcessor< stir::DiscretisedDensity< 3, float > >
  Cstir::DataProcessor< TargetT >
  Cstir::Reconstruction< DiscretisedDensity< 3, float > >
  Cstir::Reconstruction< stir::DiscretisedDensity< 3, float > >
  Cstir::BackProjectorByBinAbstract base class for all back projectors
  Cstir::ColsherFilterThis class contains the Colsher filter used for 3D-PET reconstruction
  Cstir::DataProcessor< DataT >Base class that defines an interface for classes that do data processing
  Cstir::DistributedWorker< TargetT >This implements the Worker for the stir::distributable_computation() function
  Cstir::Filter1D< T >Preliminary class for 1D filtering using FFTs
  Cstir::Filter2D< T >2-dimensional filters (filtering done by FFTs)
  Cstir::ForwardProjectorByBinAbstract base class for all forward projectors
  Cstir::ProjDataRebinningBase class for all rebinning algorithms for 3D PET data
  Cstir::ProjMatrixByBinThis is the (abstract) base class for all projection matrices which are organised by 'bin'
  Cstir::RampFilterThe ramp filter used for (2D) FBP
  Cstir::Reconstruction< TargetT >Base class for all ReconstructionsAs there is not a lot of commonality between different reconstruction algorithms, this base class is rather basic. It essentially takes care of constructing a target image, calls the virtual reconstruct() function, and writes the result to file
 Cstir::TimeFrameDefinitionsClass used for storing time frame durations
 Cstir::TimeGateDefinitionsClass used for storing time gate durations
 Cstir::TimerA general base class for timers. Interface is like a stop watch
  Cstir::CPUTimerA class for measuring elapsed CPU time
 Cstir::TypeForNumericType< numeric_type_enum >A helper class that specifies the C++ type for a particular NumericType
 Cstir::unique_ptr< T >STL class
 Cstir::Utah_phantomA class that represents a Utah phantom
 Cvector< T >STL class
 Cstir::VectorWithOffset< T >A templated class for vectors, but with indices starting not from 0
  Cstir::NumericVectorWithOffset< Array< num_dimensions - 1, elemT >, elemT >
   Cstir::Array< 2, elemT >
    Cstir::Sinogram< elemT >A class for 2d projection data
    Cstir::Viewgram< elemT >A class for 2d projection data
   Cstir::Array< 3, elemT >
    Cstir::SegmentBySinogram< elemT >A class for storing (3d) projection data with fixed SegmentIndices
    Cstir::SegmentByView< elemT >A class for storing (3d) projection data with fixed SegmentIndices
   Cstir::Array< 1, elemT >The 1-dimensional (partial) specialisation of Array
   Cstir::Array< num_dimensions, std::complex< elemT > >
   Cstir::Array< 3, stir::BasicCoordinate< 3, elemT > >
   Cstir::Array< 3, std::pair< stir::BasicCoordinate< 3, elemT >, elemT > >
   Cstir::Array< num_dimensions, elemT >This class defines multi-dimensional (numeric) arrays
    Cstir::DiscretisedDensity< 3, float >
    Cstir::DiscretisedDensity< 3, elemT >
    Cstir::DiscretisedDensity< 3, CartesianCoordinate3D< float > >
    Cstir::DiscretisedDensity< num_dimensions, float >
    Cstir::SegmentByView< elem_type >
    Cstir::DiscretisedDensity< num_dimensions, elemT >This abstract class is the basis for all image representations
  Cstir::NumericVectorWithOffset< Array< num_dimensions - 1, T >, T >
   Cstir::Array< 1, T >
  Cstir::NumericVectorWithOffset< T, elemT >Like VectorWithOffset, but with changes in various numeric operators
   Cstir::Array< 1, float >
   Cstir::Array< 2, float >
    Cstir::Viewgram< float >
   Cstir::Array< 3, float >
   Cstir::Array< 4, float >
   Cstir::iterator< 1, float >
   Cstir::const_iterator< 1, float >
   Cstir::full_iterator< 1, float >
   Cstir::const_full_iterator< 1, float >
 Cstir::VectorWithOffset< Array< num_dimensions - 1, int > >
  Cstir::NumericVectorWithOffset< Array< num_dimensions - 1, int >, int >
   Cstir::Array< 2, int >
   Cstir::Array< num_dimensions - 1, int >
 Cstir::VectorWithOffset< Array< num_dimensions - 1, out_elemT > >
  Cstir::NumericVectorWithOffset< Array< num_dimensions - 1, out_elemT >, out_elemT >
   Cstir::Array< num_dimensions, out_elemT >
   Cstir::Array< num_dimensions - 1, out_elemT >
 Cstir::VectorWithOffset< Array< num_dimensions - 1, std::complex< float > > >
  Cstir::NumericVectorWithOffset< Array< num_dimensions - 1, std::complex< float > >, std::complex< float > >
   Cstir::Array< 1, std::complex< float > >
   Cstir::Array< 2, std::complex< float > >
   Cstir::Array< 3, std::complex< float > >
   Cstir::Array< num_dimensions, std::complex< float > >
   Cstir::Array< num_dimensions - 1, std::complex< float > >
 Cstir::VectorWithOffset< Array< num_dimensions - 1, unsigned char > >
  Cstir::NumericVectorWithOffset< Array< num_dimensions - 1, unsigned char >, unsigned char >
   Cstir::Array< 3, unsigned char >
   Cstir::Array< num_dimensions - 1, unsigned char >
 Cstir::VectorWithOffset< elemT >
  Cstir::NumericVectorWithOffset< elemT, elemT >
   Cstir::Array< 1, elemT >The 1-dimensional (partial) specialisation of Array
 Cstir::VectorWithOffset< IndexRange< num_dimensions - 1 > >
  Cstir::IndexRange< 2 >
   Cstir::IndexRange2D'convenience' class for 2D index ranges
  Cstir::IndexRange< 3 >
   Cstir::IndexRange3D'convenience' class for 3D index ranges. Provides an easier constructor for regular ranges
  Cstir::IndexRange< 4 >
   Cstir::IndexRange4DA convenience class for 4D index ranges
  Cstir::IndexRange< 1 >The (simple) 1 dimensional specialisation of IndexRange
  Cstir::IndexRange< num_dimensions >This class defines ranges which can be 'irregular'
 Cstir::VerbosityThis class enables the user to control the on-screen output
 CSPECTUB::volume_typeStructure for bin information
 CSPECTUB::voxel_typeStructure for voxel information
 CSPECTUB::wm_da_typeWeight_mat_da structure definition. Structure for generating weight matrix
 CSPECTUB::wm_typeWeight_mat structure definition. Structure for reading weight matrix
 CSPECTUB::wmh_typeComplementary information (matrix header)
 Cstir::ZoomOptionsThis class enables the user to choose between different zooming options