rainlance
/
nplot
mirror of https://github.com/mhowlett/nplot.git
1
0
Fork 0
Code Releases Activity
nplot/src/LinearAxis.cs

572 lines
21 KiB
C#
Raw Permalink Blame History

/*
* NPlot - A charting library for .NET
*
* LinearAxis.cs
* Copyright (C) 2003-2006 Matt Howlett and others.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections;
using System.Drawing;
using System.Text;
namespace NPlot
{
/// <summary>
/// Provides functionality for drawing axes with a linear numeric scale.
/// </summary>
public class LinearAxis : Axis, ICloneable
{
/// <summary>
/// If LargeTickStep isn't specified, then a suitable value is
/// calculated automatically. To determine the tick spacing, the
/// world axis length is divided by ApproximateNumberLargeTicks
/// and the next lowest distance m*10^e for some m in the Mantissas
/// set and some integer e is used as the large tick spacing.
/// </summary>
public float ApproxNumberLargeTicks = 3.0f;
/// <summary>
/// If LargeTickStep isn't specified, then a suitable value is
/// calculated automatically. The value will be of the form
/// m*10^e for some m in this set.
/// </summary>
public double[] Mantissas = {1.0, 2.0, 5.0};
/// <summary>
/// If NumberOfSmallTicks isn't specified then ....
/// If specified LargeTickStep manually, then no small ticks unless
/// NumberOfSmallTicks specified.
/// </summary>
public int[] SmallTickCounts = {4, 1, 4};
/// <summary>
/// If set !NaN, gives the distance between large ticks.
/// </summary>
private double largeTickStep_ = double.NaN;
private double largeTickValue_ = double.NaN;
private object numberSmallTicks_;
private double offset_;
private double scale_ = 1.0;
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="a">The Axis to clone</param>
public LinearAxis(Axis a)
: base(a)
{
Init();
}
/// <summary>
/// Default constructor.
/// </summary>
public LinearAxis()
{
Init();
}
/// <summary>
/// Construct a linear axis with the provided world min and max values.
/// </summary>
/// <param name="worldMin">the world minimum value of the axis.</param>
/// <param name="worldMax">the world maximum value of the axis.</param>
public LinearAxis(double worldMin, double worldMax)
: base(worldMin, worldMax)
{
Init();
}
/// <summary>
/// The distance between large ticks. If this is set to NaN [default],
/// this distance will be calculated automatically.
/// </summary>
public double LargeTickStep
{
set { largeTickStep_ = value; }
get { return largeTickStep_; }
}
/// <summary>
/// If set, a large tick will be placed at this position, and other large ticks will
/// be placed relative to this position.
/// </summary>
public double LargeTickValue
{
set { largeTickValue_ = value; }
get { return largeTickValue_; }
}
/// <summary>
/// The number of small ticks between large ticks.
/// </summary>
public int NumberOfSmallTicks
{
set { numberSmallTicks_ = value; }
get
{
// TODO: something better here.
return (int) numberSmallTicks_;
}
}
/// <summary>
/// Scale to apply to world values when labelling axis:
/// (labelWorld = world * scale + offset). This does not
/// affect the "real" world range of the axis.
/// </summary>
public double Scale
{
get { return scale_; }
set { scale_ = value; }
}
/// <summary>
/// Offset to apply to world values when labelling the axis:
/// (labelWorld = axisWorld * scale + offset). This does not
/// affect the "real" world range of the axis.
/// </summary>
public double Offset
{
get { return offset_; }
set { offset_ = value; }
}
/// <summary>
/// Deep copy of LinearAxis.
/// </summary>
/// <returns>A copy of the LinearAxis Class</returns>
public override object Clone()
{
LinearAxis a = new LinearAxis();
// ensure that this isn't being called on a derived type. If it is, then oh no!
if (GetType() != a.GetType())
{
throw new NPlotException("Clone not defined in derived type. Help!");
}
DoClone(this, a);
return a;
}
/// <summary>
/// Helper method for Clone.
/// </summary>
protected void DoClone(LinearAxis b, LinearAxis a)
{
Axis.DoClone(b, a);
a.numberSmallTicks_ = b.numberSmallTicks_;
a.largeTickValue_ = b.largeTickValue_;
a.largeTickStep_ = b.largeTickStep_;
a.offset_ = b.offset_;
a.scale_ = b.scale_;
}
private void Init()
{
NumberFormat = "{0:g5}";
}
/// <summary>
/// Draws the large and small ticks [and tick labels] for this axis.
/// </summary>
/// <param name="g">The graphics surface on which to draw.</param>
/// <param name="physicalMin">The physical position corresponding to the world minimum of the axis.</param>
/// <param name="physicalMax">The physical position corresponding to the world maximum of the axis.</param>
/// <param name="boundingBox">out: smallest box that completely surrounds all ticks and associated labels for this axis.</param>
/// <param name="labelOffset">out: offset from the axis to draw the axis label.</param>
protected override void DrawTicks(
Graphics g,
Point physicalMin,
Point physicalMax,
out object labelOffset,
out object boundingBox)
{
Point tLabelOffset;
Rectangle tBoundingBox;
labelOffset = getDefaultLabelOffset(physicalMin, physicalMax);
boundingBox = null;
ArrayList largeTickPositions;
ArrayList smallTickPositions;
WorldTickPositions(physicalMin, physicalMax, out largeTickPositions, out smallTickPositions);
labelOffset = new Point(0, 0);
boundingBox = null;
if (largeTickPositions.Count > 0)
{
for (int i = 0; i < largeTickPositions.Count; ++i)
{
double labelNumber = (double) largeTickPositions[i];
// TODO: Find out why zero is sometimes significantly not zero [seen as high as 10^-16].
if (Math.Abs(labelNumber) < 0.000000000000001)
{
labelNumber = 0.0;
}
StringBuilder label = new StringBuilder();
label.AppendFormat(NumberFormat, labelNumber);
DrawTick(g, ((double) largeTickPositions[i]/scale_ - offset_),
LargeTickSize, label.ToString(),
new Point(0, 0), physicalMin, physicalMax,
out tLabelOffset, out tBoundingBox);
UpdateOffsetAndBounds(ref labelOffset, ref boundingBox,
tLabelOffset, tBoundingBox);
}
}
for (int i = 0; i < smallTickPositions.Count; ++i)
{
DrawTick(g, ((double) smallTickPositions[i]/scale_ - offset_),
SmallTickSize, "",
new Point(0, 0), physicalMin, physicalMax,
out tLabelOffset, out tBoundingBox);
// assume bounding box and label offset unchanged by small tick bounds.
}
}
/// <summary>
/// Determines the positions, in world coordinates, of the small ticks
/// if they have not already been generated.
/// </summary>
/// <param name="physicalMin">The physical position corresponding to the world minimum of the axis.</param>
/// <param name="physicalMax">The physical position corresponding to the world maximum of the axis.</param>
/// <param name="largeTickPositions">The positions of the large ticks.</param>
/// <param name="smallTickPositions">If null, small tick positions are returned via this parameter. Otherwise this function does nothing.</param>
internal override void WorldTickPositions_SecondPass(
Point physicalMin,
Point physicalMax,
ArrayList largeTickPositions,
ref ArrayList smallTickPositions)
{
// return if already generated.
if (smallTickPositions != null)
return;
int physicalAxisLength = Utils.Distance(physicalMin, physicalMax);
double adjustedMax = AdjustedWorldValue(WorldMax);
double adjustedMin = AdjustedWorldValue(WorldMin);
smallTickPositions = new ArrayList();
// TODO: Can optimize this now.
bool shouldCullMiddle;
double bigTickSpacing = DetermineLargeTickStep(physicalAxisLength, out shouldCullMiddle);
int nSmall = DetermineNumberSmallTicks(bigTickSpacing);
double smallTickSpacing = bigTickSpacing/nSmall;
// if there is at least one big tick
if (largeTickPositions.Count > 0)
{
double pos1 = (double) largeTickPositions[0] - smallTickSpacing;
while (pos1 > adjustedMin)
{
smallTickPositions.Add(pos1);
pos1 -= smallTickSpacing;
}
}
for (int i = 0; i < largeTickPositions.Count; ++i)
{
for (int j = 1; j < nSmall; ++j)
{
double pos = (double) largeTickPositions[i] + (j)*smallTickSpacing;
if (pos <= adjustedMax)
{
smallTickPositions.Add(pos);
}
}
}
}
/// <summary>
/// Adjusts a real world value to one that has been modified to
/// reflect the Axis Scale and Offset properties.
/// </summary>
/// <param name="world">world value to adjust</param>
/// <returns>adjusted world value</returns>
public double AdjustedWorldValue(double world)
{
return world*scale_ + offset_;
}
/// <summary>
/// Determines the positions, in world coordinates, of the large ticks.
/// When the physical extent of the axis is small, some of the positions
/// that were generated in this pass may be converted to small tick
/// positions and returned as well.
/// If the LargeTickStep isn't set then this is calculated automatically and
/// depends on the physical extent of the axis.
/// </summary>
/// <param name="physicalMin">The physical position corresponding to the world minimum of the axis.</param>
/// <param name="physicalMax">The physical position corresponding to the world maximum of the axis.</param>
/// <param name="largeTickPositions">ArrayList containing the positions of the large ticks.</param>
/// <param name="smallTickPositions">ArrayList containing the positions of the small ticks if calculated, null otherwise.</param>
internal override void WorldTickPositions_FirstPass(
Point physicalMin,
Point physicalMax,
out ArrayList largeTickPositions,
out ArrayList smallTickPositions
)
{
// (1) error check
if (double.IsNaN(WorldMin) || double.IsNaN(WorldMax))
{
throw new NPlotException("world extent of axis not set.");
}
double adjustedMax = AdjustedWorldValue(WorldMax);
double adjustedMin = AdjustedWorldValue(WorldMin);
// (2) determine distance between large ticks.
bool shouldCullMiddle;
double tickDist = DetermineLargeTickStep(
Utils.Distance(physicalMin, physicalMax),
out shouldCullMiddle);
// (3) determine starting position.
double first = 0.0f;
if (!double.IsNaN(largeTickValue_))
{
// this works for both case when largTickValue_ lt or gt adjustedMin.
first = largeTickValue_ + (Math.Ceiling((adjustedMin - largeTickValue_)/tickDist))*tickDist;
}
else
{
if (adjustedMin > 0.0)
{
double nToFirst = Math.Floor(adjustedMin/tickDist) + 1.0f;
first = nToFirst*tickDist;
}
else
{
double nToFirst = Math.Floor(-adjustedMin/tickDist) - 1.0f;
first = -nToFirst*tickDist;
}
// could miss one, if first is just below zero.
if ((first - tickDist) >= adjustedMin)
{
first -= tickDist;
}
}
// (4) now make list of large tick positions.
largeTickPositions = new ArrayList();
if (tickDist < 0.0) // some sanity checking. TODO: remove this.
throw new NPlotException("Tick dist is negative");
double position = first;
int safetyCount = 0;
while (
(position <= adjustedMax) &&
(++safetyCount < 5000))
{
largeTickPositions.Add(position);
position += tickDist;
}
// (5) if the physical extent is too small, and the middle
// ticks should be turned into small ticks, then do this now.
smallTickPositions = null;
if (shouldCullMiddle)
{
smallTickPositions = new ArrayList();
if (largeTickPositions.Count > 2)
{
for (int i = 1; i < largeTickPositions.Count - 1; ++i)
{
smallTickPositions.Add(largeTickPositions[i]);
}
}
ArrayList culledPositions = new ArrayList();
culledPositions.Add(largeTickPositions[0]);
culledPositions.Add(largeTickPositions[largeTickPositions.Count - 1]);
largeTickPositions = culledPositions;
}
}
/// <summary>
/// Calculates the world spacing between large ticks, based on the physical
/// axis length (parameter), world axis length, Mantissa values and
/// MinPhysicalLargeTickStep. A value such that at least two
/// </summary>
/// <param name="physicalLength">physical length of the axis</param>
/// <param name="shouldCullMiddle">
/// Returns true if we were forced to make spacing of
/// large ticks too small in order to ensure that there are at least two of
/// them. The draw ticks method should not draw more than two large ticks if this
/// returns true.
/// </param>
/// <returns>Large tick spacing</returns>
/// <remarks>TODO: This can be optimised a bit.</remarks>
private double DetermineLargeTickStep(float physicalLength, out bool shouldCullMiddle)
{
shouldCullMiddle = false;
if (double.IsNaN(WorldMin) || double.IsNaN(WorldMax))
{
throw new NPlotException("world extent of axis not set.");
}
// if the large tick has been explicitly set, then return this.
if (!double.IsNaN(largeTickStep_))
{
if (largeTickStep_ <= 0.0f)
{
throw new NPlotException(
"can't have negative or zero tick step - reverse WorldMin WorldMax instead."
);
}
return largeTickStep_;
}
// otherwise we need to calculate the large tick step ourselves.
// adjust world max and min for offset and scale properties of axis.
double adjustedMax = AdjustedWorldValue(WorldMax);
double adjustedMin = AdjustedWorldValue(WorldMin);
double range = adjustedMax - adjustedMin;
// if axis has zero world length, then return arbitrary number.
if (Utils.DoubleEqual(adjustedMax, adjustedMin))
{
return 1.0f;
}
double approxTickStep;
if (TicksIndependentOfPhysicalExtent)
{
approxTickStep = range/6.0f;
}
else
{
approxTickStep = (MinPhysicalLargeTickStep/physicalLength)*range;
}
double exponent = Math.Floor(Math.Log10(approxTickStep));
double mantissa = Math.Pow(10.0, Math.Log10(approxTickStep) - exponent);
// determine next whole mantissa below the approx one.
int mantissaIndex = Mantissas.Length - 1;
for (int i = 1; i < Mantissas.Length; ++i)
{
if (mantissa < Mantissas[i])
{
mantissaIndex = i - 1;
break;
}
}
// then choose next largest spacing.
mantissaIndex += 1;
if (mantissaIndex == Mantissas.Length)
{
mantissaIndex = 0;
exponent += 1.0;
}
if (!TicksIndependentOfPhysicalExtent)
{
// now make sure that the returned value is such that at least two
// large tick marks will be displayed.
double tickStep = Math.Pow(10.0, exponent)*Mantissas[mantissaIndex];
float physicalStep = (float) ((tickStep/range)*physicalLength);
while (physicalStep > physicalLength/2)
{
shouldCullMiddle = true;
mantissaIndex -= 1;
if (mantissaIndex == -1)
{
mantissaIndex = Mantissas.Length - 1;
exponent -= 1.0;
}
tickStep = Math.Pow(10.0, exponent)*Mantissas[mantissaIndex];
physicalStep = (float) ((tickStep/range)*physicalLength);
}
}
// and we're done.
return Math.Pow(10.0, exponent)*Mantissas[mantissaIndex];
}
/// <summary>
/// Given the large tick step, determine the number of small ticks that should
/// be placed in between.
/// </summary>
/// <param name="bigTickDist">the large tick step.</param>
/// <returns>the number of small ticks to place between large ticks.</returns>
private int DetermineNumberSmallTicks(double bigTickDist)
{
if (numberSmallTicks_ != null)
{
return (int) numberSmallTicks_ + 1;
}
if (SmallTickCounts.Length != Mantissas.Length)
{
throw new NPlotException("Mantissa.Length != SmallTickCounts.Length");
}
if (bigTickDist > 0.0f)
{
double exponent = Math.Floor(Math.Log10(bigTickDist));
double mantissa = Math.Pow(10.0, Math.Log10(bigTickDist) - exponent);
for (int i = 0; i < Mantissas.Length; ++i)
{
if (Math.Abs(mantissa - Mantissas[i]) < 0.001)
{
return SmallTickCounts[i] + 1;
}
}
}
return 0;
}
}
}
View Git Blame Copy Permalink