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
155
156
157
158
159
|
/*=========================================================================
*
* 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 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 ITK_TEMPLATE_EXPORT VideoFileReader : public VideoSource<TOutputVideoStream>
{
public:
ITK_DISALLOW_COPY_AND_MOVE(VideoFileReader);
/** Standard class type aliases. */
using Self = VideoFileReader;
using Superclass = VideoSource<TOutputVideoStream>;
using Pointer = SmartPointer<Self>;
using VideoStreamType = TOutputVideoStream;
using VideoStreamPointer = typename VideoStreamType::Pointer;
using FrameType = typename VideoStreamType::FrameType;
using PixelType = typename FrameType::PixelType;
using RegionType = typename FrameType::RegionType;
using SizeType = typename FrameType::SizeType;
using IndexType = typename FrameType::IndexType;
using PointType = typename FrameType::PointType;
using SpacingType = typename FrameType::SpacingType;
using DirectionType = typename FrameType::DirectionType;
using TemporalOffsetType = typename VideoIOBase::TemporalOffsetType;
using FrameOffsetType = typename VideoIOBase::FrameOffsetType;
using TemporalRatioType = typename VideoIOBase::TemporalRatioType;
static constexpr unsigned int FrameDimension = FrameType::ImageDimension;
/** Pixel conversion type alias */
using ConvertPixelTraits = DefaultConvertPixelTraits<PixelType>;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(VideoFileReader);
/** 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);
itkBooleanMacro(IFrameSafe);
/** Set up the output information */
void
UpdateOutputInformation() 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:
VideoFileReader();
~VideoFileReader() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const 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. */
void
TemporalStreamingGenerateData() override;
/** Convert buffer for output */
void
DoConvertBuffer(const void * inputData, FrameOffsetType frameNumber);
/** Set up the VideoIO using VideoIOFactory
* Warning: this will overwrite any currently set VideoIO */
void
InitializeVideoIO();
private:
/** 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{};
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
# include "itkVideoFileReader.hxx"
#endif
#endif
|
