vtkImporter.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkImporter_h
#define vtkImporter_h
 
#include "vtkDataAssembly.h"   // for vtkDataAssembly
#include "vtkIOImportModule.h" // For export macro
#include "vtkResourceStream.h" // For Stream
#include "vtkSmartPointer.h"   // for vtkSmartPointer
 
#include "vtkObject.h"
 
#include <string> // for std::string
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractArray;
class vtkActorCollection;
class vtkCollection;
class vtkDataSet;
class vtkDoubleArray;
class vtkInformationIntegerKey;
class vtkLightCollection;
class vtkRenderWindow;
class vtkRenderer;
 
class VTKIOIMPORT_EXPORT vtkImporter : public vtkObject
{
public:
  vtkTypeMacro(vtkImporter, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);


  vtkSetSmartPointerMacro(Stream, vtkResourceStream);
  vtkGetSmartPointerMacro(Stream, vtkResourceStream);


  vtkGetObjectMacro(Renderer, vtkRenderer);


  vtkGetObjectMacro(SceneHierarchy, vtkDataAssembly);


  vtkActorCollection* GetImportedActors() { return this->ActorCollection.Get(); }
  vtkCollection* GetImportedCameras() { return this->CameraCollection.Get(); }
  vtkLightCollection* GetImportedLights() { return this->LightCollection.Get(); }


  virtual void SetRenderWindow(vtkRenderWindow*);
  vtkGetObjectMacro(RenderWindow, vtkRenderWindow);

  VTK_UNBLOCKTHREADS
  bool Update();

  virtual std::string GetOutputsDescription() { return ""; }
 
  enum class AnimationSupportLevel : unsigned char
  {
    NONE,
    UNIQUE,
    SINGLE,
    MULTI
  };

  virtual AnimationSupportLevel GetAnimationSupportLevel() { return AnimationSupportLevel::NONE; }

  virtual vtkIdType GetNumberOfAnimations();

  virtual std::string GetAnimationName(vtkIdType vtkNotUsed(animationIndex)) { return ""; }


  virtual void EnableAnimation(vtkIdType vtkNotUsed(animationIndex)) {}
  virtual void DisableAnimation(vtkIdType vtkNotUsed(animationIndex)) {}
  virtual bool IsAnimationEnabled(vtkIdType vtkNotUsed(animationIndex)) { return false; }

  virtual vtkIdType GetNumberOfCameras() { return 0; }

  virtual std::string GetCameraName(vtkIdType vtkNotUsed(camIndex)) { return ""; }

  virtual void SetCamera(vtkIdType vtkNotUsed(camIndex)) {}

  virtual bool GetTemporalInformation(
    vtkIdType animationIndex, double timeRange[2], int& nbTimeSteps, vtkDoubleArray* timeSteps);

  virtual bool UpdateAtTimeValue(double vtkNotUsed(timeValue)) { return true; };
 
  enum class InterpolateAnimationSupportLevel : unsigned char
  {
    NEVER,
    CAPABLE,
    ALWAYS,
  };

  virtual InterpolateAnimationSupportLevel GetInterpolateAnimationSupportLevel()
  {
    return InterpolateAnimationSupportLevel::NEVER;
  }


  vtkSetMacro(InterpolateBetweenTimeSteps, bool);
  vtkGetMacro(InterpolateBetweenTimeSteps, bool);
  vtkBooleanMacro(InterpolateBetweenTimeSteps, bool);


  vtkSetMacro(ImportArmature, bool);
  vtkGetMacro(ImportArmature, bool);
  vtkBooleanMacro(ImportArmature, bool);
 
protected:
  vtkImporter();
  ~vtkImporter() override;
 
  virtual int ImportBegin() { return 1; }
  virtual void ImportEnd() {}
  virtual void ImportActors(vtkRenderer*) {}
  virtual void ImportCameras(vtkRenderer*) {}
  virtual void ImportLights(vtkRenderer*) {}
  virtual void ImportProperties(vtkRenderer*) {}
  virtual void ReadData();
 
  enum class UpdateStatusEnum : bool
  {
    SUCCESS,
    FAILURE
  };

  void SetUpdateStatus(UpdateStatusEnum updateStatus)
  {
    this->UpdateStatus = updateStatus;
    this->Modified();
  }

  UpdateStatusEnum GetUpdateStatus() { return this->UpdateStatus; }
 
  static std::string GetDataSetDescription(vtkDataSet* ds, vtkIndent indent);
  static std::string GetArrayDescription(vtkAbstractArray* array, vtkIndent indent);
 
  vtkRenderer* Renderer = nullptr;
  vtkRenderWindow* RenderWindow = nullptr;
  vtkSmartPointer<vtkDataAssembly> SceneHierarchy;
 
  vtkNew<vtkActorCollection> ActorCollection;
  vtkNew<vtkCollection> CameraCollection;
  vtkNew<vtkLightCollection> LightCollection;
 
private:
  vtkImporter(const vtkImporter&) = delete;
  void operator=(const vtkImporter&) = delete;
 
  bool SetAndCheckUpdateStatus();
 
  char* FileName = nullptr;
  vtkSmartPointer<vtkResourceStream> Stream;
 
  UpdateStatusEnum UpdateStatus = UpdateStatusEnum::SUCCESS;
  bool ImportArmature = false;
  bool InterpolateBetweenTimeSteps = true;
};
 
VTK_ABI_NAMESPACE_END
#endif