859 lines
24 KiB
C++
859 lines
24 KiB
C++
#include "widget.h"
|
|
#include "ui_widget.h"
|
|
#include "gaosixy.h"
|
|
#include <iostream>
|
|
#include <QPainter>
|
|
#include <QVector>
|
|
#include <QDebug>
|
|
using namespace std;
|
|
|
|
|
|
enum COLOR_TPYE
|
|
{
|
|
RGB,
|
|
GRAY,
|
|
RED,
|
|
BLUE,
|
|
GREEN
|
|
};
|
|
|
|
Widget::Widget(QWidget *parent) :
|
|
QWidget(parent),
|
|
ui(new Ui::Widget)
|
|
{
|
|
ui->setupUi(this);
|
|
setWindowTitle(tr("zuobiaozhou")); //设置标题栏标题
|
|
//resize(300,300); //设置窗口初始大小
|
|
//ui->table->setWindowFlags(Qt::WindowStaysOnTopHint);
|
|
initAllLstPnt();
|
|
initInterface();
|
|
}
|
|
|
|
Widget::~Widget()
|
|
{
|
|
delete ui;
|
|
}
|
|
|
|
void Widget::setLstPnt_RGB(const QList<QPoint> &plst)
|
|
{
|
|
rgbLine = QList<QPoint>(plst);
|
|
drawLineFromPoint(rgbLine, RGB);
|
|
}
|
|
|
|
QList<QPoint> Widget::getLstPnt_RGB() const
|
|
{
|
|
return rgbLine;
|
|
}
|
|
|
|
void Widget::setLstPnt_RED(const QList<QPoint> &plst)
|
|
{
|
|
redLine = QList<QPoint>(plst);
|
|
drawLineFromPoint(redLine, RED);
|
|
}
|
|
|
|
void Widget::setLstPnt_BLUE(const QList<QPoint> &plst)
|
|
{
|
|
blueLine = QList<QPoint>(plst);
|
|
drawLineFromPoint(blueLine, BLUE);
|
|
}
|
|
|
|
QList<QPoint> Widget::getLstPnt_BLUE() const
|
|
{
|
|
return blueLine;
|
|
}
|
|
|
|
void Widget::setLstPnt_GREEN(const QList<QPoint> &plst)
|
|
{
|
|
greenLine = QList<QPoint>(plst);
|
|
drawLineFromPoint(greenLine, GREEN);
|
|
}
|
|
|
|
QList<QPoint> Widget::getLstPnt_GREEN() const
|
|
{
|
|
return greenLine;
|
|
}
|
|
|
|
void Widget::setLstPnt_GRAY(const QList<QPoint> &plst)
|
|
{
|
|
grayLine = QList<QPoint>(plst);
|
|
drawLineFromPoint(grayLine, GRAY);
|
|
}
|
|
|
|
QList<QPoint> Widget::getLstPnt_GRAY() const
|
|
{
|
|
return grayLine;
|
|
}
|
|
|
|
QVector<int> Widget::getRgbALLPoint()
|
|
{
|
|
return rgbALLPoint;
|
|
}
|
|
|
|
QList<QPoint> Widget::getRgbKeyPoint() const
|
|
{
|
|
return rgbLine;
|
|
}
|
|
|
|
void Widget::setRgbKeyPoint(const QList<QPoint> &pLst)
|
|
{
|
|
if(pLst.size() > 4) return;
|
|
rgbLine = QList<QPoint>(pLst);
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(rgbLine);
|
|
drawLineFromPoint(rgbLine, RGB);
|
|
update();
|
|
}
|
|
|
|
QVector<int> Widget::getRedALLPoint()
|
|
{
|
|
return redALLPoint;
|
|
}
|
|
|
|
QList<QPoint> Widget::getRedKeyPoint() const
|
|
{
|
|
return redLine;
|
|
}
|
|
|
|
void Widget::setRedKeyPoint(const QList<QPoint> &pLst)
|
|
{
|
|
if(pLst.size() > 4) return;
|
|
redLine = QList<QPoint>(pLst);
|
|
drawLineFromPoint(redLine, RED);
|
|
update();
|
|
}
|
|
|
|
QVector<int> Widget::getBlueALLPoint()
|
|
{
|
|
return blueALLPoint;
|
|
}
|
|
|
|
QList<QPoint> Widget::getBlueKeyPoint() const
|
|
{
|
|
return blueLine;
|
|
}
|
|
|
|
void Widget::setBlueKeyPoint(const QList<QPoint> &pLst)
|
|
{
|
|
if(pLst.size() > 4) return;
|
|
blueLine = QList<QPoint>(pLst);
|
|
drawLineFromPoint(blueLine, BLUE);
|
|
update();
|
|
}
|
|
|
|
QVector<int> Widget::getGreenALLPoint()
|
|
{
|
|
return greenALLPoint;
|
|
}
|
|
|
|
QList<QPoint> Widget::getGreenKeyPoint() const
|
|
{
|
|
return greenLine;
|
|
}
|
|
|
|
void Widget::setGreenKeyPoint(const QList<QPoint> &pLst)
|
|
{
|
|
if(pLst.size() > 4) return;
|
|
greenLine = QList<QPoint>(pLst);
|
|
drawLineFromPoint(greenLine, GREEN);
|
|
update();
|
|
}
|
|
|
|
QVector<int> Widget::getGrayALLPoint()
|
|
{
|
|
return grayALLPoint;
|
|
}
|
|
|
|
QList<QPoint> Widget::getGrayKeyPoint() const
|
|
{
|
|
return grayLine;
|
|
}
|
|
|
|
void Widget::setGrayKeyPoint(const QList<QPoint> &pLst)
|
|
{
|
|
if(pLst.size() > 4) return;
|
|
grayLine = QList<QPoint>(pLst);
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(grayLine);
|
|
drawLineFromPoint(grayLine, GRAY);
|
|
update();
|
|
}
|
|
|
|
void Widget::initAllLstPnt()
|
|
{
|
|
pointLst.clear();
|
|
pointLst.append(QPoint(0,0));
|
|
pointLst.append(QPoint(255,255));
|
|
redLine.clear();
|
|
redLine.append(QPoint(0,0));
|
|
redLine.append(QPoint(255,255));
|
|
blueLine.clear();
|
|
blueLine.append(QPoint(0,0));
|
|
blueLine.append(QPoint(255,255));
|
|
greenLine.clear();
|
|
greenLine.append(QPoint(0,0));
|
|
greenLine.append(QPoint(255,255));
|
|
rgbLine.clear();
|
|
rgbLine.append(QPoint(0,0));
|
|
rgbLine.append(QPoint(255,255));
|
|
grayLine.clear();
|
|
grayLine.append(QPoint(0,0));
|
|
grayLine.append(QPoint(255,255));
|
|
drawLineFromPoint(redLine, RED);
|
|
drawLineFromPoint(rgbLine, RGB);
|
|
drawLineFromPoint(greenLine, GREEN);
|
|
drawLineFromPoint(blueLine, BLUE);
|
|
drawLineFromPoint(grayLine, GRAY);
|
|
}
|
|
|
|
void Widget::initInterface()
|
|
{
|
|
color = Qt::gray;
|
|
selectCol = RGB;
|
|
leftMouseMv = false;
|
|
newPoint = false;
|
|
clickLine = false;
|
|
dragPoint = -1;
|
|
setMouseTracking(true);
|
|
ui->widget_2->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:0, x2:1, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 255, 255, 255))}");
|
|
ui->widget->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:1, x2:0, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 255, 255, 255))}");
|
|
}
|
|
|
|
void Widget::paintEvent(QPaintEvent *)
|
|
{
|
|
QPainter painter(this);
|
|
painter.setRenderHint(QPainter::Antialiasing,true); //开启抗锯齿
|
|
painter.translate(ui->widget->width(),ui->widget->height()); //坐标系统平移变换,把原点平移
|
|
painter.scale(ui->table->width() / 258.0,ui->table->height() / 258.0); //坐标系统比例变换,使绘制的图形随窗口的放大而放大
|
|
painter.scale(1,-1);
|
|
|
|
drawCoordinate(painter);
|
|
drawBackColorBySlc(painter);
|
|
drawCoorScale(painter);
|
|
drawCurveByColor(painter);
|
|
drawAllPoint(painter);
|
|
|
|
if(dragPoint < 0){
|
|
setMouseTracking(true);
|
|
emit dragPointChecked(false);
|
|
}
|
|
}
|
|
|
|
void Widget::mousePressEvent(QMouseEvent *event)
|
|
{
|
|
int x = (event->x() - ui->widget->width())*258/ui->table->width();
|
|
int y = (height() - event->y()-ui->widget_2->height())*258/ui->table->height();
|
|
//qDebug() << x << y;
|
|
if(event->button() == Qt::LeftButton){
|
|
newPoint = false;
|
|
dragPoint = -1;
|
|
clickLine = false;
|
|
for(int i = 0; i < linePoint.size();i++){
|
|
int px = linePoint.at(i).x();
|
|
int py = linePoint.at(i).y();
|
|
if(qAbs(x-px) <= 6 && qAbs(y-py) <= 6)
|
|
{
|
|
newPoint = true;
|
|
for(int j = 0; j < pointLst.size(); j++){
|
|
int lx = pointLst.at(j).x();
|
|
int ly = pointLst.at(j).y();
|
|
if(qAbs(x-lx) <= 6 && qAbs(y-ly) <= 6){
|
|
dragPoint = j;
|
|
clickLine = true;
|
|
leftMouseMv = true;
|
|
newPoint = false;
|
|
emit dragPointChecked(true);
|
|
setMouseTracking(false);
|
|
update();
|
|
break;
|
|
}
|
|
}
|
|
if(newPoint && pointLst.size() < 4 && x > pointLst.at(0).x() && x < pointLst.at(1).x()){
|
|
pointLst.append(QPoint(x,y));
|
|
dragPoint = pointLst.size()-1;
|
|
leftMouseMv = true;
|
|
clickLine = true;
|
|
emit dragPointChecked(true);
|
|
setMouseTracking(false);
|
|
update();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if(event->button() == Qt::RightButton){
|
|
for(int j = 0; j < pointLst.size(); j++){
|
|
int lx = pointLst.at(j).x();
|
|
int ly = pointLst.at(j).y();
|
|
if(qAbs(x-lx) <= 7 && qAbs(y-ly) <= 5){
|
|
if(j > 1)
|
|
pointLst.removeAt(j);
|
|
if(j == dragPoint){
|
|
dragPoint = -1;
|
|
emit dragPointChecked(false);
|
|
}else if(j > dragPoint){
|
|
dragPoint = dragPoint;
|
|
}else {
|
|
dragPoint = dragPoint-1;
|
|
}
|
|
update();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(!clickLine){
|
|
dragPoint = -1;
|
|
emit dragPointChecked(false);
|
|
setMouseTracking(true);
|
|
update();
|
|
}
|
|
emit mouseCoordSig(QPoint(x,y));
|
|
}
|
|
|
|
void Widget::mouseMoveEvent(QMouseEvent *event)
|
|
{
|
|
int x = (event->x() - ui->widget->width())*258/ui->table->width();
|
|
int y = (height() - event->y()-ui->widget_2->height())*258/ui->table->height();
|
|
if(x < 0) x = 0;
|
|
if(y < 0) y = 0;
|
|
if(x >= 255) x = 255;
|
|
if(y >= 255) y = 255;
|
|
//qDebug() << x << y;
|
|
if(leftMouseMv && dragPoint >= 0)
|
|
{
|
|
if(pointLst[dragPoint] != pointLst.at(0) && pointLst[dragPoint] != pointLst.at(1)){
|
|
if(x <= pointLst.at(0).x()) x = pointLst.at(0).x() + 1;
|
|
if(x >= pointLst.at(1).x()) x = pointLst.at(1).x() - 1;
|
|
|
|
if(pointLst.size() == 4){
|
|
if(dragPoint == 2){
|
|
if(pointLst[2].x() > pointLst[3].x() && x <= pointLst[3].x())
|
|
x = pointLst[3].x() + 1;
|
|
if(pointLst[2].x() < pointLst[3].x() && x >= pointLst[3].x())
|
|
x = pointLst[3].x() - 1;
|
|
}
|
|
else if(dragPoint == 3){
|
|
if(pointLst[2].x() < pointLst[3].x() && x <= pointLst[2].x())
|
|
x = pointLst[2].x() + 1;
|
|
if(pointLst[2].x() > pointLst[3].x() && x >= pointLst[2].x())
|
|
x = pointLst[2].x() - 1;
|
|
}
|
|
}
|
|
}
|
|
else if(pointLst[dragPoint] == pointLst.at(0)){
|
|
int min = 999;
|
|
for(int i = 1; i < pointLst.size(); i++){
|
|
if(min > pointLst[i].x()) min = pointLst[i].x();
|
|
}
|
|
if(x >= min) x = min-1;
|
|
}
|
|
else if(pointLst[dragPoint] == pointLst.at(1)){
|
|
if(pointLst.size() > 2){
|
|
int max = 0;
|
|
for(int i = 2; i < pointLst.size(); i++){
|
|
if(max < pointLst[i].x()) max = pointLst[i].x();
|
|
}
|
|
if(x <= max) x = max+1;
|
|
}
|
|
else if(pointLst.size() <= 2)
|
|
if(x <= pointLst.at(0).x()) x = pointLst.at(0).x()+1;
|
|
}
|
|
pointLst[dragPoint].setX(x);
|
|
pointLst[dragPoint].setY(y);
|
|
emit lineChangeSig();
|
|
update();
|
|
}
|
|
emit mouseCoordSig(QPoint(x,y));
|
|
}
|
|
|
|
void Widget::mouseReleaseEvent(QMouseEvent *)
|
|
{
|
|
leftMouseMv = false;
|
|
}
|
|
|
|
void Widget::enterEvent(QEvent *)
|
|
{
|
|
setFocus(Qt::MouseFocusReason);
|
|
}
|
|
|
|
void Widget::leaveEvent(QEvent *)
|
|
{
|
|
if(dragPoint < 0)
|
|
emit mouseLeaveSig();
|
|
}
|
|
|
|
void Widget::setHist_RGB(const QVector<int> &hist)
|
|
{
|
|
rgbBackColor = QVector<int>(hist);
|
|
}
|
|
|
|
QVector<int> Widget::getHist_RED() const
|
|
{
|
|
return redBackColor;
|
|
}
|
|
|
|
void Widget::setHist_RED(const QVector<int> &hist)
|
|
{
|
|
redBackColor = QVector<int>(hist);
|
|
}
|
|
|
|
QVector<int> Widget::getHist_RGB() const
|
|
{
|
|
return rgbBackColor;
|
|
}
|
|
|
|
void Widget::setHist_GREEN(const QVector<int> &hist)
|
|
{
|
|
greenBackColor = QVector<int>(hist);
|
|
}
|
|
|
|
QVector<int> Widget::getHist_GREEN() const
|
|
{
|
|
return greenBackColor;
|
|
}
|
|
|
|
void Widget::setHist_BLUE(const QVector<int> &hist)
|
|
{
|
|
blueBackColor = QVector<int>(hist);
|
|
}
|
|
|
|
QVector<int> Widget::getHist_BLUE() const
|
|
{
|
|
return blueBackColor;
|
|
}
|
|
|
|
void Widget::setHist_GRAY(const QVector<int> &hist)
|
|
{
|
|
grayBackColor = QVector<int>(hist);
|
|
}
|
|
|
|
QVector<int> Widget::getHist_GRAY() const
|
|
{
|
|
return grayBackColor;
|
|
}
|
|
|
|
void Widget::drawCoordinate(QPainter &painter)
|
|
{
|
|
painter.setBrush(QColor(79,79,79));
|
|
painter.drawRect(0, 0, 260, 260);
|
|
painter.drawLine(-2000,0,2000,0);
|
|
painter.drawLine(0,1500,0,-1500);
|
|
}
|
|
|
|
void Widget::drawBackgroudColor(QPainter &painter,QVector<int> &curCol)
|
|
{
|
|
painter.setPen(QPen(color,1));
|
|
painter.setBrush(color);
|
|
int max = 0;
|
|
for(int i = 0; i < curCol.size(); i++)
|
|
{
|
|
if(curCol.at(i) > max)
|
|
{
|
|
max = curCol.at(i);
|
|
}
|
|
}
|
|
for(int i = 0; i < curCol.size(); i++)
|
|
{
|
|
painter.drawRect(i, 0, 1, curCol.at(i)*255/max);
|
|
}
|
|
|
|
}
|
|
|
|
void Widget::drawBackColorBySlc(QPainter &painter)
|
|
{
|
|
switch(selectCol){
|
|
case RGB:
|
|
drawBackgroudColor(painter,rgbBackColor);
|
|
break;
|
|
case GREEN:
|
|
drawBackgroudColor(painter,greenBackColor);
|
|
break;
|
|
case BLUE:
|
|
drawBackgroudColor(painter,blueBackColor);
|
|
break;
|
|
case RED:
|
|
drawBackgroudColor(painter,redBackColor);
|
|
break;
|
|
case GRAY:
|
|
drawBackgroudColor(painter,grayBackColor);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Widget::drawCoorScale(QPainter &painter)
|
|
{
|
|
painter.setPen(QPen(Qt::gray,1));
|
|
for(int i = 0; i < 260 ; i+=50)
|
|
{
|
|
if(i%50 == 0 && i >=50)
|
|
{
|
|
QVector<qreal> dashes;
|
|
qreal space = 3;
|
|
dashes << 5 << space << 5 <<space;
|
|
QPen pen;
|
|
pen.setDashPattern(dashes);
|
|
pen.setWidth(1);
|
|
painter.setPen(pen);
|
|
painter.drawLine(i,300,i,0);
|
|
painter.drawLine(0,i,300,i);
|
|
}
|
|
}
|
|
QLine line(0,0,255,255);
|
|
painter.drawLine(line);
|
|
}
|
|
|
|
void Widget::drawLineFromPoint(QList<QPoint> &plst, const int& col)
|
|
{
|
|
double **a;
|
|
int len = plst.size();
|
|
a = new double *[len];
|
|
for(int i = 0; i < len; i++){
|
|
a[i] = new double[len+1];
|
|
}
|
|
/*******通过pointLst的所有点给二维数组赋值生成行列式*******/
|
|
for(int i = 0; i < len; i++){
|
|
for(int j = 0;j < len + 1; j++){
|
|
if(j < len)
|
|
a[i][j] = caculateAllMi(plst.at(i).x(),len-j-1);
|
|
if(j == len)
|
|
a[i][j] = plst.at(i).y();
|
|
}
|
|
}
|
|
|
|
/*******调用高斯消元法计算曲线方程的系数值********/
|
|
GaoSiXY gaoSi;
|
|
double *result = new double[len] ;
|
|
gaoSi.solve(a,len,result);
|
|
|
|
/********保存曲线方程 x 的系数(a,b,c,d....)********/
|
|
QList<double> xiNum;
|
|
for(int i = 0; i < len; i++){
|
|
xiNum.append(*(result+i));
|
|
}
|
|
|
|
linePoint.clear();
|
|
linePoints.clear();
|
|
for(int i = 0; i < 256; i++){
|
|
int x = i;
|
|
double yVal = 0;
|
|
for(int j = 0; j < len; j++){
|
|
yVal += xiNum.at(j)*caculateAllMi(x,len-j-1);
|
|
}
|
|
int y = (int)yVal;
|
|
if(y > 255) y = 255;
|
|
if(y < 0) y = 0;
|
|
if(x < plst.at(0).x()) y = plst.at(0).y();
|
|
if(x > plst.at(1).x()) y = plst.at(1).y();
|
|
allLinePoints[x] = y;
|
|
linePoints.append(y);
|
|
linePoint.append(QPoint(x,y));
|
|
}
|
|
|
|
|
|
if(col == RED){
|
|
redALLPoint.clear();
|
|
for(int i = 0; i < linePoint.size(); i++)
|
|
redALLPoint.append(linePoint.at(i).y());
|
|
}
|
|
if(col == GREEN){
|
|
greenALLPoint.clear();
|
|
for(int i = 0; i < linePoint.size(); i++)
|
|
greenALLPoint.append(linePoint.at(i).y());
|
|
}
|
|
if(col == BLUE){
|
|
blueALLPoint.clear();
|
|
for(int i = 0; i < linePoint.size(); i++)
|
|
blueALLPoint.append(linePoint.at(i).y());
|
|
}
|
|
if(col == GRAY){
|
|
grayALLPoint.clear();
|
|
for(int i = 0; i < linePoint.size(); i++)
|
|
grayALLPoint.append(linePoint.at(i).y());
|
|
}
|
|
if(col == RGB){
|
|
rgbALLPoint.clear();
|
|
for(int i = 0; i < linePoint.size(); i++)
|
|
{
|
|
rgbALLPoint.append(linePoint.at(i).y());
|
|
}
|
|
}
|
|
|
|
|
|
for(int i = 0;i < len; i++){
|
|
delete[] a[i];
|
|
}
|
|
delete []a;
|
|
}
|
|
|
|
void Widget::drawAllPoint(QPainter &painter)
|
|
{
|
|
if(pointLst.size() > 0)
|
|
{
|
|
painter.setPen(QPen(Qt::white,1));
|
|
painter.setBrush(Qt::white);
|
|
for(int i = 0; i < pointLst.size(); i++){
|
|
painter.drawEllipse(pointLst.at(i),3,3);
|
|
}
|
|
if(dragPoint >= 0){
|
|
painter.setPen(QPen(QColor(0, 245, 255),2));
|
|
painter.drawEllipse(pointLst[dragPoint],4,4);
|
|
}
|
|
}
|
|
|
|
if(selectCol == GREEN){
|
|
greenLine.clear();
|
|
greenLine = QList<QPoint>(pointLst);
|
|
}
|
|
else if(selectCol == RED){
|
|
redLine.clear();
|
|
redLine = QList<QPoint>(pointLst);
|
|
}else if(selectCol == BLUE){
|
|
blueLine.clear();
|
|
blueLine = QList<QPoint>(pointLst);
|
|
}else if(selectCol == RGB){
|
|
rgbLine.clear();
|
|
rgbLine = QList<QPoint>(pointLst);
|
|
}else if(selectCol == GRAY){
|
|
grayLine.clear();
|
|
grayLine = QList<QPoint>(pointLst);
|
|
}
|
|
}
|
|
|
|
void Widget::drawCurveByColor(QPainter &painter)
|
|
{
|
|
switch (selectCol) {
|
|
case RGB:
|
|
painter.setPen(QPen(Qt::white,1));
|
|
drawLineFromPoint(rgbLine, RGB);
|
|
drawLineByVector(painter,rgbALLPoint);
|
|
if(redLine.size()>2 || redLine.at(0)!= QPoint(0,0) || redLine.at(1)!= QPoint(255,255)){
|
|
painter.setPen(QPen(Qt::red,1));
|
|
drawLineFromPoint(redLine,RED);
|
|
drawLineByVector(painter,redALLPoint);
|
|
}
|
|
if(blueLine.size()>2 || blueLine.at(0)!= QPoint(0,0) || blueLine.at(1)!= QPoint(255,255)){
|
|
painter.setPen(QPen(Qt::blue,1));
|
|
drawLineFromPoint(blueLine, BLUE);
|
|
drawLineByVector(painter,blueALLPoint);
|
|
}
|
|
if(greenLine.size()>2 || greenLine.at(0)!= QPoint(0,0) || greenLine.at(1)!= QPoint(255,255)){
|
|
painter.setPen(QPen(Qt::green,1));
|
|
drawLineFromPoint(greenLine, BLUE);
|
|
drawLineByVector(painter,greenALLPoint);
|
|
}
|
|
break;
|
|
case RED:
|
|
painter.setPen(QPen(Qt::red,1));
|
|
drawLineFromPoint(redLine,RED);
|
|
drawLineByVector(painter,redALLPoint);
|
|
break;
|
|
case BLUE:
|
|
painter.setPen(QPen(Qt::blue,1));
|
|
drawLineFromPoint(blueLine, BLUE);
|
|
drawLineByVector(painter,blueALLPoint);
|
|
break;
|
|
case GREEN:
|
|
painter.setPen(QPen(Qt::green,1));
|
|
drawLineFromPoint(greenLine, GREEN);
|
|
drawLineByVector(painter,greenALLPoint);
|
|
break;
|
|
case GRAY:
|
|
painter.setPen(QPen(Qt::white,1));
|
|
drawLineFromPoint(grayLine, GRAY);
|
|
drawLineByVector(painter,grayALLPoint);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
drawLineFromPoint(pointLst, -1);
|
|
}
|
|
|
|
void Widget::drawLineByVector(QPainter &painter,QVector<int> &pVec)
|
|
{
|
|
for(int i = 0; i < pVec.size()-1; i++){
|
|
painter.drawLine(QPoint(i,pVec.at(i)),QPoint(i+1,pVec.at(i+1)));
|
|
}
|
|
//update();
|
|
}
|
|
|
|
int Widget::caculateAllMi(int num, int n)
|
|
{
|
|
int val = 1;
|
|
if(n == 0) return 1;
|
|
for(int i = 0; i < n; i++){
|
|
val *= num;
|
|
}
|
|
return val;
|
|
}
|
|
|
|
void Widget::getCurLineLUT(uchar *table, size_t length)
|
|
{
|
|
for(size_t i = 0; i < length; i++)
|
|
{
|
|
table[i] = allLinePoints[i];
|
|
}
|
|
}
|
|
|
|
QVector<unsigned char> Widget::getCurLinePntVec()
|
|
{
|
|
return linePoints;
|
|
}
|
|
|
|
void Widget::updateCurLinePnt(const int& colType)
|
|
{
|
|
dragPoint = -1;
|
|
selectCol = colType;
|
|
if(selectCol == GREEN){
|
|
color = QColor(202, 255, 112);
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(greenLine);
|
|
ui->widget_2->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:0, x2:1, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(0, 255, 0, 255))}");
|
|
ui->widget->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:1, x2:0, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(0, 255, 0, 255))}");
|
|
}else if(selectCol == BLUE){
|
|
color = QColor(131, 111, 255);
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(blueLine);
|
|
ui->widget_2->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:0, x2:1, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(0, 0, 255, 255))}");
|
|
ui->widget->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:1, x2:0, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(0, 0, 255, 255))}");
|
|
}else if(selectCol == RED){
|
|
color = QColor(255, 160, 122);
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(redLine);
|
|
ui->widget_2->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:0, x2:1, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 0, 0, 255))}");
|
|
ui->widget->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:1, x2:0, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 0, 0, 255))}");
|
|
}else if(selectCol == GRAY){
|
|
color = Qt::gray;
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(grayLine);
|
|
ui->widget_2->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:0, x2:1, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 255, 255, 255))}");
|
|
ui->widget->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:1, x2:0, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 255, 255, 255))}");
|
|
}else if(selectCol == RGB){
|
|
color = Qt::gray;
|
|
pointLst.clear();
|
|
pointLst = QList<QPoint>(rgbLine);
|
|
ui->widget_2->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:0, x2:1, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 255, 255, 255))}");
|
|
ui->widget->setStyleSheet("QWidget{background-color:qlineargradient("
|
|
"spread:pad, x1:0, y1:1, x2:0, y2:0, "
|
|
"stop:0 rgba(0, 0, 0, 255), stop:1 rgba(255, 255, 255, 255))}");
|
|
}
|
|
update();
|
|
}
|
|
|
|
void Widget::setXCoorVal(const int &xVal)
|
|
{
|
|
if(dragPoint >= 0){
|
|
int x = xVal;
|
|
if(pointLst[dragPoint] != pointLst.at(0) && pointLst[dragPoint] != pointLst.at(1)){
|
|
if(pointLst.size() == 3 && x > pointLst.at(0).x() && x < pointLst.at(1).x())
|
|
pointLst[dragPoint].setX(x);
|
|
|
|
if(pointLst.size() == 4){
|
|
if(dragPoint == 2){
|
|
if(pointLst[2].x() > pointLst[3].x() && x > pointLst[3].x() && x < pointLst[1].x())
|
|
pointLst[dragPoint].setX(x);
|
|
if(pointLst[2].x() < pointLst[3].x() && x < pointLst[3].x() && x > pointLst[0].x())
|
|
pointLst[dragPoint].setX(x);
|
|
}
|
|
else if(dragPoint == 3){
|
|
if(pointLst[2].x() < pointLst[3].x() && x > pointLst[2].x() && x < pointLst[1].x())
|
|
pointLst[dragPoint].setX(x);
|
|
if(pointLst[2].x() > pointLst[3].x() && x < pointLst[2].x() && x > pointLst[0].x())
|
|
pointLst[dragPoint].setX(x);
|
|
}
|
|
}
|
|
}
|
|
else if(pointLst[dragPoint] == pointLst.at(0)){
|
|
int min = 999;
|
|
for(int i = 1; i < pointLst.size(); i++){
|
|
if(min > pointLst[i].x()) min = pointLst[i].x();
|
|
}
|
|
if(x < min) pointLst[dragPoint].setX(x);
|
|
}
|
|
else if(pointLst[dragPoint] == pointLst.at(1)){
|
|
if(pointLst.size() > 2){
|
|
int max = 0;
|
|
for(int i = 2; i < pointLst.size(); i++){
|
|
if(max < pointLst[i].x()) max = pointLst[i].x();
|
|
}
|
|
if(x > max) pointLst[dragPoint].setX(x);
|
|
}
|
|
else if(pointLst.size() <= 2)
|
|
if(x > pointLst.at(0).x()) pointLst[dragPoint].setX(x);
|
|
}
|
|
update();
|
|
}
|
|
}
|
|
|
|
void Widget::setYCoorVal(const int &yVal)
|
|
{
|
|
if(dragPoint >= 0){
|
|
pointLst[dragPoint].setY(yVal);
|
|
update();
|
|
}
|
|
}
|
|
|
|
void Widget::initSelectColLine(const int& colType)
|
|
{
|
|
pointLst.clear();
|
|
pointLst.append(QPoint(0,0));
|
|
pointLst.append(QPoint(255,255));
|
|
switch(colType){
|
|
case RED:
|
|
redLine.clear();
|
|
redLine.append(QPoint(0,0));
|
|
redLine.append(QPoint(255,255));
|
|
break;
|
|
case BLUE:
|
|
blueLine.clear();
|
|
blueLine.append(QPoint(0,0));
|
|
blueLine.append(QPoint(255,255));
|
|
break;
|
|
case GREEN:
|
|
greenLine.clear();
|
|
greenLine.append(QPoint(0,0));
|
|
greenLine.append(QPoint(255,255));
|
|
break;
|
|
case GRAY:
|
|
grayLine.clear();
|
|
grayLine.append(QPoint(0,0));
|
|
grayLine.append(QPoint(255,255));
|
|
break;
|
|
case RGB:
|
|
initAllLstPnt();
|
|
break;
|
|
}
|
|
dragPoint = -1;
|
|
leftMouseMv = false;
|
|
newPoint = false;
|
|
clickLine = false;
|
|
setMouseTracking(true);
|
|
qDebug() << "init";
|
|
updateCurLinePnt(colType);
|
|
}
|
|
|
|
void Widget::SetAllLinePnt(QVector<int> &all)
|
|
{
|
|
allLinePntSet = QVector<int>(all);
|
|
}
|
|
|