extensions/source/scanner/grid.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "sal/config.h"
  21
  22 #include <grid.hrc>
  23 #include <cstdio>
  24 #include <math.h> // for M_LN10 and M_E
  25
  26 #include <cmath>
  27
  28 #include <grid.hxx>
  29
  30 // for ::std::sort
  31 #include <algorithm>
  32
  33 ResId SaneResId( sal_uInt32 );
  34
  35 /***********************************************************************
  36  *
  37  *  GridWindow
  38  *
  39  ***********************************************************************/
  40
  41 // ---------------------------------------------------------------------
  42
  43 GridWindow::GridWindow(double* pXValues, double* pYValues, int nValues, Window* pParent, sal_Bool bCutValues )
  44 :   ModalDialog( pParent, SaneResId( GRID_DIALOG ) ),
  45     m_aGridArea( 50, 15, 100, 100 ),
  46     m_pXValues( pXValues ),
  47     m_pOrigYValues( pYValues ),
  48     m_nValues( nValues ),
  49     m_pNewYValues( NULL ),
  50     m_bCutValues( bCutValues ),
  51     m_aHandles(),
  52     m_nDragIndex( 0xffffffff ),
  53     m_aMarkerBitmap( Bitmap( SaneResId( GRID_DIALOG_HANDLE_BMP ) ), Color( 255, 255, 255 ) ),
  54     m_aOKButton( this, SaneResId( GRID_DIALOG_OK_BTN ) ),
  55     m_aCancelButton( this, SaneResId( GRID_DIALOG_CANCEL_BTN ) ),
  56     m_aResetTypeBox( this, SaneResId( GRID_DIALOG_TYPE_BOX ) ),
  57     m_aResetButton( this, SaneResId( GRID_DIALOG_RESET_BTN ) )
  58 {
  59     sal_uInt16 nPos = m_aResetTypeBox.InsertEntry( String( SaneResId( RESET_TYPE_LINEAR_ASCENDING ) ) );
  60     m_aResetTypeBox.SetEntryData( nPos, (void *)RESET_TYPE_LINEAR_ASCENDING );
  61
  62     nPos = m_aResetTypeBox.InsertEntry( String( SaneResId( RESET_TYPE_LINEAR_DESCENDING ) ) );
  63     m_aResetTypeBox.SetEntryData( nPos, (void *)RESET_TYPE_LINEAR_DESCENDING );
  64
  65     nPos = m_aResetTypeBox.InsertEntry( String( SaneResId( RESET_TYPE_RESET ) ) );
  66     m_aResetTypeBox.SetEntryData( nPos, (void *)RESET_TYPE_RESET );
  67
  68     nPos = m_aResetTypeBox.InsertEntry( String( SaneResId( RESET_TYPE_EXPONENTIAL ) ) );
  69     m_aResetTypeBox.SetEntryData( nPos, (void *)RESET_TYPE_EXPONENTIAL );
  70
  71     m_aResetTypeBox.SelectEntryPos( 0 );
  72
  73     m_aResetButton.SetClickHdl( LINK( this, GridWindow, ClickButtonHdl ) );
  74
  75     SetMapMode( MapMode( MAP_PIXEL ) );
  76     Size aSize = GetOutputSizePixel();
  77     Size aBtnSize = m_aOKButton.GetOutputSizePixel();
  78     m_aGridArea.setWidth( aSize.Width() - aBtnSize.Width() - 80 );
  79     m_aGridArea.setHeight( aSize.Height() - 40 );
  80
  81     if( m_pOrigYValues && m_nValues )
  82     {
  83         m_pNewYValues = new double[ m_nValues ];
  84         memcpy( m_pNewYValues, m_pOrigYValues, sizeof( double ) * m_nValues );
  85     }
  86
  87     setBoundings( 0, 0, 1023, 1023 );
  88     computeExtremes();
  89
  90     // create left and right marker as first and last entry
  91     m_BmOffX = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Width() >> 1);
  92     m_BmOffY = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Height() >> 1);
  93     m_aHandles.push_back(impHandle(transform(findMinX(), findMinY()), m_BmOffX, m_BmOffY));
  94     m_aHandles.push_back(impHandle(transform(findMaxX(), findMaxY()), m_BmOffX, m_BmOffY));
  95
  96     FreeResource();
  97 }
  98
  99 // ---------------------------------------------------------------------
 100
 101 GridWindow::~GridWindow()
 102 {
 103     if( m_pNewYValues )
 104         delete [] m_pNewYValues;
 105 }
 106
 107 // ---------------------------------------------------------------------
 108
 109 double GridWindow::findMinX()
 110 {
 111     if( ! m_pXValues )
 112         return 0.0;
 113     double fMin = m_pXValues[0];
 114     for( int i = 1; i < m_nValues; i++ )
 115         if( m_pXValues[ i ] < fMin )
 116             fMin = m_pXValues[ i ];
 117     return fMin;
 118 }
 119
 120 // ---------------------------------------------------------------------
 121
 122 double GridWindow::findMinY()
 123 {
 124     if( ! m_pNewYValues )
 125         return 0.0;
 126     double fMin = m_pNewYValues[0];
 127     for( int i = 1; i < m_nValues; i++ )
 128         if( m_pNewYValues[ i ] < fMin )
 129             fMin = m_pNewYValues[ i ];
 130     return fMin;
 131 }
 132
 133 // ---------------------------------------------------------------------
 134
 135 double GridWindow::findMaxX()
 136 {
 137     if( ! m_pXValues )
 138         return 0.0;
 139     double fMax = m_pXValues[0];
 140     for( int i = 1; i < m_nValues; i++ )
 141         if( m_pXValues[ i ] > fMax )
 142             fMax = m_pXValues[ i ];
 143     return fMax;
 144 }
 145
 146 // ---------------------------------------------------------------------
 147
 148 double GridWindow::findMaxY()
 149 {
 150     if( ! m_pNewYValues )
 151         return 0.0;
 152     double fMax = m_pNewYValues[0];
 153     for( int i = 1; i < m_nValues; i++ )
 154         if( m_pNewYValues[ i ] > fMax )
 155             fMax = m_pNewYValues[ i ];
 156     return fMax;
 157 }
 158
 159 // ---------------------------------------------------------------------
 160
 161 void GridWindow::computeExtremes()
 162 {
 163     if( m_nValues && m_pXValues && m_pOrigYValues )
 164     {
 165         m_fMaxX = m_fMinX = m_pXValues[0];
 166         m_fMaxY = m_fMinY = m_pOrigYValues[0];
 167         for( int i = 1; i < m_nValues; i++ )
 168         {
 169             if( m_pXValues[ i ] > m_fMaxX )
 170                 m_fMaxX = m_pXValues[ i ];
 171             else if( m_pXValues[ i ] < m_fMinX )
 172                 m_fMinX = m_pXValues[ i ];
 173             if( m_pOrigYValues[ i ] > m_fMaxY )
 174                 m_fMaxY = m_pOrigYValues[ i ];
 175             else if( m_pOrigYValues[ i ] < m_fMinY )
 176                 m_fMinY = m_pOrigYValues[ i ];
 177         }
 178         setBoundings( m_fMinX, m_fMinY, m_fMaxX, m_fMaxY );
 179     }
 180 }
 181
 182 // ---------------------------------------------------------------------
 183
 184 Point GridWindow::transform( double x, double y )
 185 {
 186     Point aRet;
 187
 188     aRet.X() = (long)( ( x - m_fMinX ) *
 189         (double)m_aGridArea.GetWidth() / ( m_fMaxX - m_fMinX )
 190         + m_aGridArea.Left() );
 191     aRet.Y() = (long)(
 192         m_aGridArea.Bottom() -
 193         ( y - m_fMinY ) *
 194         (double)m_aGridArea.GetHeight() / ( m_fMaxY - m_fMinY ) );
 195     return aRet;
 196 }
 197
 198 // ---------------------------------------------------------------------
 199
 200 void GridWindow::transform( const Point& rOriginal, double& x, double& y )
 201 {
 202     x = ( rOriginal.X() - m_aGridArea.Left() ) * (m_fMaxX - m_fMinX) / (double)m_aGridArea.GetWidth() + m_fMinX;
 203     y = ( m_aGridArea.Bottom() - rOriginal.Y() ) * (m_fMaxY - m_fMinY) / (double)m_aGridArea.GetHeight() + m_fMinY;
 204 }
 205
 206 // ---------------------------------------------------------------------
 207
 208 void GridWindow::drawLine( double x1, double y1, double x2, double y2 )
 209 {
 210     DrawLine( transform( x1, y1 ), transform( x2, y2 ) );
 211 }
 212
 213 // ---------------------------------------------------------------------
 214
 215 void GridWindow::computeChunk( double fMin, double fMax, double& fChunkOut, double& fMinChunkOut )
 216 {
 217     // get a nice chunk size like 10, 100, 25 or such
 218     fChunkOut = ( fMax - fMin ) / 6.0;
 219     int logchunk = (int)std::log10( fChunkOut );
 220     int nChunk = (int)( fChunkOut / std::exp( (double)(logchunk-1) * M_LN10 ) );
 221     if( nChunk >= 75 )
 222         nChunk = 100;
 223     else if( nChunk >= 35 )
 224         nChunk = 50;
 225     else if ( nChunk > 20 )
 226         nChunk = 25;
 227     else if ( nChunk >= 13 )
 228         nChunk = 20;
 229     else if( nChunk > 5 )
 230         nChunk = 10;
 231     else
 232         nChunk = 5;
 233     fChunkOut = (double) nChunk * exp( (double)(logchunk-1) * M_LN10 );
 234     // compute whole chunks fitting into fMin
 235     nChunk = (int)( fMin / fChunkOut );
 236     fMinChunkOut = (double)nChunk * fChunkOut;
 237     while( fMinChunkOut < fMin )
 238         fMinChunkOut += fChunkOut;
 239 }
 240
 241 // ---------------------------------------------------------------------
 242
 243 void GridWindow::computeNew()
 244 {
 245     if(2L == m_aHandles.size())
 246     {
 247         // special case: only left and right markers
 248         double xleft, yleft;
 249         double xright, yright;
 250         transform(m_aHandles[0L].maPos, xleft, yleft);
 251         transform(m_aHandles[1L].maPos, xright, yright );
 252         double factor = (yright-yleft)/(xright-xleft);
 253         for( int i = 0; i < m_nValues; i++ )
 254         {
 255             m_pNewYValues[ i ] = yleft + ( m_pXValues[ i ] - xleft )*factor;
 256         }
 257     }
 258     else
 259     {
 260         // sort markers
 261         std::sort(m_aHandles.begin(), m_aHandles.end());
 262         const int nSorted = m_aHandles.size();
 263         int i;
 264
 265         // get node arrays
 266         double* nodex = new double[ nSorted ];
 267         double* nodey = new double[ nSorted ];
 268
 269         for( i = 0L; i < nSorted; i++ )
 270             transform( m_aHandles[i].maPos, nodex[ i ], nodey[ i ] );
 271
 272         for( i = 0; i < m_nValues; i++ )
 273         {
 274             double x = m_pXValues[ i ];
 275             m_pNewYValues[ i ] = interpolate( x, nodex, nodey, nSorted );
 276             if( m_bCutValues )
 277             {
 278                 if( m_pNewYValues[ i ] > m_fMaxY )
 279                     m_pNewYValues[ i ] = m_fMaxY;
 280                 else if( m_pNewYValues[ i ] < m_fMinY )
 281                     m_pNewYValues[ i ] = m_fMinY;
 282             }
 283         }
 284
 285         delete [] nodex;
 286         delete [] nodey;
 287     }
 288 }
 289
 290 // ---------------------------------------------------------------------
 291
 292 double GridWindow::interpolate(
 293     double x,
 294     double* pNodeX,
 295     double* pNodeY,
 296     int nNodes )
 297 {
 298     // compute Lagrange interpolation
 299     double ret = 0;
 300     for( int i = 0; i < nNodes; i++ )
 301     {
 302         double sum = pNodeY[ i ];
 303         for( int n = 0; n < nNodes; n++ )
 304         {
 305             if( n != i )
 306             {
 307                 sum *= x - pNodeX[ n ];
 308                 sum /= pNodeX[ i ] - pNodeX[ n ];
 309             }
 310         }
 311         ret += sum;
 312     }
 313     return ret;
 314 }
 315
 316 // ---------------------------------------------------------------------
 317
 318 void GridWindow::setBoundings( double fMinX, double fMinY, double fMaxX, double fMaxY )
 319 {
 320     m_fMinX = fMinX;
 321     m_fMinY = fMinY;
 322     m_fMaxX = fMaxX;
 323     m_fMaxY = fMaxY;
 324
 325     computeChunk( m_fMinX, m_fMaxX, m_fChunkX, m_fMinChunkX );
 326     computeChunk( m_fMinY, m_fMaxY, m_fChunkY, m_fMinChunkY );
 327 }
 328
 329 // ---------------------------------------------------------------------
 330
 331 void GridWindow::drawGrid()
 332 {
 333     char pBuf[256];
 334     SetLineColor( Color( COL_BLACK ) );
 335     // draw vertical lines
 336     for( double fX = m_fMinChunkX; fX < m_fMaxX; fX += m_fChunkX )
 337     {
 338         drawLine( fX, m_fMinY, fX, m_fMaxY );
 339         // draw tickmarks
 340         Point aPt = transform( fX, m_fMinY );
 341         std::sprintf( pBuf, "%g", fX );
 342         String aMark( pBuf, osl_getThreadTextEncoding() );
 343         Size aTextSize( GetTextWidth( aMark ), GetTextHeight() );
 344         aPt.X() -= aTextSize.Width()/2;
 345         aPt.Y() += aTextSize.Height()/2;
 346         DrawText( aPt, aMark );
 347     }
 348     // draw horizontal lines
 349     for( double fY = m_fMinChunkY; fY < m_fMaxY; fY += m_fChunkY )
 350     {
 351         drawLine( m_fMinX, fY, m_fMaxX, fY );
 352         // draw tickmarks
 353         Point aPt = transform( m_fMinX, fY );
 354         std::sprintf( pBuf, "%g", fY );
 355         String aMark( pBuf, osl_getThreadTextEncoding() );
 356         Size aTextSize( GetTextWidth( aMark ), GetTextHeight() );
 357         aPt.X() -= aTextSize.Width() + 2;
 358         aPt.Y() -= aTextSize.Height()/2;
 359         DrawText( aPt, aMark );
 360     }
 361
 362     // draw boundings
 363     drawLine( m_fMinX, m_fMinY, m_fMaxX, m_fMinY );
 364     drawLine( m_fMinX, m_fMaxY, m_fMaxX, m_fMaxY );
 365     drawLine( m_fMinX, m_fMinY, m_fMinX, m_fMaxY );
 366     drawLine( m_fMaxX, m_fMinY, m_fMaxX, m_fMaxY );
 367 }
 368
 369 // ---------------------------------------------------------------------
 370
 371 void GridWindow::drawOriginal()
 372 {
 373     if( m_nValues && m_pXValues && m_pOrigYValues )
 374     {
 375         SetLineColor( Color( COL_RED ) );
 376         for( int i = 0; i < m_nValues-1; i++ )
 377         {
 378             drawLine( m_pXValues[ i   ], m_pOrigYValues[ i   ],
 379                       m_pXValues[ i+1 ], m_pOrigYValues[ i+1 ] );
 380         }
 381     }
 382 }
 383
 384 // ---------------------------------------------------------------------
 385
 386 void GridWindow::drawNew()
 387 {
 388     if( m_nValues && m_pXValues && m_pNewYValues )
 389     {
 390         SetClipRegion(Region(m_aGridArea));
 391         SetLineColor( Color( COL_YELLOW ) );
 392         for( int i = 0; i < m_nValues-1; i++ )
 393         {
 394             drawLine( m_pXValues[ i   ], m_pNewYValues[ i   ],
 395                       m_pXValues[ i+1 ], m_pNewYValues[ i+1 ] );
 396         }
 397         SetClipRegion();
 398     }
 399 }
 400
 401 // ---------------------------------------------------------------------
 402
 403 void GridWindow::drawHandles()
 404 {
 405     for(sal_uInt32 i(0L); i < m_aHandles.size(); i++)
 406     {
 407         m_aHandles[i].draw(*this, m_aMarkerBitmap);
 408     }
 409 }
 410
 411 // ---------------------------------------------------------------------
 412
 413 void GridWindow::Paint( const Rectangle& rRect )
 414 {
 415     ModalDialog::Paint( rRect );
 416     drawGrid();
 417     drawOriginal();
 418     drawNew();
 419     drawHandles();
 420 }
 421
 422 // ---------------------------------------------------------------------
 423
 424 void GridWindow::MouseMove( const MouseEvent& rEvt )
 425 {
 426     if( rEvt.GetButtons() == MOUSE_LEFT && m_nDragIndex != 0xffffffff )
 427     {
 428         Point aPoint( rEvt.GetPosPixel() );
 429
 430         if( m_nDragIndex == 0L || m_nDragIndex == m_aHandles.size() - 1L)
 431         {
 432             aPoint.X() = m_aHandles[m_nDragIndex].maPos.X();
 433         }
 434         else
 435         {
 436             if(aPoint.X() < m_aGridArea.Left())
 437                 aPoint.X() = m_aGridArea.Left();
 438             else if(aPoint.X() > m_aGridArea.Right())
 439                 aPoint.X() = m_aGridArea.Right();
 440         }
 441
 442         if( aPoint.Y() < m_aGridArea.Top() )
 443             aPoint.Y() = m_aGridArea.Top();
 444         else if( aPoint.Y() > m_aGridArea.Bottom() )
 445             aPoint.Y() = m_aGridArea.Bottom();
 446
 447         if( aPoint != m_aHandles[m_nDragIndex].maPos )
 448         {
 449             m_aHandles[m_nDragIndex].maPos = aPoint;
 450             Invalidate( m_aGridArea );
 451         }
 452     }
 453
 454     ModalDialog::MouseMove( rEvt );
 455 }
 456
 457 // ---------------------------------------------------------------------
 458
 459 void GridWindow::MouseButtonUp( const MouseEvent& rEvt )
 460 {
 461     if( rEvt.GetButtons() == MOUSE_LEFT )
 462     {
 463         if( m_nDragIndex != 0xffffffff )
 464         {
 465             m_nDragIndex = 0xffffffff;
 466             computeNew();
 467             Invalidate( m_aGridArea );
 468             Paint( m_aGridArea );
 469         }
 470     }
 471
 472     ModalDialog::MouseButtonUp( rEvt );
 473 }
 474
 475 // ---------------------------------------------------------------------
 476
 477 void GridWindow::MouseButtonDown( const MouseEvent& rEvt )
 478 {
 479     Point aPoint( rEvt.GetPosPixel() );
 480     sal_uInt32 nMarkerIndex = 0xffffffff;
 481
 482     for(sal_uInt32 a(0L); nMarkerIndex == 0xffffffff && a < m_aHandles.size(); a++)
 483     {
 484         if(m_aHandles[a].isHit(*this, aPoint))
 485         {
 486             nMarkerIndex = a;
 487         }
 488     }
 489
 490     if( rEvt.GetButtons() == MOUSE_LEFT )
 491     {
 492         // user wants to drag a button
 493         if( nMarkerIndex != 0xffffffff )
 494         {
 495             m_nDragIndex = nMarkerIndex;
 496         }
 497     }
 498     else if( rEvt.GetButtons() == MOUSE_RIGHT )
 499     {
 500         // user wants to add/delete a button
 501         if( nMarkerIndex != 0xffffffff )
 502         {
 503             if( nMarkerIndex != 0L && nMarkerIndex != m_aHandles.size() - 1L)
 504             {
 505                 // delete marker under mouse
 506                 if( m_nDragIndex == nMarkerIndex )
 507                     m_nDragIndex = 0xffffffff;
 508
 509                 m_aHandles.erase(m_aHandles.begin() + nMarkerIndex);
 510             }
 511         }
 512         else
 513         {
 514             m_BmOffX = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Width() >> 1);
 515             m_BmOffY = sal_uInt16(m_aMarkerBitmap.GetSizePixel().Height() >> 1);
 516             m_aHandles.push_back(impHandle(aPoint, m_BmOffX, m_BmOffY));
 517         }
 518
 519         computeNew();
 520         Invalidate( m_aGridArea );
 521         Paint( m_aGridArea );
 522     }
 523
 524     ModalDialog::MouseButtonDown( rEvt );
 525 }
 526
 527 // ---------------------------------------------------------------------
 528
 529 IMPL_LINK( GridWindow, ClickButtonHdl, Button*, pButton )
 530 {
 531     if( pButton == &m_aResetButton )
 532     {
 533         int nType = (int)(sal_IntPtr)m_aResetTypeBox.GetEntryData( m_aResetTypeBox.GetSelectEntryPos() );
 534         switch( nType )
 535         {
 536             case RESET_TYPE_LINEAR_ASCENDING:
 537             {
 538                 for( int i = 0; i < m_nValues; i++ )
 539                 {
 540                     m_pNewYValues[ i ] = m_fMinY + (m_fMaxY-m_fMinY)/(m_fMaxX-m_fMinX)*(m_pXValues[i]-m_fMinX);
 541                 }
 542             }
 543             break;
 544             case RESET_TYPE_LINEAR_DESCENDING:
 545             {
 546                 for( int i = 0; i < m_nValues; i++ )
 547                 {
 548                     m_pNewYValues[ i ] = m_fMaxY - (m_fMaxY-m_fMinY)/(m_fMaxX-m_fMinX)*(m_pXValues[i]-m_fMinX);
 549                 }
 550             }
 551             break;
 552             case RESET_TYPE_RESET:
 553             {
 554                 if( m_pOrigYValues && m_pNewYValues && m_nValues )
 555                     memcpy( m_pNewYValues, m_pOrigYValues, m_nValues*sizeof(double) );
 556             }
 557             break;
 558             case RESET_TYPE_EXPONENTIAL:
 559             {
 560                 for( int i = 0; i < m_nValues; i++ )
 561                 {
 562                     m_pNewYValues[ i ] = m_fMinY + (m_fMaxY-m_fMinY)*(std::exp((m_pXValues[i]-m_fMinX)/(m_fMaxX-m_fMinX))-1.0)/(M_E-1.0);
 563                 }
 564             }
 565             break;
 566
 567             default:
 568                 break;
 569         }
 570
 571         for(sal_uInt32 i(0L); i < m_aHandles.size(); i++)
 572         {
 573             // find nearest xvalue
 574             double x, y;
 575             transform( m_aHandles[i].maPos, x, y );
 576             int nIndex = 0;
 577             double delta = std::fabs( x-m_pXValues[0] );
 578             for( int n = 1; n < m_nValues; n++ )
 579             {
 580                 if( delta > std::fabs( x - m_pXValues[ n ] ) )
 581                 {
 582                     delta = std::fabs( x - m_pXValues[ n ] );
 583                     nIndex = n;
 584                 }
 585             }
 586             if( 0 == i )
 587                 m_aHandles[i].maPos = transform( m_fMinX, m_pNewYValues[ nIndex ] );
 588             else if( m_aHandles.size() - 1L == i )
 589                 m_aHandles[i].maPos = transform( m_fMaxX, m_pNewYValues[ nIndex ] );
 590             else
 591                 m_aHandles[i].maPos = transform( m_pXValues[ nIndex ], m_pNewYValues[ nIndex ] );
 592         }
 593
 594         Invalidate( m_aGridArea );
 595         Paint(Rectangle());
 596     }
 597     return 0;
 598 }
 599
 600 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */