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 "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;
 
 
  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 frameRate, int& nbTimeSteps,
    double timeRange[2], vtkDoubleArray* timeSteps);
 
  virtual bool UpdateAtTimeValue(double vtkNotUsed(timeValue)) { return true; };
 
 
  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();
 
  UpdateStatusEnum UpdateStatus = UpdateStatusEnum::SUCCESS;
  bool ImportArmature = false;
};
 
VTK_ABI_NAMESPACE_END
#endif