/*!
\brief Complete a polygon to be a closed polygon
including the area between the original polygon
and the baseline.
\param xMap X map
\param yMap Y map
\param pa Polygon to be completed
*/
void QwtPlotCurve::closePolyline(
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
QwtPolygon &pa) const
{
const int sz = pa.size();
if ( sz < 2 )
return;
pa.resize(sz + 2);
if ( d_data->curveType == QwtPlotCurve::Xfy )
{
pa.setPoint(sz,
xMap.transform(d_data->reference), pa.point(sz - 1).y());
pa.setPoint(sz + 1,
xMap.transform(d_data->reference), pa.point(0).y());
}
else
{
pa.setPoint(sz,
pa.point(sz - 1).x(), yMap.transform(d_data->reference));
pa.setPoint(pa.size() - 1,
pa.point(0).x(), yMap.transform(d_data->reference));
}
}
/*!
Draw lines
\param painter Painter
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param radialMap Maps radius values into painter coordinates.
\param pole Position of the pole in painter coordinates
\param from index of the first point to be painted
\param to index of the last point to be painted.
\sa draw(), drawLines(), setCurveFitter()
*/
void QwtPolarCurve::drawLines( QPainter *painter,
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QwtDoublePoint &pole, int from, int to ) const
{
int size = to - from + 1;
if ( size <= 0 )
return;
QwtPolygon polyline;
if ( d_data->curveFitter )
{
#if QT_VERSION < 0x040000
QwtArray<QwtDoublePoint> points( size );
#else
QwtPolygonF points( size );
#endif
for ( int j = from; j <= to; j++ )
points[j - from] = QwtDoublePoint( azimuth( j ), radius( j ) );
points = d_data->curveFitter->fitCurve( points );
polyline.resize( points.size() );
for ( int i = 0; i < ( int )points.size(); i++ )
{
const QwtPolarPoint point( points[i].x(), points[i].y() );
double r = radialMap.xTransform( point.radius() );
const double a = azimuthMap.xTransform( point.azimuth() );
polyline.setPoint( i, qwtPolar2Pos( pole, r, a ).toPoint() );
}
}
else
{
polyline.resize( size );
for ( int i = from; i <= to; i++ )
{
const QwtPolarPoint point = sample( i );
double r = radialMap.xTransform( point.radius() );
const double a = azimuthMap.xTransform( point.azimuth() );
polyline.setPoint( i - from, qwtPolar2Pos( pole, r, a ).toPoint() );
}
}
QRect clipRect = painter->window();
clipRect.setRect( clipRect.x() - 1, clipRect.y() - 1,
clipRect.width() + 2, clipRect.height() + 2 );
polyline = QwtClipper::clipPolygon( clipRect, polyline );
QwtPainter::drawPolyline( painter, polyline );
}
inline static void addPoint(QwtPolygon &pa, uint pos, const QPoint &point)
{
if ( uint(pa.size()) <= pos )
pa.resize(pos + 5);
pa.setPoint(pos, point);
}
inline void QwtPolygonClipper::addPoint(
QwtPolygon &pa, uint pos, const QPoint &point) const
{
if ( uint(pa.size()) <= pos )
pa.resize(pos + 5);
pa.setPoint(pos, point);
}
/*!
Draw dots
\param painter Painter
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa draw(), drawCurve(), drawSticks(), drawLines(), drawSteps()
*/
void QwtPlotCurve::drawDots(QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to) const
{
const QRect window = painter->window();
if ( window.isEmpty() )
return;
const bool doFill = d_data->brush.style() != Qt::NoBrush;
QwtPolygon polyline;
if ( doFill )
polyline.resize(to - from + 1);
if ( to > from && d_data->paintAttributes & PaintFiltered )
{
if ( doFill )
{
QPoint pp( xMap.transform(x(from)), yMap.transform(y(from)) );
QwtPainter::drawPoint(painter, pp.x(), pp.y());
polyline.setPoint(0, pp);
int count = 1;
for (int i = from + 1; i <= to; i++)
{
const QPoint pi(xMap.transform(x(i)), yMap.transform(y(i)));
if ( pi != pp )
{
QwtPainter::drawPoint(painter, pi.x(), pi.y());
polyline.setPoint(count, pi);
count++;
pp = pi;
}
}
if ( int(polyline.size()) != count )
polyline.resize(count);
}
else
{
// if we don't need to fill, we can sort out
// duplicates independent from the order
PrivateData::PixelMatrix pixelMatrix(window);
for (int i = from; i <= to; i++)
{
const QPoint p( xMap.transform(x(i)),
yMap.transform(y(i)) );
if ( pixelMatrix.testPixel(p) )
QwtPainter::drawPoint(painter, p.x(), p.y());
}
}
}
else
{
for (int i = from; i <= to; i++)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
QwtPainter::drawPoint(painter, xi, yi);
if ( doFill )
polyline.setPoint(i - from, xi, yi);
}
}
if ( doFill )
{
if ( d_data->paintAttributes & ClipPolygons )
polyline = QwtClipper::clipPolygon(painter->window(), polyline);
fillCurve(painter, xMap, yMap, polyline);
}
}
/*!
\brief Draw lines
If the CurveAttribute Fitted is enabled a QwtCurveFitter tries
to interpolate/smooth the curve, before it is painted.
\param painter Painter
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setCurveAttribute(), setCurveFitter(), draw(),
drawLines(), drawDots(), drawSteps(), drawSticks()
*/
void QwtPlotCurve::drawLines(QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to) const
{
int size = to - from + 1;
if ( size <= 0 )
return;
QwtPolygon polyline;
if ( ( d_data->attributes & Fitted ) && d_data->curveFitter )
{
// Transform x and y values to window coordinates
// to avoid a distinction between linear and
// logarithmic scales.
#if QT_VERSION < 0x040000
QwtArray<QwtDoublePoint> points(size);
#else
QPolygonF points(size);
#endif
for (int i = from; i <= to; i++)
{
QwtDoublePoint &p = points[i];
p.setX( xMap.xTransform(x(i)) );
p.setY( yMap.xTransform(y(i)) );
}
points = d_data->curveFitter->fitCurve(points);
size = points.size();
if ( size == 0 )
return;
// Round QwtDoublePoints to QPoints
// When Qwt support for Qt3 has been dropped (Qwt 6.x)
// we will use a doubles for painting and the following
// step will be obsolete.
polyline.resize(size);
const QwtDoublePoint *p = points.data();
QPoint *pl = polyline.data();
if ( d_data->paintAttributes & PaintFiltered )
{
QPoint pp(qRound(p[0].x()), qRound(p[0].y()));
pl[0] = pp;
int count = 1;
for (int i = 1; i < size; i++)
{
const QPoint pi(qRound(p[i].x()), qRound(p[i].y()));
if ( pi != pp )
{
pl[count++] = pi;
pp = pi;
}
}
if ( count != size )
polyline.resize(count);
}
else
{
for ( int i = 0; i < size; i++ )
{
pl[i].setX( qRound(p[i].x()) );
pl[i].setY( qRound(p[i].y()) );
}
}
}
else
{
polyline.resize(size);
if ( d_data->paintAttributes & PaintFiltered )
{
QPoint pp( xMap.transform(x(from)), yMap.transform(y(from)) );
polyline.setPoint(0, pp);
int count = 1;
for (int i = from + 1; i <= to; i++)
{
const QPoint pi(xMap.transform(x(i)), yMap.transform(y(i)));
if ( pi != pp )
{
polyline.setPoint(count, pi);
count++;
pp = pi;
}
}
if ( count != size )
polyline.resize(count);
}
else
{
for (int i = from; i <= to; i++)
{
int xi = xMap.transform(x(i));
int yi = yMap.transform(y(i));
polyline.setPoint(i - from, xi, yi);
}
}
}
if ( d_data->paintAttributes & ClipPolygons )
polyline = QwtClipper::clipPolygon(painter->window(), polyline);
QwtPainter::drawPolyline(painter, polyline);
if ( d_data->brush.style() != Qt::NoBrush )
fillCurve(painter, xMap, yMap, polyline);
}