9 #include "qwt_polar_spectrogram.h" 
   10 #include "qwt_polar.h" 
   11 #include "qwt_polar_plot.h" 
   12 #include "qwt_color_map.h" 
   13 #include "qwt_scale_map.h" 
   14 #include "qwt_raster_data.h" 
   16 #include "qwt_clipper.h" 
   19 #include <qpainterpath.h> 
   22 #include <qtconcurrentrun.h> 
   24 #if QT_VERSION < 0x050000 
   28 class QwtPolarSpectrogram::TileInfo
 
   36 class QwtPolarSpectrogram::PrivateData
 
   61     m_data = 
new PrivateData;
 
   93     if ( 
data != m_data->data )
 
  126         delete m_data->colorMap;
 
  139     return m_data->colorMap;
 
  152         m_data->paintAttributes |= attribute;
 
  154         m_data->paintAttributes &= ~attribute;
 
  164     return ( m_data->paintAttributes & attribute );
 
  179     const QPointF& pole, 
double,
 
  180     const QRectF& canvasRect )
 const 
  182     const QRectF plotRect = 
plot()->
plotRect( canvasRect.toRect() );
 
  183     QRect imageRect = canvasRect.toRect();
 
  187     painter->setClipRect( canvasRect );
 
  189     QPainterPath clipPathCanvas;
 
  190     clipPathCanvas.addEllipse( plotRect );
 
  191     painter->setClipPath( clipPathCanvas, Qt::IntersectClip );
 
  193     imageRect &= plotRect.toAlignedRect(); 
 
  196     if ( radialInterval.
isValid() )
 
  201         QRectF clipRect( 0, 0, 2 * radius, 2 * radius );
 
  202         clipRect.moveCenter( pole );
 
  204         imageRect &= clipRect.toRect(); 
 
  206         QPainterPath clipPathRadial;
 
  207         clipPathRadial.addEllipse( clipRect );
 
  208         painter->setClipPath( clipPathRadial, Qt::IntersectClip );
 
  211     const QImage image = 
renderImage( azimuthMap, radialMap, pole, imageRect );
 
  212     painter->drawImage( imageRect, image );
 
  237     const QPointF& pole, 
const QRect& rect )
 const 
  239     if ( m_data->data == NULL || m_data->colorMap == NULL )
 
  243                   ? QImage::Format_ARGB32 : QImage::Format_Indexed8 );
 
  245     const QwtInterval intensityRange = m_data->data->interval( Qt::ZAxis );
 
  246     if ( !intensityRange.
isValid() )
 
  250         image.setColorTable( m_data->colorMap->colorTable256() );
 
  258     m_data->data->initRaster( QRectF(), QSize() );
 
  261 #if !defined( QT_NO_QFUTURE ) 
  264     if ( numThreads <= 0 )
 
  265         numThreads = QThread::idealThreadCount();
 
  267     if ( numThreads <= 0 )
 
  270     const int numRows = rect.height() / numThreads;
 
  274     for ( uint i = 0; i < numThreads; i++ )
 
  276         QRect tile( rect.x(), rect.y() + i * numRows, rect.width(), numRows );
 
  277         if ( i == numThreads - 1 )
 
  278             tile.setHeight( rect.height() - i * numRows );
 
  281         tileInfo.imagePos = rect.topLeft();
 
  282         tileInfo.rect = tile;
 
  283         tileInfo.image = ℑ
 
  285         tileInfos += tileInfo;
 
  289     for ( 
int i = 0; i < tileInfos.size(); i++ )
 
  291         if ( i == tileInfos.size() - 1 )
 
  293             renderTileInfo( azimuthMap, radialMap, pole, &tileInfos[i] );
 
  297             futures += QtConcurrent::run(
 
  298 #
if QT_VERSION >= 0x060000
 
  299                 &QwtPolarSpectrogram::renderTileInfo, 
this,
 
  301                 this, &QwtPolarSpectrogram::renderTileInfo,
 
  303                 azimuthMap, radialMap, pole, &tileInfos[i] );
 
  307     for ( 
int i = 0; i < futures.size(); i++ )
 
  308         futures[i].waitForFinished();
 
  311     renderTile( azimuthMap, radialMap, pole, rect.topLeft(), rect, &image );
 
  314     m_data->data->discardRaster();
 
  319 void QwtPolarSpectrogram::renderTileInfo(
 
  321     const QPointF& pole, TileInfo* tileInfo )
 const 
  324         tileInfo->imagePos, tileInfo->rect, tileInfo->image );
 
  345     const QPointF& pole, 
const QPoint& imagePos,
 
  346     const QRect& tile, QImage* image )
 const 
  348     const QwtInterval intensityRange = m_data->data->interval( Qt::ZAxis );
 
  349     if ( !intensityRange.
isValid() )
 
  354     const int y0 = imagePos.y();
 
  355     const int y1 = tile.top();
 
  356     const int y2 = tile.bottom();
 
  358     const int x0 = imagePos.x();
 
  359     const int x1 = tile.left();
 
  360     const int x2 = tile.right();
 
  364         for ( 
int y = y1; y <= y2; y++ )
 
  366             const double dy = pole.y() - y;
 
  367             const double dy2 = qwtSqr( dy );
 
  369             QRgb* line = 
reinterpret_cast< QRgb* 
>( image->scanLine( y - y0 ) );
 
  372             for ( 
int x = x1; x <= x2; x++ )
 
  374                 const double dx = x - pole.x();
 
  376                 double a = doFastAtan ? qwtFastAtan2( dy, dx ) : qAtan2( dy, dx );
 
  381                 if ( a < azimuthMap.
p1() )
 
  384                 const double r = qSqrt( qwtSqr( dx ) + dy2 );
 
  389                 const double value = m_data->data->value( azimuth, radius );
 
  390                 if ( qIsNaN( value ) )
 
  396                     *line++ = m_data->colorMap->rgb( intensityRange, value );
 
  403         for ( 
int y = y1; y <= y2; y++ )
 
  405             const double dy = pole.y() - y;
 
  406             const double dy2 = qwtSqr( dy );
 
  408             unsigned char* line = image->scanLine( y - y0 );
 
  410             for ( 
int x = x1; x <= x2; x++ )
 
  412                 const double dx = x - pole.x();
 
  414                 double a = doFastAtan ? qwtFastAtan2( dy, dx ) : qAtan2( dy, dx );
 
  417                 if ( a < azimuthMap.
p1() )
 
  420                 const double r = qSqrt( qwtSqr( dx ) + dy2 );
 
  425                 const double value = m_data->data->value( azimuth, radius );
 
  427                 const uint index = m_data->colorMap->colorIndex( 256, intensityRange, value );
 
  428                 *line++ = 
static_cast< unsigned char >( index );
 
  445     if ( scaleId == QwtPolar::ScaleRadius )
 
  446         return m_data->data->interval( Qt::YAxis );
 
QwtColorMap is used to map values into colors.
@ RGB
The map is intended to map into RGB values.
A class representing an interval.
QwtLinearColorMap builds a color map from color stops.
Base class for items on a polar plot.
virtual QwtInterval boundingInterval(int scaleId) const
virtual void itemChanged()
@ Legend
The item is represented on the legend.
@ Rtti_PolarSpectrogram
For QwtPolarSpectrogram.
QwtPolarPlot * plot() const
uint renderThreadCount() const
void setItemAttribute(ItemAttribute, bool on=true)
void setZ(double z)
Set the z value.
QwtPolarSpectrogram()
Constructor.
const QwtColorMap * colorMap() const
const QwtRasterData * data() const
void setData(QwtRasterData *data)
virtual ~QwtPolarSpectrogram()
Destructor.
virtual int rtti() const override
void setColorMap(QwtColorMap *)
virtual QImage renderImage(const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, const QPointF &pole, const QRect &rect) const
Render an image from the data and color map.
void setPaintAttribute(PaintAttribute, bool on=true)
bool testPaintAttribute(PaintAttribute) const
QFlags< PaintAttribute > PaintAttributes
virtual void renderTile(const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, const QPointF &pole, const QPoint &imagePos, const QRect &tile, QImage *image) const
Render a sub-rectangle of an image.
virtual QwtInterval boundingInterval(int scaleId) const override
virtual void draw(QPainter *painter, const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap, const QPointF &pole, double radius, const QRectF &canvasRect) const override
QwtRasterData defines an interface to any type of raster data.
double transform(double s) const
double invTransform(double p) const
A class representing a text.