LabelPosition* FeaturePart::curvedPlacementAtOffset( PointSet* path_positions, double* path_distances, int& orientation, int index, double distance, bool& flip )

if ( !isUprightLabel() )

{

if ( orientation != 1 )

flip = true; // Report to the caller, that the orientation is flipped

orientation = 1;

}

{

flip = true;

}

while ( render_angle >= 2 * M_PI ) render_angle -= 2 * M_PI;

if ( render_angle > M_PI / 2 && render_angle < 1.5 * M_PI )

slp->incrementUpsideDownCharCount();

bool reversed = (( flags & FLAG_MAP_ORIENTATION ) ? isRightToLeft : false );

if ( !( flags & FLAG_MAP_ORIENTATION ) )

//... but if we are using line orientation flags, then we can only accept a single orientation,

// as we need to ensure that the labels fall inside or outside the polyline or polygon (and not mixed)

bool flip = false;

bool orientation_forced = ( orientation != 0 ); // Whether the orientation was set by the caller

LabelPosition* slp = curvedPlacementAtOffset( mapShape, path_distances, orientation, 1, i * delta, flip );

if ( slp == nullptr )

continue;

// If we placed too many characters upside down

if ( slp->upsideDownCharCount() >= li->char_num / 2.0 )

// if we auto-detected the orientation then retry with the opposite orientation

if ( !orientation_forced )

orientation = -orientation;

delete slp;

slp = curvedPlacementAtOffset( mapShape, path_distances, orientation, 1, i * delta, flip );

}

else if ( isUprightLabel() && !flip )

{

// Retry with the opposite orientation

orientation = -orientation;

delete slp;

slp = curvedPlacementAtOffset( mapShape, path_distances, orientation, 1, i * delta, flip );

}

}

if ( slp == nullptr )

continue;

// evaluate cost

double angle_diff = 0.0, angle_last = 0.0, diff;

LabelPosition* tmp = slp;

double sin_avg = 0, cos_avg = 0;

while ( tmp )

{

if ( tmp != slp ) // not first?

{

diff = fabs( tmp->getAlpha() - angle_last );

if ( diff > 2*M_PI ) diff -= 2 * M_PI;

diff = qMin( diff, 2 * M_PI - diff ); // difference 350 deg is actually just 10 deg...

angle_diff += diff;

sin_avg += sin( tmp->getAlpha() );

cos_avg += cos( tmp->getAlpha() );

angle_last = tmp->getAlpha();

tmp = tmp->getNextPart();

}

double angle_diff_avg = li->char_num > 1 ? ( angle_diff / ( li->char_num - 1 ) ) : 0; // <0, pi> but pi/8 is much already

double cost = angle_diff_avg / 100; // <0, 0.031 > but usually <0, 0.003 >

if ( cost < 0.0001 ) cost = 0.0001;

// penalize positions which are further from the line's midpoint

double labelCenter = ( i * delta ) + getLabelWidth() / 2;

double costCenter = qAbs( total_distance / 2 - labelCenter ) / total_distance; // <0, 0.5>

cost += costCenter / 1000; // < 0, 0.0005 >

slp->setCost( cost );

// average angle is calculated with respect to periodicity of angles

double angle_avg = atan2( sin_avg / li->char_num, cos_avg / li->char_num );

bool localreversed = flip ? !reversed : reversed;

// displacement - we loop through 3 times, generating above, online then below line placements successively

for ( int i = 0; i <= 2; ++i )

{

LabelPosition* p = nullptr;

if ( i == 0 && (( !localreversed && ( flags & FLAG_ABOVE_LINE ) ) || ( localreversed && ( flags & FLAG_BELOW_LINE ) ) ) )

p = _createCurvedCandidate( slp, angle_avg, mLF->distLabel() + li->label_height / 2 );

if ( i == 1 && flags & FLAG_ON_LINE )

p = _createCurvedCandidate( slp, angle_avg, 0 );

p->setCost( p->cost() + 0.002 );

}

if ( i == 2 && (( !localreversed && ( flags & FLAG_BELOW_LINE ) ) || ( localreversed && ( flags & FLAG_ABOVE_LINE ) ) ) )

{

p = _createCurvedCandidate( slp, angle_avg, -li->label_height / 2 - mLF->distLabel() );

p->setCost( p->cost() + 0.001 );

}

if ( p && mLF->permissibleZonePrepared() )

{

bool within = true;

LabelPosition* currentPos = p;

while ( within && currentPos )

within = GeomFunction::containsCandidate( mLF->permissibleZonePrepared(), currentPos->getX(), currentPos->getY(), currentPos->getWidth(), currentPos->getHeight(), currentPos->getAlpha() );

currentPos = currentPos->getNextPart();

if ( !within )

delete p;

p = nullptr;

if ( p )

positions.append( p );

// delete original candidate

delete slp;

}

if ( mLF->layer()->isCurved() )

bool FeaturePart::isUprightLabel() const

{

bool uprightLabel = false;

switch ( mLF->layer()->upsidedownLabels() )

{

case Layer::Upright:

uprightLabel = true;

break;

case Layer::ShowDefined:

// upright only dynamic labels

if ( !hasFixedRotation() || ( !hasFixedPosition() && fixedAngle() == 0.0 ) )

{

uprightLabel = true;

}

break;

case Layer::ShowAll:

break;

default:

uprightLabel = true;

}

return uprightLabel;

}

int& orientation, int index, double distance, bool& flip );

//! Returns true if the feature's label has a fixed rotation

bool hasFixedRotation() const { return mLF->hasFixedAngle(); }

//! Returns the fixed angle for the feature's label

double fixedAngle() const { return mLF->fixedAngle(); }

//! Returns true if the feature's label has a fixed position

bool hasFixedPosition() const { return mLF->hasFixedPosition(); }

//! Returns true if the feature's label should always been shown,

//! even when it collides with other labels

bool alwaysShow() const { return mLF->alwaysShow(); }

//! Returns true if the feature should act as an obstacle to labels

bool isObstacle() const { return mLF->isObstacle(); }

//! Returns the feature's obstacle factor, which represents the penalty

//! incurred for a label to overlap the feature

double obstacleFactor() const { return mLF->obstacleFactor(); }

//! Returns the distance between repeating labels for this feature

double repeatDistance() const { return mLF->repeatDistance(); }

//! Returns true if feature's label must be displayed upright

bool isUprightLabel() const;