freespaceview.h

Go to the documentation of this file.

#ifndef FREESPACEVIEW_H
#define FREESPACEVIEW_H

#include <baseview.h>
#include <grid.h>
#include <freespace.h>
#include <fs_path.h>
#include <k_frechet/kalgorithm.h>
#include <palette.h>
#include <intervalview.h>

#include <array2d.h>
#include <QPolygonF>
#include <QGraphicsItemGroup>

namespace frechet { namespace view {

class FreeSpaceView;
class CellView : public QGraphicsItemGroup
{
private:
    int i;
    int j;
    FreeSpaceView* parent;

    QRectF cellBounds;
    QPainterPath clipShape;

    QGraphicsPolygonItem* _poly;   
    QGraphicsEllipseItem* _ellipse;
    bool useEllipse;
    QGraphicsLineItem* _bounds[4];

    enum What {
        MASK    = 0x00f,
        NOTHING = 0x00, 
        POLY    = 0x01, 
        ELLIPSE = 0x02, 

        BOUNDS = 0x10,  

        ELLIPSE_AND_BOUNDS = ELLIPSE|BOUNDS,    
        POLY_AND_BOUNDS = POLY|BOUNDS           
    } what;

public:
    typedef data::Array2D<CellView*> Matrix;
    typedef boost::shared_ptr<Matrix> MatrixPtr;    

    CellView(FreeSpaceView* parent, int i, int j);
    virtual ~CellView();

    void setColor(QColor areaColor, QColor borderColor=QColor());

    void update(double eps, bool showBounds, QLineF bounds[4]);

    virtual QPainterPath shape() const {
        return clipShape;
    }
    virtual QRectF boundingRect() const {
        return cellBounds;
    }
    bool dropUnusedItems();

private:
    friend class FreeSpaceView;
    static const double DET_MINIMUM;
    static const double MAX_DIAMETER;

    //void addLine(QLineF,int i);
    QPolygonF createPolygon(int i, int j, bool* thin);

    QGraphicsPolygonItem* getPoly();
    QGraphicsEllipseItem* getEllipse();
    QGraphicsLineItem* getBounds(int i);
    void setBounds(QLineF bounds[4]);

    void dodraw(What what);
    void dropUnusedItem(QGraphicsItem** item);

    static void setBrushColor(QAbstractGraphicsShapeItem* item, QColor col);
    static void setPenColor(QAbstractGraphicsShapeItem* item, QColor col);
    static void setBoundsPenColor(QGraphicsLineItem** bounds, int len, QColor col);
    static void setPenStyle(QAbstractGraphicsShapeItem* item, Qt::PenStyle style);
    static void setPenStyleWidth(QAbstractGraphicsShapeItem* item, Qt::PenStyle style, float width);

};
class FreeSpaceView : public BaseView
{
    Q_OBJECT
public:
    QPen GRID_PEN [4];
    QPen AREA_PEN;      
    QPen BOUNDS_PEN;    
    QPen PATH_PEN;      
    static const QBrush AREA_BRUSH1;    
    static const QBrush AREA_BRUSH2;    
    static const double TF_MAX_ARG;     
    static const QColor LIGHT_GRAY;     
    static const QColor AREA_COLOR;     

    FreeSpaceView(QWidget *parent = 0);
    virtual ~FreeSpaceView();

    void populateScene();

    bool showBounds() const { return _showBounds; }

    virtual void dropUnusedItems() override;
    virtual void segmentSelected(GraphicsHoverLineItem *item) override;

signals:
    void curveFinished(bool yes);
    void hiliteSegment(int loc, int a, int b);

public slots:
    void calculateFreeSpace(double epsilon);
    void showBounds(bool show);

    void showGreedyResult();
    void showOptimalResult();
    void hideResult();
    void showPath(bool show);

    void onHiliteSegment(int loc, int a, int b);
    void onAlgorithmChanged(int alg);
    void hilitePoint(QPointF p);

    virtual void saveSettings(QSettings& settings, QString group);
    virtual void restoreSettings(QSettings& settings, QString group);

private:
    friend class CellView;
    bool path_ok;
    bool _showBounds;
    Palette componentPalette;

    CellView::MatrixPtr cells;

    IntervalView* intervalView[2];
    QGraphicsItemGroup *pathView;
    QGraphicsPathItem *select;

    CellView* getCellView(int i, int j);

    void updateView(double eps);

    void updateBounds();

    void updateIntervals();

    void showResult(const data::BitSet* resultSet);

    void createBoundsRect(int i, int j, QLineF result[4]);

    void createReachabilityRect(int i, int j, QLineF result[4]);

    QLineF boundsLine(QPointF a, QPointF b, int i, int j);

    QTransform createEllipseTransform(int i, int j);

    static bool validTransform(const QTransform& tf);

    static bool validTransformArg(double x);

    void addGridLine(QLineF line, LineStyle style);

    void doHiliteSegment(GraphicsHoverLineItem::Location loc, int a, int b);
};

} }  // namespace frechet::view

#endif // FREESPACEVIEW_H