BioCore.Graphics Class Reference

Inheritance diagram for BioCore.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 26 of file Graphics.cs.

Member Function Documentation

Dispose()

void BioCore.Graphics.Dispose

(

)

Definition at line 280 of file Graphics.cs.

        {
            pen.Dispose();
        }

DrawEllipse() [1/2]

void BioCore.Graphics.DrawEllipse

(

Rectangle

r

)

Definition at line 152 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 BioCore.Graphics.DrawEllipse

(

RectangleF

r

)

Definition at line 170 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 BioCore.Graphics.DrawLine	(	int	x,
		int	y,
		int	x2,
		int	y2 )

Definition at line 38 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 BioCore.Graphics.DrawLine	(	PointF	p,
		PointF	p2 )

Definition at line 110 of file Graphics.cs.

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

DrawRectangle() [1/2]

void BioCore.Graphics.DrawRectangle

(

Rectangle

r

)

Definition at line 128 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 BioCore.Graphics.DrawRectangle

(

RectangleF

r

)

Definition at line 147 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 BioCore.Graphics.DrawScanline	(	int	x,
		int	x2,
		int	line,
		ColorS	col )

Definition at line 273 of file Graphics.cs.

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

FillEllipse() [1/3]

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

Definition at line 174 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 BioCore.Graphics.FillEllipse	(	Rectangle	r,
		ColorS	c )

Definition at line 198 of file Graphics.cs.

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

FillEllipse() [3/3]

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

Definition at line 194 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 BioCore.Graphics.FillPolygon	(	PointF[]	pfs,
		Rectangle	r )

Definition at line 202 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.
            System.Drawing.Point p = new System.Drawing.Point(r.X + (r.Width / 2), r.Y + (r.Height / 2));
            System.Drawing.Point? pp = null;
            polygon = pfs;
            for (int x = r.X; x < r.Width + r.X; x++)
            {
                if (PointInPolygon(x, (int)p.Y))
                {
                    pp = new System.Drawing.Point(x, p.Y);
                    break;
                }
            }
            filler.FloodFill(new AForge.Point(pp.Value.X,pp.Value.Y));
            //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 BioCore.Graphics.FillPolygon	(	PointF[]	pfs,
		Rectangle	r,
		ColorS	c )

Definition at line 255 of file Graphics.cs.

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

FillPolygon() [3/4]

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

Definition at line 242 of file Graphics.cs.

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

FillPolygon() [4/4]

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

Definition at line 260 of file Graphics.cs.

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

FillRectangle() [1/2]

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

Definition at line 114 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 BioCore.Graphics.FillRectangle	(	RectangleF	r,
		ColorS	col )

Definition at line 124 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 BioCore.Graphics.FromImage ( Bitmap b )

static

Definition at line 31 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 BioCore.Graphics.PointInPolygon	(	int	x,
		int	y )

Definition at line 247 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 BioCore.Graphics.buf

Definition at line 28 of file Graphics.cs.

pen

Pen BioCore.Graphics.pen

Definition at line 29 of file Graphics.cs.

---

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

• BioCore/BioCore/Graphics/Graphics.cs