paraview-dev 5.0.1+dfsg1-4 / usr / include / paraview / vtkFlashContour.h

This file is indexed.

/usr/include/paraview/vtkFlashContour.h is in paraview-dev 5.0.1+dfsg1-4.

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
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkFlashContour.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.

=========================================================================*/
// .NAME vtkFlashContour - Contour of a flash AMR volume.
// .SECTION Description
// This filter takes a cell data array and generates a polydata
// surface.  


#ifndef vtkFlashContour_h
#define vtkFlashContour_h

#include "vtkPVVTKExtensionsDefaultModule.h" //needed for exports
#include "vtkMultiBlockDataSetAlgorithm.h"

class vtkImageData;
class vtkPoints;
class vtkCellArray;
class vtkUnsignedCharArray;
class vtkPolyData;
class vtkDoubleArray;
class vtkIntArray;

class VTKPVVTKEXTENSIONSDEFAULT_EXPORT vtkFlashContour : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkFlashContour *New();
  vtkTypeMacro(vtkFlashContour,vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);

  vtkSetMacro(IsoValue, double);
  vtkGetMacro(IsoValue, double);

  vtkSetStringMacro(PassAttribute);
  vtkGetStringMacro(PassAttribute);

protected:
  vtkFlashContour();
  ~vtkFlashContour();

  double IsoValue;
  char* PassAttribute;
  vtkDoubleArray* PassArray;

  // Just for debugging.
  vtkIntArray *BlockIdCellArray;
  int CurrentBlockId;
  // A couple cell arrays to help determine where I should refine.
  vtkUnsignedCharArray *LevelCellArray;
  unsigned char CurrentLevel;
  // Instead of maximum depth, compute the different between the 
  // maximum depth and the current depth.
  vtkUnsignedCharArray *RemainingDepthCellArray;
  unsigned char RemainingDepth;
  unsigned char ComputeBranchDepth(int globalBlockId);

  vtkPoints *Points;
  vtkCellArray *Faces;
  vtkPolyData *Mesh;

  char* CellArrayNameToProcess;
  vtkSetStringMacro(CellArrayNameToProcess);

  //BTX
  virtual int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);
  virtual int FillInputPortInformation(int port, vtkInformation *info);
  virtual int FillOutputPortInformation(int port, vtkInformation *info);
  void PropogateNeighbors(int neighbors[3][3][3], int x, int y, int z);

  // Save some ivars to reduce arguments to recursive methods.
  int  NumberOfGlobalBlocks;
  int* GlobalLevelArray;
  int* GlobalChildrenArray;
  int* GlobalNeighborArray;
  int* GlobalToLocalMap;

  void RecurseTree(int neighborhood[3][3][3], vtkMultiBlockDataSet* input);
  void ProcessBlock(vtkImageData* block);
  void ProcessCell(const double *origin, const double *spacing, 
                   const double *cornerValues, const double *passValues);
  void ProcessNeighborhoodSharedRegion(
    int neighborhood[3][3][3], 
    int r[3], 
    vtkMultiBlockDataSet *input);
  void ProcessSharedRegion(
    int regionDims[3],
    double* cornerPtrs[8], int incs[3],
    double cornerPoints[32], double cornerSpacings[32], 
    int cornerLevelDiffs[8],
    double* passPtrs[8]);
  void ProcessDegenerateCell(
    double  cornerPoints[32], 
    double* cornerPtrs[8],
    double* passPtrs[8]);
  void ProcessCellFinal(
    const double cornerPoints[32], 
    const double cornerValues[8],
    int          cubeCase,
    const double passValues[8]);


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

#endif

APT Browse - Built by Thomas Orozco.