Engauge Digitizer  2
ExportFileRelations.cpp
1 #include "CurveConnectAs.h"
2 #include "Document.h"
3 #include "EngaugeAssert.h"
4 #include "ExportFileRelations.h"
5 #include "ExportLayoutFunctions.h"
6 #include "ExportOrdinalsSmooth.h"
7 #include "ExportOrdinalsStraight.h"
8 #include "FormatCoordsUnits.h"
9 #include "Logger.h"
10 #include <qdebug.h>
11 #include <qmath.h>
12 #include <QTextStream>
13 #include <QVector>
14 #include "Spline.h"
15 #include "SplinePair.h"
16 #include "Transformation.h"
17 #include <vector>
18 
19 using namespace std;
20 
21 const int COLUMNS_PER_CURVE = 2;
22 
24 {
25 }
26 
27 void ExportFileRelations::exportAllPerLineXThetaValuesMerged (const DocumentModelExportFormat &modelExportOverride,
28  const Document &document,
29  const MainWindowModel &modelMainWindow,
30  const QStringList &curvesIncluded,
31  const QString &delimiter,
32  const Transformation &transformation,
33  QTextStream &str) const
34 {
35  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::exportAllPerLineXThetaValuesMerged";
36 
37  int curveCount = curvesIncluded.count();
38  int maxColumnSize = maxColumnSizeAllocation (modelExportOverride,
39  document,
40  transformation,
41  curvesIncluded);
42 
43  // Skip if every curve was a function
44  if (maxColumnSize > 0) {
45 
46  QVector<QVector<QString*> > xThetaYRadiusValues (COLUMNS_PER_CURVE * curveCount, QVector<QString*> (maxColumnSize));
47  initializeXThetaYRadiusValues (curvesIncluded,
48  xThetaYRadiusValues);
49  loadXThetaYRadiusValues (modelExportOverride,
50  document,
51  modelMainWindow,
52  curvesIncluded,
53  transformation,
54  xThetaYRadiusValues);
55  outputXThetaYRadiusValues (modelExportOverride,
56  curvesIncluded,
57  xThetaYRadiusValues,
58  delimiter,
59  str);
60  destroy2DArray (xThetaYRadiusValues);
61  }
62 }
63 
64 void ExportFileRelations::exportOnePerLineXThetaValuesMerged (const DocumentModelExportFormat &modelExportOverride,
65  const Document &document,
66  const MainWindowModel &modelMainWindow,
67  const QStringList &curvesIncluded,
68  const QString &delimiter,
69  const Transformation &transformation,
70  QTextStream &str) const
71 {
72  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::exportOnePerLineXThetaValuesMerged";
73 
74  QStringList::const_iterator itr;
75  for (itr = curvesIncluded.begin(); itr != curvesIncluded.end(); itr++) {
76 
77  QString curveIncluded = *itr;
78 
79  exportAllPerLineXThetaValuesMerged (modelExportOverride,
80  document,
81  modelMainWindow,
82  QStringList (curveIncluded),
83  delimiter,
84  transformation,
85  str);
86  }
87 }
88 
90  const Document &document,
91  const MainWindowModel &modelMainWindow,
92  const Transformation &transformation,
93  QTextStream &str) const
94 {
95  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::exportToFile";
96 
97  // Identify curves to be included
98  QStringList curvesIncluded = curvesToInclude (modelExportOverride,
99  document,
100  document.curvesGraphsNames(),
101  CONNECT_AS_RELATION_SMOOTH,
102  CONNECT_AS_RELATION_STRAIGHT);
103 
104  // Delimiter
105  const QString delimiter = exportDelimiterToText (modelExportOverride.delimiter());
106 
107  // Export in one of two layouts
108  if (modelExportOverride.layoutFunctions() == EXPORT_LAYOUT_ALL_PER_LINE) {
109  exportAllPerLineXThetaValuesMerged (modelExportOverride,
110  document,
111  modelMainWindow,
112  curvesIncluded,
113  delimiter,
114  transformation,
115  str);
116  } else {
117  exportOnePerLineXThetaValuesMerged (modelExportOverride,
118  document,
119  modelMainWindow,
120  curvesIncluded,
121  delimiter,
122  transformation,
123  str);
124  }
125 }
126 
127 void ExportFileRelations::initializeXThetaYRadiusValues (const QStringList &curvesIncluded,
128  QVector<QVector<QString*> > &xThetaYRadiusValues) const
129 {
130  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::initializeXThetaYRadiusValues";
131 
132  // Initialize every entry with empty string
133  int curveCount = curvesIncluded.count();
134  int xThetaCount = xThetaYRadiusValues [0].count();
135  for (int row = 0; row < xThetaCount; row++) {
136  for (int col = 0; col < COLUMNS_PER_CURVE * curveCount; col++) {
137  xThetaYRadiusValues [col] [row] = new QString;
138  }
139  }
140 }
141 
142 QPointF ExportFileRelations::linearlyInterpolate (const Points &points,
143  double ordinal,
144  const Transformation &transformation) const
145 {
146  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::linearlyInterpolate";
147 
148  double xTheta = 0, yRadius = 0;
149  double ordinalBefore = 0; // Not set until ip=1
150  QPointF posGraphBefore; // Not set until ip=1
151  bool foundIt = false;
152  for (int ip = 0; ip < points.count(); ip++) {
153 
154  const Point &point = points.at (ip);
155  QPointF posGraph;
156  transformation.transformScreenToRawGraph (point.posScreen(),
157  posGraph);
158 
159  if (ordinal <= point.ordinal()) {
160 
161  foundIt = true;
162  if (ip == 0) {
163 
164  // Use first point
165  xTheta = posGraph.x();
166  yRadius = posGraph.y();
167 
168  } else {
169 
170  // Between posGraphBefore and posGraph. Note that if posGraph.x()=posGraphBefore.x() then
171  // previous iteration of loop would have been used for interpolation, and then the loop was exited
172  double s = (ordinal - ordinalBefore) / (point.ordinal() - ordinalBefore);
173  xTheta = (1.0 - s) * posGraphBefore.x() + s * posGraph.x();
174  yRadius = (1.0 - s) * posGraphBefore.y() + s * posGraph.y();
175  }
176 
177  break;
178  }
179 
180  ordinalBefore = point.ordinal();
181  posGraphBefore = posGraph;
182  }
183 
184  if (!foundIt) {
185 
186  // Use last point
187  xTheta = posGraphBefore.x();
188  yRadius = posGraphBefore.y();
189 
190  }
191 
192  return QPointF (xTheta,
193  yRadius);
194 }
195 
196 void ExportFileRelations::loadXThetaYRadiusValues (const DocumentModelExportFormat &modelExportOverride,
197  const Document &document,
198  const MainWindowModel &modelMainWindow,
199  const QStringList &curvesIncluded,
200  const Transformation &transformation,
201  QVector<QVector<QString*> > &xThetaYRadiusValues) const
202 {
203  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::loadXThetaYRadiusValues";
204 
205  // The curve processing logic here is mirrored in maxColumnSizeAllocation so the array allocations are in sync
206  for (int ic = 0; ic < curvesIncluded.count(); ic++) {
207 
208  int colXTheta = 2 * ic;
209  int colYRadius = 2 * ic + 1;
210 
211  const QString curveName = curvesIncluded.at (ic);
212 
213  const Curve *curve = document.curveForCurveName (curveName);
214  const Points points = curve->points ();
215 
216  if (modelExportOverride.pointsSelectionRelations() == EXPORT_POINTS_SELECTION_RELATIONS_RAW) {
217 
218  // No interpolation. Raw points
219  loadXThetaYRadiusValuesForCurveRaw (document.modelCoords(),
220  modelMainWindow,
221  points,
222  xThetaYRadiusValues [colXTheta],
223  xThetaYRadiusValues [colYRadius],
224  transformation);
225  } else {
226 
227  const LineStyle &lineStyle = document.modelCurveStyles().lineStyle(curveName);
228 
229  // Interpolation. Points are taken approximately every every modelExport.pointsIntervalRelations
230  ExportValuesOrdinal ordinals = ordinalsAtIntervals (modelExportOverride.pointsIntervalRelations(),
231  modelExportOverride.pointsIntervalUnitsRelations(),
232  lineStyle.curveConnectAs(),
233  transformation,
234  points);
235 
236  if (curve->curveStyle().lineStyle().curveConnectAs() == CONNECT_AS_RELATION_SMOOTH) {
237 
238  loadXThetaYRadiusValuesForCurveInterpolatedSmooth (document.modelCoords(),
239  modelMainWindow,
240  points,
241  ordinals,
242  xThetaYRadiusValues [colXTheta],
243  xThetaYRadiusValues [colYRadius],
244  transformation);
245 
246  } else {
247 
248  loadXThetaYRadiusValuesForCurveInterpolatedStraight (document.modelCoords(),
249  modelMainWindow,
250  points,
251  ordinals,
252  xThetaYRadiusValues [colXTheta],
253  xThetaYRadiusValues [colYRadius],
254  transformation);
255  }
256  }
257  }
258 }
259 
260 void ExportFileRelations::loadXThetaYRadiusValuesForCurveInterpolatedSmooth (const DocumentModelCoords &modelCoords,
261  const MainWindowModel &modelMainWindow,
262  const Points &points,
263  const ExportValuesOrdinal &ordinals,
264  QVector<QString*> &xThetaValues,
265  QVector<QString*> &yRadiusValues,
266  const Transformation &transformation) const
267 {
268  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::loadXThetaYRadiusValuesForCurveInterpolatedSmooth";
269 
270  vector<double> t;
271  vector<SplinePair> xy;
272  ExportOrdinalsSmooth ordinalsSmooth;
273 
274  ordinalsSmooth.loadSplinePairsWithTransformation (points,
275  transformation,
276  t,
277  xy);
278 
279  // Fit a spline
280  Spline spline (t,
281  xy);
282 
283  FormatCoordsUnits format;
284 
285  // Extract the points
286  for (int row = 0; row < ordinals.count(); row++) {
287 
288  double ordinal = ordinals.at (row);
289  SplinePair splinePairFound = spline.interpolateCoeff(ordinal);
290  double xTheta = splinePairFound.x ();
291  double yRadius = splinePairFound.y ();
292 
293  // Save values for this row into xThetaValues and yRadiusValues, after appropriate formatting
294  format.unformattedToFormatted (xTheta,
295  yRadius,
296  modelCoords,
297  modelMainWindow,
298  *(xThetaValues [row]),
299  *(yRadiusValues [row]),
300  transformation);
301  }
302 }
303 
304 void ExportFileRelations::loadXThetaYRadiusValuesForCurveInterpolatedStraight (const DocumentModelCoords &modelCoords,
305  const MainWindowModel &modelMainWindow,
306  const Points &points,
307  const ExportValuesOrdinal &ordinals,
308  QVector<QString*> &xThetaValues,
309  QVector<QString*> &yRadiusValues,
310  const Transformation &transformation) const
311 {
312  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::loadXThetaYRadiusValuesForCurveInterpolatedStraight";
313 
314  FormatCoordsUnits format;
315 
316  // Get value at desired points
317  for (int row = 0; row < ordinals.count(); row++) {
318 
319  double ordinal = ordinals.at (row);
320 
321  QPointF pointInterpolated = linearlyInterpolate (points,
322  ordinal,
323  transformation);
324 
325  // Save values for this row into xThetaValues and yRadiusValues, after appropriate formatting
326  format.unformattedToFormatted (pointInterpolated.x(),
327  pointInterpolated.y(),
328  modelCoords,
329  modelMainWindow,
330  *(xThetaValues [row]),
331  *(yRadiusValues [row]),
332  transformation);
333  }
334 }
335 
336 void ExportFileRelations::loadXThetaYRadiusValuesForCurveRaw (const DocumentModelCoords &modelCoords,
337  const MainWindowModel &modelMainWindow,
338  const Points &points,
339  QVector<QString*> &xThetaValues,
340  QVector<QString*> &yRadiusValues,
341  const Transformation &transformation) const
342 {
343  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::loadXThetaYRadiusValuesForCurveRaw";
344 
345  FormatCoordsUnits format;
346 
347  for (int pt = 0; pt < points.count(); pt++) {
348 
349  const Point &point = points.at (pt);
350 
351  QPointF posGraph;
352  transformation.transformScreenToRawGraph (point.posScreen(),
353  posGraph);
354 
355  // Save values for this row into xThetaValues and yRadiusValues, after appropriate formatting
356  format.unformattedToFormatted (posGraph.x(),
357  posGraph.y(),
358  modelCoords,
359  modelMainWindow,
360  *(xThetaValues [pt]),
361  *(yRadiusValues [pt]),
362  transformation);
363  }
364 }
365 
366 int ExportFileRelations::maxColumnSizeAllocation (const DocumentModelExportFormat &modelExport,
367  const Document &document,
368  const Transformation &transformation,
369  const QStringList &curvesIncluded) const
370 {
371  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::maxColumnSizeAllocation";
372 
373  int maxColumnSize = 0;
374 
375  // The curve processing logic here is mirrored in loadXThetaYRadiusValues so the array allocations are in sync
376  for (int ic = 0; ic < curvesIncluded.count(); ic++) {
377 
378  const QString curveName = curvesIncluded.at (ic);
379 
380  const Curve *curve = document.curveForCurveName (curveName);
381  const Points points = curve->points ();
382 
383  if (modelExport.pointsSelectionRelations() == EXPORT_POINTS_SELECTION_RELATIONS_RAW) {
384 
385  // No interpolation. Raw points
386  maxColumnSize = qMax (maxColumnSize,
387  points.count());
388 
389  } else {
390 
391  const LineStyle &lineStyle = document.modelCurveStyles().lineStyle(curveName);
392 
393  // Interpolation. Points are taken approximately every every modelExport.pointsIntervalRelations
394  ExportValuesOrdinal ordinals = ordinalsAtIntervals (modelExport.pointsIntervalRelations(),
395  modelExport.pointsIntervalUnitsRelations(),
396  lineStyle.curveConnectAs(),
397  transformation,
398  points);
399 
400  maxColumnSize = qMax (maxColumnSize,
401  ordinals.count());
402  }
403  }
404 
405  return maxColumnSize;
406 }
407 
408 ExportValuesOrdinal ExportFileRelations::ordinalsAtIntervals (double pointsIntervalRelations,
409  ExportPointsIntervalUnits pointsIntervalUnits,
410  CurveConnectAs curveConnectAs,
411  const Transformation &transformation,
412  const Points &points) const
413 {
414  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::ordinalsAtIntervals";
415 
416  if (pointsIntervalUnits == EXPORT_POINTS_INTERVAL_UNITS_GRAPH) {
417  if (curveConnectAs == CONNECT_AS_RELATION_SMOOTH) {
418 
419  return ordinalsAtIntervalsSmoothGraph (pointsIntervalRelations,
420  transformation,
421  points);
422 
423  } else {
424 
425  return ordinalsAtIntervalsStraightGraph (pointsIntervalRelations,
426  transformation,
427  points);
428 
429  }
430  } else {
431 
432  if (curveConnectAs == CONNECT_AS_RELATION_SMOOTH) {
433 
434  return ordinalsAtIntervalsSmoothScreen (pointsIntervalRelations,
435  points);
436 
437  } else {
438 
439  return ordinalsAtIntervalsStraightScreen (pointsIntervalRelations,
440  points);
441 
442  }
443  }
444 }
445 
446 ExportValuesOrdinal ExportFileRelations::ordinalsAtIntervalsSmoothGraph (double pointsIntervalRelations,
447  const Transformation &transformation,
448  const Points &points) const
449 {
450  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::ordinalsAtIntervalsSmoothGraph";
451 
452  ExportValuesOrdinal ordinals;
453 
454  // Prevent infinite loop when there are no points or will be too many points
455  if ((pointsIntervalRelations > 0) &&
456  (points.count() > 0)) {
457 
458  vector<double> t;
459  vector<SplinePair> xy;
460  ExportOrdinalsSmooth ordinalsSmooth;
461 
462  ordinalsSmooth.loadSplinePairsWithTransformation (points,
463  transformation,
464  t,
465  xy);
466 
467  ordinals = ordinalsSmooth.ordinalsAtIntervalsGraph (t,
468  xy,
469  pointsIntervalRelations);
470  }
471 
472  return ordinals;
473 }
474 
475 ExportValuesOrdinal ExportFileRelations::ordinalsAtIntervalsSmoothScreen (double pointsIntervalRelations,
476  const Points &points) const
477 {
478  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::ordinalsAtIntervalsSmoothScreen"
479  << " pointCount=" << points.count();
480 
481  // Results
482  ExportValuesOrdinal ordinals;
483 
484  // Prevent infinite loop when there are no points or will be too many points
485  if ((pointsIntervalRelations > 0) &&
486  (points.count() > 0)) {
487 
488  vector<double> t;
489  vector<SplinePair> xy;
490  ExportOrdinalsSmooth ordinalsSmooth;
491 
492  ordinalsSmooth.loadSplinePairsWithoutTransformation (points,
493  t,
494  xy);
495 
496  ordinals = ordinalsSmooth.ordinalsAtIntervalsGraph (t,
497  xy,
498  pointsIntervalRelations);
499  }
500 
501  return ordinals;
502 }
503 
504 ExportValuesOrdinal ExportFileRelations::ordinalsAtIntervalsStraightGraph (double pointsIntervalRelations,
505  const Transformation &transformation,
506  const Points &points) const
507 {
508  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::ordinalsAtIntervalsStraightGraph";
509 
510  ExportValuesOrdinal ordinals;
511 
512  // Prevent infinite loop when there are no points or will be too many points
513  if ((pointsIntervalRelations > 0) &&
514  (points.count() > 0)) {
515 
516  ExportOrdinalsStraight ordinalsStraight;
517 
518  ordinals = ordinalsStraight.ordinalsAtIntervalsGraphWithTransformation (points,
519  transformation,
520  pointsIntervalRelations);
521  }
522 
523  return ordinals;
524 }
525 
526 ExportValuesOrdinal ExportFileRelations::ordinalsAtIntervalsStraightScreen (double pointsIntervalRelations,
527  const Points &points) const
528 {
529  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::ordinalsAtIntervalsStraightScreen"
530  << " pointCount=" << points.count();
531 
532  // Results
533  ExportValuesOrdinal ordinals;
534 
535  // Prevent infinite loop when there are no points or will be too many points
536  if ((pointsIntervalRelations > 0) &&
537  (points.count() > 0)) {
538 
539  ExportOrdinalsStraight ordinalsStraight;
540 
541  ordinals = ordinalsStraight.ordinalsAtIntervalsGraphWithoutTransformation (points,
542  pointsIntervalRelations);
543  }
544 
545  return ordinals;
546 }
547 
548 void ExportFileRelations::outputXThetaYRadiusValues (const DocumentModelExportFormat &modelExportOverride,
549  const QStringList &curvesIncluded,
550  QVector<QVector<QString*> > &xThetaYRadiusValues,
551  const QString &delimiter,
552  QTextStream &str) const
553 {
554  LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::outputXThetaYRadiusValues";
555 
556  // Header
557  if (modelExportOverride.header() != EXPORT_HEADER_NONE) {
558  if (modelExportOverride.header() == EXPORT_HEADER_GNUPLOT) {
559  str << curveSeparator(str.string());
560  str << gnuplotComment();
561  }
562  QString delimiterForRow;
563  QStringList::const_iterator itr;
564  for (itr = curvesIncluded.begin(); itr != curvesIncluded.end(); itr++) {
565  QString curveName = *itr;
566  str << delimiterForRow << modelExportOverride.xLabel();
567  delimiterForRow = delimiter;
568  str << delimiterForRow << curveName;
569  }
570  str << "\n";
571  }
572 
573  for (int row = 0; row < xThetaYRadiusValues [0].count(); row++) {
574 
575  QString delimiterForRow;
576  for (int col = 0; col < xThetaYRadiusValues.count(); col++) {
577 
578  str << delimiterForRow << *(xThetaYRadiusValues [col] [row]);
579  delimiterForRow = delimiter;
580  }
581 
582  str << "\n";
583  }
584 }
void transformScreenToRawGraph(const QPointF &coordScreen, QPointF &coordGraph) const
Transform from cartesian pixel screen coordinates to cartesian/polar graph coordinates.
ExportLayoutFunctions layoutFunctions() const
Get method for functions layout.
Cubic interpolation given independent and dependent value vectors.
Definition: Spline.h:15
ExportPointsIntervalUnits pointsIntervalUnitsRelations() const
Get method for points interval units for relations.
const Points points() const
Return a shallow copy of the Points.
Definition: Curve.cpp:369
Model for DlgSettingsExportFormat and CmdSettingsExportFormat.
void exportToFile(const DocumentModelExportFormat &modelExportOverride, const Document &document, const MainWindowModel &modelMainWindow, const Transformation &transformation, QTextStream &str) const
Export Document points according to the settings.
LineStyle lineStyle() const
Get method for LineStyle.
Definition: CurveStyle.cpp:20
DocumentModelCoords modelCoords() const
Get method for DocumentModelCoords.
Definition: Document.cpp:652
double y() const
Get method for y.
Definition: SplinePair.cpp:65
Class that represents one digitized point. The screen-to-graph coordinate transformation is always ex...
Definition: Point.h:17
QPointF posScreen() const
Accessor for screen position.
Definition: Point.cpp:344
ExportHeader header() const
Get method for header.
const LineStyle lineStyle(const QString &curveName) const
Get method for copying one line style in one step.
Definition: CurveStyles.cpp:90
void unformattedToFormatted(double xThetaUnformatted, double yRadiusUnformatted, const DocumentModelCoords &modelCoords, const MainWindowModel &mainWindowModel, QString &xThetaFormatted, QString &yRadiusFormatted, const Transformation &transformation) const
Convert unformatted numeric value to formatted string. Transformation is used to determine best resol...
Affine transformation between screen and graph coordinates, based on digitized axis points...
ExportValuesOrdinal ordinalsAtIntervalsGraphWithoutTransformation(const Points &points, double pointsInterval) const
Compute ordinals, without any conversion to graph coordinates.
QString xLabel() const
Get method for x label.
CurveStyles modelCurveStyles() const
Get method for CurveStyles.
Definition: Document.cpp:657
void loadSplinePairsWithTransformation(const Points &points, const Transformation &transformation, std::vector< double > &t, std::vector< SplinePair > &xy) const
Load t (=ordinal) and xy (=screen position) spline pairs, converting screen coordinates to graph coor...
Model for DlgSettingsMainWindow and CmdSettingsMainWindow.
void loadSplinePairsWithoutTransformation(const Points &points, std::vector< double > &t, std::vector< SplinePair > &xy) const
Load t (=ordinal) and xy (=screen position) spline pairs, without any conversion to graph coordinates...
Utility class to interpolate points spaced evenly along a piecewise defined curve with fitted spline...
ExportDelimiter delimiter() const
Get method for delimiter.
Model for DlgSettingsCoords and CmdSettingsCoords.
double pointsIntervalRelations() const
Get method for relations interval for relations.
Storage of one imported image and the data attached to that image.
Definition: Document.h:29
Container for one set of digitized Points.
Definition: Curve.h:26
ExportValuesOrdinal ordinalsAtIntervalsGraph(const std::vector< double > &t, const std::vector< SplinePair > &xy, double pointsInterval) const
Perform the interpolation on the arrays loaded by the other methods.
Details for a specific Line.
Definition: LineStyle.h:13
QStringList curvesGraphsNames() const
See CurvesGraphs::curvesGraphsNames.
Definition: Document.cpp:299
Highest-level wrapper around other Formats classes.
Utility class to interpolate points spaced evenly along a piecewise defined curve with line segments ...
double x() const
Get method for x.
Definition: SplinePair.cpp:60
const Curve * curveForCurveName(const QString &curveName) const
See CurvesGraphs::curveForCurveNames, although this also works for AXIS_CURVE_NAME.
Definition: Document.cpp:281
CurveStyle curveStyle() const
Return the curve style.
Definition: Curve.cpp:132
double ordinal(ApplyHasCheck applyHasCheck=KEEP_HAS_CHECK) const
Get method for ordinal. Skip check if copying one instance to another.
Definition: Point.cpp:326
ExportFileRelations()
Single constructor.
CurveConnectAs curveConnectAs() const
Get method for connect type.
Definition: LineStyle.cpp:56
ExportValuesOrdinal ordinalsAtIntervalsGraphWithTransformation(const Points &points, const Transformation &transformation, double pointsInterval) const
Compute ordinals, converting screen coordinates to graph coordinates.
Single X/Y pair for cubic spline interpolation initialization and calculations.
Definition: SplinePair.h:5
ExportPointsSelectionRelations pointsSelectionRelations() const
Get method for point selection for relations.