/usr/include/ITK-4.5/itkTransformIOBase.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 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 | /*=========================================================================
*
* 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 __itkTransformIOBase_h
#define __itkTransformIOBase_h
#include "itkLightProcessObject.h"
#include "itkTransformBase.h"
#include <list>
#include <iostream>
#include <fstream>
#include <string>
namespace itk
{
/** \class TransformIOBaseTemplate
*
* \brief Abstract superclass defining the Transform IO interface.
*
* TransformIOBaseTemplate is a pure virtual base class for derived classes that
* read/write transform data considering the type of input transform.
* First, TransformIOBase is derived from this class for legacy read/write transform.
* This class also is used by the TransformFileReader and TransformFileWriter
* classes. End users don't directly manipulate classes derived from TransformIOBaseTemplate;
* the TransformIOFactory is used by the Reader/Writer to pick a concrete derived class to do
* the actual reading/writing of transforms.
*
* \ingroup ITKIOTransformBase
*/
template<typename TScalar>
class TransformIOBaseTemplate:public LightProcessObject
{
public:
/** Standard class typedefs */
typedef TransformIOBaseTemplate Self;
typedef LightProcessObject Superclass;
typedef SmartPointer< Self > Pointer;
/** Run-time type information (and related methods). */
itkTypeMacro(TransformIOBaseTemplate, Superclass);
/** Transform types */
typedef TScalar ScalarType;
typedef TransformBaseTemplate<ScalarType> TransformType;
/** For writing, a const transform list gets passed in, for
* reading, a non-const transform list is created from the file.
*/
typedef typename TransformType::Pointer TransformPointer;
typedef std::list< TransformPointer > TransformListType;
typedef typename TransformType::ConstPointer ConstTransformPointer;
typedef std::list< ConstTransformPointer > ConstTransformListType;
/** Set/Get the name of the file to be read. */
itkSetStringMacro(FileName);
itkGetStringMacro(FileName);
/** Reads the data from disk into the memory buffer provided. */
virtual void Read() = 0;
/** Writes the transform list to disk. */
virtual void Write() = 0;
/** Determine the file type. Returns true if this TransformIO can read the
* file specified. */
virtual bool CanReadFile(const char *) = 0;
/** Determine the file type. Returns true if this TransformIO can read the
* file specified. */
virtual bool CanWriteFile(const char *) = 0;
/** Get the list of transforms resulting from a file read */
TransformListType & GetTransformList() { return m_ReadTransformList; }
TransformListType & GetReadTransformList() { return m_ReadTransformList; }
ConstTransformListType & GetWriteTransformList() { return m_WriteTransformList; }
/** Set the list of transforms before writing */
void SetTransformList(ConstTransformListType & transformList);
/** Set the writer to append to the specified file */
itkSetMacro(AppendMode, bool);
itkGetConstMacro(AppendMode, bool);
itkBooleanMacro(AppendMode);
/** The transform type has a string representation used when reading
* and writing transform files. In the case where a double-precision
* transform is to be written as float, or vice versa, the transform
* type name used to write the file needs to patched in order for the
* transform I/O hierachy to work correctly. These template functions
* will be chosen at compile time within template classes in order to
* patch up the type name.
* */
static inline void CorrectTransformPrecisionType( std::string & itkNotUsed(inputTransformName) )
{
itkGenericExceptionMacro(<< "Unknown ScalarType" << typeid(ScalarType).name());
}
protected:
TransformIOBaseTemplate();
virtual ~TransformIOBaseTemplate();
void PrintSelf(std::ostream & os, Indent indent) const;
void OpenStream(std::ofstream & outputStream, bool binary);
void CreateTransform(TransformPointer & ptr, const std::string & ClassName);
std::string m_FileName;
TransformListType m_ReadTransformList;
ConstTransformListType m_WriteTransformList;
bool m_AppendMode;
/* The following struct returns the string name of computation type */
/* default implementation */
static inline const std::string GetTypeNameString()
{
itkGenericExceptionMacro(<< "Unknown ScalarType" << typeid(ScalarType).name());
}
};
template <>
inline void
TransformIOBaseTemplate<float>
::CorrectTransformPrecisionType( std::string & inputTransformName )
{
// output precision type is not found in input transform.
if(inputTransformName.find("float") == std::string::npos)
{
const std::string::size_type begin = inputTransformName.find("double");
inputTransformName.replace(begin, 6, "float");
}
}
template <>
inline void
TransformIOBaseTemplate<double>
::CorrectTransformPrecisionType( std::string & inputTransformName )
{
// output precision type is not found in input transform.
if(inputTransformName.find("double") == std::string::npos)
{
const std::string::size_type begin = inputTransformName.find("float");
inputTransformName.replace(begin, 5, "double");
}
}
template <>
inline const std::string
TransformIOBaseTemplate<float>
::GetTypeNameString()
{
return std::string("float");
}
template <>
inline const std::string
TransformIOBaseTemplate<double>
::GetTypeNameString()
{
return std::string("double");
}
/** This helps to meet backward compatibility */
typedef itk::TransformIOBaseTemplate<double> TransformIOBase;
} // end namespace itk
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTransformIOBase.hxx"
#endif
#endif // __itkTransformIOBase.h
|