/*!
 * \file AwesomeImgViewer.cpp
 * \date 2018/06/26
 *
 * \author Lin, Chi
 * Contact: lin.chi@hzleaper.com
 *
 *
 * \note
*/

#include "AwesomeImgViewer.h"
#include "AwesomeRoi.h"
#include "qtUtils.h"
#include <QScrollBar>
#include <QMouseEvent>
#include <QApplication>

AwesomeImgViewer::AwesomeImgViewer(QWidget* parent)
	: lpImgViewer(parent), mOpState(Reserved), mRoiCounter(0), mRestrictMode(false), mHasImg(false),
	mpMaskImgItem(nullptr), mpMaskImg(nullptr)
{
	setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
	setRenderHint(QPainter::HighQualityAntialiasing);
}

QGraphicsPixmapItem* AwesomeImgViewer::setImg(QImage& img)
{
	QGraphicsPixmapItem* ret = lpImgViewer::setImg(img);
	mHasImg = true;
	mpImgItem->setFlag(QGraphicsItem::ItemIsMovable, true);
	
	refreshSenseRng();

	// refresh restrict area
	if (mRestrictMode) {
		for(QMap<QString, AwesomeRoiBase*>::iterator it = mMapRoiItems.begin();it!=mMapRoiItems.end();++it)
		{
			(*it)->setRestricArea(mpImgItem->boundingRect().adjusted(1, 1, -1, -1));
		}
	}

	return ret;
}

QGraphicsPixmapItem* AwesomeImgViewer::setMaskImg(QImage& maskImg)
{
	if (mpMaskImg)
		delete mpMaskImg;
	mpMaskImg = new QImage(maskImg);

	if (!mpMaskImgItem)
		mpMaskImgItem = scene()->addPixmap(QPixmap::fromImage(maskImg, Qt::NoFormatConversion));
	else
		mpMaskImgItem->setPixmap(QPixmap::fromImage(maskImg, Qt::NoFormatConversion));

	mpMaskImgItem->setParentItem(mpImgItem);
	mpMaskImgItem->setOffset(mpImgItem->offset());

	return mpMaskImgItem;
}

void AwesomeImgViewer::addRectRoi(
	const QPointF& pos, 
	const QSizeF& size, 
	double angle,
	const QString& label, 
	const QColor& color, 
	const QColor& activeColor)
{
	QPointF offset = mpImgItem ? mpImgItem->offset() : QPointF();

	AwesomeRectRoi* rectRoi = new AwesomeRectRoi(&mCommonProps, QSizeF(abs(size.width()), abs(size.height())), mpImgItem);
	if (size.width() < 0 || size.height() < 0) 
		rectRoi->setRoiSift(true);
	rectRoi->setPos(pos + offset);
	addRoiCommon(rectRoi, label, color, activeColor);
	rectRoi->getGraphicsItem()->setRotation(angle); // should be the last one
	//rectRoi->setRoiPicked(false);
}

void AwesomeImgViewer::addAffineRoi(const QPointF& tl, const QPointF& tr, const QPointF& br, const QPointF& bl,
	const QString& label, const QColor& color, const QColor& activeColor)
{
	AffineRect ar = {tl, tr, br, bl};
	AwesomeAffineRoi* affineRoi = new AwesomeAffineRoi(&mCommonProps, ar, mpImgItem);
	addRoiCommon(affineRoi, label, color, activeColor);
}

void AwesomeImgViewer::addPointRoi(const QPointF& pos, double r, double angle,
	const QString& label, const QColor& color, const QColor& activeColor)
{
	AwesomePointRoi* pointRoi = new AwesomePointRoi(&mCommonProps, abs(r), mpImgItem);
	if (r < 0) pointRoi->setRoiSift(true);
	pointRoi->setPos(pos);
	if (angle != DBL_MAX)
		pointRoi->setAngle(angle);
	addRoiCommon(pointRoi, label, color, activeColor);
}

void AwesomeImgViewer::mousePressEvent(QMouseEvent* e)
{
	setCursor(Qt::PointingHandCursor);
	{
		if (mOpState == Reserved && mHasImg) {
			QPoint curpos = (mpImgItem->mapFromScene(this->mapToScene(e->pos())) +
				QPointF(mImgOriSize.width() / 2.0, mImgOriSize.height() / 2.0) + QPointF(-0.5, -0.5)).toPoint();
			if (curpos.x() >= 0 && curpos.x() < mImgOriSize.width() && curpos.y() >= 0 && curpos.y() < mImgOriSize.height()) {
				// report pixel clicked when it's inside the image
				emit pixelClicked(curpos);
			}
		}
	}
	if (mOpState == Prepared) {
		addMousePos2AddingPnt(e, 0);
		mOpState = Adding;
		clearSelection();
	}
	else if (mOpState == Picking && mHasImg) {
		QPoint curpos = (mpImgItem->mapFromScene(this->mapToScene(e->pos())) +
			QPointF(mImgOriSize.width() / 2.0, mImgOriSize.height() / 2.0) + QPointF(-0.5, -0.5)).toPoint();
		if (curpos.x() >= 0 && curpos.x() < mImgOriSize.width() && curpos.y() >= 0 && curpos.y() < mImgOriSize.height()) {
			// report pixel clicked when it's inside the image
			emit pixelClicked(curpos);
		}
	}
	else {
		// clear selection if click on empty place
		QPointF mpos = getMousePos(e);
		bool doClear = true;
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			QGraphicsItem* pItem = (*roiItem)->getGraphicsItem();
			if ((*roiItem)->senseRect().contains(pItem->mapFromParent(mpos))) {
				doClear = false;
				if (mCommonProps.siftMode) {
					setCursor(Qt::PointingHandCursor);
					mCommonProps.isSifting = (*roiItem)->isRoiPicked() ? -1 : 1;
					(*roiItem)->setRoiPicked(!(*roiItem)->isRoiPicked());
				}
				break;
			}
		}
		if (doClear)
			clearSelection();

		lpImgViewer::mousePressEvent(e);
	}
}

void AwesomeImgViewer::mouseMoveEvent(QMouseEvent* e)
{
	if (mOpState == Adding) {
		addMousePos2AddingPnt(e, 1);
	}
	else if (mCommonProps.isSifting != 0) {
		QPointF mpos = getMousePos(e);
		bool doPicked = mCommonProps.isSifting > 0;
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			QGraphicsItem* gItem = (*roiItem)->getGraphicsItem();
			if ((*roiItem)->isRoiPicked() != doPicked && gItem->boundingRect().contains(gItem->mapFromParent(mpos))) {
				(*roiItem)->setRoiPicked(doPicked);
			}
		}
	}
	else {
		lpImgViewer::mouseMoveEvent(e);
	}
}

void AwesomeImgViewer::mouseReleaseEvent(QMouseEvent* e)
{
	if (mOpState == Adding) {
		addMousePos2AddingPnt(e, 1);
		if (mAddingType == AwsRoiRect)
			addRectRoi((mAddingPnts[0] + mAddingPnts[1]) / 2,
				QSizeF(abs(mAddingPnts[0].x() - mAddingPnts[1].x()), abs(mAddingPnts[0].y() - mAddingPnts[1].y())));
		else if (mAddingType == AwsRoiAffine) {
			qreal l = std::min<qreal>(mAddingPnts[0].x(), mAddingPnts[1].x());
			qreal r = std::max<qreal>(mAddingPnts[0].x(), mAddingPnts[1].x());
			qreal t = std::min<qreal>(mAddingPnts[0].y(), mAddingPnts[1].y());
			qreal b = std::max<qreal>(mAddingPnts[0].y(), mAddingPnts[1].y());
			addAffineRoi(QPointF(l, t), QPointF(r, t), QPointF(r, b), QPointF(l, b));
		}
		else if (mAddingType == AwsRoiPoint) {
			QPointF away = getMousePos(e) - mAddingPnts.front();
			if (abs(away.x()) + abs(away.y()) < 4) {
				addPointRoi(mAddingPnts.front(), 2);
			}
		}
		resetAdding();
	}
	else if (mCommonProps.isSifting != 0) {
		setCursor(Qt::ArrowCursor);
		mCommonProps.isSifting = 0;
	}
	else if (mOpState != Picking) {
		setIsAddingRoi(false);
	}

	lpImgViewer::mouseReleaseEvent(e);
}

void AwesomeImgViewer::wheelEvent(QWheelEvent* e)
{
	lpImgViewer::wheelEvent(e);
	refreshSenseRng();
}

void AwesomeImgViewer::keyPressEvent(QKeyEvent* e)
{
	if (e->key() == Qt::Key_A && e->modifiers() == Qt::ControlModifier) {
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			(*roiItem)->setRoiPicked(true);
		}
	}
	else if (e->key() == Qt::Key_Delete) {
		onBtnDeleteClicked();
	}
	else if (e->key() == Qt::Key_Insert) {

	}
	else if (e->key() == Qt::Key_Escape && mOpState != Reserved) {
		resetAdding();
	}
	else {
		lpImgViewer::keyPressEvent(e);
	}
}

void AwesomeImgViewer::getAllRoiVertex(QVector<AwesomeRoiInfo>& allRoiInfo)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		AwesomeRoiInfo* pRoiInfo = allRoiInfo.insert(allRoiInfo.end(), AwesomeRoiInfo());
		getRoiInfo((*roiItem), *pRoiInfo);
	}
}

void AwesomeImgViewer::getDetectVertex(AwesomeRoiInfo& detectRoiInfo)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		if ((*roiItem)->objectName().contains("Detect"))
		{
			getRoiInfo((*roiItem), detectRoiInfo);
			break;
		}
	}
}

void AwesomeImgViewer::getAllFilterVertex(QList<AwesomeRoiInfo>& allFilterRoiInfo)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		if ((*roiItem)->objectName().contains("Detect"))
			continue;
		AwesomeRoiInfo roiInfo;
		getRoiInfo((*roiItem), roiInfo);
		allFilterRoiInfo.append(roiInfo);
	}
}


QMap<QString, QVector<QPoint>> AwesomeImgViewer::getAllFilterVectorMap()
{
	QMap<QString, QVector<QPoint>> rlt;
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		QString strID = (*roiItem)->objectName();
		if (strID.contains("Detect"))
			continue;
		
		AwesomeRoiInfo roiInfo;
		getRoiInfo((*roiItem), roiInfo);
		QVector<QPoint> polygon;
		for (int i = 0; i < roiInfo.vertex.size(); i++) {
			polygon.append(roiInfo.vertex.at(i).toPoint());
		}
		rlt.insert(strID, polygon);
	}
	return rlt;
}

QStringList AwesomeImgViewer::getAllSiftRois() const
{
	QStringList allSiftRoiNames;
// 	foreach(AwesomeRoiBase* roiItem, mRoiItems) {
// 		if (roiItem->isRoiSift()) {
// 			allSiftRoiNames.append(roiItem->getLabel());
// 		}
// 	}
	return allSiftRoiNames;
}

void AwesomeImgViewer::enableSingleDetectRoi(bool enable, const QPointF& centerpos, const QSizeF& size, qreal angle, const QString& label)
{
	enableSingleMode(enable);//清除所有ROI
	if (enable) {
		if (centerpos.isNull() || size.isEmpty()) {
			QPixmap img = mpImgItem->pixmap();
			int w = std::max<int>(std::max<int>(100, img.width() / 5), std::max<int>(100, img.height() / 5));
			addRectRoi(QPointF(w / 2. - 1, w / 2. - 1), QSizeF(w, w), angle, label, QColor(0, 200,0), QColor(0, 200, 111));
		}
		else {
			addRectRoi(centerpos, size, angle, label, QColor(0, 200, 0), QColor(0, 200, 111));
		}
	}
	m_detectRoiAngle = angle;
}

void AwesomeImgViewer::enableSingleAffineRoiMode(bool enable,
	const QPointF& tl, const QPointF& tr, const QPointF& br, const QPointF& bl, const QString& label)
{
	enableSingleMode(enable);
	if (enable) {
		QPixmap img = mpImgItem->pixmap();
		qreal x = img.width() / 2., y = img.height() / 2.;
		addAffineRoi(tl.isNull() ? QPointF(-x, -y) : tl, tr.isNull() ? QPointF(x, -y) : tr,
			br.isNull() ? QPointF(x, y) : br, bl.isNull() ? QPointF(-x, y) : bl, label);
	}
}

void AwesomeImgViewer::changeRoiRect(const QPointF& pos /*= QPointF()*/, const QSizeF& size /*= QSizeF()*/, const QString& label /*= ""*/)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator it = mMapRoiItems.begin(); it != mMapRoiItems.end(); ++it)
	{
		if (it.key().contains("Detect"))
		{
			((AwesomeRectRoi*)*it)->setPos(pos);
			((AwesomeRectRoi*)*it)->setRealRect(QRectF(-size.width() / 2, -size.height() / 2, size.width(), size.height()));
			break;
		}
	}
}

void AwesomeImgViewer::changeFilterRoiRect(const QPointF& pos /*= QPointF()*/, const QSizeF& size /*= QSizeF()*/, const QString& strName /*= ""*/)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator it = mMapRoiItems.begin(); it != mMapRoiItems.end(); ++it)
	{
		if (it.key() == strName)
		{
			((AwesomeRectRoi*)*it)->setPos(pos);
			((AwesomeRectRoi*)*it)->setRealRect(QRectF(-size.width() / 2, -size.height() / 2, size.width(), size.height()));
			break;
		}
	}
}

QStringList AwesomeImgViewer::getAllFilterNames()
{
	QStringList filterNames;
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		QString strObjName = (*roiItem)->objectName();
		if (strObjName.contains("Detect"))
			continue;
		filterNames.append(strObjName);
	}
	return filterNames;
}

void AwesomeImgViewer::setFilterROISelect(QString strName)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		QString strN = (*roiItem)->objectName();
		if(strName == strN)
			(*roiItem)->setRoiPicked(true);
		else
			(*roiItem)->setRoiPicked(false);
	}
}

void AwesomeImgViewer::changeRoiRectAngle(qreal angle /*= 0*/, const QString& label /*= ""*/)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator it = mMapRoiItems.begin(); it != mMapRoiItems.end(); ++it)
	{
		if (it.key().contains("Detect"))
		{
			((AwesomeRectRoi*)*it)->getGraphicsItem()->setRotation(angle);
			m_detectRoiAngle = angle;
		}
		else {
			((AwesomeRectRoi*)*it)->getGraphicsItem()->setRotation(angle);
		}
	}
}

void AwesomeImgViewer::enableSiftMode(bool enable)
{
	mCommonProps.siftMode = enable;
	if (mCommonProps.siftMode) {
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			(*roiItem)->getGraphicsItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
		}
	}
}

void AwesomeImgViewer::enablePickMode(bool enable)
{
	if (!mHasImg) return;
	
	if (enable) {
		mpImgItem->setFlag(QGraphicsItem::ItemIsMovable, false);
		static QPixmap pipettePixmap(":/cursor_pipette.png");
		setCursor(QCursor(pipettePixmap, 4, 26));
		mOpState = OpState::Picking;
	}
	else {
		mpImgItem->setFlag(QGraphicsItem::ItemIsMovable, true);
		setCursor(Qt::ArrowCursor);
		mOpState = OpState::Reserved;
	}
}

void AwesomeImgViewer::setLabelVisible(bool visible)
{
	if (visible) {
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			(*roiItem)->showLabel();
		}
	}
	else {
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			(*roiItem)->hideLabel();
		}
	}
}

void AwesomeImgViewer::enableRoiCtrl(bool enable, const QList<AwesomeRoiType>& enableRoiTypes)
{
// 	ui->wgtRoiCtrl->setVisible(enable);
// 	mpCtrlBar->adjustSize();
// 	if (enableRoiTypes.size() > 0) {
// 		int c = ui->comboRoiType->count();
// 		for (int i = c - 1; i >= 0; --i) {
// 			int t = ui->comboRoiType->itemData(i).toInt();
// 			if (enableRoiTypes.indexOf(static_cast<AwesomeRoiType>(t)) < 0) {
// 				ui->comboRoiType->removeItem(i);
// 			}
// 		}
// 	}
}

void AwesomeImgViewer::clear()
{
	lpImgViewer::clear();
	mMapRoiItems.clear();
	mAddingPnts.clear();
	mAddingType = AwsRoiReserved;

	// set null image to init the root image item
	QImage img_root = QImage(":/imagena.png");
	setImg(img_root);

	mpAddingPath = new QGraphicsPathItem(mpImgItem);
	mpAddingPath->setPen(QPen(QColor(20, 20, 20), 1, Qt::DashLine));

	mHasImg = false;
	mpImgItem->setFlag(QGraphicsItem::ItemIsMovable, false); // disable moving placeholder image

	mpMaskImgItem = nullptr;
	if (mpMaskImg) {
		delete mpMaskImg;
		mpMaskImg = nullptr;
	}
}

void AwesomeImgViewer::onResetView()
{
	scaleImg2(1.0);
	setIsAutoResetTransform(true);
}

void AwesomeImgViewer::onSetScale(qreal val)
{
	scaleImg2(1.0);
}

void AwesomeImgViewer::onClearAllROI()
{
	enableSingleMode(true);
}

void AwesomeImgViewer::onAddFilterROI(const QPointF& pos /*= QPointF()*/, const QSizeF& size /*= QSizeF()*/, qreal angle /*= 0*/, const QString& label /*= ""*/)
{
	angle = m_detectRoiAngle;
	if (pos.isNull() || size.isEmpty()) {
		QPixmap img = mpImgItem->pixmap();
		int w = std::min<int>(std::max<int>(50, img.width()), std::max<int>(50, img.height()));
		addRectRoi(QPointF(w / 2. - 1, w / 2. - 1), QSizeF(w, w), angle, label, QColor(230, 200, 0), QColor(230, 200, 111));
	}
	else {
		addRectRoi(pos, size, angle, label, QColor(230, 200, 0), QColor(230, 200, 111));
	}
}

void AwesomeImgViewer::onClearFilterROIs(const QString& label /*= "Filter"*/)
{
	QStringList lstName;
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		QString strName = (*roiItem)->objectName();
		if (!strName.contains("Filter"))
			continue;
		scene()->removeItem((*roiItem)->getGraphicsItem());
		delete (*roiItem);
		lstName.append(strName);
	}
	foreach(QString var, lstName)
	{
		mMapRoiItems.remove(var);
	}
}

void AwesomeImgViewer::onBtnAddClicked(bool isChecked)
{
	// no add op in single roi mode
	if (mCommonProps.singleRoiMode) return;

	if (mCommonProps.siftMode) {
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			if ((*roiItem)->isRoiPicked()) {
				(*roiItem)->setRoiSift(false);
				(*roiItem)->setRoiPicked(false); // un-pick
				(*roiItem)->setRoiActive(false); // un-active
			}
		}
	}
	else
	{
// 		mAddingType = static_cast<AwesomeRoiType>(ui->comboRoiType->currentData().toInt());
// 		if (mAddingType <= AwsRoiReserved || mAddingType >= AwsRoiLast) return;
// 		setIsAddingRoi(isChecked);
	}
}

void AwesomeImgViewer::onBtnDeleteClicked()
{
	// no delete op in single roi mode
// 	if (mCommonProps.singleRoiMode || mCommonProps.siftMode) return;
// 
// 	for (int i = mRoiItems.size() - 1; i >= 0; i--) {
// 		AwesomeRoiBase* roiItem = mRoiItems[i];
// 		if (roiItem->isRoiPicked()) {
// 			mRoiItems.remove(i);
// 			scene()->removeItem(roiItem->getGraphicsItem());
// 			delete roiItem;
// 		}
// 	}
// 	unsetCursor();
}

void AwesomeImgViewer::onBtnSubClicked(bool isChecked)
{
	// no add op in single roi mode
// 	if (mCommonProps.singleRoiMode) return;
// 
// 	if (mCommonProps.siftMode) {
// 		foreach(AwesomeRoiBase* roiItem, mRoiItems) {
// 			if (roiItem->isRoiPicked()) {
// 				roiItem->setRoiSift(true);
// 				roiItem->setRoiPicked(false); // un-pick
// 				roiItem->setRoiActive(false); // un-active
// 			}
// 		}
// 	}
}

void AwesomeImgViewer::onBtnHideRoiPressed()
{
	// hide all roi
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		(*roiItem)->getGraphicsItem()->hide();
	}
}

void AwesomeImgViewer::onBtnHideRoiReleased()
{
	// show all roi
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		(*roiItem)->getGraphicsItem()->show();
	}
}

void AwesomeImgViewer::onRoiSelected(bool isSelected)
{
	if (isSelected && mCommonProps.isSifting == 0) {
		Qt::KeyboardModifiers k = QApplication::queryKeyboardModifiers();
		if (!k.testFlag(Qt::ShiftModifier) && !k.testFlag(Qt::ControlModifier)) {
			// not multi-select, clear other selection
			clearSelection(sender());
		}
	}
}

void AwesomeImgViewer::onRoiChanged()
{
	AwesomeRoiInfo roiInfo;
	AwesomeRoiBase* roiItem = qobject_cast<AwesomeRoiBase*>(sender());
	if (roiItem&&roiItem->objectName().contains("Detect")) {
		getRoiInfo(roiItem, roiInfo);
		emit roiChanged(roiInfo);
	}
	else
	{
		getRoiInfo(roiItem, roiInfo);
		QString strObj = roiItem->objectName();
		emit filterroiChanged(roiInfo, strObj);
	}
}

void AwesomeImgViewer::onRoiLockIng()
{
	AwesomeRoiBase* roiItem = qobject_cast<AwesomeRoiBase*>(sender());
	QString strName = roiItem->objectName();
	emit roiLockIng(strName);
}

void AwesomeImgViewer::addRoiCommon(
	AwesomeRoiBase* roiItem,
	const QString& label, 
	const QColor& color, 
	const QColor& activeColor
)
{
	if (color.isValid()) 
		roiItem->setNormalColor(color);
	else if (mDefaultColor.isValid()) 
		roiItem->setNormalColor(mDefaultColor);
	if (activeColor.isValid()) 
		roiItem->setActiveColor(activeColor);
	else if (mDefaultActiveColor.isValid()) 
		roiItem->setActiveColor(mDefaultActiveColor);

	mRoiCounter++;
	if (label.isNull())
		roiItem->setLabel(QString::number(mRoiCounter));
	else 
		roiItem->setLabel(label);
	QString strObjname = QString("%1").arg(label);
	roiItem->setObjectName(strObjname);
	if (mRestrictMode)
		roiItem->setRestricArea(mpImgItem->boundingRect().adjusted(1, 1, -1, -1));

	connect(roiItem, SIGNAL(toggledPick(bool)), this, SLOT(onRoiSelected(bool)));
	connect(roiItem, SIGNAL(roiChanged()), this, SLOT(onRoiChanged()));
	connect(roiItem, SIGNAL(roiLockIng()), this, SLOT(onRoiLockIng()));

	mMapRoiItems.insert(strObjname, roiItem);
}

void AwesomeImgViewer::setIsAddingRoi(bool isAddingRoi)
{
	mOpState = isAddingRoi ? Prepared : Reserved;
	if (isAddingRoi)
	{
		setCursor(Qt::CrossCursor);
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			QGraphicsItem* gItem = (*roiItem)->getGraphicsItem();
			gItem->setEnabled(false);
		}
	}
	else
	{
		setCursor(Qt::ArrowCursor);
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			QGraphicsItem* gItem = (*roiItem)->getGraphicsItem();
			gItem->setEnabled(true);
		}
	}
}

QPointF AwesomeImgViewer::getMousePos(QMouseEvent* e)
{
	if (mpImgItem)
		return mpImgItem->mapFromScene(this->mapToScene(e->pos()));
	return QPointF();
}

void AwesomeImgViewer::addMousePos2AddingPnt(QMouseEvent* e, int idx)
{
	if (mAddingPnts.size() <= idx || idx == -1)
		mAddingPnts.append(getMousePos(e));
	else
		mAddingPnts[idx] = getMousePos(e);
	updateAddingPath();
}

void AwesomeImgViewer::updateAddingPath()
{
	if (mAddingPnts.size() == 0)
		mpAddingPath->setPath(QPainterPath());
	else
	{
		QPainterPath p;
		if ((mAddingType == AwsRoiRect || mAddingType == AwsRoiAffine) && mAddingPnts.size() >= 2) {
			p.addRect(std::min<qreal>(mAddingPnts[0].x(), mAddingPnts[1].x()),
				std::min<qreal>(mAddingPnts[0].y(), mAddingPnts[1].y()),
				abs(mAddingPnts[0].x() - mAddingPnts[1].x()),
				abs(mAddingPnts[0].y() - mAddingPnts[1].y()));
		}
		else if (mAddingType == AwsRoiPoint && mAddingPnts.size() >= 1) {
			p.addEllipse(mAddingPnts.front(), 2, 2);
		}
		mpAddingPath->setPath(p);
	}
}

void AwesomeImgViewer::resetAdding()
{
	mOpState = Reserved;
	mAddingPnts.clear();
	updateAddingPath();
}

void AwesomeImgViewer::clearSelection(QObject* excludeObj)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		if ((*roiItem) != excludeObj)
			(*roiItem)->setRoiPicked(false);
	}
}

void AwesomeImgViewer::getRoiOnImg(AwesomeRoiBase* roiItem, QList<QPointF>& roiOnImg)
{
	const QList<QPointF>& pnts = roiItem->getVertex();
	QGraphicsItem* gItem = roiItem->getGraphicsItem();
	foreach(const QPointF& pnt, pnts) {
		roiOnImg.append(gItem->mapToParent(pnt) - mpImgItem->offset()); // roi item's parent is the image.
	}
}

void AwesomeImgViewer::getRoiInfo(AwesomeRoiBase* roiItem, AwesomeRoiInfo& roiInfo)
{
	roiInfo.type = roiItem->getRoiType();
	roiInfo.label = roiItem->getLabel();
	getRoiOnImg(roiItem, roiInfo.vertex);
}

void AwesomeImgViewer::enableSingleMode(bool enable)
{
	mCommonProps.singleRoiMode = enable;
	if (enable) {
		// delete all roi
		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			scene()->removeItem((*roiItem)->getGraphicsItem());
			delete (*roiItem);
		}
		mMapRoiItems.clear();
	}
}

float AwesomeImgViewer::getSenseRng()
{
	QPointF a = mapToScene(QPoint(0, 15));
	QPointF b = mapToScene(QPoint(0, 0));
	return abs(a.y() - b.y());
}

void AwesomeImgViewer::refreshSenseRng()
{
	if (mpImgItem) {
		mCommonProps.senseRng = getSenseRng();
		mCommonProps.labelFont = QApplication::font();
		QFontMetricsF metrics(mCommonProps.labelFont);
		float factor = (mCommonProps.senseRng - 0.5) / metrics.height();
		mCommonProps.labelFont.setPointSizeF(mCommonProps.labelFont.pointSizeF() * factor);

		for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
		{
			(*roiItem)->updateSenseRng();
		}
	}
}

void AwesomeImgViewer::setLockAll(bool bLock)
{
	for (QMap<QString, AwesomeRoiBase*>::iterator roiItem = mMapRoiItems.begin(); roiItem != mMapRoiItems.end(); ++roiItem)
	{
		(*roiItem)->onSetLock(bLock);
	}
}