summaryrefslogtreecommitdiffstats
path: root/chart2/source/view/inc/PlottingPositionHelper.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /chart2/source/view/inc/PlottingPositionHelper.hxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'chart2/source/view/inc/PlottingPositionHelper.hxx')
-rw-r--r--chart2/source/view/inc/PlottingPositionHelper.hxx467
1 files changed, 467 insertions, 0 deletions
diff --git a/chart2/source/view/inc/PlottingPositionHelper.hxx b/chart2/source/view/inc/PlottingPositionHelper.hxx
new file mode 100644
index 000000000..c0480a4e3
--- /dev/null
+++ b/chart2/source/view/inc/PlottingPositionHelper.hxx
@@ -0,0 +1,467 @@
+/* -*- 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 .
+ */
+#pragma once
+
+#include <sal/config.h>
+
+#include <memory>
+
+#include <chartview/ExplicitScaleValues.hxx>
+
+#include <basegfx/range/b2drectangle.hxx>
+#include <tools/long.hxx>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/Position3D.hpp>
+#include <basegfx/matrix/b3dhommatrix.hxx>
+#include <com/sun/star/awt/Point.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <rtl/ref.hxx>
+#include <svx/unoshape.hxx>
+
+namespace com::sun::star::drawing { class XShapes; }
+namespace com::sun::star::drawing { struct HomogenMatrix; }
+namespace com::sun::star::drawing { struct PolyPolygonShape3D; }
+
+namespace chart
+{
+
+class ShapeFactory;
+
+/** allows the transformation of numeric values from one
+ coordinate-system into another. Values may be transformed using
+ any mapping.
+ This is a non-UNO variant of the css::chart2::XTransformation interface,
+ but using more efficient calling and returning types.
+ */
+class XTransformation2
+{
+public:
+ virtual ~XTransformation2();
+ /** transforms the given input data tuple, given in the source
+ coordinate system, according to the internal transformation
+ rules, into a tuple of transformed coordinates in the
+ destination coordinate system.
+
+ <p>Note that both coordinate systems may have different
+ dimensions, e.g., if a transformation does simply a projection
+ into a lower-dimensional space.</p>
+
+ @param aValues a source tuple of data that is to be
+ transformed. The length of this sequence must be
+ equivalent to the dimension of the source coordinate
+ system.
+
+ @return the transformed data tuple. The length of this
+ sequence is equal to the dimension of the output
+ coordinate system.
+
+ @throws ::com::sun::star::lang::IllegalArgumentException
+ if the dimension of the input vector is not equal to the
+ dimension given in getSourceDimension().
+ */
+ virtual css::drawing::Position3D transform(
+ const css::drawing::Position3D& rSourceValues ) const = 0;
+ virtual css::drawing::Position3D transform(
+ const css::uno::Sequence< double >& rSourceValues ) const = 0;
+};
+
+
+class PlottingPositionHelper
+{
+public:
+ PlottingPositionHelper();
+ PlottingPositionHelper( const PlottingPositionHelper& rSource );
+ virtual ~PlottingPositionHelper();
+
+ virtual std::unique_ptr<PlottingPositionHelper> clone() const;
+ std::unique_ptr<PlottingPositionHelper> createSecondaryPosHelper( const ExplicitScaleData& rSecondaryScale );
+
+ virtual void setTransformationSceneToScreen( const css::drawing::HomogenMatrix& rMatrix);
+
+ virtual void setScales( std::vector< ExplicitScaleData >&& rScales, bool bSwapXAndYAxis );
+ const std::vector< ExplicitScaleData >& getScales() const { return m_aScales;}
+
+ //better performance for big data
+ inline void setCoordinateSystemResolution( const css::uno::Sequence< sal_Int32 >& rCoordinateSystemResolution );
+ inline bool isSameForGivenResolution( double fX, double fY, double fZ
+ , double fX2, double fY2, double fZ2 );
+
+ inline bool isStrongLowerRequested( sal_Int32 nDimensionIndex ) const;
+ inline bool isLogicVisible( double fX, double fY, double fZ ) const;
+ inline void doLogicScaling( double* pX, double* pY, double* pZ ) const;
+ inline void doUnshiftedLogicScaling( double* pX, double* pY, double* pZ ) const;
+ inline void clipLogicValues( double* pX, double* pY, double* pZ ) const;
+ void clipScaledLogicValues( double* pX, double* pY, double* pZ ) const;
+ inline bool clipYRange( double& rMin, double& rMax ) const;
+
+ inline void doLogicScaling( css::drawing::Position3D& rPos ) const;
+
+ virtual ::chart::XTransformation2*
+ getTransformationScaledLogicToScene() const;
+
+ virtual css::drawing::Position3D
+ transformLogicToScene( double fX, double fY, double fZ, bool bClip ) const;
+
+ virtual css::drawing::Position3D
+ transformScaledLogicToScene( double fX, double fY, double fZ, bool bClip ) const;
+
+ void transformScaledLogicToScene( css::drawing::PolyPolygonShape3D& rPoly ) const;
+ void transformScaledLogicToScene( std::vector<std::vector<css::drawing::Position3D>>& rPoly ) const;
+
+ static css::awt::Point transformSceneToScreenPosition(
+ const css::drawing::Position3D& rScenePosition3D
+ , const rtl::Reference<SvxShapeGroupAnyD>& xSceneTarget
+ , sal_Int32 nDimensionCount );
+
+ inline double getLogicMinX() const;
+ inline double getLogicMinY() const;
+ inline double getLogicMinZ() const;
+ inline double getLogicMaxX() const;
+ inline double getLogicMaxY() const;
+ inline double getLogicMaxZ() const;
+
+ inline bool isMathematicalOrientationX() const;
+ inline bool isMathematicalOrientationY() const;
+ inline bool isMathematicalOrientationZ() const;
+
+ ::basegfx::B2DRectangle getScaledLogicClipDoubleRect() const;
+ css::drawing::Direction3D getScaledLogicWidth() const;
+
+ inline bool isSwapXAndY() const;
+
+ bool isPercentY() const;
+
+ double getBaseValueY() const;
+
+ inline bool maySkipPointsInRegressionCalculation() const;
+
+ void setTimeResolution( tools::Long nTimeResolution, const Date& rNullDate );
+ virtual void setScaledCategoryWidth( double fScaledCategoryWidth );
+ void AllowShiftXAxisPos( bool bAllowShift );
+ void AllowShiftZAxisPos( bool bAllowShift );
+
+protected: //member
+ std::vector< ExplicitScaleData > m_aScales;
+ ::basegfx::B3DHomMatrix m_aMatrixScreenToScene;
+
+ //this is calculated based on m_aScales and m_aMatrixScreenToScene
+ mutable std::unique_ptr< ::chart::XTransformation2 > m_xTransformationLogicToScene;
+
+ bool m_bSwapXAndY;//e.g. true for bar chart and false for column chart
+
+ sal_Int32 m_nXResolution;
+ sal_Int32 m_nYResolution;
+ sal_Int32 m_nZResolution;
+
+ bool m_bMaySkipPointsInRegressionCalculation;
+
+ bool m_bDateAxis;
+ tools::Long m_nTimeResolution;
+ Date m_aNullDate;
+
+ double m_fScaledCategoryWidth;
+ bool m_bAllowShiftXAxisPos;
+ bool m_bAllowShiftZAxisPos;
+};
+
+class PolarPlottingPositionHelper : public PlottingPositionHelper
+{
+public:
+ PolarPlottingPositionHelper();
+ PolarPlottingPositionHelper( const PolarPlottingPositionHelper& rSource );
+ virtual ~PolarPlottingPositionHelper() override;
+
+ virtual std::unique_ptr<PlottingPositionHelper> clone() const override;
+
+ virtual void setTransformationSceneToScreen( const css::drawing::HomogenMatrix& rMatrix) override;
+ virtual void setScales( std::vector< ExplicitScaleData >&& rScales, bool bSwapXAndYAxis ) override;
+
+ const ::basegfx::B3DHomMatrix& getUnitCartesianToScene() const { return m_aUnitCartesianToScene;}
+
+ virtual ::chart::XTransformation2*
+ getTransformationScaledLogicToScene() const override;
+
+ //the resulting values provided by the following 3 methods should be used
+ //for input to the transformation received with
+ //'getTransformationScaledLogicToScene'
+
+ /** Given a value in the radius axis scale range, it returns the normalized
+ * value.
+ */
+ double transformToRadius( double fLogicValueOnRadiusAxis, bool bDoScaling=true ) const;
+
+ /** Given a value in the angle axis scale range (e.g. [0,1] for pie charts)
+ * this method returns the related angle in degree.
+ */
+ double transformToAngleDegree( double fLogicValueOnAngleAxis, bool bDoScaling=true ) const;
+
+ /** Given 2 values in the angle axis scale range (e.g. [0,1] for pie charts)
+ * this method returns the angle between the 2 values keeping into account
+ * the correct axis orientation; (for instance, this method is used for
+ * computing the angle width of a pie slice).
+ */
+ double getWidthAngleDegree( double& fStartLogicValueOnAngleAxis, double& fEndLogicValueOnAngleAxis ) const;
+
+ virtual css::drawing::Position3D
+ transformLogicToScene( double fX, double fY, double fZ, bool bClip ) const override;
+ virtual css::drawing::Position3D
+ transformScaledLogicToScene( double fX, double fY, double fZ, bool bClip ) const override;
+ css::drawing::Position3D
+ transformAngleRadiusToScene( double fLogicValueOnAngleAxis, double fLogicValueOnRadiusAxis, double fLogicZ, bool bDoScaling=true ) const;
+
+ /** It returns the scene coordinates of the passed point: this point is
+ * described through a normalized cylindrical coordinate system.
+ * (For a pie chart the origin of the coordinate system is the pie center).
+ */
+ css::drawing::Position3D
+ transformUnitCircleToScene( double fUnitAngleDegree, double fUnitRadius, double fLogicZ ) const;
+
+ using PlottingPositionHelper::transformScaledLogicToScene;
+
+ double getOuterLogicRadius() const;
+
+ inline bool isMathematicalOrientationAngle() const;
+ inline bool isMathematicalOrientationRadius() const;
+public:
+ ///m_bSwapXAndY (inherited): by default the X axis (scale[0]) represents
+ ///the angle axis and the Y axis (scale[1]) represents the radius axis;
+ ///when this parameter is true, the opposite happens (this is the case for
+ ///pie charts).
+
+ ///Offset for radius axis in absolute logic scaled values (1.0 == 1 category)
+ ///For a donut, it represents the non-normalized inner radius (see notes for
+ ///transformToRadius)
+ double m_fRadiusOffset;
+ ///Offset for angle axis in real degree.
+ ///For a pie it represents the angle offset at which the first slice have to
+ ///start;
+ double m_fAngleDegreeOffset;
+
+private:
+ ::basegfx::B3DHomMatrix m_aUnitCartesianToScene;
+
+ ::basegfx::B3DHomMatrix impl_calculateMatrixUnitCartesianToScene( const ::basegfx::B3DHomMatrix& rMatrixScreenToScene ) const;
+};
+
+bool PolarPlottingPositionHelper::isMathematicalOrientationAngle() const
+{
+ const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[1] : m_aScales[2];
+ if( css::chart2::AxisOrientation_MATHEMATICAL==rScale.Orientation )
+ return true;
+ return false;
+}
+bool PolarPlottingPositionHelper::isMathematicalOrientationRadius() const
+{
+ const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[0] : m_aScales[1];
+ if( css::chart2::AxisOrientation_MATHEMATICAL==rScale.Orientation )
+ return true;
+ return false;
+}
+
+//better performance for big data
+void PlottingPositionHelper::setCoordinateSystemResolution( const css::uno::Sequence< sal_Int32 >& rCoordinateSystemResolution )
+{
+ m_nXResolution = 1000;
+ m_nYResolution = 1000;
+ m_nZResolution = 1000;
+ if( rCoordinateSystemResolution.getLength() > 0 )
+ m_nXResolution = rCoordinateSystemResolution[0];
+ if( rCoordinateSystemResolution.getLength() > 1 )
+ m_nYResolution = rCoordinateSystemResolution[1];
+ if( rCoordinateSystemResolution.getLength() > 2 )
+ m_nZResolution = rCoordinateSystemResolution[2];
+}
+
+bool PlottingPositionHelper::isSameForGivenResolution( double fX, double fY, double fZ
+ , double fX2, double fY2, double fZ2 /*these values are all expected tp be scaled already*/ )
+{
+ if( !std::isfinite(fX) || !std::isfinite(fY) || !std::isfinite(fZ)
+ || !std::isfinite(fX2) || !std::isfinite(fY2) || !std::isfinite(fZ2) )
+ return false;
+
+ double fScaledMinX = getLogicMinX();
+ double fScaledMinY = getLogicMinY();
+ double fScaledMinZ = getLogicMinZ();
+ double fScaledMaxX = getLogicMaxX();
+ double fScaledMaxY = getLogicMaxY();
+ double fScaledMaxZ = getLogicMaxZ();
+
+ doLogicScaling( &fScaledMinX, &fScaledMinY, &fScaledMinZ );
+ doLogicScaling( &fScaledMaxX, &fScaledMaxY, &fScaledMaxZ);
+
+ bool bSameX = ( static_cast<sal_Int32>(m_nXResolution*(fX - fScaledMinX)/(fScaledMaxX-fScaledMinX))
+ == static_cast<sal_Int32>(m_nXResolution*(fX2 - fScaledMinX)/(fScaledMaxX-fScaledMinX)) );
+
+ bool bSameY = ( static_cast<sal_Int32>(m_nYResolution*(fY - fScaledMinY)/(fScaledMaxY-fScaledMinY))
+ == static_cast<sal_Int32>(m_nYResolution*(fY2 - fScaledMinY)/(fScaledMaxY-fScaledMinY)) );
+
+ bool bSameZ = ( static_cast<sal_Int32>(m_nZResolution*(fZ - fScaledMinZ)/(fScaledMaxZ-fScaledMinZ))
+ == static_cast<sal_Int32>(m_nZResolution*(fZ2 - fScaledMinZ)/(fScaledMaxZ-fScaledMinZ)) );
+
+ return (bSameX && bSameY && bSameZ);
+}
+
+bool PlottingPositionHelper::isStrongLowerRequested( sal_Int32 nDimensionIndex ) const
+{
+ if( m_aScales.empty() )
+ return false;
+ if( 0==nDimensionIndex )
+ return m_bAllowShiftXAxisPos && m_aScales[nDimensionIndex].m_bShiftedCategoryPosition;
+ else if( 2==nDimensionIndex )
+ return m_bAllowShiftZAxisPos && m_aScales[nDimensionIndex].m_bShiftedCategoryPosition;
+ return false;
+}
+
+bool PlottingPositionHelper::isLogicVisible(
+ double fX, double fY, double fZ ) const
+{
+ return fX >= m_aScales[0].Minimum && ( isStrongLowerRequested(0) ? fX < m_aScales[0].Maximum : fX <= m_aScales[0].Maximum )
+ && fY >= m_aScales[1].Minimum && fY <= m_aScales[1].Maximum
+ && fZ >= m_aScales[2].Minimum && ( isStrongLowerRequested(2) ? fZ < m_aScales[2].Maximum : fZ <= m_aScales[2].Maximum );
+}
+
+void PlottingPositionHelper::doLogicScaling( double* pX, double* pY, double* pZ ) const
+{
+ if(pX)
+ {
+ if( m_aScales[0].Scaling.is())
+ *pX = m_aScales[0].Scaling->doScaling(*pX);
+ if( m_bAllowShiftXAxisPos && m_aScales[0].m_bShiftedCategoryPosition )
+ (*pX) += m_fScaledCategoryWidth/2.0;
+ }
+ if(pY && m_aScales[1].Scaling.is())
+ *pY = m_aScales[1].Scaling->doScaling(*pY);
+ if(pZ)
+ {
+ if( m_aScales[2].Scaling.is())
+ *pZ = m_aScales[2].Scaling->doScaling(*pZ);
+ if( m_bAllowShiftZAxisPos && m_aScales[2].m_bShiftedCategoryPosition)
+ (*pZ) += 0.5;
+ }
+}
+
+void PlottingPositionHelper::doUnshiftedLogicScaling( double* pX, double* pY, double* pZ ) const
+{
+ if(pX && m_aScales[0].Scaling.is())
+ *pX = m_aScales[0].Scaling->doScaling(*pX);
+ if(pY && m_aScales[1].Scaling.is())
+ *pY = m_aScales[1].Scaling->doScaling(*pY);
+ if(pZ && m_aScales[2].Scaling.is())
+ *pZ = m_aScales[2].Scaling->doScaling(*pZ);
+}
+
+void PlottingPositionHelper::doLogicScaling( css::drawing::Position3D& rPos ) const
+{
+ doLogicScaling( &rPos.PositionX, &rPos.PositionY, &rPos.PositionZ );
+}
+
+void PlottingPositionHelper::clipLogicValues( double* pX, double* pY, double* pZ ) const
+{
+ if(pX)
+ {
+ if( *pX < m_aScales[0].Minimum )
+ *pX = m_aScales[0].Minimum;
+ else if( *pX > m_aScales[0].Maximum )
+ *pX = m_aScales[0].Maximum;
+ }
+ if(pY)
+ {
+ if( *pY < m_aScales[1].Minimum )
+ *pY = m_aScales[1].Minimum;
+ else if( *pY > m_aScales[1].Maximum )
+ *pY = m_aScales[1].Maximum;
+ }
+ if(pZ)
+ {
+ if( *pZ < m_aScales[2].Minimum )
+ *pZ = m_aScales[2].Minimum;
+ else if( *pZ > m_aScales[2].Maximum )
+ *pZ = m_aScales[2].Maximum;
+ }
+}
+
+inline bool PlottingPositionHelper::clipYRange( double& rMin, double& rMax ) const
+{
+ //returns true if something remains
+ if( rMin > rMax )
+ {
+ double fHelp = rMin;
+ rMin = rMax;
+ rMax = fHelp;
+ }
+ if( rMin > getLogicMaxY() )
+ return false;
+ if( rMax < getLogicMinY() )
+ return false;
+ if( rMin < getLogicMinY() )
+ rMin = getLogicMinY();
+ if( rMax > getLogicMaxY() )
+ rMax = getLogicMaxY();
+ return true;
+}
+
+inline double PlottingPositionHelper::getLogicMinX() const
+{
+ return m_aScales[0].Minimum;
+}
+inline double PlottingPositionHelper::getLogicMinY() const
+{
+ return m_aScales[1].Minimum;
+}
+inline double PlottingPositionHelper::getLogicMinZ() const
+{
+ return m_aScales[2].Minimum;
+}
+
+inline double PlottingPositionHelper::getLogicMaxX() const
+{
+ return m_aScales[0].Maximum;
+}
+inline double PlottingPositionHelper::getLogicMaxY() const
+{
+ return m_aScales[1].Maximum;
+}
+inline double PlottingPositionHelper::getLogicMaxZ() const
+{
+ return m_aScales[2].Maximum;
+}
+inline bool PlottingPositionHelper::isMathematicalOrientationX() const
+{
+ return css::chart2::AxisOrientation_MATHEMATICAL == m_aScales[0].Orientation;
+}
+inline bool PlottingPositionHelper::isMathematicalOrientationY() const
+{
+ return css::chart2::AxisOrientation_MATHEMATICAL == m_aScales[1].Orientation;
+}
+inline bool PlottingPositionHelper::isMathematicalOrientationZ() const
+{
+ return css::chart2::AxisOrientation_MATHEMATICAL == m_aScales[2].Orientation;
+}
+inline bool PlottingPositionHelper::isSwapXAndY() const
+{
+ return m_bSwapXAndY;
+}
+inline bool PlottingPositionHelper::maySkipPointsInRegressionCalculation() const
+{
+ return m_bMaySkipPointsInRegressionCalculation;
+}
+
+} //namespace chart
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */