chart2/source/view/charttypes/AreaChart.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 "AreaChart.hxx"
  21 #include <PlottingPositionHelper.hxx>
  22 #include <ShapeFactory.hxx>
  23 #include <CommonConverters.hxx>
  24 #include <ExplicitCategoriesProvider.hxx>
  25 #include <ObjectIdentifier.hxx>
  26 #include "Splines.hxx"
  27 #include <ChartTypeHelper.hxx>
  28 #include <LabelPositionHelper.hxx>
  29 #include <Clipping.hxx>
  30 #include <Stripe.hxx>
  31 #include <DateHelper.hxx>
  32 #include <unonames.hxx>
  33 #include <ConfigAccess.hxx>
  34
  35 #include <com/sun/star/chart2/Symbol.hpp>
  36 #include <com/sun/star/chart/DataLabelPlacement.hpp>
  37 #include <com/sun/star/chart/MissingValueTreatment.hpp>
  38
  39 #include <rtl/math.hxx>
  40 #include <sal/log.hxx>
  41 #include <osl/diagnose.h>
  42
  43 #include <com/sun/star/drawing/DoubleSequence.hpp>
  44 #include <com/sun/star/drawing/XShapes.hpp>
  45 #include <com/sun/star/beans/XPropertySet.hpp>
  46
  47 namespace chart
  48 {
  49 using namespace ::com::sun::star;
  50 using namespace ::rtl::math;
  51 using namespace ::com::sun::star::chart2;
  52
  53 AreaChart::AreaChart( const uno::Reference<XChartType>& xChartTypeModel
  54                      , sal_Int32 nDimensionCount
  55                      , bool bCategoryXAxis
  56                      , bool bNoArea
  57                      )
  58         : VSeriesPlotter( xChartTypeModel, nDimensionCount, bCategoryXAxis )
  59         , m_pMainPosHelper(new PlottingPositionHelper())
  60         , m_bArea(!bNoArea)
  61         , m_bLine(bNoArea)
  62         , m_bSymbol( ChartTypeHelper::isSupportingSymbolProperties(xChartTypeModel,nDimensionCount) )
  63         , m_eCurveStyle(CurveStyle_LINES)
  64         , m_nCurveResolution(20)
  65         , m_nSplineOrder(3)
  66 {
  67     m_pMainPosHelper->AllowShiftXAxisPos(true);
  68     m_pMainPosHelper->AllowShiftZAxisPos(true);
  69
  70     PlotterBase::m_pPosHelper = m_pMainPosHelper.get();
  71     VSeriesPlotter::m_pMainPosHelper = m_pMainPosHelper.get();
  72
  73     try
  74     {
  75         if( m_xChartTypeModelProps.is() )
  76         {
  77             m_xChartTypeModelProps->getPropertyValue(CHART_UNONAME_CURVE_STYLE) >>= m_eCurveStyle;
  78             m_xChartTypeModelProps->getPropertyValue(CHART_UNONAME_CURVE_RESOLUTION) >>= m_nCurveResolution;
  79             m_xChartTypeModelProps->getPropertyValue(CHART_UNONAME_SPLINE_ORDER) >>= m_nSplineOrder;
  80         }
  81     }
  82     catch( uno::Exception& e )
  83     {
  84         //the above properties are not supported by all charttypes supported by this class (e.g. area or net chart)
  85         //in that cases this exception is ok
  86         e.Context.is();//to have debug information without compilation warnings
  87     }
  88 }
  89
  90 AreaChart::~AreaChart()
  91 {
  92 }
  93
  94 bool AreaChart::isSeparateStackingForDifferentSigns( sal_Int32 /*nDimensionIndex*/ )
  95 {
  96     // no separate stacking in all types of line/area charts
  97     return false;
  98 }
  99
 100 LegendSymbolStyle AreaChart::getLegendSymbolStyle()
 101 {
 102     if( m_bArea || m_nDimension == 3 )
 103         return LegendSymbolStyle::Box;
 104     return LegendSymbolStyle::Line;
 105 }
 106
 107 uno::Any AreaChart::getExplicitSymbol( const VDataSeries& rSeries, sal_Int32 nPointIndex )
 108 {
 109     uno::Any aRet;
 110
 111     Symbol* pSymbolProperties = rSeries.getSymbolProperties( nPointIndex );
 112     if( pSymbolProperties )
 113     {
 114         aRet <<= *pSymbolProperties;
 115     }
 116
 117     return aRet;
 118 }
 119
 120 drawing::Direction3D AreaChart::getPreferredDiagramAspectRatio() const
 121 {
 122     drawing::Direction3D aRet(1,-1,1);
 123     if( m_nDimension == 2 )
 124         aRet = drawing::Direction3D(-1,-1,-1);
 125     else if (m_pPosHelper)
 126     {
 127         drawing::Direction3D aScale( m_pPosHelper->getScaledLogicWidth() );
 128         aRet.DirectionZ = aScale.DirectionZ*0.2;
 129         if(aRet.DirectionZ>1.0)
 130             aRet.DirectionZ=1.0;
 131         if(aRet.DirectionZ>10)
 132             aRet.DirectionZ=10;
 133     }
 134     return aRet;
 135 }
 136
 137 void AreaChart::addSeries( std::unique_ptr<VDataSeries> pSeries, sal_Int32 zSlot, sal_Int32 xSlot, sal_Int32 ySlot )
 138 {
 139     if( m_bArea && pSeries )
 140     {
 141         sal_Int32 nMissingValueTreatment = pSeries->getMissingValueTreatment();
 142         if( nMissingValueTreatment == css::chart::MissingValueTreatment::LEAVE_GAP  )
 143             pSeries->setMissingValueTreatment( css::chart::MissingValueTreatment::USE_ZERO );
 144     }
 145     if( m_nDimension == 3 && !m_bCategoryXAxis )
 146     {
 147         //3D xy always deep
 148         OSL_ENSURE( zSlot==-1,"3D xy charts should be deep stacked in model also" );
 149         zSlot=-1;
 150         xSlot=0;
 151         ySlot=0;
 152     }
 153     VSeriesPlotter::addSeries( std::move(pSeries), zSlot, xSlot, ySlot );
 154 }
 155
 156 static void lcl_removeDuplicatePoints( drawing::PolyPolygonShape3D& rPolyPoly, PlottingPositionHelper& rPosHelper )
 157 {
 158     sal_Int32 nPolyCount = rPolyPoly.SequenceX.getLength();
 159     if(!nPolyCount)
 160         return;
 161
 162     drawing::PolyPolygonShape3D aTmp;
 163     aTmp.SequenceX.realloc(nPolyCount);
 164     aTmp.SequenceY.realloc(nPolyCount);
 165     aTmp.SequenceZ.realloc(nPolyCount);
 166
 167     for( sal_Int32 nPolygonIndex = 0; nPolygonIndex<nPolyCount; nPolygonIndex++ )
 168     {
 169         drawing::DoubleSequence* pOuterSourceX = &rPolyPoly.SequenceX.getArray()[nPolygonIndex];
 170         drawing::DoubleSequence* pOuterSourceY = &rPolyPoly.SequenceY.getArray()[nPolygonIndex];
 171         drawing::DoubleSequence* pOuterSourceZ = &rPolyPoly.SequenceZ.getArray()[nPolygonIndex];
 172
 173         drawing::DoubleSequence* pOuterTargetX = &aTmp.SequenceX.getArray()[nPolygonIndex];
 174         drawing::DoubleSequence* pOuterTargetY = &aTmp.SequenceY.getArray()[nPolygonIndex];
 175         drawing::DoubleSequence* pOuterTargetZ = &aTmp.SequenceZ.getArray()[nPolygonIndex];
 176
 177         sal_Int32 nPointCount = pOuterSourceX->getLength();
 178         if( !nPointCount )
 179             continue;
 180
 181         pOuterTargetX->realloc(nPointCount);
 182         pOuterTargetY->realloc(nPointCount);
 183         pOuterTargetZ->realloc(nPointCount);
 184
 185         double* pSourceX = pOuterSourceX->getArray();
 186         double* pSourceY = pOuterSourceY->getArray();
 187         double* pSourceZ = pOuterSourceZ->getArray();
 188
 189         double* pTargetX = pOuterTargetX->getArray();
 190         double* pTargetY = pOuterTargetY->getArray();
 191         double* pTargetZ = pOuterTargetZ->getArray();
 192
 193         //copy first point
 194         *pTargetX=*pSourceX++;
 195         *pTargetY=*pSourceY++;
 196         *pTargetZ=*pSourceZ++;
 197         sal_Int32 nTargetPointCount=1;
 198
 199         for( sal_Int32 nSource=1; nSource<nPointCount; nSource++ )
 200         {
 201             if( !rPosHelper.isSameForGivenResolution( *pTargetX, *pTargetY, *pTargetZ
 202                                                    , *pSourceX, *pSourceY, *pSourceZ ) )
 203             {
 204                 pTargetX++; pTargetY++; pTargetZ++;
 205                 *pTargetX=*pSourceX;
 206                 *pTargetY=*pSourceY;
 207                 *pTargetZ=*pSourceZ;
 208                 nTargetPointCount++;
 209             }
 210             pSourceX++; pSourceY++; pSourceZ++;
 211         }
 212
 213         //free unused space
 214         if( nTargetPointCount<nPointCount )
 215         {
 216             pOuterTargetX->realloc(nTargetPointCount);
 217             pOuterTargetY->realloc(nTargetPointCount);
 218             pOuterTargetZ->realloc(nTargetPointCount);
 219         }
 220
 221         pOuterSourceX->realloc(0);
 222         pOuterSourceY->realloc(0);
 223         pOuterSourceZ->realloc(0);
 224     }
 225
 226     //free space
 227     rPolyPoly.SequenceX.realloc(nPolyCount);
 228     rPolyPoly.SequenceY.realloc(nPolyCount);
 229     rPolyPoly.SequenceZ.realloc(nPolyCount);
 230
 231     rPolyPoly=aTmp;
 232 }
 233
 234 bool AreaChart::create_stepped_line( drawing::PolyPolygonShape3D aStartPoly, chart2::CurveStyle eCurveStyle, PlottingPositionHelper const * pPosHelper, drawing::PolyPolygonShape3D &aPoly )
 235 {
 236     sal_uInt32 nOuterCount = aStartPoly.SequenceX.getLength();
 237     if ( !nOuterCount )
 238         return false;
 239
 240     drawing::PolyPolygonShape3D aSteppedPoly;
 241     aSteppedPoly.SequenceX.realloc(nOuterCount);
 242     aSteppedPoly.SequenceY.realloc(nOuterCount);
 243     aSteppedPoly.SequenceZ.realloc(nOuterCount);
 244
 245     for( sal_uInt32 nOuter = 0; nOuter < nOuterCount; ++nOuter )
 246     {
 247         if( aStartPoly.SequenceX[nOuter].getLength() <= 1 )
 248             continue; //we need at least two points
 249
 250         sal_uInt32 nMaxIndexPoints = aStartPoly.SequenceX[nOuter].getLength()-1; // is >1
 251         sal_uInt32 nNewIndexPoints = 0;
 252         if ( eCurveStyle==CurveStyle_STEP_START || eCurveStyle==CurveStyle_STEP_END)
 253             nNewIndexPoints = nMaxIndexPoints * 2 + 1;
 254         else
 255             nNewIndexPoints = nMaxIndexPoints * 3 + 1;
 256
 257         const double* pOldX = aStartPoly.SequenceX[nOuter].getConstArray();
 258         const double* pOldY = aStartPoly.SequenceY[nOuter].getConstArray();
 259         const double* pOldZ = aStartPoly.SequenceZ[nOuter].getConstArray();
 260
 261         aSteppedPoly.SequenceX[nOuter].realloc( nNewIndexPoints );
 262         aSteppedPoly.SequenceY[nOuter].realloc( nNewIndexPoints );
 263         aSteppedPoly.SequenceZ[nOuter].realloc( nNewIndexPoints );
 264
 265         double* pNewX = aSteppedPoly.SequenceX[nOuter].getArray();
 266         double* pNewY = aSteppedPoly.SequenceY[nOuter].getArray();
 267         double* pNewZ = aSteppedPoly.SequenceZ[nOuter].getArray();
 268
 269         pNewX[0] = pOldX[0];
 270         pNewY[0] = pOldY[0];
 271         pNewZ[0] = pOldZ[0];
 272         for( sal_uInt32 oi = 0; oi < nMaxIndexPoints; oi++ )
 273         {
 274             switch ( eCurveStyle )
 275             {
 276                 case CurveStyle_STEP_START:
 277                      /**           O
 278                                    |
 279                                    |
 280                                    |
 281                              O-----+
 282                      */
 283                     // create the intermediate point
 284                     pNewX[1+oi*2] = pOldX[oi+1];
 285                     pNewY[1+oi*2] = pOldY[oi];
 286                     pNewZ[1+oi*2] = pOldZ[oi];
 287                     // and now the normal one
 288                     pNewX[1+oi*2+1] = pOldX[oi+1];
 289                     pNewY[1+oi*2+1] = pOldY[oi+1];
 290                     pNewZ[1+oi*2+1] = pOldZ[oi+1];
 291                     break;
 292                 case CurveStyle_STEP_END:
 293                      /**    +------O
 294                             |
 295                             |
 296                             |
 297                             O
 298                      */
 299                     // create the intermediate point
 300                     pNewX[1+oi*2] = pOldX[oi];
 301                     pNewY[1+oi*2] = pOldY[oi+1];
 302                     pNewZ[1+oi*2] = pOldZ[oi];
 303                     // and now the normal one
 304                     pNewX[1+oi*2+1] = pOldX[oi+1];
 305                     pNewY[1+oi*2+1] = pOldY[oi+1];
 306                     pNewZ[1+oi*2+1] = pOldZ[oi+1];
 307                     break;
 308                 case CurveStyle_STEP_CENTER_X:
 309                      /**        +--O
 310                                 |
 311                                 |
 312                                 |
 313                              O--+
 314                      */
 315                     // create the first intermediate point
 316                     pNewX[1+oi*3] = (pOldX[oi]+pOldX[oi+1])/2;
 317                     pNewY[1+oi*3] = pOldY[oi];
 318                     pNewZ[1+oi*3] = pOldZ[oi];
 319                     // create the second intermediate point
 320                     pNewX[1+oi*3+1] = (pOldX[oi]+pOldX[oi+1])/2;
 321                     pNewY[1+oi*3+1] = pOldY[oi+1];
 322                     pNewZ[1+oi*3+1] = pOldZ[oi];
 323                     // and now the normal one
 324                     pNewX[1+oi*3+2] = pOldX[oi+1];
 325                     pNewY[1+oi*3+2] = pOldY[oi+1];
 326                     pNewZ[1+oi*3+2] = pOldZ[oi+1];
 327                     break;
 328                 case CurveStyle_STEP_CENTER_Y:
 329                      /**           O
 330                                    |
 331                              +-----+
 332                              |
 333                              O
 334                      */
 335                     // create the first intermediate point
 336                     pNewX[1+oi*3] = pOldX[oi];
 337                     pNewY[1+oi*3] = (pOldY[oi]+pOldY[oi+1])/2;
 338                     pNewZ[1+oi*3] = pOldZ[oi];
 339                     // create the second intermediate point
 340                     pNewX[1+oi*3+1] = pOldX[oi+1];
 341                     pNewY[1+oi*3+1] = (pOldY[oi]+pOldY[oi+1])/2;
 342                     pNewZ[1+oi*3+1] = pOldZ[oi];
 343                     // and now the normal one
 344                     pNewX[1+oi*3+2] = pOldX[oi+1];
 345                     pNewY[1+oi*3+2] = pOldY[oi+1];
 346                     pNewZ[1+oi*3+2] = pOldZ[oi+1];
 347                     break;
 348                 default:
 349                     // this should never be executed
 350                     OSL_FAIL("Unknown curvestyle in AreaChart::create_stepped_line");
 351             }
 352         }
 353     }
 354     Clipping::clipPolygonAtRectangle( aSteppedPoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
 355
 356     return true;
 357 }
 358
 359 bool AreaChart::impl_createLine( VDataSeries* pSeries
 360                 , drawing::PolyPolygonShape3D const * pSeriesPoly
 361                 , PlottingPositionHelper* pPosHelper )
 362 {
 363     //return true if a line was created successfully
 364     uno::Reference< drawing::XShapes > xSeriesGroupShape_Shapes = getSeriesGroupShapeBackChild(pSeries, m_xSeriesTarget);
 365
 366     drawing::PolyPolygonShape3D aPoly;
 367     if(m_eCurveStyle==CurveStyle_CUBIC_SPLINES)
 368     {
 369         drawing::PolyPolygonShape3D aSplinePoly;
 370         SplineCalculater::CalculateCubicSplines( *pSeriesPoly, aSplinePoly, m_nCurveResolution );
 371         lcl_removeDuplicatePoints( aSplinePoly, *pPosHelper );
 372         Clipping::clipPolygonAtRectangle( aSplinePoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
 373     }
 374     else if(m_eCurveStyle==CurveStyle_B_SPLINES)
 375     {
 376         drawing::PolyPolygonShape3D aSplinePoly;
 377         SplineCalculater::CalculateBSplines( *pSeriesPoly, aSplinePoly, m_nCurveResolution, m_nSplineOrder );
 378         lcl_removeDuplicatePoints( aSplinePoly, *pPosHelper );
 379         Clipping::clipPolygonAtRectangle( aSplinePoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
 380     }
 381     else if (m_eCurveStyle==CurveStyle_STEP_START ||
 382              m_eCurveStyle==CurveStyle_STEP_END ||
 383              m_eCurveStyle==CurveStyle_STEP_CENTER_Y ||
 384              m_eCurveStyle==CurveStyle_STEP_CENTER_X
 385             )
 386     {
 387         if (!create_stepped_line(*pSeriesPoly, m_eCurveStyle, pPosHelper, aPoly))
 388         {
 389             return false;
 390         }
 391     }
 392     else
 393     { // default to creating a straight line
 394         SAL_WARN_IF(m_eCurveStyle != CurveStyle_LINES, "chart2.areachart", "Unknown curve style");
 395         Clipping::clipPolygonAtRectangle( *pSeriesPoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
 396     }
 397
 398     if(!ShapeFactory::hasPolygonAnyLines(aPoly))
 399         return false;
 400
 401     //transformation 3) -> 4)
 402     pPosHelper->transformScaledLogicToScene( aPoly );
 403
 404     //create line:
 405     uno::Reference< drawing::XShape > xShape;
 406     if(m_nDimension==3)
 407     {
 408         double fDepth = getTransformedDepth();
 409         sal_Int32 nPolyCount = aPoly.SequenceX.getLength();
 410         for(sal_Int32 nPoly=0;nPoly<nPolyCount;nPoly++)
 411         {
 412             sal_Int32 nPointCount = aPoly.SequenceX[nPoly].getLength();
 413             for(sal_Int32 nPoint=0;nPoint<nPointCount-1;nPoint++)
 414             {
 415                 drawing::Position3D aPoint1, aPoint2;
 416                 aPoint1.PositionX = aPoly.SequenceX[nPoly][nPoint+1];
 417                 aPoint1.PositionY = aPoly.SequenceY[nPoly][nPoint+1];
 418                 aPoint1.PositionZ = aPoly.SequenceZ[nPoly][nPoint+1];
 419
 420                 aPoint2.PositionX = aPoly.SequenceX[nPoly][nPoint];
 421                 aPoint2.PositionY = aPoly.SequenceY[nPoly][nPoint];
 422                 aPoint2.PositionZ = aPoly.SequenceZ[nPoly][nPoint];
 423
 424                 m_pShapeFactory->createStripe(xSeriesGroupShape_Shapes
 425                     , Stripe( aPoint1, aPoint2, fDepth )
 426                     , pSeries->getPropertiesOfSeries(), PropertyMapper::getPropertyNameMapForFilledSeriesProperties(), true, 1 );
 427             }
 428         }
 429     }
 430     else //m_nDimension!=3
 431     {
 432         xShape = m_pShapeFactory->createLine2D( xSeriesGroupShape_Shapes
 433                 , PolyToPointSequence( aPoly ) );
 434         setMappedProperties( xShape
 435                 , pSeries->getPropertiesOfSeries()
 436                 , PropertyMapper::getPropertyNameMapForLineSeriesProperties() );
 437         //because of this name this line will be used for marking
 438         ::chart::ShapeFactory::setShapeName(xShape, "MarkHandles");
 439     }
 440     return true;
 441 }
 442
 443 bool AreaChart::impl_createArea( VDataSeries* pSeries
 444                 , drawing::PolyPolygonShape3D const * pSeriesPoly
 445                 , drawing::PolyPolygonShape3D const * pPreviousSeriesPoly
 446                 , PlottingPositionHelper const * pPosHelper )
 447 {
 448     //return true if an area was created successfully
 449
 450     uno::Reference< drawing::XShapes > xSeriesGroupShape_Shapes = getSeriesGroupShapeBackChild(pSeries, m_xSeriesTarget);
 451     double zValue = pSeries->m_fLogicZPos;
 452
 453     drawing::PolyPolygonShape3D aPoly( *pSeriesPoly );
 454     //add second part to the polygon (grounding points or previous series points)
 455     if(!pPreviousSeriesPoly)
 456     {
 457         double fMinX = pSeries->m_fLogicMinX;
 458         double fMaxX = pSeries->m_fLogicMaxX;
 459         double fY = pPosHelper->getBaseValueY();//logic grounding
 460         if( m_nDimension==3 )
 461             fY = pPosHelper->getLogicMinY();
 462
 463         //clip to scale
 464         if(fMaxX<pPosHelper->getLogicMinX() || fMinX>pPosHelper->getLogicMaxX())
 465             return false;//no visible shape needed
 466         pPosHelper->clipLogicValues( &fMinX, &fY, nullptr );
 467         pPosHelper->clipLogicValues( &fMaxX, nullptr, nullptr );
 468
 469         //apply scaling
 470         {
 471             pPosHelper->doLogicScaling( &fMinX, &fY, &zValue );
 472             pPosHelper->doLogicScaling( &fMaxX, nullptr, nullptr );
 473         }
 474
 475         AddPointToPoly( aPoly, drawing::Position3D( fMaxX,fY,zValue) );
 476         AddPointToPoly( aPoly, drawing::Position3D( fMinX,fY,zValue) );
 477     }
 478     else
 479     {
 480         appendPoly( aPoly, *pPreviousSeriesPoly );
 481     }
 482     ShapeFactory::closePolygon(aPoly);
 483
 484     //apply clipping
 485     {
 486         drawing::PolyPolygonShape3D aClippedPoly;
 487         Clipping::clipPolygonAtRectangle( aPoly, pPosHelper->getScaledLogicClipDoubleRect(), aClippedPoly, false );
 488         ShapeFactory::closePolygon(aClippedPoly); //again necessary after clipping
 489         aPoly = aClippedPoly;
 490     }
 491
 492     if(!ShapeFactory::hasPolygonAnyLines(aPoly))
 493         return false;
 494
 495     //transformation 3) -> 4)
 496     pPosHelper->transformScaledLogicToScene( aPoly );
 497
 498     //create area:
 499     uno::Reference< drawing::XShape > xShape;
 500     if(m_nDimension==3)
 501     {
 502         xShape = m_pShapeFactory->createArea3D( xSeriesGroupShape_Shapes
 503                 , aPoly, getTransformedDepth() );
 504     }
 505     else //m_nDimension!=3
 506     {
 507         xShape = m_pShapeFactory->createArea2D( xSeriesGroupShape_Shapes
 508                 , aPoly );
 509     }
 510     setMappedProperties( xShape
 511                 , pSeries->getPropertiesOfSeries()
 512                 , PropertyMapper::getPropertyNameMapForFilledSeriesProperties() );
 513     //because of this name this line will be used for marking
 514     ::chart::ShapeFactory::setShapeName(xShape, "MarkHandles");
 515     return true;
 516 }
 517
 518 void AreaChart::impl_createSeriesShapes()
 519 {
 520     //the polygon shapes for each series need to be created before
 521
 522     //iterate through all series again to create the series shapes
 523     for( auto const& rZSlot : m_aZSlots )
 524     {
 525         for( auto const& rXSlot : rZSlot )
 526         {
 527             std::map< sal_Int32, drawing::PolyPolygonShape3D* > aPreviousSeriesPolyMap;//a PreviousSeriesPoly for each different nAttachedAxisIndex
 528             drawing::PolyPolygonShape3D* pSeriesPoly = nullptr;
 529
 530             //iterate through all series
 531             for( std::unique_ptr<VDataSeries> const & pSeries : rXSlot.m_aSeriesVector )
 532             {
 533                 sal_Int32 nAttachedAxisIndex = pSeries->getAttachedAxisIndex();
 534                 PlottingPositionHelper& rPosHelper = getPlottingPositionHelper(nAttachedAxisIndex);
 535                 m_pPosHelper = &rPosHelper;
 536
 537                 createRegressionCurvesShapes( *pSeries, m_xErrorBarTarget, m_xRegressionCurveEquationTarget,
 538                                               m_pPosHelper->maySkipPointsInRegressionCalculation());
 539
 540                 pSeriesPoly = &pSeries->m_aPolyPolygonShape3D;
 541                 if( m_bArea )
 542                 {
 543                     if (!impl_createArea(pSeries.get(), pSeriesPoly,
 544                                          aPreviousSeriesPolyMap[nAttachedAxisIndex], &rPosHelper))
 545                         continue;
 546                 }
 547                 if( m_bLine )
 548                 {
 549                     if (!impl_createLine(pSeries.get(), pSeriesPoly, &rPosHelper))
 550                         continue;
 551                 }
 552                 aPreviousSeriesPolyMap[nAttachedAxisIndex] = pSeriesPoly;
 553             }//next series in x slot (next y slot)
 554         }//next x slot
 555     }//next z slot
 556 }
 557
 558 namespace
 559 {
 560
 561 void lcl_reorderSeries( std::vector< std::vector< VDataSeriesGroup > >&  rZSlots )
 562 {
 563     std::vector< std::vector< VDataSeriesGroup > >  aRet;
 564     aRet.reserve( rZSlots.size() );
 565
 566     std::vector< std::vector< VDataSeriesGroup > >::reverse_iterator aZIt( rZSlots.rbegin() );
 567     std::vector< std::vector< VDataSeriesGroup > >::reverse_iterator aZEnd( rZSlots.rend() );
 568     for( ; aZIt != aZEnd; ++aZIt )
 569     {
 570         std::vector< VDataSeriesGroup > aXSlot;
 571         aXSlot.reserve( aZIt->size() );
 572
 573         std::vector< VDataSeriesGroup >::reverse_iterator aXIt( aZIt->rbegin() );
 574         std::vector< VDataSeriesGroup >::reverse_iterator aXEnd( aZIt->rend() );
 575         for( ; aXIt != aXEnd; ++aXIt )
 576             aXSlot.push_back(std::move(*aXIt));
 577
 578         aRet.push_back(std::move(aXSlot));
 579     }
 580
 581     rZSlots = std::move(aRet);
 582 }
 583
 584 }//anonymous namespace
 585
 586 //better performance for big data
 587 struct FormerPoint
 588 {
 589     FormerPoint( double fX, double fY, double fZ )
 590         : m_fX(fX), m_fY(fY), m_fZ(fZ)
 591         {}
 592     FormerPoint()
 593     {
 594         ::rtl::math::setNan( &m_fX );
 595         ::rtl::math::setNan( &m_fY );
 596         ::rtl::math::setNan( &m_fZ );
 597     }
 598
 599     double m_fX;
 600     double m_fY;
 601     double m_fZ;
 602 };
 603
 604 void AreaChart::createShapes()
 605 {
 606     if( m_aZSlots.empty() ) //no series
 607         return;
 608
 609     if( m_nDimension == 2 && ( m_bArea || !m_bCategoryXAxis ) )
 610         lcl_reorderSeries( m_aZSlots );
 611
 612     OSL_ENSURE(m_pShapeFactory&&m_xLogicTarget.is()&&m_xFinalTarget.is(),"AreaChart is not proper initialized");
 613     if(!(m_pShapeFactory&&m_xLogicTarget.is()&&m_xFinalTarget.is()))
 614         return;
 615
 616     //the text labels should be always on top of the other series shapes
 617     //for area chart the error bars should be always on top of the other series shapes
 618
 619     //therefore create an own group for the texts and the error bars to move them to front
 620     //(because the text group is created after the series group the texts are displayed on top)
 621     m_xSeriesTarget   = createGroupShape( m_xLogicTarget );
 622     if( m_bArea )
 623         m_xErrorBarTarget = createGroupShape( m_xLogicTarget );
 624     else
 625         m_xErrorBarTarget = m_xSeriesTarget;
 626     m_xTextTarget     = m_pShapeFactory->createGroup2D( m_xFinalTarget );
 627     m_xRegressionCurveEquationTarget = m_pShapeFactory->createGroup2D( m_xFinalTarget );
 628
 629     //check necessary here that different Y axis can not be stacked in the same group? ... hm?
 630
 631     //update/create information for current group
 632     double fLogicZ        = 1.0;//as defined
 633
 634     sal_Int32 nStartIndex = 0; // inclusive       ;..todo get somehow from x scale
 635     sal_Int32 nEndIndex = VSeriesPlotter::getPointCount();
 636     if(nEndIndex<=0)
 637         nEndIndex=1;
 638
 639     //better performance for big data
 640     std::map< VDataSeries*, FormerPoint > aSeriesFormerPointMap;
 641     m_bPointsWereSkipped = false;
 642     sal_Int32 nSkippedPoints = 0;
 643     sal_Int32 nCreatedPoints = 0;
 644
 645     bool bDateCategory = (m_pExplicitCategoriesProvider && m_pExplicitCategoriesProvider->isDateAxis());
 646
 647     std::vector<std::map< sal_Int32, double > > aLogicYSumMapByX(nEndIndex);//one for each different nAttachedAxisIndex
 648     for( auto const& rZSlot : m_aZSlots )
 649     {
 650         //iterate through all x slots in this category to get 100percent sum
 651         for( auto const& rXSlot : rZSlot )
 652         {
 653             for( std::unique_ptr<VDataSeries> const & pSeries : rXSlot.m_aSeriesVector )
 654             {
 655                 if(!pSeries)
 656                     continue;
 657
 658                 if (bDateCategory)
 659                     pSeries->doSortByXValues();
 660
 661                 for( sal_Int32 nIndex = nStartIndex; nIndex < nEndIndex; nIndex++ )
 662                 {
 663                     std::map< sal_Int32, double >& rLogicYSumMap = aLogicYSumMapByX[nIndex];
 664                     sal_Int32 nAttachedAxisIndex = pSeries->getAttachedAxisIndex();
 665                     if( rLogicYSumMap.find(nAttachedAxisIndex)==rLogicYSumMap.end() )
 666                         rLogicYSumMap[nAttachedAxisIndex]=0.0;
 667
 668                     m_pPosHelper = &getPlottingPositionHelper(nAttachedAxisIndex);
 669
 670                     double fAdd = pSeries->getYValue( nIndex );
 671                     if( !::rtl::math::isNan(fAdd) && !::rtl::math::isInf(fAdd) )
 672                         rLogicYSumMap[nAttachedAxisIndex] += fabs( fAdd );
 673                 }
 674             }
 675         }
 676     }
 677
 678     sal_Int32 nZ=1;
 679     for( auto const& rZSlot : m_aZSlots )
 680     {
 681         //for the area chart there should be at most one x slot (no side by side stacking available)
 682         //attention different: xSlots are always interpreted as independent areas one behind the other: @todo this doesn't work why not???
 683         for( auto const& rXSlot : rZSlot )
 684         {
 685             std::vector<std::map< sal_Int32, double > > aLogicYForNextSeriesMapByX(nEndIndex); //one for each different nAttachedAxisIndex
 686             //iterate through all series
 687             for( std::unique_ptr<VDataSeries> const & pSeries : rXSlot.m_aSeriesVector )
 688             {
 689                 if(!pSeries)
 690                     continue;
 691
 692                 uno::Reference< drawing::XShapes > xSeriesGroupShape_Shapes = getSeriesGroupShapeFrontChild(pSeries.get(), m_xSeriesTarget);
 693
 694                 sal_Int32 nAttachedAxisIndex = pSeries->getAttachedAxisIndex();
 695                 PlottingPositionHelper& rPosHelper = getPlottingPositionHelper(nAttachedAxisIndex);
 696                 m_pPosHelper = &rPosHelper;
 697
 698                 if(m_nDimension==3)
 699                     fLogicZ = nZ+0.5;
 700                 pSeries->m_fLogicZPos = fLogicZ;
 701
 702                 for( sal_Int32 nIndex = nStartIndex; nIndex < nEndIndex; nIndex++ )
 703                 {
 704
 705                     /*  #i70133# ignore points outside of series length in standard area
 706                         charts. Stacked area charts will use missing points as zeros. In
 707                         standard charts, pSeriesList contains only one series. */
 708                     if( m_bArea && (rXSlot.m_aSeriesVector.size() == 1) && (nIndex >= pSeries->getTotalPointCount()) )
 709                         continue;
 710
 711                     //collect data point information (logic coordinates, style ):
 712                     double fLogicX = pSeries->getXValue(nIndex);
 713                     if (bDateCategory)
 714                     {
 715                         if (rtl::math::isNan(fLogicX))
 716                             continue;
 717
 718                         fLogicX = DateHelper::RasterizeDateValue( fLogicX, m_aNullDate, m_nTimeResolution );
 719                     }
 720                     double fLogicY = pSeries->getYValue(nIndex);
 721
 722                     if( m_nDimension==3 && m_bArea && rXSlot.m_aSeriesVector.size()!=1 )
 723                         fLogicY = fabs( fLogicY );
 724
 725                     std::map< sal_Int32, double >& rLogicYSumMap = aLogicYSumMapByX[nIndex];
 726                     if (rPosHelper.isPercentY() && rLogicYSumMap[nAttachedAxisIndex] != 0.0)
 727                     {
 728                         fLogicY = fabs( fLogicY )/rLogicYSumMap[nAttachedAxisIndex];
 729                     }
 730
 731                     if(    ::rtl::math::isNan(fLogicX) || ::rtl::math::isInf(fLogicX)
 732                             || ::rtl::math::isNan(fLogicY) || ::rtl::math::isInf(fLogicY)
 733                             || ::rtl::math::isNan(fLogicZ) || ::rtl::math::isInf(fLogicZ) )
 734                     {
 735                         if( pSeries->getMissingValueTreatment() == css::chart::MissingValueTreatment::LEAVE_GAP )
 736                         {
 737                             drawing::PolyPolygonShape3D& rPolygon = pSeries->m_aPolyPolygonShape3D;
 738                             sal_Int32& rIndex = pSeries->m_nPolygonIndex;
 739                             if( 0<= rIndex && rIndex < rPolygon.SequenceX.getLength() )
 740                             {
 741                                 if( rPolygon.SequenceX[ rIndex ].hasElements() )
 742                                     rIndex++; //start a new polygon for the next point if the current poly is not empty
 743                             }
 744                         }
 745                         continue;
 746                     }
 747
 748                     std::map< sal_Int32, double >& rLogicYForNextSeriesMap = aLogicYForNextSeriesMapByX[nIndex];
 749                     if( rLogicYForNextSeriesMap.find(nAttachedAxisIndex) == rLogicYForNextSeriesMap.end() )
 750                         rLogicYForNextSeriesMap[nAttachedAxisIndex] = 0.0;
 751
 752                     double fLogicValueForLabeDisplay = fLogicY;
 753
 754                     fLogicY += rLogicYForNextSeriesMap[nAttachedAxisIndex];
 755                     rLogicYForNextSeriesMap[nAttachedAxisIndex] = fLogicY;
 756
 757                     bool bIsVisible = rPosHelper.isLogicVisible(fLogicX, fLogicY, fLogicZ);
 758
 759                     //remind minimal and maximal x values for area 'grounding' points
 760                     //only for filled area
 761                     {
 762                         double& rfMinX = pSeries->m_fLogicMinX;
 763                         if(!nIndex||fLogicX<rfMinX)
 764                             rfMinX=fLogicX;
 765                         double& rfMaxX = pSeries->m_fLogicMaxX;
 766                         if(!nIndex||fLogicX>rfMaxX)
 767                             rfMaxX=fLogicX;
 768                     }
 769
 770                     drawing::Position3D aUnscaledLogicPosition( fLogicX, fLogicY, fLogicZ );
 771                     drawing::Position3D aScaledLogicPosition(aUnscaledLogicPosition);
 772                     rPosHelper.doLogicScaling(aScaledLogicPosition);
 773
 774                     //transformation 3) -> 4)
 775                     drawing::Position3D aScenePosition(
 776                         rPosHelper.transformLogicToScene(fLogicX, fLogicY, fLogicZ, false));
 777
 778                     //better performance for big data
 779                     FormerPoint aFormerPoint( aSeriesFormerPointMap[pSeries.get()] );
 780                     rPosHelper.setCoordinateSystemResolution(m_aCoordinateSystemResolution);
 781                     if (!pSeries->isAttributedDataPoint(nIndex)
 782                         && rPosHelper.isSameForGivenResolution(
 783                                aFormerPoint.m_fX, aFormerPoint.m_fY, aFormerPoint.m_fZ,
 784                                aScaledLogicPosition.PositionX, aScaledLogicPosition.PositionY,
 785                                aScaledLogicPosition.PositionZ))
 786                     {
 787                         ++nSkippedPoints;
 788                         m_bPointsWereSkipped = true;
 789                         continue;
 790                     }
 791                     aSeriesFormerPointMap[pSeries.get()] = FormerPoint(aScaledLogicPosition.PositionX, aScaledLogicPosition.PositionY, aScaledLogicPosition.PositionZ);
 792
 793                     //store point information for series polygon
 794                     //for area and/or line (symbols only do not need this)
 795                     if( isValidPosition(aScaledLogicPosition) )
 796                     {
 797                         AddPointToPoly( pSeries->m_aPolyPolygonShape3D, aScaledLogicPosition, pSeries->m_nPolygonIndex );
 798                     }
 799
 800                     //create a single datapoint if point is visible
 801                     //apply clipping:
 802                     if( !bIsVisible )
 803                         continue;
 804
 805                     bool bCreateYErrorBar = false, bCreateXErrorBar = false;
 806                     {
 807                         uno::Reference< beans::XPropertySet > xErrorBarProp(pSeries->getYErrorBarProperties(nIndex));
 808                         if( xErrorBarProp.is() )
 809                         {
 810                             bool bShowPositive = false;
 811                             bool bShowNegative = false;
 812                             xErrorBarProp->getPropertyValue("ShowPositiveError") >>= bShowPositive;
 813                             xErrorBarProp->getPropertyValue("ShowNegativeError") >>= bShowNegative;
 814                             bCreateYErrorBar = bShowPositive || bShowNegative;
 815                         }
 816
 817                         xErrorBarProp = pSeries->getXErrorBarProperties(nIndex);
 818                         if ( xErrorBarProp.is() )
 819                         {
 820                             bool bShowPositive = false;
 821                             bool bShowNegative = false;
 822                             xErrorBarProp->getPropertyValue("ShowPositiveError") >>= bShowPositive;
 823                             xErrorBarProp->getPropertyValue("ShowNegativeError") >>= bShowNegative;
 824                             bCreateXErrorBar = bShowPositive || bShowNegative;
 825                         }
 826                     }
 827
 828                     Symbol* pSymbolProperties = m_bSymbol ? pSeries->getSymbolProperties( nIndex ) : nullptr;
 829                     bool bCreateSymbol = pSymbolProperties && (pSymbolProperties->Style != SymbolStyle_NONE);
 830
 831                     if( !bCreateSymbol && !bCreateYErrorBar &&
 832                             !bCreateXErrorBar && !pSeries->getDataPointLabelIfLabel(nIndex) )
 833                         continue;
 834
 835                     //create a group shape for this point and add to the series shape:
 836                     OUString aPointCID = ObjectIdentifier::createPointCID(
 837                             pSeries->getPointCID_Stub(), nIndex );
 838                     uno::Reference< drawing::XShapes > xPointGroupShape_Shapes(
 839                             createGroupShape(xSeriesGroupShape_Shapes,aPointCID) );
 840                     uno::Reference<drawing::XShape> xPointGroupShape_Shape( xPointGroupShape_Shapes, uno::UNO_QUERY );
 841
 842                     {
 843                         nCreatedPoints++;
 844
 845                         //create data point
 846                         drawing::Direction3D aSymbolSize(0,0,0);
 847                         if( bCreateSymbol )
 848                         {
 849                             if(m_nDimension!=3)
 850                             {
 851                                 if (pSymbolProperties->Style != SymbolStyle_NONE)
 852                                 {
 853                                     aSymbolSize.DirectionX = pSymbolProperties->Size.Width;
 854                                     aSymbolSize.DirectionY = pSymbolProperties->Size.Height;
 855                                 }
 856
 857                                 if (pSymbolProperties->Style == SymbolStyle_STANDARD)
 858                                 {
 859                                     sal_Int32 nSymbol = pSymbolProperties->StandardSymbol;
 860                                     m_pShapeFactory->createSymbol2D(
 861                                         xPointGroupShape_Shapes, aScenePosition, aSymbolSize,
 862                                         nSymbol, pSymbolProperties->BorderColor,
 863                                         pSymbolProperties->FillColor);
 864                                 }
 865                                 else if (pSymbolProperties->Style == SymbolStyle_GRAPHIC)
 866                                 {
 867                                     m_pShapeFactory->createGraphic2D(xPointGroupShape_Shapes,
 868                                                                      aScenePosition, aSymbolSize,
 869                                                                      pSymbolProperties->Graphic);
 870                                 }
 871                                 //@todo other symbol styles
 872                             }
 873                         }
 874                         //create error bars or rectangles, depending on configuration
 875                         if ( ConfigAccess::getUseErrorRectangle() )
 876                         {
 877                             if ( bCreateXErrorBar || bCreateYErrorBar )
 878                             {
 879                                 createErrorRectangle(
 880                                       aUnscaledLogicPosition,
 881                                       *pSeries,
 882                                       nIndex,
 883                                       m_xErrorBarTarget,
 884                                       bCreateXErrorBar,
 885                                       bCreateYErrorBar );
 886                             }
 887                         }
 888                         else
 889                         {
 890                             if (bCreateXErrorBar)
 891                                 createErrorBar_X( aUnscaledLogicPosition, *pSeries, nIndex, m_xErrorBarTarget );
 892
 893                             if (bCreateYErrorBar)
 894                                 createErrorBar_Y( aUnscaledLogicPosition, *pSeries, nIndex, m_xErrorBarTarget, nullptr );
 895                         }
 896
 897                         //create data point label
 898                         if( pSeries->getDataPointLabelIfLabel(nIndex) )
 899                         {
 900                             LabelAlignment eAlignment = LABEL_ALIGN_TOP;
 901                             drawing::Position3D aScenePosition3D( aScenePosition.PositionX
 902                                     , aScenePosition.PositionY
 903                                     , aScenePosition.PositionZ+getTransformedDepth() );
 904
 905                             sal_Int32 nLabelPlacement = pSeries->getLabelPlacement(
 906                                 nIndex, m_xChartTypeModel, rPosHelper.isSwapXAndY());
 907
 908                             switch(nLabelPlacement)
 909                             {
 910                                 case css::chart::DataLabelPlacement::TOP:
 911                                     aScenePosition3D.PositionY -= (aSymbolSize.DirectionY/2+1);
 912                                     eAlignment = LABEL_ALIGN_TOP;
 913                                     break;
 914                                 case css::chart::DataLabelPlacement::BOTTOM:
 915                                     aScenePosition3D.PositionY += (aSymbolSize.DirectionY/2+1);
 916                                     eAlignment = LABEL_ALIGN_BOTTOM;
 917                                     break;
 918                                 case css::chart::DataLabelPlacement::LEFT:
 919                                     aScenePosition3D.PositionX -= (aSymbolSize.DirectionX/2+1);
 920                                     eAlignment = LABEL_ALIGN_LEFT;
 921                                     break;
 922                                 case css::chart::DataLabelPlacement::RIGHT:
 923                                     aScenePosition3D.PositionX += (aSymbolSize.DirectionX/2+1);
 924                                     eAlignment = LABEL_ALIGN_RIGHT;
 925                                     break;
 926                                 case css::chart::DataLabelPlacement::CENTER:
 927                                     eAlignment = LABEL_ALIGN_CENTER;
 928                                     //todo implement this different for area charts
 929                                     break;
 930                                 default:
 931                                     OSL_FAIL("this label alignment is not implemented yet");
 932                                     aScenePosition3D.PositionY -= (aSymbolSize.DirectionY/2+1);
 933                                     eAlignment = LABEL_ALIGN_TOP;
 934                                     break;
 935                             }
 936
 937                             awt::Point aScreenPosition2D;//get the screen position for the labels
 938                             sal_Int32 nOffset = 100; //todo maybe calculate this font height dependent
 939                             {
 940                                 if(eAlignment==LABEL_ALIGN_CENTER || m_nDimension == 3 )
 941                                     nOffset = 0;
 942                                 aScreenPosition2D = LabelPositionHelper(m_nDimension,m_xLogicTarget,m_pShapeFactory)
 943                                         .transformSceneToScreenPosition( aScenePosition3D );
 944                             }
 945
 946                             createDataLabel( m_xTextTarget, *pSeries, nIndex
 947                                     , fLogicValueForLabeDisplay
 948                                     , rLogicYSumMap[nAttachedAxisIndex], aScreenPosition2D, eAlignment, nOffset );
 949                         }
 950                     }
 951
 952                     //remove PointGroupShape if empty
 953                     if(!xPointGroupShape_Shapes->getCount())
 954                         xSeriesGroupShape_Shapes->remove(xPointGroupShape_Shape);
 955                 }
 956
 957             }//next series in x slot (next y slot)
 958         }//next x slot
 959         ++nZ;
 960     }//next z slot
 961
 962     impl_createSeriesShapes();
 963
 964     /* @todo remove series shapes if empty
 965     //remove and delete point-group-shape if empty
 966     if(!xSeriesGroupShape_Shapes->getCount())
 967     {
 968         pSeries->m_xShape.set(NULL);
 969         m_xLogicTarget->remove(xSeriesGroupShape_Shape);
 970     }
 971     */
 972
 973     //remove and delete series-group-shape if empty
 974
 975     //... todo
 976
 977     SAL_INFO(
 978         "chart2",
 979         "skipped points: " << nSkippedPoints << " created points: "
 980             << nCreatedPoints);
 981 }
 982
 983 } //namespace chart
 984
 985 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */