GeometryStrategyFunctionSmooth Class Reference

Calculate for line through the points that is smoothly connected as a function. More...

#include <GeometryStrategyFunctionSmooth.h>

Inheritance diagram for GeometryStrategyFunctionSmooth:

Collaboration diagram for GeometryStrategyFunctionSmooth:

Public Member Functions
	GeometryStrategyFunctionSmooth ()
	Single constructor.
virtual	~GeometryStrategyFunctionSmooth ()
virtual void	calculateGeometry (const Points &points, const DocumentModelCoords &modelCoords, const DocumentModelGeneral &modelGeneral, const MainWindowModel &modelMainWindow, const Transformation &transformation, QString &funcArea, QString &polyArea, QVector< QString > &x, QVector< QString > &y, QVector< bool > &isPotentialExportAmbiguity, QVector< QString > &distanceGraphForward, QVector< QString > &distancePercentForward, QVector< QString > &distanceGraphBackward, QVector< QString > &distancePercentBackward) const
	Calculate geometry parameters.
virtual void	loadSmoothAmbiguityVector (QVector< QString > &x, QVector< QString > &y, const Transformation &transformation, QVector< bool > &isPotentialExportAmbiguity) const
	Generate a vector that identifies points belonging to segments that overlap, for smoothly connected functions.
Public Member Functions inherited from GeometryStrategyAbstractBase
	GeometryStrategyAbstractBase ()
	Single constructor.
virtual	~GeometryStrategyAbstractBase ()

Additional Inherited Members
Protected Member Functions inherited from GeometryStrategyAbstractBase
void	calculatePositionsGraph (const Points &points, const Transformation &transformation, QVector< QPointF > &positionsGraph) const
	Convert screen positions to graph positions.
double	functionArea (const QVector< QPointF > &positionsGraph) const
	Use trapezoidal approximation to compute area under the function. Does not apply to relation.
void	insertSubintervalsAndLoadDistances (int subintervalsPerInterval, const QVector< QPointF > &positionsGraph, QVector< QPointF > &positionsGraphWithSubintervals, QVector< QString > &distanceGraphForward, QVector< QString > &distancePercentForward, QVector< QString > &distanceGraphBackward, QVector< QString > &distancePercentBackward) const
	Insert the specified number of subintervals into each interval.
virtual void	loadPotentialExportVector (QVector< QString > &x, QVector< QString > &y, const Transformation &transformation, QVector< bool > &isPotentialExportAmbiguity) const
	Load isPotentialExportAmbiguity vector. Default in base class is to load false values since there are no ambiguities.
void	loadXY (const QVector< QPointF > &positionsGraph, const DocumentModelCoords &modelCoords, const DocumentModelGeneral &modelGeneral, const MainWindowModel &modelMainWindow, const Transformation &transformation, QVector< QString > &x, QVector< QString > &y) const
	Load x and y coordinate vectors.
double	polygonAreaForSimplyConnected (const QVector< QPointF > &points) const
	Area in polygon using Shoelace formula, which only works if polygon is simply connected.

Detailed Description

Calculate for line through the points that is smoothly connected as a function.

Definition at line 16 of file GeometryStrategyFunctionSmooth.h.

Constructor & Destructor Documentation

GeometryStrategyFunctionSmooth()

GeometryStrategyFunctionSmooth::GeometryStrategyFunctionSmooth

(

)

Single constructor.

Definition at line 15 of file GeometryStrategyFunctionSmooth.cpp.

{
}

~GeometryStrategyFunctionSmooth()

GeometryStrategyFunctionSmooth::~GeometryStrategyFunctionSmooth ( )

virtual

Definition at line 19 of file GeometryStrategyFunctionSmooth.cpp.

{
}

Member Function Documentation

calculateGeometry()

void GeometryStrategyFunctionSmooth::calculateGeometry ( const Points & points, const DocumentModelCoords & modelCoords, const DocumentModelGeneral & modelGeneral, const MainWindowModel & modelMainWindow, const Transformation & transformation, QString & funcArea, QString & polyArea, QVector< QString > & x, QVector< QString > & y, QVector< bool > & isPotentialExportAmbiguity, QVector< QString > & distanceGraphForward, QVector< QString > & distancePercentForward, QVector< QString > & distanceGraphBackward, QVector< QString > & distancePercentBackward ) const

virtual

Calculate geometry parameters.

Implements GeometryStrategyAbstractBase.

Definition at line 23 of file GeometryStrategyFunctionSmooth.cpp.

{
  const int NUM_SUB_INTERVALS_SMOOTH = 10; // One input point becomes NUM_SUB_INTERVALS points to account for smoothing
 
  QVector<QPointF> positionsGraph, positionsGraphWithSubintervals;
  calculatePositionsGraph (points,
                           transformation,
                           positionsGraph);
 
  insertSubintervalsAndLoadDistances (NUM_SUB_INTERVALS_SMOOTH,
                                      positionsGraph,
                                      positionsGraphWithSubintervals,
                                      distanceGraphForward,
                                      distancePercentForward,
                                      distanceGraphBackward,
                                      distancePercentBackward);
  double fArea = functionArea (positionsGraphWithSubintervals);
 
  loadXY (positionsGraph,
          modelCoords,
          modelGeneral,
          modelMainWindow,
          transformation,
          x,
          y);
 
  loadSmoothAmbiguityVector (x,
                             y,
                             transformation,
                             isPotentialExportAmbiguity);
 
  // Set header values
  funcArea = QString::number (fArea);
  polyArea = "";
}

loadSmoothAmbiguityVector()

void GeometryStrategyFunctionSmooth::loadSmoothAmbiguityVector ( QVector< QString > & x, QVector< QString > & y, const Transformation & transformation, QVector< bool > & isPotentialExportAmbiguity ) const

virtual

Generate a vector that identifies points belonging to segments that overlap, for smoothly connected functions.

Definition at line 72 of file GeometryStrategyFunctionSmooth.cpp.

{
  // There are N-1 segments for N points
  int numSegments = x.size () - 1;
 
  // Graph/screen transformation must be defined for SplineDrawer, and
  // at least one point must be defined for Spline. Even better, one segment
  // must be defined for Spline
  if (transformation.transformIsDefined() &&
      numSegments > 0) {
 
    // Create spline
    vector<double> t (unsigned (x.size ()));
    vector<SplinePair> xy (unsigned (x.size ()));
    for (unsigned int i = 0; i < unsigned (x.size ()); i++) {
      t [i] = i;
      xy [i] = SplinePair (x.at (signed (i)).toDouble (),
                           y.at (signed (i)).toDouble ());
    }
    Spline s (t,
              xy);
 
    SplineDrawer sd (transformation);
 
    for (int segment = 0; segment < numSegments; segment++) {
      bool isMultiValued = sd.segmentIsMultiValued (s,
                                                    x.size (),
                                                    segment);
      isPotentialExportAmbiguity.push_back (isMultiValued);
    }
  } else {
 
    for (int segment = 0; segment < numSegments; segment++) {
      isPotentialExportAmbiguity.push_back (false);
    }
  }
}

---

The documentation for this class was generated from the following files:

• Geometry/GeometryStrategyFunctionSmooth.h
• Geometry/GeometryStrategyFunctionSmooth.cpp