    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   Licensed to the Apache Software Foundation (ASF) under one or more
     *   contributor license agreements. See the NOTICE file distributed
     *   with this work for additional information regarding copyright
     *   ownership. The ASF licenses this file to you under the Apache
     *   License, Version 2.0 (the "License"); you may not use this file
     *   except in compliance with the License. You may obtain a copy of
     *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
     */

    #include "AreaChart.hxx"
    #include <PlottingPositionHelper.hxx>
    #include <ShapeFactory.hxx>
    #include <CommonConverters.hxx>
    #include <ExplicitCategoriesProvider.hxx>
    #include <ViewDefines.hxx>
    #include <ObjectIdentifier.hxx>
    #include "Splines.hxx"
    #include <ChartTypeHelper.hxx>
    #include <LabelPositionHelper.hxx>
    #include <Clipping.hxx>
    #include <Stripe.hxx>
    #include <DateHelper.hxx>
    #include <unonames.hxx>

    #include <com/sun/star/chart2/Symbol.hpp>
    #include <com/sun/star/chart/DataLabelPlacement.hpp>
    #include <com/sun/star/chart/MissingValueTreatment.hpp>

    #include <editeng/unoprnms.hxx>
    #include <rtl/math.hxx>
    #include <sal/log.hxx>
    #include <osl/diagnose.h>

    #include <com/sun/star/drawing/DoubleSequence.hpp>
    #include <com/sun/star/drawing/NormalsKind.hpp>
    #include <com/sun/star/drawing/XShapes.hpp>
    #include <com/sun/star/lang/XServiceName.hpp>
    #include <com/sun/star/beans/XPropertySet.hpp>

    namespace chart
    {
    using namespace ::com::sun::star;
    using namespace ::rtl::math;
    using namespace ::com::sun::star::chart2;

    AreaChart::AreaChart( const uno::Reference<XChartType>& xChartTypeModel
                         , sal_Int32 nDimensionCount
                         , bool bCategoryXAxis
                         , bool bNoArea
                         )
            : VSeriesPlotter( xChartTypeModel, nDimensionCount, bCategoryXAxis )
            , m_pMainPosHelper(new PlottingPositionHelper())
            , m_bArea(!bNoArea)
            , m_bLine(bNoArea)
            , m_bSymbol( ChartTypeHelper::isSupportingSymbolProperties(xChartTypeModel,nDimensionCount) )
            , m_eCurveStyle(CurveStyle_LINES)
            , m_nCurveResolution(20)
            , m_nSplineOrder(3)
    {
        m_pMainPosHelper->AllowShiftXAxisPos(true);
        m_pMainPosHelper->AllowShiftZAxisPos(true);

        PlotterBase::m_pPosHelper = m_pMainPosHelper.get();
        VSeriesPlotter::m_pMainPosHelper = m_pMainPosHelper.get();

        try
        {
            if( m_xChartTypeModelProps.is() )
            {
                m_xChartTypeModelProps->getPropertyValue(CHART_UNONAME_CURVE_STYLE) >>= m_eCurveStyle;
                m_xChartTypeModelProps->getPropertyValue(CHART_UNONAME_CURVE_RESOLUTION) >>= m_nCurveResolution;
                m_xChartTypeModelProps->getPropertyValue(CHART_UNONAME_SPLINE_ORDER) >>= m_nSplineOrder;
            }
        }
        catch( uno::Exception& e )
        {
            //the above properties are not supported by all charttypes supported by this class (e.g. area or net chart)
            //in that cases this exception is ok
            e.Context.is();//to have debug information without compilation warnings
        }
    }

    AreaChart::~AreaChart()
    {
    }

    double AreaChart::getMaximumX()
    {
        double fMax = VSeriesPlotter::getMaximumX();
        return fMax;
    }

    bool AreaChart::isSeparateStackingForDifferentSigns( sal_Int32 /*nDimensionIndex*/ )
    {
        // no separate stacking in all types of line/area charts
        return false;
    }

    LegendSymbolStyle AreaChart::getLegendSymbolStyle()
    {
        if( m_bArea || m_nDimension == 3 )
            return LegendSymbolStyle_BOX;
        return LegendSymbolStyle_LINE;
    }

    uno::Any AreaChart::getExplicitSymbol( const VDataSeries& rSeries, sal_Int32 nPointIndex )
    {
        uno::Any aRet;

        Symbol* pSymbolProperties = rSeries.getSymbolProperties( nPointIndex );
        if( pSymbolProperties )
        {
            aRet <<= *pSymbolProperties;
        }

        return aRet;
    }

    drawing::Direction3D AreaChart::getPreferredDiagramAspectRatio() const
    {
        drawing::Direction3D aRet(1,-1,1);
        if( m_nDimension == 2 )
            aRet = drawing::Direction3D(-1,-1,-1);
        else if (m_pPosHelper)
        {
            drawing::Direction3D aScale( m_pPosHelper->getScaledLogicWidth() );
            aRet.DirectionZ = aScale.DirectionZ*0.2;
            if(aRet.DirectionZ>1.0)
                aRet.DirectionZ=1.0;
            if(aRet.DirectionZ>10)
                aRet.DirectionZ=10;
        }
        return aRet;
    }

    void AreaChart::addSeries( std::unique_ptr<VDataSeries> pSeries, sal_Int32 zSlot, sal_Int32 xSlot, sal_Int32 ySlot )
    {
        if( m_bArea && pSeries )
        {
            sal_Int32 nMissingValueTreatment = pSeries->getMissingValueTreatment();
            if( nMissingValueTreatment == css::chart::MissingValueTreatment::LEAVE_GAP  )
                pSeries->setMissingValueTreatment( css::chart::MissingValueTreatment::USE_ZERO );
        }
        if( m_nDimension == 3 && !m_bCategoryXAxis )
        {
            //3D xy always deep
            OSL_ENSURE( zSlot==-1,"3D xy charts should be deep stacked in model also" );
            zSlot=-1;
            xSlot=0;
            ySlot=0;
        }
        VSeriesPlotter::addSeries( std::move(pSeries), zSlot, xSlot, ySlot );
    }

    void lcl_removeDuplicatePoints( drawing::PolyPolygonShape3D& rPolyPoly, PlottingPositionHelper& rPosHelper )
    {
        sal_Int32 nPolyCount = rPolyPoly.SequenceX.getLength();
        if(!nPolyCount)
            return;

        drawing::PolyPolygonShape3D aTmp;
        aTmp.SequenceX.realloc(nPolyCount);
        aTmp.SequenceY.realloc(nPolyCount);
        aTmp.SequenceZ.realloc(nPolyCount);

        for( sal_Int32 nPolygonIndex = 0; nPolygonIndex<nPolyCount; nPolygonIndex++ )
        {
            drawing::DoubleSequence* pOuterSourceX = &rPolyPoly.SequenceX.getArray()[nPolygonIndex];
            drawing::DoubleSequence* pOuterSourceY = &rPolyPoly.SequenceY.getArray()[nPolygonIndex];
            drawing::DoubleSequence* pOuterSourceZ = &rPolyPoly.SequenceZ.getArray()[nPolygonIndex];

            drawing::DoubleSequence* pOuterTargetX = &aTmp.SequenceX.getArray()[nPolygonIndex];
            drawing::DoubleSequence* pOuterTargetY = &aTmp.SequenceY.getArray()[nPolygonIndex];
            drawing::DoubleSequence* pOuterTargetZ = &aTmp.SequenceZ.getArray()[nPolygonIndex];

            sal_Int32 nPointCount = pOuterSourceX->getLength();
            if( !nPointCount )
                continue;

            pOuterTargetX->realloc(nPointCount);
            pOuterTargetY->realloc(nPointCount);
            pOuterTargetZ->realloc(nPointCount);

            double* pSourceX = pOuterSourceX->getArray();
            double* pSourceY = pOuterSourceY->getArray();
            double* pSourceZ = pOuterSourceZ->getArray();

            double* pTargetX = pOuterTargetX->getArray();
            double* pTargetY = pOuterTargetY->getArray();
            double* pTargetZ = pOuterTargetZ->getArray();

            //copy first point
            *pTargetX=*pSourceX++;
            *pTargetY=*pSourceY++;
            *pTargetZ=*pSourceZ++;
            sal_Int32 nTargetPointCount=1;

            for( sal_Int32 nSource=1; nSource<nPointCount; nSource++ )
            {
                if( !rPosHelper.isSameForGivenResolution( *pTargetX, *pTargetY, *pTargetZ
                                                       , *pSourceX, *pSourceY, *pSourceZ ) )
                {
                    pTargetX++; pTargetY++; pTargetZ++;
                    *pTargetX=*pSourceX;
                    *pTargetY=*pSourceY;
                    *pTargetZ=*pSourceZ;
                    nTargetPointCount++;
                }
                pSourceX++; pSourceY++; pSourceZ++;
            }

            //free unused space
            if( nTargetPointCount<nPointCount )
            {
                pOuterTargetX->realloc(nTargetPointCount);
                pOuterTargetY->realloc(nTargetPointCount);
                pOuterTargetZ->realloc(nTargetPointCount);
            }

            pOuterSourceX->realloc(0);
            pOuterSourceY->realloc(0);
            pOuterSourceZ->realloc(0);
        }

        //free space
        rPolyPoly.SequenceX.realloc(nPolyCount);
        rPolyPoly.SequenceY.realloc(nPolyCount);
        rPolyPoly.SequenceZ.realloc(nPolyCount);

        rPolyPoly=aTmp;
    }

    bool AreaChart::create_stepped_line( drawing::PolyPolygonShape3D aStartPoly, chart2::CurveStyle eCurveStyle, PlottingPositionHelper const * pPosHelper, drawing::PolyPolygonShape3D &aPoly )
    {
        sal_uInt32 nOuterCount = aStartPoly.SequenceX.getLength();
        if ( !nOuterCount )
            return false;

        drawing::PolyPolygonShape3D aSteppedPoly;
        aSteppedPoly.SequenceX.realloc(nOuterCount);
        aSteppedPoly.SequenceY.realloc(nOuterCount);
        aSteppedPoly.SequenceZ.realloc(nOuterCount);

        for( sal_uInt32 nOuter = 0; nOuter < nOuterCount; ++nOuter )
        {
            if( aStartPoly.SequenceX[nOuter].getLength() <= 1 )
                continue; //we need at least two points

            sal_uInt32 nMaxIndexPoints = aStartPoly.SequenceX[nOuter].getLength()-1; // is >1
            sal_uInt32 nNewIndexPoints = 0;
            if ( eCurveStyle==CurveStyle_STEP_START || eCurveStyle==CurveStyle_STEP_END)
                nNewIndexPoints = nMaxIndexPoints * 2 + 1;
            else
                nNewIndexPoints = nMaxIndexPoints * 3 + 1;

            const double* pOldX = aStartPoly.SequenceX[nOuter].getConstArray();
            const double* pOldY = aStartPoly.SequenceY[nOuter].getConstArray();
            const double* pOldZ = aStartPoly.SequenceZ[nOuter].getConstArray();

            aSteppedPoly.SequenceX[nOuter].realloc( nNewIndexPoints );
            aSteppedPoly.SequenceY[nOuter].realloc( nNewIndexPoints );
            aSteppedPoly.SequenceZ[nOuter].realloc( nNewIndexPoints );

            double* pNewX = aSteppedPoly.SequenceX[nOuter].getArray();
            double* pNewY = aSteppedPoly.SequenceY[nOuter].getArray();
            double* pNewZ = aSteppedPoly.SequenceZ[nOuter].getArray();

            pNewX[0] = pOldX[0];
            pNewY[0] = pOldY[0];
            pNewZ[0] = pOldZ[0];
            for( sal_uInt32 oi = 0; oi < nMaxIndexPoints; oi++ )
            {
                switch ( eCurveStyle )
                {
                    case CurveStyle_STEP_START:
                         /**           O
                                       |
                                       |
                                       |
                                 O-----+
                         */
                        // create the intermediate point
                        pNewX[1+oi*2] = pOldX[oi+1];
                        pNewY[1+oi*2] = pOldY[oi];
                        pNewZ[1+oi*2] = pOldZ[oi];
                        // and now the normal one
                        pNewX[1+oi*2+1] = pOldX[oi+1];
                        pNewY[1+oi*2+1] = pOldY[oi+1];
                        pNewZ[1+oi*2+1] = pOldZ[oi+1];
                        break;
                    case CurveStyle_STEP_END:
                         /**    +------O
                                |
                                |
                                |
                                O
                         */
                        // create the intermediate point
                        pNewX[1+oi*2] = pOldX[oi];
                        pNewY[1+oi*2] = pOldY[oi+1];
                        pNewZ[1+oi*2] = pOldZ[oi];
                        // and now the normal one
                        pNewX[1+oi*2+1] = pOldX[oi+1];
                        pNewY[1+oi*2+1] = pOldY[oi+1];
                        pNewZ[1+oi*2+1] = pOldZ[oi+1];
                        break;
                    case CurveStyle_STEP_CENTER_X:
                         /**        +--O
                                    |
                                    |
                                    |
                                 O--+
                         */
                        // create the first intermediate point
                        pNewX[1+oi*3] = (pOldX[oi]+pOldX[oi+1])/2;
                        pNewY[1+oi*3] = pOldY[oi];
                        pNewZ[1+oi*3] = pOldZ[oi];
                        // create the second intermediate point
                        pNewX[1+oi*3+1] = (pOldX[oi]+pOldX[oi+1])/2;
                        pNewY[1+oi*3+1] = pOldY[oi+1];
                        pNewZ[1+oi*3+1] = pOldZ[oi];
                        // and now the normal one
                        pNewX[1+oi*3+2] = pOldX[oi+1];
                        pNewY[1+oi*3+2] = pOldY[oi+1];
                        pNewZ[1+oi*3+2] = pOldZ[oi+1];
                        break;
                    case CurveStyle_STEP_CENTER_Y:
                         /**           O
                                       |
                                 +-----+
                                 |
                                 O
                         */
                        // create the first intermediate point
                        pNewX[1+oi*3] = pOldX[oi];
                        pNewY[1+oi*3] = (pOldY[oi]+pOldY[oi+1])/2;
                        pNewZ[1+oi*3] = pOldZ[oi];
                        // create the second intermediate point
                        pNewX[1+oi*3+1] = pOldX[oi+1];
                        pNewY[1+oi*3+1] = (pOldY[oi]+pOldY[oi+1])/2;
                        pNewZ[1+oi*3+1] = pOldZ[oi];
                        // and now the normal one
                        pNewX[1+oi*3+2] = pOldX[oi+1];
                        pNewY[1+oi*3+2] = pOldY[oi+1];
                        pNewZ[1+oi*3+2] = pOldZ[oi+1];
                        break;
                    default:
                        // this should never be executed
                        OSL_FAIL("Unknown curvestyle in AreaChart::create_stepped_line");
                }
            }
        }
        Clipping::clipPolygonAtRectangle( aSteppedPoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );

        return true;
    }

    bool AreaChart::impl_createLine( VDataSeries* pSeries
                    , drawing::PolyPolygonShape3D const * pSeriesPoly
                    , PlottingPositionHelper* pPosHelper )
    {
        //return true if a line was created successfully
        uno::Reference< drawing::XShapes > xSeriesGroupShape_Shapes = getSeriesGroupShapeBackChild(pSeries, m_xSeriesTarget);

        drawing::PolyPolygonShape3D aPoly;
        if(m_eCurveStyle==CurveStyle_CUBIC_SPLINES)
        {
            drawing::PolyPolygonShape3D aSplinePoly;
            SplineCalculater::CalculateCubicSplines( *pSeriesPoly, aSplinePoly, m_nCurveResolution );
            lcl_removeDuplicatePoints( aSplinePoly, *pPosHelper );
            Clipping::clipPolygonAtRectangle( aSplinePoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
        }
        else if(m_eCurveStyle==CurveStyle_B_SPLINES)
        {
            drawing::PolyPolygonShape3D aSplinePoly;
            SplineCalculater::CalculateBSplines( *pSeriesPoly, aSplinePoly, m_nCurveResolution, m_nSplineOrder );
            lcl_removeDuplicatePoints( aSplinePoly, *pPosHelper );
            Clipping::clipPolygonAtRectangle( aSplinePoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
        }
        else if (m_eCurveStyle==CurveStyle_STEP_START ||
                 m_eCurveStyle==CurveStyle_STEP_END ||
                 m_eCurveStyle==CurveStyle_STEP_CENTER_Y ||
                 m_eCurveStyle==CurveStyle_STEP_CENTER_X
                )
        {
            if (!create_stepped_line(*pSeriesPoly, m_eCurveStyle, pPosHelper, aPoly))
            {
                return false;
            }
        }
        else
        { // default to creating a straight line
            SAL_WARN_IF(m_eCurveStyle != CurveStyle_LINES, "chart2.areachart", "Unknown curve style");
            Clipping::clipPolygonAtRectangle( *pSeriesPoly, pPosHelper->getScaledLogicClipDoubleRect(), aPoly );
        }

        if(!ShapeFactory::hasPolygonAnyLines(aPoly))
            return false;

        //transformation 3) -> 4)
        pPosHelper->transformScaledLogicToScene( aPoly );

        //create line:
        uno::Reference< drawing::XShape > xShape;
        if(m_nDimension==3)
        {
            double fDepth = getTransformedDepth();
            sal_Int32 nPolyCount = aPoly.SequenceX.getLength();
            for(sal_Int32 nPoly=0;nPoly<nPolyCount;nPoly++)
            {
                sal_Int32 nPointCount = aPoly.SequenceX[nPoly].getLength();
                for(sal_Int32 nPoint=0;nPoint<nPointCount-1;nPoint++)
                {
                    drawing::Position3D aPoint1, aPoint2;
                    aPoint1.PositionX = aPoly.SequenceX[nPoly][nPoint+1];
                    aPoint1.PositionY = aPoly.SequenceY[nPoly][nPoint+1];
                    aPoint1.PositionZ = aPoly.SequenceZ[nPoly][nPoint+1];

                    aPoint2.PositionX = aPoly.SequenceX[nPoly][nPoint];
                    aPoint2.PositionY = aPoly.SequenceY[nPoly][nPoint];
                    aPoint2.PositionZ = aPoly.SequenceZ[nPoly][nPoint];

                    Stripe aStripe( aPoint1, aPoint2, fDepth );

                    m_pShapeFactory->createStripe(xSeriesGroupShape_Shapes
                        , Stripe( aPoint1, aPoint2, fDepth )
                        , pSeries->getPropertiesOfSeries(), PropertyMapper::getPropertyNameMapForFilledSeriesProperties(), true, 1 );
                }
            }
        }
        else //m_nDimension!=3
        {
            xShape = m_pShapeFactory->createLine2D( xSeriesGroupShape_Shapes
                    , PolyToPointSequence( aPoly ) );
            setMappedProperties( xShape
                    , pSeries->getPropertiesOfSeries()
                    , PropertyMapper::getPropertyNameMapForLineSeriesProperties() );
            //because of this name this line will be used for marking
            ::chart::ShapeFactory::setShapeName(xShape, "MarkHandles");
        }
        return true;
    }

    bool AreaChart::impl_createArea( VDataSeries* pSeries
                    , drawing::PolyPolygonShape3D const * pSeriesPoly
                    , drawing::PolyPolygonShape3D const * pPreviousSeriesPoly
                    , PlottingPositionHelper const * pPosHelper )
    {
        //return true if an area was created successfully

        uno::Reference< drawing::XShapes > xSeriesGroupShape_Shapes = getSeriesGroupShapeBackChild(pSeries, m_xSeriesTarget);
        double zValue = pSeries->m_fLogicZPos;

        drawing::PolyPolygonShape3D aPoly( *pSeriesPoly );
        //add second part to the polygon (grounding points or previous series points)
        if(!pPreviousSeriesPoly)
        {
            double fMinX = pSeries->m_fLogicMinX;
            double fMaxX = pSeries->m_fLogicMaxX;
            double fY = pPosHelper->getBaseValueY();//logic grounding
            if( m_nDimension==3 )
                fY = pPosHelper->getLogicMinY();

            //clip to scale
            if(fMaxX<pPosHelper->getLogicMinX() || fMinX>pPosHelper->getLogicMaxX())
                return false;//no visible shape needed
            pPosHelper->clipLogicValues( &fMinX, &fY, nullptr );
            pPosHelper->clipLogicValues( &fMaxX, nullptr, nullptr );

            //apply scaling
            {
                pPosHelper->doLogicScaling( &fMinX, &fY, &zValue );
                pPosHelper->doLogicScaling( &fMaxX, nullptr, nullptr );
            }

            AddPointToPoly( aPoly, drawing::Position3D( fMaxX,fY,zValue) );
            AddPointToPoly( aPoly, drawing::Position3D( fMinX,fY,zValue) );
        }
        else
        {
            appendPoly( aPoly, *pPreviousSeriesPoly );
        }
        ShapeFactory::closePolygon(aPoly);

        //apply clipping
        {
            drawing::PolyPolygonShape3D aClippedPoly;
            Clipping::clipPolygonAtRectangle( aPoly, pPosHelper->getScaledLogicClipDoubleRect(), aClippedPoly, false );
            ShapeFactory::closePolygon(aClippedPoly); //again necessary after clipping
            aPoly = aClippedPoly;
        }

        if(!ShapeFactory::hasPolygonAnyLines(aPoly))
            return false;

        //transformation 3) -> 4)
        pPosHelper->transformScaledLogicToScene( aPoly );

        //create area:
        uno::Reference< drawing::XShape > xShape;
        if(m_nDimension==3)
        {
            xShape = m_pShapeFactory->createArea3D( xSeriesGroupShape_Shapes
                    , aPoly, getTransformedDepth() );
        }
        else //m_nDimension!=3
        {
            xShape = m_pShapeFactory->createArea2D( xSeriesGroupShape_Shapes
                    , aPoly );
        }
        setMappedProperties( xShape
                    , pSeries->getPropertiesOfSeries()
                    , PropertyMapper::getPropertyNameMapForFilledSeriesProperties() );
        //because of this name this line will be used for marking
        ::chart::ShapeFactory::setShapeName(xShape, "MarkHandles");
        return true;
    }

    void AreaChart::impl_createSeriesShapes()
    {
        //the polygon shapes for each series need to be created before

        //iterate through all series again to create the series shapes
        for( auto const& rZSlot : m_aZSlots )
        {
            for( auto const& rXSlot : rZSlot )
            {
                std::map< sal_Int32, drawing::PolyPolygonShape3D* > aPreviousSeriesPolyMap;//a PreviousSeriesPoly for each different nAttachedAxisIndex
                drawing::PolyPolygonShape3D* pSeriesPoly = nullptr;

                //iterate through all series
                for( std::unique_ptr<VDataSeries> const & pSeries : rXSlot.m_aSeriesVector )
                {
                    sal_Int32 nAttachedAxisIndex = pSeries->getAttachedAxisIndex();
                    PlottingPositionHelper* pPosHelper = &(getPlottingPositionHelper( nAttachedAxisIndex ));
                    if(!pPosHelper)
                        pPosHelper = m_pMainPosHelper.get();
                    PlotterBase::m_pPosHelper = pPosHelper;

                    createRegressionCurvesShapes( *pSeries, m_xErrorBarTarget, m_xRegressionCurveEquationTarget,
                                                  m_pPosHelper->maySkipPointsInRegressionCalculation());

                    pSeriesPoly = &pSeries->m_aPolyPolygonShape3D;
                    if( m_bArea )
                    {
                        if( !impl_createArea( pSeries.get(), pSeriesPoly, aPreviousSeriesPolyMap[nAttachedAxisIndex], pPosHelper ) )
                            continue;
                    }
                    if( m_bLine )
                    {
                        if( !impl_createLine( pSeries.get(), pSeriesPoly, pPosHelper ) )
                            continue;
                    }
                    aPreviousSeriesPolyMap[nAttachedAxisIndex] = pSeriesPoly;
                }//next series in x slot (next y slot)
            }//next x slot
        }//next z slot
    }

    namespace
    {

    void lcl_reorderSeries( std::vector< std::vector< VDataSeriesGroup > >&  rZSlots )
    {
        std::vector< std::vector< VDataSeriesGroup > >  aRet;
        aRet.reserve( rZSlots.size() );

        std::vector< std::vector< VDataSeriesGroup > >::reverse_iterator aZIt( rZSlots.rbegin() );
        std::vector< std::vector< VDataSeriesGroup > >::reverse_iterator aZEnd( rZSlots.rend() );
        for( ; aZIt != aZEnd; ++aZIt )
        {
            std::vector< VDataSeriesGroup > aXSlot;
            aXSlot.reserve( aZIt->size() );

            std::vector< VDataSeriesGroup >::reverse_iterator aXIt( aZIt->rbegin() );
            std::vector< VDataSeriesGroup >::reverse_iterator aXEnd( aZIt->rend() );
            for( ; aXIt != aXEnd; ++aXIt )
                aXSlot.push_back(std::move(*aXIt));

            aRet.push_back(std::move(aXSlot));
        }

        rZSlots = std::move(aRet);
    }

    }//anonymous namespace

    //better performance for big data
    struct FormerPoint
    {
        FormerPoint( double fX, double fY, double fZ )
            : m_fX(fX), m_fY(fY), m_fZ(fZ)
            {}
        FormerPoint()
        {
            ::rtl::math::setNan( &m_fX );
            ::rtl::math::setNan( &m_fY );
            ::rtl::math::setNan( &m_fZ );
        }

        double m_fX;
        double m_fY;
        double m_fZ;
    };

    void AreaChart::createShapes()
    {
        if( m_aZSlots.empty() ) //no series
            return;

        if( m_nDimension == 2 && ( m_bArea || !m_bCategoryXAxis ) )
            lcl_reorderSeries( m_aZSlots );

        OSL_ENSURE(m_pShapeFactory&&m_xLogicTarget.is()&&m_xFinalTarget.is(),"AreaChart is not proper initialized");
        if(!(m_pShapeFactory&&m_xLogicTarget.is()&&m_xFinalTarget.is()))
            return;

        //the text labels should be always on top of the other series shapes
        //for area chart the error bars should be always on top of the other series shapes

        //therefore create an own group for the texts and the error bars to move them to front
        //(because the text group is created after the series group the texts are displayed on top)
        m_xSeriesTarget   = createGroupShape( m_xLogicTarget );
        if( m_bArea )
            m_xErrorBarTarget = createGroupShape( m_xLogicTarget );
        else
            m_xErrorBarTarget = m_xSeriesTarget;
        m_xTextTarget     = m_pShapeFactory->createGroup2D( m_xFinalTarget );
        m_xRegressionCurveEquationTarget = m_pShapeFactory->createGroup2D( m_xFinalTarget );

        //check necessary here that different Y axis can not be stacked in the same group? ... hm?

        //update/create information for current group
        double fLogicZ        = 1.0;//as defined

        sal_Int32 nStartIndex = 0; // inclusive       ;..todo get somehow from x scale
        sal_Int32 nEndIndex = VSeriesPlotter::getPointCount();
        if(nEndIndex<=0)
            nEndIndex=1;

        //better performance for big data
        std::map< VDataSeries*, FormerPoint > aSeriesFormerPointMap;
        m_bPointsWereSkipped = false;
        sal_Int32 nSkippedPoints = 0;
        sal_Int32 nCreatedPoints = 0;

        bool bDateCategory = (m_pExplicitCategoriesProvider && m_pExplicitCategoriesProvider->isDateAxis());

        std::vector<std::map< sal_Int32, double > > aLogicYSumMapByX(nEndIndex);//one for each different nAttachedAxisIndex
        for( auto const& rZSlot : m_aZSlots )
        {
            //iterate through all x slots in this category to get 100percent sum
            for( auto const& rXSlot : rZSlot )
            {
                for( std::unique_ptr<VDataSeries> const & pSeries : rXSlot.m_aSeriesVector )
                {
                    if(!pSeries)
                        continue;

                    if (bDateCategory)
                        pSeries->doSortByXValues();

                    for( sal_Int32 nIndex = nStartIndex; nIndex < nEndIndex; nIndex++ )
                    {
                        std::map< sal_Int32, double >& rLogicYSumMap = aLogicYSumMapByX[nIndex];
                        sal_Int32 nAttachedAxisIndex = pSeries->getAttachedAxisIndex();
                        if( rLogicYSumMap.find(nAttachedAxisIndex)==rLogicYSumMap.end() )
                            rLogicYSumMap[nAttachedAxisIndex]=0.0;

                        PlottingPositionHelper* pPosHelper = &(getPlottingPositionHelper( nAttachedAxisIndex ));
                        if(!pPosHelper)
                            pPosHelper = m_pMainPosHelper.get();
                        PlotterBase::m_pPosHelper = pPosHelper;

                        double fAdd = pSeries->getYValue( nIndex );
                        if( !::rtl::math::isNan(fAdd) && !::rtl::math::isInf(fAdd) )
                            rLogicYSumMap[nAttachedAxisIndex] += fabs( fAdd );
                    }
                }
            }
        }

        sal_Int32 nZ=1;
        for( auto const& rZSlot : m_aZSlots )
        {
            //for the area chart there should be at most one x slot (no side by side stacking available)
            //attention different: xSlots are always interpreted as independent areas one behind the other: @todo this doesn't work why not???
            for( auto const& rXSlot : rZSlot )
            {
                std::vector<std::map< sal_Int32, double > > aLogicYForNextSeriesMapByX(nEndIndex); //one for each different nAttachedAxisIndex
                //iterate through all series
                for( std::unique_ptr<VDataSeries> const & pSeries : rXSlot.m_aSeriesVector )
                {
                    if(!pSeries)
                        continue;

                    uno::Reference< drawing::XShapes > xSeriesGroupShape_Shapes = getSeriesGroupShapeFrontChild(pSeries.get(), m_xSeriesTarget);

                    sal_Int32 nAttachedAxisIndex = pSeries->getAttachedAxisIndex();
                    PlottingPositionHelper* pPosHelper = &(getPlottingPositionHelper( nAttachedAxisIndex ));
                    if(!pPosHelper)
                        pPosHelper = m_pMainPosHelper.get();
                    PlotterBase::m_pPosHelper = pPosHelper;

                    if(m_nDimension==3)
                        fLogicZ = nZ+0.5;
                    pSeries->m_fLogicZPos = fLogicZ;

                    for( sal_Int32 nIndex = nStartIndex; nIndex < nEndIndex; nIndex++ )
                    {

                        /*  #i70133# ignore points outside of series length in standard area
                            charts. Stacked area charts will use missing points as zeros. In
                            standard charts, pSeriesList contains only one series. */
                        if( m_bArea && (rXSlot.m_aSeriesVector.size() == 1) && (nIndex >= pSeries->getTotalPointCount()) )
                            continue;

                        //collect data point information (logic coordinates, style ):
                        double fLogicX = pSeries->getXValue(nIndex);
                        if (bDateCategory)
                            fLogicX = DateHelper::RasterizeDateValue( fLogicX, m_aNullDate, m_nTimeResolution );
                        double fLogicY = pSeries->getYValue(nIndex);

                        if( m_nDimension==3 && m_bArea && rXSlot.m_aSeriesVector.size()!=1 )
                            fLogicY = fabs( fLogicY );

                        std::map< sal_Int32, double >& rLogicYSumMap = aLogicYSumMapByX[nIndex];
                        if( pPosHelper->isPercentY() && rLogicYSumMap[nAttachedAxisIndex] != 0.0 )
                        {
                            fLogicY = fabs( fLogicY )/rLogicYSumMap[nAttachedAxisIndex];
                        }

                        if(    ::rtl::math::isNan(fLogicX) || ::rtl::math::isInf(fLogicX)
                                || ::rtl::math::isNan(fLogicY) || ::rtl::math::isInf(fLogicY)
                                || ::rtl::math::isNan(fLogicZ) || ::rtl::math::isInf(fLogicZ) )
                        {
                            if( pSeries->getMissingValueTreatment() == css::chart::MissingValueTreatment::LEAVE_GAP )
                            {
                                drawing::PolyPolygonShape3D& rPolygon = pSeries->m_aPolyPolygonShape3D;
                                sal_Int32& rIndex = pSeries->m_nPolygonIndex;
                                if( 0<= rIndex && rIndex < rPolygon.SequenceX.getLength() )
                                {
                                    if( rPolygon.SequenceX[ rIndex ].getLength() )
                                        rIndex++; //start a new polygon for the next point if the current poly is not empty
                                }
                            }
                            continue;
                        }

                        std::map< sal_Int32, double >& rLogicYForNextSeriesMap = aLogicYForNextSeriesMapByX[nIndex];
                        if( rLogicYForNextSeriesMap.find(nAttachedAxisIndex) == rLogicYForNextSeriesMap.end() )
                            rLogicYForNextSeriesMap[nAttachedAxisIndex] = 0.0;

                        double fLogicValueForLabeDisplay = fLogicY;

                        fLogicY += rLogicYForNextSeriesMap[nAttachedAxisIndex];
                        rLogicYForNextSeriesMap[nAttachedAxisIndex] = fLogicY;

                        bool bIsVisible = pPosHelper->isLogicVisible( fLogicX, fLogicY, fLogicZ );

                        //remind minimal and maximal x values for area 'grounding' points
                        //only for filled area
                        {
                            double& rfMinX = pSeries->m_fLogicMinX;
                            if(!nIndex||fLogicX<rfMinX)
                                rfMinX=fLogicX;
                            double& rfMaxX = pSeries->m_fLogicMaxX;
                            if(!nIndex||fLogicX>rfMaxX)
                                rfMaxX=fLogicX;
                        }

                        drawing::Position3D aUnscaledLogicPosition( fLogicX, fLogicY, fLogicZ );
                        drawing::Position3D aScaledLogicPosition(aUnscaledLogicPosition);
                        pPosHelper->doLogicScaling( aScaledLogicPosition );

                        //transformation 3) -> 4)
                        drawing::Position3D aScenePosition( pPosHelper->transformLogicToScene( fLogicX,fLogicY,fLogicZ, false ) );

                        //better performance for big data
                        FormerPoint aFormerPoint( aSeriesFormerPointMap[pSeries.get()] );
                        pPosHelper->setCoordinateSystemResolution( m_aCoordinateSystemResolution );
                        if( !pSeries->isAttributedDataPoint(nIndex)
                                &&
                                pPosHelper->isSameForGivenResolution( aFormerPoint.m_fX, aFormerPoint.m_fY, aFormerPoint.m_fZ
                                    , aScaledLogicPosition.PositionX, aScaledLogicPosition.PositionY, aScaledLogicPosition.PositionZ ) )
                        {
                            ++nSkippedPoints;
                            m_bPointsWereSkipped = true;
                            continue;
                        }
                        aSeriesFormerPointMap[pSeries.get()] = FormerPoint(aScaledLogicPosition.PositionX, aScaledLogicPosition.PositionY, aScaledLogicPosition.PositionZ);

                        //store point information for series polygon
                        //for area and/or line (symbols only do not need this)
                        if( isValidPosition(aScaledLogicPosition) )
                        {
                            AddPointToPoly( pSeries->m_aPolyPolygonShape3D, aScaledLogicPosition, pSeries->m_nPolygonIndex );
                        }

                        //create a single datapoint if point is visible
                        //apply clipping:
                        if( !bIsVisible )
                            continue;

                        bool bCreateYErrorBar = false, bCreateXErrorBar = false;
                        {
                            uno::Reference< beans::XPropertySet > xErrorBarProp(pSeries->getYErrorBarProperties(nIndex));
                            if( xErrorBarProp.is() )
                            {
                                bool bShowPositive = false;
                                bool bShowNegative = false;
                                xErrorBarProp->getPropertyValue("ShowPositiveError") >>= bShowPositive;
                                xErrorBarProp->getPropertyValue("ShowNegativeError") >>= bShowNegative;
                                bCreateYErrorBar = bShowPositive || bShowNegative;
                            }

                            xErrorBarProp = pSeries->getXErrorBarProperties(nIndex);
                            if ( xErrorBarProp.is() )
                            {
                                bool bShowPositive = false;
                                bool bShowNegative = false;
                                xErrorBarProp->getPropertyValue("ShowPositiveError") >>= bShowPositive;
                                xErrorBarProp->getPropertyValue("ShowNegativeError") >>= bShowNegative;
                                bCreateXErrorBar = bShowPositive || bShowNegative;
                            }
                        }

                        Symbol* pSymbolProperties = m_bSymbol ? pSeries->getSymbolProperties( nIndex ) : nullptr;
                        bool bCreateSymbol = pSymbolProperties && (pSymbolProperties->Style != SymbolStyle_NONE);

                        if( !bCreateSymbol && !bCreateYErrorBar &&
                                !bCreateXErrorBar && !pSeries->getDataPointLabelIfLabel(nIndex) )
                            continue;

                        //create a group shape for this point and add to the series shape:
                        OUString aPointCID = ObjectIdentifier::createPointCID(
                                pSeries->getPointCID_Stub(), nIndex );
                        uno::Reference< drawing::XShapes > xPointGroupShape_Shapes(
                                createGroupShape(xSeriesGroupShape_Shapes,aPointCID) );
                        uno::Reference<drawing::XShape> xPointGroupShape_Shape =
                            uno::Reference<drawing::XShape>( xPointGroupShape_Shapes, uno::UNO_QUERY );

                        {
                            nCreatedPoints++;

                            //create data point
                            drawing::Direction3D aSymbolSize(0,0,0);
                            if( bCreateSymbol )
                            {
                                if(m_nDimension!=3)
                                {
                                    if( pSymbolProperties )
                                    {
                                        if( pSymbolProperties->Style != SymbolStyle_NONE )
                                        {
                                            aSymbolSize.DirectionX = pSymbolProperties->Size.Width;
                                            aSymbolSize.DirectionY = pSymbolProperties->Size.Height;
                                        }

                                        if( pSymbolProperties->Style == SymbolStyle_STANDARD )
                                        {
                                            sal_Int32 nSymbol = pSymbolProperties->StandardSymbol;
                                            m_pShapeFactory->createSymbol2D( xPointGroupShape_Shapes
                                                    , aScenePosition, aSymbolSize
                                                    , nSymbol
                                                    , pSymbolProperties->BorderColor
                                                    , pSymbolProperties->FillColor );
                                        }
                                        else if( pSymbolProperties->Style == SymbolStyle_GRAPHIC )
                                        {
                                            m_pShapeFactory->createGraphic2D( xPointGroupShape_Shapes
                                                    , aScenePosition , aSymbolSize
                                                    , pSymbolProperties->Graphic );
                                        }
                                        //@todo other symbol styles
                                    }
                                }
                            }
                            //create error bars
                            if (bCreateXErrorBar)
                                createErrorBar_X( aUnscaledLogicPosition, *pSeries, nIndex, m_xErrorBarTarget );

                            if (bCreateYErrorBar)
                                createErrorBar_Y( aUnscaledLogicPosition, *pSeries, nIndex, m_xErrorBarTarget, nullptr );

                            //create data point label
                            if( pSeries->getDataPointLabelIfLabel(nIndex) )
                            {
                                LabelAlignment eAlignment = LABEL_ALIGN_TOP;
                                drawing::Position3D aScenePosition3D( aScenePosition.PositionX
                                        , aScenePosition.PositionY
                                        , aScenePosition.PositionZ+getTransformedDepth() );

                                sal_Int32 nLabelPlacement = pSeries->getLabelPlacement( nIndex, m_xChartTypeModel, pPosHelper->isSwapXAndY() );

                                switch(nLabelPlacement)
                                {
                                    case css::chart::DataLabelPlacement::TOP:
                                        aScenePosition3D.PositionY -= (aSymbolSize.DirectionY/2+1);
                                        eAlignment = LABEL_ALIGN_TOP;
                                        break;
                                    case css::chart::DataLabelPlacement::BOTTOM:
                                        aScenePosition3D.PositionY += (aSymbolSize.DirectionY/2+1);
                                        eAlignment = LABEL_ALIGN_BOTTOM;
                                        break;
                                    case css::chart::DataLabelPlacement::LEFT:
                                        aScenePosition3D.PositionX -= (aSymbolSize.DirectionX/2+1);
                                        eAlignment = LABEL_ALIGN_LEFT;
                                        break;
                                    case css::chart::DataLabelPlacement::RIGHT:
                                        aScenePosition3D.PositionX += (aSymbolSize.DirectionX/2+1);
                                        eAlignment = LABEL_ALIGN_RIGHT;
                                        break;
                                    case css::chart::DataLabelPlacement::CENTER:
                                        eAlignment = LABEL_ALIGN_CENTER;
                                        //todo implement this different for area charts
                                        break;
                                    default:
                                        OSL_FAIL("this label alignment is not implemented yet");
                                        aScenePosition3D.PositionY -= (aSymbolSize.DirectionY/2+1);
                                        eAlignment = LABEL_ALIGN_TOP;
                                        break;
                                }

                                awt::Point aScreenPosition2D;//get the screen position for the labels
                                sal_Int32 nOffset = 100; //todo maybe calculate this font height dependent
                                {
                                    if(eAlignment==LABEL_ALIGN_CENTER || m_nDimension == 3 )
                                        nOffset = 0;
                                    aScreenPosition2D = awt::Point( LabelPositionHelper(m_nDimension,m_xLogicTarget,m_pShapeFactory)
                                            .transformSceneToScreenPosition( aScenePosition3D ) );
                                }

                                createDataLabel( m_xTextTarget, *pSeries, nIndex
                                        , fLogicValueForLabeDisplay
                                        , rLogicYSumMap[nAttachedAxisIndex], aScreenPosition2D, eAlignment, nOffset );
                            }
                        }

                        //remove PointGroupShape if empty
                        if(!xPointGroupShape_Shapes->getCount())
                            xSeriesGroupShape_Shapes->remove(xPointGroupShape_Shape);
                    }

                }//next series in x slot (next y slot)
            }//next x slot
            ++nZ;
        }//next z slot

        impl_createSeriesShapes();

        /* @todo remove series shapes if empty
        //remove and delete point-group-shape if empty
        if(!xSeriesGroupShape_Shapes->getCount())
        {
            pSeries->m_xShape.set(NULL);
            m_xLogicTarget->remove(xSeriesGroupShape_Shape);
        }
        */

        //remove and delete series-group-shape if empty

        //... todo

        SAL_INFO(
            "chart2",
            "skipped points: " << nSkippedPoints << " created points: "
                << nCreatedPoints);
    }

    } //namespace chart

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V547 Expression '!pPosHelper' is always false.

↑ V547 Expression '!pPosHelper' is always false.

↑ V560 A part of conditional expression is always true: !bCreateXErrorBar.

↑ V547 Expression '!pPosHelper' is always false.

↑ V547 Expression 'pSymbolProperties' is always true.

↑ V547 Expression 'bCreateXErrorBar' is always false.

↑ V547 Expression 'bCreateYErrorBar' is always false.

↑ V560 A part of conditional expression is always true: !bCreateYErrorBar.