This file is indexed.

/usr/include/ITK-4.9/itkVideoFileReader.h is in libinsighttoolkit4-dev 4.9.0-4ubuntu1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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
 *
 *         http://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 itkVideoFileReader_h
#define itkVideoFileReader_h

#include "itkVideoSource.h"
#include "itkVideoIOFactory.h"
#include "itkDefaultConvertPixelTraits.h"

namespace itk
{

/** \class VideoFileReader
 * \brief Reader that creates a VideoStream
 *
 * This class is responsible for reading video information from files. It is a
 * subclass of VideoSource, giving it functionality to connect to other
 * TemporalProcessObject classes (specifically, VideoToVideoFilter classes). It
 * uses the temporal streaming implementation provided by TemporalProcessObject
 * to load a single frame at a time into the frame buffer of the output
 * VideoSource.
 *
 * \ingroup ITKVideoIO
 */
template< typename TOutputVideoStream >
class VideoFileReader : public VideoSource< TOutputVideoStream >
{
public:

  /**-TYPEDEFS---------------------------------------------------------------*/
  typedef VideoFileReader                          Self;
  typedef VideoSource< TOutputVideoStream >        Superclass;
  typedef SmartPointer<Self>                       Pointer;
  typedef TOutputVideoStream                       VideoStreamType;
  typedef typename VideoStreamType::Pointer        VideoStreamPointer;

  typedef typename VideoStreamType::FrameType      FrameType;
  typedef typename FrameType::PixelType            PixelType;
  typedef typename FrameType::RegionType           RegionType;
  typedef typename FrameType::SizeType             SizeType;
  typedef typename FrameType::IndexType            IndexType;
  typedef typename FrameType::PointType            PointType;
  typedef typename FrameType::SpacingType          SpacingType;
  typedef typename FrameType::DirectionType        DirectionType;

  typedef typename VideoIOBase::TemporalOffsetType TemporalOffsetType;
  typedef typename VideoIOBase::FrameOffsetType    FrameOffsetType;
  typedef typename VideoIOBase::TemporalRatioType  TemporalRatioType;

  itkStaticConstMacro(FrameDimension,unsigned int,FrameType::ImageDimension);

  /** Pixel conversion typedefs */
  typedef DefaultConvertPixelTraits<PixelType> ConvertPixelTraits;

  /** Method for creation through the object factory. */
  itkNewMacro(Self);

  /** Run-time type information (and related methods). */
  itkTypeMacro(VideoFileReader, VideoSource);

  /**-PUBLIC METHODS---------------------------------------------------------*/

  /** Specify the file to read. This is forwarded to the IO instance. */
  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);

  /** Get/Set IFrameSafe. If true, the last IFrame will be reported as the last
   * frame for the largest possible temporal region */
  itkSetMacro(IFrameSafe, bool);
  itkGetMacro(IFrameSafe, bool);

  /** Set up the output information */
  virtual void UpdateOutputInformation() ITK_OVERRIDE;

  /** Set the internal VideoIOBase pointer. This will generally be called by
   * the object that creates the RingBuffer (e.g. itk::VideoFileReader) */
  void SetVideoIO(VideoIOBase* videoIO);

  /** Get the current position as frame, ratio, or MSec */
  FrameOffsetType GetCurrentPositionFrame();

  TemporalRatioType GetCurrentPositionRatio();

  TemporalOffsetType GetCurrentPositionMSec();

  /** Get number of frames */
  FrameOffsetType GetNumberOfFrames();

  /** Get framerate */
  TemporalRatioType GetFramesPerSecond();

protected:

  /**-PROTECTED METHODS------------------------------------------------------*/
  VideoFileReader();
  virtual ~VideoFileReader();
  void PrintSelf(std::ostream & os, Indent indent) const ITK_OVERRIDE;

  /** Override TemporalStreamingGenerateData to generate output a single frame.
   * We don't override ThreadedGenerateData because we read whole frames one at
   * a time. As such, we have to handle the allocation of the frames here. */
  virtual void TemporalStreamingGenerateData() ITK_OVERRIDE;

  /** Convert buffer for output */
  void DoConvertBuffer(void* inputData, FrameOffsetType frameNumber);

  /** Set up the VideoIO using VideoIOFactory
   * Warning: this will overwrite any currently set VideoIO */
  void InitializeVideoIO();

  /**-PROTECTED MEMBERS------------------------------------------------------*/

  /** The file to read */
  std::string m_FileName;

  /** VideoIOBase used to retrieve images. This may be changed if more
   * hierarchy is added to support general ImageSet sources */
  VideoIOBase::Pointer m_VideoIO;

  /** Flag to store whether or not the pixel type needs to be converted */
  bool m_PixelConversionNeeded;

  /** Flag to indicate whether to report the last frame as the last IFrame. On
   * by default */
  bool m_IFrameSafe;

private:
  VideoFileReader(const Self &) ITK_DELETE_FUNCTION;
  void operator=(const Self &) ITK_DELETE_FUNCTION;

};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVideoFileReader.hxx"
#endif

#endif