Compute endpoints for polar centipedes. More...

#include <CentipedeEndpointsPolar.h>

Inheritance diagram for CentipedeEndpointsPolar:

Collaboration diagram for CentipedeEndpointsPolar:

Public Member Functions
	CentipedeEndpointsPolar (const DocumentModelCoords &modelCoords, const DocumentModelGuideline &modelGuideline, const Transformation &transformation, const QPointF &posClickScreen, const QPointF &posOriginScreen)
	Constructor with individual coordinates.
virtual	~CentipedeEndpointsPolar ()
void	ellipseScreenConstantRForTHighLowAngles (const Transformation &transformation, const QPointF &posClickScreen, double &angleRotation, QRectF &rectBounding, CentipedeDebugPolar &DebugPolar)
	Ellipse for R value of circle/coordinate intersection. Start/span angles are calculated separately.
QPointF	posScreenConstantRForHighT (double radius) const
	Screen point for R value of circle/coordinate intersection in the increasing T direction.
QPointF	posScreenConstantRForLowT (double radius) const
	Screen point for R value of circle/coordinate intersection in the decreasing T direction.
void	posScreenConstantRHighLow (double radiusAboutClick, QPointF &posLow, QPointF &posHigh) const
	Return two points (posLow and posHigh) where circle around posClickScreen intersects constant-radiusAboutClick ellipse.
void	posScreenConstantTForRHighLow (double radius, QPointF &posLow, QPointF &posHigh) const
	Endpoints for radial line segmentin polar coordinates.
Public Member Functions inherited from CentipedeEndpointsAbstract
	CentipedeEndpointsAbstract (const DocumentModelGuideline &modelGuideline, const Transformation &transformation, const QPointF &posClickScreen)
	Constructor with individual coordinates.
virtual	~CentipedeEndpointsAbstract ()

Additional Inherited Members
Protected Member Functions inherited from CentipedeEndpointsAbstract
const DocumentModelGuideline &	modelGuideline () const
	Settings.
QPointF	posClickScreen () const
	Center of circle in screen coordinates.
const Transformation &	transformation () const
	Transformation which is static through the entire lifetime of the Centipede class instances.

Detailed Description

Compute endpoints for polar centipedes.

Definition at line 20 of file CentipedeEndpointsPolar.h.

Constructor & Destructor Documentation

◆ CentipedeEndpointsPolar()

CentipedeEndpointsPolar::CentipedeEndpointsPolar	(	const DocumentModelCoords &	modelCoords,
		const DocumentModelGuideline &	modelGuideline,
		const Transformation &	transformation,
		const QPointF &	posClickScreen,
		const QPointF &	posOriginScreen )

Constructor with individual coordinates.

Definition at line 21 of file CentipedeEndpointsPolar.cpp.

                                                                                 :
  CentipedeEndpointsAbstract (modelGuideline,
                              transformation,
                              posClickScreen),
  m_modelCoords (modelCoords),
  m_posOriginScreen (posOriginScreen)
{
}

◆ ~CentipedeEndpointsPolar()

CentipedeEndpointsPolar::~CentipedeEndpointsPolar ( )

virtual

Definition at line 34 of file CentipedeEndpointsPolar.cpp.

35{

36}

Member Function Documentation

◆ ellipseScreenConstantRForTHighLowAngles()

void CentipedeEndpointsPolar::ellipseScreenConstantRForTHighLowAngles	(	const Transformation &	transformation,
		const QPointF &	posClickScreen,
		double &	angleRotation,
		QRectF &	rectBounding,
		CentipedeDebugPolar &	DebugPolar )

Ellipse for R value of circle/coordinate intersection. Start/span angles are calculated separately.

Definition at line 55 of file CentipedeEndpointsPolar.cpp.

{
  //  LOG4CPP is below
 
  QPointF posClickGraph;
  transformation.transformScreenToRawGraph (posClickScreen,
                                            posClickGraph);
  double rGraph = posClickGraph.y();
 
  // Points at origin, then 0  degrees at range rGraph
  QPointF posScreenOrigin, posScreen0, posScreen90, posScreen180;
  transformation.transformRawGraphToScreen (QPointF (tAtOrigin (), rAtOrigin ()),
                                            posScreenOrigin);
  transformation.transformRawGraphToScreen (QPointF (0, rGraph),
                                            posScreen0);
  transformation.transformRawGraphToScreen (QPointF (90.0, rGraph),
                                            posScreen90);
  transformation.transformRawGraphToScreen (QPointF (180.0, rGraph),
                                            posScreen180);
 
  QPointF centerTo90 = posScreen90 - posScreenOrigin;
 
  // Corners of parallelogram circumscribing the ellipse
  QPointF posScreenTL = posScreen180 + centerTo90;
  QPointF posScreenTR = posScreen0 + centerTo90;
  QPointF posScreenBL = posScreen180 - centerTo90;
  QPointF posScreenBR = posScreen0 - centerTo90;
 
  double aAligned = 0, bAligned = 0;
  ellipseFromParallelogram (posScreenTL.x() - posScreenOrigin.x(),
                            posScreenTL.y() - posScreenOrigin.y(),
                            posScreenTR.x() - posScreenOrigin.x(),
                            posScreenTR.y() - posScreenOrigin.y(),
                            posScreenBR.x() - posScreenOrigin.x(),
                            posScreenBR.y() - posScreenOrigin.y(),
                            angleRotation,
                            aAligned,
                            bAligned);
 
  double angleGraphAxisFromScreenAxis = qAtan2 (posScreen0.y() - posScreenOrigin.y(),
                                                posScreen0.x() - posScreenOrigin.x());
 
  debugPolar = CentipedeDebugPolar (posScreenTL,
                                    posScreenTR,
                                    posScreenBL,
                                    posScreenBR,
                                    angleGraphAxisFromScreenAxis,
                                    angleRotation,
                                    aAligned,
                                    bAligned,
                                    rGraph);
 
  // Bounding rectangle before rotation. We make sure the rectangle is normalized which at one point
  // seemed to prevent drawing artifacts
  rectBounding = QRectF (-1.0 * aAligned,
                         -1.0 * bAligned,
                         2.0 * aAligned,
                         2.0 * bAligned);
 
  LOG4CPP_INFO_S ((*mainCat)) << "CentipedeEndpointsPolar::ellipseScreenConstantRForTHighLowAngles angleRotation="
                              << qRadiansToDegrees (angleRotation) << " posScreen0=" << QPointFToString (posScreen0).toLatin1().data()
                              << " posScreen90=" << QPointFToString (posScreen90).toLatin1().data()
                              << " a=" << aAligned
                              << " b=" << bAligned;
}

◆ posScreenConstantRForHighT()

QPointF CentipedeEndpointsPolar::posScreenConstantRForHighT ( double radius ) const

Screen point for R value of circle/coordinate intersection in the increasing T direction.

Definition at line 212 of file CentipedeEndpointsPolar.cpp.

{
  return posScreenConstantRCommon (radius,
                                    CENTIPEDE_INTERSECTION_HIGH);
}

◆ posScreenConstantRForLowT()

QPointF CentipedeEndpointsPolar::posScreenConstantRForLowT ( double radius ) const

Screen point for R value of circle/coordinate intersection in the decreasing T direction.

Definition at line 218 of file CentipedeEndpointsPolar.cpp.

{
  return posScreenConstantRCommon (radius,
                                   CENTIPEDE_INTERSECTION_LOW);
}

◆ posScreenConstantRHighLow()

void CentipedeEndpointsPolar::posScreenConstantRHighLow	(	double	radiusAboutClick,
		QPointF &	posLow,
		QPointF &	posHigh ) const

Return two points (posLow and posHigh) where circle around posClickScreen intersects constant-radiusAboutClick ellipse.

Definition at line 224 of file CentipedeEndpointsPolar.cpp.

{
  // Click point
  QPointF posClickGraph;
  transformation().transformScreenToRawGraph (posClickScreen(),
                                              posClickGraph);
  double yClick = posClickGraph.y();
 
  // Iterate points around the circle starting at angleCenter, and going in two different
  // directions (clockwise for angleHigh and counterclockwise for angleLow)
  bool isFirstLow = true, isFirstHigh = true;
  QPointF posLowGraph, posHighGraph;
  for (int i = 0; i < NUM_CIRCLE_POINTS; i++) {
    QPointF posGraphPreviousLow, posGraphNextLow, posScreenPreviousLow;
    QPointF posGraphPreviousHigh, posGraphNextHigh, posScreenPreviousHigh;
    generatePreviousAndNextPointsConstantR (radiusAboutClick,
                                            i,
                                            i + 1,
                                            posGraphPreviousLow,
                                            posGraphNextLow,
                                            posScreenPreviousLow);
    generatePreviousAndNextPointsConstantR (radiusAboutClick,
                                            - i,
                                            - i - 1,
                                            posGraphPreviousHigh,
                                            posGraphNextHigh,
                                            posScreenPreviousHigh);
 
    double epsilon = qAbs (posGraphPreviousLow.y() - posGraphNextLow.y()) / 10.0; // Allow for roundoff
 
    bool transitionUpLow = (posGraphPreviousLow.y() - epsilon <= yClick) && (yClick < posGraphNextLow.y() + epsilon);
    bool transitionDownLow = (posGraphNextLow.y() - epsilon <= yClick) && (yClick < posGraphPreviousLow.y() + epsilon);
    bool transitionUpHigh = (posGraphPreviousHigh.y() - epsilon <= yClick) && (yClick < posGraphNextHigh.y() + epsilon);
    bool transitionDownHigh = (posGraphNextHigh.y() - epsilon <= yClick) && (yClick < posGraphPreviousHigh.y() + epsilon);
 
    if (isFirstLow  && (transitionDownLow || transitionUpLow)) {
      // Found the first (=best) low value
      isFirstLow = false;
      posLowGraph = (posGraphPreviousLow + posGraphNextLow) / 2.0; // Average
      if (!isFirstHigh) {
        break; // Done
      }
    }
 
    if (isFirstHigh && (transitionDownHigh || transitionUpHigh)) {
      // Found the first (=best) high value
      isFirstHigh = false;
      posHighGraph = (posGraphPreviousHigh + posGraphNextHigh) / 2.0;
      if (!isFirstLow) {
        break; // Done
      }
    }
  }
 
  // Convert from graph to screen coordinates
  transformation().transformRawGraphToScreen (posLowGraph,
                                              posLow);
  transformation().transformRawGraphToScreen (posHighGraph,
                                              posHigh);
}

◆ posScreenConstantTForRHighLow()

void CentipedeEndpointsPolar::posScreenConstantTForRHighLow	(	double	radius,
		QPointF &	posLow,
		QPointF &	posHigh ) const

Endpoints for radial line segmentin polar coordinates.

Definition at line 287 of file CentipedeEndpointsPolar.cpp.

{
  // This replaces CentipedeSegmentAbstract::posScreenConstantXTCommon since the polar coordinate radial vector
  // can be on the other side of the origin if the ellipse center is within radius of the origin. This routine
  // uses a different strategy of iterating on a line rather than a circle (since circle has tough issues with quadrants
  // and 360 rollover)
 
  // Origin and screen vector to center
  QPointF posOriginScreen;
  transformation().transformRawGraphToScreen (QPointF (tAtOrigin (), rAtOrigin ()),
                                              posOriginScreen);
  QPointF vecCenter = posClickScreen() - posOriginScreen;
 
  // Number of solutions found
  int numberFound = 0;
 
  // Iterate points along the line from -2*vecCenterMagnitude to +2*vecCenterMagnitude
  const double DOUBLE_PLUS_EXTRA = 2.1;
  double maxRadius = DOUBLE_PLUS_EXTRA * (magnitude (vecCenter) + radius);
  QPointF posStart = posOriginScreen - 2 * maxRadius * normalize (vecCenter);
  QPointF posStop = posOriginScreen + 2 * maxRadius * normalize (vecCenter);
  for (int i = 0; i < NUM_LINE_POINTS; i++) {
    double sPrevious = (double) i / (double) NUM_LINE_POINTS;
    double sNext = (double) (i + 1) / (double) NUM_LINE_POINTS;
 
    QPointF posPrevious = (1.0 - sPrevious) * posStart + sPrevious * posStop;
    QPointF posNext = (1.0 - sNext) * posStart + sNext * posStop;
 
    double distancePrevious = magnitude (posPrevious - posClickScreen());
    double distanceNext = magnitude (posNext - posClickScreen());
 
    if ((distancePrevious < radius && radius <= distanceNext) ||
        (distancePrevious > radius && radius >= distanceNext)) {
 
      if (numberFound == 0) {
        posLow = (posPrevious + posNext) / 2.0; // Average for accuracy
      } else if (numberFound == 1) {
        posHigh = (posPrevious + posNext) / 2.0; // Average for accuracy
        break; // Done
      }
 
      ++numberFound;
    }
  }
}

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

Centipede/CentipedeEndpointsPolar.h
Centipede/CentipedeEndpointsPolar.cpp

Public Member Functions

Additional Inherited Members