vtkNetCDFCFReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2008 Sandia Corporation
// SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-LANL-California-USGov

#ifndef vtkNetCDFCFReader_h
#define vtkNetCDFCFReader_h

#include "vtkIONetCDFModule.h" // For export macro
#include "vtkNetCDFReader.h"

#include "vtkStdString.h" // Used for ivars.

VTK_ABI_NAMESPACE_BEGIN
class vtkImageData;
class vtkPoints;
class vtkRectilinearGrid;
class vtkStructuredGrid;
class vtkUnstructuredGrid;

class VTKIONETCDF_EXPORT vtkNetCDFCFReader : public vtkNetCDFReader
{
public:
  vtkTypeMacro(vtkNetCDFCFReader, vtkNetCDFReader);
  static vtkNetCDFCFReader* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkGetMacro(SphericalCoordinates, vtkTypeBool);
  vtkSetMacro(SphericalCoordinates, vtkTypeBool);
  vtkBooleanMacro(SphericalCoordinates, vtkTypeBool);


  vtkGetMacro(VerticalScale, double);
  vtkSetMacro(VerticalScale, double);
  vtkGetMacro(VerticalBias, double);
  vtkSetMacro(VerticalBias, double);


  vtkGetMacro(OutputType, int);
  virtual void SetOutputType(int type);
  void SetOutputTypeToAutomatic() { this->SetOutputType(-1); }
  void SetOutputTypeToImage() { this->SetOutputType(VTK_IMAGE_DATA); }
  void SetOutputTypeToRectilinear() { this->SetOutputType(VTK_RECTILINEAR_GRID); }
  void SetOutputTypeToStructured() { this->SetOutputType(VTK_STRUCTURED_GRID); }
  void SetOutputTypeToUnstructured() { this->SetOutputType(VTK_UNSTRUCTURED_GRID); }

  static int CanReadFile(VTK_FILEPATH const char* filename);


  void SetTimeDimensionName(const char* name);
  void SetLatitudeDimensionName(const char* name);
  void SetLongitudeDimensionName(const char* name);
  void SetVerticalDimensionName(const char* name);


  const char* GetTimeDimensionName();
  const char* GetLatitudeDimensionName();
  const char* GetLongitudeDimensionName();
  const char* GetVerticalDimensionName();

protected:
  vtkNetCDFCFReader();
  ~vtkNetCDFCFReader() override;

  vtkTypeBool SphericalCoordinates;

  double VerticalScale;
  double VerticalBias;

  int OutputType;

  int RequestDataObject(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  int RequestInformation(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  int RequestData(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;


  int ReadMetaData(int ncFD) override;
  int IsTimeDimension(int ncFD, int dimId) override;
  vtkSmartPointer<vtkDoubleArray> GetTimeValues(int ncFD, int dimId) override;

  class vtkDimensionInfo
  {
  public:
    vtkDimensionInfo() = default;
    vtkDimensionInfo(vtkNetCDFAccessor* accessor, int ncFD, int id,
      const std::vector<std::string>& dimensionNames);

    const char* GetName() const { return this->Name.c_str(); }
    enum UnitsEnum
    {
      UNDEFINED_UNITS,
      TIME_UNITS,
      LATITUDE_UNITS,
      LONGITUDE_UNITS,
      VERTICAL_UNITS,
      NUMBER_OF_UNITS
    };
    UnitsEnum GetUnits() const { return this->Units; }
    vtkSmartPointer<vtkDoubleArray> GetCoordinates() { return this->Coordinates; }
    vtkSmartPointer<vtkDoubleArray> GetBounds() { return this->Bounds; }
    bool GetHasRegularSpacing() const { return this->HasRegularSpacing; }
    double GetOrigin() const { return this->Origin; }
    double GetSpacing() const { return this->Spacing; }
    vtkSmartPointer<vtkStringArray> GetSpecialVariables() const { return this->SpecialVariables; }
    void SetUnitsIfSpecialDimensionOverriden(UnitsEnum unit, const char* name);

  protected:
    vtkNetCDFAccessor* Accessor = nullptr;
    vtkStdString Name;
    int DimId;
    vtkSmartPointer<vtkDoubleArray> Coordinates;
    vtkSmartPointer<vtkDoubleArray> Bounds;
    UnitsEnum Units;
    bool HasRegularSpacing;
    double Origin, Spacing;
    vtkSmartPointer<vtkStringArray> SpecialVariables;
    std::vector<std::string> SpecialDimensionOverrideNames;
    int LoadMetaData(int ncFD);
  };
  void SetSpecialDimensionOverrideName(vtkDimensionInfo::UnitsEnum dim, const char* name)
  {
    this->SpecialDimensionOverrideNames[dim] = name;
  }
  const char* GetSpecialDimensionName(vtkDimensionInfo::UnitsEnum dim);

  class vtkDimensionInfoVector;
  friend class vtkDimensionInfoVector;
  vtkDimensionInfoVector* DimensionInfo;
  vtkDimensionInfo* GetDimensionInfo(int dimension);

  class vtkDependentDimensionInfo
  {
  public:
    vtkDependentDimensionInfo(vtkNetCDFAccessor* accessor)
      : Accessor(accessor)
      , Valid(false)
    {
    }
    vtkDependentDimensionInfo(
      vtkNetCDFAccessor* accessor, int ncFD, int varId, vtkNetCDFCFReader* parent);
    bool GetValid() const { return this->Valid; }
    bool GetHasBounds() const { return this->HasBounds; }
    bool GetCellsUnstructured() const { return this->CellsUnstructured; }
    vtkSmartPointer<vtkIntArray> GetGridDimensions() const { return this->GridDimensions; }
    vtkSmartPointer<vtkDoubleArray> GetLongitudeCoordinates() const
    {
      return this->LongitudeCoordinates;
    }
    vtkSmartPointer<vtkDoubleArray> GetLatitudeCoordinates() const
    {
      return this->LatitudeCoordinates;
    }
    vtkSmartPointer<vtkStringArray> GetSpecialVariables() const { return this->SpecialVariables; }

  protected:
    vtkNetCDFAccessor* Accessor;
    bool Valid;
    bool HasBounds;
    bool CellsUnstructured;
    vtkSmartPointer<vtkIntArray> GridDimensions;
    vtkSmartPointer<vtkDoubleArray> LongitudeCoordinates;
    vtkSmartPointer<vtkDoubleArray> LatitudeCoordinates;
    vtkSmartPointer<vtkStringArray> SpecialVariables;
    int LoadMetaData(int ncFD, int varId, vtkNetCDFCFReader* parent);
    int LoadCoordinateVariable(int ncFD, int varId, vtkDoubleArray* coords);
    int LoadBoundsVariable(int ncFD, int varId, vtkDoubleArray* coords);
    int LoadUnstructuredBoundsVariable(int ncFD, int varId, vtkDoubleArray* coords);
  };
  friend class vtkDependentDimensionInfo;
  class vtkDependentDimensionInfoVector;
  friend class vtkDependentDimensionInfoVector;
  vtkDependentDimensionInfoVector* DependentDimensionInfo;

  // Finds the dependent dimension information for the given set of dimensions.
  // Returns nullptr if no information has been recorded.
  vtkDependentDimensionInfo* FindDependentDimensionInfo(vtkIntArray* dims);

  virtual void IdentifySphericalCoordinates(
    vtkIntArray* dimensions, int& longitudeDim, int& latitudeDim, int& verticalDim);

  enum CoordinateTypesEnum
  {
    COORDS_UNIFORM_RECTILINEAR,
    COORDS_NONUNIFORM_RECTILINEAR,
    COORDS_REGULAR_SPHERICAL,
    COORDS_2D_EUCLIDEAN,
    COORDS_2D_SPHERICAL,
    COORDS_EUCLIDEAN_4SIDED_CELLS,
    COORDS_SPHERICAL_4SIDED_CELLS,
    COORDS_EUCLIDEAN_PSIDED_CELLS,
    COORDS_SPHERICAL_PSIDED_CELLS
  };

  CoordinateTypesEnum CoordinateType(vtkIntArray* dimensions);

  bool DimensionsAreForPointData(vtkIntArray* dimensions) override;

  void ExtentForDimensionsAndPiece(
    int pieceNumber, int numberOfPieces, int ghostLevels, int extent[6]);

  void GetUpdateExtentForOutput(vtkDataSet* output, int extent[6]) override;


  void AddRectilinearCoordinates(vtkImageData* imageOutput);
  void AddRectilinearCoordinates(vtkRectilinearGrid* rectilinearOutput);
  void FakeRectilinearCoordinates(vtkRectilinearGrid* rectilinearOutput);
  void Add1DRectilinearCoordinates(vtkPoints* points, const int extent[6]);
  void Add2DRectilinearCoordinates(vtkPoints* points, const int extent[6]);
  void Add1DRectilinearCoordinates(vtkStructuredGrid* structuredOutput);
  void Add2DRectilinearCoordinates(vtkStructuredGrid* structuredOutput);
  void FakeStructuredCoordinates(vtkStructuredGrid* structuredOutput);
  void Add1DRectilinearCoordinates(vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);
  void Add2DRectilinearCoordinates(vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);


  void Add1DSphericalCoordinates(vtkPoints* points, const int extent[6]);
  void Add2DSphericalCoordinates(vtkPoints* points, const int extent[6]);
  void Add1DSphericalCoordinates(vtkStructuredGrid* structuredOutput);
  void Add2DSphericalCoordinates(vtkStructuredGrid* structuredOutput);
  void Add1DSphericalCoordinates(vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);
  void Add2DSphericalCoordinates(vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);

  void AddStructuredCells(vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);


  void AddUnstructuredRectilinearCoordinates(
    vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);
  void AddUnstructuredSphericalCoordinates(
    vtkUnstructuredGrid* unstructuredOutput, const int extent[6]);

  std::vector<std::string> SpecialDimensionOverrideNames;

private:
  vtkNetCDFCFReader(const vtkNetCDFCFReader&) = delete;
  void operator=(const vtkNetCDFCFReader&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif // vtkNetCDFCFReader_h