Steema Central

Code: Select all

	int w = bitmap.Width;
	int h = bitmap.Height;
	BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, w, h), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);

	unsafe
	{
		int *ptr = (int*)bmData.Scan0.ToPointer();

		for(int y = 0; y < h; ++y)
		{
			for(int x = 0; x < w; ++x)
			{
				*ptr++ = (int)colors[x,y].ToArgb();
			}
		}
	}

	bitmap.UnlockBits(bmData);

Code: Select all

lockRect = new Rectangle(new Point(0,0), fBuffer.Size);
fBufferData = fBuffer.LockBits(lockRect,System.Drawing.Imaging.ImageLockMode.ReadWrite,System.Drawing.Imaging.PixelFormat.Format32bppPArgb);

System.IntPtr b2line0 = resultData.Scan0;
System.IntPtr b1line0 = fBufferData.Scan0;

int Dif=fBufferData.Stride; 

for(y=0; y<h; ++y) 
{
tmpy = Utils.Round(Utils.Sqr(y-yy));

for(x=0; x<w; ++x) 
{
dist = Math.Sqrt(Utils.Sqr(x-xx)+tmpy);
offset=(y*Dif)+(BytesPerPixel*x);

Marshal.WriteByte(b2line0,offset+2,Marshal.ReadByte(b1line0, offset+2));
Marshal.WriteByte(b2line0,offset+1,Marshal.ReadByte(b1line0, offset+1));
Marshal.WriteByte(b2line0,offset,Marshal.ReadByte(b1line0, offset));
Marshal.WriteByte(b2line0,offset+3,Marshal.ReadByte(b1line0, offset+3));
}
}
fBuffer.UnlockBits(fBufferData);
result.UnlockBits(resultData);

Code: Select all

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

public class ConsoleApp
{
	private static void SetPixelFill(Bitmap bitmap)
	{
		int width = bitmap.Width;
		int height = bitmap.Height;
		Color color = Color.Purple;

		for(int j = 0; j < height; ++j)
			for(int i = 0; i < width; ++i)
				bitmap.SetPixel(i, j, color);
	}

	private static void MarshalFill(Bitmap bitmap)
	{
		int width = bitmap.Width;
		int height = bitmap.Height;
		Color color = Color.Purple;

		BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);

		IntPtr ptr = bmData.Scan0;

		for(int j = 0; j < height; ++j)
			for(int i = 0; i < width; ++i)
				Marshal.WriteInt32(ptr, (i + j * width) * 4, color.ToArgb());

		bitmap.UnlockBits(bmData);
	}

	private static void DirectFill(Bitmap bitmap)
	{
		int width = bitmap.Width;
		int height = bitmap.Height;
		Color color = Color.Purple;

		BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);

		unsafe
		{
			int *ptr = (int*)bmData.Scan0.ToPointer();

			for(int j = 0; j < height; ++j)
				for(int i = 0; i < width; ++i)
					*(ptr + i + j * width) = color.ToArgb();
		}

		bitmap.UnlockBits(bmData);
	}

	private static void DirectFillOptimized(Bitmap bitmap)
	{
		int width = bitmap.Width;
		int height = bitmap.Height;
		Color color = Color.Purple;

		int argb = color.ToArgb();

		BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);

		unsafe
		{
			int *ptr = (int*)bmData.Scan0.ToPointer();

			for(int j = 0; j < height; ++j)
				for(int i = 0; i < width; ++i)
					*ptr++ = argb;
		}

		bitmap.UnlockBits(bmData);
	}



	private delegate void TestInvoker(Bitmap bitmap);

	private static void RunTest(string testName, TestInvoker test, Bitmap originalBitmap)
	{
		Bitmap bitmap = (Bitmap)originalBitmap.Clone();

		System.Console.Write("\nRunning \"{0}\" test...   ", testName);

		DateTime start = DateTime.Now;

		test.Invoke(bitmap);

		System.Console.WriteLine("{0} ms", (DateTime.Now - start).TotalMilliseconds);
		bitmap.Save(testName + ".png");
	}

	public static void Main(string[] args)
	{
		Bitmap originalBitmap = new Bitmap(1600, 1200, PixelFormat.Format32bppArgb);

		RunTest("SetPixel fill", new TestInvoker(SetPixelFill), originalBitmap);
		RunTest("marshal fill", new TestInvoker(MarshalFill), originalBitmap);
		RunTest("direct fill", new TestInvoker(DirectFill), originalBitmap);
		RunTest("direct fill optimized", new TestInvoker(DirectFillOptimized), originalBitmap);
	}
}

Code: Select all

Running "SetPixel fill" test...   4453.125 ms
Running "marshal fill" test...   93.75 ms
Running "direct fill" test...   78.125 ms
Running "direct fill optimized" test...   31.25 ms

Code: Select all

   private DateTime start; 

    private void Form1_Load(object sender, EventArgs e)
    {
      tChart1.Aspect.View3D = false;
      start = DateTime.Now;
      Steema.TeeChart.Styles.ColorGrid grid = new Steema.TeeChart.Styles.ColorGrid(tChart1.Chart);
      grid.FillSampleValues(100); 
    }

    private void tChart1_AfterDraw(object sender, Steema.TeeChart.Drawing.Graphics3D g)
    {
      label1.Text = (DateTime.Now - start).TotalMilliseconds.ToString();
    }

Code: Select all

private void DrawCellUsingBitmap(ref Rectangle tmpBounds, ref Rectangle R)
{
	try
	{
		int newWidth = Math.Abs((int) (((1 + tmpBounds.Right) - tmpBounds.Left) - this.tmpDec));
		int newHeight = Math.Abs((int) (((1 + tmpBounds.Bottom) - tmpBounds.Top) - this.tmpDec));
		if(newWidth == 0 || newHeight == 0)
			throw new Exception();

		if(bbitmap == null || bbitmap.Width != newWidth || bbitmap.Height != newHeight)
		{
			if(bbitmap != null)
				bbitmap.Dispose();

			bbitmap = new Bitmap(newWidth, newHeight);
		}
	}
	catch
	{
		throw new TeeChartException(Texts.ColorGridSeriesRangeExceed);
	}

	this.FillBitmap(ref tmpBounds, bbitmap);
	if (this.MinXValue() > 1)
	{
		  tmpBounds.X += Utils.Round(this.MinXValue());
		  tmpBounds.Width += Utils.Round(this.MinXValue());
	}
	if (this.MinZValue() > 1)
	{
		  tmpBounds.Y += Utils.Round(this.MinZValue());
		  tmpBounds.Height += Utils.Round(this.MinZValue());
	}
	R = this.CalcDestRectangle(tmpBounds);
	this.DrawBitmap(bbitmap, ref R);
}

Code: Select all

	public class MyGrid : Steema.TeeChart.Styles.ColorGrid 
	{
		public MyGrid(Steema.TeeChart.Chart c) : base(c) 
		{
			ypalette = false;
		}

		private bool ypalette;

		/// <summary>
		/// Setting to true will create a Grid Palette based only on the Series YValues.
		/// </summary>
		[DefaultValue(false)]
		public bool YPalette 
		{
			get{return ypalette;}
			set{ypalette = value;}
		}

		public override Color ValueColor(int valueIndex)
		{
			if(ypalette) 
			{
				double argb = (-16777215 / YValues.Range) * YValues[valueIndex];
				return Color.FromArgb(Steema.TeeChart.Utils.Round(argb));
			}
			else 
				return base.ValueColor (valueIndex);
		}
	}

Code: Select all

using System;
using System.Collections.Generic;
using System.Text;
using Steema.TeeChart;
using System.Drawing;
using Steema.TeeChart.Styles;
using System.Reflection;
using System.Drawing.Imaging;
using Steema.TeeChart.Drawing;
using System.ComponentModel;

namespace WindowsApplication1
{
	public class FastColorGrid : Steema.TeeChart.Styles.ColorGrid
	{

		#region Private fields
		
		private bool simpleColoring = false;
		private Bitmap bbitmap = null;

		#endregion

		#region Construction/destruction
		
		public FastColorGrid()
		{
			base.IrregularGrid = false;
		}

		public FastColorGrid(Chart c)
			: base(c)
		{
			base.IrregularGrid = false;
		}
		
		#endregion

		#region Public properties

		[DefaultValue(false)]
		public bool SimpleColoring
		{
			get { return simpleColoring; }
			set { simpleColoring = value; }
		}

		#endregion

		#region Overrides

		protected override void Draw()
		{
			if (base.Count <= 0)
				return;

			int horzStartPos = (int)GetHorizAxis.CalcPosPoint(GetHorizAxis.IStartPos);
			int horzEndPos = (int)GetHorizAxis.CalcPosPoint(GetHorizAxis.IEndPos);
			if (GetHorizAxis.Inverted)
				horzStartPos++;
			else
				horzEndPos++;
			int vertStartPos = (int)GetVertAxis.CalcPosPoint(GetVertAxis.IStartPos);
			int vertEndPos = (int)GetVertAxis.CalcPosPoint(GetVertAxis.IEndPos);
			if (GetVertAxis.Inverted)
				vertEndPos++;
			else
				vertStartPos++;

			Rectangle rectangle1 = Rectangle.FromLTRB(horzStartPos, vertStartPos, horzEndPos, vertEndPos);
			Chart.Graphics3D.OrientRectangle(ref rectangle1);
			rectangle1.X -= Utils.Round(this.MinXValue());
			rectangle1.Y -= Utils.Round(this.MinZValue());
			rectangle1.Width -= Utils.Round(this.MinXValue());
			rectangle1.Height -= Utils.Round(this.MinZValue());
			if (rectangle1.X < 1)
			{
				rectangle1.X = 1;
			}
			if (rectangle1.Y < 1)
			{
				rectangle1.Y = 1;
			}
			if (rectangle1.Right > NumXValues)
			{
				rectangle1.Width = NumXValues - rectangle1.X;
			}
			if (rectangle1.Bottom > NumZValues)
			{
				rectangle1.Height = NumZValues - rectangle1.Y;
			}

			Rectangle rectangle2 = new Rectangle(0, 0, 0, 0);
			DrawCellUsingBitmap(ref rectangle1, ref rectangle2);
		}

		#endregion

		#region Private methods

		private void DrawCellUsingBitmap(ref Rectangle tmpBounds, ref Rectangle R)
		{
			int newWidth = Math.Abs((int)((1 + tmpBounds.Right) - tmpBounds.Left));
			int newHeight = Math.Abs((int)((1 + tmpBounds.Bottom) - tmpBounds.Top));
			if (newWidth == 0 || newHeight == 0 || newWidth > 3000 || newHeight > 3000)
				throw new TeeChartException(Texts.ColorGridSeriesRangeExceed);

			if (bbitmap == null || bbitmap.Width != newWidth || bbitmap.Height != newHeight)
			{
				if (bbitmap != null)
					bbitmap.Dispose();

				bbitmap = new Bitmap(newWidth, newHeight);
			}

			FillBitmap(ref tmpBounds, bbitmap);

			if (MinXValue() > 1)
			{
				tmpBounds.X += Utils.Round(MinXValue());
				tmpBounds.Width += Utils.Round(MinXValue());
			}
			if (MinZValue() > 1)
			{
				tmpBounds.Y += Utils.Round(MinZValue());
				tmpBounds.Height += Utils.Round(MinZValue());
			}
			R = CalcDestRectangle(tmpBounds);
			DrawBitmap(bbitmap, ref R);
		}

		private void FillBitmap(ref Rectangle tmpBounds, Bitmap bitmap)
		{
			int width = bitmap.Width;
			int height = bitmap.Height;
			int top = tmpBounds.Top;
			int bottom = tmpBounds.Bottom;
			int left = tmpBounds.Left;
			int right = tmpBounds.Right;

			BitmapData data1 = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppRgb);
			IntPtr ptr1 = data1.Scan0;

			unsafe
			{
				int* imgBase = (int*)ptr1.ToPointer();
				if (simpleColoring)
				{
					double[] v = YValues.Value;
					int xValues = NumXValues;
					int zValues = NumZValues;

					double minYValue = YValues.Minimum;
					double range = 255 / (YValues.Maximum - YValues.Minimum);
					int left1 = left - 1;
					int xcnt = right - left + 1;

					for (int z = top; z <= bottom; z++)
					{
						int zz = z - top;
						int* p = imgBase + zz * width;
						int t = (z - 1) + zValues * left1;
						for (int x = xcnt; x > 0; --x)
						{
							int c = 255 - (int)((v[t] - minYValue) * range);
							t += zValues;
							*p++ = c << 16 | c << 8 | c >> 1 | 0x80;
						}
					}
				}
				else
				{
					for (int z = top; z <= bottom; z++)
					{
						int zz = z - top;
						int* p = imgBase + zz * width;
						for (int x = left; x <= right; x++)
						{
							Color color = Color.White;
							int idx = base[x, z];
							if (idx != -1)
							{
								color = this.ValueColor(idx);
								if (color == Color.Empty)
									color = Color.White;
							}
							*p++ = color.ToArgb();
						}
					}
				}
			}
			bitmap.UnlockBits(data1);
		}

		private void DrawBitmap(Bitmap bitmap, ref Rectangle r)
		{
			Graphics3D graphicsd1 = Chart.Graphics3D;
			graphicsd1.PrepareDrawImage();
			graphicsd1.Draw(r, bitmap, false);
		}

		private Rectangle CalcDestRectangle(Rectangle tmpBounds)
		{
			int num1 = GetHorizAxis.CalcPosValue(Math.Max(MinXValue(), CalcMinValue((double)(tmpBounds.Left - 1))));
			int num2 = GetHorizAxis.CalcPosValue(Math.Min(MaxXValue(), CalcMaxValue((double)tmpBounds.Right)));
			int num3 = GetVertAxis.CalcPosValue(Math.Max(MinZValue(), CalcMinValue((double)(tmpBounds.Top - 1))));
			int num4 = GetVertAxis.CalcPosValue(Math.Min(MaxZValue(), CalcMaxValue((double)tmpBounds.Bottom)));
			return Rectangle.FromLTRB(num1, num3, num2, num4);
		}

		private double CalcMinValue(double Value)
		{
			if (!CenteredPoints)
			{
				return Value;
			}
			return (Value - 0.5);
		}

		private double CalcMaxValue(double Value)
		{
			if (CenteredPoints)
			{
				return (Value + 0.5);
			}

			return (Value + 1);
		}

		#endregion
	}
}