GridLineFactory Class Reference

Factory class for generating the points, composed of QGraphicsItem objects, along a GridLine. More...

#include <GridLineFactory.h>

Collaboration diagram for GridLineFactory:

Public Member Functions
	GridLineFactory (QGraphicsScene &scene, const DocumentModelCoords &modelCoords)
	Simple constructor for general use (i.e. not by Checker) More...
	GridLineFactory (QGraphicsScene &scene, int pointRadius, const QList< Point > &pointsToIsolate, const DocumentModelCoords &modelCoords)
	Constructor for use by Checker, which has points that are isolated. More...
GridLine *	createGridLine (double xFrom, double yFrom, double xTo, double yTo, const Transformation &transformation)
	Create grid line, either along constant X/theta or constant Y/radius side. More...
void	createGridLinesForEvenlySpacedGrid (const DocumentModelGridDisplay &modelGridDisplay, const Document &document, const MainWindowModel &modelMainWindow, const Transformation &transformation, GridLines &gridLines)
	Create a rectangular (cartesian) or annular (polar) grid of evenly spaced grid lines. More...

Detailed Description

Factory class for generating the points, composed of QGraphicsItem objects, along a GridLine.

For polar coordinates, the grid lines will appear as an annular segments.

For the Checker class, a set of Points can be specified which will be isolated by having grid lines stop at a specified distance (or radius) from each point

Definition at line 28 of file GridLineFactory.h.

Constructor & Destructor Documentation

GridLineFactory() [1/2]

GridLineFactory::GridLineFactory	(	QGraphicsScene &	scene,
		const DocumentModelCoords &	modelCoords
	)

Simple constructor for general use (i.e. not by Checker)

Definition at line 35 of file GridLineFactory.cpp.

                                                                         :
  m_scene (scene),
  m_pointRadius (0.0),
  m_modelCoords (modelCoords),
  m_isChecker (false)
{
  LOG4CPP_DEBUG_S ((*mainCat)) << "GridLineFactory::GridLineFactory";
}

GridLineFactory() [2/2]

GridLineFactory::GridLineFactory	(	QGraphicsScene &	scene,
		int	pointRadius,
		const QList< Point > &	pointsToIsolate,
		const DocumentModelCoords &	modelCoords
	)

Constructor for use by Checker, which has points that are isolated.

Definition at line 45 of file GridLineFactory.cpp.

                                                                         :
  m_scene (scene),
  m_pointRadius (pointRadius),
  m_pointsToIsolate (pointsToIsolate),
  m_modelCoords (modelCoords),
  m_isChecker (true)
{
  LOG4CPP_DEBUG_S ((*mainCat)) << "GridLineFactory::GridLineFactory"
                               << " pointRadius=" << pointRadius
                               << " pointsToIsolate=" << pointsToIsolate.count();
}

Member Function Documentation

createGridLine()

GridLine * GridLineFactory::createGridLine	(	double	xFrom,
		double	yFrom,
		double	xTo,
		double	yTo,
		const Transformation &	transformation
	)

Create grid line, either along constant X/theta or constant Y/radius side.

Line goes from pointFromGraph to pointToGraph. If the coordinates are polar, we go clockwise from pointFromGraph to pointToGraph (as set up by adjustPolarAngleRange).

Definition at line 73 of file GridLineFactory.cpp.

{
  LOG4CPP_DEBUG_S ((*mainCat)) << "GridLineFactory::createGridLine"
                               << " xFrom=" << xFrom
                               << " yFrom=" << yFrom
                               << " xTo=" << xTo
                               << " yTo=" << yTo;
 
  GridLine *gridLine = new GridLine ();
 
  // Originally a complicated algorithm tried to intercept a straight line from (xFrom,yFrom) to (xTo,yTo). That did not work well since:
  // 1) Calculations for mostly orthogonal cartesian coordinates worked less well with non-orthogonal polar coordinates
  // 2) Ambiguity in polar coordinates between the shorter and longer paths between (theta0,radius) and (theta1,radius)
  //
  // Current algorithm breaks up the interval between (xMin,yMin) and (xMax,yMax) into many smaller pieces and stitches the
  // desired pieces together. For straight lines in linear graphs this algorithm is very much overkill, but there is no significant
  // penalty and this approach works in every situation
 
  // Should give single-pixel resolution on most images, and 'good enough' resolution on extremely large images
  const int NUM_STEPS = 1000;
 
  bool stateSegmentIsActive = false;
  QPointF posStartScreen (0, 0);
 
  // Loop through steps. Final step i=NUM_STEPS does final processing if a segment is active
  for (int i = 0; i <= NUM_STEPS; i++) {
 
    double s = double (i) / double (NUM_STEPS);
 
    // Interpolate coordinates assuming normal linear scaling
    double xGraph = (1.0 - s) * xFrom + s * xTo;
    double yGraph = (1.0 - s) * yFrom + s * yTo;
 
    // Replace interpolated coordinates using log scaling if appropriate, preserving the same ranges
    if (m_modelCoords.coordScaleXTheta() == COORD_SCALE_LOG) {
      xGraph = qExp ((1.0 - s) * qLn (xFrom) + s * qLn (xTo));
    }
    if (m_modelCoords.coordScaleYRadius() == COORD_SCALE_LOG) {
      yGraph = qExp ((1.0 - s) * qLn (yFrom) + s * qLn (yTo));
    }
 
    QPointF pointScreen;
    transformation.transformRawGraphToScreen (QPointF (xGraph, yGraph),
                                              pointScreen);
 
    double distanceToNearestPoint = minScreenDistanceFromPoints (pointScreen);
    if ((distanceToNearestPoint < m_pointRadius) ||
        (i == NUM_STEPS)) {
 
        // Too close to point, so point is not included in side. Or this is the final iteration of the loop
      if (stateSegmentIsActive) {
 
        // State transition
        finishActiveGridLine (posStartScreen,
                              pointScreen,
                              yFrom,
                              yTo,
                              transformation,
                              *gridLine);
        stateSegmentIsActive = false;
 
      }
    } else {
 
      // Outside point, so include point in side
      if (!stateSegmentIsActive) {
 
        // State transition
        stateSegmentIsActive = true;
        posStartScreen = pointScreen;
 
      }
    }
  }
 
  return gridLine;
}

createGridLinesForEvenlySpacedGrid()

void GridLineFactory::createGridLinesForEvenlySpacedGrid	(	const DocumentModelGridDisplay &	modelGridDisplay,
		const Document &	document,
		const MainWindowModel &	modelMainWindow,
		const Transformation &	transformation,
		GridLines &	gridLines
	)

Create a rectangular (cartesian) or annular (polar) grid of evenly spaced grid lines.

Definition at line 155 of file GridLineFactory.cpp.

{
  // At a minimum the transformation must be defined. Also, there is a brief interval between the definition of
  // the transformation and the initialization of modelGridDisplay (at which point this method gets called again) and
  // we do not want to create grid lines during that brief interval
  if (transformation.transformIsDefined() &&
      modelGridDisplay.stable()) {
 
    double startX = modelGridDisplay.startX ();
    double startY = modelGridDisplay.startY ();
    double stepX  = modelGridDisplay.stepX  ();
    double stepY  = modelGridDisplay.stepY  ();
    double stopX  = modelGridDisplay.stopX  ();
    double stopY  = modelGridDisplay.stopY  ();
 
    // Limit the number of grid lines. This is a noop if the limit is not exceeded
    GridLineLimiter gridLineLimiter;
    gridLineLimiter.limitForXTheta (document,
                                    transformation,
                                    m_modelCoords,
                                    modelMainWindow,
                                    modelGridDisplay,
                                    startX,
                                    stepX,
                                    stopX);
    gridLineLimiter.limitForYRadius (document,
                                     transformation,
                                     m_modelCoords,
                                     modelMainWindow,
                                     modelGridDisplay,
                                     startY,
                                     stepY,
                                     stopY);
 
    // Apply if possible
    bool isLinearX = (m_modelCoords.coordScaleXTheta() == COORD_SCALE_LINEAR);
    bool isLinearY = (m_modelCoords.coordScaleYRadius() == COORD_SCALE_LINEAR);
    if (stepX > (isLinearX ? 0 : 1) &&
        stepY > (isLinearY ? 0 : 1) &&
        (isLinearX || (startX > 0)) &&
        (isLinearY || (startY > 0))) {
 
      QColor color (ColorPaletteToQColor (modelGridDisplay.paletteColor()));
      QPen pen (QPen (color,
                      GRID_LINE_WIDTH,
                      GRID_LINE_STYLE));
 
      for (double x = startX; x <= stopX; (isLinearX ? x += stepX : x *= stepX)) {
 
        GridLine *gridLine = createGridLine (x, startY, x, stopY, transformation);
        gridLine->setPen (pen);
        gridLines.add (gridLine);
      }
 
      for (double y = startY; y <= stopY; (isLinearY ? y += stepY : y *= stepY)) {
 
        GridLine *gridLine = createGridLine (startX, y, stopX, y, transformation);
        gridLine->setPen (pen);
        gridLines.add (gridLine);
      }
    }
  }
}

---

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

• Grid/GridLineFactory.h
• Grid/GridLineFactory.cpp