/usr/include/InsightToolkit/Common/itkValarrayImageContainer.h is in libinsighttoolkit3-dev 3.20.1-1.
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 | /*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: itkValarrayImageContainer.h
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef __itkValarrayImageContainer_h
#define __itkValarrayImageContainer_h
#include "itkObject.h"
#include "itkObjectFactory.h"
#include <utility>
#include <valarray>
namespace itk
{
/** \class ValarrayImageContainer
* Defines a front-end to the STL "valarray" container that conforms to the
* ImageContainerInterface. This is a full-fleged Object, so
* there is modification time, debug, and reference count information.
*
* Template parameters for ValarrayImageContainer:
*
* TElementIdentifier =
* An INTEGRAL type for use in indexing the valarray.
* It must have a < operator defined for ordering.
*
* TElement =
* The element type stored in the container.
*
* \ingroup ImageObjects
* \ingroup DataRepresentation
*/
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
|