vtkGL2PSExporter.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGL2PSExporter.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.
 
=========================================================================*/
#ifndef vtkGL2PSExporter_h
#define vtkGL2PSExporter_h
 
#include "vtkExporter.h"
#include "vtkIOExportGL2PSModule.h" // For export macro
 
#include "vtkNew.h" // For vtkNew
 
class vtkPropCollection;
 
class VTKIOEXPORTGL2PS_EXPORT vtkGL2PSExporter : public vtkExporter
{
public:
  static vtkGL2PSExporter* New();
  vtkTypeMacro(vtkGL2PSExporter, vtkExporter);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetFilePathMacro(FilePrefix);
  vtkGetFilePathMacro(FilePrefix);
 
 
  vtkSetMacro(BufferSize, int);
  vtkGetMacro(BufferSize, int);
 
 
  vtkSetStringMacro(Title);
  vtkGetStringMacro(Title);
 
  enum OutputFormat
  {
    PS_FILE,
    EPS_FILE,
    PDF_FILE,
    TEX_FILE,
    SVG_FILE
  };
 
 
  void UsePainterSettings()
  {
    this->SetSortToOff();
    this->SetSimpleLineOffset(0);
  }
 
 
  vtkSetClampMacro(FileFormat, int, PS_FILE, SVG_FILE);
  vtkGetMacro(FileFormat, int);
  void SetFileFormatToPS() { this->SetFileFormat(PS_FILE); }
  void SetFileFormatToEPS() { this->SetFileFormat(EPS_FILE); }
  void SetFileFormatToPDF() { this->SetFileFormat(PDF_FILE); }
  void SetFileFormatToTeX() { this->SetFileFormat(TEX_FILE); }
  void SetFileFormatToSVG() { this->SetFileFormat(SVG_FILE); }
  const char* GetFileFormatAsString();
 
  enum SortScheme
  {
    NO_SORT = 0,
    SIMPLE_SORT = 1,
    BSP_SORT = 2
  };
 
 
  vtkSetClampMacro(Sort, int, NO_SORT, BSP_SORT);
  vtkGetMacro(Sort, int);
  void SetSortToOff() { this->SetSort(NO_SORT); }
  void SetSortToSimple() { this->SetSort(SIMPLE_SORT); }
  void SetSortToBSP() { this->SetSort(BSP_SORT); }
  const char* GetSortAsString();
 
 
  vtkSetMacro(Compress, vtkTypeBool);
  vtkGetMacro(Compress, vtkTypeBool);
  vtkBooleanMacro(Compress, vtkTypeBool);
 
 
  vtkSetMacro(DrawBackground, vtkTypeBool);
  vtkGetMacro(DrawBackground, vtkTypeBool);
  vtkBooleanMacro(DrawBackground, vtkTypeBool);
 
 
  vtkSetMacro(SimpleLineOffset, vtkTypeBool);
  vtkGetMacro(SimpleLineOffset, vtkTypeBool);
  vtkBooleanMacro(SimpleLineOffset, vtkTypeBool);
 
 
  vtkSetMacro(Silent, vtkTypeBool);
  vtkGetMacro(Silent, vtkTypeBool);
  vtkBooleanMacro(Silent, vtkTypeBool);
 
 
  vtkSetMacro(BestRoot, vtkTypeBool);
  vtkGetMacro(BestRoot, vtkTypeBool);
  vtkBooleanMacro(BestRoot, vtkTypeBool);
 
 
  vtkSetMacro(Text, vtkTypeBool);
  vtkGetMacro(Text, vtkTypeBool);
  vtkBooleanMacro(Text, vtkTypeBool);
 
 
  vtkSetMacro(Landscape, vtkTypeBool);
  vtkGetMacro(Landscape, vtkTypeBool);
  vtkBooleanMacro(Landscape, vtkTypeBool);
 
 
  vtkSetMacro(PS3Shading, vtkTypeBool);
  vtkGetMacro(PS3Shading, vtkTypeBool);
  vtkBooleanMacro(PS3Shading, vtkTypeBool);
 
 
  vtkSetMacro(OcclusionCull, vtkTypeBool);
  vtkGetMacro(OcclusionCull, vtkTypeBool);
  vtkBooleanMacro(OcclusionCull, vtkTypeBool);
 
 
  vtkSetMacro(Write3DPropsAsRasterImage, vtkTypeBool);
  vtkGetMacro(Write3DPropsAsRasterImage, vtkTypeBool);
  vtkBooleanMacro(Write3DPropsAsRasterImage, vtkTypeBool);
 
 
  vtkSetMacro(TextAsPath, bool);
  vtkGetMacro(TextAsPath, bool);
  vtkBooleanMacro(TextAsPath, bool);
 
 
  void SetRasterExclusions(vtkPropCollection*);
  vtkGetObjectMacro(RasterExclusions, vtkPropCollection);
 
 
  vtkSetMacro(PointSizeFactor, float);
  vtkGetMacro(PointSizeFactor, float);
 
 
  vtkSetMacro(LineWidthFactor, float);
  vtkGetMacro(LineWidthFactor, float);
 
protected:
  vtkGL2PSExporter();
  ~vtkGL2PSExporter() override;
 
  int GetGL2PSOptions();
  int GetGL2PSSort();
  int GetGL2PSFormat();
  const char* GetFileExtension();
 
  vtkPropCollection* RasterExclusions;
 
  char* FilePrefix;
  char* Title;
  int FileFormat;
  int BufferSize;
  int Sort;
  vtkTypeBool Compress;
  vtkTypeBool DrawBackground;
  vtkTypeBool SimpleLineOffset;
  vtkTypeBool Silent;
  vtkTypeBool BestRoot;
  vtkTypeBool Text;
  vtkTypeBool Landscape;
  vtkTypeBool PS3Shading;
  vtkTypeBool OcclusionCull;
  vtkTypeBool Write3DPropsAsRasterImage;
  bool TextAsPath;
  float PointSizeFactor;
  float LineWidthFactor;
 
private:
  vtkGL2PSExporter(const vtkGL2PSExporter&) = delete;
  void operator=(const vtkGL2PSExporter&) = delete;
};
 
inline const char* vtkGL2PSExporter::GetSortAsString(void)
{
  if (this->Sort == NO_SORT)
  {
    return "Off";
  }
  else if (this->Sort == SIMPLE_SORT)
  {
    return "Simple";
  }
  else
  {
    return "BSP";
  }
}
 
inline const char* vtkGL2PSExporter::GetFileFormatAsString(void)
{
  if (this->FileFormat == PS_FILE)
  {
    return "PS";
  }
  else if (this->FileFormat == EPS_FILE)
  {
    return "EPS";
  }
  else if (this->FileFormat == PDF_FILE)
  {
    return "PDF";
  }
  else if (this->FileFormat == TEX_FILE)
  {
    return "TeX";
  }
  else
  {
    return "SVG";
  }
}
 
#endif