Newer
Older
/***************************************************************************
File : ScaleEngine.cpp
Project : QtiPlot
--------------------------------------------------------------------
Copyright : (C) 2007 by Ion Vasilief
Email (use @ for *) : ion_vasilief*yahoo.fr
Description : Extensions to QwtScaleEngine and QwtScaleTransformation
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software *
* Foundation, Inc., 51 Franklin Street, Fifth Floor, *
* Boston, MA 02110-1301 USA *
* *
***************************************************************************/
#include "qwt_compat.h"
#include "ScaleEngine.h"
QwtScaleTransformation* ScaleEngine::transformation() const
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
}
double ScaleTransformation::invXForm(double p, double p1, double p2, double s1, double s2) const
{
if (!d_engine->hasBreak()){
QwtScaleTransformation *tr = new QwtScaleTransformation (d_engine->type());
double res = tr->invXForm(p, p1, p2, s1, s2);
delete tr;
return res;
}
const int d_break_space = d_engine->breakWidth();
const double lb = d_engine->axisBreakLeft();
const double rb = d_engine->axisBreakRight();
const double pm = p1 + (p2 - p1)*(double)d_engine->breakPosition()/100.0;
double pml, pmr;
if (p2 > p1){
pml = pm - d_break_space;
pmr = pm + d_break_space;
} else {
pml = pm + d_break_space;
pmr = pm - d_break_space;
}
if (p > pml && p < pmr)
return pm;
bool invertedScale = d_engine->testAttribute(QwtScaleEngine::Inverted);
QwtScaleTransformation::Type d_type = d_engine->type();
if (invertedScale){
if ((p2 > p1 && p <= pml) || (p2 < p1 && p >= pml)){
if (d_engine->log10ScaleAfterBreak())
return s1*exp((p - p1)/(pml - p1)*log(rb/s1));
else
return s1 + (rb - s1)/(pml - p1)*(p - p1);
}
if ((p2 > p1 && p >= pmr) || (p2 < p1 && p <= pmr)){
if (d_type == QwtScaleTransformation::Log10)
return lb * exp((p - pmr)/(p2 - pmr)*log(s2/lb));
else if (d_type == QwtScaleTransformation::Linear)
return lb + (p - pmr)/(p2 - pmr)*(s2 - lb);
}
}
if ((p2 > p1 && p <= pml) || (p2 < p1 && p >= pml)){
if (d_type == QwtScaleTransformation::Linear)
return s1 + (lb - s1)*(p - p1)/(pml - p1);
else if (d_type == QwtScaleTransformation::Log10)
return s1 * exp((p - p1)/(pml - p1)*log(lb/s1));
}
if ((p2 > p1 && p >= pmr) || (p2 < p1 && p <= pmr)){
if (d_engine->log10ScaleAfterBreak())
return rb * exp((p - pmr)/(p2 - pmr)*log(s2/rb));
else
return rb + (p - pmr)*(s2 - rb)/(p2 - pmr);
}
return DBL_MAX; // something invalid
}
double ScaleTransformation::xForm(double s, double s1, double s2, double p1, double p2) const
{
if (!d_engine->hasBreak()){
QwtScaleTransformation *tr = new QwtScaleTransformation (d_engine->type());
double res = tr->xForm(s, s1, s2, p1, p2);
delete tr;
return res;
}
const int d_break_space = d_engine->breakWidth();
const double lb = d_engine->axisBreakLeft();
const double rb = d_engine->axisBreakRight();
const double pm = p1 + (p2 - p1)*(double)d_engine->breakPosition()/100.0;
double pml, pmr;
if (p2 > p1){
pml = pm - d_break_space;
pmr = pm + d_break_space;
} else {
pml = pm + d_break_space;
pmr = pm - d_break_space;
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
}
if (s > lb && s < rb)
return pm;
bool invertedScale = d_engine->testAttribute(QwtScaleEngine::Inverted);
QwtScaleTransformation::Type d_type = d_engine->type();
if (invertedScale){
if (s <= lb){
if (d_type == QwtScaleTransformation::Linear)
return pmr + (lb - s)/(lb - s2)*(p2 - pmr);
else if (d_type == QwtScaleTransformation::Log10){
return pmr + log(lb/s)/log(lb/s2)*(p2 - pmr);
}
}
if (s >= rb){
if (d_engine->log10ScaleAfterBreak())
return p1 + log(s1/s)/log(s1/rb)*(pml - p1);
else
return p1 + (s1 - s)/(s1 - rb)*(pml - p1);
}
}
if (s <= lb){
return p1 + (s - s1)/(lb - s1)*(pml - p1);
else if (d_type == QwtScaleTransformation::Log10)
return p1 + log(s/s1)/log(lb/s1)*(pml - p1);
if (s >= rb){
if (d_engine->log10ScaleAfterBreak())
return pmr + log(s/rb)/log(s2/rb)*(p2 - pmr);
return pmr + (s - rb)/(s2 - rb)*(p2 - pmr);
}
return DBL_MAX; // something invalid
}
QwtScaleTransformation *ScaleTransformation::copy() const
{
return new ScaleTransformation(d_engine);
}
/*****************************************************************************
*
* Class ScaleEngine
*
*****************************************************************************/
ScaleEngine::ScaleEngine(QwtScaleTransformation::Type type,double left_break, double right_break): QwtScaleEngine(),
d_type(type),
d_break_left(left_break),
d_break_right(right_break),
d_break_pos(50),
d_step_before(0.0),
d_step_after(0.0),
d_minor_ticks_before(1),
d_minor_ticks_after(1),
d_log10_scale_after(false),
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
d_break_decoration(true)
{}
bool ScaleEngine::hasBreak() const
{
return (d_break_left == d_break_right || (d_break_left == -DBL_MAX && d_break_right == DBL_MAX))?false:true;
}
double ScaleEngine::axisBreakLeft() const
{
return d_break_left;
}
double ScaleEngine::axisBreakRight() const
{
return d_break_right;
}
int ScaleEngine::breakWidth() const
{
return d_break_width;
}
int ScaleEngine::breakPosition() const
{
return d_break_pos;
}
double ScaleEngine::stepBeforeBreak() const
{
return d_step_before;
}
double ScaleEngine::stepAfterBreak() const
{
return d_step_after;
}
QwtScaleTransformation::Type ScaleEngine::type() const
{
return d_type;
}
int ScaleEngine::minTicksBeforeBreak() const
{
return d_minor_ticks_before;
}
int ScaleEngine::minTicksAfterBreak() const
{
return d_minor_ticks_after;
}
bool ScaleEngine::log10ScaleAfterBreak() const
{
return d_log10_scale_after;
}
bool ScaleEngine::hasBreakDecoration() const
{
return d_break_decoration;
}
void ScaleEngine::clone(const ScaleEngine *engine)
{
d_type = engine->type();
d_break_left = engine->axisBreakLeft();
d_break_right = engine->axisBreakRight();
d_break_pos = engine->breakPosition();
d_step_before = engine->stepBeforeBreak();
d_step_after = engine->stepAfterBreak();
d_minor_ticks_before = engine->minTicksBeforeBreak();
d_minor_ticks_after = engine->minTicksAfterBreak();
d_log10_scale_after = engine->log10ScaleAfterBreak();
d_break_decoration = engine->hasBreakDecoration();
setAttributes(engine->attributes());
setMargins(engine->loMargin(), engine->hiMargin());
}
QwtScaleDiv ScaleEngine::divideScale(double x1, double x2, int maxMajSteps,
int maxMinSteps, double stepSize) const
{
QwtScaleEngine *engine;
if (!hasBreak()){
if (d_type == QwtScaleTransformation::Log10)
engine = new QwtLog10ScaleEngine();
else
engine = new QwtLinearScaleEngine();
QwtScaleDiv div = engine->divideScale(x1, x2, maxMajSteps, maxMinSteps, stepSize);
delete engine;
return div;
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
}
double lb = d_break_left;
double rb = d_break_right;
double step1 = d_step_before;
double step2 = d_step_after;
if (x1 > x2){
lb = d_break_right;
rb = d_break_left;
step1 = d_step_after;
step2 = d_step_before;
if (d_log10_scale_after)
engine = new QwtLog10ScaleEngine();
else
engine = new QwtLinearScaleEngine();
} else if (d_type == QwtScaleTransformation::Log10)
engine = new QwtLog10ScaleEngine();
else
engine = new QwtLinearScaleEngine();
int max_min_intervals = d_minor_ticks_before;
if (d_minor_ticks_before == 1)
max_min_intervals = 3;
if (d_minor_ticks_before > 1)
max_min_intervals = d_minor_ticks_before + 1;
QwtScaleDiv div1 = engine->divideScale(x1, lb, maxMajSteps/2, max_min_intervals, step1);
max_min_intervals = d_minor_ticks_after;
if (d_minor_ticks_after == 1)
max_min_intervals = 3;
if (d_minor_ticks_after > 1)
max_min_intervals = d_minor_ticks_after + 1;
delete engine;
if (testAttribute(QwtScaleEngine::Inverted)){
if (d_type == QwtScaleTransformation::Log10)
engine = new QwtLog10ScaleEngine();
else
engine = new QwtLinearScaleEngine();
} else if (d_log10_scale_after)
engine = new QwtLog10ScaleEngine();
else
engine = new QwtLinearScaleEngine();
QwtScaleDiv div2 = engine->divideScale(rb, x2, maxMajSteps/2, max_min_intervals, step2);
QwtValueList ticks[QwtScaleDiv::NTickTypes];
ticks[QwtScaleDiv::MinorTick] = div1.ticks(QwtScaleDiv::MinorTick) + div2.ticks(QwtScaleDiv::MinorTick);
ticks[QwtScaleDiv::MediumTick] = div1.ticks(QwtScaleDiv::MediumTick) + div2.ticks(QwtScaleDiv::MediumTick);
ticks[QwtScaleDiv::MajorTick] = div1.ticks(QwtScaleDiv::MajorTick) + div2.ticks(QwtScaleDiv::MajorTick);
return QwtScaleDiv(x1, x2, ticks);
}
void ScaleEngine::autoScale (int maxNumSteps, double &x1, double &x2, double &stepSize) const
{
if (!hasBreak() || testAttribute(QwtScaleEngine::Inverted)){
QwtScaleEngine *engine;
if (d_type == QwtScaleTransformation::Log10)
engine = new QwtLog10ScaleEngine();
else
engine = new QwtLinearScaleEngine();
engine->setAttributes(attributes());
engine->setReference(reference());
engine->setMargins(loMargin(), hiMargin());
engine->autoScale(maxNumSteps, x1, x2, stepSize);
delete engine;
} else {
QwtScaleEngine *engine;
if (d_type == QwtScaleTransformation::Log10)
engine = new QwtLinearScaleEngine();
engine->setAttributes(attributes());
double breakLeft = d_break_left;
engine->autoScale(maxNumSteps, x1, breakLeft, stepSize);
delete engine;
engine = new QwtLinearScaleEngine();
engine->setAttributes(attributes());
double breakRight = d_break_right;
engine->autoScale(maxNumSteps, breakRight, x2, stepSize);
delete engine;
}