qgstextrendererutils.cpp

Go to the documentation of this file.

/***************************************************************************
  qgstextrendererutils.h
  -----------------
   begin                : May 2020
   copyright            : (C) Nyall Dawson
   email                : nyall dot dawson at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgstextrendererutils.h"
 
#include "qgsdatadefinedutils.h"
#include "qgsgeometryutils_base.h"
#include "qgsvectorlayer.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
QgsTextBackgroundSettings::ShapeType QgsTextRendererUtils::decodeShapeType( const QString &string )
{
  static constexpr auto SHAPE_TYPE_MAP = makeDataDefinedStringDecoder<QgsTextBackgroundSettings::ShapeType>( {
    { u"square", QgsTextBackgroundSettings::ShapeSquare },
    { u"ellipse", QgsTextBackgroundSettings::ShapeEllipse },
    { u"circle", QgsTextBackgroundSettings::ShapeCircle },
    { u"svg", QgsTextBackgroundSettings::ShapeSVG },
    { u"marker", QgsTextBackgroundSettings::ShapeMarkerSymbol },
    { u"rectangle", QgsTextBackgroundSettings::ShapeRectangle },
  } );
 
  auto evaluatedType = SHAPE_TYPE_MAP.lookup( string );
  if ( evaluatedType )
  {
    return *evaluatedType;
  }
  return QgsTextBackgroundSettings::ShapeRectangle;
}
 
QgsTextBackgroundSettings::SizeType QgsTextRendererUtils::decodeBackgroundSizeType( const QString &string )
{
  static constexpr auto SIZE_TYPE_MAP = makeDataDefinedStringDecoder<QgsTextBackgroundSettings::SizeType>( {
    { u"fixed", QgsTextBackgroundSettings::SizeFixed },
    { u"buffer", QgsTextBackgroundSettings::SizeBuffer },
  } );
 
  auto evaluatedType = SIZE_TYPE_MAP.lookup( string );
  if ( evaluatedType )
  {
    return *evaluatedType;
  }
  return QgsTextBackgroundSettings::SizeBuffer;
}
 
QgsTextBackgroundSettings::RotationType QgsTextRendererUtils::decodeBackgroundRotationType( const QString &string )
{
  static constexpr auto ROTATION_TYPE_MAP = makeDataDefinedStringDecoder<QgsTextBackgroundSettings::RotationType>( {
    { u"offset", QgsTextBackgroundSettings::RotationOffset },
    { u"fixed", QgsTextBackgroundSettings::RotationFixed },
    { u"sync", QgsTextBackgroundSettings::RotationSync },
  } );
 
  auto evaluatedType = ROTATION_TYPE_MAP.lookup( string );
  if ( evaluatedType )
  {
    return *evaluatedType;
  }
  return QgsTextBackgroundSettings::RotationSync;
}
 
QgsTextShadowSettings::ShadowPlacement QgsTextRendererUtils::decodeShadowPlacementType( const QString &string )
{
  static constexpr auto SHADOW_PLACEMENT_MAP = makeDataDefinedStringDecoder<QgsTextShadowSettings::ShadowPlacement>( {
    { u"text", QgsTextShadowSettings::ShadowText },
    { u"buffer", QgsTextShadowSettings::ShadowBuffer },
    { u"background", QgsTextShadowSettings::ShadowShape },
    { u"lowest", QgsTextShadowSettings::ShadowLowest },
  } );
 
  auto evaluatedType = SHADOW_PLACEMENT_MAP.lookup( string );
  if ( evaluatedType )
  {
    return *evaluatedType;
  }
  return QgsTextShadowSettings::ShadowLowest;
}
 
QString QgsTextRendererUtils::encodeTextOrientation( Qgis::TextOrientation orientation )
{
  switch ( orientation )
  {
    case Qgis::TextOrientation::Horizontal:
      return u"horizontal"_s;
    case Qgis::TextOrientation::Vertical:
      return u"vertical"_s;
    case Qgis::TextOrientation::RotationBased:
      return u"rotation-based"_s;
  }
  return QString();
}
 
Qgis::TextOrientation QgsTextRendererUtils::decodeTextOrientation( const QString &name, bool *ok )
{
  if ( ok )
    *ok = true;
 
  static constexpr auto ORIENTATION_MAP = makeDataDefinedStringDecoder<Qgis::TextOrientation>( {
    { u"horizontal", Qgis::TextOrientation::Horizontal },
    { u"vertical", Qgis::TextOrientation::Vertical },
    { u"rotationbased", Qgis::TextOrientation::RotationBased },
  } );
 
  auto evaluatedOrientation = ORIENTATION_MAP.lookup( name );
  if ( evaluatedOrientation )
  {
    return *evaluatedOrientation;
  }
 
  if ( ok )
    *ok = false;
  return Qgis::TextOrientation::Horizontal;
}
 
Qgis::RenderUnit QgsTextRendererUtils::convertFromOldLabelUnit( int val )
{
  if ( val == 0 )
    return Qgis::RenderUnit::Points;
  else if ( val == 1 )
    return Qgis::RenderUnit::Millimeters;
  else if ( val == 2 )
    return Qgis::RenderUnit::MapUnits;
  else if ( val == 3 )
    return Qgis::RenderUnit::Percentage;
  else
    return Qgis::RenderUnit::Millimeters;
}
 
QColor QgsTextRendererUtils::readColor( QgsVectorLayer *layer, const QString &property, const QColor &defaultColor, bool withAlpha )
{
  const int r = layer->customProperty( property + 'R', QVariant( defaultColor.red() ) ).toInt();
  const int g = layer->customProperty( property + 'G', QVariant( defaultColor.green() ) ).toInt();
  const int b = layer->customProperty( property + 'B', QVariant( defaultColor.blue() ) ).toInt();
  const int a = withAlpha ? layer->customProperty( property + 'A', QVariant( defaultColor.alpha() ) ).toInt() : 255;
  return QColor( r, g, b, a );
}
 
std::unique_ptr< QgsTextRendererUtils::CurvePlacementProperties > QgsTextRendererUtils::generateCurvedTextPlacement(
  const QgsPrecalculatedTextMetrics &metrics,
  const QPolygonF &line,
  double offsetAlongLine,
  LabelLineDirection direction,
  double maxConcaveAngle,
  double maxConvexAngle,
  Qgis::CurvedTextFlags flags,
  Qgis::TextAnchorPoint textAnchor
)
{
  const std::size_t numPoints = line.size();
  std::vector<double> pathDistances( numPoints );
 
  const QPointF *p = line.data();
  double dx, dy;
 
  pathDistances[0] = 0;
  double prevX = p->x();
  double prevY = p->y();
  p++;
 
  std::vector< double > x( numPoints );
  std::vector< double > y( numPoints );
  x[0] = prevX;
  y[0] = prevY;
 
  for ( std::size_t i = 1; i < numPoints; ++i )
  {
    dx = p->x() - prevX;
    dy = p->y() - prevY;
    pathDistances[i] = std::sqrt( dx * dx + dy * dy );
 
    prevX = p->x();
    prevY = p->y();
    p++;
    x[i] = prevX;
    y[i] = prevY;
  }
 
  return generateCurvedTextPlacementPrivate( metrics, x.data(), y.data(), numPoints, pathDistances, offsetAlongLine, direction, flags, maxConcaveAngle, maxConvexAngle, false, 0, 0, textAnchor );
}
 
std::unique_ptr< QgsTextRendererUtils::CurvePlacementProperties > QgsTextRendererUtils::generateCurvedTextPlacement(
  const QgsPrecalculatedTextMetrics &metrics,
  const double *x,
  const double *y,
  int numPoints,
  const std::vector<double> &pathDistances,
  double offsetAlongLine,
  LabelLineDirection direction,
  double maxConcaveAngle,
  double maxConvexAngle,
  Qgis::CurvedTextFlags flags,
  double additionalCharacterSpacing,
  double additionalWordSpacing,
  Qgis::TextAnchorPoint textAnchor
)
{
  return generateCurvedTextPlacementPrivate( metrics, x, y, numPoints, pathDistances, offsetAlongLine, direction, flags, maxConcaveAngle, maxConvexAngle, false, additionalCharacterSpacing, additionalWordSpacing, textAnchor );
}
 
std::unique_ptr< QgsTextRendererUtils::CurvePlacementProperties > QgsTextRendererUtils::generateCurvedTextPlacementPrivate(
  const QgsPrecalculatedTextMetrics &metrics,
  const double *x,
  const double *y,
  int numPoints,
  const std::vector<double> &pathDistances,
  double offsetAlongLine,
  LabelLineDirection direction,
  Qgis::CurvedTextFlags flags,
  double maxConcaveAngle,
  double maxConvexAngle,
  bool isSecondAttempt,
  double additionalCharacterSpacing,
  double additionalWordSpacing,
  Qgis::TextAnchorPoint textAnchor
)
{
  auto output = std::make_unique< CurvePlacementProperties >();
  output->graphemePlacement.reserve( metrics.count() );
 
  if ( !qgsDoubleNear( additionalCharacterSpacing, 0 ) || !qgsDoubleNear( additionalWordSpacing, 0 ) )
    flags.setFlag( Qgis::CurvedTextFlag::ExtendLineToFitText );
 
  double totalLineLength = 0.0;
  for ( double pathDistance : pathDistances )
  {
    totalLineLength += pathDistance;
  }
 
  // cleanup incompatible parameters
  switch ( textAnchor )
  {
    case Qgis::TextAnchorPoint::StartOfText:
      break;
 
    case Qgis::TextAnchorPoint::CenterOfText:
    case Qgis::TextAnchorPoint::EndOfText:
      // TruncateStringWhenLineIsTooShort, offset along line not supported in these modes
      flags.setFlag( Qgis::CurvedTextFlag::TruncateStringWhenLineIsTooShort, false );
      offsetAlongLine = 0;
      break;
 
    case Qgis::TextAnchorPoint::FollowPlacement:
      // follow placement mode not supported here!
      textAnchor = Qgis::TextAnchorPoint::StartOfText;
      break;
  }
 
  double totalTextWidth = 0.0;
  int characterCount = metrics.count();
  for ( int i = 0; i < characterCount; ++i )
  {
    const double currentCharacterWidth = metrics.characterWidth( i );
    double spacing = 0.0;
    if ( i > 0 )
    {
      spacing = additionalCharacterSpacing;
      if ( !qgsDoubleNear( additionalWordSpacing, 0.0 ) )
      {
        const QString g = metrics.grapheme( i - 1 );
        if ( !g.isEmpty() && g.at( 0 ).isSpace() )
        {
          spacing += additionalWordSpacing;
        }
      }
    }
    totalTextWidth += currentCharacterWidth + spacing;
  }
  double adjustedOffsetAlongLine = 0.0;
  // expand calculated text width by a couple of pixels -- it's ok for us to run over the line
  // by a couple of pixels, and we don't want to risk truncating text due to floating point
  // calculation fuzziness
  constexpr double TEXT_WIDTH_ADJUSTMENT_FACTOR = 1.5;
  switch ( textAnchor )
  {
    case Qgis::TextAnchorPoint::StartOfText:
      adjustedOffsetAlongLine = offsetAlongLine;
      break;
 
    case Qgis::TextAnchorPoint::CenterOfText:
      adjustedOffsetAlongLine = ( totalLineLength - ( totalTextWidth + TEXT_WIDTH_ADJUSTMENT_FACTOR ) ) / 2.0;
      break;
 
    case Qgis::TextAnchorPoint::EndOfText:
      adjustedOffsetAlongLine = totalLineLength - ( totalTextWidth + TEXT_WIDTH_ADJUSTMENT_FACTOR );
      break;
 
    case Qgis::TextAnchorPoint::FollowPlacement:
      break;
  }
 
  std::vector< double > modifiedX( x, x + numPoints );
  std::vector< double > modifiedY( y, y + numPoints );
  std::vector< double > modifiedPathDistances = pathDistances;
 
  if ( adjustedOffsetAlongLine < 0.0 && ( flags & Qgis::CurvedTextFlag::ExtendLineToFitText ) )
  {
    // extend first segment of line to adjust for negative start offsets
    const double extension = std::abs( adjustedOffsetAlongLine );
    const double firstSegmentLength = modifiedPathDistances[1];
    if ( firstSegmentLength > 0.0 )
    {
      const double dx = modifiedX[1] - modifiedX[0];
      const double dy = modifiedY[1] - modifiedY[0];
      modifiedX[0] -= ( dx / firstSegmentLength ) * extension;
      modifiedY[0] -= ( dy / firstSegmentLength ) * extension;
      modifiedPathDistances[1] += extension;
      adjustedOffsetAlongLine = 0.0;
    }
  }
 
  double offsetAlongSegment = adjustedOffsetAlongLine;
  int index = 1;
  // Find index of segment corresponding to starting offset
  while ( index < numPoints && offsetAlongSegment > modifiedPathDistances[index] )
  {
    offsetAlongSegment -= modifiedPathDistances[index];
    index += 1;
  }
  if ( index >= numPoints )
  {
    return output;
  }
 
  const double segmentLength = modifiedPathDistances[index];
  if ( qgsDoubleNear( segmentLength, 0.0 ) )
  {
    // Not allowed to place across on 0 length segments or discontinuities
    return output;
  }
 
  if ( direction == RespectPainterOrientation && !isSecondAttempt )
  {
    // Calculate the orientation based on the angle of the path segment under consideration
 
    double distance = offsetAlongSegment;
    int endindex = index;
 
    double startLabelX = 0;
    double startLabelY = 0;
    double endLabelX = 0;
    double endLabelY = 0;
    for ( int i = 0; i < characterCount; i++ )
    {
      const double characterWidth = metrics.characterWidth( i );
      double characterStartX, characterStartY;
 
      // calculate additional spacing for this character
      double currentSpacing = 0.0;
      if ( i > 0 )
      {
        currentSpacing = additionalCharacterSpacing;
        if ( !qgsDoubleNear( additionalWordSpacing, 0.0 ) )
        {
          const QString g = metrics.grapheme( i - 1 );
          if ( !g.isEmpty() && g.at( 0 ).isSpace() )
          {
            currentSpacing += additionalWordSpacing;
          }
        }
      }
 
      if ( !nextCharPosition( characterWidth, modifiedPathDistances, modifiedX.data(), modifiedY.data(), numPoints, endindex, distance, characterStartX, characterStartY, endLabelX, endLabelY, flags, currentSpacing ) )
      {
        if ( flags & Qgis::CurvedTextFlag::TruncateStringWhenLineIsTooShort )
        {
          characterCount = i + 1;
          break;
        }
        else
        {
          return output;
        }
      }
      if ( i == 0 )
      {
        startLabelX = characterStartX;
        startLabelY = characterStartY;
      }
    }
 
    // Determine the angle of the path segment under consideration
    const double dx = endLabelX - startLabelX;
    const double dy = endLabelY - startLabelY;
    const double lineAngle = std::atan2( -dy, dx ) * 180 / M_PI;
 
    if ( lineAngle > 90 || lineAngle < -90 )
    {
      output->labeledLineSegmentIsRightToLeft = true;
    }
  }
 
  if ( isSecondAttempt )
  {
    // we know that treating the segment as running from right to left gave too many upside down characters, so try again treating the
    // segment as left to right
    output->labeledLineSegmentIsRightToLeft = false;
    output->flippedCharacterPlacementToGetUprightLabels = true;
  }
 
  const double dx = modifiedX[index] - modifiedX[index - 1];
  const double dy = modifiedY[index] - modifiedY[index - 1];
 
  double angle = std::atan2( -dy, dx );
 
  const double maxCharacterDescent = metrics.maximumCharacterDescent();
  const double maxCharacterHeight = metrics.maximumCharacterHeight();
 
  for ( int i = 0; i < characterCount; i++ )
  {
    const double lastCharacterAngle = angle;
 
    // next character index, depending on the orientation
    const int k = !output->flippedCharacterPlacementToGetUprightLabels ? i : characterCount - i - 1;
 
    // grab the next character according to the orientation
    const double characterWidth = metrics.characterWidth( k );
    if ( qgsDoubleNear( characterWidth, 0.0 ) )
      // Certain scripts rely on zero-width character, skip those to prevent failure (see #15801)
      continue;
 
    const double characterHeight = metrics.characterHeight( k );
    const double characterDescent = metrics.characterDescent( k );
 
    double characterStartX = 0;
    double characterStartY = 0;
    double characterEndX = 0;
    double characterEndY = 0;
 
    // Calculate Spacing
    double currentSpacing = 0.0;
    if ( i > 0 )
    {
      currentSpacing = additionalCharacterSpacing;
      if ( !qgsDoubleNear( additionalWordSpacing, 0.0 ) )
      {
        int prevCharIndex = !output->flippedCharacterPlacementToGetUprightLabels ? k - 1 : k + 1;
        if ( prevCharIndex >= 0 && prevCharIndex < metrics.count() )
        {
          const QString g = metrics.grapheme( prevCharIndex );
          if ( !g.isEmpty() && g.at( 0 ).isSpace() )
            currentSpacing += additionalWordSpacing;
        }
      }
    }
 
    if ( !nextCharPosition( characterWidth, modifiedPathDistances, modifiedX.data(), modifiedY.data(), numPoints, index, offsetAlongSegment, characterStartX, characterStartY, characterEndX, characterEndY, flags, currentSpacing ) )
    {
      if ( flags & Qgis::CurvedTextFlag::TruncateStringWhenLineIsTooShort )
      {
        characterCount = i + 1;
        break;
      }
      else
      {
        output->graphemePlacement.clear();
        return output;
      }
    }
 
    // Calculate angle from the start of the character to the end based on start/end of character
    angle = std::atan2( characterStartY - characterEndY, characterEndX - characterStartX );
 
    if ( maxConcaveAngle >= 0 || maxConvexAngle >= 0 )
    {
      // Test lastCharacterAngle vs angle
      // since our rendering angle has changed then check against our
      // max allowable angle change.
      double angleDelta = lastCharacterAngle - angle;
      // normalise between -180 and 180
      while ( angleDelta > M_PI )
        angleDelta -= 2 * M_PI;
      while ( angleDelta < -M_PI )
        angleDelta += 2 * M_PI;
      if ( ( maxConcaveAngle >= 0 && angleDelta > 0 && angleDelta > maxConcaveAngle ) || ( maxConvexAngle >= 0 && angleDelta < 0 && angleDelta < -maxConvexAngle ) )
      {
        output->graphemePlacement.clear();
        return output;
      }
    }
 
    if ( !( flags & Qgis::CurvedTextFlag::UseBaselinePlacement ) )
    {
      // Shift the character downwards since the draw position is specified at the baseline
      // and we're calculating the mean line here
      double dist = 0.9 * maxCharacterHeight / 2 - ( maxCharacterDescent - characterDescent );
      if ( output->flippedCharacterPlacementToGetUprightLabels )
      {
        dist = -dist;
      }
      characterStartX += dist * std::cos( angle + M_PI_2 );
      characterStartY -= dist * std::sin( angle + M_PI_2 );
    }
 
    double renderAngle = angle;
    CurvedGraphemePlacement placement;
    placement.graphemeIndex = !output->flippedCharacterPlacementToGetUprightLabels ? i : characterCount - i - 1;
    placement.x = characterStartX;
    placement.y = characterStartY;
    placement.width = characterWidth;
    placement.height = characterHeight;
    const QString grapheme = metrics.grapheme( placement.graphemeIndex );
    placement.isWhitespace = grapheme.isEmpty() || grapheme.at( 0 ).isSpace() || grapheme.at( 0 ) == '\t';
    if ( output->flippedCharacterPlacementToGetUprightLabels )
    {
      // rotate in place
      placement.x += characterWidth * std::cos( renderAngle );
      placement.y -= characterWidth * std::sin( renderAngle );
      renderAngle += M_PI;
    }
    placement.angle = -renderAngle;
    output->graphemePlacement.push_back( placement );
 
    // Normalise to 0 <= angle < 2PI
    while ( renderAngle >= 2 * M_PI )
      renderAngle -= 2 * M_PI;
    while ( renderAngle < 0 )
      renderAngle += 2 * M_PI;
 
    if ( renderAngle > M_PI_2 && renderAngle < 1.5 * M_PI )
      output->upsideDownCharCount++;
  }
 
  if ( !isSecondAttempt && ( flags & Qgis::CurvedTextFlag::UprightCharactersOnly ) && output->upsideDownCharCount >= characterCount / 2.0 )
  {
    // more of text is upside down then right side up...
    // if text should be shown upright then retry with the opposite orientation
    return generateCurvedTextPlacementPrivate( metrics, x, y, numPoints, pathDistances, offsetAlongLine, direction, flags, maxConcaveAngle, maxConvexAngle, true, additionalCharacterSpacing, additionalWordSpacing, textAnchor );
  }
 
  return output;
}
 
bool QgsTextRendererUtils::nextCharPosition(
  double charWidth,
  const std::vector<double> &pathDistances,
  const double *x,
  const double *y,
  int numPoints,
  int &index,
  double &currentDistanceAlongSegment,
  double &characterStartX,
  double &characterStartY,
  double &characterEndX,
  double &characterEndY,
  Qgis::CurvedTextFlags flags,
  double additionalSpacing
)
{
  if ( !qgsDoubleNear( additionalSpacing, 0.0 ) )
  {
    currentDistanceAlongSegment += additionalSpacing;
 
    // forward spacing
    while ( index < numPoints && currentDistanceAlongSegment > pathDistances[index] )
    {
      currentDistanceAlongSegment -= pathDistances[index];
      index++;
    }
    // backward spacing (compression)
    while ( currentDistanceAlongSegment < 0 )
    {
      index--;
      if ( index < 1 )
        return false;
      currentDistanceAlongSegment += pathDistances[index];
    }
  }
 
  // intentional for readability:
  // NOLINTBEGIN(bugprone-branch-clone)
  if ( index >= numPoints )
  {
    // do not support extending the line start or end points via additional spacing
    return false;
  }
  else if ( qgsDoubleNear( pathDistances[index], 0.0 ) )
  {
    // Not allowed to place across on 0 length segments or discontinuities
    return false;
  }
  // NOLINTEND(bugprone-branch-clone)
 
  double segmentStartX = x[index - 1];
  double segmentStartY = y[index - 1];
 
  double segmentEndX = x[index];
  double segmentEndY = y[index];
 
  double segmentLength = pathDistances[index];
 
  const double segmentDx = segmentEndX - segmentStartX;
  const double segmentDy = segmentEndY - segmentStartY;
 
  characterStartX = segmentStartX + segmentDx * currentDistanceAlongSegment / segmentLength;
  characterStartY = segmentStartY + segmentDy * currentDistanceAlongSegment / segmentLength;
 
  // Coordinates this character ends at, calculated below
  characterEndX = 0;
  characterEndY = 0;
 
  if ( segmentLength - currentDistanceAlongSegment >= charWidth )
  {
    // if the distance remaining in this segment is enough, we just go further along the segment
    currentDistanceAlongSegment += charWidth;
    characterEndX = segmentStartX + segmentDx * currentDistanceAlongSegment / segmentLength;
    characterEndY = segmentStartY + segmentDy * currentDistanceAlongSegment / segmentLength;
  }
  else
  {
    // If there isn't enough distance left on this segment
    // then we need to search until we find the line segment that ends further than ci.width away
    do
    {
      index++;
      if ( index >= numPoints ) // Bail out if we run off the end of the shape
      {
        if ( flags & Qgis::CurvedTextFlag::ExtendLineToFitText )
        {
          // here we should extend out the final segment of the line to fit the character
          const double lastSegmentDx = segmentEndX - segmentStartX;
          const double lastSegmentDy = segmentEndY - segmentStartY;
          const double lastSegmentLength = std::sqrt( lastSegmentDx * lastSegmentDx + lastSegmentDy * lastSegmentDy );
          if ( qgsDoubleNear( lastSegmentLength, 0.0 ) )
          {
            // last segment has 0 length, can't extend
            return false;
          }
 
          segmentEndX = segmentStartX + ( lastSegmentDx / lastSegmentLength ) * charWidth;
          segmentEndY = segmentStartY + ( lastSegmentDy / lastSegmentLength ) * charWidth;
          index--;
          break;
        }
        else
        {
          return false;
        }
      }
 
      segmentStartX = segmentEndX;
      segmentStartY = segmentEndY;
      segmentEndX = x[index];
      segmentEndY = y[index];
    } while ( std::sqrt( std::pow( characterStartX - segmentEndX, 2 ) + std::pow( characterStartY - segmentEndY, 2 ) ) < charWidth ); // Distance from character start to end
 
    // Calculate the position to place the end of the character on
    findLineCircleIntersection( characterStartX, characterStartY, charWidth, segmentStartX, segmentStartY, segmentEndX, segmentEndY, characterEndX, characterEndY );
 
    // Need to calculate distance on the new segment
    currentDistanceAlongSegment = std::sqrt( std::pow( segmentStartX - characterEndX, 2 ) + std::pow( segmentStartY - characterEndY, 2 ) );
  }
  return true;
}
 
void QgsTextRendererUtils::findLineCircleIntersection( double cx, double cy, double radius, double x1, double y1, double x2, double y2, double &xRes, double &yRes )
{
  double multiplier = 1;
  if ( radius < 10 )
  {
    // these calculations get unstable for small coordinates differences, e.g. as a result of map labeling in a geographic
    // CRS
    multiplier = 10000;
    x1 *= multiplier;
    y1 *= multiplier;
    x2 *= multiplier;
    y2 *= multiplier;
    cx *= multiplier;
    cy *= multiplier;
    radius *= multiplier;
  }
 
  const double dx = x2 - x1;
  const double dy = y2 - y1;
 
  const double A = dx * dx + dy * dy;
  const double B = 2 * ( dx * ( x1 - cx ) + dy * ( y1 - cy ) );
  const double C = QgsGeometryUtilsBase::sqrDistance2D( x1, y1, cx, cy ) - radius * radius;
 
  const double det = B * B - 4 * A * C;
  if ( A <= 0.000000000001 || det < 0 )
    // Should never happen, No real solutions.
    return;
 
  if ( qgsDoubleNear( det, 0.0 ) )
  {
    // Could potentially happen.... One solution.
    const double t = -B / ( 2 * A );
    xRes = x1 + t * dx;
    yRes = y1 + t * dy;
  }
  else
  {
    // Two solutions.
    // Always use the 1st one
    // We only really have one solution here, as we know the line segment will start in the circle and end outside
    const double t = ( -B + std::sqrt( det ) ) / ( 2 * A );
    xRes = x1 + t * dx;
    yRes = y1 + t * dy;
  }
 
  if ( multiplier != 1 )
  {
    xRes /= multiplier;
    yRes /= multiplier;
  }
}