This file is indexed.

/usr/include/vtkNIFTIWriter.h is in libvtk-dicom-dev 0.7.10-1build1.

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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkNIFTIWriter.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/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 notice for more information.

=========================================================================*/
/*! \class vtkNIFTIWriter
 *  \brief Write NIfTI-1 and NIfTI-2 medical image files
 *
 *  This class writes NIFTI files, either in .nii format or as separate
 *  .img and .hdr files.  If told to write a file that ends in ".gz",
 *  then the writer will automatically compress the file with zlib.
 *  Images of type unsigned char that have 3 or 4 scalar components
 *  will automatically be written as RGB or RGBA respectively.  Images
 *  of type float or double that have 2 components will automatically be
 *  written as complex values.
 *
 *  This class was contributed to VTK by the Calgary Image Processing and
 *  Analysis Centre (CIPAC).
 *
 *  \sa vtkNIFTIReader
 */

#ifndef vtkNIFTIWriter_h
#define vtkNIFTIWriter_h

#include <vtkImageWriter.h>
#include "vtkDICOMModule.h" // For export macro

class vtkMatrix4x4;
class vtkNIFTIHeader;

class VTKDICOM_EXPORT vtkNIFTIWriter : public vtkImageWriter
{
public:
  //! Static method for construction.
  static vtkNIFTIWriter *New();
  vtkTypeMacro(vtkNIFTIWriter, vtkImageWriter);

  //! Print information about this object.
  virtual void PrintSelf(ostream& os, vtkIndent indent);

  //@{
  //! Set the version number for the NIfTI file format to use.
  /*!
   *  This can be 1, 2, or 0 (the default).  If set to zero, then it
   *  will save as NIfTI version 1 unless SetNIFTIHeader() provided
   *  header information from a NIfTI version 2 file.
   */
  vtkSetMacro(NIFTIVersion, int);
  vtkGetMacro(NIFTIVersion, int);
  //@}

  //@{
  //! Set a short description (max 80 chars) of how the file was produced.
  vtkSetStringMacro(Description);
  vtkGetStringMacro(Description);
  //@}

  //@{
  //! Set the time dimension to use in the NIFTI file (or zero if none).
  /*!
   *  The number of components of the input data must be divisible by the time
   *  dimension if the time dimension is not set to zero.  The vector dimension
   *  will be set to the number of components divided by the time dimension.
   */
  vtkGetMacro(TimeDimension, int);
  vtkSetMacro(TimeDimension, int);
  vtkGetMacro(TimeSpacing, double);
  vtkSetMacro(TimeSpacing, double);
  //@}

  //@{
  //! Set the slope and intercept for calibrating the scalar values.
  /*!
   *  Other programs that read the NIFTI file can use the equation
   *  v = u*RescaleSlope + RescaleIntercept to rescale the data to
   *  real values.  If both the slope and the intercept are zero,
   *  then the SclSlope and SclIntercept in the header info provided
   *  via SetNIFTIHeader() are used instead.
   */
  vtkSetMacro(RescaleSlope, double);
  vtkGetMacro(RescaleSlope, double);
  vtkSetMacro(RescaleIntercept, double);
  vtkGetMacro(RescaleIntercept, double);
  //@}

  //@{
  //! Write planar RGB (separate R, G, and B planes), rather than packed RGB.
  /*!
   *  Use this option with extreme caution: the NIFTI standard requires RGB
   *  pixels to be packed.  The Analyze format, however, was used to store
   *  both planar RGB and packed RGB depending on the software, without any
   *  indication in the header about which convention was being used.
   */
  vtkGetMacro(PlanarRGB, bool);
  vtkSetMacro(PlanarRGB, bool);
  vtkBooleanMacro(PlanarRGB, bool);
  //@}

  //@{
  //! The QFac sets the ordering of the slices in the NIFTI file.
  /*!
   *  If QFac is -1, then the slice ordering in the file will be reversed
   *  as compared to VTK. Use with caution.
   */
  vtkSetMacro(QFac, double);
  vtkGetMacro(QFac, double);
  //@}

  //@{
  //! Set the "qform" orientation and offset for the image data.
  /*!
   *  The 3x3 portion of the matrix must be orthonormal and have a
   *  positive determinant, it will be used to compute the quaternion.
   *  The last column of the matrix will be used for the offset.
   *  In the NIFTI header, the qform_code will be set to 1.
   */
  void SetQFormMatrix(vtkMatrix4x4 *);
  vtkMatrix4x4 *GetQFormMatrix() { return this->QFormMatrix; }
  //@}

  //@{
  //! Set a matrix for the "sform" transformation stored in the file.
  /*!
   *  Unlike the qform matrix, the sform matrix can contain scaling
   *  information.  Before being stored in the NIFTI header, the
   *  first three columns of the matrix will be multipled by the voxel
   *  spacing. In the NIFTI header, the sform_code will be set to 2.
   */
  void SetSFormMatrix(vtkMatrix4x4 *);
  vtkMatrix4x4 *GetSFormMatrix() { return this->SFormMatrix; }
  //@}

  //@{
  //! Set the NIFTI header information to use when writing the file.
  /*!
   *  The data dimensions and pixdim from the supplied header will be
   *  ignored.  Likewise, the QForm and SForm information in the supplied
   *  header will be ignored if you have called SetQFormMatrix() or
   *  SetSFormMatrix() to provide the orientation information for the file.
   */
  void SetNIFTIHeader(vtkNIFTIHeader *hdr);
  vtkNIFTIHeader *GetNIFTIHeader();
  //@}

protected:
  vtkNIFTIWriter();
  ~vtkNIFTIWriter();

  //! Generate the header information for the file.
  int GenerateHeader(vtkInformation *info, bool singleFile);

  //! The main execution method, which writes the file.
  virtual int RequestData(vtkInformation *request,
                          vtkInformationVector** inputVector,
                          vtkInformationVector* outputVector);

  //! Make a new filename by replacing extension "ext1" with "ext2".
  /*!
   *  The extensions must include a period, must be three characters
   *  long, and must be lower case.  A new string is returned that must
   *  be deleted by the caller.
   */
  static char *ReplaceExtension(
    const char *fname, const char *ext1, const char *ext2);

  //! Time dimension to use in the file.
  int TimeDimension;
  double TimeSpacing;

  //! Information for rescaling data to quantitative units.
  double RescaleIntercept;
  double RescaleSlope;

  //! Set to -1 when VTK slice order is opposite to NIFTI slice order.
  double QFac;

  //! The orientation matrices for the NIFTI file.
  vtkMatrix4x4 *QFormMatrix;
  vtkMatrix4x4 *SFormMatrix;

  //! A description of how the file was produced.
  char *Description;

  //! The header information.
  vtkNIFTIHeader *NIFTIHeader;
  vtkNIFTIHeader *OwnHeader;
  int NIFTIVersion;

  //! Use planar RGB instead of the default (packed).
  bool PlanarRGB;

private:
  vtkNIFTIWriter(const vtkNIFTIWriter&) VTK_DELETE_FUNCTION;
  void operator=(const vtkNIFTIWriter&) VTK_DELETE_FUNCTION;
};

#endif // vtkNIFTIWriter_h