/usr/include/ITK-4.5/itkValarrayImageContainer.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 | /*=========================================================================
*
* 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 __itkValarrayImageContainer_h
#define __itkValarrayImageContainer_h
#include "itkObject.h"
#include "itkObjectFactory.h"
#include <utility>
#include <valarray>
namespace itk
{
/** \class ValarrayImageContainer
* \brief Defines a front-end to the std\\::\<valarray\> container that conforms to the
* ImageContainerInterface.
*
* This is a full-fleged Object, so
* there is modification time, debug, and reference count information.
*
* \tparam TElementIdentifier
* An INTEGRAL type for use in indexing the valarray.
* It must have a \< operator defined for ordering.
*
* \tparam TElement
* The element type stored in the container.
*
* \ingroup ImageObjects
* \ingroup DataRepresentation
* \ingroup ITKCommon
*/
template<
typename TElementIdentifier,
typename TElement
>
class ValarrayImageContainer:
public Object,
private std::valarray< TElement >
{
public:
/** Standard class typedefs. */
typedef ValarrayImageContainer Self;
typedef Object Superclass;
typedef SmartPointer< Self > Pointer;
typedef SmartPointer< const Self > ConstPointer;
/** Save the template parameters. */
typedef TElementIdentifier ElementIdentifier;
typedef TElement Element;
private:
/** Quick access to the STL valarray type that was inherited. */
typedef std::valarray< Element > ValarrayType;
protected:
/** Provide pass-through constructors corresponding to all the STL
* valarray constructors. These are for internal use only since
* this is also an Object which must be constructed through the
* "New()" routine. */
ValarrayImageContainer():
ValarrayType() {}
ValarrayImageContainer(unsigned long n):
ValarrayType(n) {}
ValarrayImageContainer(unsigned long n, const Element & x):
ValarrayType(n, x) {}
ValarrayImageContainer(const Self & r):
ValarrayType(r) {}
public:
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Standard part of every itk Object. */
itkTypeMacro(ValarrayImageContainer, Object);
/** Index operator. This version can be an lvalue. */
TElement & operator[](const ElementIdentifier id)
{ return this->ValarrayType::operator[](id); }
/** Index operator. This version can only be an rvalue */
const TElement & operator[](const ElementIdentifier id) const
{ return this->ValarrayType::operator[](id); }
/** Return a pointer to the beginning of the buffer. This is used by
* the image iterator class. */
TElement * GetBufferPointer()
{
if ( this->Size() > 0 )
{
return & ( this->ValarrayType::operator[](0) );
}
else
{
return NULL;
}
}
/** Get the number of elements currently stored in the container. */
unsigned long Size(void) const
{ return static_cast< unsigned long >( this->ValarrayType::size() ); }
/** Tell the container to allocate enough memory to allow at least
* as many elements as the size given to be stored. This is NOT
* guaranteed to actually allocate any memory, but is useful if the
* implementation of the container allocates contiguous storage. */
void Reserve(ElementIdentifier num)
{ this->ValarrayType::resize(num); }
/** Tell the container to try to minimize its memory usage for storage of
* the current number of elements. This is NOT guaranteed to decrease
* memory usage. */
void Squeeze(void)
{ this->ValarrayType::resize( this->ValarrayType::size() ); }
/** Tell the container to release any of its allocated memory. */
void Initialize(void)
{ this->ValarrayType::resize(0); }
/** Tell the container to release any of its allocated memory. */
void Fill(const TElement & value)
{ this->ValarrayType::operator=(value); }
public:
/** PrintSelf routine. Normally this is a protected internal method. It is
* made public here so that Image can call this method. Users should not
* call this method but should call Print() instead. */
virtual void PrintSelf(std::ostream & os, Indent indent) const
{
Object::PrintSelf(os, indent);
// Print out the pointer to bulk data memory. We use const_cast<> to
// cast away the constness so we can call GetBufferPointer()
os << indent << "Pointer: "
<< const_cast< ValarrayImageContainer * >( this )->GetBufferPointer()
<< std::endl;
os << indent << "Size: " << this->Size() << std::endl;
}
};
} // end namespace itk
#endif
|