VisualMelon/HeatMapSeries.cs

## HeatMapSeries.cs
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="HeatMapSeries.cs" company="OxyPlot">
//   Copyright (c) 2014 OxyPlot contributors
// </copyright>
// <summary>
//   Specifies how the heat map coordinates are defined.
// </summary>
// --------------------------------------------------------------------------------------------------------------------

namespace OxyPlot.Series
{
    using System;

    using OxyPlot.Axes;

    /// <summary>
    /// Specifies how the heat map coordinates are defined.
    /// </summary>
    public enum HeatMapCoordinateDefinition
    {
        /// <summary>
        /// The coordinates defines the center of the cells
        /// </summary>
        Center,

        /// <summary>
        /// The coordinates defines the edge of the cells
        /// </summary>
        Edge
    }

    /// <summary>
    /// Represents a heat map.
    /// </summary>
    public class HeatMapSeries : XYAxisSeries
    {
        /// <summary>
        /// The default tracker format string
        /// </summary>
        public new const string DefaultTrackerFormatString = "{0}\n{1}: {2}\n{3}: {4}\n{5}: {6}";

        /// <summary>
        /// The default color-axis title
        /// </summary>
        private const string DefaultColorAxisTitle = "Value";

        /// <summary>
        /// The hash code of the data when the image was updated.
        /// </summary>
        private int dataHash;

        /// <summary>
        /// The hash code of the color axis when the image was updated.
        /// </summary>
        private int colorAxisHash;

        /// <summary>
        /// The image
        /// </summary>
        private OxyImage image;

        /// <summary>
        /// Initializes a new instance of the <see cref="HeatMapSeries" /> class.
        /// </summary>
        public HeatMapSeries()
        {
            this.TrackerFormatString = DefaultTrackerFormatString;
            this.Interpolate = true;
            this.LabelFormatString = "0.00";
            this.LabelFontSize = 0;
        }

        /// <summary>
        /// Gets or sets the x-coordinate of the elements at index [0,*] in the data set.
        /// </summary>
        /// <value>
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [0,*] in the data set.
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the left edge of the element at index [0,*] in the data set.
        /// </value>
        public double X0 { get; set; }

        /// <summary>
        /// Gets or sets the x-coordinate of the mid point for the elements at index [m-1,*] in the data set.
        /// </summary>
        /// <value>
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [m-1,*] in the data set.
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the right edge of the element at index [m-1,*] in the data set.
        /// </value>
        public double X1 { get; set; }

        /// <summary>
        /// Gets or sets the y-coordinate of the mid point for the elements at index [*,0] in the data set.
        /// </summary>
        /// <value>
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [*,0] in the data set.
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the bottom edge of the element at index [*,0] in the data set.
        /// </value>
        public double Y0 { get; set; }

        /// <summary>
        /// Gets or sets the y-coordinate of the mid point for the elements at index [*,n-1] in the data set.
        /// </summary>
        /// <value>
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [*,n-1] in the data set.
        /// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the top edge of the element at index [*,n-1] in the data set.
        /// </value>
        public double Y1 { get; set; }

        /// <summary>
        /// Gets or sets the data array.
        /// </summary>
        /// <remarks>Note that the indices of the data array refer to [x,y].
        /// The first dimension is along the x-axis.
        /// The second dimension is along the y-axis.
        /// Remember to call the <see cref="Invalidate" /> method if the contents of the <see cref="Data" /> array is changed.</remarks>
        public double[,] Data { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to interpolate when rendering. The default value is <c>true</c>.
        /// </summary>
        /// <remarks>This property is not supported on all platforms.</remarks>
        public bool Interpolate { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to use discrete rectangles for rendering uninterpolated (ignored if Interpolate is set to true). The default value is <c>false</c>.
        /// </summary>
        public bool RenderDiscreteRectangles { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to treat the x dimension as logarithmic. The default value is <c>false</c>.
        /// </summary>
        public bool LogX { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to treat the y dimension as logarithmic. The default value is <c>false</c>.
        /// </summary>
        public bool LogY { get; set; }

        /// <summary>
        /// Gets the minimum value of the dataset.
        /// </summary>
        public double MinValue { get; private set; }

        /// <summary>
        /// Gets the maximum value of the dataset.
        /// </summary>
        public double MaxValue { get; private set; }

        /// <summary>
        /// Gets or sets the color axis.
        /// </summary>
        /// <value>The color axis.</value>
        public IColorAxis ColorAxis { get; protected set; }

        /// <summary>
        /// Gets or sets the color axis key.
        /// </summary>
        /// <value>The color axis key.</value>
        public string ColorAxisKey { get; set; }

        /// <summary>
        /// Gets or sets the coordinate definition. The default value is <see cref="HeatMapCoordinateDefinition.Center" />.
        /// </summary>
        /// <value>The coordinate definition.</value>
        public HeatMapCoordinateDefinition CoordinateDefinition { get; set; }

        /// <summary>
        /// Gets or sets the format string for the cell labels. The default value is <c>0.00</c>.
        /// </summary>
        /// <value>The format string.</value>
        /// <remarks>The label format string is only used when <see cref="LabelFontSize" /> is greater than 0.</remarks>
        public string LabelFormatString { get; set; }

        /// <summary>
        /// Gets or sets the font size of the labels. The default value is <c>0</c> (labels not visible).
        /// </summary>
        /// <value>The font size relative to the cell height.</value>
        public double LabelFontSize { get; set; }

        /// <summary>
        /// Invalidates the image that renders the heat map. The image will be regenerated the next time the <see cref="HeatMapSeries" /> is rendered.
        /// </summary>
        /// <remarks>Call <see cref="PlotModel.InvalidatePlot" /> to refresh the view.</remarks>
        public void Invalidate()
        {
            this.image = null;
        }

        /// <summary>
        /// Renders the series on the specified render context.
        /// </summary>
        /// <param name="rc">The rendering context.</param>
        public override void Render(IRenderContext rc)
        {
            if (this.Data == null)
            {
                this.image = null;
                return;
            }

            if (this.ColorAxis == null)
            {
                throw new InvalidOperationException("Color axis not specified.");
            }

            double left = this.X0;
            double right = this.X1;
            double bottom = this.Y0;
            double top = this.Y1;

            int m = this.Data.GetLength(0);
            int n = this.Data.GetLength(1);
            double dx = (this.X1 - this.X0) / (m - 1);
            double dy = (this.Y1 - this.Y0) / (n - 1);

            if (this.CoordinateDefinition == HeatMapCoordinateDefinition.Center)
            {
                if (LogX)
                {
                    double gx = Math.Log(this.X1 / this.X0) / (m - 1);
                    left *= Math.Exp(gx / -2);
                    right *= Math.Exp(gx / 2);
                }
                else
                {
                    left -= dx / 2;
                    right += dx / 2;
                }

                if (LogY)
                {
                    double gy = Math.Log(this.Y1 / this.Y0) / (n - 1);
                    bottom *= Math.Exp(gy / -2);
                    top *= Math.Exp(gy / 2);
                }
                else
                {
                    bottom -= dy / 2;
                    top += dy / 2;
                }
            }

            var s00 = this.Transform(left, bottom);
            var s11 = this.Transform(right, top);
            var rect = new OxyRect(s00, s11);

            bool needImage = Interpolate || !RenderDiscreteRectangles;

            var currentDataHash = this.Data.GetHashCode();
            var currentColorAxisHash = this.ColorAxis.GetElementHashCode();
            if ((needImage && this.image == null) || currentDataHash != this.dataHash || currentColorAxisHash != this.colorAxisHash)
            {
                if (needImage)
                    this.UpdateImage();
                this.dataHash = currentDataHash;
                this.colorAxisHash = currentColorAxisHash;
            }

            var clip = this.GetClippingRect();
            if (needImage)
            {
                if (this.image != null)
                {
                    rc.DrawClippedImage(clip, this.image, rect.Left, rect.Top, rect.Width, rect.Height, 1, this.Interpolate);
                }
            }
            else
            {
                s00 = this.Orientate(s00); // disorientate
                s11 = this.Orientate(s11); // disorientate

                double sdx = (s11.X - s00.X) / m;
                double sdy = (s11.Y - s00.Y) / n;

                // draw lots of rectangles
                for (int i = 0; i < m; i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        OxyColor rectcolor = this.ColorAxis.GetColor(this.Data[i, j]);

                        var pointa = this.Orientate(new ScreenPoint(s00.X + i * sdx, s00.Y + j * sdy)); // reorientate
                        var pointb = this.Orientate(new ScreenPoint(s00.X + (i + 1) * sdx, s00.Y + (j + 1) * sdy)); // reorientate
                        OxyRect rectrect = new OxyRect(pointa, pointb);

                        rc.DrawClippedRectangle(clip, rectrect, rectcolor, OxyColors.Undefined, 0);
                    }
                }
            }

            if (this.LabelFontSize > 0)
            {
                this.RenderLabels(rc, rect);
            }
        }

        // fudge Tranform/InverseTranform testing (for Transpose #535)
        protected new OxyRect GetClippingRect()
        {
            double minX = Math.Min(this.XAxis.ScreenMin.X, this.XAxis.ScreenMax.X);
            double minY = Math.Min(this.YAxis.ScreenMin.Y, this.YAxis.ScreenMax.Y);
            double maxX = Math.Max(this.XAxis.ScreenMin.X, this.XAxis.ScreenMax.X);
            double maxY = Math.Max(this.YAxis.ScreenMin.Y, this.YAxis.ScreenMax.Y);

            if (XAxis.IsVertical())
                return new OxyRect(minY, minX, maxY - minY, maxX - minX);
            else
                return new OxyRect(minX, minY, maxX - minX, maxY - minY);
        }

        private ScreenPoint Orientate(ScreenPoint point)
        {
            if (XAxis.IsVertical())
            {
                point = new ScreenPoint(point.Y, point.X);
            }
            return point;
        }

        public new ScreenPoint Transform(double x, double y)
        {
            return Orientate(base.Transform(x, y));
        }

        public new ScreenPoint Transform(DataPoint p)
        {
            return Orientate(base.Transform(p));
        }

        public new DataPoint InverseTransform(ScreenPoint point)
        {
            return base.InverseTransform(Orientate(point));
        }
        //

        /// <summary>
        /// Gets the point on the series that is nearest the specified point.
        /// </summary>
        /// <param name="point">The point.</param>
        /// <param name="interpolate">Interpolate the series if this flag is set to <c>true</c>.</param>
        /// <returns>A TrackerHitResult for the current hit.</returns>
        public override TrackerHitResult GetNearestPoint(ScreenPoint point, bool interpolate)
        {
            if (!this.Interpolate)
            {
                // It makes no sense to interpolate the tracker when the plot is not interpolated.
                interpolate = false;
            }

            var p = this.InverseTransform(point);

            if (!this.IsPointInRange(p))
            {
                return null;
            }

            // these are screen space coords
            double i;
            double j;

            if (LogX)
            {
                double gx = Math.Log(this.X1 / this.X0) / (this.Data.GetLength(0) - 1);
                i = Math.Log(p.X / this.X0) / gx;
            }
            else
            {
                double dx = (this.X1 - this.X0) / (this.Data.GetLength(0) - 1);
                i = (p.X - this.X0) / dx;
            }

            if (LogY)
            {
                double gy = Math.Log(this.Y1 / this.Y0) / (this.Data.GetLength(1) - 1);
                j = Math.Log(p.Y / this.Y0) / gy;
            }
            else
            {
                double dy = (this.Y1 - this.Y0) / (this.Data.GetLength(1) - 1);
                j = (p.Y - this.Y0) / dy;
            }

            if (!interpolate)
            {
                i = Math.Round(i);
                j = Math.Round(j);

                double px;
                double py;

                if (LogX)
                {
                    double gx = Math.Log(this.X1 / this.X0) / (this.Data.GetLength(0) - 1);
                    px = this.X0 * Math.Exp((double)i * gx);
                }
                else
                {
                    double dx = (this.X1 - this.X0) / (this.Data.GetLength(0) - 1);
                    px = (i * dx) + this.X0;
                }

                if (LogY)
                {
                    double gy = Math.Log(this.Y1 / this.Y0) / (this.Data.GetLength(1) - 1);
                    py = this.Y0 * Math.Exp((double)j * gy);
                }
                else
                {
                    double dy = (this.Y1 - this.Y0) / (this.Data.GetLength(1) - 1);
                    py = (j * dy) + this.Y0;
                }

                p = new DataPoint(px, py);
                point = this.Transform(p);
            }

            var value = GetValue(this.Data, i, j);
            var colorAxis = this.ColorAxis as Axis;
            var colorAxisTitle = (colorAxis != null ? colorAxis.Title : null) ?? DefaultColorAxisTitle;

            return new TrackerHitResult
            {
                Series = this,
                DataPoint = p,
                Position = point,
                Item = null,
                Index = -1,
                Text = StringHelper.Format(
                this.ActualCulture,
                this.TrackerFormatString,
                null,
                this.Title,
                this.XAxis.Title ?? DefaultXAxisTitle,
                this.XAxis.GetValue(p.X),
                this.YAxis.Title ?? DefaultYAxisTitle,
                this.YAxis.GetValue(p.Y),
                colorAxisTitle,
                value)
            };
        }

        /// <summary>
        /// Ensures that the axes of the series is defined.
        /// </summary>
        protected internal override void EnsureAxes()
        {
            base.EnsureAxes();

            this.ColorAxis =
                this.PlotModel.GetAxisOrDefault(this.ColorAxisKey, (Axis)this.PlotModel.DefaultColorAxis) as IColorAxis;
        }

        /// <summary>
        /// Updates the maximum and minimum values of the series for the x and y dimensions only.
        /// </summary>
        protected internal void UpdateMaxMinXY()
        {
            int m = this.Data.GetLength(0);
            int n = this.Data.GetLength(1);

            this.MinX = Math.Min(this.X0, this.X1);
            this.MaxX = Math.Max(this.X0, this.X1);

            this.MinY = Math.Min(this.Y0, this.Y1);
            this.MaxY = Math.Max(this.Y0, this.Y1);

            if (this.CoordinateDefinition == HeatMapCoordinateDefinition.Center)
            {
                if (LogX)
                {
                    double gx = Math.Log(this.MaxX / this.MinX) / (m - 1);
                    this.MinX *= Math.Exp(gx / -2);
                    this.MaxX *= Math.Exp(gx / 2);
                }
                else
                {
                    double dx = (this.MaxX - this.MinX) / (m - 1);
                    this.MinX -= dx / 2;
                    this.MaxX += dx / 2;
                }

                if (LogY)
                {
                    double gy = Math.Log(this.MaxY / this.MinY) / (n - 1);
                    this.MinY *= Math.Exp(gy / -2);
                    this.MaxY *= Math.Exp(gy / 2);
                }
                else
                {
                    double dy = (this.MaxY - this.MinY) / (n - 1);
                    this.MinY -= dy / 2;
                    this.MaxY += dy / 2;
                }
            }
        }

        /// <summary>
        /// Updates the maximum and minimum values of the series.
        /// </summary>
        protected internal override void UpdateMaxMin()
        {
            base.UpdateMaxMin();

            UpdateMaxMinXY();

            this.MinValue = this.Data.Min2D(true);
            this.MaxValue = this.Data.Max2D();
        }

        /// <summary>
        /// Updates the axes to include the max and min of this series.
        /// </summary>
        protected internal override void UpdateAxisMaxMin()
        {
            base.UpdateAxisMaxMin();
            var colorAxis = this.ColorAxis as Axis;
            if (colorAxis != null)
            {
                colorAxis.Include(this.MinValue);
                colorAxis.Include(this.MaxValue);
            }
        }

        /// <summary>
        /// Renders the labels.
        /// </summary>
        /// <param name="rc">The <see cref="IRenderContext" /></param>
        /// <param name="rect">The bounding rectangle for the data.</param>
        protected virtual void RenderLabels(IRenderContext rc, OxyRect rect)
        {
            var clip = this.GetClippingRect();
            int m = this.Data.GetLength(0);
            int n = this.Data.GetLength(1);
            //double dx = (this.X1 - this.X0) / (m - 1);
            //double dy = (this.Y1 - this.Y0) / (n - 1);
            double fontSize = (rect.Height / n) * this.LabelFontSize;

            double left = this.X0;
            double right = this.X1;
            double bottom = this.Y0;
            double top = this.Y1;

            var s00 = this.Orientate(this.Transform(left, bottom)); // disorientate
            var s11 = this.Orientate(this.Transform(right, top)); // disorientate

            //var labelrect = new OxyRect(s00, s11);
            //double sdx = labelrect.Width / (m - 1);
            //double sdy = labelrect.Height / (n - 1);
            //var labelrect = new OxyRect(s00, s11);
            double sdx = (s11.X - s00.X) / (m - 1);
            double sdy = (s11.Y - s00.Y) / (n - 1);

            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    //var p = new DataPoint((i * dx) + this.X0, (j * dy) + this.Y0);
                    //var point = this.Transform(p);
                    var point = this.Orientate(new ScreenPoint(s00.X + i * sdx, s00.Y + j * sdy)); // reorientate
                    var v = GetValue(this.Data, i, j);
                    var color = this.ColorAxis.GetColor(v);
                    var hsv = color.ToHsv();
                    var textColor = hsv[2] > 0.6 ? OxyColors.Black : OxyColors.White;
                    var label = this.GetLabel(v, i, j);
                    rc.DrawClippedText(
                        clip,
                        point,
                        label,
                        textColor,
                        this.ActualFont,
                        fontSize,
                        500,
                        0,
                        HorizontalAlignment.Center,
                        VerticalAlignment.Middle);
                }
            }
        }

        /// <summary>
        /// Gets the label for the specified cell.
        /// </summary>
        /// <param name="v">The value of the cell.</param>
        /// <param name="i">The first index.</param>
        /// <param name="j">The second index.</param>
        /// <returns>The label string.</returns>
        protected virtual string GetLabel(double v, int i, int j)
        {
            return v.ToString(this.LabelFormatString, this.ActualCulture);
        }

        /// <summary>
        /// Gets the interpolated value at the specified position in the data array (by bilinear interpolation).
        /// Where interpolation is impossible, return NaN, rather than a calculated nonsense value.
        /// </summary>
        /// <param name="data">The data.</param>
        /// <param name="i">The first index.</param>
        /// <param name="j">The second index.</param>
        /// <returns>The interpolated value.</returns>
        private static double GetValue(double[,] data, double i, double j)
        {
            //// Note data[0, 0] is displayed in quadrant 1, not exactly at the origin, and that implies the invoker can produce negative coordinates.
            i = Math.Max(i, 0);
            j = Math.Max(j, 0);

            int i0 = (int)i;
            int i1 = i0 + 1 < data.GetLength(0) ? i0 + 1 : i0;

            int j0 = (int)j;
            int j1 = j0 + 1 < data.GetLength(1) ? j0 + 1 : j0;

            i = Math.Min(i, i1);
            j = Math.Min(j, j1);

            if ((i == i0) && (j == j0))
            {
                return data[i0, j0];
            }
            else if ((i != i0) && (j == j0))
            {
                //// interpolate only by i

                if (double.IsNaN(data[i0, j0]) || double.IsNaN(data[i1, j0]))
                {
                    return double.NaN;
                }

                double ifraction = i - i0;
                if (i0 != i1)
                {
                    return (data[i0, j0] * (1 - ifraction)) + (data[i1, j0] * ifraction);
                }
                else
                {
                    return data[i0, j0];
                }
            }
            else if ((i == i0) && (j != j0))
            {
                //// interpolate only by j

                if (double.IsNaN(data[i0, j0]) || double.IsNaN(data[i0, j1]))
                {
                    return double.NaN;
                }

                double jfraction = j - j0;
                if (j0 != j1)
                {
                    return (data[i0, j0] * (1 - jfraction)) + (data[i0, j1] * jfraction);
                }
                else
                {
                    return data[i0, j0];
                }
            }
            else
            {
                if (double.IsNaN(data[i0, j0]) || double.IsNaN(data[i1, j0]) || double.IsNaN(data[i0, j1]) || double.IsNaN(data[i1, j1]))
                {
                    return double.NaN;
                }

                double ifraction = i - i0;
                double jfraction = j - j0;
                double v0;
                double v1;
                if (i0 != i1)
                {
                    v0 = (data[i0, j0] * (1 - ifraction)) + (data[i1, j0] * ifraction);
                    v1 = (data[i0, j1] * (1 - ifraction)) + (data[i1, j1] * ifraction);
                }
                else
                {
                    v0 = data[i0, j0];
                    v1 = data[i0, j1];
                }

                if (j0 != j1)
                {
                    return (v0 * (1 - jfraction)) + (v1 * jfraction);
                }
                else
                {
                    return v0;
                }
            }
        }

        /// <summary>
        /// Tests if a <see cref="DataPoint" /> is inside the heat map
        /// </summary>
        /// <param name="p">The <see cref="DataPoint" /> to test.</param>
        /// <returns><c>True</c> if the point is inside the heat map.</returns>
        private bool IsPointInRange(DataPoint p)
        {
            UpdateMaxMinXY();

            return p.X >= this.MinX && p.X <= this.MaxX && p.Y >= this.MinY && p.Y <= this.MaxY;

            /*
            double left = this.X0;
            double right = this.X1;
            double bottom = this.Y0;
            double top = this.Y1;

            if (this.CoordinateDefinition == HeatMapCoordinateDefinition.Center)
            {
                double dx = (this.X1 - this.X0) / (this.Data.GetLength(0) - 1);
                double dy = (this.Y1 - this.Y0) / (this.Data.GetLength(1) - 1);

                left -= dx / 2;
                right += dx / 2;
                bottom -= dy / 2;
                top += dy / 2;
            }

            return p.X >= left && p.X <= right && p.Y >= bottom && p.Y <= top;
            */
        }

        /// <summary>
        /// Updates the image.
        /// </summary>
        private void UpdateImage()
        {
            // determine if the provided data should be reversed in x-direction
            var reverseX = this.XAxis.Transform(this.X0) > this.XAxis.Transform(this.X1);

            // determine if the provided data should be reversed in y-direction
            var reverseY = this.YAxis.Transform(this.Y0) > this.YAxis.Transform(this.Y1);

            var swapXY = this.XAxis.IsVertical();

            int m = this.Data.GetLength(0);
            int n = this.Data.GetLength(1);
            var buffer = swapXY ? new OxyColor[n, m] : new OxyColor[m, n];
            for (int i = 0; i < m; i++)
            {
                var ii = reverseX ? m - 1 - i : i;
                for (int j = 0; j < n; j++)
                {
                    var jj = reverseY ? n - 1 - j : j;
                    if (swapXY)
                        buffer[j, i] = this.ColorAxis.GetColor(this.Data[ii, jj]);
                    else
                        buffer[i, j] = this.ColorAxis.GetColor(this.Data[ii, jj]);

                }
            }

            this.image = OxyImage.Create(buffer, ImageFormat.Png);
        }
    }
}

## Summary.txt
These changes (to one file) attempt to address the following three issues:

https://github.com/oxyplot/oxyplot/issues/535
https://github.com/oxyplot/oxyplot/issues/801
https://github.com/oxyplot/oxyplot/issues/802

They include adding 3 new properties to the HeatMapSeries, and changes to all rendering and tracking functions.

They make no effort to resolve https://github.com/oxyplot/oxyplot/issues/164, because I'm not sure it makes sense

The changes that influence #535 may well be applicable to other serieses, I am not certain.

These changes can be broken down into individual commits, #801 depending on #802, #535 being mostly independant (though it modifies code introduced by #801 and #802)
	// --------------------------------------------------------------------------------------------------------------------
	// <copyright file="HeatMapSeries.cs" company="OxyPlot">
	// Copyright (c) 2014 OxyPlot contributors
	// </copyright>
	// <summary>
	// Specifies how the heat map coordinates are defined.
	// </summary>
	// --------------------------------------------------------------------------------------------------------------------

	namespace OxyPlot.Series
	{
	using System;

	using OxyPlot.Axes;

	/// <summary>
	/// Specifies how the heat map coordinates are defined.
	/// </summary>
	public enum HeatMapCoordinateDefinition
	{
	/// <summary>
	/// The coordinates defines the center of the cells
	/// </summary>
	Center,

	/// <summary>
	/// The coordinates defines the edge of the cells
	/// </summary>
	Edge
	}

	/// <summary>
	/// Represents a heat map.
	/// </summary>
	public class HeatMapSeries : XYAxisSeries
	{
	/// <summary>
	/// The default tracker format string
	/// </summary>
	public new const string DefaultTrackerFormatString = "{0}\n{1}: {2}\n{3}: {4}\n{5}: {6}";

	/// <summary>
	/// The default color-axis title
	/// </summary>
	private const string DefaultColorAxisTitle = "Value";

	/// <summary>
	/// The hash code of the data when the image was updated.
	/// </summary>
	private int dataHash;

	/// <summary>
	/// The hash code of the color axis when the image was updated.
	/// </summary>
	private int colorAxisHash;

	/// <summary>
	/// The image
	/// </summary>
	private OxyImage image;

	/// <summary>
	/// Initializes a new instance of the <see cref="HeatMapSeries" /> class.
	/// </summary>
	public HeatMapSeries()
	{
	this.TrackerFormatString = DefaultTrackerFormatString;
	this.Interpolate = true;
	this.LabelFormatString = "0.00";
	this.LabelFontSize = 0;
	}

	/// <summary>
	/// Gets or sets the x-coordinate of the elements at index [0,*] in the data set.
	/// </summary>
	/// <value>
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [0,*] in the data set.
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the left edge of the element at index [0,*] in the data set.
	/// </value>
	public double X0 { get; set; }

	/// <summary>
	/// Gets or sets the x-coordinate of the mid point for the elements at index [m-1,*] in the data set.
	/// </summary>
	/// <value>
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [m-1,*] in the data set.
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the right edge of the element at index [m-1,*] in the data set.
	/// </value>
	public double X1 { get; set; }

	/// <summary>
	/// Gets or sets the y-coordinate of the mid point for the elements at index [*,0] in the data set.
	/// </summary>
	/// <value>
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [*,0] in the data set.
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the bottom edge of the element at index [*,0] in the data set.
	/// </value>
	public double Y0 { get; set; }

	/// <summary>
	/// Gets or sets the y-coordinate of the mid point for the elements at index [*,n-1] in the data set.
	/// </summary>
	/// <value>
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Center"/>, the value defines the mid point of the element at index [*,n-1] in the data set.
	/// If <see cref="CoordinateDefinition" /> equals <see cref="HeatMapCoordinateDefinition.Edge"/>, the value defines the coordinate of the top edge of the element at index [*,n-1] in the data set.
	/// </value>
	public double Y1 { get; set; }

	/// <summary>
	/// Gets or sets the data array.
	/// </summary>
	/// <remarks>Note that the indices of the data array refer to [x,y].
	/// The first dimension is along the x-axis.
	/// The second dimension is along the y-axis.
	/// Remember to call the <see cref="Invalidate" /> method if the contents of the <see cref="Data" /> array is changed.</remarks>
	public double[,] Data { get; set; }

	/// <summary>
	/// Gets or sets a value indicating whether to interpolate when rendering. The default value is <c>true</c>.
	/// </summary>
	/// <remarks>This property is not supported on all platforms.</remarks>
	public bool Interpolate { get; set; }

	/// <summary>
	/// Gets or sets a value indicating whether to use discrete rectangles for rendering uninterpolated (ignored if Interpolate is set to true). The default value is <c>false</c>.
	/// </summary>
	public bool RenderDiscreteRectangles { get; set; }

	/// <summary>
	/// Gets or sets a value indicating whether to treat the x dimension as logarithmic. The default value is <c>false</c>.
	/// </summary>
	public bool LogX { get; set; }

	/// <summary>
	/// Gets or sets a value indicating whether to treat the y dimension as logarithmic. The default value is <c>false</c>.
	/// </summary>
	public bool LogY { get; set; }

	/// <summary>
	/// Gets the minimum value of the dataset.
	/// </summary>
	public double MinValue { get; private set; }

	/// <summary>
	/// Gets the maximum value of the dataset.
	/// </summary>
	public double MaxValue { get; private set; }

	/// <summary>
	/// Gets or sets the color axis.
	/// </summary>
	/// <value>The color axis.</value>
	public IColorAxis ColorAxis { get; protected set; }

	/// <summary>
	/// Gets or sets the color axis key.
	/// </summary>
	/// <value>The color axis key.</value>
	public string ColorAxisKey { get; set; }

	/// <summary>
	/// Gets or sets the coordinate definition. The default value is <see cref="HeatMapCoordinateDefinition.Center" />.
	/// </summary>
	/// <value>The coordinate definition.</value>
	public HeatMapCoordinateDefinition CoordinateDefinition { get; set; }

	/// <summary>
	/// Gets or sets the format string for the cell labels. The default value is <c>0.00</c>.
	/// </summary>
	/// <value>The format string.</value>
	/// <remarks>The label format string is only used when <see cref="LabelFontSize" /> is greater than 0.</remarks>
	public string LabelFormatString { get; set; }

	/// <summary>
	/// Gets or sets the font size of the labels. The default value is <c>0</c> (labels not visible).
	/// </summary>
	/// <value>The font size relative to the cell height.</value>
	public double LabelFontSize { get; set; }

	/// <summary>
	/// Invalidates the image that renders the heat map. The image will be regenerated the next time the <see cref="HeatMapSeries" /> is rendered.
	/// </summary>
	/// <remarks>Call <see cref="PlotModel.InvalidatePlot" /> to refresh the view.</remarks>
	public void Invalidate()
	{
	this.image = null;
	}

	/// <summary>
	/// Renders the series on the specified render context.
	/// </summary>
	/// <param name="rc">The rendering context.</param>
	public override void Render(IRenderContext rc)
	{
	if (this.Data == null)
	{
	this.image = null;
	return;
	}

	if (this.ColorAxis == null)
	{
	throw new InvalidOperationException("Color axis not specified.");
	}

	double left = this.X0;
	double right = this.X1;
	double bottom = this.Y0;
	double top = this.Y1;

	int m = this.Data.GetLength(0);
	int n = this.Data.GetLength(1);
	double dx = (this.X1 - this.X0) / (m - 1);
	double dy = (this.Y1 - this.Y0) / (n - 1);

	if (this.CoordinateDefinition == HeatMapCoordinateDefinition.Center)
	{
	if (LogX)
	{
	double gx = Math.Log(this.X1 / this.X0) / (m - 1);
	left *= Math.Exp(gx / -2);
	right *= Math.Exp(gx / 2);
	}
	else
	{
	left -= dx / 2;
	right += dx / 2;
	}

	if (LogY)
	{
	double gy = Math.Log(this.Y1 / this.Y0) / (n - 1);
	bottom *= Math.Exp(gy / -2);
	top *= Math.Exp(gy / 2);
	}
	else
	{
	bottom -= dy / 2;
	top += dy / 2;
	}
	}

	var s00 = this.Transform(left, bottom);
	var s11 = this.Transform(right, top);
	var rect = new OxyRect(s00, s11);

	bool needImage = Interpolate \|\| !RenderDiscreteRectangles;

	var currentDataHash = this.Data.GetHashCode();
	var currentColorAxisHash = this.ColorAxis.GetElementHashCode();
	if ((needImage && this.image == null) \|\| currentDataHash != this.dataHash \|\| currentColorAxisHash != this.colorAxisHash)
	{
	if (needImage)
	this.UpdateImage();
	this.dataHash = currentDataHash;
	this.colorAxisHash = currentColorAxisHash;
	}

	var clip = this.GetClippingRect();
	if (needImage)
	{
	if (this.image != null)
	{
	rc.DrawClippedImage(clip, this.image, rect.Left, rect.Top, rect.Width, rect.Height, 1, this.Interpolate);
	}
	}
	else
	{
	s00 = this.Orientate(s00); // disorientate
	s11 = this.Orientate(s11); // disorientate

	double sdx = (s11.X - s00.X) / m;
	double sdy = (s11.Y - s00.Y) / n;

	// draw lots of rectangles
	for (int i = 0; i < m; i++)
	{
	for (int j = 0; j < n; j++)
	{
	OxyColor rectcolor = this.ColorAxis.GetColor(this.Data[i, j]);

	var pointa = this.Orientate(new ScreenPoint(s00.X + i * sdx, s00.Y + j * sdy)); // reorientate
	var pointb = this.Orientate(new ScreenPoint(s00.X + (i + 1) * sdx, s00.Y + (j + 1) * sdy)); // reorientate
	OxyRect rectrect = new OxyRect(pointa, pointb);

	rc.DrawClippedRectangle(clip, rectrect, rectcolor, OxyColors.Undefined, 0);
	}
	}
	}

	if (this.LabelFontSize > 0)
	{
	this.RenderLabels(rc, rect);
	}
	}

	// fudge Tranform/InverseTranform testing (for Transpose #535)
	protected new OxyRect GetClippingRect()
	{
	double minX = Math.Min(this.XAxis.ScreenMin.X, this.XAxis.ScreenMax.X);
	double minY = Math.Min(this.YAxis.ScreenMin.Y, this.YAxis.ScreenMax.Y);
	double maxX = Math.Max(this.XAxis.ScreenMin.X, this.XAxis.ScreenMax.X);
	double maxY = Math.Max(this.YAxis.ScreenMin.Y, this.YAxis.ScreenMax.Y);

	if (XAxis.IsVertical())
	return new OxyRect(minY, minX, maxY - minY, maxX - minX);
	else
	return new OxyRect(minX, minY, maxX - minX, maxY - minY);
	}

	private ScreenPoint Orientate(ScreenPoint point)
	{
	if (XAxis.IsVertical())
	{
	point = new ScreenPoint(point.Y, point.X);
	}
	return point;
	}

	public new ScreenPoint Transform(double x, double y)
	{
	return Orientate(base.Transform(x, y));
	}

	public new ScreenPoint Transform(DataPoint p)
	{
	return Orientate(base.Transform(p));
	}

	public new DataPoint InverseTransform(ScreenPoint point)
	{
	return base.InverseTransform(Orientate(point));
	}
	//

	/// <summary>
	/// Gets the point on the series that is nearest the specified point.
	/// </summary>
	/// <param name="point">The point.</param>
	/// <param name="interpolate">Interpolate the series if this flag is set to <c>true</c>.</param>
	/// <returns>A TrackerHitResult for the current hit.</returns>
	public override TrackerHitResult GetNearestPoint(ScreenPoint point, bool interpolate)
	{
	if (!this.Interpolate)
	{
	// It makes no sense to interpolate the tracker when the plot is not interpolated.
	interpolate = false;
	}

	var p = this.InverseTransform(point);

	if (!this.IsPointInRange(p))
	{
	return null;
	}

	// these are screen space coords
	double i;
	double j;

	if (LogX)
	{
	double gx = Math.Log(this.X1 / this.X0) / (this.Data.GetLength(0) - 1);
	i = Math.Log(p.X / this.X0) / gx;
	}
	else
	{
	double dx = (this.X1 - this.X0) / (this.Data.GetLength(0) - 1);
	i = (p.X - this.X0) / dx;
	}

	if (LogY)
	{
	double gy = Math.Log(this.Y1 / this.Y0) / (this.Data.GetLength(1) - 1);
	j = Math.Log(p.Y / this.Y0) / gy;
	}
	else
	{
	double dy = (this.Y1 - this.Y0) / (this.Data.GetLength(1) - 1);
	j = (p.Y - this.Y0) / dy;
	}

	if (!interpolate)
	{
	i = Math.Round(i);
	j = Math.Round(j);

	double px;
	double py;

	if (LogX)
	{
	double gx = Math.Log(this.X1 / this.X0) / (this.Data.GetLength(0) - 1);
	px = this.X0 * Math.Exp((double)i * gx);
	}
	else
	{
	double dx = (this.X1 - this.X0) / (this.Data.GetLength(0) - 1);
	px = (i * dx) + this.X0;
	}

	if (LogY)
	{
	double gy = Math.Log(this.Y1 / this.Y0) / (this.Data.GetLength(1) - 1);
	py = this.Y0 * Math.Exp((double)j * gy);
	}
	else
	{
	double dy = (this.Y1 - this.Y0) / (this.Data.GetLength(1) - 1);
	py = (j * dy) + this.Y0;
	}

	p = new DataPoint(px, py);
	point = this.Transform(p);
	}

	var value = GetValue(this.Data, i, j);
	var colorAxis = this.ColorAxis as Axis;
	var colorAxisTitle = (colorAxis != null ? colorAxis.Title : null) ?? DefaultColorAxisTitle;

	return new TrackerHitResult
	{
	Series = this,
	DataPoint = p,
	Position = point,
	Item = null,
	Index = -1,
	Text = StringHelper.Format(
	this.ActualCulture,
	this.TrackerFormatString,
	null,
	this.Title,
	this.XAxis.Title ?? DefaultXAxisTitle,
	this.XAxis.GetValue(p.X),
	this.YAxis.Title ?? DefaultYAxisTitle,
	this.YAxis.GetValue(p.Y),
	colorAxisTitle,
	value)
	};
	}

	/// <summary>
	/// Ensures that the axes of the series is defined.
	/// </summary>
	protected internal override void EnsureAxes()
	{
	base.EnsureAxes();

	this.ColorAxis =
	this.PlotModel.GetAxisOrDefault(this.ColorAxisKey, (Axis)this.PlotModel.DefaultColorAxis) as IColorAxis;
	}

	/// <summary>
	/// Updates the maximum and minimum values of the series for the x and y dimensions only.
	/// </summary>
	protected internal void UpdateMaxMinXY()
	{
	int m = this.Data.GetLength(0);
	int n = this.Data.GetLength(1);

	this.MinX = Math.Min(this.X0, this.X1);
	this.MaxX = Math.Max(this.X0, this.X1);

	this.MinY = Math.Min(this.Y0, this.Y1);
	this.MaxY = Math.Max(this.Y0, this.Y1);

	if (this.CoordinateDefinition == HeatMapCoordinateDefinition.Center)
	{
	if (LogX)
	{
	double gx = Math.Log(this.MaxX / this.MinX) / (m - 1);
	this.MinX *= Math.Exp(gx / -2);
	this.MaxX *= Math.Exp(gx / 2);
	}
	else
	{
	double dx = (this.MaxX - this.MinX) / (m - 1);
	this.MinX -= dx / 2;
	this.MaxX += dx / 2;
	}

	if (LogY)
	{
	double gy = Math.Log(this.MaxY / this.MinY) / (n - 1);
	this.MinY *= Math.Exp(gy / -2);
	this.MaxY *= Math.Exp(gy / 2);
	}
	else
	{
	double dy = (this.MaxY - this.MinY) / (n - 1);
	this.MinY -= dy / 2;
	this.MaxY += dy / 2;
	}
	}
	}

	/// <summary>
	/// Updates the maximum and minimum values of the series.
	/// </summary>
	protected internal override void UpdateMaxMin()
	{
	base.UpdateMaxMin();

	UpdateMaxMinXY();

	this.MinValue = this.Data.Min2D(true);
	this.MaxValue = this.Data.Max2D();
	}

	/// <summary>
	/// Updates the axes to include the max and min of this series.
	/// </summary>
	protected internal override void UpdateAxisMaxMin()
	{
	base.UpdateAxisMaxMin();
	var colorAxis = this.ColorAxis as Axis;
	if (colorAxis != null)
	{
	colorAxis.Include(this.MinValue);
	colorAxis.Include(this.MaxValue);
	}
	}

	/// <summary>
	/// Renders the labels.
	/// </summary>
	/// <param name="rc">The <see cref="IRenderContext" /></param>
	/// <param name="rect">The bounding rectangle for the data.</param>
	protected virtual void RenderLabels(IRenderContext rc, OxyRect rect)
	{
	var clip = this.GetClippingRect();
	int m = this.Data.GetLength(0);
	int n = this.Data.GetLength(1);
	//double dx = (this.X1 - this.X0) / (m - 1);
	//double dy = (this.Y1 - this.Y0) / (n - 1);
	double fontSize = (rect.Height / n) * this.LabelFontSize;

	double left = this.X0;
	double right = this.X1;
	double bottom = this.Y0;
	double top = this.Y1;

	var s00 = this.Orientate(this.Transform(left, bottom)); // disorientate
	var s11 = this.Orientate(this.Transform(right, top)); // disorientate

	//var labelrect = new OxyRect(s00, s11);
	//double sdx = labelrect.Width / (m - 1);
	//double sdy = labelrect.Height / (n - 1);
	//var labelrect = new OxyRect(s00, s11);
	double sdx = (s11.X - s00.X) / (m - 1);
	double sdy = (s11.Y - s00.Y) / (n - 1);

	for (int i = 0; i < m; i++)
	{
	for (int j = 0; j < n; j++)
	{
	//var p = new DataPoint((i * dx) + this.X0, (j * dy) + this.Y0);
	//var point = this.Transform(p);
	var point = this.Orientate(new ScreenPoint(s00.X + i * sdx, s00.Y + j * sdy)); // reorientate
	var v = GetValue(this.Data, i, j);
	var color = this.ColorAxis.GetColor(v);
	var hsv = color.ToHsv();
	var textColor = hsv[2] > 0.6 ? OxyColors.Black : OxyColors.White;
	var label = this.GetLabel(v, i, j);
	rc.DrawClippedText(
	clip,
	point,
	label,
	textColor,
	this.ActualFont,
	fontSize,
	500,
	0,
	HorizontalAlignment.Center,
	VerticalAlignment.Middle);
	}
	}
	}

	/// <summary>
	/// Gets the label for the specified cell.
	/// </summary>
	/// <param name="v">The value of the cell.</param>
	/// <param name="i">The first index.</param>
	/// <param name="j">The second index.</param>
	/// <returns>The label string.</returns>
	protected virtual string GetLabel(double v, int i, int j)
	{
	return v.ToString(this.LabelFormatString, this.ActualCulture);
	}

	/// <summary>
	/// Gets the interpolated value at the specified position in the data array (by bilinear interpolation).
	/// Where interpolation is impossible, return NaN, rather than a calculated nonsense value.
	/// </summary>
	/// <param name="data">The data.</param>
	/// <param name="i">The first index.</param>
	/// <param name="j">The second index.</param>
	/// <returns>The interpolated value.</returns>
	private static double GetValue(double[,] data, double i, double j)
	{
	//// Note data[0, 0] is displayed in quadrant 1, not exactly at the origin, and that implies the invoker can produce negative coordinates.
	i = Math.Max(i, 0);
	j = Math.Max(j, 0);

	int i0 = (int)i;
	int i1 = i0 + 1 < data.GetLength(0) ? i0 + 1 : i0;

	int j0 = (int)j;
	int j1 = j0 + 1 < data.GetLength(1) ? j0 + 1 : j0;

	i = Math.Min(i, i1);
	j = Math.Min(j, j1);

	if ((i == i0) && (j == j0))
	{
	return data[i0, j0];
	}
	else if ((i != i0) && (j == j0))
	{
	//// interpolate only by i

	if (double.IsNaN(data[i0, j0]) \|\| double.IsNaN(data[i1, j0]))
	{
	return double.NaN;
	}

	double ifraction = i - i0;
	if (i0 != i1)
	{
	return (data[i0, j0] * (1 - ifraction)) + (data[i1, j0] * ifraction);
	}
	else
	{
	return data[i0, j0];
	}
	}
	else if ((i == i0) && (j != j0))
	{
	//// interpolate only by j

	if (double.IsNaN(data[i0, j0]) \|\| double.IsNaN(data[i0, j1]))
	{
	return double.NaN;
	}

	double jfraction = j - j0;
	if (j0 != j1)
	{
	return (data[i0, j0] * (1 - jfraction)) + (data[i0, j1] * jfraction);
	}
	else
	{
	return data[i0, j0];
	}
	}
	else
	{
	if (double.IsNaN(data[i0, j0]) \|\| double.IsNaN(data[i1, j0]) \|\| double.IsNaN(data[i0, j1]) \|\| double.IsNaN(data[i1, j1]))
	{
	return double.NaN;
	}

	double ifraction = i - i0;
	double jfraction = j - j0;
	double v0;
	double v1;
	if (i0 != i1)
	{
	v0 = (data[i0, j0] * (1 - ifraction)) + (data[i1, j0] * ifraction);
	v1 = (data[i0, j1] * (1 - ifraction)) + (data[i1, j1] * ifraction);
	}
	else
	{
	v0 = data[i0, j0];
	v1 = data[i0, j1];
	}

	if (j0 != j1)
	{
	return (v0 * (1 - jfraction)) + (v1 * jfraction);
	}
	else
	{
	return v0;
	}
	}
	}

	/// <summary>
	/// Tests if a <see cref="DataPoint" /> is inside the heat map
	/// </summary>
	/// <param name="p">The <see cref="DataPoint" /> to test.</param>
	/// <returns><c>True</c> if the point is inside the heat map.</returns>
	private bool IsPointInRange(DataPoint p)
	{
	UpdateMaxMinXY();

	return p.X >= this.MinX && p.X <= this.MaxX && p.Y >= this.MinY && p.Y <= this.MaxY;

	/*
	double left = this.X0;
	double right = this.X1;
	double bottom = this.Y0;
	double top = this.Y1;

	if (this.CoordinateDefinition == HeatMapCoordinateDefinition.Center)
	{
	double dx = (this.X1 - this.X0) / (this.Data.GetLength(0) - 1);
	double dy = (this.Y1 - this.Y0) / (this.Data.GetLength(1) - 1);

	left -= dx / 2;
	right += dx / 2;
	bottom -= dy / 2;
	top += dy / 2;
	}

	return p.X >= left && p.X <= right && p.Y >= bottom && p.Y <= top;
	*/
	}

	/// <summary>
	/// Updates the image.
	/// </summary>
	private void UpdateImage()
	{
	// determine if the provided data should be reversed in x-direction
	var reverseX = this.XAxis.Transform(this.X0) > this.XAxis.Transform(this.X1);

	// determine if the provided data should be reversed in y-direction
	var reverseY = this.YAxis.Transform(this.Y0) > this.YAxis.Transform(this.Y1);

	var swapXY = this.XAxis.IsVertical();

	int m = this.Data.GetLength(0);
	int n = this.Data.GetLength(1);
	var buffer = swapXY ? new OxyColor[n, m] : new OxyColor[m, n];
	for (int i = 0; i < m; i++)
	{
	var ii = reverseX ? m - 1 - i : i;
	for (int j = 0; j < n; j++)
	{
	var jj = reverseY ? n - 1 - j : j;
	if (swapXY)
	buffer[j, i] = this.ColorAxis.GetColor(this.Data[ii, jj]);
	else
	buffer[i, j] = this.ColorAxis.GetColor(this.Data[ii, jj]);

	}
	}

	this.image = OxyImage.Create(buffer, ImageFormat.Png);
	}
	}
	}
	These changes (to one file) attempt to address the following three issues:

	https://github.com/oxyplot/oxyplot/issues/535
	https://github.com/oxyplot/oxyplot/issues/801
	https://github.com/oxyplot/oxyplot/issues/802

	They include adding 3 new properties to the HeatMapSeries, and changes to all rendering and tracking functions.

	They make no effort to resolve https://github.com/oxyplot/oxyplot/issues/164, because I'm not sure it makes sense

	The changes that influence #535 may well be applicable to other serieses, I am not certain.

	These changes can be broken down into individual commits, #801 depending on #802, #535 being mostly independant (though it modifies code introduced by #801 and #802)