vtkContext2D.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkContext2D.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 vtkContext2D_h
#define vtkContext2D_h
 
#include "vtkDeprecation.h" // for deprecation macros
#include "vtkObject.h"
#include "vtkRenderingContext2DModule.h" // For export macro
 
class vtkWindow;
 
class vtkContext3D;
class vtkStdString;
class vtkUnicodeString;
class vtkTextProperty;
 
class vtkPoints2D;
class vtkVector2f;
class vtkRectf;
class vtkUnsignedCharArray;
class vtkContextDevice2D;
class vtkPen;
class vtkBrush;
class vtkImageData;
class vtkPolyData;
class vtkTransform2D;
class vtkAbstractContextBufferId;
 
class VTKRENDERINGCONTEXT2D_EXPORT vtkContext2D : public vtkObject
{
public:
  vtkTypeMacro(vtkContext2D, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkContext2D* New();
 
  bool Begin(vtkContextDevice2D* device);
 
  vtkGetObjectMacro(Device, vtkContextDevice2D);
 
  bool End();
 
  bool GetBufferIdMode() const;
 
  void BufferIdModeBegin(vtkAbstractContextBufferId* bufferId);
 
  void BufferIdModeEnd();
 
  void DrawLine(float x1, float y1, float x2, float y2);
 
  void DrawLine(float p[4]);
 
  void DrawLine(vtkPoints2D* points);
 
  void DrawPoly(float* x, float* y, int n);
 
  void DrawPoly(vtkPoints2D* points);
 
  void DrawPoly(float* points, int n);
 
  void DrawPoly(float* points, int n, unsigned char* colors, int nc_comps);
 
  void DrawLines(vtkPoints2D* points);
 
  void DrawLines(float* points, int n);
 
  void DrawPoint(float x, float y);
 
  void DrawPoints(float* x, float* y, int n);
 
  void DrawPoints(vtkPoints2D* points);
 
  void DrawPoints(float* points, int n);
 
  void DrawPointSprites(vtkImageData* sprite, vtkPoints2D* points);
 
 
  void DrawPointSprites(vtkImageData* sprite, vtkPoints2D* points, vtkUnsignedCharArray* colors);
  void DrawPointSprites(
    vtkImageData* sprite, float* points, int n, unsigned char* colors, int nc_comps);
 
  void DrawPointSprites(vtkImageData* sprite, float* points, int n);
 
 
  virtual void DrawMarkers(
    int shape, bool highlight, float* points, int n, unsigned char* colors, int nc_comps);
  virtual void DrawMarkers(int shape, bool highlight, float* points, int n);
  virtual void DrawMarkers(int shape, bool highlight, vtkPoints2D* points);
  virtual void DrawMarkers(
    int shape, bool highlight, vtkPoints2D* points, vtkUnsignedCharArray* colors);
 
  void DrawRect(float x, float y, float w, float h);
 
 
  void DrawQuad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4);
  void DrawQuad(float* p);
 
 
  void DrawQuadStrip(vtkPoints2D* points);
  void DrawQuadStrip(float* p, int n);
 
  void DrawPolygon(float* x, float* y, int n);
 
  void DrawPolygon(vtkPoints2D* points);
 
  void DrawPolygon(float* points, int n);
 
  void DrawPolygon(float* x, float* y, int n, unsigned char* color, int nc_comps);
 
  void DrawPolygon(vtkPoints2D* points, unsigned char* color, int nc_comps);
 
  void DrawPolygon(float* points, int n, unsigned char* color, int nc_comps);
 
  void DrawEllipse(float x, float y, float rx, float ry);
 
  void DrawWedge(
    float x, float y, float outRadius, float inRadius, float startAngle, float stopAngle);
 
  void DrawEllipseWedge(float x, float y, float outRx, float outRy, float inRx, float inRy,
    float startAngle, float stopAngle);
 
  void DrawArc(float x, float y, float r, float startAngle, float stopAngle);
 
  void DrawEllipticArc(float x, float y, float rX, float rY, float startAngle, float stopAngle);
 
  void DrawImage(float x, float y, vtkImageData* image);
 
  void DrawImage(float x, float y, float scale, vtkImageData* image);
 
  void DrawImage(const vtkRectf& pos, vtkImageData* image);
 
  void DrawPolyData(
    float x, float y, vtkPolyData* polyData, vtkUnsignedCharArray* colors, int scalarMode);
 
 
  void DrawStringRect(vtkPoints2D* rect, const vtkStdString& string);
  VTK_DEPRECATED_IN_9_1_0("Use void DrawStringRect(vtkPoints2D* rect, const vtkStdString& string)")
  void DrawStringRect(vtkPoints2D* rect, const vtkUnicodeString& string);
  void DrawStringRect(vtkPoints2D* rect, const char* string);
  void DrawStringRect(const float rect[4], const vtkStdString& string);
  VTK_DEPRECATED_IN_9_1_0(
    "Use void DrawStringRect(const float rect[4], const vtkStdString& string)")
  void DrawStringRect(const float rect[4], const vtkUnicodeString& string);
  void DrawStringRect(const float rect[4], const char* string);
 
 
  void DrawString(vtkPoints2D* point, const vtkStdString& string);
  void DrawString(float x, float y, const vtkStdString& string);
  VTK_DEPRECATED_IN_9_1_0("Use void DrawString(vtkPoints2D* point, const vtkStdString& string)")
  void DrawString(vtkPoints2D* point, const vtkUnicodeString& string);
  VTK_DEPRECATED_IN_9_1_0("Use void DrawString(float x, float y, const vtkStdString& string)")
  void DrawString(float x, float y, const vtkUnicodeString& string);
  void DrawString(vtkPoints2D* point, const char* string);
  void DrawString(float x, float y, const char* string);
 
 
  void ComputeStringBounds(const vtkStdString& string, vtkPoints2D* bounds);
  void ComputeStringBounds(const vtkStdString& string, float bounds[4]);
  VTK_DEPRECATED_IN_9_1_0(
    "Use void ComputeStringBounds(const vtkStdString& string, vtkPoints2D* bounds)")
  void ComputeStringBounds(const vtkUnicodeString& string, vtkPoints2D* bounds);
  VTK_DEPRECATED_IN_9_1_0(
    "Use void ComputeStringBounds(const vtkStdString& string, float bounds[4])")
  void ComputeStringBounds(const vtkUnicodeString& string, float bounds[4]);
  void ComputeStringBounds(const char* string, vtkPoints2D* bounds);
  void ComputeStringBounds(const char* string, float bounds[4]);
 
  void ComputeJustifiedStringBounds(const char* string, float bounds[4]);
 
  int ComputeFontSizeForBoundedString(const vtkStdString& string, float width, float height);
 
 
  void DrawMathTextString(vtkPoints2D* point, const vtkStdString& string);
  void DrawMathTextString(float x, float y, const vtkStdString& string);
  void DrawMathTextString(vtkPoints2D* point, const char* string);
  void DrawMathTextString(float x, float y, const char* string);
 
 
  void DrawMathTextString(
    vtkPoints2D* point, const vtkStdString& string, const vtkStdString& fallback);
  void DrawMathTextString(
    float x, float y, const vtkStdString& string, const vtkStdString& fallback);
  void DrawMathTextString(vtkPoints2D* point, const char* string, const char* fallback);
  void DrawMathTextString(float x, float y, const char* string, const char* fallback);
 
  bool MathTextIsSupported();
 
  void ApplyPen(vtkPen* pen);
 
  vtkPen* GetPen();
 
  void ApplyBrush(vtkBrush* brush);
 
  vtkBrush* GetBrush();
 
  void ApplyTextProp(vtkTextProperty* prop);
 
  vtkTextProperty* GetTextProp();
 
  void SetTransform(vtkTransform2D* transform);
 
  vtkTransform2D* GetTransform();
 
  void AppendTransform(vtkTransform2D* transform);
 
 
  void PushMatrix();
  void PopMatrix();
 
  void ApplyId(vtkIdType id);
 
  static int FloatToInt(float x);
 
 
  vtkGetObjectMacro(Context3D, vtkContext3D);
  virtual void SetContext3D(vtkContext3D* context);
 
protected:
  vtkContext2D();
  ~vtkContext2D() override;
 
  vtkContextDevice2D* Device; // The underlying device
  vtkTransform2D* Transform;  // Current transform
 
  vtkAbstractContextBufferId* BufferId;
  vtkContext3D* Context3D; // May be very temporary - get at a 3D version.
 
private:
  vtkContext2D(const vtkContext2D&) = delete;
  void operator=(const vtkContext2D&) = delete;
 
  vtkVector2f CalculateTextPosition(vtkPoints2D* rect);
 
  vtkVector2f CalculateTextPosition(const float rect[4]);
};
 
inline int vtkContext2D::FloatToInt(float x)
{
  // Use a tolerance of 1/256 of a pixel when converting.
  // A float has only 24 bits of precision, so we cannot
  // make the tolerance too small.  For example, a tolerance
  // of 2^-8 means that the tolerance will be significant
  // for float values up to 2^16 or 65536.0.  But a
  // tolerance of 2^-16 would only be significant for
  // float values up to 2^8 or 256.0.  A small tolerance
  // disappears into insignificance when added to a large float.
  float tol = 0.00390625; // 1.0/256.0
  tol = (x >= 0 ? tol : -tol);
  return static_cast<int>(x + tol);
}
 
#endif // vtkContext2D_h