itkVideoStream.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkVideoStream_h
#define itkVideoStream_h
 
#include "itkTemporalDataObject.h"
#include "itkImage.h"
 
namespace itk
{

template <typename TFrameType>
class ITK_TEMPLATE_EXPORT VideoStream : public TemporalDataObject
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(VideoStream);

  using Self = VideoStream;
  using Superclass = TemporalDataObject;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  using ConstWeakPointer = WeakPointer<const Self>;
 
  using FrameType = TFrameType;
  using FramePointer = typename FrameType::Pointer;
  using FrameConstPointer = typename FrameType::ConstPointer;
  using typename Superclass::BufferType;
 
  using SpatialRegionType = typename FrameType::RegionType;
  using IndexType = typename FrameType::IndexType;
  using PixelType = typename FrameType::PixelType;
  using PointType = typename FrameType::PointType;
  using SpacingType = typename FrameType::SpacingType;
  using SizeType = typename FrameType::SizeType;
  using DirectionType = typename FrameType::DirectionType;
  using NumberOfComponentsPerPixelType = unsigned int;

  using SpatialRegionMapType = typename std::map<SizeValueType, SpatialRegionType>;
  using PointMapType = typename std::map<SizeValueType, PointType>;
  using DirectionMapType = typename std::map<SizeValueType, DirectionType>;
  using SpacingMapType = typename std::map<SizeValueType, SpacingType>;
  using NumberOfComponentsPerPixelMapType = typename std::map<SizeValueType, NumberOfComponentsPerPixelType>;

  static constexpr unsigned int FrameDimension = FrameType::ImageDimension;
  static unsigned int
  GetFrameDimension()
  {
    return FrameType::ImageDimension;
  }
 
  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(VideoStream);

  void
  SetMinimumBufferSize(SizeValueType minimumNumberOfFrames);

  void
  InitializeEmptyFrames();

  BufferType *
  GetFrameBuffer()
  {
    return reinterpret_cast<BufferType *>(m_DataObjectBuffer.GetPointer());
  }
  const BufferType *
  GetFrameBuffer() const
  {
    return reinterpret_cast<BufferType *>(m_DataObjectBuffer.GetPointer());
  }


  void
  SetFrameBuffer(BufferType * buffer);

  const SpatialRegionMapType &
  GetLargestPossibleSpatialRegionCache() const
  {
    return m_LargestPossibleSpatialRegionCache;
  }
  void
  SetLargestPossibleSpatialRegionCache(SpatialRegionMapType map)
  {
    m_LargestPossibleSpatialRegionCache = map;
  }

 
  const SpatialRegionMapType &
  GetRequestedSpatialRegionCache() const
  {
    return m_RequestedSpatialRegionCache;
  }
  void
  SetRequestedSpatialRegionCache(SpatialRegionMapType map)
  {
    m_RequestedSpatialRegionCache = map;
  }
 
  const SpatialRegionMapType &
  GetBufferedSpatialRegionCache() const
  {
    return m_BufferedSpatialRegionCache;
  }
  void
  SetBufferedSpatialRegionCache(SpatialRegionMapType map)
  {
    m_BufferedSpatialRegionCache = map;
  }
 
  const SpacingMapType &
  GetSpacingCache() const
  {
    return m_SpacingCache;
  }
  void
  SetSpacingCache(SpacingMapType map)
  {
    m_SpacingCache = map;
  }
 
  const PointMapType &
  GetOriginCache() const
  {
    return m_OriginCache;
  }
  void
  SetOriginCache(PointMapType map)
  {
    m_OriginCache = map;
  }
 
  const DirectionMapType &
  GetDirectionCache() const
  {
    return m_DirectionCache;
  }
  void
  SetDirectionCache(DirectionMapType map)
  {
    m_DirectionCache = map;
  }
 
  const NumberOfComponentsPerPixelMapType &
  GetNumberOfComponentsPerPixelCache() const
  {
    return m_NumberOfComponentsPerPixelCache;
  }
  void
  GetNumberOfComponentsPerPixelCache(NumberOfComponentsPerPixelMapType map)
  {
    m_NumberOfComponentsPerPixelCache = map;
  }

  void
  SetFrame(SizeValueType frameNumber, FramePointer frame);

  FrameType *
  GetFrame(SizeValueType frameNumber);
  const FrameType *
  GetFrame(SizeValueType frameNumber) const;

  void
  SetFrameLargestPossibleSpatialRegion(SizeValueType frameNumber, SpatialRegionType region);
 
  const SpatialRegionType &
  GetFrameLargestPossibleSpatialRegion(SizeValueType frameNumber) const;

  void
  SetFrameRequestedSpatialRegion(SizeValueType frameNumber, SpatialRegionType region);
 
  const SpatialRegionType &
  GetFrameRequestedSpatialRegion(SizeValueType frameNumber) const;

  void
  SetFrameBufferedSpatialRegion(SizeValueType frameNumber, SpatialRegionType region);
 
  const SpatialRegionType &
  GetFrameBufferedSpatialRegion(SizeValueType frameNumber) const;

  void
  SetFrameSpacing(SizeValueType frameNumber, SpacingType spacing);
 
  const SpacingType &
  GetFrameSpacing(SizeValueType frameNumber) const;

  void
  SetFrameOrigin(SizeValueType frameNumber, PointType origin);
 
  const PointType &
  GetFrameOrigin(SizeValueType frameNumber) const;

  void
  SetFrameDirection(SizeValueType frameNumber, DirectionType direction);
 
  const DirectionType &
  GetFrameDirection(SizeValueType frameNumber) const;

  void
  SetFrameNumberOfComponentsPerPixel(SizeValueType frameNumber, unsigned int n);
 
  const NumberOfComponentsPerPixelType &
  GetFrameNumberOfComponentsPerPixel(SizeValueType frameNumber) const;

  void
  SetAllLargestPossibleSpatialRegions(SpatialRegionType region);

  void
  SetAllRequestedSpatialRegions(SpatialRegionType region);

  void
  SetAllBufferedSpatialRegions(SpatialRegionType region);

  void
  SetAllFramesSpacing(SpacingType spacing);

  void
  SetAllFramesOrigin(PointType origin);

  void
  SetAllFramesDirection(DirectionType direction);

  void
  SetAllFramesNumberOfComponentsPerPixel(NumberOfComponentsPerPixelType n);

 
        // Initialize all frames in the buffered temporal region
        video->InitializeEmptyFrames();
 
        // Set the buffered spatial region for each frame
        SpatialRegionType bufferedSpatialRegion;
        SpatialRegionType::SizeType size;
        SpatialRegionType::IndexType start;
        size[0] = 50;
        size[1] = 40;
        start.Fill( 0 );
        bufferedSpatialRegion.SetSize( size );
        bufferedSpatialRegion.SetIndex( start );
        video->SetAllBufferedSpatialRegions( bufferedSpatialRegion );
 
        // Allocate memory for the frames
        video->Allocate();
     \endcode
   */
  void
  Allocate();

  void
  Graft(const DataObject * data) override;
 
protected:
  VideoStream() = default;
  ~VideoStream() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override
  {
    Superclass::Print(os, indent);
  }

  SpatialRegionMapType m_LargestPossibleSpatialRegionCache{};
  SpatialRegionMapType m_RequestedSpatialRegionCache{};
  SpatialRegionMapType m_BufferedSpatialRegionCache{};

  SpacingMapType                    m_SpacingCache{};
  DirectionMapType                  m_DirectionCache{};
  PointMapType                      m_OriginCache{};
  NumberOfComponentsPerPixelMapType m_NumberOfComponentsPerPixelCache{};
 
}; // end class VideoStream
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkVideoStream.hxx"
#endif
 
#endif