qgsdxfpaintengine.cpp

Go to the documentation of this file.

/***************************************************************************
                         qgsdxpaintengine.cpp
                         --------------------
    begin                : November 2013
    copyright            : (C) 2013 by Marco Hugentobler
    email                : marco at sourcepole dot ch
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 "qgsdxfpaintengine.h"
 
#include "qgsdxfexport.h"
#include "qgsdxfpaintdevice.h"
#include "qgslogger.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
QgsDxfPaintEngine::QgsDxfPaintEngine( const QgsDxfPaintDevice *dxfDevice, QgsDxfExport *dxf )
  : QPaintEngine( QPaintEngine::AllFeatures /*QPaintEngine::PainterPaths | QPaintEngine::PaintOutsidePaintEvent*/ )
  , mPaintDevice( dxfDevice )
  , mDxf( dxf )
{}
 
bool QgsDxfPaintEngine::begin( QPaintDevice *pdev )
{
  Q_UNUSED( pdev )
  return true;
}
 
bool QgsDxfPaintEngine::end()
{
  return true;
}
 
QPaintEngine::Type QgsDxfPaintEngine::type() const
{
  return QPaintEngine::User;
}
 
void QgsDxfPaintEngine::drawPixmap( const QRectF &r, const QPixmap &pm, const QRectF &sr )
{
  Q_UNUSED( r )
  Q_UNUSED( pm )
  Q_UNUSED( sr )
}
 
void QgsDxfPaintEngine::updateState( const QPaintEngineState &state )
{
  if ( state.state() & QPaintEngine::DirtyTransform )
    mTransform = state.transform();
 
  if ( state.state() & QPaintEngine::DirtyPen )
    mPen = state.pen();
 
  if ( state.state() & QPaintEngine::DirtyBrush )
    mBrush = state.brush();
 
  if ( state.state() & QPaintEngine::DirtyOpacity )
  {
    mOpacity = state.opacity();
  }
 
  // Store the clip in device coordinates so it can be intersected directly
  // with the device-space polygons we get in clipPolygonLogical().
  // Region is processed first and path second: when both flags are set in
  // the same update, the path branch overwrites the region one, matching
  // QPainter's "setClipPath replaces any region clip" semantics.
  if ( state.state() & QPaintEngine::DirtyClipRegion )
  {
    if ( state.clipOperation() == Qt::NoClip )
    {
      mClipPath = QPainterPath();
    }
    else
    {
      QPainterPath p;
      p.addRegion( state.clipRegion() );
      mClipPath = state.transform().map( p );
    }
  }
  if ( state.state() & QPaintEngine::DirtyClipPath )
  {
    if ( state.clipOperation() == Qt::NoClip )
    {
      mClipPath = QPainterPath();
    }
    else
    {
      mClipPath = state.transform().map( state.clipPath() );
    }
  }
  if ( state.state() & ( QPaintEngine::DirtyClipPath | QPaintEngine::DirtyClipRegion | QPaintEngine::DirtyClipEnabled ) )
  {
    mClipEnabled = state.isClipEnabled() && !mClipPath.isEmpty();
  }
}
 
QList<QPolygonF> QgsDxfPaintEngine::clipPolygonLogical( const QPolygonF &polyLogical ) const
{
  if ( !mClipEnabled || mClipPath.isEmpty() || polyLogical.isEmpty() )
    return { polyLogical };
 
  // mClipPath is stored in device coords; map the incoming logical polygon
  // through the current painter transform so the intersection happens in the
  // same space, then map the clipped subpaths back to logical coords for the
  // caller (which feeds them into toDxfCoordinates()).
  const QPolygonF polyDevice = mTransform.map( polyLogical );
  QPainterPath polyPath;
  polyPath.addPolygon( polyDevice );
  const QPainterPath clipped = polyPath.intersected( mClipPath );
  if ( clipped.isEmpty() )
    return {};
 
  bool invertible = false;
  const QTransform inv = mTransform.inverted( &invertible );
  if ( !invertible )
    return { polyLogical };
 
  QList<QPolygonF> result;
  const QList<QPolygonF> subs = clipped.toSubpathPolygons();
  result.reserve( subs.size() );
  for ( const QPolygonF &sub : subs )
  {
    if ( sub.size() < 2 )
      continue;
    result << inv.map( sub );
  }
  return result;
}
 
void QgsDxfPaintEngine::setRing( QgsPointSequence &polyline, const QPointF *points, int pointCount )
{
  polyline.clear();
  for ( int i = 0; i < pointCount; ++i )
    polyline.append( toDxfCoordinates( points[i] ) );
}
 
void QgsDxfPaintEngine::drawPolygon( const QPointF *points, int pointCount, PolygonDrawMode mode )
{
  Q_UNUSED( mode )
  if ( !mDxf || !mPaintDevice )
    return;
 
  QPolygonF inputPoly;
  inputPoly.reserve( pointCount );
  for ( int i = 0; i < pointCount; ++i )
    inputPoly << points[i];
 
  const QList<QPolygonF> polys = clipPolygonLogical( inputPoly );
  for ( const QPolygonF &sub : polys )
  {
    if ( sub.size() < 2 )
      continue;
 
    QgsRingSequence polygon;
    polygon << QgsPointSequence();
    setRing( polygon.last(), sub.constData(), sub.size() );
 
    if ( mode == QPaintEngine::PolylineMode )
    {
      if ( mPen.style() != Qt::NoPen && mPen.brush().style() != Qt::NoBrush )
        mDxf->writePolyline( polygon.at( 0 ), mLayer, u"CONTINUOUS"_s, penColor(), currentWidth() );
    }
    else
    {
      if ( mBrush.style() != Qt::NoBrush )
        mDxf->writePolygon( polygon, mLayer, u"SOLID"_s, brushColor() );
    }
  }
}
 
void QgsDxfPaintEngine::drawPath( const QPainterPath &path )
{
  const int pathLength = path.elementCount();
  for ( int i = 0; i < pathLength; ++i )
  {
    const QPainterPath::Element &pathElem = path.elementAt( i );
    if ( pathElem.type == QPainterPath::MoveToElement )
    {
      moveTo( pathElem.x, pathElem.y );
    }
    else if ( pathElem.type == QPainterPath::LineToElement )
    {
      lineTo( pathElem.x, pathElem.y );
    }
    else if ( pathElem.type == QPainterPath::CurveToElement )
    {
      curveTo( pathElem.x, pathElem.y );
    }
    else if ( pathElem.type == QPainterPath::CurveToDataElement )
    {
      mCurrentCurve.append( QPointF( pathElem.x, pathElem.y ) );
    }
  }
  endCurve();
  endPolygon();
 
  if ( !mPolygon.isEmpty() && mBrush.style() != Qt::NoBrush )
    mDxf->writePolygon( mPolygon, mLayer, u"SOLID"_s, brushColor() );
 
  mPolygon.clear();
}
 
void QgsDxfPaintEngine::moveTo( double dx, double dy )
{
  endCurve();
  endPolygon();
  mCurrentPolygon.append( QPointF( dx, dy ) );
}
 
void QgsDxfPaintEngine::lineTo( double dx, double dy )
{
  endCurve();
  mCurrentPolygon.append( QPointF( dx, dy ) );
}
 
void QgsDxfPaintEngine::curveTo( double dx, double dy )
{
  endCurve();
  if ( !mCurrentPolygon.isEmpty() )
    mCurrentCurve.append( mCurrentPolygon.last() );
 
  mCurrentCurve.append( QPointF( dx, dy ) );
}
 
void QgsDxfPaintEngine::endPolygon()
{
  if ( mCurrentPolygon.size() > 1 )
  {
    if ( mPen.style() != Qt::NoPen )
      drawPolygon( mCurrentPolygon.constData(), mCurrentPolygon.size(), QPaintEngine::PolylineMode );
 
    const QList<QPolygonF> clipped = clipPolygonLogical( mCurrentPolygon );
    for ( const QPolygonF &sub : clipped )
    {
      if ( sub.size() < 2 )
        continue;
      mPolygon << QgsPointSequence();
      setRing( mPolygon.last(), sub.constData(), sub.size() );
    }
  }
  mCurrentPolygon.clear();
}
 
void QgsDxfPaintEngine::endCurve()
{
  if ( mCurrentCurve.empty() )
    return;
 
  if ( mCurrentPolygon.empty() )
  {
    mCurrentCurve.clear();
    return;
  }
 
  if ( mCurrentCurve.size() >= 3 )
  {
    double t = 0.05;
    for ( int i = 1; i <= 20; ++i ) //approximate curve with 20 segments
    {
      mCurrentPolygon.append( bezierPoint( mCurrentCurve, t ) );
      t += 0.05;
    }
  }
  else if ( mCurrentCurve.size() == 2 )
  {
    mCurrentPolygon.append( mCurrentCurve.at( 1 ) );
  }
  mCurrentCurve.clear();
}
 
void QgsDxfPaintEngine::drawLines( const QLineF *lines, int lineCount )
{
  if ( !mDxf || !mPaintDevice || !lines || mPen.style() == Qt::NoPen )
    return;
 
  for ( int i = 0; i < lineCount; ++i )
  {
    mDxf->writeLine( toDxfCoordinates( lines[i].p1() ), toDxfCoordinates( lines[i].p2() ), mLayer, u"CONTINUOUS"_s, penColor(), currentWidth() );
  }
}
 
QgsPoint QgsDxfPaintEngine::toDxfCoordinates( QPointF pt ) const
{
  if ( !mPaintDevice || !mDxf )
    return QgsPoint( pt.x(), pt.y() );
 
  const QPointF dxfPt = mPaintDevice->dxfCoordinates( mTransform.map( pt ) ) + mShift;
  return QgsPoint( dxfPt.x(), dxfPt.y() );
}
 
 
double QgsDxfPaintEngine::currentWidth() const
{
  if ( !mPaintDevice )
    return 1;
 
  return mPen.widthF() * mPaintDevice->widthScaleFactor();
}
 
QPointF QgsDxfPaintEngine::bezierPoint( const QList<QPointF> &controlPolygon, double t )
{
  double x = 0;
  double y = 0;
  const int cPolySize = controlPolygon.size();
  double bPoly = 0;
 
  QList<QPointF>::const_iterator it = controlPolygon.constBegin();
  int i = 0;
  for ( ; it != controlPolygon.constEnd(); ++it )
  {
    bPoly = bernsteinPoly( cPolySize - 1, i, t );
    x += ( it->x() * bPoly );
    y += ( it->y() * bPoly );
    ++i;
  }
 
  return QPointF( x, y );
}
 
double QgsDxfPaintEngine::bernsteinPoly( int n, int i, double t )
{
  if ( i < 0 )
    return 0;
 
  return lower( n, i ) * power( t, i ) * power( ( 1 - t ), ( n - i ) );
}
 
int QgsDxfPaintEngine::lower( int n, int i )
{
  if ( i >= 0 && i <= n )
  {
    return faculty( n ) / ( faculty( i ) * faculty( n - i ) );
  }
  else
  {
    return 0;
  }
}
 
double QgsDxfPaintEngine::power( double a, int b )
{
  if ( b == 0 )
    return 1;
 
  const double tmp = a;
  for ( int i = 2; i <= std::abs( b ); i++ )
    a *= tmp;
 
  if ( b > 0 )
    return a;
  else
    return 1.0 / a;
}
 
int QgsDxfPaintEngine::faculty( int n )
{
  if ( n < 0 ) //Is faculty also defined for negative integers?
    return 0;
 
  int i;
  int result = n;
 
  if ( n == 0 || n == 1 )
    return 1; //faculty of 0 is 1!
 
  for ( i = n - 1; i >= 2; i-- )
    result *= i;
 
  return result;
}
 
QColor QgsDxfPaintEngine::penColor() const
{
  if ( qgsDoubleNear( mOpacity, 1.0 ) )
  {
    return mPen.color();
  }
  QColor c = mPen.color();
  c.setAlphaF( c.alphaF() * mOpacity );
  return c;
}
 
QColor QgsDxfPaintEngine::brushColor() const
{
  QColor c;
  switch ( mBrush.style() )
  {
    // DXF doesn't support gradients — use the middle color as a fallback for
    // the brush color
    case Qt::LinearGradientPattern:
    case Qt::RadialGradientPattern:
    case Qt::ConicalGradientPattern:
    {
      const QGradientStops stops = mBrush.gradient() ? mBrush.gradient()->stops() : QGradientStops();
      if ( !stops.isEmpty() )
      {
        c = stops.at( stops.size() / 2 ).second;
      }
      else
      {
        c = mBrush.color();
      }
      break;
    }
    default:
      c = mBrush.color();
      break;
  }
 
  if ( !qgsDoubleNear( mOpacity, 1.0 ) )
  {
    c.setAlphaF( static_cast<float>( c.alphaF() * mOpacity ) );
  }
  return c;
}