#include "lpImgViewer.h"
#include <QResizeEvent>
#include <QWheelEvent>
#include <QRectF>
#include <iostream>
#include <QtDebug>

lpImgViewer::lpImgViewer(QWidget* parent /*= 0*/)
    : QGraphicsView(parent), mpImgItem(NULL), mpInfoLabel(NULL), mpImg(NULL), m_scale(1.0), mMinScaleThre(0.01),
    mIsFixedSizeScale(false), mFixedSizeScale(1.0), mImgScaleFunc(NULL), mIsAutoResetTransform(false)
{
    QGraphicsScene* lpScene = new QGraphicsScene;
    setScene(lpScene);
    setResizeAnchor(QGraphicsView::AnchorUnderMouse);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
}

lpImgViewer::lpImgViewer(QGraphicsScene *scene, QWidget *parent /*= 0*/)
    : QGraphicsView(scene, parent), mpImgItem(NULL), mpInfoLabel(NULL), mpImg(NULL), m_scale(1.0),
    mIsFixedSizeScale(false), mFixedSizeScale(1.0), mImgScaleFunc(NULL), mIsAutoResetTransform(false)
{
    setResizeAnchor(QGraphicsView::AnchorUnderMouse);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
}

void lpImgViewer::setInitScale(qreal val)
{
    scaleImg2(val);
}

QGraphicsPixmapItem* lpImgViewer::setImg(QImage& img)
{
	scene()->setBackgroundBrush(Qt::darkGray);
	
    if (mpImg)
        delete mpImg;
    mpImg = new QImage(img);
	
	if (!mpImgItem)
	{
		mpImgItem = scene()->addPixmap(QPixmap::fromImage(img, Qt::NoFormatConversion));
		
	}
    else
        mpImgItem->setPixmap(QPixmap::fromImage(img, Qt::NoFormatConversion));
	QPointF mpos = mpImgItem->pos();
	if (mpos.x() == 0 && mpos.y() == 0)
	{
		mpImgItem->setPos(scene()->width() / 2, scene()->height() / 2);
	}
    mpImgItem->setOffset(-img.width() / 2.0, -img.height() / 2.0);
	scene()->setSceneRect(QRectF(0, 0, img.width(), img.height()));
    mImgOriSize = img.size();
    mMinScaleThre = 1.0 / std::min(mImgOriSize.width(), mImgOriSize.height());
    //qreal scale = std::min((qreal)size().width() / img.width(), (qreal)size().height() / img.height());

    if (isAutoResetTransform())
    {
        mpImgItem->setPos(0, 0);
        qreal scale = 1.0f;
        scaleImg2(scale);
        this->centerOn(0, 0);
    }
    mpImgItem->setFlags(QGraphicsItem::ItemIsMovable);

    return mpImgItem;
}

void lpImgViewer::setResetCenter()
{
	if(mpImgItem)
		mpImgItem->setPos(scene()->width() /2, scene()->height()/2);
}

void lpImgViewer::wheelEvent(QWheelEvent *evt)
{
    if (mpImgItem)
    {
        qreal numDegrees = evt->angleDelta().y() / 120;

        if (!isFixedSizeScale())
        {
            qreal newScale = transform().m11();
            if (numDegrees > 0)
                newScale *= std::pow(1.1, numDegrees);
            else if (numDegrees < 0)
                newScale *= std::pow(0.9, -numDegrees);

            mpImgItem->setTransformOriginPoint(0, 0);
            scaleImg2(newScale);
			emit sgImageScale(newScale);
        }
        else
        {
            qreal newScale = fixedSizeScale();
            if (numDegrees > 0)
                newScale *= std::pow(1.2, numDegrees);
            else if (numDegrees < 0)
                newScale *= std::pow(0.8, -numDegrees);

            if (newScale > 1.0) 
				newScale = 1.0;
            if (newScale < mMinScaleThre) 
				newScale = mMinScaleThre;

            setFixedSizeScale(newScale);

            scaleImageWithFixedViewSize();
        }
    }
}

void lpImgViewer::mouseMoveEvent(QMouseEvent *evt)
{
    if (mpImgItem)
    {
		QPoint curpos = (mpImgItem->mapFromScene(this->mapToScene(evt->pos())) +
			QPointF(mImgOriSize.width() / 2.0, mImgOriSize.height() / 2.0)+ QPointF(-0.5, -0.5)).toPoint();

        if (mpInfoLabel)//��ʾ����ֵ
            selectPixel(curpos);
        else
            emit pixelSelected(curpos);
    }

    if (mpImgItem && mpImgItem->isSelected())
    {
        QPointF pos = mpImgItem->scenePos();
        qDebug() << pos;
        emit imgMoved(pos);
    }

    QGraphicsView::mouseMoveEvent(evt);
}

void lpImgViewer::resizeEvent(QResizeEvent* evt)
{
    QGraphicsView::resizeEvent(evt);
}

void lpImgViewer::mouseReleaseEvent(QMouseEvent *evt)
{
    QGraphicsView::mouseReleaseEvent(evt);
    if (mpImgItem)
        mpImgItem->setSelected(false);
}

void lpImgViewer::closeEvent(QCloseEvent *evt)
{
    deleteLater();
}

void lpImgViewer::moveImg(QPointF pos)
{
    if (mpImgItem)
        mpImgItem->setPos(pos);
}

QString lpImgViewer::pixelInfoStr(QPoint pos, QRgb _rgb)
{
    QColor rgb(_rgb);
    QColor hsv = rgb.toHsv();
    QString infoStr("Position:[%1, %2]  Color(RGB):[%3, %4, %5] (HSV):[%6, %7, %8]");
    infoStr = infoStr.arg(pos.x()).arg(pos.y())
        .arg(rgb.red()).arg(rgb.green()).arg(rgb.blue())
        .arg(hsv.hue() / 2).arg(hsv.saturation()).arg(hsv.value());
    return infoStr;
}

void lpImgViewer::selectPixel(QPoint pos)
{
    if (pos.x() < 0 || pos.y() < 0 || pos.x() > mImgOriSize.width() || pos.y() > mImgOriSize.height())
    {
        mpInfoLabel->setText(QString("out of image..."));
        return;
    }

    if (!mpImgItem)
    {
        return;
    }

    QImage img = mpImgItem->pixmap().toImage();
    QRgb pixel = img.pixel(pos);

    mpInfoLabel->setText(pixelInfoStr(pos, pixel));
}

void lpImgViewer::scaleImageWithFixedViewSize()
{
    if (!mpImg)
    {
        return;
    }
    QImage scaledImage;
    if (!imgScaleFunc())
    {
        scaledImage = mpImg->scaled(mpImg->width()*mFixedSizeScale, mpImg->height()*mFixedSizeScale,
            Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
        mpImgItem->setPixmap(QPixmap::fromImage(scaledImage.scaled(mpImg->width(),
            mpImg->height()), Qt::NoFormatConversion));
    }
    else
    {
        scaledImage = mImgScaleFunc(*mpImg, mFixedSizeScale, Qt::SmoothTransformation);
        mpImgItem->setPixmap(QPixmap::fromImage(mImgScaleFunc(scaledImage,
            1.0 / mFixedSizeScale, Qt::FastTransformation), Qt::NoFormatConversion));
    }

    emit imgScaledWithFixedSize(fixedSizeScale());
}

void lpImgViewer::scaleImg(QTransform tf, QPointF center)
{
    this->resetTransform();
    this->setTransform(tf);
    this->centerOn(center);
}

void lpImgViewer::scaleImg2(qreal scale)
{
	if (scale < 0.01)
		return;
    m_scale = scale;
    QTransform t;
    t.scale(scale, scale);
    this->setTransform(t);

    QPointF center = this->mapToScene(width() / 2, height() / 2);

    emit imgScaled(this->transform(), center);
}

void lpImgViewer::clear()
{
    m_scale = 1.0f;
    m_channel = "";
    scene()->clear();
    mpImgItem = NULL;

    if (mpImg)
    {
        delete mpImg;
        mpImg = NULL;
    }
}