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 (C) 2005-2020 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* 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
*
* 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 otbWrapperOutputImageParameter_h
#define otbWrapperOutputImageParameter_h
//#include "otbVectorImage.h"
#include "itkImageBase.h"
#include "otbWrapperParameter.h"
#include "otbImageFileWriter.h"
#include <string>
#include "otbMultiImageFileWriter.h"
namespace otb
{
namespace Wrapper
{
/** \class OutputImageParameter
* \brief This class represents a OutputImage parameter
*
* \ingroup OTBApplicationEngine
*/
class OTBApplicationEngine_EXPORT OutputImageParameter : public Parameter
{
public:
/** Standard class typedef */
typedef OutputImageParameter Self;
typedef Parameter Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
/** Defining ::New() static method */
itkNewMacro(Self);
/** RTTI support */
itkTypeMacro(OutputImageParameter, Parameter);
/** Set the value */
itkSetObjectMacro(Image, ImageBaseType);
/** Get the value */
itkGetObjectMacro(Image, ImageBaseType);
/** Return any value */
void SetValue(ImageBaseType* image);
/** Return any value */
ImageBaseType* GetValue(void);
/** Set/Get PixelType to be used when saving */
itkSetMacro(PixelType, ImagePixelType);
itkGetMacro(PixelType, ImagePixelType);
/** Set/Get DefaultPixelType */
itkSetMacro(DefaultPixelType, ImagePixelType);
itkGetMacro(DefaultPixelType, ImagePixelType);
/** Set/Get available RAM value */
itkSetMacro(RAMValue, unsigned int);
itkGetMacro(RAMValue, unsigned int);
/** Check if multi-writing is enabled (several output images written together)*/
bool IsMultiWritingEnabled();
/** Implement the reset method (replace pixel type by default type) */
void Reset() override
{
m_PixelType = m_DefaultPixelType;
}
/** Static method to convert pixel type into string */
static std::string ConvertPixelTypeToString(ImagePixelType type);
/** Converts a string into a pixel type (returns false if the conversion
* fails) */
static bool ConvertStringToPixelType(const std::string& value, ImagePixelType& type);
/** Return true if a filename is set */
bool HasValue() const override;
void SetFileName(const char* filename);
void SetFileName(const std::string& filename);
itkGetStringMacro(FileName);
void Write();
itk::ProcessObject* GetWriter();
/** Initialize internal writers, plus the multi-writer */
void InitializeWriters(otb::MultiImageFileWriter::Pointer multi = otb::MultiImageFileWriter::Pointer() );
std::string CheckFileName(bool fixMissingExtension = false);
ParameterType GetType() const override
{
return ParameterType_OutputImage;
}
std::string ToString() const override
{
return GetFileName();
}
void FromString(const std::string& value) override
{
SetFileName(value);
}
protected:
/** Constructor */
OutputImageParameter();
/** Destructor */
~OutputImageParameter() override;
private:
OutputImageParameter(const Parameter&) = delete;
void operator=(const Parameter&) = delete;
/** Switch TInputImage according to expected output type. */
template <typename TInputImage>
void SwitchInput(TInputImage*);
/** */
template <typename TOutputImage, typename TInputImage>
void ClampAndWriteVectorImage(TInputImage*);
// FloatVectorImageType::Pointer m_Image;
ImageBaseType::Pointer m_Image;
itk::ProcessObject::Pointer m_InputCaster;
itk::ProcessObject::Pointer m_OutputCaster;
itk::ProcessObject::Pointer m_Writer;
std::string m_FileName;
ImagePixelType m_PixelType;
ImagePixelType m_DefaultPixelType;
unsigned int m_RAMValue;
/** Multi-writer, used in case several OutputImageParameter are written at once */
otb::MultiImageFileWriter::Pointer m_MultiWriter;
}; // End class OutputImage Parameter
} // End namespace Wrapper
} // End namespace otb
#endif
|
