00001
00002
00003
00004
00005
00006
00007 #include "ExportXThetaValuesMergedFunctions.h"
00008 #include "ExportAlignLinear.h"
00009 #include "ExportAlignLog.h"
00010 #include "ExportLayoutFunctions.h"
00011 #include "ExportPointsSelectionFunctions.h"
00012 #include "Logger.h"
00013 #include "Point.h"
00014 #include <qmath.h>
00015 #include "Transformation.h"
00016
00017 using namespace std;
00018
00019 ExportXThetaValuesMergedFunctions::ExportXThetaValuesMergedFunctions(const DocumentModelExportFormat &modelExport,
00020 const ValuesVectorXOrY &xThetaValuesRaw,
00021 const Transformation &transformation) :
00022 m_modelExport (modelExport),
00023 m_xThetaValuesRaw (xThetaValuesRaw),
00024 m_transformation (transformation)
00025 {
00026 }
00027
00028 void ExportXThetaValuesMergedFunctions::firstSimplestNumberLinear (double &xThetaFirstSimplestNumber,
00029 double &xThetaMin,
00030 double &xThetaMax) const
00031 {
00032 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::firstSimplestNumberLinear";
00033
00034
00035 xThetaMin = m_xThetaValuesRaw.firstKey();
00036 xThetaMax = m_xThetaValuesRaw.lastKey();
00037
00038
00039 ExportAlignLinear alignLinear (xThetaMin,
00040 xThetaMax);
00041
00042 xThetaFirstSimplestNumber = alignLinear.firstSimplestNumber();
00043 }
00044
00045 void ExportXThetaValuesMergedFunctions::firstSimplestNumberLog (double &xThetaFirstSimplestNumber,
00046 double &xThetaMin,
00047 double &xThetaMax) const
00048 {
00049 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::firstSimplestNumberLog";
00050
00051
00052 xThetaMin = m_xThetaValuesRaw.firstKey();
00053 xThetaMax = m_xThetaValuesRaw.lastKey();
00054
00055
00056 ExportAlignLog alignLog (xThetaMin,
00057 xThetaMax);
00058
00059 xThetaFirstSimplestNumber = alignLog.firstSimplestNumber();
00060 }
00061
00062 ExportValuesXOrY ExportXThetaValuesMergedFunctions::periodicLinear() const
00063 {
00064 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::periodicLinear";
00065
00066 if (m_xThetaValuesRaw.count () > 0) {
00067
00068 double xThetaFirstSimplestNumber, xThetaMin, xThetaMax;
00069 firstSimplestNumberLinear (xThetaFirstSimplestNumber,
00070 xThetaMin,
00071 xThetaMax);
00072
00073
00074
00075 if (m_modelExport.pointsIntervalUnitsFunctions() == EXPORT_POINTS_INTERVAL_UNITS_GRAPH) {
00076 return periodicLinearGraph(xThetaFirstSimplestNumber,
00077 xThetaMin,
00078 xThetaMax);
00079 } else {
00080 return periodicLinearScreen(xThetaMin,
00081 xThetaMax);
00082 }
00083 } else {
00084
00085 ExportValuesXOrY emptyList;
00086 return emptyList;
00087 }
00088 }
00089
00090 ExportValuesXOrY ExportXThetaValuesMergedFunctions::periodicLinearGraph(double xThetaFirstSimplestNumber,
00091 double xThetaMin,
00092 double xThetaMax) const
00093 {
00094 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::periodicLinearGraph";
00095
00096
00097 ValuesVectorXOrY values;
00098 double xTheta = xThetaFirstSimplestNumber;
00099 while (xTheta > xThetaMin) {
00100 xTheta -= m_modelExport.pointsIntervalFunctions();
00101 }
00102 if (xTheta < xThetaMin) {
00103 values [xThetaMin] = true;
00104 }
00105
00106 xTheta += m_modelExport.pointsIntervalFunctions();
00107 while (xTheta <= xThetaMax) {
00108 values [xTheta] = true;
00109 xTheta += m_modelExport.pointsIntervalFunctions();
00110 }
00111
00112 if (xTheta > xThetaMax) {
00113 values [xThetaMax] = true;
00114 }
00115
00116 return values.keys();
00117 }
00118
00119 ExportValuesXOrY ExportXThetaValuesMergedFunctions::periodicLinearScreen (double xThetaMin,
00120 double xThetaMax) const
00121 {
00122 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::periodicLinearScreen";
00123
00124 const double ARBITRARY_Y = 0.0;
00125
00126
00127 QPointF posScreenFirst, posScreenLast;
00128 m_transformation.transformRawGraphToScreen(QPointF (xThetaMin,
00129 ARBITRARY_Y),
00130 posScreenFirst);
00131 m_transformation.transformRawGraphToScreen(QPointF (xThetaMax,
00132 ARBITRARY_Y),
00133 posScreenLast);
00134 double deltaScreenX = posScreenLast.x() - posScreenFirst.x();
00135 double deltaScreenY = posScreenLast.y() - posScreenFirst.y();
00136 double deltaScreen = qSqrt (deltaScreenX * deltaScreenX + deltaScreenY * deltaScreenY);
00137
00138
00139 double s = 1.0;
00140 double interval = m_modelExport.pointsIntervalFunctions();
00141 if ((interval > 0) &&
00142 (interval < deltaScreen)) {
00143 s = interval / deltaScreen;
00144 }
00145
00146
00147
00148 double xNext = xThetaMin + s * (xThetaMax - xThetaMin);
00149 double delta = xNext - xThetaMin;
00150
00151 ValuesVectorXOrY values;
00152
00153 double xTheta = xThetaMin;
00154 while (xTheta <= xThetaMax) {
00155
00156 values [xTheta] = true;
00157
00158 xTheta += delta;
00159 }
00160
00161 return values.keys();
00162 }
00163
00164 ExportValuesXOrY ExportXThetaValuesMergedFunctions::periodicLog() const
00165 {
00166 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::periodicLog";
00167
00168 double xThetaFirstSimplestNumber, xThetaMin, xThetaMax;
00169 firstSimplestNumberLog (xThetaFirstSimplestNumber,
00170 xThetaMin,
00171 xThetaMax);
00172
00173
00174
00175 if (m_modelExport.pointsIntervalUnitsFunctions() == EXPORT_POINTS_INTERVAL_UNITS_GRAPH) {
00176 return periodicLogGraph(xThetaFirstSimplestNumber,
00177 xThetaMin,
00178 xThetaMax);
00179 } else {
00180 return periodicLogScreen(xThetaMin,
00181 xThetaMax);
00182 }
00183 }
00184
00185 ExportValuesXOrY ExportXThetaValuesMergedFunctions::periodicLogGraph (double xThetaFirstSimplestNumber,
00186 double xThetaMin,
00187 double xThetaMax) const
00188 {
00189 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::periodicLogGraph";
00190
00191
00192 ValuesVectorXOrY values;
00193 double xTheta = xThetaFirstSimplestNumber;
00194 while (xTheta > xThetaMin) {
00195 xTheta /= m_modelExport.pointsIntervalFunctions();
00196 }
00197 if (xTheta < xThetaMin) {
00198 values [xThetaMin] = true;
00199 }
00200
00201 xTheta *= m_modelExport.pointsIntervalFunctions();
00202 while (xTheta <= xThetaMax) {
00203 values [xTheta] = true;
00204 xTheta *= m_modelExport.pointsIntervalFunctions();
00205 }
00206
00207 if (xTheta > xThetaMax) {
00208 values [xThetaMax] = true;
00209 }
00210
00211 return values.keys();
00212 }
00213
00214 ExportValuesXOrY ExportXThetaValuesMergedFunctions::periodicLogScreen (double xThetaMin,
00215 double xThetaMax) const
00216 {
00217 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::periodicLogScreen";
00218
00219 const double ARBITRARY_Y = 0.0;
00220
00221
00222 QPointF posScreenFirst, posScreenLast;
00223 m_transformation.transformRawGraphToScreen(QPointF (xThetaMin,
00224 ARBITRARY_Y),
00225 posScreenFirst);
00226 m_transformation.transformRawGraphToScreen(QPointF (xThetaMax,
00227 ARBITRARY_Y),
00228 posScreenLast);
00229 double deltaScreenX = posScreenLast.x() - posScreenFirst.x();
00230 double deltaScreenY = posScreenLast.y() - posScreenFirst.y();
00231 double deltaScreen = qSqrt (deltaScreenX * deltaScreenX + deltaScreenY * deltaScreenY);
00232
00233
00234 double s = 1.0;
00235 double interval = m_modelExport.pointsIntervalFunctions();
00236 if ((interval > 0) &&
00237 (interval < deltaScreen)) {
00238 s = interval / deltaScreen;
00239 }
00240
00241
00242
00243 double xNext = qExp (qLn (xThetaMin) + s * (qLn (xThetaMax) - qLn (xThetaMin)));
00244 double scale = xNext / xThetaMin;
00245
00246 ValuesVectorXOrY values;
00247
00248 double xTheta = xThetaMin;
00249 while (xTheta <= xThetaMax) {
00250
00251 values [xTheta] = true;
00252
00253 xTheta *= scale;
00254 }
00255
00256 return values.keys();
00257 }
00258
00259 ExportValuesXOrY ExportXThetaValuesMergedFunctions::xThetaValues () const
00260 {
00261 LOG4CPP_INFO_S ((*mainCat)) << "ExportXThetaValuesMergedFunctions::xThetaValues";
00262
00263 if (m_modelExport.pointsSelectionFunctions() == EXPORT_POINTS_SELECTION_FUNCTIONS_INTERPOLATE_PERIODIC) {
00264
00265
00266 if (m_modelExport.pointsIntervalFunctions() == 0) {
00267
00268 ExportValuesXOrY empty;
00269 return empty;
00270
00271 } else {
00272
00273 bool isLinear = (m_transformation.modelCoords().coordScaleXTheta() == COORD_SCALE_LINEAR);
00274 if (isLinear) {
00275 return periodicLinear ();
00276 } else {
00277 return periodicLog ();
00278 }
00279 }
00280 } else {
00281
00282
00283 return m_xThetaValuesRaw.keys();
00284
00285 }
00286 }