Changeset 11158 in ntrip for trunk/BNC/qwt/qwt_plot_spectrogram.cpp

Timestamp:

Nov 3, 2026, 10:53:35 AM (8 days ago)

Author:

stuerze

Message:

deprecated functions exchanged libs updated

File:

• trunk/BNC/qwt/qwt_plot_spectrogram.cpp (modified) (35 diffs)

trunk/BNC/qwt/qwt_plot_spectrogram.cpp

@@ -1 @@
-/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
+/******************************************************************************
  * Qwt Widget Library
  * Copyright (C) 1997   Josef Wilgen
@@ -13 +13 @@
 #include "qwt_scale_map.h"
 #include "qwt_color_map.h"
+#include "qwt_math.h"
+
 #include <qimage.h>
 #include <qpen.h>
 #include <qpainter.h>
-#include <qmath.h>
-#include <qalgorithms.h>
-#if QT_VERSION >= 0x040400
 #include <qthread.h>
 #include <qfuture.h>
 #include <qtconcurrentrun.h>
+
+#define DEBUG_RENDER 0
+
+#if DEBUG_RENDER
+#include <qelapsedtimer.h>
 #endif
 
-#define DEBUG_RENDER 0
-
-#if DEBUG_RENDER
-#include <QElapsedTimer>
-#endif
+#include <algorithm>
+
+static inline bool qwtIsNaN( double d )
+{
+    // qt_is_nan is private header and qIsNaN is not inlined
+    // so we need these code here too
+
+    const uchar* ch = (const uchar*)&d;
+    if ( QSysInfo::ByteOrder == QSysInfo::BigEndian )
+    {
+        return ( ch[0] & 0x7f ) == 0x7f && ch[1] > 0xf0;
+    }
+    else
+    {
+        return ( ch[7] & 0x7f ) == 0x7f && ch[6] > 0xf0;
+    }
+}
 
 class QwtPlotSpectrogram::PrivateData
 {
-public:
-    PrivateData():
-        data( NULL )
+  public:
+    PrivateData()
+        : data( NULL )
+        , colorTableSize( 0 )
     {
         colorMap = new QwtLinearColorMap();
@@ -44 +61 @@
 #endif
     }
+
     ~PrivateData()
     {
@@ -50 +68 @@
     }
 
-    QwtRasterData *data;
-    QwtColorMap *colorMap;
+    void updateColorTable()
+    {
+        if ( colorMap->format() == QwtColorMap::Indexed )
+        {
+            colorTable = colorMap->colorTable256();
+        }
+        else
+        {
+            if ( colorTableSize == 0 )
+                colorTable.clear();
+            else
+                colorTable = colorMap->colorTable( colorTableSize );
+        }
+    }
+
+    QwtRasterData* data;
+    QwtColorMap* colorMap;
     DisplayModes displayMode;
 
-    QList<double> contourLevels;
+    QList< double > contourLevels;
     QPen defaultContourPen;
     QwtRasterData::ConrecFlags conrecFlags;
+
+    int colorTableSize;
+    QVector< QRgb > colorTable;
 };
 
@@ -69 +105 @@
 
    \sa QwtPlotItem::setItemAttribute(), QwtPlotItem::setZ()
-*/
-QwtPlotSpectrogram::QwtPlotSpectrogram( const QString &title ):
-    QwtPlotRasterItem( title )
-{
-    d_data = new PrivateData();
+ */
+QwtPlotSpectrogram::QwtPlotSpectrogram( const QString& title )
+    : QwtPlotRasterItem( title )
+{
+    m_data = new PrivateData();
 
     setItemAttribute( QwtPlotItem::AutoScale, true );
@@ -84 +120 @@
 QwtPlotSpectrogram::~QwtPlotSpectrogram()
 {
-    delete d_data;
+    delete m_data;
 }
 
@@ -102 +138 @@
 
    \sa DisplayMode, displayMode()
-*/
+ */
 void QwtPlotSpectrogram::setDisplayMode( DisplayMode mode, bool on )
 {
-    if ( on != bool( mode & d_data->displayMode ) )
+    if ( on != bool( mode & m_data->displayMode ) )
     {
         if ( on )
-            d_data->displayMode |= mode;
+            m_data->displayMode |= mode;
         else
-            d_data->displayMode &= ~mode;
+            m_data->displayMode &= ~mode;
     }
 
@@ -122 +158 @@
    \param mode Display mode
    \return true if mode is enabled
-*/
+ */
 bool QwtPlotSpectrogram::testDisplayMode( DisplayMode mode ) const
 {
-    return ( d_data->displayMode & mode );
-}
-
-/*!
-  Change the color map
-
-  Often it is useful to display the mapping between intensities and
-  colors as an additional plot axis, showing a color bar.
-
-  \param colorMap Color Map
-
-  \sa colorMap(), QwtScaleWidget::setColorBarEnabled(),
+    return ( m_data->displayMode & mode );
+}
+
+/*!
+   Change the color map
+
+   Often it is useful to display the mapping between intensities and
+   colors as an additional plot axis, showing a color bar.
+
+   \param colorMap Color Map
+
+   \sa colorMap(), QwtScaleWidget::setColorBarEnabled(),
       QwtScaleWidget::setColorMap()
-*/
-void QwtPlotSpectrogram::setColorMap( QwtColorMap *colorMap )
-{
-    if ( d_data->colorMap != colorMap )
-    {
-        delete d_data->colorMap;
-        d_data->colorMap = colorMap;
-    }
+ */
+void QwtPlotSpectrogram::setColorMap( QwtColorMap* colorMap )
+{
+    if ( colorMap == NULL )
+        return;
+
+    if ( colorMap != m_data->colorMap )
+    {
+        delete m_data->colorMap;
+        m_data->colorMap = colorMap;
+    }
+
+    m_data->updateColorTable();
 
     invalidateCache();
@@ -156 +197 @@
    \return Color Map used for mapping the intensity values to colors
    \sa setColorMap()
-*/
-const QwtColorMap *QwtPlotSpectrogram::colorMap() const
-{
-    return d_data->colorMap;
-}
-
-/*!
-  Build and assign the default pen for the contour lines
-
-  In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
-  non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
-  to hide this incompatibility.
-
-  \param color Pen color
-  \param width Pen width
-  \param style Pen style
-
-  \sa pen(), brush()
+ */
+const QwtColorMap* QwtPlotSpectrogram::colorMap() const
+{
+    return m_data->colorMap;
+}
+
+/*!
+    Limit the number of colors being used by the color map
+
+    When using a color table the mapping from the value into a color
+    is usually faster as it can be done by simple lookups into a
+    precalculated color table.
+
+    Setting a table size > 0 enables using a color table, while setting
+    the size to 0 disables it.
+
+    The default size = 0, and no color table is used.
+
+    \param numColors Number of colors. 0 means not using a color table
+    \note The colorTableSize has no effect when using a color table
+          of QwtColorMap::Indexed, where the size is always 256.
+
+
+    \sa QwtColorMap::colorTable(), colorTableSize()
+ */
+void QwtPlotSpectrogram::setColorTableSize( int numColors )
+{
+    numColors = qMax( numColors, 0 );
+    if ( numColors != m_data->colorTableSize )
+    {
+        m_data->colorTableSize = numColors;
+        m_data->updateColorTable();
+        invalidateCache();
+    }
+}
+/*!
+    \return Size of the color table, 0 means not using a color table
+    \sa QwtColorMap::colorTable(), setColorTableSize()
+ */
+int QwtPlotSpectrogram::colorTableSize() const
+{
+    return m_data->colorTableSize;
+}
+
+/*!
+   Build and assign the default pen for the contour lines
+
+   In Qt5 the default pen width is 1.0 ( 0.0 in Qt4 ) what makes it
+   non cosmetic ( see QPen::isCosmetic() ). This method has been introduced
+   to hide this incompatibility.
+
+   \param color Pen color
+   \param width Pen width
+   \param style Pen style
+
+   \sa pen(), brush()
  */
 void QwtPlotSpectrogram::setDefaultContourPen(
-    const QColor &color, qreal width, Qt::PenStyle style )
+    const QColor& color, qreal width, Qt::PenStyle style )
 {
     setDefaultContourPen( QPen( color, width, style ) );
@@ -190 +269 @@
 
    \sa defaultContourPen(), contourPen()
-*/
-void QwtPlotSpectrogram::setDefaultContourPen( const QPen &pen )
-{
-    if ( pen != d_data->defaultContourPen )
-    {
-        d_data->defaultContourPen = pen;
+ */
+void QwtPlotSpectrogram::setDefaultContourPen( const QPen& pen )
+{
+    if ( pen != m_data->defaultContourPen )
+    {
+        m_data->defaultContourPen = pen;
 
         legendChanged();
@@ -205 +284 @@
    \return Default contour pen
    \sa setDefaultContourPen()
-*/
+ */
 QPen QwtPlotSpectrogram::defaultContourPen() const
 {
-    return d_data->defaultContourPen;
+    return m_data->defaultContourPen;
 }
 
@@ -221 +300 @@
 
    \sa setDefaultContourPen(), setColorMap(), setContourLevels()
-*/
+ */
 QPen QwtPlotSpectrogram::contourPen( double level ) const
 {
-    if ( d_data->data == NULL || d_data->colorMap == NULL )
+    if ( m_data->data == NULL || m_data->colorMap == NULL )
         return QPen();
 
-    const QwtInterval intensityRange = d_data->data->interval(Qt::ZAxis);
-    const QColor c( d_data->colorMap->rgb( intensityRange, level ) );
+    const QwtInterval intensityRange = m_data->data->interval(Qt::ZAxis);
+    const QColor c( m_data->colorMap->rgb( intensityRange, level ) );
 
     return QPen( c );
@@ -242 +321 @@
    \sa testConrecFlag(), renderContourLines(),
        QwtRasterData::contourLines()
-*/
+ */
 void QwtPlotSpectrogram::setConrecFlag(
     QwtRasterData::ConrecFlag flag, bool on )
 {
-    if ( bool( d_data->conrecFlags & flag ) == on )
+    if ( bool( m_data->conrecFlags & flag ) == on )
         return;
 
     if ( on )
-        d_data->conrecFlags |= flag;
+        m_data->conrecFlags |= flag;
     else
-        d_data->conrecFlags &= ~flag;
+        m_data->conrecFlags &= ~flag;
 
     itemChanged();
@@ -268 +347 @@
    \sa setConrecClag(), renderContourLines(),
        QwtRasterData::contourLines()
-*/
+ */
 bool QwtPlotSpectrogram::testConrecFlag(
     QwtRasterData::ConrecFlag flag ) const
 {
-    return d_data->conrecFlags & flag;
+    return m_data->conrecFlags & flag;
 }
 
@@ -283 +362 @@
 
    \note contourLevels returns the same levels but sorted.
-*/
-void QwtPlotSpectrogram::setContourLevels( const QList<double> &levels )
-{
-    d_data->contourLevels = levels;
-    qSort( d_data->contourLevels );
+ */
+void QwtPlotSpectrogram::setContourLevels( const QList< double >& levels )
+{
+    m_data->contourLevels = levels;
+    std::sort( m_data->contourLevels.begin(), m_data->contourLevels.end() );
 
     legendChanged();
@@ -300 +379 @@
    \sa contourLevels(), renderContourLines(),
        QwtRasterData::contourLines()
-*/
-QList<double> QwtPlotSpectrogram::contourLevels() const
-{
-    return d_data->contourLevels;
-}
-
-/*!
-  Set the data to be displayed
-
-  \param data Spectrogram Data
-  \sa data()
-*/
-void QwtPlotSpectrogram::setData( QwtRasterData *data )
-{
-    if ( data != d_data->data )
-    {
-        delete d_data->data;
-        d_data->data = data;
+ */
+QList< double > QwtPlotSpectrogram::contourLevels() const
+{
+    return m_data->contourLevels;
+}
+
+/*!
+   Set the data to be displayed
+
+   \param data Spectrogram Data
+   \sa data()
+ */
+void QwtPlotSpectrogram::setData( QwtRasterData* data )
+{
+    if ( data != m_data->data )
+    {
+        delete m_data->data;
+        m_data->data = data;
 
         invalidateCache();
@@ -325 +404 @@
 
 /*!
-  \return Spectrogram data
-  \sa setData()
-*/
-const QwtRasterData *QwtPlotSpectrogram::data() const
-{
-    return d_data->data;
-}
-
-/*!
-  \return Spectrogram data
-  \sa setData()
-*/
-QwtRasterData *QwtPlotSpectrogram::data()
-{
-    return d_data->data;
+   \return Spectrogram data
+   \sa setData()
+ */
+const QwtRasterData* QwtPlotSpectrogram::data() const
+{
+    return m_data->data;
+}
+
+/*!
+   \return Spectrogram data
+   \sa setData()
+ */
+QwtRasterData* QwtPlotSpectrogram::data()
+{
+    return m_data->data;
 }
 
@@ -350 +429 @@
    \param axis X, Y, or Z axis
    \sa QwtRasterData::interval()
-*/
+ */
 QwtInterval QwtPlotSpectrogram::interval(Qt::Axis axis) const
 {
-    if ( d_data->data == NULL )
+    if ( m_data->data == NULL )
         return QwtInterval();
 
-    return d_data->data->interval( axis );
+    return m_data->data->interval( axis );
 }
 
@@ -374 +453 @@
    \sa QwtPlotRasterItem::pixelHint(), QwtRasterData::pixelHint(),
        render(), renderImage()
-*/
-QRectF QwtPlotSpectrogram::pixelHint( const QRectF &area ) const
-{
-    if ( d_data->data == NULL )
+ */
+QRectF QwtPlotSpectrogram::pixelHint( const QRectF& area ) const
+{
+    if ( m_data->data == NULL )
         return QRectF();
 
-    return d_data->data->pixelHint( area );
+    return m_data->data->pixelHint( area );
 }
 
@@ -388 +467 @@
    For each pixel of area the value is mapped into a color.
 
-  \param xMap X-Scale Map
-  \param yMap Y-Scale Map
-  \param area Requested area for the image in scale coordinates
-  \param imageSize Size of the requested image
+   \param xMap X-Scale Map
+   \param yMap Y-Scale Map
+   \param area Requested area for the image in scale coordinates
+   \param imageSize Size of the requested image
 
    \return A QImage::Format_Indexed8 or QImage::Format_ARGB32 depending
@@ -398 +477 @@
    \sa QwtRasterData::value(), QwtColorMap::rgb(),
        QwtColorMap::colorIndex()
-*/
+ */
 QImage QwtPlotSpectrogram::renderImage(
-    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
-    const QRectF &area, const QSize &imageSize ) const
-{
-    if ( imageSize.isEmpty() || d_data->data == NULL
-        || d_data->colorMap == NULL )
+    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
+    const QRectF& area, const QSize& imageSize ) const
+{
+    if ( imageSize.isEmpty() || m_data->data == NULL
+        || m_data->colorMap == NULL )
     {
         return QImage();
     }
 
-    const QwtInterval intensityRange = d_data->data->interval( Qt::ZAxis );
+    const QwtInterval intensityRange = m_data->data->interval( Qt::ZAxis );
     if ( !intensityRange.isValid() )
         return QImage();
 
-    QImage::Format format = ( d_data->colorMap->format() == QwtColorMap::RGB )
+    const QImage::Format format = ( m_data->colorMap->format() == QwtColorMap::RGB )
         ? QImage::Format_ARGB32 : QImage::Format_Indexed8;
 
     QImage image( imageSize, format );
 
-    if ( d_data->colorMap->format() == QwtColorMap::Indexed )
-        image.setColorTable( d_data->colorMap->colorTable( intensityRange ) );
-
-    d_data->data->initRaster( area, image.size() );
+    if ( m_data->colorMap->format() == QwtColorMap::Indexed )
+        image.setColorTable( m_data->colorMap->colorTable256() );
+
+    m_data->data->initRaster( area, image.size() );
 
 #if DEBUG_RENDER
@@ -428 +507 @@
 #endif
 
-#if QT_VERSION >= 0x040400 && !defined(QT_NO_QFUTURE)
+#if !defined( QT_NO_QFUTURE )
     uint numThreads = renderThreadCount();
 
@@ -439 +518 @@
     const int numRows = imageSize.height() / numThreads;
 
-    QList< QFuture<void> > futures;
+    QVector< QFuture< void > > futures;
+    futures.reserve( numThreads - 1 );
+
     for ( uint i = 0; i < numThreads; i++ )
     {
@@ -451 +532 @@
         {
             futures += QtConcurrent::run(
+#if QT_VERSION >= 0x060000
+                &QwtPlotSpectrogram::renderTile, this,
+#else
                 this, &QwtPlotSpectrogram::renderTile,
+#endif
                 xMap, yMap, tile, &image );
         }
     }
+
     for ( int i = 0; i < futures.size(); i++ )
         futures[i].waitForFinished();
 
-#else // QT_VERSION < 0x040400
+#else
     const QRect tile( 0, 0, image.width(), image.height() );
     renderTile( xMap, yMap, tile, &image );
@@ -468 +554 @@
 #endif
 
-    d_data->data->discardRaster();
+    m_data->data->discardRaster();
 
     return image;
@@ -483 +569 @@
     \param tile Geometry of the tile in image coordinates
     \param image Image to be rendered
-*/
+ */
 void QwtPlotSpectrogram::renderTile(
-    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
-    const QRect &tile, QImage *image ) const
-{
-    const QwtInterval range = d_data->data->interval( Qt::ZAxis );
-    if ( !range.isValid() )
+    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
+    const QRect& tile, QImage* image ) const
+{
+    const QwtInterval range = m_data->data->interval( Qt::ZAxis );
+    if ( range.width() <= 0.0 )
         return;
 
-    if ( d_data->colorMap->format() == QwtColorMap::RGB )
-    {
+    const bool hasGaps = !m_data->data->testAttribute( QwtRasterData::WithoutGaps );
+
+    if ( m_data->colorMap->format() == QwtColorMap::RGB )
+    {
+        const int numColors = m_data->colorTable.size();
+        const QRgb* rgbTable = m_data->colorTable.constData();
+        const QwtColorMap* colorMap = m_data->colorMap;
+
         for ( int y = tile.top(); y <= tile.bottom(); y++ )
         {
             const double ty = yMap.invTransform( y );
 
-            QRgb *line = reinterpret_cast<QRgb *>( image->scanLine( y ) );
+            QRgb* line = reinterpret_cast< QRgb* >( image->scanLine( y ) );
             line += tile.left();
 
@@ -505 +597 @@
                 const double tx = xMap.invTransform( x );
 
-                *line++ = d_data->colorMap->rgb( range,
-                    d_data->data->value( tx, ty ) );
+                const double value = m_data->data->value( tx, ty );
+
+                if ( hasGaps && qwtIsNaN( value ) )
+                {
+                    *line++ = 0u;
+                }
+                else if ( numColors == 0 )
+                {
+                    *line++ = colorMap->rgb( range, value );
+                }
+                else
+                {
+                    const uint index = colorMap->colorIndex( numColors, range, value );
+                    *line++ = rgbTable[index];
+                }
             }
         }
     }
-    else if ( d_data->colorMap->format() == QwtColorMap::Indexed )
+    else if ( m_data->colorMap->format() == QwtColorMap::Indexed )
     {
         for ( int y = tile.top(); y <= tile.bottom(); y++ )
@@ -516 +621 @@
             const double ty = yMap.invTransform( y );
 
-            unsigned char *line = image->scanLine( y );
+            unsigned char* line = image->scanLine( y );
             line += tile.left();
 
@@ -523 +628 @@
                 const double tx = xMap.invTransform( x );
 
-                *line++ = d_data->colorMap->colorIndex( range,
-                    d_data->data->value( tx, ty ) );
+                const double value = m_data->data->value( tx, ty );
+
+                if ( hasGaps && qwtIsNaN( value ) )
+                {
+                    *line++ = 0;
+                }
+                else
+                {
+                    const uint index = m_data->colorMap->colorIndex( 256, range, value );
+                    *line++ = static_cast< unsigned char >( index );
+                }
             }
         }
@@ -546 +660 @@
 
    \sa drawContourLines(), QwtRasterData::contourLines()
-*/
+ */
 QSize QwtPlotSpectrogram::contourRasterSize(
-    const QRectF &area, const QRect &rect ) const
+    const QRectF& area, const QRect& rect ) const
 {
     QSize raster = rect.size() / 2;
@@ -555 +669 @@
     if ( !pixelRect.isEmpty() )
     {
-        const QSize res( qCeil( rect.width() / pixelRect.width() ),
-            qCeil( rect.height() / pixelRect.height() ) );
+        const QSize res( qwtCeil( rect.width() / pixelRect.width() ),
+            qwtCeil( rect.height() / pixelRect.height() ) );
         raster = raster.boundedTo( res );
     }
@@ -572 +686 @@
    \sa contourLevels(), setConrecFlag(),
        QwtRasterData::contourLines()
-*/
+ */
 QwtRasterData::ContourLines QwtPlotSpectrogram::renderContourLines(
-    const QRectF &rect, const QSize &raster ) const
-{
-    if ( d_data->data == NULL )
+    const QRectF& rect, const QSize& raster ) const
+{
+    if ( m_data->data == NULL )
         return QwtRasterData::ContourLines();
 
-    return d_data->data->contourLines( rect, raster,
-        d_data->contourLevels, d_data->conrecFlags );
+    return m_data->data->contourLines( rect, raster,
+        m_data->contourLevels, m_data->conrecFlags );
 }
 
@@ -592 +706 @@
 
    \sa renderContourLines(), defaultContourPen(), contourPen()
-*/
-void QwtPlotSpectrogram::drawContourLines( QPainter *painter,
-        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
-        const QwtRasterData::ContourLines &contourLines ) const
-{
-    if ( d_data->data == NULL )
+ */
+void QwtPlotSpectrogram::drawContourLines( QPainter* painter,
+    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
+    const QwtRasterData::ContourLines& contourLines ) const
+{
+    if ( m_data->data == NULL )
         return;
 
-    const int numLevels = d_data->contourLevels.size();
+    const int numLevels = m_data->contourLevels.size();
     for ( int l = 0; l < numLevels; l++ )
     {
-        const double level = d_data->contourLevels[l];
+        const double level = m_data->contourLevels[l];
 
         QPen pen = defaultContourPen();
@@ -614 +728 @@
         painter->setPen( pen );
 
-        const QPolygonF &lines = contourLines[level];
+        const QPolygonF& lines = contourLines[level];
         for ( int i = 0; i < lines.size(); i += 2 )
         {
             const QPointF p1( xMap.transform( lines[i].x() ),
                 yMap.transform( lines[i].y() ) );
-            const QPointF p2( xMap.transform( lines[i+1].x() ),
-                yMap.transform( lines[i+1].y() ) );
+            const QPointF p2( xMap.transform( lines[i + 1].x() ),
+                yMap.transform( lines[i + 1].y() ) );
 
             QwtPainter::drawLine( painter, p1, p2 );
@@ -628 +742 @@
 
 /*!
-  \brief Draw the spectrogram
-
-  \param painter Painter
-  \param xMap Maps x-values into pixel coordinates.
-  \param yMap Maps y-values into pixel coordinates.
-  \param canvasRect Contents rectangle of the canvas in painter coordinates
-
-  \sa setDisplayMode(), renderImage(),
+   \brief Draw the spectrogram
+
+   \param painter Painter
+   \param xMap Maps x-values into pixel coordinates.
+   \param yMap Maps y-values into pixel coordinates.
+   \param canvasRect Contents rectangle of the canvas in painter coordinates
+
+   \sa setDisplayMode(), renderImage(),
       QwtPlotRasterItem::draw(), drawContourLines()
-*/
-void QwtPlotSpectrogram::draw( QPainter *painter,
-    const QwtScaleMap &xMap, const QwtScaleMap &yMap,
-    const QRectF &canvasRect ) const
-{
-    if ( d_data->displayMode & ImageMode )
+ */
+void QwtPlotSpectrogram::draw( QPainter* painter,
+    const QwtScaleMap& xMap, const QwtScaleMap& yMap,
+    const QRectF& canvasRect ) const
+{
+    if ( m_data->displayMode & ImageMode )
         QwtPlotRasterItem::draw( painter, xMap, yMap, canvasRect );
 
-    if ( d_data->displayMode & ContourMode )
+    if ( m_data->displayMode & ContourMode )
     {
         // Add some pixels at the borders