chart2/source/view/main/PlottingPositionHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PlottingPositionHelper.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_chart2.hxx"
  33 #include "PlottingPositionHelper.hxx"
  34 #include "CommonConverters.hxx"
  35 #include "ViewDefines.hxx"
  36 #include "Linear3DTransformation.hxx"
  37 #include "VPolarTransformation.hxx"
  38
  39 #include "ShapeFactory.hxx"
  40 #include "PropertyMapper.hxx"
  41 #include <com/sun/star/drawing/DoubleSequence.hpp>
  42 #include <com/sun/star/drawing/Position3D.hpp>
  43 #include <com/sun/star/chart2/AxisType.hpp>
  44
  45 #include <rtl/math.hxx>
  46
  47 //.............................................................................
  48 namespace chart
  49 {
  50 //.............................................................................
  51 using namespace ::com::sun::star;
  52 using namespace ::com::sun::star::chart2;
  53
  54 PlottingPositionHelper::PlottingPositionHelper()
  55         : m_aScales()
  56         , m_aMatrixScreenToScene()
  57         , m_xTransformationLogicToScene(NULL)
  58         , m_bSwapXAndY( false )
  59         , m_nXResolution( 1000 )
  60         , m_nYResolution( 1000 )
  61         , m_nZResolution( 1000 )
  62         , m_bMaySkipPointsInRegressionCalculation( true )
  63 {
  64 }
  65 PlottingPositionHelper::PlottingPositionHelper( const PlottingPositionHelper& rSource )
  66         : m_aScales( rSource.m_aScales )
  67         , m_aMatrixScreenToScene( rSource.m_aMatrixScreenToScene )
  68         , m_xTransformationLogicToScene( NULL ) //should be recalculated
  69         , m_bSwapXAndY( rSource.m_bSwapXAndY )
  70         , m_nXResolution( rSource.m_nXResolution )
  71         , m_nYResolution( rSource.m_nYResolution )
  72         , m_nZResolution( rSource.m_nZResolution )
  73         , m_bMaySkipPointsInRegressionCalculation( rSource.m_bMaySkipPointsInRegressionCalculation )
  74 {
  75 }
  76
  77 PlottingPositionHelper::~PlottingPositionHelper()
  78 {
  79
  80 }
  81
  82 PlottingPositionHelper* PlottingPositionHelper::clone() const
  83 {
  84     PlottingPositionHelper* pRet = new PlottingPositionHelper(*this);
  85     return pRet;
  86 }
  87
  88 PlottingPositionHelper* PlottingPositionHelper::createSecondaryPosHelper( const ExplicitScaleData& rSecondaryScale )
  89 {
  90     PlottingPositionHelper* pRet = this->clone();
  91     pRet->m_aScales[1]=rSecondaryScale;
  92     return pRet;
  93 }
  94
  95 void PlottingPositionHelper::setTransformationSceneToScreen( const drawing::HomogenMatrix& rMatrix)
  96 {
  97     m_aMatrixScreenToScene = HomogenMatrixToB3DHomMatrix(rMatrix);
  98     m_xTransformationLogicToScene = NULL;
  99 }
 100
 101 void PlottingPositionHelper::setScales( const uno::Sequence< ExplicitScaleData >& rScales, sal_Bool bSwapXAndYAxis )
 102 {
 103     m_aScales = rScales;
 104     m_bSwapXAndY = bSwapXAndYAxis;
 105     m_xTransformationLogicToScene = NULL;
 106 }
 107 const uno::Sequence< ExplicitScaleData >& PlottingPositionHelper::getScales() const
 108 {
 109     return m_aScales;
 110 }
 111
 112 uno::Reference< XTransformation > PlottingPositionHelper::getTransformationScaledLogicToScene() const
 113 {
 114     //this is a standard transformation for a cartesian coordinate system
 115
 116     //transformation from 2) to 4) //@todo 2) and 4) need a ink to a document
 117
 118     //we need to apply this transformation to each geometric object because of a bug/problem
 119     //of the old drawing layer (the UNO_NAME_3D_EXTRUDE_DEPTH is an integer value instead of an double )
 120     if(!m_xTransformationLogicToScene.is())
 121     {
 122         ::basegfx::B3DHomMatrix aMatrix;
 123         double MinX = getLogicMinX();
 124         double MinY = getLogicMinY();
 125         double MinZ = getLogicMinZ();
 126         double MaxX = getLogicMaxX();
 127         double MaxY = getLogicMaxY();
 128         double MaxZ = getLogicMaxZ();
 129
 130         AxisOrientation nXAxisOrientation = m_aScales[0].Orientation;
 131         AxisOrientation nYAxisOrientation = m_aScales[1].Orientation;
 132         AxisOrientation nZAxisOrientation = m_aScales[2].Orientation;
 133
 134         //apply scaling
 135         doLogicScaling( &MinX, &MinY, &MinZ );
 136         doLogicScaling( &MaxX, &MaxY, &MaxZ);
 137
 138         if(m_bSwapXAndY)
 139         {
 140             std::swap(MinX,MinY);
 141             std::swap(MaxX,MaxY);
 142             std::swap(nXAxisOrientation,nYAxisOrientation);
 143         }
 144
 145         double fWidthX = MaxX - MinX;
 146         double fWidthY = MaxY - MinY;
 147         double fWidthZ = MaxZ - MinZ;
 148
 149         double fScaleDirectionX = AxisOrientation_MATHEMATICAL==nXAxisOrientation ? 1.0 : -1.0;
 150         double fScaleDirectionY = AxisOrientation_MATHEMATICAL==nYAxisOrientation ? 1.0 : -1.0;
 151         double fScaleDirectionZ = AxisOrientation_MATHEMATICAL==nZAxisOrientation ? -1.0 : 1.0;
 152
 153         double fScaleX = fScaleDirectionX*FIXED_SIZE_FOR_3D_CHART_VOLUME/fWidthX;
 154         double fScaleY = fScaleDirectionY*FIXED_SIZE_FOR_3D_CHART_VOLUME/fWidthY;
 155         double fScaleZ = fScaleDirectionZ*FIXED_SIZE_FOR_3D_CHART_VOLUME/fWidthZ;
 156
 157         aMatrix.scale(fScaleX, fScaleY, fScaleZ);
 158
 159         if( AxisOrientation_MATHEMATICAL==nXAxisOrientation )
 160             aMatrix.translate(-MinX*fScaleX, 0.0, 0.0);
 161         else
 162             aMatrix.translate(-MaxX*fScaleX, 0.0, 0.0);
 163         if( AxisOrientation_MATHEMATICAL==nYAxisOrientation )
 164             aMatrix.translate(0.0, -MinY*fScaleY, 0.0);
 165         else
 166             aMatrix.translate(0.0, -MaxY*fScaleY, 0.0);
 167         if( AxisOrientation_MATHEMATICAL==nZAxisOrientation )
 168             aMatrix.translate(0.0, 0.0, -MaxZ*fScaleZ);//z direction in draw is reverse mathematical direction
 169         else
 170             aMatrix.translate(0.0, 0.0, -MinZ*fScaleZ);
 171
 172         aMatrix = m_aMatrixScreenToScene*aMatrix;
 173
 174         m_xTransformationLogicToScene = new Linear3DTransformation(B3DHomMatrixToHomogenMatrix( aMatrix ),m_bSwapXAndY);
 175     }
 176     return m_xTransformationLogicToScene;
 177 }
 178
 179 drawing::Position3D PlottingPositionHelper::transformLogicToScene(
 180     double fX, double fY, double fZ, bool bClip ) const
 181 {
 182     if(bClip)
 183         this->clipLogicValues( &fX,&fY,&fZ );
 184     this->doLogicScaling( &fX,&fY,&fZ );
 185
 186     return this->transformScaledLogicToScene( fX, fY, fZ, false );
 187 }
 188
 189 drawing::Position3D PlottingPositionHelper::transformScaledLogicToScene(
 190     double fX, double fY, double fZ, bool bClip  ) const
 191 {
 192     if( bClip )
 193         this->clipScaledLogicValues( &fX,&fY,&fZ );
 194
 195     drawing::Position3D aPos( fX, fY, fZ);
 196
 197     uno::Reference< XTransformation > xTransformation =
 198         this->getTransformationScaledLogicToScene();
 199     uno::Sequence< double > aSeq =
 200         xTransformation->transform( Position3DToSequence(aPos) );
 201     return SequenceToPosition3D(aSeq);
 202 }
 203
 204 //static
 205 awt::Point PlottingPositionHelper::transformSceneToScreenPosition( const drawing::Position3D& rScenePosition3D
 206                 , const uno::Reference< drawing::XShapes >& xSceneTarget
 207                 , ShapeFactory* pShapeFactory
 208                 , sal_Int32 nDimensionCount )
 209 {
 210     //@todo would like to have a cheaper method to do this transformation
 211     awt::Point aScreenPoint( static_cast<sal_Int32>(rScenePosition3D.PositionX), static_cast<sal_Int32>(rScenePosition3D.PositionY) );
 212
 213     //transformation from scene to screen (only neccessary for 3D):
 214     if(3==nDimensionCount)
 215     {
 216         //create 3D anchor shape
 217         tPropertyNameMap aDummyPropertyNameMap;
 218         uno::Reference< drawing::XShape > xShape3DAnchor = pShapeFactory->createCube( xSceneTarget
 219                 , rScenePosition3D,drawing::Direction3D(1,1,1)
 220                 , 0, 0, aDummyPropertyNameMap);
 221         //get 2D position from xShape3DAnchor
 222         aScreenPoint = xShape3DAnchor->getPosition();
 223         xSceneTarget->remove(xShape3DAnchor);
 224     }
 225     return aScreenPoint;
 226 }
 227
 228 void PlottingPositionHelper::transformScaledLogicToScene( drawing::PolyPolygonShape3D& rPolygon ) const
 229 {
 230     drawing::Position3D aScenePosition;
 231     for( sal_Int32 nS = rPolygon.SequenceX.getLength(); nS--;)
 232     {
 233         drawing::DoubleSequence& xValues = rPolygon.SequenceX[nS];
 234         drawing::DoubleSequence& yValues = rPolygon.SequenceY[nS];
 235         drawing::DoubleSequence& zValues = rPolygon.SequenceZ[nS];
 236         for( sal_Int32 nP = xValues.getLength(); nP--; )
 237         {
 238             double& fX = xValues[nP];
 239             double& fY = yValues[nP];
 240             double& fZ = zValues[nP];
 241             aScenePosition = this->transformScaledLogicToScene( fX,fY,fZ,true );
 242             fX = aScenePosition.PositionX;
 243             fY = aScenePosition.PositionY;
 244             fZ = aScenePosition.PositionZ;
 245         }
 246     }
 247 }
 248
 249
 250 void PlottingPositionHelper::clipScaledLogicValues( double* pX, double* pY, double* pZ ) const
 251 {
 252     //get logic clip values:
 253     double MinX = getLogicMinX();
 254     double MinY = getLogicMinY();
 255     double MinZ = getLogicMinZ();
 256     double MaxX = getLogicMaxX();
 257     double MaxY = getLogicMaxY();
 258     double MaxZ = getLogicMaxZ();
 259
 260     //apply scaling
 261     doLogicScaling( &MinX, &MinY, &MinZ );
 262     doLogicScaling( &MaxX, &MaxY, &MaxZ);
 263
 264     if(pX)
 265     {
 266         if( *pX < MinX )
 267             *pX = MinX;
 268         else if( *pX > MaxX )
 269             *pX = MaxX;
 270     }
 271     if(pY)
 272     {
 273         if( *pY < MinY )
 274             *pY = MinY;
 275         else if( *pY > MaxY )
 276             *pY = MaxY;
 277     }
 278     if(pZ)
 279     {
 280         if( *pZ < MinZ )
 281             *pZ = MinZ;
 282         else if( *pZ > MaxZ )
 283             *pZ = MaxZ;
 284     }
 285 }
 286
 287 basegfx::B2DRectangle PlottingPositionHelper::getScaledLogicClipDoubleRect() const
 288 {
 289     //get logic clip values:
 290     double MinX = getLogicMinX();
 291     double MinY = getLogicMinY();
 292     double MinZ = getLogicMinZ();
 293     double MaxX = getLogicMaxX();
 294     double MaxY = getLogicMaxY();
 295     double MaxZ = getLogicMaxZ();
 296
 297     //apply scaling
 298     doLogicScaling( &MinX, &MinY, &MinZ );
 299     doLogicScaling( &MaxX, &MaxY, &MaxZ);
 300
 301     basegfx::B2DRectangle aRet( MinX, MaxY, MaxX, MinY );
 302     return aRet;
 303 }
 304
 305 drawing::Direction3D PlottingPositionHelper::getScaledLogicWidth() const
 306 {
 307     drawing::Direction3D aRet;
 308
 309     double MinX = getLogicMinX();
 310     double MinY = getLogicMinY();
 311     double MinZ = getLogicMinZ();
 312     double MaxX = getLogicMaxX();
 313     double MaxY = getLogicMaxY();
 314     double MaxZ = getLogicMaxZ();
 315
 316     doLogicScaling( &MinX, &MinY, &MinZ );
 317     doLogicScaling( &MaxX, &MaxY, &MaxZ);
 318
 319     aRet.DirectionX = MaxX - MinX;
 320     aRet.DirectionY = MaxY - MinY;
 321     aRet.DirectionZ = MaxZ - MinZ;
 322     return aRet;
 323 }
 324
 325 //-----------------------------------------------------------------------------
 326 //-----------------------------------------------------------------------------
 327 //-----------------------------------------------------------------------------
 328
 329 PolarPlottingPositionHelper::PolarPlottingPositionHelper( NormalAxis eNormalAxis )
 330     : m_fRadiusOffset(0.0)
 331     , m_fAngleDegreeOffset(90.0)
 332     , m_aUnitCartesianToScene()
 333     , m_eNormalAxis(eNormalAxis)
 334 {
 335     m_bMaySkipPointsInRegressionCalculation = false;
 336 }
 337
 338 PolarPlottingPositionHelper::PolarPlottingPositionHelper( const PolarPlottingPositionHelper& rSource )
 339     : PlottingPositionHelper(rSource)
 340     , m_fRadiusOffset( rSource.m_fRadiusOffset )
 341     , m_fAngleDegreeOffset( rSource.m_fAngleDegreeOffset )
 342     , m_aUnitCartesianToScene( rSource.m_aUnitCartesianToScene )
 343     , m_eNormalAxis( rSource.m_eNormalAxis )
 344 {
 345 }
 346
 347 PolarPlottingPositionHelper::~PolarPlottingPositionHelper()
 348 {
 349 }
 350
 351 PlottingPositionHelper* PolarPlottingPositionHelper::clone() const
 352 {
 353     PolarPlottingPositionHelper* pRet = new PolarPlottingPositionHelper(*this);
 354     return pRet;
 355 }
 356
 357 void PolarPlottingPositionHelper::setTransformationSceneToScreen( const drawing::HomogenMatrix& rMatrix)
 358 {
 359     PlottingPositionHelper::setTransformationSceneToScreen( rMatrix);
 360     m_aUnitCartesianToScene =impl_calculateMatrixUnitCartesianToScene( m_aMatrixScreenToScene );
 361 }
 362 void PolarPlottingPositionHelper::setScales( const uno::Sequence< ExplicitScaleData >& rScales, sal_Bool bSwapXAndYAxis )
 363 {
 364     PlottingPositionHelper::setScales( rScales, bSwapXAndYAxis );
 365     m_aUnitCartesianToScene =impl_calculateMatrixUnitCartesianToScene( m_aMatrixScreenToScene );
 366 }
 367
 368 ::basegfx::B3DHomMatrix PolarPlottingPositionHelper::impl_calculateMatrixUnitCartesianToScene( const ::basegfx::B3DHomMatrix& rMatrixScreenToScene ) const
 369 {
 370     ::basegfx::B3DHomMatrix aRet;
 371
 372     if( !m_aScales.getLength() )
 373         return aRet;
 374
 375     double fTranslate =1.0;
 376     double fScale     =FIXED_SIZE_FOR_3D_CHART_VOLUME/2.0;
 377
 378     double fTranslateLogicZ =fTranslate;
 379     double fScaleLogicZ     =fScale;
 380     {
 381         double fScaleDirectionZ = AxisOrientation_MATHEMATICAL==m_aScales[2].Orientation ? 1.0 : -1.0;
 382         double MinZ = getLogicMinZ();
 383         double MaxZ = getLogicMaxZ();
 384         doLogicScaling( 0, 0, &MinZ );
 385         doLogicScaling( 0, 0, &MaxZ );
 386         double fWidthZ = MaxZ - MinZ;
 387
 388         if( AxisOrientation_MATHEMATICAL==m_aScales[2].Orientation )
 389             fTranslateLogicZ=MinZ;
 390         else
 391             fTranslateLogicZ=MaxZ;
 392         fScaleLogicZ = fScaleDirectionZ*FIXED_SIZE_FOR_3D_CHART_VOLUME/fWidthZ;
 393     }
 394
 395     double fTranslateX = fTranslate;
 396     double fTranslateY = fTranslate;
 397     double fTranslateZ = fTranslate;
 398
 399     double fScaleX = fScale;
 400     double fScaleY = fScale;
 401     double fScaleZ = fScale;
 402
 403     switch(m_eNormalAxis)
 404     {
 405         case NormalAxis_X:
 406             {
 407                 fTranslateX = fTranslateLogicZ;
 408                 fScaleX = fScaleLogicZ;
 409             }
 410             break;
 411         case NormalAxis_Y:
 412             {
 413                 fTranslateY = fTranslateLogicZ;
 414                 fScaleY = fScaleLogicZ;
 415             }
 416             break;
 417         default: //NormalAxis_Z:
 418             {
 419                 fTranslateZ = fTranslateLogicZ;
 420                 fScaleZ = fScaleLogicZ;
 421             }
 422             break;
 423     }
 424
 425     aRet.translate(fTranslateX, fTranslateY, fTranslateZ);//x first
 426     aRet.scale(fScaleX, fScaleY, fScaleZ);//x first
 427
 428     aRet = rMatrixScreenToScene * aRet;
 429     return aRet;
 430 }
 431
 432 ::basegfx::B3DHomMatrix PolarPlottingPositionHelper::getUnitCartesianToScene() const
 433 {
 434     return m_aUnitCartesianToScene;
 435 }
 436
 437 uno::Reference< XTransformation > PolarPlottingPositionHelper::getTransformationScaledLogicToScene() const
 438 {
 439     if( !m_xTransformationLogicToScene.is() )
 440         m_xTransformationLogicToScene = new VPolarTransformation(*this);
 441     return m_xTransformationLogicToScene;
 442 }
 443
 444 double PolarPlottingPositionHelper::getWidthAngleDegree( double& fStartLogicValueOnAngleAxis, double& fEndLogicValueOnAngleAxis ) const
 445 {
 446     const ExplicitScaleData& rAngleScale = m_bSwapXAndY ? m_aScales[1] : m_aScales[0];
 447     if( AxisOrientation_MATHEMATICAL != rAngleScale.Orientation )
 448     {
 449         double fHelp = fEndLogicValueOnAngleAxis;
 450         fEndLogicValueOnAngleAxis = fStartLogicValueOnAngleAxis;
 451         fStartLogicValueOnAngleAxis = fHelp;
 452     }
 453
 454     double fStartAngleDegree = this->transformToAngleDegree( fStartLogicValueOnAngleAxis );
 455     double fEndAngleDegree   = this->transformToAngleDegree( fEndLogicValueOnAngleAxis );
 456     double fWidthAngleDegree = fEndAngleDegree - fStartAngleDegree;
 457
 458     if( ::rtl::math::approxEqual( fStartAngleDegree, fEndAngleDegree )
 459         && !::rtl::math::approxEqual( fStartLogicValueOnAngleAxis, fEndLogicValueOnAngleAxis ) )
 460         fWidthAngleDegree = 360.0;
 461
 462     while(fWidthAngleDegree<0.0)
 463         fWidthAngleDegree+=360.0;
 464     while(fWidthAngleDegree>360.0)
 465         fWidthAngleDegree-=360.0;
 466
 467     return fWidthAngleDegree;
 468 }
 469
 470 double PolarPlottingPositionHelper::transformToAngleDegree( double fLogicValueOnAngleAxis, bool bDoScaling ) const
 471 {
 472     double fRet=0.0;
 473
 474     double fAxisAngleScaleDirection = 1.0;
 475     {
 476         const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[1] : m_aScales[0];
 477         if(AxisOrientation_MATHEMATICAL != rScale.Orientation)
 478             fAxisAngleScaleDirection *= -1.0;
 479     }
 480
 481     double MinAngleValue = 0.0;
 482     double MaxAngleValue = 0.0;
 483     {
 484         double MinX = getLogicMinX();
 485         double MinY = getLogicMinY();
 486         double MaxX = getLogicMaxX();
 487         double MaxY = getLogicMaxY();
 488         double MinZ = getLogicMinZ();
 489         double MaxZ = getLogicMaxZ();
 490
 491         doLogicScaling( &MinX, &MinY, &MinZ );
 492         doLogicScaling( &MaxX, &MaxY, &MaxZ);
 493
 494         MinAngleValue = m_bSwapXAndY ? MinY : MinX;
 495         MaxAngleValue = m_bSwapXAndY ? MaxY : MaxX;
 496     }
 497
 498     double fScaledLogicAngleValue = 0.0;
 499     if(bDoScaling)
 500     {
 501         double fX = m_bSwapXAndY ? getLogicMaxX() : fLogicValueOnAngleAxis;
 502         double fY = m_bSwapXAndY ? fLogicValueOnAngleAxis : getLogicMaxY();
 503         double fZ = getLogicMaxZ();
 504         clipLogicValues( &fX, &fY, &fZ );
 505         doLogicScaling( &fX, &fY, &fZ );
 506         fScaledLogicAngleValue = m_bSwapXAndY ? fY : fX;
 507     }
 508     else
 509         fScaledLogicAngleValue = fLogicValueOnAngleAxis;
 510
 511     fRet = m_fAngleDegreeOffset
 512                   + fAxisAngleScaleDirection*(fScaledLogicAngleValue-MinAngleValue)*360.0
 513                     /fabs(MaxAngleValue-MinAngleValue);
 514     while(fRet>360.0)
 515         fRet-=360.0;
 516     while(fRet<0)
 517         fRet+=360.0;
 518     return fRet;
 519 }
 520
 521 double PolarPlottingPositionHelper::transformToRadius( double fLogicValueOnRadiusAxis, bool bDoScaling ) const
 522 {
 523     double fNormalRadius = 0.0;
 524     {
 525         double fScaledLogicRadiusValue = 0.0;
 526         double fX = m_bSwapXAndY ? fLogicValueOnRadiusAxis: getLogicMaxX();
 527         double fY = m_bSwapXAndY ? getLogicMaxY() : fLogicValueOnRadiusAxis;
 528         if(bDoScaling)
 529             doLogicScaling( &fX, &fY, 0 );
 530
 531         fScaledLogicRadiusValue = m_bSwapXAndY ? fX : fY;
 532
 533         bool bMinIsInnerRadius = true;
 534         const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[0] : m_aScales[1];
 535         if(AxisOrientation_MATHEMATICAL != rScale.Orientation)
 536             bMinIsInnerRadius = false;
 537
 538         double fInnerScaledLogicRadius=0.0;
 539         double fOuterScaledLogicRadius=0.0;
 540         {
 541             double MinX = getLogicMinX();
 542             double MinY = getLogicMinY();
 543             doLogicScaling( &MinX, &MinY, 0 );
 544             double MaxX = getLogicMaxX();
 545             double MaxY = getLogicMaxY();
 546             doLogicScaling( &MaxX, &MaxY, 0 );
 547
 548             double fMin = m_bSwapXAndY ? MinX : MinY;
 549             double fMax = m_bSwapXAndY ? MaxX : MaxY;
 550
 551             fInnerScaledLogicRadius = bMinIsInnerRadius ? fMin : fMax;
 552             fOuterScaledLogicRadius = bMinIsInnerRadius ? fMax : fMin;
 553         }
 554
 555         if( bMinIsInnerRadius )
 556             fInnerScaledLogicRadius -= fabs(m_fRadiusOffset);
 557         else
 558             fInnerScaledLogicRadius += fabs(m_fRadiusOffset);
 559         fNormalRadius = (fScaledLogicRadiusValue-fInnerScaledLogicRadius)/(fOuterScaledLogicRadius-fInnerScaledLogicRadius);
 560     }
 561     return fNormalRadius;
 562 }
 563
 564 drawing::Position3D PolarPlottingPositionHelper::transformLogicToScene( double fX, double fY, double fZ, bool bClip ) const
 565 {
 566     if(bClip)
 567         this->clipLogicValues( &fX,&fY,&fZ );
 568     double fLogicValueOnAngleAxis  = m_bSwapXAndY ? fY : fX;
 569     double fLogicValueOnRadiusAxis = m_bSwapXAndY ? fX : fY;
 570     return this->transformAngleRadiusToScene( fLogicValueOnAngleAxis, fLogicValueOnRadiusAxis, fZ, true );
 571 }
 572
 573 drawing::Position3D PolarPlottingPositionHelper::transformScaledLogicToScene( double fX, double fY, double fZ, bool bClip ) const
 574 {
 575     if(bClip)
 576         this->clipScaledLogicValues( &fX,&fY,&fZ );
 577     double fLogicValueOnAngleAxis  = m_bSwapXAndY ? fY : fX;
 578     double fLogicValueOnRadiusAxis = m_bSwapXAndY ? fX : fY;
 579     return this->transformAngleRadiusToScene( fLogicValueOnAngleAxis, fLogicValueOnRadiusAxis, fZ, false );
 580 }
 581 drawing::Position3D PolarPlottingPositionHelper::transformUnitCircleToScene( double fUnitAngleDegree, double fUnitRadius
 582                                                                             , double fLogicZ, bool /* bDoScaling */ ) const
 583 {
 584     double fAnglePi = fUnitAngleDegree*F_PI/180.0;
 585
 586     double fX=fUnitRadius*rtl::math::cos(fAnglePi);
 587     double fY=fUnitRadius*rtl::math::sin(fAnglePi);
 588     double fZ=fLogicZ;
 589
 590     switch(m_eNormalAxis)
 591     {
 592         case NormalAxis_X:
 593             std::swap(fX,fZ);
 594             break;
 595         case NormalAxis_Y:
 596             std::swap(fY,fZ);
 597             fZ*=-1;
 598             break;
 599         default: //NormalAxis_Z
 600             break;
 601     }
 602
 603     //!! applying matrix to vector does ignore translation, so it is important to use a B3DPoint here instead of B3DVector
 604     ::basegfx::B3DPoint aPoint(fX,fY,fZ);
 605     ::basegfx::B3DPoint aRet = m_aUnitCartesianToScene * aPoint;
 606     return B3DPointToPosition3D(aRet);
 607 }
 608
 609 drawing::Position3D PolarPlottingPositionHelper::transformAngleRadiusToScene( double fLogicValueOnAngleAxis, double fLogicValueOnRadiusAxis, double fLogicZ, bool bDoScaling ) const
 610 {
 611     double fUnitAngleDegree = this->transformToAngleDegree(fLogicValueOnAngleAxis,bDoScaling);
 612     double fUnitRadius      = this->transformToRadius(fLogicValueOnRadiusAxis,bDoScaling);
 613
 614     return transformUnitCircleToScene( fUnitAngleDegree, fUnitRadius, fLogicZ, bDoScaling );
 615 }
 616
 617 #ifdef NOTYET
 618 double PolarPlottingPositionHelper::getInnerLogicRadius() const
 619 {
 620     const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[0] : m_aScales[1];
 621     if( AxisOrientation_MATHEMATICAL==rScale.Orientation )
 622         return rScale.Minimum;
 623     else
 624         return rScale.Maximum;
 625 }
 626 #endif
 627
 628 double PolarPlottingPositionHelper::getOuterLogicRadius() const
 629 {
 630     const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[0] : m_aScales[1];
 631     if( AxisOrientation_MATHEMATICAL==rScale.Orientation )
 632         return rScale.Maximum;
 633     else
 634         return rScale.Minimum;
 635 }
 636
 637 bool PlottingPositionHelper::isPercentY() const
 638 {
 639     return m_aScales[1].AxisType==AxisType::PERCENT;
 640 }
 641
 642 double PlottingPositionHelper::getBaseValueY() const
 643 {
 644     return m_aScales[1].Origin;
 645 }
 646
 647 /*
 648 // ____ XTransformation ____
 649 uno::Sequence< double > SAL_CALL PolarPlottingPositionHelper::transform(
 650                         const uno::Sequence< double >& rSourceValues )
 651             throw (uno::RuntimeException, lang::IllegalArgumentException)
 652 {
 653     uno::Sequence< double > aSourceValues(3);
 654     return aSourceValues;
 655 }
 656
 657 sal_Int32 SAL_CALL PolarPlottingPositionHelper::getSourceDimension() throw (uno::RuntimeException)
 658 {
 659     return 3;
 660 }
 661
 662 sal_Int32 SAL_CALL PolarPlottingPositionHelper::getTargetDimension() throw (uno::RuntimeException)
 663 {
 664     return 3;
 665 }
 666 */
 667
 668 //.............................................................................
 669 } //namespace chart
 670 //.............................................................................