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
160
161
162
163
164
165
166
167
168
|
/*=========================================================================
*
* 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 itkTemporalDataObject_h
#define itkTemporalDataObject_h
#include "itkDataObject.h"
#include "itkRingBuffer.h"
#include "itkTemporalRegion.h"
#include "ITKVideoCoreExport.h"
namespace itk
{
/** \class TemporalDataObjectEnums
* \brief Contains all enum classes used by TemporalUnit class.
* \ingroup ITKVideoCore
*/
class TemporalDataObjectEnums
{
public:
/**
* \class TemporalUnit
* \ingroup ITKVideoCore
* \brief For defining the way in which to compare temporal regions.
*/
enum class TemporalUnit : uint8_t
{
Frame,
RealTime,
FrameAndRealTime
};
};
// Define how to print enumeration
extern ITKVideoCore_EXPORT std::ostream &
operator<<(std::ostream & out, TemporalDataObjectEnums::TemporalUnit value);
/**
* \class TemporalDataObject
* \brief DataObject subclass with knowledge of temporal region
*
* This class represents a data object that relies on temporal regions. It uses
* an itk::RingBuffer to store DataObject pointers in sequential order. The
* pointers in the ring buffer should correspond to the BufferedTemporalRegion.
* The LargestPossibleTemporalRegion should indicate the maximum extent that
* data object is logically capable of holding, and the RequestedTemporalRegion
* is used in the pipeline to request that a certain temporal region be
* buffered
*
* \ingroup ITKVideoCore
*/
class ITK_FORCE_EXPORT_MACRO(ITKVideoCore) TemporalDataObject : public DataObject
{
public:
ITK_DISALLOW_COPY_AND_MOVE(TemporalDataObject);
/** Standard class type aliases */
using Self = TemporalDataObject;
using Superclass = DataObject;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
using ConstWeakPointer = WeakPointer<const Self>;
using BufferType = RingBuffer<DataObject>;
using TemporalRegionType = TemporalRegion;
using TemporalUnitEnum = TemporalDataObjectEnums::TemporalUnit;
using TemporalUnitType = TemporalUnitEnum;
#if !defined(ITK_LEGACY_REMOVE)
/**Exposes enums values for backwards compatibility*/
static constexpr TemporalUnitEnum Frame = TemporalUnitEnum::Frame;
static constexpr TemporalUnitEnum RealTime = TemporalUnitEnum::RealTime;
static constexpr TemporalUnitEnum FrameAndRealTime = TemporalUnitEnum::FrameAndRealTime;
#endif
itkNewMacro(Self);
/** \see LightObject::GetNameOfClass() */
itkOverrideGetNameOfClassMacro(TemporalDataObject);
/** Get the type of temporal units we care about (Defaults to Frame)*/
virtual TemporalUnitType
GetTemporalUnit() const;
/** Explicitly set temporal units (Defaults to Frame)*/
virtual void
SetTemporalUnitToFrame();
virtual void
SetTemporalUnitToRealTime();
virtual void
SetTemporalUnitToFrameAndRealTime();
/** Get/Set the number of frames that the internal buffer can hold */
SizeValueType
GetNumberOfBuffers();
void
SetNumberOfBuffers(SizeValueType num);
virtual void
SetLargestPossibleTemporalRegion(const TemporalRegionType & region);
virtual const TemporalRegionType &
GetLargestPossibleTemporalRegion() const;
virtual void
SetBufferedTemporalRegion(const TemporalRegionType & region);
virtual const TemporalRegionType &
GetBufferedTemporalRegion() const;
virtual void
SetRequestedTemporalRegion(const TemporalRegionType & region);
virtual const TemporalRegionType &
GetRequestedTemporalRegion() const;
/** Get the portion of the requested region that is not covered by the
* buffered region */
virtual const TemporalRegionType
GetUnbufferedRequestedTemporalRegion();
void
SetRequestedRegionToLargestPossibleRegion() override;
bool
RequestedRegionIsOutsideOfTheBufferedRegion() override;
bool
VerifyRequestedRegion() override;
void
CopyInformation(const DataObject *) override;
void
SetRequestedRegion(const DataObject *) override;
void
Graft(const DataObject *) override;
protected:
TemporalDataObject();
~TemporalDataObject() override;
void
PrintSelf(std::ostream & os, Indent indent) const override;
/** Buffer for holding component data objects */
BufferType::Pointer m_DataObjectBuffer{};
/** We want to keep track of our regions in time. **/
TemporalRegionType m_LargestPossibleTemporalRegion{};
TemporalRegionType m_RequestedTemporalRegion{};
TemporalRegionType m_BufferedTemporalRegion{};
TemporalUnitEnum m_TemporalUnit{ TemporalUnitEnum::Frame };
}; // end class TemporalDataObject
} // end namespace itk
#endif
|
