CGAL::Qt_widget

Definition

An object of type Qt_widget is a two-dimensional window for graphical IO. It is a class that is designed to help CGAL users to visualize easily CGAL objects and for advanced users to interact with them. This widget is designed for 2D CGAL objects only.

#include <CGAL/IO/Qt_widget.h>

Inherits From

Types

The widget class also defines the following enum type to specify which kind of point representation do you want to use:

Creation

Qt_widget provides scaling support. You can use a scaling factor for your objects as well as you can draw the objects with one scale and look at the objects with different scales. Also there is a possibility to tell the widget that you want that the visible area should be mapped to a certain interval, and the widget adjust the scaling factor according to that.

advanced

You should have the same scaling factor for X and Y if you want to keep the aspect ratio of your objects.

advanced

public slots:

Properties

You can set the properties of the functions through this functions as well as with the help of manipulators described later. The function naming convention has changed for this member functions, to Qt convention.

Layers

New CGAL Objects

Access Functions

Note that we use also types from Qt here.

advanced

The coordinates of the screen are maped to a certain interval that you can choose with set_window member function. The scale of the objects you can visualize is computed and maintained the same for both axes to keep the aspect ratio of the objects. You should use x_real or y_real to get the real world coordinates, for your screen coordinates. If you are using gmp you can use this functions with Gmpq as second parameter. You may need it when you work with rationals. The double from the other function could be more complex and can make you loose speed in computations. Computing with rational coordinates directly could increase the speed, rather than computing with complex double coordinates.

double	win.x_real ( int x)
double	win.y_real ( int y)
template<class FT>
void	x_real ( int x, FT&)	Returns the x real world coordinate of the Qt_widget.
template<class FT>
void	y_real ( int y, FT&)	Returns the y real world coordinate of the Qt_widget.
void	win.x_real ( int, Gmpq&)
void	win.y_real ( int, Gmpq&)

advanced

advanced

Painter and Pixmap

In order that layers can draw on the drawing area of a widget, they have to access the underlying pixmap and painter.

Qt_widget use as a backbuffer for drawing a pixmap defined inside the class, i.e. an object of type QPixmap. The QPixmap class is an off-screen pixel-based paint device. One common use of the QPixmap class is to enable smooth updating of widgets. The QPainter class paints on paint devices. There is an object of type QPainter defined in Qt_widget that uses as a paint device the QPixmap object.

QPixmap&	win.get_pixmap ()	Returns the current pixmap.
QPainter&	win.get_painter ()	Returns the current painter.

advanced

Signals

Operators for Output

The output operator is defined for all geometric classes in the CGAL kernel.

To use the other operators described you have to include the right header.

#include <CGAL/IO/Qt_widget_Polygon_2.h>

#include <CGAL/IO/Qt_widget_Min_ellipse_2.h>

#include <CGAL/IO/Qt_widget_Optimisation_ellipse_2.h>

#include <CGAL/IO/Qt_widget_Optimisation_circle_2.h>

#include <CGAL/IO/Qt_widget_Conic_2.h>

#include <CGAL/IO/Qt_widget_Triangulation_2.h>

#include <CGAL/IO/Qt_widget_Alpha_shape_2.h>

#include <CGAL/IO/Qt_widget_Delaunay_triangulation_2.h>

#include <CGAL/IO/Qt_widget_Constrained_triangulation_2.h>

#include <CGAL/IO/Qt_widget_Regular_triangulation_2.h>

Manipulators for Qt_widget

A manipulator is an object which can be inserted in the Qt_widget, via the operator <<, to change the context for further drawing.

Here, we simply document the use of these operators which is all the user needs to know to modify the state of a stream.

Example

In the given example, we create an object of type Qt_widget and then we use the operators for output and the manipulators to show some of the widget's functionality.

#include <CGAL/Cartesian.h>
#include <CGAL/Bbox_2.h>
#include <list>
#include <CGAL/Polygon_2.h>
#include <CGAL/IO/Qt_widget_Polygon_2.h>
#include <qapplication.h>
#include <CGAL/IO/Qt_widget.h>

typedef CGAL::Cartesian<int>   Rep;
typedef CGAL::Point_2<Rep>     Point;
typedef CGAL::Circle_2<Rep>    Circle;
typedef CGAL::Segment_2<Rep>   Segment;
typedef CGAL::Line_2<Rep>      Line;
typedef CGAL::Ray_2<Rep>       Ray;
typedef CGAL::Triangle_2<Rep>  Triangle;
typedef CGAL::Iso_rectangle_2<Rep>
                               Cgal_Rectangle;
typedef CGAL::Bbox_2           BBox;
typedef std::list<Point>       Container;
typedef CGAL::Polygon_2<Rep,Container>
                               Cgal_Polygon;

int main( int argc, char **argv )
{
  QApplication app( argc, argv );
  using namespace CGAL;
  CGAL::Qt_widget * W = new CGAL::Qt_widget();
  app.setMainWidget( W );
  W->resize(600, 600);
  W->set_window(0, 600, 0, 600);
  W->show();
  //painting something on the screen
  W->lock();

  *W << BackgroundColor(ORANGE) << RED <<
  LineWidth(3) << PointSize(3) << PointStyle(DISC);
  *W << Segment(Point(10,20),Point(300,400));
  *W << LineWidth(5) << GREEN << FillColor(BLACK) <<
    Circle(Point(400,400),50*50);
  *W << LineWidth(1) << noFill << Circle(Point(300,300),300*300);
  *W << BLUE << LineWidth(2);
  *W << Segment(Point(200,200),Point(400,400));
  *W << Segment(Point(200,400),Point(400,200));
  W->setFilled(TRUE);
  *W << RED << Triangle(Point(150,300),
                                  Point(150,350),
                                  Point(100,325));
  *W << FillColor(RED) << Cgal_Rectangle(Point(320,220),
                                              Point(350,240));
  *W << DEEPBLUE << BBox(100,80,260,140);
  Cgal_Polygon p;
  p.push_back(Point(300,30));
  p.push_back(Point(400,30));
  p.push_back(Point(500,130));
  p.push_back(Point(400,180));
  p.push_back(Point(300,130));
  *W << p;
  *W << Ray(Point(200,400), Point(180,430))
    << Ray(Point(200,400), Point(180,370));
  W->unlock();

  return app.exec();
}