You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/kchart/kdchart/KDChartBWPainter.cpp

484 lines
20 KiB

/* -*- Mode: C++ -*-
KDChart - a multi-platform charting engine
*/
/****************************************************************************
** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB. All rights reserved.
**
** This file is part of the KDChart library.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid commercial KDChart licenses may use this file in
** accordance with the KDChart Commercial License Agreement provided with
** the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.klaralvdalens-datakonsult.se/?page=products for
** information about KDChart Commercial License Agreements.
**
** Contact info@klaralvdalens-datakonsult.se if any conditions of this
** licensing are not clear to you.
**
**********************************************************************/
#include "KDChartBWPainter.h"
#include <KDChartParams.h>
#include "KDChartTextPiece.h"
#include <tqpainter.h>
#if COMPAT_TQT_VERSION >= 0x030000
#include <tqmemarray.h>
#else
#include <tqarray.h>
#define TQMemArray TQArray
#endif
#include <stdlib.h>
/**
\class KDChartBWPainter KDChartBWPainter.h
\brief A chart painter implementation that can paint Box&Whisker charts.
*/
/**
Constructor. Sets up internal data structures as necessary.
\param params the KDChartParams structure that defines the chart
*/
KDChartBWPainter::KDChartBWPainter( KDChartParams* params ) :
KDChartAxesPainter( params )
{
// This constructor intentionally left blank so far; we cannot setup the
// tqgeometry yet since we do not know the size of the painter.
}
/**
Destructor.
*/
KDChartBWPainter::~KDChartBWPainter()
{
// intentionally left blank
}
void quicksort( TQMemArray<double>& a, int lo, int hi )
{
int i=lo, j=hi;
double h;
double x=a[(lo+hi)/2];
do
{
while (a[i]<x) i++;
while (a[j]>x) j--;
if (i<=j)
{
h=a[i]; a[i]=a[j]; a[j]=h;
i++; j--;
}
} while (i<=j);
if (lo<j) quicksort(a, lo, j);
if (i<hi) quicksort(a, i, hi);
}
// The following function returns the number of used cells containing a double.
int KDChartBWPainter::calculateStats( KDChartTableDataBase& data,
uint dataset )
{
const uint nMax = data.usedCols();
int nUsed = 0;
TQMemArray<double> values( nMax );
double sum = 0.0;
TQVariant vVal;
if( data.sorted() ){
for( uint i=0; i<nMax; ++i){
if( data.cellCoord( dataset, i, vVal, 1 ) &&
TQVariant::Double == vVal.type() ) {
values[nUsed] = vVal.toDouble();
sum += values[nUsed];
++nUsed;
}
}
}else{
// make copy of the dataset and look if it is sorted
bool sorted = true;
double last = 0.0; // <-- avoids an annoying compile-time warning
for( uint i=0; i<nMax; ++i){
if( data.cellCoord( dataset, i, vVal, 1 ) &&
TQVariant::Double == vVal.type() ) {
values[nUsed] = vVal.toDouble();
if( nUsed // skip 1st value
&& last > values[nUsed] )
sorted = false;
last = values[nUsed];
sum += last;
++nUsed;
}
}
if( !sorted ){
// sort our copy of the dataset
quicksort( values, 0, nUsed-1 );
}
}
// Values now contains all used values without empty gaps.
// nUsed contains their number, so values[nUsed-1] is the last value.
if( nUsed ){
// store some values
stats[ KDChartParams::MaxValue ] = values[nUsed-1];
stats[ KDChartParams::MinValue ] = values[0];
stats[ KDChartParams::MeanValue ] = sum / nUsed;
// calculate statistics
bool bOdd = 1 == nUsed % 2;
// find median
int nUd2 = nUsed/2;
if( bOdd )
stats[ KDChartParams::Median ] = values[ nUd2 ];
else
stats[ KDChartParams::Median ] =
(values[ TQMAX(nUd2-1, 0) ] + values[ nUd2 ]) /2;
// find last value of lower quartile
nLastQ1 = TQMAX( nUd2-1, 0 );
// find 1st value of lower quartile
nFirstQ1 = nLastQ1 / 2;
// determine how many values are below the median ( == how many are above it)
int nLowerCount = nLastQ1 - nFirstQ1 + 1;
// find 1st value of upper quartile
nFirstQ3 = bOdd ? TQMIN( nUd2+1, nUsed-1 ) : nUd2;
// find last value of upper quartile
nLastQ3 = nFirstQ3 + nLowerCount - 1;
// find quartiles
bool bOdd2 = 1 == nLowerCount % 2;
// find lower quartile
if( bOdd2 )
stats[ KDChartParams::Quartile1 ] = values[ nFirstQ1 ];
else
stats[ KDChartParams::Quartile1 ] =
(values[ TQMAX(nFirstQ1-1, 0) ] + values[ nFirstQ1 ]) /2;
// find upper quartile
if( bOdd2 ){
stats[ KDChartParams::Quartile3 ] = values[ nLastQ3 ];
}
else{
//qDebug(" "+TQString::number(nLastQ3)+" "+TQString::number(KDChartParams::Quartile3)
// +" "+TQString::number(nUsed)+" "+TQString::number(TQMIN(nLastQ3+1, nUsed-1)));
stats[ KDChartParams::Quartile3 ] =
(values[ nLastQ3 ] + values[ TQMIN(nLastQ3+1, nUsed-1) ]) /2;
}
// find the interquartile range (IQR)
double iqr = stats[ KDChartParams::Quartile3 ] - stats[ KDChartParams::Quartile1 ];
// calculate the fences
double upperInner, lowerInner, upperOuter, lowerOuter;
params()->bWChartFences( upperInner, lowerInner,
upperOuter, lowerOuter );
stats[ KDChartParams::UpperInnerFence ] =
stats[ KDChartParams::Quartile3 ] + iqr * upperInner;
stats[ KDChartParams::LowerInnerFence ] =
stats[ KDChartParams::Quartile1 ] - iqr * lowerInner;
stats[ KDChartParams::UpperOuterFence ] =
stats[ KDChartParams::Quartile3 ] + iqr * upperOuter;
stats[ KDChartParams::LowerOuterFence ] =
stats[ KDChartParams::Quartile1 ] - iqr * lowerOuter;
}
return nUsed;
}
/**
This method is a specialization that returns a fallback legend text
appropriate for BW that do not have the same notion of a dataset like
e.g. bars.
This method is only used when automatic legends are used, because
manual and first-column legends do not need fallback texts.
\param uint dataset the dataset number for which to generate a
fallback text
\return the fallback text to use for describing the specified
dataset in the legend
*/
TQString KDChartBWPainter::fallbackLegendText( uint dataset ) const
{
return TQObject::tr( "Series " ) + TQString::number( dataset + 1 );
}
/**
This methods returns the number of elements to be shown in the
legend in case fallback texts are used.
This method is only used when automatic legends are used, because
manual and first-column legends do not need fallback texts.
\return the number of fallback texts to use
*/
uint KDChartBWPainter::numLegendFallbackTexts( KDChartTableDataBase* data ) const
{
return data->usedRows();
}
bool KDChartBWPainter::isNormalMode() const
{
return KDChartParams::BWNormal == params()->bWChartSubType();
}
int KDChartBWPainter::clipShiftUp( bool, double ) const
{
return 0;
}
/**
Paints the actual data area and registers the region for the data
points if \a regions is not 0.
\param painter the TQPainter onto which the chart should be painted
\param data the data that will be displayed as a chart
\param paint2nd specifies whether the main chart or the additional chart is to be drawn now
\param regions a pointer to a list of regions that will be filled
with regions representing the data segments, if not null
*/
void KDChartBWPainter::specificPaintData( TQPainter* painter,
const TQRect& ourClipRect,
KDChartTableDataBase* data,
KDChartDataRegionList* /*regions*/,
const KDChartAxisParams* axisPara,
bool /*bNormalMode*/,
uint /*chart*/,
double logWidth,
double /*areaWidthP1000*/,
double logHeight,
double /*axisYOffset*/,
double /*minColumnValue*/,
double /*maxColumnValue*/,
double /*columnValueDistance*/,
uint chartDatasetStart,
uint chartDatasetEnd,
uint datasetStart,
uint datasetEnd )
{
//double areaHeightP1000 = logHeight / 1000.0;
uint datasetNum = ( chartDatasetEnd - chartDatasetStart ) + 1;
double pixelsPerUnit = 0.0;
if( 0.0 != axisPara->trueAxisHigh() - axisPara->trueAxisLow() )
pixelsPerUnit = logHeight / (axisPara->trueAxisHigh() - axisPara->trueAxisLow());
else
pixelsPerUnit = logHeight / 10;
// Distance between the individual "stocks"
double pointDist = logWidth / ( ( double ) datasetNum );
// compute the position of the 0 axis
double zeroXAxisI = axisPara->axisZeroLineStartY() - _dataRect.y();
const int lineWidth = static_cast<int>( pointDist / 66.0 ) * TQMAX(params()->lineWidth(), 1);
const int lineWidthD2 = lineWidth * 2 / 3;
const bool noBrush = TQt::NoBrush == params()->bWChartBrush().style();
// Loop over the datasets, draw one box and whisker tqshape for each series.
for ( uint dataset = chartDatasetStart;
dataset <= chartDatasetEnd;
++dataset ) {
if( dataset >= datasetStart &&
dataset <= datasetEnd &&
0 < calculateStats( *data, dataset ) ) {
const TQColor color( params()->dataColor( dataset ) );
// transform calculated values
double drawUOF = stats[ KDChartParams::UpperOuterFence ] * pixelsPerUnit;
double drawUIF = stats[ KDChartParams::UpperInnerFence ] * pixelsPerUnit;
double drawQu3 = stats[ KDChartParams::Quartile3 ] * pixelsPerUnit;
double drawMed = stats[ KDChartParams::Median ] * pixelsPerUnit;
double drawQu1 = stats[ KDChartParams::Quartile1 ] * pixelsPerUnit;
double drawLIF = stats[ KDChartParams::LowerInnerFence ] * pixelsPerUnit;
double drawLOF = stats[ KDChartParams::LowerOuterFence ] * pixelsPerUnit;
double drawMax = stats[ KDChartParams::MaxValue ] * pixelsPerUnit;
double drawMin = stats[ KDChartParams::MinValue ] * pixelsPerUnit;
double drawMean= stats[ KDChartParams::MeanValue ] * pixelsPerUnit;
// get whisker values
double drawUWhisker = TQMIN(drawUIF, drawMax);
double drawLWhisker = TQMAX(drawLIF, drawMin);
// get the box width
const int boxWidth = TQMAX( 6, static_cast<int>( pointDist * 0.2 ) );
// get marker size (for the outliers and/or for the median value)
int markWidth = params()->bWChartOutValMarkerSize();
bool drawOutliers = ( 0 != markWidth );
if( drawOutliers ){
if( 0 > markWidth)
markWidth = TQMAX( 4, markWidth * boxWidth / -100 );
else
markWidth = TQMAX( 4, markWidth );
}
else
markWidth = boxWidth * 25 / 100; // use the default for the Median marker
painter->setPen( TQPen( color, lineWidth ) );
painter->setBrush( params()->bWChartBrush() );
// draw the box
int boxWidthD2 = boxWidth / 2;
int xPos = static_cast<int>(
pointDist * ( (double)(dataset - chartDatasetStart) + 0.5 )
- lineWidth / 2);
painter->drawRect( xPos - boxWidthD2,
static_cast<int>( zeroXAxisI - drawQu3 ),
boxWidth,
static_cast<int>( drawQu3 - drawQu1) + 1 );
// draw the median
painter->drawLine( xPos - boxWidthD2,
static_cast<int>( zeroXAxisI - drawMed ),
xPos - boxWidthD2 + boxWidth,
static_cast<int>( zeroXAxisI - drawMed ) );
// draw the whisker
painter->drawLine( xPos - boxWidthD2,
static_cast<int>( zeroXAxisI - drawUWhisker ),
xPos - boxWidthD2 + boxWidth,
static_cast<int>( zeroXAxisI - drawUWhisker ) );
painter->drawLine( xPos,
static_cast<int>( zeroXAxisI - drawUWhisker ),
xPos,
static_cast<int>( zeroXAxisI - drawQu3 ) );
painter->drawLine( xPos - boxWidthD2,
static_cast<int>( zeroXAxisI - drawLWhisker ),
xPos - boxWidthD2 + boxWidth,
static_cast<int>( zeroXAxisI - drawLWhisker ) );
painter->drawLine( xPos,
static_cast<int>( zeroXAxisI - drawLWhisker ),
xPos,
static_cast<int>( zeroXAxisI - drawQu1 ) );
// draw the values
int xPos2 = static_cast<int>(
pointDist * ( (double)(dataset - chartDatasetStart) + 0.5 )
- lineWidthD2 / 2);
int markWidthD2 = TQMAX(markWidth / 2, 2);
int markWidthD25 = TQMAX(static_cast<int>( 0.85 * markWidth / 2.0), 2);
int markWidthD35 = TQMAX(static_cast<int>( 0.85 * markWidth / 3.0), 2);
// draw the outliers
if( drawOutliers ){
const uint nMax = data->usedCols();
int drawVal;
TQVariant vVal;
for( uint i=0; i<nMax; ++i)
if( data->cellCoord( dataset, i, vVal, 1 ) &&
TQVariant::Double == vVal.type() ) {
drawVal = static_cast<int>( pixelsPerUnit * vVal.toDouble() );
if( drawLOF > drawVal || drawUOF < drawVal ) {
painter->setPen( TQt::NoPen );
painter->drawChord( xPos2 - markWidthD2,
static_cast<int>(zeroXAxisI - drawVal) - markWidthD2,
markWidth,
markWidth,
0, 5760 );
painter->setPen( TQPen( color, lineWidthD2 ) );
painter->drawArc( xPos2 - markWidthD2,
static_cast<int>(zeroXAxisI - drawVal) - markWidthD2,
markWidth,
markWidth,
0, 5760 );
} else if( drawLIF > drawVal || drawUIF < drawVal ) {
painter->setPen( TQt::NoPen );
painter->drawChord( xPos2 - markWidthD2,
static_cast<int>( zeroXAxisI - drawVal) - markWidthD2,
markWidth,
markWidth,
0, 5760 );
painter->setPen( TQPen( color, lineWidthD2 ) );
painter->drawLine( xPos2,
static_cast<int>(zeroXAxisI - drawVal) - markWidthD2,
xPos2,
static_cast<int>(zeroXAxisI - drawVal) + markWidthD2 );
painter->drawLine( xPos2 - markWidthD25,
static_cast<int>(zeroXAxisI - drawVal) - markWidthD35,
xPos2 + markWidthD25,
static_cast<int>(zeroXAxisI - drawVal) + markWidthD35 );
painter->drawLine( xPos2 + markWidthD25,
static_cast<int>(zeroXAxisI - drawVal) - markWidthD35,
xPos2 - markWidthD25,
static_cast<int>(zeroXAxisI - drawVal) + markWidthD35 );
}
}
}
// draw the mean value
bool evenLineWidthD2 = floor( ((double)lineWidthD2)/2.0 ) == ((double)lineWidthD2)/2.0;
painter->setPen( params()->bWChartBrush().color() );
painter->drawChord( xPos2 - markWidthD2-1 - (evenLineWidthD2 ? 0 : 1),
static_cast<int>( zeroXAxisI - drawMean ) - markWidthD2 - 1,
markWidthD2*2 + (evenLineWidthD2 ? 2 : 3),
markWidthD2*2 + (evenLineWidthD2 ? 2 : 3),
0, 5760 );
if( noBrush ) {
// use different color brightness for the Mean marker
int h,s,v;
color.hsv(&h,&s,&v);
painter->setPen( TQPen( 128 > v ? color.light(150) : color.dark(150),
lineWidthD2 ) );
} else
painter->setPen( TQPen( color, lineWidthD2 ) );
painter->drawLine( xPos2 - markWidthD2 - (evenLineWidthD2 ? 0 : 1),
static_cast<int>( zeroXAxisI - drawMean ),
xPos2 + markWidthD2,
static_cast<int>( zeroXAxisI - drawMean ) );
painter->drawLine( xPos2 - (evenLineWidthD2 ? 0 : 1),
static_cast<int>( zeroXAxisI - drawMean ) - markWidthD2,
xPos2 - (evenLineWidthD2 ? 0 : 1),
static_cast<int>( zeroXAxisI - drawMean ) + markWidthD2 + (evenLineWidthD2 ? 0 : 1) );
// draw the statistical value texts
painter->setPen( TQt::NoPen );
for( int ii = KDChartParams::BWStatValSTART;
ii <= KDChartParams::BWStatValEND;
++ii ){
KDChartParams::BWStatVal i = (KDChartParams::BWStatVal)ii;
if( params()->bWChartPrintStatistics( i ) ) {
TQFont statFont( params()->bWChartStatisticsFont( i ) );
float nTxtHeight = statFont.pointSizeFloat();
if ( params()->bWChartStatisticsUseRelSize( i ) ) {
nTxtHeight = params()->bWChartStatisticsFontRelSize( i )
* boxWidth / 100;
statFont.setPointSizeFloat( nTxtHeight );
}
double drawStat = pixelsPerUnit * stats[i];
KDChartTextPiece statText( painter, TQString::number( stats[i] ),
statFont );
int tw = statText.width();
int xDelta = ( KDChartParams::MaxValue == i
|| KDChartParams::MeanValue == i
|| KDChartParams::MinValue == i )
? -1 * (tw + static_cast<int>( 1.3*boxWidthD2 ))
: static_cast<int>( 1.3*boxWidthD2 );
TQBrush brush( params()->bWChartStatisticsBrush( i ) );
painter->setBrush( brush );
int y = static_cast<int>( zeroXAxisI - drawStat - nTxtHeight/2);
painter->drawRect( xPos + xDelta - 1,
y,
tw + 2,
TQMAX(static_cast < int > ( nTxtHeight ), 8) + 1 );
statText.draw( painter,
xPos + xDelta,
y,
ourClipRect,
params()->bWChartStatisticsColor( i ),
0 );
}
}
} else
continue; // we cannot display this value
}
}