BioImager.Graphics.Graphics Class Reference

Inheritance diagram for BioImager.Graphics.Graphics:

Public Member Functions
void	DrawLine (int x, int y, int x2, int y2)
void	DrawLine (PointF p, PointF p2)
void	FillRectangle (Rectangle r, ColorS col)
void	FillRectangle (RectangleF r, ColorS col)
void	DrawRectangle (Rectangle r)
void	DrawRectangle (RectangleF r)
void	DrawEllipse (Rectangle r)
void	DrawEllipse (RectangleF r)
void	FillEllipse (float xx, float yy, int w, int h, ColorS c)
void	FillEllipse (RectangleF r, ColorS c)
void	FillEllipse (Rectangle r, ColorS c)
void	FillPolygon (PointF[] pfs, Rectangle r)
void	FillPolygon (PointF[] pfs, RectangleF r)
bool	PointInPolygon (int x, int y)
void	FillPolygon (PointF[] pfs, Rectangle r, ColorS c)
void	FillPolygon (PointF[] pfs, RectangleF r, ColorS c)
void	DrawScanline (int x, int x2, int line, ColorS col)
void	Dispose ()

Static Public Member Functions
static Graphics	FromImage (Bitmap b)

Public Attributes
Bitmap	buf
Pen	pen

Detailed Description

Definition at line 32 of file Graphics.cs.

Member Function Documentation

Dispose()

void BioImager.Graphics.Graphics.Dispose

(

)

Definition at line 286 of file Graphics.cs.

        {
            pen.Dispose();
        }

DrawEllipse() [1/2]

void BioImager.Graphics.Graphics.DrawEllipse

(

Rectangle

r

)

Definition at line 158 of file Graphics.cs.

        {
            if (r.Width == 1 && r.Height == 1)
                buf.SetPixel(r.X, r.Y, pen.color);
            double radiusx = r.Width / 2;
            double radiusy = r.Height / 2;
            int x, y;
            for (double a = 0.0; a < 360.0; a += 0.1)
            {
                double angle = a * System.Math.PI / 180;
                for (int i = 0; i < pen.width; i++)
                {
                    x = (int)(radiusx * System.Math.Cos(angle) + radiusx + r.X);
                    y = (int)(radiusy * System.Math.Sin(angle) + radiusy + r.Y);
                    buf.SetPixel(x + i, y + i, pen.color);
                }
            }
        }

DrawEllipse() [2/2]

void BioImager.Graphics.Graphics.DrawEllipse

(

RectangleF

r

)

Definition at line 176 of file Graphics.cs.

        {
            DrawEllipse(new Rectangle((int)Math.Ceiling(r.X), (int)Math.Ceiling(r.Y), (int)Math.Ceiling(r.Width), (int)Math.Ceiling(r.Height)));
        }

DrawLine() [1/2]

void BioImager.Graphics.Graphics.DrawLine	(	int	x,
		int	y,
		int	x2,
		int	y2
	)

Definition at line 44 of file Graphics.cs.

        {
            //Bresenham's algorithm for line drawing.
            int w = x2 - x;
            int h = y2 - y;
            int dx1 = 0, dy1 = 0, dx2 = 0, dy2 = 0;
            if (w < 0) dx1 = -1; else if (w > 0) dx1 = 1;
            if (h < 0) dy1 = -1; else if (h > 0) dy1 = 1;
            if (w < 0) dx2 = -1; else if (w > 0) dx2 = 1;
            int longest = Math.Abs(w);
            int shortest = Math.Abs(h);
            if (!(longest > shortest))
            {
                longest = Math.Abs(h);
                shortest = Math.Abs(w);
                if (h < 0) dy2 = -1; else if (h > 0) dy2 = 1;
                dx2 = 0;
            }
            int numerator = longest >> 1;
            for (int i = 0; i <= longest; i++)
            {
                FillEllipse(x, y, pen.width, pen.width, pen.color);
                numerator += shortest;
                if (!(numerator < longest))
                {
                    numerator -= longest;
                    x += dx1;
                    y += dy1;
                }
                else
                {
                    x += dx2;
                    y += dy2;
                }
            }
        }

DrawLine() [2/2]

void BioImager.Graphics.Graphics.DrawLine	(	PointF	p,
		PointF	p2
	)

Definition at line 116 of file Graphics.cs.

        {
            DrawLine((int)p.X, (int)p.Y, (int)p2.X, (int)p2.Y);
        }

DrawRectangle() [1/2]

void BioImager.Graphics.Graphics.DrawRectangle

(

Rectangle

r

)

Definition at line 134 of file Graphics.cs.

        {
            for (int x = r.X; x < r.Width + r.X; x++)
            {
                for (int i = 0; i < pen.width; i++)
                {
                    buf.SetPixel(x + i, r.Y, pen.color);
                    buf.SetPixel(x + i, r.Y + r.Height, pen.color);
                }
            }
            for (int y = r.Y; y < r.Height + r.Y; y++)
            {
                for (int i = 0; i < pen.width; i++)
                {
                    buf.SetPixel(r.X, y + i, pen.color);
                    buf.SetPixel(r.X + r.Width, y + i, pen.color);
                }
            }
        }

DrawRectangle() [2/2]

void BioImager.Graphics.Graphics.DrawRectangle

(

RectangleF

r

)

Definition at line 153 of file Graphics.cs.

        {
            DrawRectangle(new Rectangle((int)Math.Ceiling(r.X), (int)Math.Ceiling(r.Y), (int)Math.Ceiling(r.Width), (int)Math.Ceiling(r.Height)));
        }

DrawScanline()

void BioImager.Graphics.Graphics.DrawScanline	(	int	x,
		int	x2,
		int	line,
		ColorS	col
	)

Definition at line 279 of file Graphics.cs.

        {
            for (int xx = x; xx < x2; xx++)
            {
                buf.SetPixel(xx, line, col);
            }
        }

FillEllipse() [1/3]

void BioImager.Graphics.Graphics.FillEllipse	(	float	xx,
		float	yy,
		int	w,
		int	h,
		ColorS	c
	)

Definition at line 180 of file Graphics.cs.

        {
            if (w <= 1 && w <= 1)
            {
                buf.SetPixel((int)xx, (int)yy, c);
                return;
            }
            double radiusx = w / 2;
            double radiusy = h / 2;
            int x, y;
            for (double a = 90; a < 270; a += 0.1)
            {
                double angle = a * System.Math.PI / 180;
                x = (int)(radiusx * System.Math.Cos(angle) + radiusx + xx);
                y = (int)(radiusy * System.Math.Sin(angle) + radiusy + yy);
                double angle2 = (a + 180) * System.Math.PI / 180;
                int x2 = (int)(radiusx * System.Math.Cos(angle2) + radiusx + xx);
                DrawScanline(x, x2, y, c);
            }
        }

FillEllipse() [2/3]

void BioImager.Graphics.Graphics.FillEllipse	(	Rectangle	r,
		ColorS	c
	)

Definition at line 204 of file Graphics.cs.

        {
            FillEllipse(r.X, r.Y, r.Width, r.Height, c);
        }

FillEllipse() [3/3]

void BioImager.Graphics.Graphics.FillEllipse	(	RectangleF	r,
		ColorS	c
	)

Definition at line 200 of file Graphics.cs.

        {
            FillEllipse(new Rectangle((int)Math.Ceiling(r.X), (int)Math.Ceiling(r.Y), (int)Math.Ceiling(r.Width), (int)Math.Ceiling(r.Height)), c);
        }

FillPolygon() [1/4]

void BioImager.Graphics.Graphics.FillPolygon	(	PointF[]	pfs,
		Rectangle	r
	)

Definition at line 208 of file Graphics.cs.

        {
            //We will use the flood fill algorithm to fill the polygon.
            //First we need to create a new Buffer incase the current Buffer contains filled pixels that could prevent flood fill from filling the whole area.
            Bitmap bf = buf.CopyInfo();
            bf.Bytes = new byte[buf.Bytes.Length];
 
            DrawPolygon(pfs, bf, pen.color);
 
            filler = new QueueLinearFloodFiller(filler);
            filler.FillColor = pen.color;
            filler.Tolerance = new ColorS(0, 0, 0);
            filler.Bitmap = bf;
            //Next we need to find a point inside the polygon from where to start the flood fill.
            //We use the center points x-line till we find a point inside.
            Point p = new Point(r.X + (r.Width / 2), r.Y + (r.Height / 2));
            Point? pp = null;
            polygon = pfs;
            for (int x = r.X; x < r.Width + r.X; x++)
            {
                if (PointInPolygon(x, (int)p.Y))
                {
                    pp = new Point(x, p.Y);
                    break;
                }
            }
            filler.FloodFill(pp.Value);
            //Now that we have a filled shape we draw it onto the original bitmap
            for (int x = 0; x < bf.SizeX; x++)
            {
                for (int y = 0; y < bf.SizeY; y++)
                {
                    if (bf.GetPixel(x, y) == pen.color)
                    {
                        buf.SetPixel(x, y, pen.color);
                    }
                }
            }
            bf.Dispose();
        }

FillPolygon() [2/4]

void BioImager.Graphics.Graphics.FillPolygon	(	PointF[]	pfs,
		Rectangle	r,
		ColorS	c
	)

Definition at line 261 of file Graphics.cs.

        {
            pen.color = c;
            FillPolygon(pfs, r);
        }

FillPolygon() [3/4]

void BioImager.Graphics.Graphics.FillPolygon	(	PointF[]	pfs,
		RectangleF	r
	)

Definition at line 248 of file Graphics.cs.

        {
            FillPolygon(pfs, new Rectangle((int)r.X, (int)r.Y, (int)r.Width, (int)r.Height));
        }

FillPolygon() [4/4]

void BioImager.Graphics.Graphics.FillPolygon	(	PointF[]	pfs,
		RectangleF	r,
		ColorS	c
	)

Definition at line 266 of file Graphics.cs.

        {
            pen.color = c;
            FillPolygon(pfs, r);
        }

FillRectangle() [1/2]

void BioImager.Graphics.Graphics.FillRectangle	(	Rectangle	r,
		ColorS	col
	)

Definition at line 120 of file Graphics.cs.

        {
            for (int x = r.X; x < r.Width + r.X; x++)
            {
                for (int y = r.Y; y < r.Height + r.Y; y++)
                {
                    buf.SetPixel(x, y, col);
                }
            }
        }

FillRectangle() [2/2]

void BioImager.Graphics.Graphics.FillRectangle	(	RectangleF	r,
		ColorS	col
	)

Definition at line 130 of file Graphics.cs.

        {
            FillRectangle(new Rectangle((int)Math.Ceiling(r.X), (int)Math.Ceiling(r.Y), (int)Math.Ceiling(r.Width), (int)Math.Ceiling(r.Height)), col);
        }

FromImage()

static Graphics BioImager.Graphics.Graphics.FromImage ( Bitmap  b )

static

Definition at line 37 of file Graphics.cs.

        {
            Graphics g = new Graphics();
            g.buf = b;
            g.pen = new Pen(new ColorS(ushort.MaxValue, ushort.MaxValue, ushort.MaxValue), 1, b.BitsPerPixel);
            return g;
        }

PointInPolygon()

bool BioImager.Graphics.Graphics.PointInPolygon	(	int	x,
		int	y
	)

Definition at line 253 of file Graphics.cs.

        {
            int j = polygon.Length - 1;
            bool c = false;
            for (int i = 0; i < polygon.Length; j = i++) c ^= polygon[i].Y > y ^ polygon[j].Y > y && x < (polygon[j].X - polygon[i].X) * (y - polygon[i].Y) / (polygon[j].Y - polygon[i].Y) + polygon[i].X;
            return c;
        }

Member Data Documentation

buf

Bitmap BioImager.Graphics.Graphics.buf

Definition at line 34 of file Graphics.cs.

pen

Pen BioImager.Graphics.Graphics.pen

Definition at line 35 of file Graphics.cs.

---

The documentation for this class was generated from the following file:

• F:/repos/BioImager/BioImager/Graphics/Graphics.cs