plot2D.cpp

#include "plot2D.h"

plot2D::plot2D(QWidget *parent){
    setBackgroundRole(QPalette::Dark);
    setAutoFillBackground(true);
    setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
    setMouseTracking(true);
    init_s0();
    s = &s0;
    dataarea.setRect(0,0,width(),height());
    count = count1 = count2 = 0;
    marker = s->xmin;
    xdata = ydata = xdata1 = ydata1 = xdata2 = ydata2 = NULL;
    refresh_pixmap();
}
plot2D::plot2D(plot2D *src){
    setBackgroundRole(QPalette::Dark);
    setAutoFillBackground(true);
    setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
    setMouseTracking(true);
    init_s0();
    s = src->s;
    dataarea.setRect(0,0,width(),height());
    count = count1 = count2 = 0;
    marker = s->xmin;
    if(src->count > 0){
        count = src->count;
        xdata = new double[count];
        ydata = new double[count];
        memcpy(xdata,src->xdata,count*sizeof(double));
        memcpy(ydata,src->ydata,count*sizeof(double));
    }
    else{
        count = 0;
        xdata = ydata = NULL;
    }
    if(src->count1 > 0){
        count1 = src->count1;
        xdata1 = new double[count1];
        ydata1 = new double[count1];
        memcpy(xdata1,src->xdata1,count1*sizeof(double));
        memcpy(ydata1,src->ydata1,count1*sizeof(double));
    }
    else{
        count1 = 0;
        xdata1 = ydata1 = NULL;
    }
    if(src->count2 > 0){
        count2 = src->count2;
        xdata2 = new double[count2];
        ydata2 = new double[count2];
        memcpy(xdata2,src->xdata2,count2*sizeof(double));
        memcpy(ydata2,src->ydata2,count2*sizeof(double));
    }
    else{
        count2 = 0;
        xdata2 = ydata2 = NULL;
    }
    title =src->title;
    xbarlabel = src->xbarlabel;
    ybarlabel = src->ybarlabel;
    refresh_pixmap();

}
plot2D::~plot2D(){
    if(xdata  != NULL) delete xdata;
    if(xdata1 != NULL) delete xdata1;
    if(xdata2 != NULL) delete xdata2;
    if(ydata  != NULL) delete ydata;
    if(ydata1 != NULL) delete ydata1;
    if(ydata2 != NULL) delete ydata2;
}
void plot2D::init_s0(){
    s0.autoscale = 1;
    s0.bgcolor = QColor(Qt::white).rgba();
    s0.drawtitle = 1;
    s0.drawxbarlabel = 1;
    s0.drawxlattice = 1;
    s0.drawybarlabel = 1;
    s0.drawylattice = 1;
    strcpy(s0.font,"Arial");
    s0.fontcolor = QColor(Qt::black).rgba();
    s0.fsnormal = 6;
    s0.fstitle = 10;
    s0.height = this->height();
    s0.latticecolor = QColor(0,0,0,100).rgba();
    s0.margin = 5;
    s0.width = this->width();
    s0.xmax = 1;
    s0.xmin = -1;
    s0.ymin = -1;
    s0.ymax = 1;
    s0.singlecolor = false;
    s0.fillcolor = QColor(0,255,0,150).rgba();
    s0.showline = true;
    s0.linecolor = QColor(Qt::black).rgba();
    s0.showreduceddata = true;
}

void plot2D::zoom_out(){
    double x = s->xmax-s->xmin, y = s->ymax-s->ymin;
    s->xmin = s->xmin - x/2.;
    s->xmax = s->xmax + x/2.;
    s->ymin = s->ymin - y/2.;
    s->ymax = s->ymax + y/2.;
    refresh_pixmap();
}
void plot2D::zoom_in(){
    double x = s->xmax-s->xmin, y = s->ymax-s->ymin;
    s->xmin = s->xmin + x/4.;
    s->xmax = s->xmax - x/4.;
    s->ymin = s->ymin + y/4.;
    s->ymax = s->ymax - y/4.;
    refresh_pixmap();
}
QSize plot2D::sizeHint() const{
    return QSize(250,100);
}
QSize plot2D::minimumSizeHint() const{
    return QSize(100,100);
}
void plot2D::paintEvent(QPaintEvent *){
   QPainter p(this);
    p.drawPixmap(0,0,pm);
    if(showzoombox){
        p.setBrush(QBrush(QColor(0,255,0,100)));
        p.setPen(palette().light().color());
        p.drawRect(zoombox.normalized());
    }
    if(marker != s->xmin){
        p.setPen(QPen(Qt::black));
        p.drawLine(xdatatox(marker),dataarea.bottom(),
                   xdatatox(marker),dataarea.top());
    }
}
void plot2D::resizeEvent(QResizeEvent *){
    refresh_pixmap();
}
void plot2D::mousePressEvent(QMouseEvent *event){
    if(dataarea.contains(event->pos())){
        if(   event->button() == Qt::LeftButton){
            showzoombox = 1;
            marker = s->xmin;
            xold = event->pos().x();
            yold = event->pos().y();
            zoombox.setHeight(dataarea.height());
            zoombox.setBottom(dataarea.bottom());
            zoombox.setTop(dataarea.top());
            zoombox.setLeft(xold);
        }
    }
}
void plot2D::mouseMoveEvent(QMouseEvent *event){
    this->setFocus();
    if(showzoombox){
        if(event->pos().x()>xold)
            zoombox.setWidth(event->pos().x()-xold);
        else{
            zoombox.setLeft(event->pos().x());
            zoombox.setWidth(xold-event->pos().x());
        }
    }
    else{
        if(dataarea.contains(event->pos()))
            emit mousex(xtoxdata(event->pos().x()));
        marker = xtoxdata(event->pos().x());
    }
    update();
}
void plot2D::mouseReleaseEvent(QMouseEvent *event){
    if(   event->button() == Qt::LeftButton
       && showzoombox){
        showzoombox = 0;
        if(event->pos().x()!=xold){
            if(event->pos().x()>xold)
                zoombox.setWidth(event->pos().x()-xold);
            else{
                zoombox.setLeft(event->pos().x());
                zoombox.setWidth(xold-event->pos().x());
            }
            if(zoombox.normalized().width() < 2 || zoombox.normalized().height()<2)
                return;
            double xmint = xtoxdata(zoombox.normalized().left());
            double xmaxt = xtoxdata(zoombox.normalized().right());
            double ymint = ytoydata(zoombox.normalized().bottom());
            double ymaxt = ytoydata(zoombox.normalized().top());
            s->xmin = xmint;
            s->ymin = ymint;
            s->xmax = xmaxt;
            s->ymax = ymaxt;
            emit call_zoom_repaint(s->xmin,s->xmax);
        }
        if(event->pos().y() == yold)
            emit clicked(xtoxdata(event->pos().x()));
    }
}
void plot2D::keyPressEvent(QKeyEvent *event){
    switch(event->key()){
        case Qt::Key_Plus:         
            title="";
            zoom_in();
            break;
        case Qt::Key_Minus:
            title="";
            zoom_out();
            break;
        case Qt::Key_Escape:
            emit call_fullview();
            break;
        default:
            emit keypressed(event);
    }
}
void plot2D::refresh_pixmap(){
    pm = QPixmap(size());
    QPainter p(&pm);
    p.fillRect(pm.rect(),QColor::fromRgba(s->bgcolor));
    add_axis_labels(&p);
    add_grid(&p);
    p.setRenderHint(QPainter::Antialiasing);
    add_data(&p);
    update();
}
double plot2D::xtoxdata(int x){
    return s->xmin + 1.*(x-dataarea.x())/dataarea.width()*(s->xmax-s->xmin);
}
double plot2D::ytoydata(int y){
    return s->ymax - 1.*(y-dataarea.y())/dataarea.height()*(s->ymax-s->ymin);
}
double plot2D::xdatatox(double x){
    return dataarea.left() + ((x-s->xmin)/(s->xmax-s->xmin)*dataarea.width());
}
double plot2D::ydatatoy(double y){
    return dataarea.bottom() - ((y-s->ymin)/(s->ymax-s->ymin)*dataarea.height());
}
void plot2D::add_axis_labels(QPainter* p){
    p->setFont(QFont(QString(s->font),s->fsnormal));
    QFontMetricsF q(p->font());
    float textheight = q.height();
    QFontMetricsF qt(QFont(QString(s->font),s->fstitle));
    float titleheight = qt.height();
    float ticklength = textheight /2;
    int daxmin = s->margin + ticklength,
        daxmax = this->width()-s->margin,
        daymin = s->margin             ,
        daymax = this->height()-s->margin-ticklength-s->margin-textheight;
    if(s->drawtitle && !title.isEmpty())
        daymin = daymin + titleheight + s->margin;
    if(s->drawxbarlabel && !xbarlabel.isEmpty())
        daymax = daymax - s->margin - textheight;
    if(s->drawybarlabel && !ybarlabel.isEmpty())
        daxmin = daxmin + s->margin + textheight;

    /*y-Achsen Beschriftungsintervall festlegen*/
    ysteps = floor((daymax-daymin-s->margin)/(textheight + s->margin));
    double step = 1.*(s->ymax-s->ymin)/ysteps;
    yprecission = floor(log10(step));
    step = step/pow(10,yprecission+1);
    ystep = 0.1;
    if(step > 0.1)     ystep = 0.2;
    if(step > 0.2)     ystep = 0.25;
    if(step > 0.25)    ystep = 0.5;
    if(step > 0.5)     ystep = 1.;
    ystep = ystep * pow(10,yprecission+1);
    ystep0 = ystep*ceil(s->ymin/ystep);
    ysteps = floor((s->ymax-ystep0)/ystep);

    QString a = QString("%1").arg(ystep0,0,'f',qMax(0.,-yprecission));
    QString b = QString("%1").arg(ystep0+ysteps*ystep,0,'f',qMax(0.,-yprecission));

    daxmin += s->margin + qMax(q.width(a), q.width(b));

    /*x-Achsen Beschriftungsintervall festlegen*/
    double ww;
    int OK = 1, End = 0, tickcount = 0;
    while(OK){
        if(End){ tickcount--; OK = 0;}
        else     tickcount++;
        step = 1.*(s->xmax-s->xmin)/tickcount;
        xprecission = floor(log10(step));
        step = step/pow(10,xprecission+1);
        xstep = 0.1;
        if(step > 0.1)     xstep = 0.2;
        if(step > 0.2)     xstep = 0.25;
        if(step > 0.25)    xstep = 0.5;
        if(step > 0.5)     xstep = 1.;
        xstep = xstep * pow(10,xprecission+1);
        xstep0 = xstep*ceil(s->xmin/xstep);
        xsteps = qMax(1.,floor((s->xmax-xstep0)/xstep));
        ww = q.width(QString("-%1").arg(xstep0,0,'f',qMax(0.,-xprecission)));
        if( (daxmax-daxmin)/(xsteps) - s->margin
            < q.width(QString("-%1").arg(xstep0,0,'f',qMax(0.,-xprecission))))
            End = 1;
    }

    /*Zeichenbereich festetzen*/
    dataarea = QRect(daxmin,daymin,daxmax-daxmin,daymax-daymin);

    p->setPen(QColor::fromRgba(s->fontcolor));
    /*y-Achsen Zeichnen*/
    p->drawLine(dataarea.topLeft(),dataarea.bottomLeft());
    p->drawLine(dataarea.topRight(),dataarea.bottomRight());
    double y0;
    for(double y = ystep0; y < s->ymax; y = y + ystep){
        y0 = ydatatoy(y);
        p->drawLine(dataarea.left(),           y0,
                    dataarea.left()-ticklength,y0);
        p->drawText(0,y0-textheight/2,dataarea.left()-ticklength-s->margin,textheight,
                    Qt::AlignRight,QString("%1").arg(y,0,'f',qMax(0.,-yprecission)));
    }
    if(!ybarlabel.isNull()){
        p->save();
        //p->translate(100,100);
        p->rotate(-90);
        p->drawText(0,s->margin,-height(),textheight,Qt::AlignCenter,ybarlabel);
        p->restore();
    }


    /*x-Achsen Zeichnen*/
    p->drawLine(dataarea.bottomLeft(),dataarea.bottomRight());
    p->drawLine(dataarea.topLeft(),dataarea.topRight());
    double x0;
    for(double x = xstep0; x < s->xmax; x = x + xstep){
        x0 = xdatatox(x);
        p->drawLine(x0, dataarea.bottom(),
                    x0, dataarea.bottom()+ticklength);
        QString t = QString("%1").arg(x,0,'f',qMax(0.,-xprecission));
        if(q.width(t)/2+x0+s->margin < width())
            p->drawText(x0-1000,dataarea.bottom()+ticklength+s->margin,2001,
                        textheight,Qt::AlignCenter,t);
    }
    if(s->drawxbarlabel && !xbarlabel.isNull())
        p->drawText(dataarea.left(),dataarea.bottom()+2*s->margin+ticklength+textheight,
                    dataarea.width(),textheight,Qt::AlignCenter,xbarlabel);

    /*Titel zeichnen*/
    if(s->drawtitle && !title.isNull()){
        p->setFont(QFont(QString(s->font),s->fstitle));
        p->drawText(0,s->margin,width(),titleheight,Qt::AlignCenter,title);
    }
}
void plot2D::add_grid(QPainter* p){
    p->setPen(QColor::fromRgba(s->latticecolor));
    p->setClipRect(dataarea.adjusted(+1,+1,-1,-1));
    if(s->drawylattice)
        for(double y = ystep0; y < s->ymax; y = y + ystep){
            p->drawLine(dataarea.left() ,ydatatoy(y),
                        dataarea.right(),ydatatoy(y));
        }
    if(s->drawxlattice)
    for(double x = xstep0; x < s->xmax; x = x + xstep){
        p->drawLine(xdatatox(x), dataarea.bottom(),
                    xdatatox(x), dataarea.top());
    }
}
void plot2D::add_data(QPainter* p){
    p->setClipRect(dataarea.adjusted(+1,+1,-1,-1));
    QPointF d[4];
    p->setPen(Qt::NoPen);
    if(s->singlecolor)
        p->setBrush(QBrush(QColor::fromRgba(s->fillcolor)));
    double slope;
    int iold = 0;
    double dxmin;
    if(s->showreduceddata)
        dxmin = (s->xmax-s->xmin)/(dataarea.width()/5);
    else{
        dxmin = 0;
        p->setRenderHint(QPainter::Antialiasing);
    }
    for(int i = 1; i < count; i++){
        if(   xdata[i]-xdata[iold] > dxmin
              && (  (xdata[i] >= s->xmin && xdata[i] <= s->xmax)
                  ||(xdata[i-1]>=s->xmin && xdata[i-1]<=s->xmax))){
            d[0].setX(xdatatox(xdata[iold]));
            d[1].setX(xdatatox(xdata[i]));
            if(!s->showreduceddata
               ||d[1].x()-d[0].x()>5){
                d[0].setY(ydatatoy(ydata[iold]));
                d[1].setY(ydatatoy(ydata[i]));
                d[2].setX(d[1].x());
                d[2].setY(dataarea.bottom());
                d[3].setX(d[0].x());
                d[3].setY(dataarea.bottom());
                slope = qAbs((ydata[i]-ydata[iold])/(xdata[i]-xdata[iold]))*0.001;
                if(!s->singlecolor)
                    p->setBrush(QBrush(slopetocolor(slope)));
                p->drawPolygon(d,4);
                if(s->showline){
                    p->setPen(QPen(QColor::fromRgba(s->linecolor),4,Qt::SolidLine,Qt::RoundCap));
                    p->drawLine(d[0],d[1]);
                    p->setPen(Qt::NoPen);
                }
                iold = i;
            }
        }
    }
    double tmin, tmax;
    p->setPen(QPen(Qt::red,1.0));
    if(count1 > 0){
        tmin = tmax = ydata1[0];
        for(int i = 1; i < count1; i++){
            tmin = qMin(tmin,ydata1[i]);
            tmax = qMax(tmax,ydata1[i]);
        }
        tmin -= (tmax-tmin)/20;
        tmax += (tmax-tmin)/20;
        QPointF* P = new QPointF[count1];
        int ci = 1;
        P[0].setX(xdatatox(xdata1[0]));
        P[0].setY(dataarea.bottom()
                   -dataarea.height()*
                   (ydata1[0]-tmin)/(tmax-tmin));
        for(int i = 1; i < count1; i++)
            if(  (xdata1[i-1]/1000. > s->xmin && xdata1[i-1]/1000. < s->xmax)
               ||(xdata1[i  ]/1000. > s->xmin && xdata1[i  ]/1000. < s->xmax)){
                P[ci].setX(xdatatox(xdata1[i]/1000.));
                P[ci].setY(dataarea.bottom()
                           -dataarea.height()*
                           (ydata1[i]-tmin)/(tmax-tmin));
                ci++;
            }
        if(ci < count1){
            P[ci].setX(xdatatox(xdata1[count1-1]));
            P[ci].setY(dataarea.bottom()
                       -dataarea.height()*
                       (ydata1[count1-1]-tmin)/(tmax-tmin));
            ci++;
        }
        p->drawPolyline(P,ci);
        delete P;
    }
    p->setPen(QPen(Qt::blue,1.0));
    if(count2 > 0){
        tmin = tmax = ydata2[0];
        for(int i = 1; i < count2; i++){
            tmin = qMin(tmin,ydata2[i]);
            tmax = qMax(tmax,ydata2[i]);
        }
        tmin -= (tmax-tmin)/20;
        tmax += (tmax-tmin)/20;
        QPointF* P = new QPointF[count2];
        int ci = 1;
        P[0].setX(xdatatox(xdata2[0]));
        P[0].setY(dataarea.bottom()
                   -dataarea.height()*
                   (ydata2[0]-tmin)/(tmax-tmin));
        for(int i = 1; i < count2; i++)
            if(  (xdata2[i-1]/1000. > s->xmin && xdata2[i-1]/1000. < s->xmax)
               ||(xdata2[i  ]/1000. > s->xmin && xdata2[i  ]/1000. < s->xmax)){
                P[ci].setX(xdatatox(xdata2[i]/1000.));
                P[ci].setY(dataarea.bottom()
                           -dataarea.height()*
                           (ydata2[i]-tmin)/(tmax-tmin));
                ci++;
            }
        if(ci < count2){
            P[ci].setX(xdatatox(xdata2[count2-1]));
            P[ci].setY(dataarea.bottom()
                       -dataarea.height()*
                       (ydata2[count2-1]-tmin)/(tmax-tmin));
            ci++;
        }
        p->drawPolyline(P,ci);
        delete P;
    }
    p->setClipRect(this->rect());
}
void plot2D::set_labels(QString title, QString xbarlabel, QString ybarlabel){
    this->title = title;
    this->xbarlabel = xbarlabel;
    this->ybarlabel = ybarlabel;
}
void plot2D::set_data(double** dataxy,int count){
    set_data(dataxy,count,NULL,0,NULL,0);
}
void plot2D::set_data(double** dataxy, int count,
              double** data1xy, int count1,
              double** data2xy, int count2){
    if(xdata != NULL || ydata != NULL){
        delete xdata;
        delete ydata;
        xdata1 = ydata1 = NULL;
    }
    if(xdata1 != NULL || ydata1 != NULL){
        delete xdata1;
        delete ydata1;
        xdata1 = ydata1 = NULL;
    }
    if(xdata2 != NULL || ydata2 != NULL){
        delete xdata2;
        delete ydata2;
        xdata2 = ydata2 = NULL;
    }
    this->count = count;
    if(count>0){
        xdata = new double[count];
        ydata = new double[count];
        for(int i= 0; i < count; i++){
            xdata[i] = dataxy[0][i];
            ydata[i] = dataxy[1][i];
        }
    }
    else
        xdata = ydata = NULL;
    this->count1 = count1;
    if(count1>0){
        xdata1 = new double[count1];
        ydata1 = new double[count1];
        for(int i= 0; i < count1; i++){
            xdata1[i] = data1xy[0][i];
            ydata1[i] = data1xy[1][i];
        }
    }
    else
        xdata1 = ydata1 = NULL;
    this->count2 = count2;
    if(count2>0){
        xdata2 = new double[count2];
        ydata2 = new double[count2];
        for(int i= 0; i < count2; i++){
            xdata2[i] = data2xy[0][i];
            ydata2[i] = data2xy[1][i];
        }
    }
    else
        xdata2 = ydata2 = NULL;


    if(s->autoscale)
        autoset_axis();
    else
        refresh_pixmap();

}

QColor plot2D::slopetocolor(double x){
    if(x<0.03) return QColor(255,255,255,150);
    if(x<0.05) return QColor(150,255,150,150);
    if(x<0.07) return QColor(0,255,0,150);
    if(x<0.09) return QColor(255,255,0,150);
    if(x<0.12)return QColor(255,0,0,150);
    return QColor(0,0,0,150);
}
void plot2D::autoset_axis(){
    if(xdata == NULL)
        s->ymin = s->ymax = s->xmin = s->xmax = 0;
    else{
        s->ymax = s->xmax = -1e300;
        s->ymin = s->xmin = +1e300;
    }
    for(int i = 0; i < count; i++){
        if(xdata[i] > s->xmax) s->xmax = xdata[i];
        if(ydata[i] > s->ymax) s->ymax = ydata[i];
        if(xdata[i] < s->xmin) s->xmin = xdata[i];
        if(ydata[i] < s->ymin) s->ymin = ydata[i];
    }
    if(s->xmin == s->xmax){s->xmin--; s->xmax++;}
    if(s->ymin == s->ymax){s->ymin--; s->ymax++;}
    s->ymax += (s->ymax-s->ymin)/10.;
    s->ymin -= (s->ymax-s->ymin)/20.;
    refresh_pixmap();
}
void plot2D::set_marker(double x){
    if(marker != x){
        marker = x;
        update();
    }
}
double plot2D::get_xmin(){
    return s->xmin;
}
void plot2D::set_size(int w,int h){
    resize(w,h);
    dataarea.setRect(0,0,width(),height());
    refresh_pixmap();
}
void plot2D::save_to_png(QString filename){
    pm.save(filename,"PNG");
}
void plot2D::settings(ProfilSettings* s){
    this->s = s;
}