Engauge Digitizer  2
CoordSystem.cpp
1 /******************************************************************************************************
2  * (C) 2014 markummitchell@github.com. This file is part of Engauge Digitizer, which is released *
3  * under GNU General Public License version 2 (GPLv2) or (at your option) any later version. See file *
4  * LICENSE or go to gnu.org/licenses for details. Distribution requires prior written permission. *
5  ******************************************************************************************************/
6 
7 #include "CallbackAddPointsInCurvesGraphs.h"
8 #include "CallbackCheckAddPointAxis.h"
9 #include "CallbackCheckEditPointAxis.h"
10 #include "CallbackNextOrdinal.h"
11 #include "CallbackRemovePointsInCurvesGraphs.h"
12 #include "CoordSystem.h"
13 #include "Curve.h"
14 #include "CurvesGraphs.h"
15 #include "CurveStyles.h"
16 #include "DocumentSerialize.h"
17 #include "EngaugeAssert.h"
18 #include "EnumsToQt.h"
19 #include <iostream>
20 #include "Logger.h"
21 #include "OrdinalGenerator.h"
22 #include "Point.h"
23 #include <QByteArray>
24 #include <QDataStream>
25 #include <QDebug>
26 #include <QFile>
27 #include <QImage>
28 #include <QtToString.h>
29 #include <QXmlStreamReader>
30 #include <QXmlStreamWriter>
31 #include "SettingsForGraph.h"
32 #include "Transformation.h"
33 #include "Version.h"
34 #include "Xml.h"
35 
36 const int FOUR_BYTES = 4;
37 
39  m_curveAxes (new Curve (AXIS_CURVE_NAME,
40  ColorFilterSettings::defaultFilter (),
41  CurveStyle (LineStyle::defaultAxesCurve(),
42  PointStyle::defaultAxesCurve ())))
43 {
44  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::CoordSystem";
45 
46  SettingsForGraph settingsForGraph;
47 
48  // Create one curve, or as many curve as specified in the configuration file, whichever is greater
49  for (int indexOneBased = 1; indexOneBased <= settingsForGraph.numberOfCurvesForImport (); indexOneBased++) {
50 
51  QString curveName = settingsForGraph.defaultCurveName (indexOneBased,
52  DEFAULT_GRAPH_CURVE_NAME);
53  m_curvesGraphs.addGraphCurveAtEnd (Curve (curveName,
56  PointStyle::defaultGraphCurve (m_curvesGraphs.numCurves ()))));
57 
58  resetSelectedCurveNameIfNecessary ();
59  }
60 }
61 
62 void CoordSystem::addGraphCurveAtEnd (const QString &curveName)
63 {
64  m_curvesGraphs.addGraphCurveAtEnd (Curve (curveName,
67  PointStyle::defaultGraphCurve(m_curvesGraphs.numCurves()))));
68 
69  resetSelectedCurveNameIfNecessary ();
70 }
71 
72 void CoordSystem::addPointAxisWithGeneratedIdentifier (const QPointF &posScreen,
73  const QPointF &posGraph,
74  QString &identifier,
75  double ordinal,
76  bool isXOnly)
77 {
78  Point point (AXIS_CURVE_NAME,
79  posScreen,
80  posGraph,
81  ordinal,
82  isXOnly);
83  m_curveAxes->addPoint (point);
84 
85  identifier = point.identifier();
86 
87  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::addPointAxisWithGeneratedIdentifier"
88  << " ordinal=" << ordinal
89  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ()
90  << " posGraph=" << QPointFToString (posGraph).toLatin1 ().data ()
91  << " identifier=" << identifier.toLatin1 ().data ();
92 }
93 
94 void CoordSystem::addPointAxisWithSpecifiedIdentifier (const QPointF &posScreen,
95  const QPointF &posGraph,
96  const QString &identifier,
97  double ordinal,
98  bool isXOnly)
99 {
100  Point point (AXIS_CURVE_NAME,
101  identifier,
102  posScreen,
103  posGraph,
104  ordinal,
105  isXOnly);
106  m_curveAxes->addPoint (point);
107 
108  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::addPointAxisWithSpecifiedIdentifier"
109  << " ordinal=" << ordinal
110  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ()
111  << " posGraph=" << QPointFToString (posGraph).toLatin1 ().data ()
112  << " identifier=" << identifier.toLatin1 ().data ();
113 }
114 
116  const QPointF &posScreen,
117  QString &identifier,
118  double ordinal)
119 {
120  Point point (curveName,
121  posScreen,
122  ordinal);
123  m_curvesGraphs.addPoint (point);
124 
125  identifier = point.identifier();
126 
127  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::addPointGraphWithGeneratedIdentifier"
128  << " ordinal=" << ordinal
129  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ()
130  << " identifier=" << identifier.toLatin1 ().data ();
131 }
132 
134  const QPointF &posScreen,
135  const QString &identifier,
136  double ordinal)
137 {
138  Point point (curveName,
139  identifier,
140  posScreen,
141  ordinal);
142  m_curvesGraphs.addPoint (point);
143 
144  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::addPointGraphWithSpecifiedIdentifier"
145  << " ordinal=" << ordinal
146  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ()
147  << " identifier=" << identifier.toLatin1 ().data ();
148 }
149 
151 {
152  CallbackAddPointsInCurvesGraphs ftor (*this);
153 
154  Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
156 
157  curvesGraphs.iterateThroughCurvesPoints (ftorWithCallback);
158 }
159 
160 bool CoordSystem::bytesIndicatePreVersion6 (const QByteArray &bytes) const
161 {
162  QByteArray preVersion6MagicNumber;
163  preVersion6MagicNumber.resize (FOUR_BYTES);
164 
165  // Windows compiler gives warning if 0x## is used instead of '\x##' below
166  preVersion6MagicNumber[0] = '\x00';
167  preVersion6MagicNumber[1] = '\x00';
168  preVersion6MagicNumber[2] = '\xCA';
169  preVersion6MagicNumber[3] = '\xFE';
170 
171  return (bytes == preVersion6MagicNumber);
172 }
173 
174 void CoordSystem::checkAddPointAxis (const QPointF &posScreen,
175  const QPointF &posGraph,
176  bool &isError,
177  QString &errorMessage,
178  bool isXOnly,
179  DocumentAxesPointsRequired documentAxesPointsRequired)
180 {
181  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::checkAddPointAxis"
182  << " posScreen=" << QPointFToString (posScreen).toLatin1 ().data ()
183  << " posGraph=" << QPointFToString (posGraph).toLatin1 ().data ();
184 
185  CallbackCheckAddPointAxis ftor (m_modelCoords,
186  posScreen,
187  posGraph,
188  documentAxesPointsRequired,
189  isXOnly);
190 
191  Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
193  m_curveAxes->iterateThroughCurvePoints (ftorWithCallback);
194 
195  isError = ftor.isError ();
196  errorMessage = ftor.errorMessage ();
197 }
198 
199 void CoordSystem::checkEditPointAxis (const QString &pointIdentifier,
200  const QPointF &posScreen,
201  const QPointF &posGraph,
202  bool &isError,
203  QString &errorMessage,
204  DocumentAxesPointsRequired documentAxesPointsRequired)
205 {
206  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::checkEditPointAxis"
207  << " posGraph=" << QPointFToString (posGraph).toLatin1 ().data ();
208 
209  CallbackCheckEditPointAxis ftor (m_modelCoords,
210  pointIdentifier,
211  posScreen,
212  posGraph,
213  documentAxesPointsRequired);
214 
215  Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
217  m_curveAxes->iterateThroughCurvePoints (ftorWithCallback);
218 
219  isError = ftor.isError ();
220  errorMessage = ftor.errorMessage ();
221 }
222 
224 {
225  ENGAUGE_CHECK_PTR (m_curveAxes);
226 
227  return *m_curveAxes;
228 }
229 
230 Curve *CoordSystem::curveForCurveName (const QString &curveName)
231 {
232  if (curveName == AXIS_CURVE_NAME) {
233 
234  return m_curveAxes;
235 
236  } else {
237 
238  return m_curvesGraphs.curveForCurveName (curveName);
239 
240  }
241 }
242 
243 const Curve *CoordSystem::curveForCurveName (const QString &curveName) const
244 {
245  if (curveName == AXIS_CURVE_NAME) {
246 
247  return m_curveAxes;
248 
249  } else {
250 
251  return m_curvesGraphs.curveForCurveName (curveName);
252 
253  }
254 }
255 
257 {
258  return m_curvesGraphs;
259 }
260 
262 {
263  return m_curvesGraphs.curvesGraphsNames();
264 }
265 
266 int CoordSystem::curvesGraphsNumPoints(const QString &curveName) const
267 {
268  return m_curvesGraphs.curvesGraphsNumPoints(curveName);
269 }
270 
271 void CoordSystem::editPointAxis (const QPointF &posGraph,
272  const QString &identifier)
273 {
274  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::editPointAxis"
275  << " posGraph=(" << posGraph.x () << ", " << posGraph.y () << ") identifier="
276  << " identifier=" << identifier.toLatin1 ().data ();
277 
278  m_curveAxes->editPointAxis (posGraph,
279  identifier);
280 }
281 
283  bool isY,
284  double x,
285  double y,
286  const QStringList &identifiers,
287  const Transformation &transformation)
288 {
289  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::editPointGraph posGraph=("
290  << " x=" << (isX ? QString::number (x).toLatin1().data() : "")
291  << " y=" << (isY ? QString::number (y).toLatin1().data() : "")
292  << ") identifiers=" << identifiers.join(" ").toLatin1 ().data ();
293 
294  m_curvesGraphs.editPointGraph (isX,
295  isY,
296  x,
297  y,
298  identifiers,
299  transformation);
300 }
301 
302 bool CoordSystem::isXOnly (const QString &pointIdentifier) const
303 {
304  return m_curveAxes->isXOnly (pointIdentifier);
305 }
306 
307 void CoordSystem::iterateThroughCurvePointsAxes (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback)
308 {
309  ENGAUGE_CHECK_PTR (m_curveAxes);
310 
311  m_curveAxes->iterateThroughCurvePoints (ftorWithCallback);
312 }
313 
314 void CoordSystem::iterateThroughCurvePointsAxes (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback) const
315 {
316  ENGAUGE_CHECK_PTR (m_curveAxes);
317 
318  m_curveAxes->iterateThroughCurvePoints (ftorWithCallback);
319 }
320 
321 void CoordSystem::iterateThroughCurveSegments (const QString &curveName,
322  const Functor2wRet<const Point &, const Point &, CallbackSearchReturn> &ftorWithCallback) const
323 {
324  if (curveName == AXIS_CURVE_NAME) {
325  m_curveAxes->iterateThroughCurveSegments(ftorWithCallback);
326  } else {
327  m_curvesGraphs.iterateThroughCurveSegments(curveName,
328  ftorWithCallback);
329  }
330 }
331 
332 void CoordSystem::iterateThroughCurvesPointsGraphs (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback)
333 {
334  ENGAUGE_CHECK_PTR (m_curveAxes);
335 
336  m_curvesGraphs.iterateThroughCurvesPoints (ftorWithCallback);
337 }
338 
339 void CoordSystem::iterateThroughCurvesPointsGraphs (const Functor2wRet<const QString &, const Point &, CallbackSearchReturn> &ftorWithCallback) const
340 {
341  ENGAUGE_CHECK_PTR (m_curveAxes);
342 
343  m_curvesGraphs.iterateThroughCurvesPoints (ftorWithCallback);
344 }
345 
346 bool CoordSystem::loadCurvesFile(const QString & /* curvesFile */)
347 {
348  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::loadCurvesFile";
349 
350  return true;
351 }
352 
353 void CoordSystem::loadPreVersion6 (QDataStream &str,
354  double version,
355  DocumentAxesPointsRequired &documentAxesPointsRequired)
356 {
357  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::loadPreVersion6";
358 
359  qint32 int32;
360  double dbl, radius = 0.0;
361  QString st;
362 
363  str >> st; // CurveCmbText selection
364  str >> st; // MeasureCmbText selection
365  str >> int32;
366  m_modelCoords.setCoordsType((CoordsType) int32);
367  if (version >= 3) {
368  str >> (double &) radius;
369  }
370  m_modelCoords.setOriginRadius(radius);
371  str >> int32;
372  m_modelCoords.setCoordUnitsRadius(COORD_UNITS_NON_POLAR_THETA_NUMBER);
373  m_modelCoords.setCoordUnitsTheta((CoordUnitsPolarTheta) int32);
374  str >> int32;
375  m_modelCoords.setCoordScaleXTheta((CoordScale) int32);
376  str >> int32;
377  m_modelCoords.setCoordScaleYRadius((CoordScale) int32);
378 
379  str >> int32;
380  m_modelExport.setDelimiter((ExportDelimiter) int32);
381  str >> int32;
382  m_modelExport.setLayoutFunctions((ExportLayoutFunctions) int32);
383  str >> int32;
384  m_modelExport.setPointsSelectionFunctions((ExportPointsSelectionFunctions) int32);
385  m_modelExport.setPointsSelectionRelations(EXPORT_POINTS_SELECTION_RELATIONS_RAW); // Best for maps
386  m_modelExport.setPointsIntervalUnitsFunctions((ExportPointsIntervalUnits) int32);
387  m_modelExport.setPointsIntervalUnitsRelations((ExportPointsIntervalUnits) int32);
388  str >> int32;
389  m_modelExport.setHeader((ExportHeader) int32);
390  if (version >= 5.1) {
391  str >> st; // X label
392  if (m_modelCoords.coordsType() == COORDS_TYPE_CARTESIAN) {
393  m_modelExport.setXLabel(st);
394  }
395  str >> st; // Theta label
396  if (m_modelCoords.coordsType() == COORDS_TYPE_POLAR) {
397  m_modelExport.setXLabel(st);
398  }
399  }
400 
401  // Stable flag in m_modelGridRemoval is set below after points are read in
402  str >> int32; // Remove thin lines parallel to axes
403  str >> dbl; // Thin thickness
404  str >> int32;
405  m_modelGridRemoval.setRemoveDefinedGridLines(int32);
406  str >> int32; // Initialized
407  str >> int32;
408  m_modelGridRemoval.setCountX(int32);
409  str >> int32;
410  m_modelGridRemoval.setCountY(int32);
411  str >> int32;
412  m_modelGridRemoval.setGridCoordDisableX((GridCoordDisable) int32);
413  str >> int32;
414  m_modelGridRemoval.setGridCoordDisableY((GridCoordDisable) int32);
415  str >> dbl;
416  m_modelGridRemoval.setStartX(dbl);
417  str >> dbl;
418  m_modelGridRemoval.setStartY(dbl);
419  str >> dbl;
420  m_modelGridRemoval.setStepX(dbl);
421  str >> dbl;
422  m_modelGridRemoval.setStepY(dbl);
423  str >> dbl;
424  m_modelGridRemoval.setStopX(dbl);
425  str >> dbl;
426  m_modelGridRemoval.setStopY(dbl);
427  str >> dbl;
428  m_modelGridRemoval.setCloseDistance(dbl);
429  str >> int32; // Boolean remove color flag
430  if (version >= 5) {
431  QColor color;
432  str >> color;
433  } else {
434  str >> int32; // Rgb color
435  }
436  str >> int32; // Foreground threshold low
437  str >> int32; // Foreground threshold high
438  str >> dbl; // Gap separation
439 
440  str >> int32;
441  m_modelGridDisplay.setStable(int32);
442  str >> int32;
443  m_modelGridDisplay.setCountX(int32);
444  str >> int32;
445  m_modelGridDisplay.setCountY(int32);
446  str >> int32;
447  m_modelGridDisplay.setDisableX((GridCoordDisable) int32);
448  str >> int32;
449  m_modelGridDisplay.setDisableY((GridCoordDisable) int32);
450  str >> dbl;
451  m_modelGridDisplay.setStartX (dbl);
452  str >> dbl;
453  m_modelGridDisplay.setStartY (dbl);
454  str >> dbl;
455  m_modelGridDisplay.setStepX (dbl);
456  str >> dbl;
457  m_modelGridDisplay.setStepY (dbl);
458  str >> dbl;
459  m_modelGridDisplay.setStopX (dbl);
460  str >> dbl;
461  m_modelGridDisplay.setStopY (dbl);
462 
463  str >> int32;
464  m_modelSegments.setMinLength(int32);
465  str >> int32;
466  m_modelSegments.setPointSeparation(int32);
467  str >> int32;
468  m_modelSegments.setLineWidth(int32);
469  str >> int32;
470  m_modelSegments.setLineColor((ColorPalette) int32);
471 
472  str >> int32; // Point separation
473  str >> int32;
474  m_modelPointMatch.setMaxPointSize(int32);
475  str >> int32;
476  m_modelPointMatch.setPaletteColorAccepted((ColorPalette) int32);
477  str >> int32;
478  m_modelPointMatch.setPaletteColorRejected((ColorPalette) int32);
479  if (version < 4) {
480  m_modelPointMatch.setPaletteColorCandidate(COLOR_PALETTE_BLUE);
481  } else {
482  str >> int32;
483  m_modelPointMatch.setPaletteColorCandidate((ColorPalette) int32);
484  }
485 
486  str >> int32; // Discretize method
487  str >> int32; // Intensity threshold low
488  str >> int32; // Intensity threshold high
489  str >> int32; // Foreground threshold low
490  str >> int32; // Foreground threshold high
491  str >> int32; // Hue threshold low
492  str >> int32; // Hue threshold high
493  str >> int32; // Saturation threshold low
494  str >> int32; // Saturation threshold high
495  str >> int32; // Value threshold low
496  str >> int32; // Value threshold high
497 
498  // Old versions have two Curve objects for 3 point axes and 2 point scales. New version picks one Curve
499  Curve *curveAxesIn = new Curve (str);
500  Curve *curveScaleIn = new Curve (str);
501  if (curveScaleIn->numPoints() == 2) {
502  // Nondefault case is map with scale bar
503  documentAxesPointsRequired = DOCUMENT_AXES_POINTS_REQUIRED_2;
504  m_curveAxes = curveScaleIn;
505  m_curveAxes->setCurveName (AXIS_CURVE_NAME); // Override existing "Scale" name
506  delete curveAxesIn;
507  } else {
508  // Default case is graph with axes
509  documentAxesPointsRequired = DOCUMENT_AXES_POINTS_REQUIRED_3;
510  m_curveAxes = curveAxesIn;
511  delete curveScaleIn;
512  }
513  m_curvesGraphs.loadPreVersion6 (str);
514 
515  // Information from curves and points can affect some data structures that were (mostly) set earlier
516  if (m_curveAxes->numPoints () >= documentAxesPointsRequired) {
517  m_modelGridRemoval.setStable();
518  }
519 
520  resetSelectedCurveNameIfNecessary ();
521 }
522 
523 void CoordSystem::loadVersion6 (QXmlStreamReader &reader,
524  DocumentAxesPointsRequired &documentAxesPointsRequired)
525 {
526  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::loadVersion6";
527 
528  documentAxesPointsRequired = DOCUMENT_AXES_POINTS_REQUIRED_3;
529 
530  // Import from xml. Loop to end of data or error condition occurs, whichever is first
531  while (!reader.atEnd() &&
532  !reader.hasError()) {
533  QXmlStreamReader::TokenType tokenType = loadNextFromReader(reader);
534 
535  if ((reader.name() == DOCUMENT_SERIALIZE_DOCUMENT) &&
536  (tokenType == QXmlStreamReader::EndElement)) {
537 
538  // Exit out of loop immediately
539  break;
540  }
541 
542  // Iterate to next StartElement
543  if (tokenType == QXmlStreamReader::StartElement) {
544 
545  // This is a StartElement, so process it
546  QString tag = reader.name().toString();
547  if (tag == DOCUMENT_SERIALIZE_AXES_CHECKER){
548  m_modelAxesChecker.loadXml (reader);
549  } else if (tag == DOCUMENT_SERIALIZE_COORDS) {
550  m_modelCoords.loadXml (reader);
551  } else if (tag == DOCUMENT_SERIALIZE_CURVE) {
552  m_curveAxes = new Curve (reader);
553  } else if (tag == DOCUMENT_SERIALIZE_CURVES_GRAPHS) {
554  m_curvesGraphs.loadXml (reader);
555  } else if (tag == DOCUMENT_SERIALIZE_DIGITIZE_CURVE) {
556  m_modelDigitizeCurve.loadXml (reader);
557  } else if (tag == DOCUMENT_SERIALIZE_EXPORT) {
558  m_modelExport.loadXml (reader);
559  } else if (tag == DOCUMENT_SERIALIZE_GENERAL || tag == DOCUMENT_SERIALIZE_COMMON) {
560  m_modelGeneral.loadXml (reader);
561  } else if (tag == DOCUMENT_SERIALIZE_GRID_REMOVAL) {
562  m_modelGridRemoval.loadXml (reader);
563  } else if (tag == DOCUMENT_SERIALIZE_IMAGE) {
564  ENGAUGE_ASSERT (false); // The image should have been read before this method was called
565  } else if (tag == DOCUMENT_SERIALIZE_POINT_MATCH) {
566  m_modelPointMatch.loadXml (reader);
567  } else if (tag == DOCUMENT_SERIALIZE_SEGMENTS) {
568  m_modelSegments.loadXml (reader);
569  } else {
570  m_successfulRead = false;
571  m_reasonForUnsuccessfulRead = QString ("%1 '%2' %3")
572  .arg (QObject::tr ("Unexpected xml token"))
573  .arg (tag)
574  .arg ("encountered");
575  break;
576  }
577  }
578  }
579 
580  resetSelectedCurveNameIfNecessary ();
581 }
582 
583 void CoordSystem::loadVersions7AndUp (QXmlStreamReader &reader)
584 {
585  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::loadVersions7AndUp";
586 
587  // Import from xml. Loop to end of data or error condition occurs, whichever is first
588  while (!reader.atEnd() &&
589  !reader.hasError()) {
590  QXmlStreamReader::TokenType tokenType = loadNextFromReader(reader);
591 
592  if ((reader.name() == DOCUMENT_SERIALIZE_COORD_SYSTEM) &&
593  (tokenType == QXmlStreamReader::EndElement)) {
594 
595  // Exit out of loop immediately
596  break;
597  }
598 
599  // Iterate to next StartElement
600  if (tokenType == QXmlStreamReader::StartElement) {
601 
602  // This is a StartElement, so process it
603  QString tag = reader.name().toString();
604  if (tag == DOCUMENT_SERIALIZE_AXES_CHECKER){
605  m_modelAxesChecker.loadXml (reader);
606  } else if (tag == DOCUMENT_SERIALIZE_COORDS) {
607  m_modelCoords.loadXml (reader);
608  } else if (tag == DOCUMENT_SERIALIZE_CURVE) {
609  m_curveAxes = new Curve (reader);
610  } else if (tag == DOCUMENT_SERIALIZE_CURVES_GRAPHS) {
611  m_curvesGraphs.loadXml (reader);
612  } else if (tag == DOCUMENT_SERIALIZE_DIGITIZE_CURVE) {
613  m_modelDigitizeCurve.loadXml (reader);
614  } else if (tag == DOCUMENT_SERIALIZE_EXPORT) {
615  m_modelExport.loadXml (reader);
616  } else if (tag == DOCUMENT_SERIALIZE_GENERAL || tag == DOCUMENT_SERIALIZE_COMMON) {
617  m_modelGeneral.loadXml (reader);
618  } else if (tag == DOCUMENT_SERIALIZE_GRID_DISPLAY) {
619  m_modelGridDisplay.loadXml (reader);
620  } else if (tag == DOCUMENT_SERIALIZE_GRID_REMOVAL) {
621  m_modelGridRemoval.loadXml (reader);
622  } else if (tag == DOCUMENT_SERIALIZE_IMAGE) {
623  ENGAUGE_ASSERT (false); // The image should have been read before this method was called
624  } else if (tag == DOCUMENT_SERIALIZE_POINT_MATCH) {
625  m_modelPointMatch.loadXml (reader);
626  } else if (tag == DOCUMENT_SERIALIZE_SEGMENTS) {
627  m_modelSegments.loadXml (reader);
628  } else {
629  m_successfulRead = false;
630  m_reasonForUnsuccessfulRead = QString ("Unexpected xml token '%1' encountered").arg (tag);
631  break;
632  }
633  }
634  }
635 
636  resetSelectedCurveNameIfNecessary ();
637 }
638 
640 {
641  return m_modelAxesChecker;
642 }
643 
645 {
646  // Construct a curve-specific model
648 
649  return modelColorFilter;
650 }
651 
653 {
654  return m_modelCoords;
655 }
656 
658 {
659  // Construct a curve-specific model
661 
662  return modelCurveStyles;
663 }
664 
666 {
667  return m_modelDigitizeCurve;
668 }
669 
671 {
672  return m_modelExport;
673 }
674 
676 {
677  return m_modelGeneral;
678 }
679 
681 {
682  return m_modelGridDisplay;
683 }
684 
686 {
687  return m_modelGridRemoval;
688 }
689 
691 {
692  return m_modelPointMatch;
693 }
694 
696 {
697  return m_modelSegments;
698 }
699 
700 void CoordSystem::movePoint (const QString &pointIdentifier,
701  const QPointF &deltaScreen)
702 {
703  QString curveName = Point::curveNameFromPointIdentifier (pointIdentifier);
704 
705  Curve *curve = curveForCurveName (curveName);
706  ENGAUGE_ASSERT (curve != 0);
707  curve->movePoint (pointIdentifier,
708  deltaScreen);
709 }
710 
711 int CoordSystem::nextOrdinalForCurve (const QString &curveName) const
712 {
713  CallbackNextOrdinal ftor (curveName);
714 
715  Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
717 
718  if (curveName == AXIS_CURVE_NAME) {
719  m_curveAxes->iterateThroughCurvePoints (ftorWithCallback);
720  } else {
721  m_curvesGraphs.iterateThroughCurvesPoints (ftorWithCallback);
722  }
723 
724  return ftor.nextOrdinal ();
725 }
726 
727 QPointF CoordSystem::positionGraph (const QString &pointIdentifier) const
728 {
729  QString curveName = Point::curveNameFromPointIdentifier (pointIdentifier);
730 
731  const Curve *curve = curveForCurveName (curveName);
732  return curve->positionGraph (pointIdentifier);
733 }
734 
735 QPointF CoordSystem::positionScreen (const QString &pointIdentifier) const
736 {
737  QString curveName = Point::curveNameFromPointIdentifier (pointIdentifier);
738 
739  const Curve *curve = curveForCurveName (curveName);
740  return curve->positionScreen (pointIdentifier);
741 }
742 
743 void CoordSystem::print () const
744 {
745  QString text;
746  QTextStream str (&text);
747 
748  printStream ("",
749  str);
750  std::cerr << text.toLatin1().data();
751 }
752 
753 void CoordSystem::printStream (QString indentation,
754  QTextStream &str) const
755 {
756  str << indentation << "Graph\n";
757 
758  indentation += INDENTATION_DELTA;
759 
760  // str << indentation << "name=" << m_name << "\n";
761  // str << indentation << "pixmap=" << m_pixmap.width() << "x" << m_pixmap.height() << "\n";
762 
763  m_curveAxes->printStream (indentation,
764  str);
765  m_curvesGraphs.printStream (indentation,
766  str);
767 
768  m_modelAxesChecker.printStream (indentation,
769  str);
770  m_modelCoords.printStream (indentation,
771  str);
772  m_modelDigitizeCurve.printStream (indentation,
773  str);
774  m_modelExport.printStream (indentation,
775  str);
776  m_modelGeneral.printStream (indentation,
777  str);
778  m_modelGridDisplay.printStream (indentation,
779  str);
780  m_modelGridRemoval.printStream (indentation,
781  str);
782  m_modelPointMatch.printStream (indentation,
783  str);
784  m_modelSegments.printStream (indentation,
785  str);
786 }
787 
789 {
790  ENGAUGE_ASSERT (!m_successfulRead);
791 
792  return m_reasonForUnsuccessfulRead;
793 }
794 
795 void CoordSystem::removePointAxis (const QString &identifier)
796 {
797  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::removePointAxis identifier=" << identifier.toLatin1 ().data ();
798 
799  m_curveAxes->removePoint (identifier);
800 }
801 
802 void CoordSystem::removePointGraph (const QString &identifier)
803 {
804  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::removePointGraph identifier=" << identifier.toLatin1 ().data ();
805 
806  m_curvesGraphs.removePoint (identifier);
807 }
808 
810 {
812 
813  Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
815 
816  curvesGraphs.iterateThroughCurvesPoints (ftorWithCallback);
817 }
818 
819 void CoordSystem::resetSelectedCurveNameIfNecessary ()
820 {
821  if (m_selectedCurveName.isEmpty () ||
822  curveForCurveName (m_selectedCurveName) == 0) {
823 
824  // Selected curve name is empty, or the curve has been removed so we pick another. The first is arbitrarily picked
825  m_selectedCurveName = m_curvesGraphs.curvesGraphsNames().first();
826  }
827 
828 }
829 
830 void CoordSystem::saveXml (QXmlStreamWriter &writer) const
831 {
832  writer.writeStartElement(DOCUMENT_SERIALIZE_COORD_SYSTEM);
833 
834  // Serialize the Document variables
835  m_modelGeneral.saveXml (writer);
836  m_modelCoords.saveXml (writer);
837  m_modelDigitizeCurve.saveXml (writer);
838  m_modelExport.saveXml (writer);
839  m_modelAxesChecker.saveXml (writer);
840  m_modelGridDisplay.saveXml (writer);
841  m_modelGridRemoval.saveXml (writer);
842  m_modelPointMatch.saveXml (writer);
843  m_modelSegments.saveXml (writer);
844  m_curveAxes->saveXml (writer);
845  m_curvesGraphs.saveXml (writer);
846  writer.writeEndElement();
847 }
848 
850 {
851  return m_selectedCurveName;
852 }
853 
855 {
856  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::setCurveAxes";
857 
858  if (m_curveAxes != 0) {
859  delete m_curveAxes;
860  m_curveAxes = 0;
861  }
862 
863  m_curveAxes = new Curve (curveAxes);
864 }
865 
867 {
868  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::setCurvesGraphs";
869 
870  m_curvesGraphs = curvesGraphs;
871 
872  resetSelectedCurveNameIfNecessary ();
873 }
874 
876 {
877  m_modelAxesChecker = modelAxesChecker;
878 }
879 
881 {
882  // Save the CurveFilter for each Curve
883  ColorFilterSettingsList::const_iterator itr;
884  for (itr = modelColorFilter.colorFilterSettingsList().constBegin ();
885  itr != modelColorFilter.colorFilterSettingsList().constEnd();
886  itr++) {
887 
888  QString curveName = itr.key();
889  const ColorFilterSettings &colorFilterSettings = itr.value();
890 
891  Curve *curve = curveForCurveName (curveName);
892  curve->setColorFilterSettings (colorFilterSettings);
893  }
894 }
895 
897 {
898  m_modelCoords = modelCoords;
899 }
900 
902 {
903  // Save the LineStyle and PointStyle for each Curve
904  QStringList curveNames = modelCurveStyles.curveNames();
905  QStringList::iterator itr;
906  for (itr = curveNames.begin(); itr != curveNames.end(); itr++) {
907 
908  QString curveName = *itr;
909  const CurveStyle &curveStyle = modelCurveStyles.curveStyle (curveName);
910 
911  Curve *curve = curveForCurveName (curveName);
912  curve->setCurveStyle (curveStyle);
913  }
914 }
915 
917 {
918  m_modelDigitizeCurve = modelDigitizeCurve;
919 }
920 
922 {
923  m_modelExport = modelExport;
924 }
925 
927 {
928  m_modelGeneral = modelGeneral;
929 }
930 
932 {
933  m_modelGridDisplay = modelGridDisplay;
934 }
935 
937 {
938  m_modelGridRemoval = modelGridRemoval;
939 }
940 
942 {
943  m_modelPointMatch = modelPointMatch;
944 }
945 
947 {
948  m_modelSegments = modelSegments;
949 }
950 
952 {
953  m_selectedCurveName = selectedCurveName;
954 }
955 
957 {
958  return m_successfulRead;
959 }
960 
962 {
963  LOG4CPP_INFO_S ((*mainCat)) << "CoordSystem::updatePointOrdinals";
964 
965  // The graph coordinates of all points in m_curvesGraphs must have already been updated at this point. See applyTransformation
966  m_curvesGraphs.updatePointOrdinals (transformation);
967 }
bool isError() const
True if an error occurred during iteration.
void setPointsSelectionFunctions(ExportPointsSelectionFunctions exportPointsSelectionFunctions)
Set method for point selection for functions.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
const ColorFilterSettingsList & colorFilterSettingsList() const
Get method for copying all color filters in one step.
CallbackSearchReturn callback(const QString &curveName, const Point &point)
Callback method.
void removePoint(const QString &identifier)
Perform the opposite of addPointAtEnd.
Definition: Curve.cpp:510
Manage storage and retrieval of the settings for the curves.
Model for DlgSettingsGeneral and CmdSettingsGeneral.
CurveStyle curveStyle(const QString &curveName) const
CurveStyle in specified curve.
Definition: CurveStyles.cpp:79
static QString curveNameFromPointIdentifier(const QString &pointIdentifier)
Parse the curve name from the specified point identifier. This does the opposite of uniqueIdentifierG...
Definition: Point.cpp:227
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
void setStartX(double startX)
Set method for x grid line lower bound (inclusive).
Model for DlgSettingsPointMatch and CmdSettingsPointMatch.
Callback for computing the next ordinal for a new point.
Color filter parameters for one curve. For a class, this is handled the same as LineStyle and PointSt...
static LineStyle defaultGraphCurve(int index)
Initial default for index&#39;th graph curve.
Definition: LineStyle.cpp:84
Model for DlgSettingsGridDisplay and CmdSettingsGridDisplay.
int curvesGraphsNumPoints(const QString &curveName) const
Point count.
void loadXml(QXmlStreamReader &reader)
Load from serialized xml post-version 5 file.
virtual void setModelAxesChecker(const DocumentModelAxesChecker &modelAxesChecker)
Set method for DocumentModelAxesChecker.
virtual void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
Callback that is used when iterating through a read-only CurvesGraphs to remove corresponding points ...
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
void setCurveStyle(const CurveStyle &curveStyle)
Set curve style.
Definition: Curve.cpp:563
void setCloseDistance(double closeDistance)
Set method for close distance.
Model for DlgSettingsExportFormat and CmdSettingsExportFormat.
void setLineColor(ColorPalette lineColor)
Set method for line color.
void setCountY(unsigned int countY)
Set method for y grid line count.
void setStepX(double stepX)
Set method for x grid line increment.
virtual DocumentModelGridRemoval modelGridRemoval() const
Get method for DocumentModelGridRemoval.
QStringList curveNames() const
List of all curve names.
Definition: CurveStyles.cpp:67
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
Model for DlgSettingsCurveProperties and CmdSettingsCurveProperties.
Definition: CurveStyles.h:22
void setCountX(int countX)
Set method for x count.
void setModelPointMatch(const DocumentModelPointMatch &modelPointMatch)
Set method for DocumentModelPointMatch.
void iterateThroughCurvePoints(const Functor2wRet< const QString &, const Point &, CallbackSearchReturn > &ftorWithCallback) const
Apply functor to Points on Curve.
Definition: Curve.cpp:301
void setMinLength(double minLength)
Set method for min length.
virtual DocumentModelGridDisplay modelGridDisplay() const
Get method for DocumentModelGridDisplay.
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
void addPoint(Point point)
Add Point to this Curve.
Definition: Curve.cpp:133
void setPointsSelectionRelations(ExportPointsSelectionRelations exportPointsSelectionRelations)
Set method for point selection for relations.
virtual const CurvesGraphs & curvesGraphs() const
Make all Curves available, read only, for CmdAbstract classes only.
virtual QString reasonForUnsuccessfulRead() const
Return an informative text message explaining why startup loading failed. Applies if successfulRead r...
void setColorFilterSettings(const ColorFilterSettings &colorFilterSettings)
Set color filter.
Definition: Curve.cpp:546
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
void setPaletteColorCandidate(ColorPalette paletteColorCandidate)
Set method for candidate color.
virtual void setModelGridDisplay(const DocumentModelGridDisplay &modelGridDisplay)
Set method for DocumentModelGridDisplay.
QString errorMessage() const
Error message that explains the problem indicated by isError.
void setStopY(double stopY)
Set method for y stop.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
virtual DocumentModelPointMatch modelPointMatch() const
Get method for DocumentModelPointMatch.
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
Curve * curveForCurveName(const QString &curveName)
Return the axis or graph curve for the specified curve name.
void loadVersions7AndUp(QXmlStreamReader &reader)
Load from file in versions 7 and 8 formats. Number of axes points is already defined at Document leve...
virtual bool successfulRead() const
Return true if startup loading succeeded. If the loading failed then reasonForUnsuccessfulRed will ex...
virtual void checkAddPointAxis(const QPointF &posScreen, const QPointF &posGraph, bool &isError, QString &errorMessage, bool isXOnly, DocumentAxesPointsRequired documentAxesPointsRequired)
Check before calling addPointAxis. Also returns the next available ordinal number (to prevent clashes...
QPointF positionScreen(const QString &pointIdentifier) const
Return the position, in screen coordinates, of the specified Point.
Definition: Curve.cpp:473
void setCoordScaleYRadius(CoordScale coordScale)
Set method for linear/log scale on y/radius.
Callback that is used when iterating through a read-only CurvesGraphs to add corresponding points in ...
virtual void updatePointOrdinals(const Transformation &transformation)
Update point ordinals after point addition/removal or dragging.
void editPointAxis(const QPointF &posGraph, const QString &identifier)
Edit the graph coordinates of an axis point. This method does not apply to a graph point...
Definition: Curve.cpp:153
virtual void setModelExport(const DocumentModelExportFormat &modelExport)
Set method for DocumentModelExportFormat.
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
void addGraphCurveAtEnd(Curve curve)
Append new graph Curve to end of Curve list.
void iterateThroughCurvesPoints(const Functor2wRet< const QString &, const Point &, CallbackSearchReturn > &ftorWithCallback)
Apply functor to Points on all of the Curves.
virtual QStringList curvesGraphsNames() const
See CurvesGraphs::curvesGraphsNames.
void setStartY(double startY)
Set method for y start.
void setStepY(double stepY)
Set method for y step.
Class that represents one digitized point. The screen-to-graph coordinate transformation is always ex...
Definition: Point.h:23
void setStepY(double yStep)
Set method for y grid line increment.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
bool isXOnly(const QString &pointIdentifier) const
Return true if y coordinate is undefined, otherwise x coordinae is undefined in DOCUMENT_AXES_POINT_R...
Callback for sanity checking the screen and graph coordinates of an axis point that is in the axes cu...
virtual DocumentModelDigitizeCurve modelDigitizeCurve() const
Get method for DocumentModelDigitizeCurve.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
void setDelimiter(ExportDelimiter exportDelimiter)
Set method for delimiter.
void setStartX(double startX)
Set method for x start.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
CallbackSearchReturn callback(const QString &curveName, const Point &point)
Callback method.
virtual void setModelSegments(const DocumentModelSegments &modelSegments)
Set method for DocumentModelSegments.
virtual void setModelGridRemoval(const DocumentModelGridRemoval &modelGridRemoval)
Set method for DocumentModelGridRemoval.
void setLineWidth(double lineWidth)
Set method for line width.
int numPoints() const
Number of points.
Definition: Curve.cpp:432
void editPointGraph(bool isX, bool isY, double x, double y, const QStringList &identifiers, const Transformation &transformation)
Set the x and/or y coordinate values of the specified points.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
virtual void iterateThroughCurveSegments(const QString &curveName, const Functor2wRet< const Point &, const Point &, CallbackSearchReturn > &ftorWithCallback) const
See Curve::iterateThroughCurveSegments, for any axes or graph curve.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
void setCountY(int countY)
Set method for y count.
CoordSystem()
Single constructor.
Definition: CoordSystem.cpp:38
void movePoint(const QString &pointIdentifier, const QPointF &deltaScreen)
Translate the position of a point by the specified distance vector.
Definition: Curve.cpp:423
virtual void addPointGraphWithGeneratedIdentifier(const QString &curveName, const QPointF &posScreen, QString &generatedIentifier, double ordinal)
Add a single graph point with a generated point identifier.
void setLayoutFunctions(ExportLayoutFunctions exportLayoutFunctions)
Set method for functions layout.
static ColorFilterSettings defaultFilter()
Initial default for any Curve.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
virtual int nextOrdinalForCurve(const QString &curveName) const
Default next ordinal value for specified curve.
void setStable(bool stable)
Set method for stable flag.
void saveXml(QXmlStreamWriter &writer) const
Serialize curves.
virtual void setModelGeneral(const DocumentModelGeneral &modelGeneral)
Set method for DocumentModelGeneral.
virtual DocumentModelCoords modelCoords() const
Get method for DocumentModelCoords.
Model for DlgSettingsDigitizeCurve and CmdSettingsDigitizeCurve.
virtual void setCurvesGraphs(const CurvesGraphs &curvesGraphs)
Let CmdAbstract classes overwrite CurvesGraphs. Applies to current coordinate system.
QString identifier() const
Unique identifier for a specific Point.
Definition: Point.cpp:256
virtual DocumentModelSegments modelSegments() const
Get method for DocumentModelSegments.
Affine transformation between screen and graph coordinates, based on digitized axis points...
void loadVersion6(QXmlStreamReader &reader, DocumentAxesPointsRequired &documentAxesPointsRequired)
Load from file in version 6 format. Number of axes points is read in and passed to Document...
Details for a specific Point.
Definition: PointStyle.h:20
void setStepX(double stepX)
Set method for x step.
void setMaxPointSize(double maxPointSize)
Set method for max point size.
void addPoint(const Point &point)
Append new Point to the specified Curve.
Container for all graph curves. The axes point curve is external to this class.
Definition: CurvesGraphs.h:24
Model for DlgSettingsColorFilter and CmdSettingsColorFilter.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
Definition: Curve.cpp:490
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
virtual void setCurveAxes(const Curve &curveAxes)
Let CmdAbstract classes overwrite axes Curve. Applies to current coordinate system.
void setStopX(double stopX)
Set method for x grid line upper bound (inclusive).
void setPointsIntervalUnitsFunctions(ExportPointsIntervalUnits pointsIntervalUnitsFunctions)
Set method for points interval units for functions.
virtual void addPointAxisWithSpecifiedIdentifier(const QPointF &posScreen, const QPointF &posGraph, const QString &identifier, double ordinal, bool isXOnly)
Add a single axis point with the specified point identifier.
Definition: CoordSystem.cpp:94
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
virtual DocumentModelAxesChecker modelAxesChecker() const
Get method for DocumentModelAxesChecker.
virtual void removePointsInCurvesGraphs(CurvesGraphs &curvesGraphs)
Remove all points identified in the specified CurvesGraphs. See also addPointsInCurvesGraphs.
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
virtual void saveXml(QXmlStreamWriter &writer) const
Save graph to xml.
virtual void loadXml(QXmlStreamReader &reader)
Load model from serialized xml.
virtual void setModelColorFilter(const DocumentModelColorFilter &modelColorFilter)
Set method for DocumentModelColorFilter.
void setCoordUnitsTheta(CoordUnitsPolarTheta coordUnits)
Set method for theta units.
virtual DocumentModelColorFilter modelColorFilter() const
Get method for DocumentModelColorFilter.
void setRemoveDefinedGridLines(bool removeDefinedGridLines)
Set method for removing defined grid lines.
void iterateThroughCurveSegments(const Functor2wRet< const Point &, const Point &, CallbackSearchReturn > &ftorWithCallback) const
Apply functor to successive Points, as line segments, on Curve. This could be a bit slow...
Definition: Curve.cpp:316
int numCurves() const
Current number of graphs curves.
virtual void removePointGraph(const QString &identifier)
Perform the opposite of addPointGraph.
void setCurveName(const QString &curveName)
Change the curve name.
Definition: Curve.cpp:551
void setDisableX(GridCoordDisable disableX)
Set method for x grid line disabled variable.
void setStopY(double yStop)
Set method for y grid line upper bound (inclusive).
CallbackSearchReturn callback(const QString &curveName, const Point &point)
Callback method.
Model for DlgSettingsCoords and CmdSettingsCoords.
Container for LineStyle and PointStyle for one Curve.
Definition: CurveStyle.h:18
void setOriginRadius(double originRadius)
Set method for origin radius in polar mode.
void setGridCoordDisableY(GridCoordDisable gridCoordDisable)
Set method for y coord parameter to disable.
void setDisableY(GridCoordDisable disableY)
Set method for y grid line disabled variable.
Container for one set of digitized Points.
Definition: Curve.h:33
void updatePointOrdinals(const Transformation &transformation)
Update point ordinals to be consistent with their CurveStyle and x/theta coordinate.
Details for a specific Line.
Definition: LineStyle.h:19
virtual QPointF positionGraph(const QString &pointIdentifier) const
See Curve::positionGraph.
void iterateThroughCurveSegments(const QString &curveNameWanted, const Functor2wRet< const Point &, const Point &, CallbackSearchReturn > &ftorWithCallback) const
Apply functor to segments on the specified axis or graph Curve.
int numberOfCurvesForImport() const
Return the number of curve names to be generated. Value is maximum of 1 and the number in the configu...
void setCoordUnitsRadius(CoordUnitsNonPolarTheta coordUnits)
Set method for radius units.
void setGridCoordDisableX(GridCoordDisable gridCoordDisable)
Set method for x coord parameter to disable.
QPointF positionGraph(const QString &pointIdentifier) const
Return the position, in graph coordinates, of the specified Point.
Definition: Curve.cpp:456
void loadPreVersion6(QDataStream &str, double version, DocumentAxesPointsRequired &documentAxesPointsRequired)
Load from file in pre-version 6 format. Number of axes points is read in and passed to Document...
void setPaletteColorRejected(ColorPalette paletteColorRejected)
Set method for rejected color.
virtual void checkEditPointAxis(const QString &pointIdentifier, const QPointF &posScreen, const QPointF &posGraph, bool &isError, QString &errorMessage, DocumentAxesPointsRequired documentAxesPointsRequired)
Check before calling editPointAxis.
virtual Curve * curveForCurveName(const QString &curveName)
See CurvesGraphs::curveForCurveName, although this also works for AXIS_CURVE_NAME.
void setCountX(unsigned int countX)
Set method for x grid line count.
QStringList curvesGraphsNames() const
List of graph curve names.
void setStartY(double yStart)
Set method for y grid line lower bound (inclusive).
virtual void removePointAxis(const QString &identifier)
Perform the opposite of addPointAxis.
Model for DlgSettingsAxesChecker and CmdSettingsAxesChecker.
virtual void addGraphCurveAtEnd(const QString &curveName)
Add new graph curve to the list of existing graph curves.
Definition: CoordSystem.cpp:62
virtual QPointF positionScreen(const QString &pointIdentifier) const
See Curve::positionScreen.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
void setStable()
Set the stable flag to true. This public version has no argument since it cannot be undone...
CoordsType coordsType() const
Get method for coordinates type.
virtual bool loadCurvesFile(const QString &curvesFile)
Load the curve names in the specified Engauge file into the current graph. This is called near the en...
virtual void addPointGraphWithSpecifiedIdentifier(const QString &curveName, const QPointF &posScreen, const QString &identifier, double ordinal)
Add a single graph point with the specified point identifer. Note that PointStyle is not applied to t...
virtual void addPointAxisWithGeneratedIdentifier(const QPointF &posScreen, const QPointF &posGraph, QString &identifier, double ordinal, bool isXOnly)
Add a single axis point with a generated point identifier.
Definition: CoordSystem.cpp:72
virtual void print() const
Debugging method for printing directly from symbolic debugger.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
virtual void movePoint(const QString &pointIdentifier, const QPointF &deltaScreen)
See Curve::movePoint.
virtual void editPointGraph(bool isX, bool isY, double x, double y, const QStringList &identifiers, const Transformation &transformation)
Edit the graph coordinates of one or more graph points.
virtual DocumentModelGeneral modelGeneral() const
Get method for DocumentModelGeneral.
void setPointsIntervalUnitsRelations(ExportPointsIntervalUnits pointsIntervalUnitsRelations)
Set method for points interval units for relations.
virtual void addPointsInCurvesGraphs(CurvesGraphs &curvesGraphs)
Add all points identified in the specified CurvesGraphs. See also removePointsInCurvesGraphs.
virtual void iterateThroughCurvesPointsGraphs(const Functor2wRet< const QString &, const Point &, CallbackSearchReturn > &ftorWithCallback)
See Curve::iterateThroughCurvePoints, for all the graphs curves.
Model for DlgSettingsSegments and CmdSettingsSegments.
virtual DocumentModelExportFormat modelExport() const
Get method for DocumentModelExportFormat.
double nextOrdinal() const
Computed next ordinal.
void loadPreVersion6(QDataStream &str)
Load from serialized binary pre-version 6 file.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
virtual int curvesGraphsNumPoints(const QString &curveName) const
See CurvesGraphs::curvesGraphsNumPoints.
Callback for sanity checking the screen and graph coordinates of an axis point, before it is added to...
virtual void editPointAxis(const QPointF &posGraph, const QString &identifier)
Edit the graph coordinates of a single axis point. Call this after checkAddPointAxis to guarantee suc...
void setHeader(ExportHeader exportHeader)
Set method for header.
void saveXml(QXmlStreamWriter &writer) const
Serialize curve.
Definition: Curve.cpp:523
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
virtual void setModelCurveStyles(const CurveStyles &modelCurveStyles)
Set method for CurveStyles.
virtual void setSelectedCurveName(const QString &selectedCurveName)
Save curve name that is selected for the current coordinate system, for the next time the coordinate ...
virtual CurveStyles modelCurveStyles() const
Get method for CurveStyles.
void removePoint(const QString &pointIdentifier)
Remove the Point from its Curve.
QString errorMessage() const
Error message that explains the problem indicated by isError.
virtual const Curve & curveAxes() const
Get method for axis curve.
Model for DlgSettingsGridRemoval and CmdSettingsGridRemoval. The settings are unstable until the user...
virtual QString selectedCurveName() const
Currently selected curve name. This is used to set the selected curve combobox in MainWindow...
bool isError() const
True if an error occurred during iteration.
bool isXOnly(const QString &pointIdentifier) const
Determine if specified point has just x coordinate. Otherwise has just y coordinate, or both x and y coordinates.
Definition: Curve.cpp:284
static PointStyle defaultGraphCurve(int index)
Initial default for index&#39;th graph curve.
Definition: PointStyle.cpp:83
void setPointSeparation(double pointSeparation)
Set method for point separation.
QString defaultCurveName(int indexOneBased, const QString &defaultName) const
Default graph name for the specified curve index.
void setPaletteColorAccepted(ColorPalette paletteColorAccepted)
Set method for accepted color.
void setStopX(double stopX)
Set method for x stop.
virtual void iterateThroughCurvePointsAxes(const Functor2wRet< const QString &, const Point &, CallbackSearchReturn > &ftorWithCallback)
See Curve::iterateThroughCurvePoints, for the axes curve.
void setCoordScaleXTheta(CoordScale coordScale)
Set method for linear/log scale on x/theta.
virtual void setModelCoords(const DocumentModelCoords &modelCoords)
Set method for DocumentModelCoords.
CallbackSearchReturn callback(const QString &curveName, const Point &point)
Callback method.
void printStream(QString indentation, QTextStream &str) const
Debugging method that supports print method of this class and printStream method of some other class(...
void setXLabel(const QString &xLabel)
Set method for x label.
virtual void setModelDigitizeCurve(const DocumentModelDigitizeCurve &modelDigitizeCurve)
Set method for DocumentModelDigitizeCurve.
virtual void saveXml(QXmlStreamWriter &writer) const
Save entire model as xml into stream.
void setCoordsType(CoordsType coordsType)
Set method for coordinates type.