Moved some common include files to public headers folder

guilib/include/rtabmap/gui/ConsoleWidget.h

@@ -0,0 +1,78 @@
+/*
+Copyright (c) 2010-2014, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef CONSOLEWIDGET_H_
+#define CONSOLEWIDGET_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <rtabmap/utilite/UEventsHandler.h>
+#include <QWidget>
+#include <QtCore/QMutex>
+#include <QtCore/QTimer>
+#include <QtCore/QTime>
+
+class Ui_consoleWidget;
+class QMessageBox;
+class QTextCursor;
+
+namespace rtabmap {
+
+class RTABMAPGUI_EXP ConsoleWidget : public QWidget, public UEventsHandler
+{
+	Q_OBJECT;
+
+public:
+	ConsoleWidget(QWidget * parent = 0);
+	virtual ~ConsoleWidget();
+
+public slots:
+	void appendMsg(const QString & msg, int level = 1);
+
+signals:
+	void msgReceived(const QString &, int);
+
+private slots:
+	void flushConsole();
+
+protected:
+	virtual void handleEvent(UEvent * anEvent);
+
+private:
+	Ui_consoleWidget * _ui;
+	QMessageBox * _errorMessage;
+	QMutex _errorMessageMutex;
+	QMutex _msgListMutex;
+	QTimer _timer;
+	QTime _time;
+	QTextCursor * _textCursor;
+	QList<QPair<QString, int> > _msgList;
+};
+
+}
+
+#endif /* CONSOLEWIDGET_H_ */

guilib/include/rtabmap/gui/GraphViewer.h

@@ -0,0 +1,156 @@
+/*
+Copyright (c) 2010-2014, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef GRAPHVIEWER_H_
+#define GRAPHVIEWER_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <QGraphicsView>
+#include <QtCore/QMap>
+#include <QtCore/QSettings>
+#include <rtabmap/core/Link.h>
+#include <opencv2/opencv.hpp>
+#include <map>
+
+class QGraphicsItem;
+class QGraphicsPixmapItem;
+class QGraphicsItemGroup;
+
+namespace rtabmap {
+
+class NodeItem;
+class LinkItem;
+
+class RTABMAPGUI_EXP GraphViewer : public QGraphicsView {
+
+	Q_OBJECT;
+
+public:
+	GraphViewer(QWidget * parent = 0);
+	virtual ~GraphViewer();
+
+	void updateGraph(const std::map<int, Transform> & poses,
+					 const std::multimap<int, Link> & constraints,
+					 const std::map<int, int> & mapIds);
+	void updateReferentialPosition(const Transform & t);
+	void updateMap(const cv::Mat & map8U, float resolution, float xMin, float yMin);
+	void updatePosterior(const std::map<int, float> & posterior);
+	void updateLocalPath(const std::vector<int> & localPath);
+	void setGlobalPath(const std::vector<std::pair<int, Transform> > & globalPath);
+	void setCurrentGoalID(int id);
+	void setLocalRadius(float radius);
+	void clearGraph();
+	void clearMap();
+	void clearPosterior();
+	void clearAll();
+
+	void saveSettings(QSettings & settings, const QString & group = "") const;
+	void loadSettings(QSettings & settings, const QString & group = "");
+
+	//getters
+	const QString & getWorkingDirectory() const {return _workingDirectory;}
+	float getNodeRadius() const {return _nodeRadius;}
+	float getLinkWidth() const {return _linkWidth;}
+	const QColor & getNodeColor() const {return _nodeColor;}
+	const QColor & getCurrentGoalColor() const {return _currentGoalColor;}
+	const QColor & getNeighborColor() const {return _neighborColor;}
+	const QColor & getGlobalLoopClosureColor() const {return _loopClosureColor;}
+	const QColor & getLocalLoopClosureColor() const {return _loopClosureLocalColor;}
+	const QColor & getUserLoopClosureColor() const {return _loopClosureUserColor;}
+	const QColor & getVirtualLoopClosureColor() const {return _loopClosureVirtualColor;}
+	const QColor & getLocalPathColor() const {return _localPathColor;}
+	const QColor & getGlobalPathColor() const {return _globalPathColor;}
+	const QColor & getIntraSessionLoopColor() const {return _loopIntraSessionColor;}
+	const QColor & getInterSessionLoopColor() const {return _loopInterSessionColor;}
+	bool isIntraInterSessionColorsEnabled() const {return _intraInterSessionColors;}
+	bool isGridMapVisible() const;
+	bool isOriginVisible() const;
+	bool isReferentialVisible() const;
+	bool isLocalRadiusVisible() const;
+
+	// setters
+	void setWorkingDirectory(const QString & path);
+	void setNodeRadius(float radius);
+	void setLinkWidth(float width);
+	void setNodeColor(const QColor & color);
+	void setCurrentGoalColor(const QColor & color);
+	void setNeighborColor(const QColor & color);
+	void setGlobalLoopClosureColor(const QColor & color);
+	void setLocalLoopClosureColor(const QColor & color);
+	void setUserLoopClosureColor(const QColor & color);
+	void setVirtualLoopClosureColor(const QColor & color);
+	void setLocalPathColor(const QColor & color);
+	void setGlobalPathColor(const QColor & color);
+	void setIntraSessionLoopColor(const QColor & color);
+	void setInterSessionLoopColor(const QColor & color);
+	void setIntraInterSessionColorsEnabled(bool enabled);
+	void setGridMapVisible(bool visible);
+	void setOriginVisible(bool visible);
+	void setReferentialVisible(bool visible);
+	void setLocalRadiusVisible(bool visible);
+
+signals:
+	void configChanged();
+
+public slots:
+	void restoreDefaults();
+
+protected:
+	virtual void wheelEvent ( QWheelEvent * event );
+	virtual void contextMenuEvent(QContextMenuEvent * event);
+
+private:
+	QString _workingDirectory;
+	QColor _nodeColor;
+	QColor _currentGoalColor;
+	QColor _neighborColor;
+	QColor _loopClosureColor;
+	QColor _loopClosureLocalColor;
+	QColor _loopClosureUserColor;
+	QColor _loopClosureVirtualColor;
+	QColor _localPathColor;
+	QColor _globalPathColor;
+	QColor _loopIntraSessionColor;
+	QColor _loopInterSessionColor;
+	bool _intraInterSessionColors;
+	QGraphicsItem * _root;
+	QMap<int, NodeItem*> _nodeItems;
+	QMultiMap<int, LinkItem*> _linkItems;
+	QMultiMap<int, LinkItem*> _localPathLinkItems;
+	QMultiMap<int, LinkItem*> _globalPathLinkItems;
+	float _nodeRadius;
+	float _linkWidth;
+	QGraphicsPixmapItem * _gridMap;
+	QGraphicsItemGroup * _referential;
+	QGraphicsItemGroup * _originReferential;
+	float _gridCellSize;
+	QGraphicsEllipseItem * _localRadius;
+};
+
+} /* namespace rtabmap */
+#endif /* GRAPHVIEWER_H_ */

guilib/include/rtabmap/gui/MainWindow.h

@@ -63,7 +63,7 @@ class AboutDialog;
 class Plot;
 class PdfPlotCurve;
 class StatsToolBox;
-class DetailedProgressDialog;
+class ProgressDialog;
 class TwistGridWidget;
 class ExportCloudsDialog;
 class PostProcessingDialog;
@@ -297,7 +297,7 @@ private:
 	PdfPlotCurve * _likelihoodCurve;
 	PdfPlotCurve * _rawLikelihoodCurve;
 
-	DetailedProgressDialog * _initProgressDialog;
+	ProgressDialog * _initProgressDialog;
 
 	QString _graphSavingFileName;
 	QMap<int, QString> _exportPosesFileName;

guilib/include/rtabmap/gui/PdfPlot.h

@@ -0,0 +1,79 @@
+/*
+Copyright (c) 2010-2014, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef PDFPLOT_H_
+#define PDFPLOT_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <rtabmap/utilite/UPlot.h>
+#include "opencv2/opencv.hpp"
+#include "rtabmap/core/Signature.h"
+
+namespace rtabmap {
+
+class RTABMAPGUI_EXP PdfPlotItem : public UPlotItem
+{
+public:
+	PdfPlotItem(float dataX, float dataY, float width, int childCount = -1);
+	virtual ~PdfPlotItem();
+
+	void setLikelihood(int id, float value, int childCount);
+	void setSignaturesRef(const QMap<int, Signature> * signaturesRef) {_signaturesRef = signaturesRef;}
+
+	float value() const {return this->data().y();}
+	int id() const {return this->data().x();}
+
+protected:
+	virtual void showDescription(bool shown);
+
+private:
+	QGraphicsPixmapItem * _img;
+	int _childCount;
+	const QMap<int, Signature> * _signaturesRef;
+	QGraphicsTextItem * _text;
+
+};
+
+class RTABMAPGUI_EXP PdfPlotCurve : public UPlotCurve
+{
+	Q_OBJECT
+
+public:
+	PdfPlotCurve(const QString & name, const QMap<int, Signature> * signaturesMapRef, QObject * parent = 0);
+	virtual ~PdfPlotCurve();
+
+	virtual void clear();
+	void setData(const QMap<int, float> & dataMap, const QMap<int, int> & weightsMap);
+
+private:
+	const QMap<int, Signature> * _signaturesMapRef;
+};
+
+}
+
+#endif /* PDFPLOT_H_ */

guilib/include/rtabmap/gui/ProgressDialog.h

@@ -0,0 +1,78 @@
+/*
+Copyright (c) 2010-2014, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef PROGRESSDIALOG_H_
+#define PROGRESSDIALOG_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <QDialog>
+
+class QLabel;
+class QTextEdit;
+class QProgressBar;
+class QPushButton;
+class QCheckBox;
+
+namespace rtabmap {
+
+class RTABMAPGUI_EXP ProgressDialog : public QDialog
+{
+	Q_OBJECT
+
+public:
+	ProgressDialog(QWidget *parent = 0, Qt::WindowFlags flags = 0);
+	virtual ~ProgressDialog();
+
+	void setEndMessage(const QString & message) {_endMessage = message;} // Message shown when the progress is finished
+	void setValue(int value);
+	int maximumSteps() const;
+	void setMaximumSteps(int steps);
+	void setAutoClose(bool on, int delayedClosingTimeMsec = -1);
+
+protected:
+	virtual void closeEvent(QCloseEvent * event);
+
+public slots:
+	void appendText(const QString & text ,const QColor & color = Qt::black);
+	void incrementStep();
+	void clear();
+	void resetProgress();
+
+private:
+	QLabel * _text;
+	QTextEdit * _detailedText;
+	QProgressBar * _progressBar;
+	QPushButton * _closeButton;
+	QCheckBox * _closeWhenDoneCheckBox;
+	QString _endMessage;
+	int _delayedClosingTime; // sec
+};
+
+}
+
+#endif /* PROGRESSDIALOG_H_ */

guilib/include/rtabmap/gui/StatsToolBox.h

@@ -0,0 +1,117 @@
+/*
+Copyright (c) 2010-2014, Mathieu Labbe - IntRoLab - Universite de Sherbrooke
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Universite de Sherbrooke nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef STATSTOOLBOX_H_
+#define STATSTOOLBOX_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <QWidget>
+#include <QtCore/QMap>
+
+class QToolButton;
+class QLabel;
+class QMenu;
+class QGridLayout;
+class QToolBox;
+
+namespace rtabmap {
+
+class RTABMAPGUI_EXP StatItem : public QWidget
+{
+	Q_OBJECT;
+
+public:
+	StatItem(const QString & name, const std::vector<float> & x, const std::vector<float> & y, const QString & unit = QString(), const QMenu * menu = 0, QGridLayout * grid = 0, QWidget * parent = 0);
+	virtual ~StatItem();
+	void setValue(float x, float y);
+	void setValues(const std::vector<float> & x, const std::vector<float> & y);
+	QString value() const;
+
+public slots:
+	void updateMenu(const QMenu * menu);
+
+signals:
+	void valueChanged(float, float);
+	void valuesChanged(const std::vector<float> &, const std::vector<float> &);
+	void plotRequested(const StatItem *, const QString &);
+
+private slots:
+	void preparePlotRequest();
+
+private:
+	void setupUi(QGridLayout * grid);
+
+private:
+	QToolButton * _button;
+	QLabel * _name;
+	QLabel * _value;
+	QLabel * _unit;
+	QMenu * _menu;
+};
+
+
+
+
+class RTABMAPGUI_EXP StatsToolBox : public QWidget
+{
+	Q_OBJECT;
+
+public:
+	StatsToolBox(QWidget * parent);
+	virtual ~StatsToolBox();
+
+	void getFiguresSetup(QList<int> & curvesPerFigure, QStringList & curveNames);
+	void addCurve(const QString & name, bool newFigure = true);
+	void setWorkingDirectory(const QString & workingDirectory);
+	void closeFigures();
+
+public slots:
+	void updateStat(const QString & statFullName, float x, float y);
+	void updateStat(const QString & statFullName, const std::vector<float> & x, const std::vector<float> & y);
+
+signals:
+	void menuChanged(const QMenu *);
+	void figuresSetupChanged();
+
+private slots:
+	void plot(const StatItem * stat, const QString & plotName = QString());
+	void figureDeleted(QObject * obj);
+
+protected:
+	virtual void contextMenuEvent(QContextMenuEvent * event);
+
+private:
+	QMenu * _plotMenu;
+	QToolBox * _statBox;
+	QString _workingDirectory;
+	QMap<QString, QWidget*> _figures;
+};
+
+}
+
+#endif /* STATSTOOLBOX_H_ */

guilib/include/rtabmap/utilite/UImageView.h

@@ -0,0 +1,98 @@
+/*
+ * ImageView.h
+ *
+ *  Created on: 2012-06-20
+ *      Author: mathieu
+ */
+
+#ifndef IMAGEVIEW_H_
+#define IMAGEVIEW_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <QWidget>
+#include <QtGui/QPainter>
+
+class RTABMAPGUI_EXP UImageView : public QWidget
+{
+	Q_OBJECT;
+public:
+	UImageView(QWidget * parent = 0) : QWidget(parent) {}
+	~UImageView() {}
+	void setBackgroundBrush(const QBrush & brush) {brush_ = brush;}
+
+public slots:
+	void setImage(const QImage & image)
+	{
+		pixmap_ = QPixmap::fromImage(image);
+		this->update();
+	}
+
+private:
+	void computeScaleOffsets(float & scale, float & offsetX, float & offsetY)
+	{
+		scale = 1.0f;
+		offsetX = 0.0f;
+		offsetY = 0.0f;
+
+		if(!pixmap_.isNull())
+		{
+			float w = pixmap_.width();
+			float h = pixmap_.height();
+			float widthRatio = float(this->rect().width()) / w;
+			float heightRatio = float(this->rect().height()) / h;
+
+			if(widthRatio < heightRatio)
+			{
+				scale = widthRatio;
+			}
+			else
+			{
+				scale = heightRatio;
+			}
+
+			w *= scale;
+			h *= scale;
+
+			if(w < this->rect().width())
+			{
+				offsetX = (this->rect().width() - w)/2.0f;
+			}
+			if(h < this->rect().height())
+			{
+				offsetY = (this->rect().height() - h)/2.0f;
+			}
+		}
+	}
+
+protected:
+	virtual void paintEvent(QPaintEvent *event)
+	{
+		QPainter painter(this);
+
+		//Draw background
+		painter.save();
+		painter.setBrush(brush_);
+		painter.drawRect(this->rect());
+		painter.restore();
+
+		if(!pixmap_.isNull())
+		{
+			painter.save();
+			//Scale
+			float ratio, offsetX, offsetY;
+			this->computeScaleOffsets(ratio, offsetX, offsetY);
+			painter.translate(offsetX, offsetY);
+			painter.scale(ratio, ratio);
+			painter.drawPixmap(QPoint(0,0), pixmap_);
+			painter.restore();
+		}
+	}
+
+private:
+	QPixmap pixmap_;
+	QBrush brush_;
+};
+
+
+#endif /* IMAGEVIEW_H_ */

guilib/include/rtabmap/utilite/UPlot.h

@@ -0,0 +1,628 @@
+/*
+*  utilite is a cross-platform library with
+*  useful utilities for fast and small developing.
+*  Copyright (C) 2010  Mathieu Labbe
+*
+*  utilite is free library: you can redistribute it and/or modify
+*  it under the terms of the GNU Lesser General Public License as published by
+*  the Free Software Foundation, either version 3 of the License, or
+*  (at your option) any later version.
+*
+*  utilite is distributed in the hope that it will be useful,
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*  GNU Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public License
+*  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef UPLOT_H_
+#define UPLOT_H_
+
+#include "rtabmap/gui/RtabmapGuiExp.h" // DLL export/import defines
+
+#include <QFrame>
+#include <QtCore/QList>
+#include <QtCore/QMap>
+#include <QtGui/QPen>
+#include <QtGui/QBrush>
+#include <QGraphicsEllipseItem>
+#include <QtCore/QMutex>
+#include <QLabel>
+#include <QPushButton>
+#include <QtCore/QTime>
+
+class QGraphicsView;
+class QGraphicsScene;
+class QGraphicsItem;
+class QFormLayout;
+
+/**
+ * UPlotItem is a QGraphicsEllipseItem and can be inherited to do custom behaviors
+ * on an hoverEnterEvent() for example.
+ */
+class RTABMAPGUI_EXP UPlotItem : public QGraphicsEllipseItem
+{
+public:
+	/**
+	 * Constructor 1.
+	 */
+	UPlotItem(qreal dataX, qreal dataY, qreal width=2);
+	/**
+	 * Constructor 2.
+	 */
+	UPlotItem(const QPointF & data, qreal width=2);
+	virtual ~UPlotItem();
+
+public:
+	void setNextItem(UPlotItem * nextItem);
+	void setPreviousItem(UPlotItem * previousItem);
+	void setData(const QPointF & data);
+
+	UPlotItem * nextItem() const {return _nextItem;}
+	UPlotItem * previousItem() const {return _previousItem;};
+	const QPointF & data() const {return _data;}
+
+protected:
+	virtual void hoverEnterEvent(QGraphicsSceneHoverEvent * event);
+	virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent * event);
+	virtual void focusInEvent(QFocusEvent * event);
+	virtual void focusOutEvent(QFocusEvent * event);
+	virtual void keyReleaseEvent(QKeyEvent * keyEvent);
+
+	virtual void showDescription(bool shown);
+private:
+	void init(qreal dataX, qreal dataY);
+
+private:
+	QPointF _data;
+	UPlotItem * _previousItem;
+	UPlotItem * _nextItem;
+	QGraphicsTextItem * _text;
+	QGraphicsRectItem * _textBackground;
+};
+
+class UPlot;
+
+/**
+ * UPlotCurve is a curve used to hold data shown in a UPlot.
+ */
+class RTABMAPGUI_EXP UPlotCurve : public QObject
+{
+	Q_OBJECT
+
+public:
+	/**
+	 * Constructor 1
+	 */
+	UPlotCurve(const QString & name, QObject * parent = 0);
+	/**
+	 * Constructor 2
+	 */
+	UPlotCurve(const QString & name, const QVector<UPlotItem *> data, QObject * parent = 0);
+	/**
+	 * Constructor 3
+	 */
+	UPlotCurve(const QString & name, const QVector<float> & x, const QVector<float> & y, QObject * parent = 0);
+	virtual ~UPlotCurve();
+
+	/**
+	 * Get pen.
+	 */
+	const QPen & pen() const {return _pen;}
+	/**
+	 * Get brush.
+	 */
+	const QBrush & brush() const {return _brush;}
+
+	/**
+	 * Set pen.
+	 */
+	void setPen(const QPen & pen);
+	/**
+	 * Set brush.
+	 */
+	void setBrush(const QBrush & brush);
+
+	void setItemsColor(const QColor & color);
+	QColor itemsColor() const  {return _itemsColor;}
+
+	/**
+	 * Get name.
+	 */
+	QString name() const {return _name;}
+	/**
+	 * Get the number of items in the curve (dot + line items).
+	 */
+	int itemsSize() const;
+	QPointF getItemData(int index);
+	bool isVisible() const {return _visible;}
+	void setData(QVector<UPlotItem*> & data); // take the ownership
+	void getData(QVector<float> & x, QVector<float> & y) const; // only call in Qt MainThread
+	void draw(QPainter * painter, const QRect & limits);
+
+public slots:
+	/**
+	 *
+	 * Clear curve's values.
+	 */
+	virtual void clear();
+	/**
+	 *
+	 * Show or hide the curve.
+	 */
+    void setVisible(bool visible);
+    /**
+     *
+	 * Set increment of the x values (when auto-increment is used).
+	 */
+    void setXIncrement(float increment);
+    /**
+     *
+	 * Set starting x value (when auto-increment is used).
+	 */
+    void setXStart(float val);
+    /**
+     *
+	 * Add a single value, using a custom UPlotItem.
+	 */
+	void addValue(UPlotItem * data); // take the ownership
+	/**
+	 *
+	 * Add a single value y, x is auto-incremented by the increment set with setXIncrement().
+	 * @see setXStart()
+	 */
+	void addValue(float y);
+	/**
+	 *
+	 * Add a single value y at x.
+	 */
+	void addValue(float x, float y);
+	/**
+	 *
+	 * For convenience...
+	 * Add a single value y, x is auto-incremented by the increment set with setXIncrement().
+	 * @see setXStart()
+	 */
+	void addValue(const QString & y);
+	/**
+	 *
+	 * For convenience...
+	 * Add multiple values, using custom UPlotItem.
+	 */
+	void addValues(QVector<UPlotItem *> & data); // take the ownership
+	/**
+	 *
+	 * Add multiple values y at x. Vectors must have the same size.
+	 */
+	void addValues(const QVector<float> & xs, const QVector<float> & ys);
+	/**
+	 *
+	 * Add multiple values y, x is auto-incremented by the increment set with setXIncrement().
+	 * @see setXStart()
+	 */
+	void addValues(const QVector<float> & ys);
+	void addValues(const QVector<int> & ys); // for convenience
+	/**
+	 *
+	 * Add multiple values y, x is auto-incremented by the increment set with setXIncrement().
+	 * @see setXStart()
+	 */
+	void addValues(const std::vector<float> & ys); // for convenience
+	void addValues(const std::vector<int> & ys); // for convenience
+
+	void setData(const QVector<float> & x, const QVector<float> & y);
+	void setData(const std::vector<float> & x, const std::vector<float> & y);
+	void setData(const QVector<float> & y);
+	void setData(const std::vector<float> & y);
+
+signals:
+	/**
+	 *
+	 *  emitted when data is changed.
+	 */
+	void dataChanged(const UPlotCurve *);
+
+protected:
+	friend class UPlot;
+	void attach(UPlot * plot);
+	void detach(UPlot * plot);
+	void updateMinMax();
+	const QVector<float> & getMinMax() const {return _minMax;}
+	int removeItem(int index);
+	void _addValue(UPlotItem * data);;
+	virtual bool isMinMaxValid() const {return _minMax.size();}
+	virtual void update(float scaleX, float scaleY, float offsetX, float offsetY, float xDir, float yDir, int maxItemsKept);
+	QList<QGraphicsItem *> _items;
+	UPlot * _plot;
+
+private:
+	void removeItem(UPlotItem * item);
+
+private:
+	QString _name;
+	QPen _pen;
+	QBrush _brush;
+	float _xIncrement;
+	float _xStart;
+	bool _visible;
+	bool _valuesShown;
+	QVector<float> _minMax; // minX, maxX, minY, maxY
+	QGraphicsRectItem * _rootItem;
+	QColor _itemsColor;
+};
+
+
+/**
+ * A special UPlotCurve that shows as a line at the specified value, spanning all the UPlot.
+ */
+class RTABMAPGUI_EXP UPlotCurveThreshold : public UPlotCurve
+{
+	Q_OBJECT
+
+public:
+	/**
+	 * Constructor.
+	 */
+	UPlotCurveThreshold(const QString & name, float thesholdValue, Qt::Orientation orientation = Qt::Horizontal, QObject * parent = 0);
+	virtual ~UPlotCurveThreshold();
+
+public slots:
+	/**
+	 * Set threshold value.
+	 */
+	void setThreshold(float threshold);
+	/**
+	 * Set orientation (Qt::Horizontal or Qt::Vertical).
+	 */
+	void setOrientation(Qt::Orientation orientation);
+
+protected:
+	friend class UPlot;
+	virtual void update(float scaleX, float scaleY, float offsetX, float offsetY, float xDir, float yDir, int maxItemsKept);
+	virtual bool isMinMaxValid() const {return false;}
+
+private:
+	Qt::Orientation _orientation;
+};
+
+/**
+ * The UPlot axis object.
+ */
+class RTABMAPGUI_EXP UPlotAxis : public QWidget
+{
+public:
+	/**
+	 * Constructor.
+	 */
+	UPlotAxis(Qt::Orientation orientation = Qt::Horizontal, float min=0, float max=1, QWidget * parent = 0);
+	virtual ~UPlotAxis();
+
+public:
+	/**
+	 * Set axis minimum and maximum values, compute the resulting
+	 * intervals depending on the size of the axis.
+	 */
+	void setAxis(float & min, float & max);
+	/**
+	 * Size of the border between the first line and the beginning of the widget.
+	 */
+	int border() const {return _border;}
+	/**
+	 * Interval step value.
+	 */
+	int step() const {return _step;}
+	/**
+	 * Number of intervals.
+	 */
+	int count() const {return _count;}
+	/**
+	 * Reverse the axis (for vertical :bottom->up, for horizontal :right->left)
+	 */
+	void setReversed(bool reversed); // Vertical :bottom->up, horizontal :right->left
+
+protected:
+	virtual void paintEvent(QPaintEvent * event);
+
+private:
+	Qt::Orientation _orientation;
+	float _min;
+	float _max;
+	int _count;
+	int _step;
+	bool _reversed;
+	int _gradMaxDigits;
+	int _border;
+};
+
+
+/**
+ * The UPlot legend item. Used internally by UPlot.
+ */
+class RTABMAPGUI_EXP UPlotLegendItem : public QPushButton
+{
+	Q_OBJECT
+
+public:
+	/**
+	 * Constructor.
+	 */
+	UPlotLegendItem(UPlotCurve * curve, QWidget * parent = 0);
+	virtual ~UPlotLegendItem();
+	const UPlotCurve * curve() const {return _curve;}
+	QPixmap createSymbol(const QPen & pen, const QBrush & brush);
+
+signals:
+	void legendItemRemoved(const UPlotCurve *);
+	void moveUpRequest(UPlotLegendItem *);
+	void moveDownRequest(UPlotLegendItem *);
+
+private slots:
+	void updateStdDev();
+
+protected:
+	virtual void contextMenuEvent(QContextMenuEvent * event);
+
+private:
+	UPlotCurve * _curve;
+	QMenu * _menu;
+	QAction * _aChangeText;
+	QAction * _aResetText;
+	QAction * _aChangeColor;
+	QAction * _aCopyToClipboard;
+	QAction * _aShowStdDev;
+	QAction * _aRemoveCurve;
+	QAction * _aMoveUp;
+	QAction * _aMoveDown;
+};
+
+/**
+ * The UPlot legend. Used internally by UPlot.
+ */
+class RTABMAPGUI_EXP UPlotLegend : public QWidget
+{
+	Q_OBJECT
+
+public:
+	/**
+	 * Constructor.
+	 */
+	UPlotLegend(QWidget * parent = 0);
+	virtual ~UPlotLegend();
+
+	void setFlat(bool on);
+	bool isFlat() const {return _flat;}
+	void addItem(UPlotCurve * curve);
+	bool remove(const UPlotCurve * curve);
+
+private slots:
+	void removeLegendItem(const UPlotCurve * curve);
+	void moveUp(UPlotLegendItem * item);
+	void moveDown(UPlotLegendItem * item);
+
+signals:
+	void legendItemRemoved(const UPlotCurve * curve);
+	void legendItemToggled(const UPlotCurve * curve, bool toggled);
+	void legendItemMoved(const UPlotCurve * curve, int);
+
+protected:
+	virtual void contextMenuEvent(QContextMenuEvent * event);
+
+private slots:
+	void redirectToggled(bool);
+
+private:
+	bool _flat;
+	QMenu * _menu;
+	QAction * _aUseFlatButtons;
+};
+
+
+/**
+ * Orientable QLabel. Inherit QLabel and let you to specify the orientation.
+ */
+class RTABMAPGUI_EXP UOrientableLabel : public QLabel
+{
+	Q_OBJECT
+
+public:
+	/**
+	 * Constructor.
+	 */
+	UOrientableLabel(const QString & text, Qt::Orientation orientation = Qt::Horizontal, QWidget * parent = 0);
+	virtual ~UOrientableLabel();
+	/**
+	 * Get orientation.
+	 */
+	Qt::Orientation orientation() const {return _orientation;}
+	/**
+	 * Set orientation (Qt::Vertical or Qt::Horizontal).
+	 */
+	void setOrientation(Qt::Orientation orientation);
+	QSize sizeHint() const;
+	QSize minimumSizeHint() const;
+protected:
+    virtual void paintEvent(QPaintEvent* event);
+private:
+    Qt::Orientation _orientation;
+};
+
+/**
+ * UPlot is a QWidget to create a plot like MATLAB, and
+ * incrementally add new values like a scope using Qt signals/slots.
+ * Many customizations can be done at runtime with the right-click menu.
+ * @image html UPlot.gif
+ * @image html UPlotMenu.png
+ *
+ * Example:
+ * @code
+ * #include "utilite/UPlot.h"
+ * #include <QApplication>
+ *
+ * int main(int argc, char * argv[])
+ * {
+ *	QApplication app(argc, argv);
+ *	UPlot plot;
+ *	UPlotCurve * curve = plot.addCurve("My curve");
+ *	float y[10] = {0, 1, 2, 3, -3, -2, -1, 0, 1, 2};
+ *	curve->addValues(std::vector<float>(y, y+10));
+ *	plot.showGrid(true);
+ *	plot.setGraphicsView(true);
+ *	plot.show();
+ *	app.exec();
+ * 	return 0;
+ * }
+ * @endcode
+ * @image html SimplePlot.tiff
+ *
+ *
+ */
+class RTABMAPGUI_EXP UPlot : public QWidget
+{
+	Q_OBJECT
+
+public:
+	/**
+	 * Constructor.
+	 */
+	UPlot(QWidget * parent = 0);
+	virtual ~UPlot();
+
+	/**
+	 * Add a curve. The returned curve doesn't need to be deallocated (UPlot keeps the ownership).
+	 */
+	UPlotCurve * addCurve(const QString & curveName, const QColor & color = QColor());
+	/**
+	 * Add a curve. Ownership is transferred to UPlot if ownershipTransferred=true.
+	 */
+	bool addCurve(UPlotCurve * curve, bool ownershipTransferred = true);
+	/**
+	 * Get all curve names.
+	 */
+	QStringList curveNames();
+	bool contains(const QString & curveName);
+	void removeCurves();
+	/**
+	 * Add a threshold to the plot.
+	 */
+	UPlotCurveThreshold * addThreshold(const QString & name, float value, Qt::Orientation orientation = Qt::Horizontal);
+	QString title() const {return this->objectName();}
+	QPen getRandomPenColored();
+	void showLegend(bool shown);
+	void showGrid(bool shown);
+	void showRefreshRate(bool shown);
+	void trackMouse(bool tracking);
+	void keepAllData(bool kept);
+	void showXAxis(bool shown) {_horizontalAxis->setVisible(shown);}
+	void showYAxis(bool shown) {_verticalAxis->setVisible(shown);}
+	void setVariableXAxis() {_fixedAxis[0] = false;}
+	void setVariableYAxis() {_fixedAxis[1] = false;}
+	void setFixedXAxis(float x1, float x2);
+	void setFixedYAxis(float y1, float y2);
+	void setMaxVisibleItems(int maxVisibleItems);
+	void setTitle(const QString & text);
+	void setXLabel(const QString & text);
+	void setYLabel(const QString & text, Qt::Orientation orientation = Qt::Vertical);
+	void setWorkingDirectory(const QString & workingDirectory);
+	void setGraphicsView(bool on);
+	void setBackgroundColor(const QColor & color);
+	QRectF sceneRect() const;
+
+public slots:
+	/**
+	 *
+	 * Remove a curve. If UPlot is the parent of the curve, the curve is deleted.
+	 */
+	void removeCurve(const UPlotCurve * curve);
+	void showCurve(const UPlotCurve * curve, bool shown);
+	void updateAxis(); //reset axis and recompute it with all curves minMax
+	/**
+	 *
+	 * Clear all curves' data.
+	 */
+	void clearData();
+
+private slots:
+	void captureScreen();
+	void updateAxis(const UPlotCurve * curve);
+	void moveCurve(const UPlotCurve *, int index);
+
+protected:
+	virtual void contextMenuEvent(QContextMenuEvent * event);
+	virtual void paintEvent(QPaintEvent * event);
+	virtual void resizeEvent(QResizeEvent * event);
+	virtual void mousePressEvent(QMouseEvent * event);
+	virtual void mouseMoveEvent(QMouseEvent * event);
+	virtual void mouseReleaseEvent(QMouseEvent * event);
+	virtual void mouseDoubleClickEvent(QMouseEvent * event);
+
+private:
+	friend class UPlotCurve;
+	void addItem(QGraphicsItem * item);
+
+private:
+	void replot(QPainter * painter);
+	bool updateAxis(float x, float y);
+	bool updateAxis(float x1, float x2, float y1, float y2);
+	void setupUi();
+	void createActions();
+	void createMenus();
+	void selectScreenCaptureFormat();
+	bool mousePosToValue(const QPoint & pos, float & x, float & y);
+
+private:
+	UPlotLegend * _legend;
+	QGraphicsView * _view;
+	QGraphicsItem * _sceneRoot;
+	QWidget * _graphicsViewHolder;
+	float _axisMaximums[4]; // {x1->x2, y1->y2}
+	bool _axisMaximumsSet[4]; // {x1->x2, y1->y2}
+	bool _fixedAxis[2];
+	UPlotAxis * _verticalAxis;
+	UPlotAxis * _horizontalAxis;
+	int _penStyleCount;
+	int _maxVisibleItems;
+	QList<QGraphicsLineItem *> hGridLines;
+	QList<QGraphicsLineItem *> vGridLines;
+	QList<UPlotCurve*> _curves;
+	QLabel * _title;
+	QLabel * _xLabel;
+	UOrientableLabel * _yLabel;
+	QLabel * _refreshRate;
+	QString _workingDirectory;
+	QTime _refreshIntervalTime;
+	int _lowestRefreshRate;
+	QTime _refreshStartTime;
+	QString _autoScreenCaptureFormat;
+	QPoint _mousePressedPos;
+	QPoint _mouseCurrentPos;
+	QColor _bgColor;
+
+	QMenu * _menu;
+	QAction * _aShowLegend;
+	QAction * _aShowGrid;
+	QAction * _aKeepAllData;
+	QAction * _aLimit0;
+	QAction * _aLimit10;
+	QAction * _aLimit50;
+	QAction * _aLimit100;
+	QAction * _aLimit500;
+	QAction * _aLimit1000;
+	QAction * _aLimitCustom;
+	QAction * _aAddVerticalLine;
+	QAction * _aAddHorizontalLine;
+	QAction * _aChangeTitle;
+	QAction * _aChangeXLabel;
+	QAction * _aChangeYLabel;
+	QAction * _aChangeBackgroundColor;
+	QAction * _aYLabelVertical;
+	QAction * _aShowRefreshRate;
+	QAction * _aMouseTracking;
+	QAction * _aSaveFigure;
+	QAction * _aAutoScreenCapture;
+	QAction * _aClearData;
+	QAction * _aGraphicsView;
+};
+
+#endif /* UPLOT_H_ */