vtkExtractCTHPart.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkExtractCTHPart.h,v $

  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.

=========================================================================*/
#ifndef __vtkExtractCTHPart_h
#define __vtkExtractCTHPart_h

#include "vtkPolyDataAlgorithm.h"
class vtkPlane;
class vtkDataArray;
class vtkDoubleArray;
class vtkRectilinearGrid;

class vtkExtractCTHPartInternal;
class vtkHierarchicalDataSet;
class vtkPolyData;
class vtkUniformGrid;
class vtkImageData;
class vtkDataSet;

class vtkContourFilter;
class vtkAppendPolyData;
class vtkDataSetSurfaceFilter;
class vtkClipPolyData;
class vtkCutter;

class vtkMultiProcessController;

//#define EXTRACT_USE_IMAGE_DATA 1

class VTK_PARALLEL_EXPORT vtkExtractCTHPart : public vtkPolyDataAlgorithm
{
public:
  vtkTypeRevisionMacro(vtkExtractCTHPart,vtkPolyDataAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkInformationDoubleVectorKey *BOUNDS();
  
  static vtkExtractCTHPart *New();


  void RemoveAllVolumeArrayNames();
  void AddVolumeArrayName(char* arrayName);
  int GetNumberOfVolumeArrayNames();
  const char* GetVolumeArrayName(int idx);


  void SetClipPlane(vtkPlane *clipPlane);
  vtkGetObjectMacro(ClipPlane, vtkPlane);

  unsigned long GetMTime();
  
  void SetController(vtkMultiProcessController* controller);
  
  // Return the controller used to coordinate parallel processing. By default,
  // it is the global controller.
  vtkGetObjectMacro(Controller,vtkMultiProcessController);
  
protected:
  vtkExtractCTHPart();
  ~vtkExtractCTHPart();

  void SetOutputData(int idx, vtkPolyData* d);
  
  int RequestInformation(vtkInformation *request,
                         vtkInformationVector **inputVector,
                         vtkInformationVector *outputVector);
  
  int RequestData(vtkInformation *, vtkInformationVector **,
                  vtkInformationVector *);
  
  void ComputeBounds(vtkHierarchicalDataSet *input,
                     int processNumber,
                     int numProcessors);
  

  int GetParentProcessor(int proc);
  int GetLeftChildProcessor(int proc);
  
  void ExecutePart(const char *arrayName,
                   vtkHierarchicalDataSet *input,
                   vtkAppendPolyData *appendSurface,
                   vtkAppendPolyData *append);
  
  void ExecutePartOnUniformGrid(const char *arrayName,
#ifdef EXTRACT_USE_IMAGE_DATA
                                vtkImageData *input,
#else
                                vtkUniformGrid *input,
#endif
                                vtkAppendPolyData *appendSurface,
                                vtkAppendPolyData *append);
  
  void ExecutePartOnRectilinearGrid( const char *arrayName,
                                     vtkRectilinearGrid *input,
                                     vtkAppendPolyData *appendSurface,
                                     vtkAppendPolyData *append);
  
  void ExecuteCellDataToPointData(vtkDataArray *cellVolumeFraction, 
                                  vtkDoubleArray *pointVolumeFraction,
                                  int *dims);
  
  int FillInputPortInformation(int port,
                               vtkInformation *info);
  
  void CreateInternalPipeline();
  void DeleteInternalPipeline();
  

  int ExtractUniformGridSurface(
#ifdef EXTRACT_USE_IMAGE_DATA
    vtkImageData *input,
#else
    vtkUniformGrid *input,
#endif
    vtkPolyData *output);
  

  int ExtractRectilinearGridSurface(vtkRectilinearGrid *input,
                                    vtkPolyData *output);
  
  void ExecuteFaceQuads(vtkDataSet *input,
                        vtkPolyData *output,
                        int maxFlag,
                        int originExtents[3],
                        int ext[6],
                        int aAxis,
                        int bAxis,
                        int cAxis);
  

  int IsGhostFace(int axis0,
                  int maxFlag,
                  int dims[3],
                  vtkUnsignedCharArray *ghostArray);
  
  vtkPlane *ClipPlane;
  vtkExtractCTHPartInternal* Internals;
  
  // Internal Pipeline elements
  vtkDoubleArray *PointVolumeFraction;
  
#ifdef EXTRACT_USE_IMAGE_DATA
  vtkImageData *Data;
#else
  vtkUniformGrid *Data;
#endif
  
  vtkContourFilter *Contour;
  vtkAppendPolyData *Append2;
  vtkClipPolyData *Clip1;
  vtkCutter *Cut;
  vtkClipPolyData *Clip2;
  
  vtkPolyData *PolyData;
  vtkPolyData *RPolyData;
  vtkPolyData *SurfacePolyData;
  
  vtkRectilinearGrid *RData;
  vtkContourFilter *RContour;
  vtkAppendPolyData *RAppend2;
  vtkClipPolyData *RClip1;
  vtkCutter *RCut;
  vtkClipPolyData *RClip2;
  
  double Bounds[6]; // Whole bounds (dataset over all the processors)
  
  vtkMultiProcessController *Controller;
private:
  vtkExtractCTHPart(const vtkExtractCTHPart&);  // Not implemented.
  void operator=(const vtkExtractCTHPart&);  // Not implemented.
};
#endif

---