libvtkedge-dev 0.2.0~20110819-1build2 / usr / include / VTKEdge / vtkKWEDataArrayStreamer.h

This file is indexed.

/usr/include/VTKEdge/vtkKWEDataArrayStreamer.h is in libvtkedge-dev 0.2.0~20110819-1build2.

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
//=============================================================================
//   This file is part of VTKEdge. See vtkedge.org for more information.
//
//   Copyright (c) 2010 Kitware, Inc.
//
//   VTKEdge may be used under the terms of the BSD License
//   Please see the file Copyright.txt in the root directory of
//   VTKEdge for further information.
//
//   Alternatively, you may see: 
//
//   http://www.vtkedge.org/vtkedge/project/license.html
//
//
//   For custom extensions, consulting services, or training for
//   this or any other Kitware supported open source project, please
//   contact Kitware at sales@kitware.com.
//
//
//=============================================================================
// .NAME vtkKWEDataArrayStreamer
// .SECTION Description
// Compute 2D texture image extent to transfer any data array as 2D image
// chunks to GPU memory. It is also used to transfer back 2D texture chunk
// as part of a data array.
// .SECTION See Also
// Used by the vtkKWEGPUArrayCalculator.

#ifndef __vtkKWEDataArrayStreamer_h
#define __vtkKWEDataArrayStreamer_h

#include "vtkObject.h"
#include "VTKEdgeConfigure.h" // include configuration header

class VTKEdge_COMMON_EXPORT vtkKWEDataArrayStreamer : public vtkObject
{
 public:
  static vtkKWEDataArrayStreamer *New();
  vtkTypeRevisionMacro(vtkKWEDataArrayStreamer,vtkObject);
  void PrintSelf(ostream &os,vtkIndent indent);

  // Description:
  // Data array to split. Initial value is 0.
  vtkSetMacro(NumberOfTuples, vtkIdType);
  vtkGetMacro(NumberOfTuples, vtkIdType);

  // Description:
  // Maximum size of any dimension of a 3D texture. Initial value is 16,
  // the minimal value of the OpenGL specifications.
  vtkSetMacro(Max3DTextureSize,int);
  vtkGetMacro(Max3DTextureSize,int);

  // Description:
  // Maximum size of any dimension of a 1D or 2D texture. Initial value is 64,
  // the minimal value of the OpenGL specifications.
  vtkSetMacro(MaxTextureSize,int);
  vtkGetMacro(MaxTextureSize,int);

  // Description:
  // User-defined maximum size in bytes of a texture in GPU memory.
  // Initial value is 134217728 bytes (128*2^20=128Mb).
  // In a 32-bit build, this ivar can encode up to 4GB.
  // A null value means no limit.
  vtkSetMacro(MaxTextureMemorySizeInBytes,vtkIdType);
  vtkGetMacro(MaxTextureMemorySizeInBytes,vtkIdType);

  // Description:
  // Size of a tuple in bytes (number of components*size of type).
  // If the streamer is used by several dataarray at the same time,
  // the user should set its value to the maximum tuple size.
  // Initial value is 1.
  vtkSetMacro(TupleSize,int);
  vtkGetMacro(TupleSize,int);

  // Description:
  // User-defined maximum number of tuples per block. If 0, this value is
  // ignored. Initial value is 0.
  vtkSetMacro(MaxNumberOfTuplesPerBlock,vtkIdType);
  vtkGetMacro(MaxNumberOfTuplesPerBlock,vtkIdType);

  // Description:
  // Place the cursor on the first chunk, if any.
  void Begin();

  // Description:
  // Is the iteration over?
  bool IsDone();

  // Description:
  // Go the next chunk, if any.
  // \pre not_done: !IsDone()
  void Next();

  // Description:
  // Number of colums and number of rows of the current image chunk.
  // \pre  not_done: !IsDone()
  vtkGetVector2Macro(ChunkDimensions,vtkIdType);

  // Description:
  // Current starting tuple position in the data array.
  // \pre  not_done: !IsDone()
  vtkGetMacro(Cursor,vtkIdType);

//BTX
protected:
  vtkKWEDataArrayStreamer();
  ~vtkKWEDataArrayStreamer();

  void UpdateChunkDimensions();

  vtkIdType NumberOfTuples;

  int Max3DTextureSize;
  int MaxTextureSize;
  vtkIdType MaxTextureMemorySizeInBytes;
  int TupleSize;
  vtkIdType MaxNumberOfTuplesPerBlock;

  vtkIdType ChunkDimensions[2];
  vtkIdType Cursor;
  vtkIdType Step;

  vtkIdType Stage2Cursor;
  vtkIdType Stage2Step;
  vtkIdType Stage3Cursor;
  vtkIdType Stage3Step;
  vtkIdType Stage2NumberOfRows;

private:
  vtkKWEDataArrayStreamer(const vtkKWEDataArrayStreamer&); // Not implemented.
  void operator=(const vtkKWEDataArrayStreamer&); // Not implemented.
//ETX
};

#endif

APT Browse - Built by Thomas Orozco.