/// <summary>
/// Returns the range for the data points of the series.
/// </summary>
/// <param name="rangeConsumer">Consumer of the range.</param>
/// <returns>Range of values.</returns>
protected override Range <IComparable> IRangeProviderGetRange(IRangeConsumer rangeConsumer)
{
if (rangeConsumer == ActualDependentAxis)
{
IEnumerable <Range <double> > dependentValueRangesByIndependentValue = IndependentValueDependentValues
.Select(g => g.Where(d => ValueHelper.CanGraph(d)))
.Select(g => g.Scan(0.0, (s, t) => s + t).Skip(1).GetRange())
.DefaultIfEmpty(new Range <double>(0, 0))
.ToArray();
double minimum = dependentValueRangesByIndependentValue.Min(r => r.Minimum);
double maximum = dependentValueRangesByIndependentValue.Max(r => r.Maximum);
if (IsStacked100)
{
minimum = Math.Min(minimum, 0);
maximum = Math.Max(maximum, 0);
}
return(new Range <IComparable>(minimum, maximum));
}
else
{
return(base.IRangeProviderGetRange(rangeConsumer));
}
}
/// <summary>
/// Update axes when a data point's effective independent value changes.
/// </summary>
private void UpdateActualIndependentAxis()
{
if (InternalActualIndependentAxis != null)
{
ICategoryAxis categoryAxis = InternalActualIndependentAxis as ICategoryAxis;
if (categoryAxis != null)
{
IDataProvider categoryInformationProvider = (IDataProvider)this;
categoryAxis.DataChanged(categoryInformationProvider, categoryInformationProvider.GetData(categoryAxis));
}
IRangeConsumer rangeAxis = InternalActualIndependentAxis as IRangeConsumer;
if (rangeAxis != null)
{
IRangeProvider rangeInformationProvider = (IRangeProvider)this;
rangeAxis.RangeChanged(rangeInformationProvider, rangeInformationProvider.GetRange(rangeAxis));
}
}
}
/// <summary>
/// Returns the actual range of data for a given axis.
/// </summary>
/// <param name="consumer">The axis to retrieve the range for.</param>
/// <returns>The actual range of data.</returns>
protected virtual Range <IComparable> GetRange(IRangeConsumer consumer)
{
if (consumer == null)
{
throw new ArgumentNullException("consumer");
}
if (consumer == InternalActualDependentAxis)
{
if (this.DataPointsByActualDependentValue.Count > 0)
{
return(this.DataPointsByActualDependentValue.GetKeyRange());
}
}
IAxis axis = consumer as IAxis;
return((axis != null)
? ActiveDataPoints.Select(dataPoint => (IComparable)GetActualDataPointAxisValue(dataPoint, axis)).GetRange()
: new Range <IComparable>());
}
/// <summary>
/// Returns the data range.
/// </summary>
/// <param name="rangeConsumer">The consumer requesting the range.</param>
/// <returns>The data range.</returns>
Range <IComparable> IRangeProvider.GetRange(IRangeConsumer rangeConsumer)
{
return(GetRange(rangeConsumer));
}
/// <summary>
/// Returns the range for the data points of the series.
/// </summary>
/// <param name="rangeConsumer">Consumer of the range.</param>
/// <returns>Range of values.</returns>
protected override Range<IComparable> IRangeProviderGetRange(IRangeConsumer rangeConsumer)
{
if (rangeConsumer == ActualDependentAxis)
{
IEnumerable<Range<double>> dependentValueRangesByIndependentValue = IndependentValueDependentValues
.Select(g => g.Where(d => ValueHelper.CanGraph(d)))
.Select(g => g.Scan(0.0, (s, t) => s + t).Skip(1).GetRange())
.DefaultIfEmpty(new Range<double>(0, 0))
.ToArray();
double minimum = dependentValueRangesByIndependentValue.Min(r => r.Minimum);
double maximum = dependentValueRangesByIndependentValue.Max(r => r.Maximum);
if (IsStacked100)
{
minimum = Math.Min(minimum, 0);
maximum = Math.Max(maximum, 0);
}
return new Range<IComparable>(minimum, maximum);
}
else
{
return base.IRangeProviderGetRange(rangeConsumer);
}
}
/// <summary>
/// Returns the range for the data points of the series.
/// </summary>
/// <param name="rangeConsumer">Consumer of the range.</param>
/// <returns>Range of values.</returns>
protected virtual Range<IComparable> IRangeProviderGetRange(IRangeConsumer rangeConsumer)
{
if (rangeConsumer == ActualIndependentAxis)
{
if (ActualIndependentAxis.CanPlot(0.0))
{
return IndependentValueGroups
.Select(g => ValueHelper.ToDouble(g.IndependentValue))
.Where(d => ValueHelper.CanGraph(d))
.DefaultIfEmpty()
.CastWrapper<IComparable>()
.GetRange();
}
else
{
return IndependentValueGroups
.Select(g => ValueHelper.ToDateTime(g.IndependentValue))
.DefaultIfEmpty()
.CastWrapper<IComparable>()
.GetRange();
}
}
throw new NotSupportedException();
}
/// <summary>
/// Returns the range for the data points of the series.
/// </summary>
/// <param name="rangeConsumer">Consumer of the range.</param>
/// <returns>Range of values.</returns>
Range<IComparable> IRangeProvider.GetRange(IRangeConsumer rangeConsumer)
{
return IRangeProviderGetRange(rangeConsumer);
}
/// <summary>
/// If data is found returns the minimum and maximum dependent numeric
/// values.
/// </summary>
/// <param name="rangeConsumer">IRangeConsumer that needs the data.</param>
/// <returns>
/// The range of values or empty if no data is present.
/// </returns>
public Range<IComparable> GetRange(IRangeConsumer rangeConsumer)
{
// Use an empty range so we only plot over the area used by other
// axes.
return new Range<IComparable>();
}
protected override Range<IComparable> IRangeProviderGetRange(IRangeConsumer rangeConsumer)
{
if (rangeConsumer == ActualDependentAxis)
{
var dependentValuesByIndependentValue = IndependentValueDependentValues.Select(e => e.ToArray()).ToArray();
var mostNegative = dependentValuesByIndependentValue
.Select(g => g.Where(v => v < 0)
.Sum())
.Where(v => v < 0)
.ToArray();
var leastNegative = dependentValuesByIndependentValue
.Select(g => g.Where(v => v <= 0)
.DefaultIfEmpty(1.0)
.First())
.Where(v => v <= 0)
.ToArray();
var mostPositive = dependentValuesByIndependentValue
.Select(g => g.Where(v => 0 < v)
.Sum())
.Where(v => 0 < v)
.ToArray();
var leastPositive = dependentValuesByIndependentValue
.Select(g => g.Where(v => 0 <= v)
.DefaultIfEmpty(-1.0)
.First())
.Where(v => 0 <= v)
.ToArray();
// Compute minimum
double minimum = 0;
if (mostNegative.Any())
{
minimum = mostNegative.Min();
}
else if (leastPositive.Any())
{
minimum = leastPositive.Min();
}
// Compute maximum
double maximum = 0;
if (mostPositive.Any())
{
maximum = mostPositive.Max();
}
else if (leastNegative.Any())
{
maximum = leastNegative.Max();
}
if (IsStacked100)
{
minimum = Math.Min(minimum, 0);
maximum = Math.Max(maximum, 0);
}
return new Range<IComparable>(minimum, maximum);
}
else if (rangeConsumer == ActualIndependentAxis)
{
// Using a non-ICategoryAxis for the independent axis
// Need to specifically adjust for slot size of bars/columns so they don't overlap
// Note: Calculation for slotSize is not perfect, but it's quick, close, and errs on the safe side
Range<IComparable> range = base.IRangeProviderGetRange(rangeConsumer);
int count = Math.Max(IndependentValueGroups.Count(), 1);
if (ActualIndependentAxis.CanPlot(0.0))
{
double minimum = ValueHelper.ToDouble(range.Minimum);
double maximum = ValueHelper.ToDouble(range.Maximum);
double slotSize = (maximum - minimum) / count;
return new Range<IComparable>(minimum - slotSize, maximum + slotSize);
}
else
{
DateTime minimum = ValueHelper.ToDateTime(range.Minimum);
DateTime maximum = ValueHelper.ToDateTime(range.Maximum);
TimeSpan slotSize = TimeSpan.FromTicks((maximum - minimum).Ticks / count);
return new Range<IComparable>(minimum - slotSize, maximum + slotSize);
}
}
else
{
return base.IRangeProviderGetRange(rangeConsumer);
}
}
/// <summary>
/// If data is found returns the minimum and maximum dependent numeric
/// values.
/// </summary>
/// <param name="rangeConsumer">IRangeConsumer that needs the data.</param>
/// <returns>
/// The range of values or empty if no data is present.
/// </returns>
public Range <IComparable> GetRange(IRangeConsumer rangeConsumer)
{
// Use an empty range so we only plot over the area used by other
// axes.
return(new Range <IComparable>());
}
/// <summary>
/// Returns the actual range of data for a given axis.
/// </summary>
/// <param name="consumer">The axis to retrieve the range for.</param>
/// <returns>The actual range of data.</returns>
protected virtual Range<IComparable> GetRange(IRangeConsumer consumer)
{
if (consumer == null)
{
throw new ArgumentNullException("consumer");
}
if (consumer == InternalActualDependentAxis)
{
if (this.DataPointsByActualDependentValue.Count > 0)
{
return this.DataPointsByActualDependentValue.GetKeyRange();
}
}
IAxis axis = consumer as IAxis;
return (axis != null)
? ActiveDataPoints.Select(dataPoint => (IComparable)GetActualDataPointAxisValue(dataPoint, axis)).GetRange()
: new Range<IComparable>();
}
protected override Range <IComparable> IRangeProviderGetRange(IRangeConsumer rangeConsumer)
{
if (rangeConsumer == ActualDependentAxis)
{
var dependentValuesByIndependentValue = IndependentValueDependentValues.Select(e => e.ToArray()).ToArray();
var mostNegative = dependentValuesByIndependentValue
.Select(g => g.Where(v => v < 0)
.Sum())
.Where(v => v < 0)
.ToArray();
var leastNegative = dependentValuesByIndependentValue
.Select(g => g.Where(v => v <= 0)
.DefaultIfEmpty(1.0)
.First())
.Where(v => v <= 0)
.ToArray();
var mostPositive = dependentValuesByIndependentValue
.Select(g => g.Where(v => 0 < v)
.Sum())
.Where(v => 0 < v)
.ToArray();
var leastPositive = dependentValuesByIndependentValue
.Select(g => g.Where(v => 0 <= v)
.DefaultIfEmpty(-1.0)
.First())
.Where(v => 0 <= v)
.ToArray();
// Compute minimum
double minimum = 0;
if (mostNegative.Any())
{
minimum = mostNegative.Min();
}
else if (leastPositive.Any())
{
minimum = leastPositive.Min();
}
// Compute maximum
double maximum = 0;
if (mostPositive.Any())
{
maximum = mostPositive.Max();
}
else if (leastNegative.Any())
{
maximum = leastNegative.Max();
}
if (IsStacked100)
{
minimum = Math.Min(minimum, 0);
maximum = Math.Max(maximum, 0);
}
return(new Range <IComparable>(minimum, maximum));
}
else if (rangeConsumer == ActualIndependentAxis)
{
// Using a non-ICategoryAxis for the independent axis
// Need to specifically adjust for slot size of bars/columns so they don't overlap
// Note: Calculation for slotSize is not perfect, but it's quick, close, and errs on the safe side
Range <IComparable> range = base.IRangeProviderGetRange(rangeConsumer);
int count = Math.Max(IndependentValueGroups.Count(), 1);
if (ActualIndependentAxis.CanPlot(0.0))
{
double minimum = ValueHelper.ToDouble(range.Minimum);
double maximum = ValueHelper.ToDouble(range.Maximum);
double slotSize = (maximum - minimum) / count;
return(new Range <IComparable>(minimum - slotSize, maximum + slotSize));
}
else
{
DateTime minimum = ValueHelper.ToDateTime(range.Minimum);
DateTime maximum = ValueHelper.ToDateTime(range.Maximum);
TimeSpan slotSize = TimeSpan.FromTicks((maximum - minimum).Ticks / count);
return(new Range <IComparable>(minimum - slotSize, maximum + slotSize));
}
}
else
{
return(base.IRangeProviderGetRange(rangeConsumer));
}
}
