kalzium/src/spectrumwidget.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005, 2006 by Carsten Niehaus                                 *
   3  *   cniehaus@kde.org                                                      *
   4  *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program; if not, write to the                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.             *
  20  ***************************************************************************/
  21 #include "spectrumwidget.h"
  22 #include "spectrum.h"
  23 #include "kalziumutils.h"
  24
  25 #include <element.h>
  26
  27 #include <kdebug.h>
  28 #include <klocale.h>
  29 #include <math.h>
  30
  31 #include <QCursor>
  32 #include <QKeyEvent>
  33 #include <QSizePolicy>
  34 #include <QPainter>
  35 #include <QPixmap>
  36
  37 #include <qglobal.h>
  38 #if defined(Q_OS_SOLARIS)
  39 #include <ieeefp.h>
  40 #endif
  41
  42 SpectrumWidget::SpectrumWidget( QWidget *parent )
  43   : QWidget( parent )
  44 {
  45         startValue = 0;
  46         endValue = 0;
  47
  48         m_LMBPointCurrent.setX( -1 );
  49         m_LMBPointPress.setX( -1 );
  50
  51         m_realHeight = 200;
  52
  53         Gamma = 0.8;
  54         IntensityMax = 255;
  55
  56         setType( EmissionSpectrum );
  57
  58         setMinimumSize( 400, 230 );
  59         setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
  60         setAttribute( Qt::WA_OpaquePaintEvent, true );
  61 }
  62
  63 void SpectrumWidget::paintEvent( QPaintEvent * /*e*/ )
  64 {
  65         if ( !m_spectrum )
  66                  return;
  67
  68         m_pixmap = QPixmap( width(), height() );
  69         m_pixmap.fill( this, width(), height() );
  70
  71         QPainter p;
  72         p.begin( &m_pixmap );
  73         p.fillRect( 0, 0, width(), m_realHeight, Qt::black );
  74
  75         paintBands( &p );
  76
  77         drawTickmarks( &p );
  78
  79         if ( m_LMBPointPress.x() != -1 && m_LMBPointCurrent.x() != -1 )
  80                 drawZoomLine( &p );
  81
  82         p.end();
  83
  84         QPainter p2(this);
  85         p2.drawPixmap(0, 0, m_pixmap);
  86 }
  87
  88 void SpectrumWidget::drawZoomLine( QPainter* p )
  89 {
  90         p->setPen( Qt::white );
  91         p->drawLine( m_LMBPointPress.x(), m_LMBPointPress.y(), m_LMBPointCurrent.x(), m_LMBPointPress.y() );
  92         p->drawLine( m_LMBPointCurrent.x(), m_LMBPointPress.y()+10, m_LMBPointCurrent.x(), m_LMBPointPress.y()-10 );
  93         p->drawLine( m_LMBPointPress.x(), m_LMBPointPress.y()+10, m_LMBPointPress.x(), m_LMBPointPress.y()-10 );
  94 }
  95
  96 void SpectrumWidget::paintBands( QPainter* p )
  97 {
  98     if ( m_type == AbsorptionSpectrum )
  99     {
 100         for ( double va = startValue; va <= endValue ; va += 0.1 )
 101         {
 102             int x = xPos( va );
 103             p->setPen( linecolor( va ) );
 104             p->drawLine( x,0,x, m_realHeight );
 105         }
 106
 107         p->setPen( Qt::black );
 108     }
 109
 110     int i = 0;
 111     int x = 0;
 112     int temp = 0;
 113
 114     foreach ( Spectrum::peak * peak , m_spectrum->peaklist() )
 115     {
 116         if ( peak->wavelength < startValue || peak->wavelength > endValue )
 117             continue;
 118
 119         x = xPos( peak->wavelength );
 120
 121         temp = 0;
 122
 123         switch ( m_type )
 124         {
 125             case EmissionSpectrum:
 126                 p->setPen( linecolor( peak->wavelength ) );
 127                 p->drawLine( x,0,x, m_realHeight-1 );
 128
 129                 p->setPen( Qt::black );
 130                 p->drawLine( x,m_realHeight,x, m_realHeight );
 131                 break;
 132
 133             case AbsorptionSpectrum:
 134                 p->setPen( Qt::black );
 135                 p->drawLine( x,0,x, m_realHeight-1 );
 136                 break;
 137         }
 138
 139         i++;
 140     }
 141 }
 142
 143 QColor SpectrumWidget::linecolor( double spectrum )
 144 {
 145         int r,g,b;
 146         wavelengthToRGB( spectrum, r,g,b );
 147
 148         QColor c( r,g,b );
 149         return c;
 150 }
 151
 152
 153 void SpectrumWidget::wavelengthToRGB( double wavelength, int& r, int& g, int& b )
 154 {
 155     double blue = 0.0, green = 0.0, red = 0.0, factor = 0.0;
 156
 157     int wavelength_ = ( int ) floor( wavelength );
 158     if ( wavelength_ < 380 || wavelength_ > 780 )
 159     {
 160         //make everything white
 161         r = g = b = 255;
 162         return;
 163     }
 164     else if ( wavelength_ > 380 && wavelength_ < 439 )
 165     {
 166         red = -( wavelength-440 ) / ( 440-380 );
 167         green = 0.0;
 168         blue = 1.0;
 169     }
 170     else if ( wavelength_ > 440 && wavelength_ < 489 )
 171     {
 172         red = 0.0;
 173         green = ( wavelength-440 ) / ( 490-440 );
 174         blue = 1.0;
 175     }
 176     else if ( wavelength_ > 490 && wavelength_ < 509 )
 177     {
 178         red = 0.0;
 179         green = 1.0;
 180         blue = -( wavelength-510 ) / ( 510-490 );
 181     }
 182     else if ( wavelength_ > 510 && wavelength_ < 579 )
 183     {
 184         red = ( wavelength-510 ) / ( 580-510 );
 185         green = 1.0;
 186         blue = 0.0;
 187     }
 188     else if ( wavelength_ > 580 && wavelength_ < 644 )
 189     {
 190         red = 1.0;
 191         green = -( wavelength-645 ) / ( 645-580 );
 192         blue = 0.0;
 193     }
 194     else if ( wavelength_ > 645 && wavelength_ < 780 )
 195     {
 196         red = 1.0;
 197         green = 0.0;
 198         blue = 0.0;
 199     }
 200
 201     if ( wavelength_ > 380 && wavelength_ < 419 )
 202         factor = 0.3 + 0.7*( wavelength - 380 ) / ( 420 - 380 );
 203     else if ( wavelength_ > 420 && wavelength_ < 700 )
 204         factor = 1.0;
 205     else if ( wavelength_ > 701 && wavelength_ < 780 )
 206         factor = 0.3 + 0.7*( 780 - wavelength ) / ( 780 - 700 );
 207     else
 208         factor = 0.0;
 209
 210     r = Adjust( red, factor );
 211     g = Adjust( green, factor );
 212     b = Adjust( blue, factor );
 213 }
 214
 215 int SpectrumWidget::Adjust( double color, double factor )
 216 {
 217         if ( color == 0.0 )
 218                 return 0;
 219         else
 220                 return qRound( IntensityMax * pow( color*factor, Gamma ));
 221 }
 222
 223 void SpectrumWidget::drawTickmarks( QPainter* p )
 224 {
 225     //the size of the text on the tickmarks
 226     const int space = 20;
 227
 228     //the distance between the tickmarks in pixel
 229     const int d = 10;
 230
 231     //the total number of tickmarks to draw (small and long)
 232     const int numberOfTickmarks = ( int )floor( width()/d );
 233
 234     double pos = 0.0;
 235
 236     for ( int i = 0; i < numberOfTickmarks; i++  )
 237     {
 238         if( i%5 == 0 )
 239         {//long tickmarks plus text
 240             p->drawLine( i*d, m_realHeight, i*d, m_realHeight+10 );
 241             if ( i%10 == 0 &&
 242                     i*d > space &&
 243                     i*d < width()-space )
 244             {
 245                 pos = ( double ) ( i*d )/width();
 246                 p->fillRect( i*d-space, m_realHeight+12, 2*space, 15, Qt::white );
 247                 p->drawText( i*d-space, m_realHeight+12, 2*space, 15, Qt::AlignCenter, QString::number( KalziumUtils::strippedValue( Wavelength( pos ) ) ) );
 248             }
 249         }
 250         else {//small tickmarks
 251             p->drawLine( i*d, m_realHeight, i*d, m_realHeight+5 );
 252         }
 253     }
 254 }
 255
 256 void SpectrumWidget::keyPressEvent( QKeyEvent *e )
 257 {
 258     switch ( e->key() )
 259     {
 260         case Qt::Key_Plus:
 261             slotZoomIn();
 262             break;
 263         case Qt::Key_Minus:
 264             slotZoomOut();
 265             break;
 266     }
 267 }
 268
 269 void SpectrumWidget::slotZoomOut()
 270 {
 271     kDebug() << "SpectrumWidget::slotZoomOut() "<< startValue << ":: "<< endValue;
 272
 273     double diff = endValue - startValue;
 274
 275     double offset = diff * 0.05;
 276
 277     endValue = endValue + offset;
 278     startValue = startValue - offset;
 279
 280     //check for invalid values
 281     if ( startValue < 0.0 )
 282         startValue = 0.0;
 283
 284     if ( endValue > 800.0 )
 285         endValue = 800.0;
 286
 287     setBorders( startValue, endValue );
 288 }
 289
 290 void SpectrumWidget::setBorders( double left, double right )
 291 {
 292     kDebug() << "setBorders    " << left << ".."<< right;
 293
 294     startValue = left;
 295     endValue = right;
 296
 297     //round the startValue down and the endValue up
 298     emit bordersChanged( int(startValue+0.5), int(endValue+0.5) );
 299
 300     update();
 301 }
 302
 303 void SpectrumWidget::slotZoomIn()
 304 {
 305     kDebug() << "SpectrumWidget::slotZoomIn() "<< startValue << ":: "<< endValue;
 306
 307     double diff = endValue - startValue;
 308
 309     double offset = diff * 0.05;
 310
 311     endValue = endValue - offset;
 312     startValue = startValue + offset;
 313
 314     setBorders( startValue, endValue );
 315 }
 316
 317 void SpectrumWidget::mouseMoveEvent( QMouseEvent *e )
 318 {
 319     m_LMBPointCurrent = e->pos();
 320     update();
 321 }
 322
 323 void SpectrumWidget::mousePressEvent(  QMouseEvent *e )
 324 {
 325     if (  e->button() == Qt::LeftButton )
 326         m_LMBPointPress = e->pos();
 327     if (  e->button() == Qt::RightButton )
 328         slotZoomOut();
 329
 330     findPeakFromMouseposition( Wavelength( ( double )e->pos().x()/width() ) );
 331 }
 332
 333 void SpectrumWidget::findPeakFromMouseposition( double wavelength )
 334 {
 335     kDebug() << "SpectrumWidget::findPeakFromMouseposition()";
 336     Spectrum::peak *peak = NULL;
 337
 338     //find the difference in percent (1.0 is 100%, 0.1 is 10%)
 339     double dif = 0.0;
 340
 341     bool foundWavelength = false;
 342
 343     //find the highest intensity
 344     foreach( Spectrum::peak *currentPeak, m_spectrum->peaklist() )
 345     {
 346         double thisdif = currentPeak->wavelength / wavelength;
 347
 348         if ( thisdif < 0.9 || thisdif > 1.1 )
 349             continue;
 350
 351         if ( thisdif > 1.0 ){//convert for example 1.3 to 0.7
 352             thisdif = thisdif-1;
 353             thisdif = 1-thisdif;
 354         }
 355
 356         if ( thisdif > dif )
 357         {
 358             dif = thisdif;
 359             peak = currentPeak;
 360             foundWavelength = true;
 361         }
 362     }
 363
 364     if ( foundWavelength )
 365         emit peakSelected(peak);
 366 }
 367
 368 void SpectrumWidget::mouseReleaseEvent(  QMouseEvent *e )
 369 {
 370         if (  e->button() == Qt::LeftButton )
 371         {
 372                 int left = (int)Wavelength( ( double )m_LMBPointPress.x()/width() );
 373                 int right = (int)Wavelength( ( double )e->pos().x()/width() );
 374
 375                 if ( left == right )
 376                         return;
 377
 378                 if ( left > right )
 379                         setBorders( right, left );
 380                 else
 381                         setBorders( left, right );
 382         }
 383
 384         m_LMBPointPress.setX( -1 );
 385         m_LMBPointCurrent.setX( -1 );
 386 }
 387
 388 void SpectrumWidget::restart()
 389 {
 390     //set the minimum and maximum peak to the min/max wavelenght
 391     //plus/minus ten. This makes then always visible
 392     setBorders(m_spectrum->minPeak()-10.0, m_spectrum->maxPeak()+10.0);
 393 }
 394
 395 #include "spectrumwidget.moc"
 396