From 911981b4468e42e6cf2e0522b549ab39f9d9a535 Mon Sep 17 00:00:00 2001 From: bj4rnee Date: Fri, 19 Jan 2024 20:01:22 +0100 Subject: [PATCH] changes --- QTierazon/CMakeLists.txt | 2 + QTierazon/CMakeLists.txt.user | 2 +- QTierazon/Cmplx.cpp | 267 ++++++++++++++++++++++++++++++++++ QTierazon/cmplx.h | 170 ++++++++++++++++++++++ QTierazon/patternWidget.cpp | 190 ++++++++++++++++++------ QTierazon/patternWidget.h | 243 ++++++++++++++++++++++++++++++- QTierazon/renderthread.cpp | 11 +- QTierazon/renderthread.h | 5 +- 8 files changed, 833 insertions(+), 57 deletions(-) create mode 100644 QTierazon/Cmplx.cpp create mode 100644 QTierazon/cmplx.h diff --git a/QTierazon/CMakeLists.txt b/QTierazon/CMakeLists.txt index 798a300..4e5e789 100644 --- a/QTierazon/CMakeLists.txt +++ b/QTierazon/CMakeLists.txt @@ -28,6 +28,8 @@ set(PROJECT_SOURCES patternWidget.h renderthread.cpp renderthread.h + Cmplx.cpp + cmplx.h framelesswindow.ui mainfrm.ui ) diff --git a/QTierazon/CMakeLists.txt.user b/QTierazon/CMakeLists.txt.user index 197eb8f..5ce05f1 100644 --- a/QTierazon/CMakeLists.txt.user +++ b/QTierazon/CMakeLists.txt.user @@ -1,6 +1,6 @@ - + EnvironmentId diff --git a/QTierazon/Cmplx.cpp b/QTierazon/Cmplx.cpp new file mode 100644 index 0000000..9d2b74f --- /dev/null +++ b/QTierazon/Cmplx.cpp @@ -0,0 +1,267 @@ +/* +Complex C++ Utilities + +from C Mathematical Function Handbook by Louis Baker +Copyright 1991 by Louis Baker. All rights reserved. + +*/ + +#include +#include "cmplx.h" + +cmplx::cmplx(double xx, double yy) // constructor +{ + x = xx; + y = yy; +} + +cmplx::cmplx() // constructor +{ + x = 0.; + y = 0.; + bio = 0; +} + +// double cmplx::sum_of_sqrs() +// { return (x*x+y*y);} + +// double cmplx::abs() +// { return sqrt(x*x+y*y);} + +// double cmplx::real() +// { return x; } + +// double cmplx::imag() +// { return y; } + +// double cmplx::imaginary() +// { return y; } + +double cmplx::squares() +{ + if (bio) + { + if (bio == 1) + { + if (fabs(x) > fabs(y)) + return sqrt(2 * x * x); + else + return sqrt(2 * y * y); + } + else if (bio == 2) + return sqrt(2 * x * y); + else if (bio == 3) + { + if (fabs(x) > fabs(y)) + return sqrt(2 * y * y); + else + return sqrt(2 * x * x); + } + else if (bio == 4) + { + if (fabs(x) > fabs(y)) + return 2 * x * x; + else + return 2 * y * y; + } + else if (bio == 5) + return 2 * x * y; + else + { + if (fabs(x) > fabs(y)) + return 2 * y * y; + else + return 2 * x * x; + } + } + else + return (x * x + y * y); +} + +double cmplx::magnitude() +{ + if (bio) + { + if (bio == 1) + { + if (fabs(x) > fabs(y)) + return sqrt(2 * x * x); + else + return sqrt(2 * y * y); + } + else if (bio == 2) + return sqrt(2 * x * y); + else if (bio == 3) + { + if (fabs(x) > fabs(y)) + return sqrt(2 * y * y); + else + return sqrt(2 * x * x); + } + else if (bio == 4) + { + if (fabs(x) > fabs(y)) + return 2 * x * x; + else + return 2 * y * y; + } + else if (bio == 5) + return 2 * x * y; + else + { + if (fabs(x) > fabs(y)) + return 2 * y * y; + else + return 2 * x * x; + } + } + else + return sqrt(x * x + y * y); +} + +double cmplx::biotest() +{ + return (bio * x * y); +} + +void cmplx::set_biomorph(double dBiomorph) +{ + bio = dBiomorph; +} + +void cmplx::set_real(double set_x) +{ + x = set_x; +} + +void cmplx::set_imag(double set_y) +{ + y = set_y; +} + +// cmplx cmplx::cexp() +//{ +// static double scale; +// scale= x; + +// if( x > topexp) +// return cmplx( errorcode,0.); +// if( x<-topexp) +// return cmplx( 0.,0.); + +// scale= exp((scale)); +// return cmplx(scale*cos(y),scale*sin(y)); + +// return cmplx(exp(x)*cos(y),exp(x)*sin(y)); + +//} + +// cmplx cmplx::clog() +//{ +// static double mant,arg,mag;mag=(*this).abs(); + +// mag=fabs(mag); // ?? + +// if( mag < zerotol ) +// return cmplx(errorcode,0.); + +// mant = log(mag); +// arg= atan2(y,x); +// return cmplx(mant,arg); + +// return cmplx(log(fabs((*this).abs())),atan2(y,x)); +//} + +// cmplx cmplx::operator^(double expon) +//{ +// static cmplx z; +// z= (*this).clog( ) * expon; +// return z.cexp(); + +// return ((*this).clog( ) * expon).cexp(); +//} + +// cmplx cmplx::operator^(cmplx expon) +//{ +// static cmplx z; +// z= (*this).clog( ) * expon; +// return z.cexp(); + +// return ((*this).clog( ) * expon).cexp(); +//} + +cmplx cmplx::csin() +{ + return cmplx(.5 * (exp(y) + 1. / exp(y)) * sin(x), cos(x) * .5 * (exp(y) - 1. / exp(y))); +} + +cmplx cmplx::ccos() +{ + // static double z,zi,sinh,cosh,real; + // static double z,zi; + // real=x; + + // if( y> topexp) + // return cmplx( errorcode,0.); + // if( y<-topexp) + // return cmplx( 0.,0.); + + // z=exp(y); + // zi=1./z; + // cosh=.5*(z+zi); + // sinh=.5*(z-zi); + + // return cmplx(cosh*cos(x),-sin(x)*sinh); + return cmplx(.5 * (exp(y) + 1. / exp(y)) * cos(x), -sin(x) * .5 * (exp(y) - 1. / exp(y))); +} + +cmplx cmplx::csin_error() +{ + if (y > topexp) + return cmplx(errorcode, 0.); + if (y < -topexp) + return cmplx(0., 0.); + return cmplx(.5 * (exp(y) + 1. / exp(y)) * sin(x), cos(x) * .5 * (exp(y) - 1. / exp(y))); +} + +cmplx tangent(cmplx &x) +{ + return x.csin() / x.ccos(); +} + +cmplx sinh(cmplx &x) +{ + static cmplx i(0., 1.); + return -i * (x * i).csin(); +} + +// cmplx tanh(cmplx& x) +//{ +// cmplx i(0.,1.); +// return -i * tangent( x*i); +// } + +cmplx asin(cmplx &x) +{ + // static cmplx i(0.,1.); + // return -i * (i*x+ ((1.-x*x)^.5)).clog(); + + return -cmplx(0., 1.) * (cmplx(0., 1.) * x + ((1. - x * x) ^ .5)).clog(); +} + +cmplx acos(cmplx &x) +{ + // static cmplx i(0.,1.); + // return -i * (x+ i*((1.-x*x)^.5)).clog(); + + return -cmplx(0., 1.) * (x + cmplx(0., 1.) * ((1. - x * x) ^ .5)).clog(); +} + +cmplx arctan(cmplx &x) +{ + // static cmplx i(0.,1.),a; + // a= ( i+x )/(i-x); + // return .5 * i * a.clog(); + + return .5 * cmplx(0., 1.) * (cmplx(0., 1.) + x) / (cmplx(0., 1.) - x).clog(); +} diff --git a/QTierazon/cmplx.h b/QTierazon/cmplx.h new file mode 100644 index 0000000..8e0f2bc --- /dev/null +++ b/QTierazon/cmplx.h @@ -0,0 +1,170 @@ +// cmplx.h +#include "math.h" + +#define maxterm 100 +#define abstol 1.e-10 +#define reltol 1.e-5 +#define zerotol 1.e-50 // 1.e-14 +#define errorcode -1.e60 +#define pi 3.141592653589793238462643383279 +#define rad 57.2958 +#define lim 15. +// #define max(a,b) ((a)>(b)?(a):(b)) +#define infinite_loop for(;;) +#define rabs(x) ((x)<0.? -(x):(x)) +#define ABS(X) rabs(X) +#define topexp 350. +#define expo 2.7183 + +class cmplx +{ +// Attributes +public: + double x,y; + double bio; + + // Operations +public: + cmplx( double xx , double yy); //create + cmplx(); //create + + inline void operator=(cmplx rvalue) + {x=rvalue.x;y=rvalue.y;} + inline void operator-=(cmplx rvalue) + {x-=rvalue.x;y-=rvalue.y;} + inline void operator+=(cmplx rvalue) + {x+=rvalue.x;y+=rvalue.y;} + inline void operator*=(cmplx rvalue) + { + *this=cmplx(rvalue.x*x-rvalue.y*y, + rvalue.x*y+rvalue.y*x); + } + inline void operator*=(double rvalue) + { + *this=cmplx(rvalue*x, rvalue*y);//return *this; + } + inline cmplx& operator+(cmplx& rvalue) + {return cmplx(x+rvalue.x,y+rvalue.y);} + inline cmplx& operator-(cmplx& rvalue) + {return cmplx(x-rvalue.x,y-rvalue.y);} + inline cmplx& operator-() //unary minus + {return cmplx(-x,-y);} + inline cmplx& operator*(cmplx rvalue) + {return cmplx( + rvalue.x*x-rvalue.y*y, + rvalue.x*y+rvalue.y*x);} + inline friend cmplx operator/(double dividend,cmplx divisor) + { + return cmplx((dividend*divisor.x)/(divisor.x*divisor.x+divisor.y*divisor.y), + (-dividend*divisor.y)/(divisor.x*divisor.x+divisor.y*divisor.y)); + } + inline cmplx operator/(cmplx divisor) + { + return cmplx((divisor.x*x+divisor.y*y)/(divisor.x*divisor.x+divisor.y*divisor.y), + (divisor.x*y-divisor.y*x)/(divisor.x*divisor.x+divisor.y*divisor.y)); + } + + inline int operator==(cmplx rvalue) + {return (x==rvalue.x && y==rvalue.y);} + + inline cmplx operator^(double expon) + { + return ((*this).clog( ) * expon).cexp(); + } + + inline cmplx operator^(cmplx expon) + { + return ((*this).clog( ) * expon).cexp(); + } + + friend cmplx operator^(double base, cmplx expon); + + inline double real() {return x;} + inline double imaginary() {return y;} + inline double imag() {return y;} + inline double abs() {return (x*x+y*y);} + inline double magnitude1() {return sqrt(x*x+y*y);} + + inline cmplx Real() { + return cmplx (x, 0); } + + inline cmplx Imag() { + return cmplx (y, 0); } + + inline cmplx cexp() { + return cmplx(exp(x)*cos(y),exp(x)*sin(y));} + + inline cmplx clog() { + return cmplx(log(fabs((*this).magnitude1())),atan2(y,x));} + + inline cmplx unknown() { // suppose to be sine + return cmplx(.5*(exp(y)+1./exp(y))*sin(x),cos(x)*.5*(exp(y)-1./exp(y)));} + + inline cmplx conjugate() + {return cmplx(x,-y);} + inline friend cmplx operator*(cmplx& num,double real) + {return cmplx(num.x*real,num.y*real);} + inline friend cmplx operator*(double real,cmplx num) + {return cmplx(num.x*real,num.y*real);} + inline friend cmplx operator+(cmplx num,double real) + {return cmplx(num.x+real,num.y);} + inline friend cmplx operator+(double real,cmplx num) + {return cmplx(num.x+real,num.y);} + inline cmplx operator+=(double real) + {return cmplx(x+=real,y);} + inline cmplx operator-=(double real) + { + return cmplx(x-=real,y);} + inline cmplx operator++() + {x+=1.;return *this;} + inline friend cmplx operator/(cmplx num,double real) + {return cmplx(num.x/real,num.y/real);} + inline friend cmplx operator-(cmplx num,double real) + {return cmplx(num.x-real,num.y);} + inline friend cmplx operator-(double real,cmplx num) + {return cmplx(real-num.x,-num.y);} + + void set_biomorph(double dBiomorph); + void set_real(double set_x); + void set_imag(double set_y); + + double squares(); + double magnitude(); + double biotest(); + + cmplx csin(); + cmplx csin_error(); // used for alden's ray method + cmplx ccos(); + cmplx csqrt(); + + //void print( char *ahead="",char *behind=""); + cmplx hurwitz(cmplx ); + +}; + +#define _cmplx_DEFINED + +//double cmplx::abs(); +//double cmplx::sum_of_sqrs(); +//cmplx cmplx::cexp(); +//cmplx cmplx::clog(); +//double cmplx::squares(); + +//cmplx cmplx::operator^(double expon); +//cmplx cmplx::operator^(cmplx expon); + +//cmplx cmplx::csin(); // TODO commented these 3 lines +//cmplx cmplx::ccos(); +//cmplx cmplx::csin_error(); + +cmplx tangent ( cmplx& x); +cmplx sinh(cmplx& x); +cmplx asin(cmplx&x); +cmplx acos(cmplx&x); +cmplx arctan( cmplx& x); +cmplx cpow( cmplx& x, int nPower); +cmplx cpow( cmplx& x, cmplx& nPower); +double loggam(double x); +double gamma(double x); +double bernoulli(int n); /* n even 0<=n*/ +double expon(double x); diff --git a/QTierazon/patternWidget.cpp b/QTierazon/patternWidget.cpp index cbc3c64..3172ae3 100644 --- a/QTierazon/patternWidget.cpp +++ b/QTierazon/patternWidget.cpp @@ -5,47 +5,161 @@ #include -//! [0] -const double DefaultCenterX = -0.637011; -const double DefaultCenterY = -0.0395159; -const double DefaultScale = 0.00403897; - -const double ZoomInFactor = 0.8; -const double ZoomOutFactor = 1 / ZoomInFactor; -const int ScrollStep = 20; -//! [0] - -//! [1] +//constructor PatternWidget::PatternWidget(QWidget *parent) : - QWidget(parent), - centerX(DefaultCenterX), - centerY(DefaultCenterY), - pixmapScale(DefaultScale), - curScale(DefaultScale) + QWidget(parent) + { connect(&thread, &RenderThread::renderedImage, this, &PatternWidget::updatePixmap); - setWindowTitle(tr("Mandelbrot")); + nImageSize = 0; + + // nRedStart = 0; + // nGrnStart = 40; + // nBluStart = 30; + + nRedStart = 143; + nGrnStart = 58; + nBluStart = 27; + + nColorOrder = 4; + nColorMethod = 0; + nColorMode = 0; + nColorMethodSave = 0; + nFilterSave = 0; + nDistortionSave = 0; + nFDOptionSave = 0; + + min = 0; + max = 64; + + nRed = 2; + nGrn = 2; + nBlu = 2; + + bEdgeDetect = false; + bEmboss = false; + bSharpen = false; + bBlur = false; + bAverage = false; + bReduceSize = false; + + nMatrix = 0; + + bTraceContour = false; + + iIter_Data = NULL; + rIter_Data = NULL; + gIter_Data = NULL; + bIter_Data = NULL; + + pXTemp = NULL; // pointer to x temp array + pYTemp = NULL; // pointer to y temp array + + rjData = NULL; + gjData = NULL; + bjData = NULL; + + pXSave = NULL; + pYSave = NULL; + + bDraw = false; + bLaunch = false; + bAbort = false; + + CRMIN = -2; //-2.0; // // left + CIMIN = -2; //-1.33333; // // top + CRMAX = 2; // 1.0; // // right + CIMAX = 2; // 1.33333; // // bottom + + dMagnification = 1; + + + dMIN = 1e-11; + + CRMID = CRMID_Start = CRMID_Finish = ((CRMAX - CRMIN) / 2.0) + CRMIN; + CIMID = CIMID_Start = CIMID_Finish = ((CIMAX - CIMIN) / 2.0) + CIMIN; + + + CRMIN_JUL = -1.5; + CIMIN_JUL = -1.5; + CRMAX_JUL = 1.5; + CIMAX_JUL = 1.5; + + CRMIN_NEW = 0; + CIMIN_NEW = 0; + CRMAX_NEW = 0; + CIMAX_NEW = 0; + + CRMIN_OLD = 0; + CIMIN_OLD = 0; + CRMAX_OLD = 0; + CIMAX_OLD = 0; + + NMAX = 128; + NMAX_Save = 0; + dBailout = 4; + + dLower = 0; + dUpper = 256; + + jul = 0; + jul_save = 1; + + + nDistortion = 1; + nFilter = 0; + + bColorize = true; + + dStrands = .08; + dBiomorph = 0; + dBay100 = 1; + dBay1000 = 1; + + nFormulaType = 0; + + nFDOption = 0; + bDimensionVariant = 0; + + cOrient.set_real(1); + cOrient.set_imag(0); + + // Formulae Parser Variables + u_real = 0; + v_real = 0; + w_real = 0; + z_real = 0; + + u_imag = 0; + v_imag = 0; + w_imag = 0; + z_imag = 0; + + strFormulae = "z*z+c"; + + // DLL initialization TODO + //szTemp = "rsx_fv25.dll"; + //Load_DLL(); + + nDistortion_sav = nDistortion; + nFilter_sav = nFilter; + nColorMethod_sav = nColorMethod; + nFDOption_sav = nFDOption; + + #if QT_CONFIG(cursor) setCursor(Qt::CrossCursor); #endif } -//! [1] -//! [2] + void PatternWidget::paintEvent(QPaintEvent * /* event */) { QPainter painter(this); painter.fillRect(rect(), Qt::black); - if (pixmap.isNull()) { - painter.setPen(Qt::white); - painter.drawText(rect(), Qt::AlignCenter, tr("Rendering initial image, please wait...")); -//! [2] //! [3] - return; -//! [3] //! [4] - } //! [4] //! [5] @@ -75,14 +189,14 @@ void PatternWidget::paintEvent(QPaintEvent * /* event */) } } -//! [9] + //! [10] void PatternWidget::resizeEvent(QResizeEvent * /* event */) { - thread.render(centerX, centerY, curScale, size(), devicePixelRatio()); + thread.render(centerX, centerY, size(), devicePixelRatio()); } -//! [10] + /*void PatternWidget::keyPressEvent(QKeyEvent *event) { @@ -115,28 +229,20 @@ void PatternWidget::resizeEvent(QResizeEvent * /* event */) */ -//! [16] -void PatternWidget::updatePixmap(const QImage &image, double scaleFactor) +// +void PatternWidget::updatePixmap(const QImage &image) { - if (!lastDragPos.isNull()) - return; - - //info = image.text(RenderThread::infoKey()); - pixmap = QPixmap::fromImage(image); pixmapOffset = QPoint(); - lastDragPos = QPoint(); - pixmapScale = scaleFactor; update(); } -//! [16] -//! [17] +//TODO void PatternWidget::zoom(double zoomFactor) { curScale *= zoomFactor; update(); - thread.render(centerX, centerY, curScale, size(), devicePixelRatio()); + thread.render(centerX, centerY, size(), devicePixelRatio()); } -//! [17] +// diff --git a/QTierazon/patternWidget.h b/QTierazon/patternWidget.h index bc03c8b..bf5dd6f 100644 --- a/QTierazon/patternWidget.h +++ b/QTierazon/patternWidget.h @@ -4,6 +4,8 @@ #include #include #include "renderthread.h" +#include "cmplx.h" +#include class PatternWidget : public QWidget @@ -12,27 +14,260 @@ class PatternWidget : public QWidget public: PatternWidget(QWidget *parent = nullptr); + void updateBuffer(); + + // Fractal dimension variables + int i2, jrw, bDimensionVariant; + double x_std, y_std, dm, da; + double denominator, x_rmin, x_rmax, y_rmin, y_rmax; + + // Data array pointers + double *pXTemp; + double *pYTemp; + + double *rjData; + double *gjData; + double *bjData; + + double *pXSave; + double *pYSave; + + cmplx cx_std; + cmplx cy_std; + cmplx cFDx; + cmplx cFDy; + cmplx cRng_x; + cmplx cRng_y; + cmplx cNMAX; + + double dFDx; // Fractal Dimension x + double dFDy; // Fractal Dimension y + + double dFDx_0; // Initial F Dimension x + double dFDy_0; // Initial F Dimension y + + int nDIter_x; + int nDIter_y; + int nFDOption; + int NMAX_Save; + int nColorMethod; + int nColorMode; + int nColorMethodSave; + int min, max; + int ntemp; + + int nFormulaType; + + int nFilterSave; + int nDistortionSave; + int nFDOptionSave; + + // Average variables + double x_mean; + double y_mean; + + // misc + bool bEdgeDetect; + bool bEmboss; + bool bSharpen; + bool bBlur; + bool bAverage; + bool bTraceContour; + bool bReduceSize; + bool bColorize; + + double rj, gj, bj; + int xi, yi, ii; + int red, grn, blu; + int nRed, nGrn, nBlu; + int nRedStart, nGrnStart, nBluStart; + + double PrtScale; + double CrtScale; + double dMIN; + double dzx, dzy; + double dzx_save, dzy_save; + double temp, temp1, temp2; + double x_temp, y_temp, length; + double x_temp1, y_temp1; + double dUpper, dLower; + double rr, rn; + double deg; + + int *iIter_Data; + int *rIter_Data; + int *gIter_Data; + int *bIter_Data; + + int rb_avg; + int cxDIB; + int cyDIB; + int nImageSize; + int nXpix, nYpix; + int rb_width; + int rb_height; + int rb_center_x; + int rb_center_y; + int dim_avg; + int nFilter; + int nColorOrder; + int kr, kc; + int UBANDS; + int nMatrix; + int n_color_sav; + + // Constants used for mandelbrot pattern + // define Mandelbrot set constants: + double CIMAX; // 1.2 + double CIMIN; // -1.2 + double CRMAX; // 1.0 + double CRMIN; // -2.0 + + double CIMAX_JUL; // 1.5 + double CIMIN_JUL; // -1.5 + double CRMAX_JUL; // 1.5 + double CRMIN_JUL; // -1.5 + + double CIMAX_OLD; // 1.2 + double CIMIN_OLD; // -1.2 + double CRMAX_OLD; // 1.0 + double CRMIN_OLD; // -2.0 + + double CRMID; // rubber band x mid point + double CIMID; // rubber band y mid point + double CRMID_Start; // rubber band x mid point finish + double CIMID_Start; // rubber band y mid point finish + double CRMID_Finish; // rubber band x mid point finish + double CIMID_Finish; // rubber band y mid point finish + + double CIMAX_NEW; // 1.2 + double CIMIN_NEW; // -1.2 + double CRMAX_NEW; // 1.0 + double CRMIN_NEW; // -2.0 + + double CRMID_OLD; + double CIMID_OLD; + + double CRMID_JUL; + double CIMID_JUL; + + double dMag_new; + double dMagnification; + double Radius_x; + double Radius_y; + + int dBiomorph; + double rorder_r; + double rorder_i; + double dBay100, dBay1000; + double dStrands, dStrands_HI, dStrands_LO; + double limit; + + double rx_ratio, ry_ratio; + double dx_length, dy_length; + + double zx, zy; + + + // Variables for the Mandelbrot fractal + bool bDraw; + bool bLaunch; + bool bAbort; + bool bGeometry; + + int RowMax; + int Row; + int Col; + int ColMax; + + int size_x, size_y; + + double CR; + double DCI; + double DCR; + int NMAX; + int temp_max; + int Orig_X, Orig_Y; + int dBailout; + double cxx, cyy; + int nDistortion; + + int nDistortion_sav; + int nFilter_sav; + int nColorMethod_sav; + int nFDOption_sav; + + int niter, /* maximum number of iterations */ + px, py, /* current pixel */ + nx, ny, /* number of pixels */ + nc, /* number of colors to use */ + i, j, /* counters for miscellaneous use */ + jul, /* 1 = Julia Set, 0 = Mandelbrot */ + jul_save; + + double ri; + + double x, y, /* last point on orbit */ + xsquared, ysquared, /* used to speed up computations */ + ldx, ldy, /* theoretical size of pixels */ + cx, cy, /* number to add each iteration */ + xO, yO, /* starting x,y */ + xI, yI; /* ending x,y */ + + cmplx c; + cmplx cn; + cmplx z; + cmplx z1; + cmplx z2; + cmplx cOrient; + cmplx uu; + cmplx vv; + cmplx ww; + + QRect rubberBand, rubberBandSave; + + double rb_left; + double rb_top; + double rb_right; + double rb_bottom; + + double sxmin; + double symin; + double sxmax; + double symax; + double x_size; + double y_size; + + // Formulae parser variables + double u_real, v_real, w_real, z_real; + double u_imag, v_imag, w_imag, z_imag; + QString strFormulae; + +//#include "Expression.h" +// MExpression *ParsedExpr; + protected: void paintEvent(QPaintEvent *event) override; void resizeEvent(QResizeEvent *event) override; private slots: - void updatePixmap(const QImage &image, double scaleFactor); + void updatePixmap(const QImage &image); //pixmap is updated with buffer after rendering void zoom(double zoomFactor); private: RenderThread thread; QPixmap pixmap; + QImage wbuffer; // the buffer of the widget QPoint pixmapOffset; - QPoint lastDragPos; - //QString help; - QString info; + + // old (maybe not in use) double centerX; double centerY; double pixmapScale; double curScale; + }; #endif // PATTERNWIDGET_H diff --git a/QTierazon/renderthread.cpp b/QTierazon/renderthread.cpp index 5065d05..25e6e89 100644 --- a/QTierazon/renderthread.cpp +++ b/QTierazon/renderthread.cpp @@ -31,14 +31,13 @@ RenderThread::~RenderThread() //! [1] //! [2] -void RenderThread::render(double centerX, double centerY, double scaleFactor, +void RenderThread::render(double centerX, double centerY, QSize resultSize, double devicePixelRatio) { QMutexLocker locker(&mutex); this->centerX = centerX; this->centerY = centerY; - this->scaleFactor = scaleFactor; this->devicePixelRatio = devicePixelRatio; this->resultSize = resultSize; @@ -59,8 +58,6 @@ void RenderThread::run() mutex.lock(); const double devicePixelRatio = this->devicePixelRatio; const QSize resultSize = this->resultSize * devicePixelRatio; - const double requestedScaleFactor = this->scaleFactor; - const double scaleFactor = requestedScaleFactor / devicePixelRatio; const double centerX = this->centerX; const double centerY = this->centerY; mutex.unlock(); @@ -89,10 +86,10 @@ void RenderThread::run() auto scanLine = reinterpret_cast(image.scanLine(y + halfHeight)); - const double ay = centerY + (y * scaleFactor); + const double ay = centerY + (y); for (int x = -halfWidth; x < halfWidth; ++x) { - const double ax = centerX + (x * scaleFactor); + const double ax = centerX + (x ); double a1 = ax; double b1 = ay; int numIterations = 0; @@ -135,7 +132,7 @@ void RenderThread::run() str << elapsed << "ms"; image.setText(infoKey(), message); - emit renderedImage(image, requestedScaleFactor); + emit renderedImage(image); } //! [5] //! [6] ++pass; diff --git a/QTierazon/renderthread.h b/QTierazon/renderthread.h index 720b92c..6288b2b 100644 --- a/QTierazon/renderthread.h +++ b/QTierazon/renderthread.h @@ -19,7 +19,7 @@ public: RenderThread(QObject *parent = nullptr); ~RenderThread(); - void render(double centerX, double centerY, double scaleFactor, QSize resultSize, + void render(double centerX, double centerY, QSize resultSize, double devicePixelRatio); static void setNumPasses(int n) { numPasses = n; } @@ -27,7 +27,7 @@ public: static QString infoKey() { return QStringLiteral("info"); } signals: - void renderedImage(const QImage &image, double scaleFactor); + void renderedImage(const QImage &image); protected: void run() override; @@ -39,7 +39,6 @@ private: QWaitCondition condition; double centerX; double centerY; - double scaleFactor; double devicePixelRatio; QSize resultSize; static int numPasses;