/usr/include/ITK-4.5/itkVideoFileWriter.h is in libinsighttoolkit4-dev 4.5.0-3.
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 155 156 157 158 | /*=========================================================================
*
* 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 __itkVideoFileWriter_h
#define __itkVideoFileWriter_h
#include "itkTemporalProcessObject.h"
#include "itkVideoIOFactory.h"
namespace itk
{
/** \class VideoFileWriter
* \brief Writer that takes in a VideoStream and writes the frames to a file
*
* This class is a subclass of TemporalProcessObject which specifically takes a
* single VideoStream as input and writes the frames out to a file in sequence.
* A call to Update() will write the entire requested temporal region to the
* file. If no temporal region is requested, the largest possible will be used.
*
* \ingroup ITKVideoIO
*/
template< typename TInputVideoStream >
class VideoFileWriter : public TemporalProcessObject
{
public:
/**-TYPEDEFS---------------------------------------------------------------*/
typedef VideoFileWriter< TInputVideoStream> Self;
typedef TemporalProcessObject Superclass;
typedef SmartPointer<Self> Pointer;
typedef VideoIOBase IOBaseType;
typedef typename VideoIOBase::Pointer IOBasePointer;
typedef typename IOBaseType::SizeValueType SizeValueType;
typedef typename IOBaseType::TemporalRatioType TemporalRatioType;
typedef TInputVideoStream VideoStreamType;
typedef typename VideoStreamType::Pointer VideoStreamPointer;
typedef typename VideoStreamType::FrameType FrameType;
typedef typename FrameType::PixelType PixelType;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(VideoFileWriter, TemporalProcessObject);
/**-PUBLIC METHODS---------------------------------------------------------*/
/** Specify the file to read. This is forwarded to the IO instance. */
itkSetStringMacro(FileName);
itkGetStringMacro(FileName);
/** Specify the output FpS */
itkSetMacro(FramesPerSecond, TemporalRatioType);
itkGetMacro(FramesPerSecond, TemporalRatioType);
/** Specify the FourCC to use for video encoding. FourCC, or four character
* code, is commonly used to denote the codec to be used to encode video by
* many libraries. See http://en.wikipedia.org/wiki/FourCC for more
* information. */
itkSetStringMacro(FourCC);
itkGetStringMacro(FourCC);
/** Get/Set the OutputTemporalRegion */
itkSetMacro(OutputTemporalRegion, TemporalRegion);
itkGetMacro(OutputTemporalRegion, TemporalRegion);
/** Set/Get the input video pointer */
using Superclass::SetInput;
void SetInput( const VideoStreamType* input );
const VideoStreamType* GetInput();
/** Manually set the VideoIO to use */
void SetVideoIO( IOBasePointer videoIO );
/** Write the requested temporal region to a file. If no OutputTemporalRegion
* has been set, the largest possible temporal region of the input will be
* used. */
void Write();
/** Finish writing the video and close the file */
void FinishWriting();
/** Aliased to the Write() method to be consistent with the rest of the
* pipeline. */
virtual void Update();
/** Write the entire video to a file, if possible. This is the same as
* calling write or update without setting an output temporal region. */
virtual void UpdateLargestPossibleRegion();
protected:
/**-PROTECTED METHODS------------------------------------------------------*/
VideoFileWriter();
virtual ~VideoFileWriter();
void PrintSelf(std::ostream &os, Indent indent) const;
/** Initialize output parameters */
bool InitializeOutputParameters();
/** Set up the VideoIO using VideoIOFactory. Returns true if successful, false
* otherwise.
* Warning: this will overwrite any currently set VideoIO */
bool InitializeVideoIO();
/** Override TemporalStreamingGenerateData to do the actual writing. */
virtual void TemporalStreamingGenerateData();
/**-PROTECTED MEMBERS------------------------------------------------------*/
/** The file to read */
std::string m_FileName;
/** The VideoIO used for writing */
IOBasePointer m_VideoIO;
/** TemporalRegion to write out */
TemporalRegion m_OutputTemporalRegion;
/** Parameters for writing */
TemporalRatioType m_FramesPerSecond;
std::string m_FourCC;
std::vector<SizeValueType> m_Dimensions;
SizeValueType m_NumberOfComponents;
ImageIOBase::IOComponentType m_ComponentType;
private:
VideoFileWriter(const Self &); // purposely not implemented
void operator=(const Self &); // purposely not implemented
};
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVideoFileWriter.hxx"
#endif
#endif
|