1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23 #ifndef _CHART2_PLOTTINGPOSITIONHELPER_HXX
24 #define _CHART2_PLOTTINGPOSITIONHELPER_HXX
25
26 #include "LabelAlignment.hxx"
27 #include "chartview/ExplicitScaleValues.hxx"
28
29 #include <basegfx/range/b2drectangle.hxx>
30 #include <rtl/math.hxx>
31 #include <com/sun/star/chart2/XTransformation.hpp>
32 #include <com/sun/star/drawing/Direction3D.hpp>
33 #include <com/sun/star/drawing/HomogenMatrix.hpp>
34 #include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
35 #include <com/sun/star/drawing/Position3D.hpp>
36 #include <com/sun/star/drawing/XShapes.hpp>
37 #include <basegfx/matrix/b3dhommatrix.hxx>
38
39 /*
40 //for WeakImplHelper1
41 #include <cppuhelper/implbase1.hxx>
42 */
43 //.............................................................................
44 namespace chart
45 {
46 //.............................................................................
47
48 class ShapeFactory;
49
50 //-----------------------------------------------------------------------------
51 /**
52 */
53
54 class PlottingPositionHelper
55 {
56 public:
57 PlottingPositionHelper();
58 PlottingPositionHelper( const PlottingPositionHelper& rSource );
59 virtual ~PlottingPositionHelper();
60
61 virtual PlottingPositionHelper* clone() const;
62 virtual PlottingPositionHelper* createSecondaryPosHelper( const ExplicitScaleData& rSecondaryScale );
63
64 virtual void setTransformationSceneToScreen( const ::com::sun::star::drawing::HomogenMatrix& rMatrix);
65
66 virtual void setScales( const ::std::vector< ExplicitScaleData >& rScales, bool bSwapXAndYAxis );
67 const ::std::vector< ExplicitScaleData >& getScales() const;
68
69 //better performance for big data
70 inline void setCoordinateSystemResolution( const ::com::sun::star::uno::Sequence< sal_Int32 >& rCoordinateSystemResolution );
71 inline bool isSameForGivenResolution( double fX, double fY, double fZ
72 , double fX2, double fY2, double fZ2 );
73
74 inline bool isStrongLowerRequested( sal_Int32 nDimensionIndex ) const;
75 inline bool isLogicVisible( double fX, double fY, double fZ ) const;
76 inline void doLogicScaling( double* pX, double* pY, double* pZ, bool bClip=false ) const;
77 inline void doUnshiftedLogicScaling( double* pX, double* pY, double* pZ, bool bClip=false ) const;
78 inline void clipLogicValues( double* pX, double* pY, double* pZ ) const;
79 void clipScaledLogicValues( double* pX, double* pY, double* pZ ) const;
80 inline bool clipYRange( double& rMin, double& rMax ) const;
81
82 inline void doLogicScaling( ::com::sun::star::drawing::Position3D& rPos, bool bClip=false ) const;
83
84 virtual ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XTransformation >
85 getTransformationScaledLogicToScene() const;
86
87 virtual ::com::sun::star::drawing::Position3D
88 transformLogicToScene( double fX, double fY, double fZ, bool bClip ) const;
89
90 virtual ::com::sun::star::drawing::Position3D
91 transformScaledLogicToScene( double fX, double fY, double fZ, bool bClip ) const;
92
93 void transformScaledLogicToScene( ::com::sun::star::drawing::PolyPolygonShape3D& rPoly ) const;
94
95 static com::sun::star::awt::Point transformSceneToScreenPosition(
96 const com::sun::star::drawing::Position3D& rScenePosition3D
97 , const com::sun::star::uno::Reference< com::sun::star::drawing::XShapes >& xSceneTarget
98 , ShapeFactory* pShapeFactory, sal_Int32 nDimensionCount );
99
100 inline double getLogicMinX() const;
101 inline double getLogicMinY() const;
102 inline double getLogicMinZ() const;
103 inline double getLogicMaxX() const;
104 inline double getLogicMaxY() const;
105 inline double getLogicMaxZ() const;
106
107 inline bool isMathematicalOrientationX() const;
108 inline bool isMathematicalOrientationY() const;
109 inline bool isMathematicalOrientationZ() const;
110
111 ::basegfx::B2DRectangle getScaledLogicClipDoubleRect() const;
112 ::com::sun::star::drawing::Direction3D getScaledLogicWidth() const;
113
114 inline bool isSwapXAndY() const;
115
116 bool isPercentY() const;
117
118 double getBaseValueY() const;
119
120 inline bool maySkipPointsInRegressionCalculation() const;
121
122 void setTimeResolution( long nTimeResolution, const Date& rNullDate );
123 virtual void setScaledCategoryWidth( double fScaledCategoryWidth );
124 void AllowShiftXAxisPos( bool bAllowShift );
125 void AllowShiftZAxisPos( bool bAllowShift );
126
127 protected: //member
128 ::std::vector< ExplicitScaleData > m_aScales;
129 ::basegfx::B3DHomMatrix m_aMatrixScreenToScene;
130
131 //this is calculated based on m_aScales and m_aMatrixScreenToScene
132 mutable ::com::sun::star::uno::Reference<
133 ::com::sun::star::chart2::XTransformation > m_xTransformationLogicToScene;
134
135 bool m_bSwapXAndY;//e.g. true for bar chart and false for column chart
136
137 sal_Int32 m_nXResolution;
138 sal_Int32 m_nYResolution;
139 sal_Int32 m_nZResolution;
140
141 bool m_bMaySkipPointsInRegressionCalculation;
142
143 bool m_bDateAxis;
144 long m_nTimeResolution;
145 Date m_aNullDate;
146
147 double m_fScaledCategoryWidth;
148 bool m_bAllowShiftXAxisPos;
149 bool m_bAllowShiftZAxisPos;
150 };
151
152 //describes wich axis of the drawinglayer scene or sreen axis are the normal axis
153 enum NormalAxis
154 {
155 NormalAxis_X
156 , NormalAxis_Y
157 , NormalAxis_Z
158 };
159
160 class PolarPlottingPositionHelper : public PlottingPositionHelper
161 /*
162 , public ::cppu::WeakImplHelper1<
163 ::com::sun::star::chart2::XTransformation >
164 */
165 {
166 public:
167 PolarPlottingPositionHelper( NormalAxis eNormalAxis=NormalAxis_Z );
168 PolarPlottingPositionHelper( const PolarPlottingPositionHelper& rSource );
169 virtual ~PolarPlottingPositionHelper();
170
171 virtual PlottingPositionHelper* clone() const;
172
173 virtual void setTransformationSceneToScreen( const ::com::sun::star::drawing::HomogenMatrix& rMatrix);
174 virtual void setScales( const std::vector< ExplicitScaleData >& rScales, bool bSwapXAndYAxis );
175
176 ::basegfx::B3DHomMatrix getUnitCartesianToScene() const;
177
178 virtual ::com::sun::star::uno::Reference< ::com::sun::star::chart2::XTransformation >
179 getTransformationScaledLogicToScene() const;
180
181 //the resulting values should be used for input to the transformation
182 //received with 'getTransformationScaledLogicToScene'
183 double transformToRadius( double fLogicValueOnRadiusAxis, bool bDoScaling=true ) const;
184 double transformToAngleDegree( double fLogicValueOnAngleAxis, bool bDoScaling=true ) const;
185 double getWidthAngleDegree( double& fStartLogicValueOnAngleAxis, double& fEndLogicValueOnAngleAxis ) const;
186 //
187
188 virtual ::com::sun::star::drawing::Position3D
189 transformLogicToScene( double fX, double fY, double fZ, bool bClip ) const;
190 virtual ::com::sun::star::drawing::Position3D
191 transformScaledLogicToScene( double fX, double fY, double fZ, bool bClip ) const;
192 ::com::sun::star::drawing::Position3D
193 transformAngleRadiusToScene( double fLogicValueOnAngleAxis, double fLogicValueOnRadiusAxis, double fLogicZ, bool bDoScaling=true ) const;
194 ::com::sun::star::drawing::Position3D
195 transformUnitCircleToScene( double fUnitAngleDegree, double fUnitRadius, double fLogicZ, bool bDoScaling=true ) const;
196
197 using PlottingPositionHelper::transformScaledLogicToScene;
198
199 #ifdef NOTYET
200 double getInnerLogicRadius() const;
201 #endif
202 double getOuterLogicRadius() const;
203
204 inline bool isMathematicalOrientationAngle() const;
205 inline bool isMathematicalOrientationRadius() const;
206
207 /*
208 // ____ XTransformation ____
209 /// @see ::com::sun::star::chart2::XTransformation
210 virtual ::com::sun::star::uno::Sequence< double > SAL_CALL transform(
211 const ::com::sun::star::uno::Sequence< double >& rSourceValues )
212 throw (::com::sun::star::lang::IllegalArgumentException,
213 ::com::sun::star::uno::RuntimeException);
214 /// @see ::com::sun::star::chart2::XTransformation
215 virtual sal_Int32 SAL_CALL getSourceDimension()
216 throw (::com::sun::star::uno::RuntimeException);
217 /// @see ::com::sun::star::chart2::XTransformation
218 virtual sal_Int32 SAL_CALL getTargetDimension()
219 throw (::com::sun::star::uno::RuntimeException);
220 */
221 public:
222 //Offset for radius axis in absolute logic scaled values (1.0 == 1 category)
223 double m_fRadiusOffset;
224 //Offset for angle axis in real degree
225 double m_fAngleDegreeOffset;
226
227 private:
228 ::basegfx::B3DHomMatrix m_aUnitCartesianToScene;
229 NormalAxis m_eNormalAxis;
230
231 ::basegfx::B3DHomMatrix impl_calculateMatrixUnitCartesianToScene( const ::basegfx::B3DHomMatrix& rMatrixScreenToScene ) const;
232 };
233
isMathematicalOrientationAngle() const234 bool PolarPlottingPositionHelper::isMathematicalOrientationAngle() const
235 {
236 const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[1] : m_aScales[2];
237 if( ::com::sun::star::chart2::AxisOrientation_MATHEMATICAL==rScale.Orientation )
238 return true;
239 return false;
240 }
isMathematicalOrientationRadius() const241 bool PolarPlottingPositionHelper::isMathematicalOrientationRadius() const
242 {
243 const ExplicitScaleData& rScale = m_bSwapXAndY ? m_aScales[0] : m_aScales[1];
244 if( ::com::sun::star::chart2::AxisOrientation_MATHEMATICAL==rScale.Orientation )
245 return true;
246 return false;
247 }
248
249 //better performance for big data
setCoordinateSystemResolution(const::com::sun::star::uno::Sequence<sal_Int32> & rCoordinateSystemResolution)250 void PlottingPositionHelper::setCoordinateSystemResolution( const ::com::sun::star::uno::Sequence< sal_Int32 >& rCoordinateSystemResolution )
251 {
252 m_nXResolution = 1000;
253 m_nYResolution = 1000;
254 m_nZResolution = 1000;
255 if( rCoordinateSystemResolution.getLength() > 0 )
256 m_nXResolution = rCoordinateSystemResolution[0];
257 if( rCoordinateSystemResolution.getLength() > 1 )
258 m_nYResolution = rCoordinateSystemResolution[1];
259 if( rCoordinateSystemResolution.getLength() > 2 )
260 m_nZResolution = rCoordinateSystemResolution[2];
261 }
262
isSameForGivenResolution(double fX,double fY,double fZ,double fX2,double fY2,double fZ2)263 bool PlottingPositionHelper::isSameForGivenResolution( double fX, double fY, double fZ
264 , double fX2, double fY2, double fZ2 /*these values are all expected tp be scaled already*/ )
265 {
266 if( !::rtl::math::isFinite(fX) || !::rtl::math::isFinite(fY) || !::rtl::math::isFinite(fZ)
267 || !::rtl::math::isFinite(fX2) || !::rtl::math::isFinite(fY2) || !::rtl::math::isFinite(fZ2) )
268 return false;
269
270 double fScaledMinX = getLogicMinX();
271 double fScaledMinY = getLogicMinY();
272 double fScaledMinZ = getLogicMinZ();
273 double fScaledMaxX = getLogicMaxX();
274 double fScaledMaxY = getLogicMaxY();
275 double fScaledMaxZ = getLogicMaxZ();
276
277 doLogicScaling( &fScaledMinX, &fScaledMinY, &fScaledMinZ );
278 doLogicScaling( &fScaledMaxX, &fScaledMaxY, &fScaledMaxZ);
279
280 bool bSameX = ( static_cast<sal_Int32>(m_nXResolution*(fX - fScaledMinX)/(fScaledMaxX-fScaledMinX))
281 == static_cast<sal_Int32>(m_nXResolution*(fX2 - fScaledMinX)/(fScaledMaxX-fScaledMinX)) );
282
283 bool bSameY = ( static_cast<sal_Int32>(m_nYResolution*(fY - fScaledMinY)/(fScaledMaxY-fScaledMinY))
284 == static_cast<sal_Int32>(m_nYResolution*(fY2 - fScaledMinY)/(fScaledMaxY-fScaledMinY)) );
285
286 bool bSameZ = ( static_cast<sal_Int32>(m_nZResolution*(fZ - fScaledMinZ)/(fScaledMaxZ-fScaledMinZ))
287 == static_cast<sal_Int32>(m_nZResolution*(fZ2 - fScaledMinZ)/(fScaledMaxZ-fScaledMinZ)) );
288
289 return (bSameX && bSameY && bSameZ);
290 }
291
isStrongLowerRequested(sal_Int32 nDimensionIndex) const292 bool PlottingPositionHelper::isStrongLowerRequested( sal_Int32 nDimensionIndex ) const
293 {
294 if( m_aScales.empty() )
295 return false;
296 if( 0==nDimensionIndex )
297 return m_bAllowShiftXAxisPos && m_aScales[nDimensionIndex].ShiftedCategoryPosition;
298 else if( 2==nDimensionIndex )
299 return m_bAllowShiftZAxisPos && m_aScales[nDimensionIndex].ShiftedCategoryPosition;
300 return false;
301 }
302
isLogicVisible(double fX,double fY,double fZ) const303 bool PlottingPositionHelper::isLogicVisible(
304 double fX, double fY, double fZ ) const
305 {
306 return fX >= m_aScales[0].Minimum && ( isStrongLowerRequested(0) ? fX < m_aScales[0].Maximum : fX <= m_aScales[0].Maximum )
307 && fY >= m_aScales[1].Minimum && fY <= m_aScales[1].Maximum
308 && fZ >= m_aScales[2].Minimum && ( isStrongLowerRequested(2) ? fZ < m_aScales[2].Maximum : fZ <= m_aScales[2].Maximum );
309 }
310
doLogicScaling(double * pX,double * pY,double * pZ,bool bClip) const311 void PlottingPositionHelper::doLogicScaling( double* pX, double* pY, double* pZ, bool bClip ) const
312 {
313 if(bClip)
314 this->clipLogicValues( pX,pY,pZ );
315
316 if(pX)
317 {
318 if( m_aScales[0].Scaling.is())
319 *pX = m_aScales[0].Scaling->doScaling(*pX);
320 if( m_bAllowShiftXAxisPos && m_aScales[0].ShiftedCategoryPosition )
321 (*pX) += m_fScaledCategoryWidth/2.0;
322 }
323 if(pY && m_aScales[1].Scaling.is())
324 *pY = m_aScales[1].Scaling->doScaling(*pY);
325 if(pZ)
326 {
327 if( m_aScales[2].Scaling.is())
328 *pZ = m_aScales[2].Scaling->doScaling(*pZ);
329 if( m_bAllowShiftZAxisPos && m_aScales[2].ShiftedCategoryPosition)
330 (*pZ) += 0.5;
331 }
332 }
333
doUnshiftedLogicScaling(double * pX,double * pY,double * pZ,bool bClip) const334 void PlottingPositionHelper::doUnshiftedLogicScaling( double* pX, double* pY, double* pZ, bool bClip ) const
335 {
336 if(bClip)
337 this->clipLogicValues( pX,pY,pZ );
338
339 if(pX && m_aScales[0].Scaling.is())
340 *pX = m_aScales[0].Scaling->doScaling(*pX);
341 if(pY && m_aScales[1].Scaling.is())
342 *pY = m_aScales[1].Scaling->doScaling(*pY);
343 if(pZ && m_aScales[2].Scaling.is())
344 *pZ = m_aScales[2].Scaling->doScaling(*pZ);
345 }
346
doLogicScaling(::com::sun::star::drawing::Position3D & rPos,bool bClip) const347 void PlottingPositionHelper::doLogicScaling( ::com::sun::star::drawing::Position3D& rPos, bool bClip ) const
348 {
349 doLogicScaling( &rPos.PositionX, &rPos.PositionY, &rPos.PositionZ, bClip );
350 }
351
clipLogicValues(double * pX,double * pY,double * pZ) const352 void PlottingPositionHelper::clipLogicValues( double* pX, double* pY, double* pZ ) const
353 {
354 if(pX)
355 {
356 if( *pX < m_aScales[0].Minimum )
357 *pX = m_aScales[0].Minimum;
358 else if( *pX > m_aScales[0].Maximum )
359 *pX = m_aScales[0].Maximum;
360 }
361 if(pY)
362 {
363 if( *pY < m_aScales[1].Minimum )
364 *pY = m_aScales[1].Minimum;
365 else if( *pY > m_aScales[1].Maximum )
366 *pY = m_aScales[1].Maximum;
367 }
368 if(pZ)
369 {
370 if( *pZ < m_aScales[2].Minimum )
371 *pZ = m_aScales[2].Minimum;
372 else if( *pZ > m_aScales[2].Maximum )
373 *pZ = m_aScales[2].Maximum;
374 }
375 }
376
clipYRange(double & rMin,double & rMax) const377 inline bool PlottingPositionHelper::clipYRange( double& rMin, double& rMax ) const
378 {
379 //returns true if something remains
380 if( rMin > rMax )
381 {
382 double fHelp = rMin;
383 rMin = rMax;
384 rMax = fHelp;
385 }
386 if( rMin > getLogicMaxY() )
387 return false;
388 if( rMax < getLogicMinY() )
389 return false;
390 if( rMin < getLogicMinY() )
391 rMin = getLogicMinY();
392 if( rMax > getLogicMaxY() )
393 rMax = getLogicMaxY();
394 return true;
395 }
396
getLogicMinX() const397 inline double PlottingPositionHelper::getLogicMinX() const
398 {
399 return m_aScales[0].Minimum;
400 }
getLogicMinY() const401 inline double PlottingPositionHelper::getLogicMinY() const
402 {
403 return m_aScales[1].Minimum;
404 }
getLogicMinZ() const405 inline double PlottingPositionHelper::getLogicMinZ() const
406 {
407 return m_aScales[2].Minimum;
408 }
409
getLogicMaxX() const410 inline double PlottingPositionHelper::getLogicMaxX() const
411 {
412 return m_aScales[0].Maximum;
413 }
getLogicMaxY() const414 inline double PlottingPositionHelper::getLogicMaxY() const
415 {
416 return m_aScales[1].Maximum;
417 }
getLogicMaxZ() const418 inline double PlottingPositionHelper::getLogicMaxZ() const
419 {
420 return m_aScales[2].Maximum;
421 }
isMathematicalOrientationX() const422 inline bool PlottingPositionHelper::isMathematicalOrientationX() const
423 {
424 return ::com::sun::star::chart2::AxisOrientation_MATHEMATICAL == m_aScales[0].Orientation;
425 }
isMathematicalOrientationY() const426 inline bool PlottingPositionHelper::isMathematicalOrientationY() const
427 {
428 return ::com::sun::star::chart2::AxisOrientation_MATHEMATICAL == m_aScales[1].Orientation;
429 }
isMathematicalOrientationZ() const430 inline bool PlottingPositionHelper::isMathematicalOrientationZ() const
431 {
432 return ::com::sun::star::chart2::AxisOrientation_MATHEMATICAL == m_aScales[2].Orientation;
433 }
isSwapXAndY() const434 inline bool PlottingPositionHelper::isSwapXAndY() const
435 {
436 return m_bSwapXAndY;
437 }
maySkipPointsInRegressionCalculation() const438 inline bool PlottingPositionHelper::maySkipPointsInRegressionCalculation() const
439 {
440 return m_bMaySkipPointsInRegressionCalculation;
441 }
442
443 //.............................................................................
444 } //namespace chart
445 //.............................................................................
446 #endif
447