Bio.Graphics.Graphics Class Reference

Inheritance diagram for Bio.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 ()
	The Dispose() function is used to release the resources used by the object.

Static Public Member Functions
static Graphics	FromImage (Bitmap b)

Public Attributes
Bitmap	buf
Pen	pen

Detailed Description

Definition at line 37 of file Graphics.cs.

Member Function Documentation

Dispose()

void Bio.Graphics.Graphics.Dispose

(

)

The Dispose() function is used to release the resources used by the object.

Definition at line 396 of file Graphics.cs.

        {
            pen.Dispose();
        }

DrawEllipse() [1/2]

void Bio.Graphics.Graphics.DrawEllipse

(

Rectangle

r

)

For every angle from 0 to 360, draw a point at the angle's cosine and sine, multiplied by the radius, plus the radius, plus the center point

Parameters

Rectangle

The rectangle that the ellipse will be drawn in.

Definition at line 203 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 Bio.Graphics.Graphics.DrawEllipse

(

RectangleF

r

)

If you pass a RectangleF to DrawEllipse, it will convert it to a Rectangle and then call DrawEllipse(Rectangle)

Parameters

RectangleF

A rectangle with floating point coordinates.

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

‍Draw a line from (x,y) to (x2,y2) by drawing a series of ellipses with the same width and height as the pen width

Parameters

x	The x coordinate of the first point.
y	The y coordinate of the first point.
x2	The x coordinate of the end point of the line.
y2	The y coordinate of the second point.

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

DrawLine(PointF p, PointF p2) is a function that takes two points and draws a line between them

Parameters

PointF	A structure that defines a point in a two-dimensional plane.
PointF	A structure that defines a point in a two-dimensional plane.

Definition at line 150 of file Graphics.cs.

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

DrawRectangle() [1/2]

void Bio.Graphics.Graphics.DrawRectangle

(

Rectangle

r

)

For each pixel in the rectangle, draw a line of pixels of the same color

Parameters

Rectangle

The rectangle to draw

Definition at line 179 of file Graphics.cs.

        {
            DrawLine(new PointF(r.X, r.Y), new PointF(r.X + r.Width, r.Y));
            DrawLine(new PointF(r.X + r.Width, r.Y), new PointF(r.X + r.Width, r.Y + r.Height));
            DrawLine(new PointF(r.X, r.Y), new PointF(r.X, r.Y + r.Height));
            DrawLine(new PointF(r.X, r.Y + r.Height), new PointF(r.X + r.Width, r.Y + r.Height));
        }

DrawRectangle() [2/2]

void Bio.Graphics.Graphics.DrawRectangle

(

RectangleF

r

)

"Draw a rectangle with the top left corner at (x,y) and the bottom right corner at (x+width,y+height)."

The function is called with a RectangleF object, which is a rectangle with floating point coordinates. The function converts the floating point coordinates to integers and then calls the DrawRectangle function that takes integer coordinates

Parameters

RectangleF

A rectangle with float coordinates.

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

DrawScanline(int x, int x2, int line, ColorS col)

This function draws a scanline from x to x2 on the y line

Parameters

x	The starting x position of the scanline
x2	The end of the scanline
line	The line to draw the scanline on
ColorS	A struct that contains the RGB values of a color.

Definition at line 388 of file Graphics.cs.

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

FillEllipse() [1/3]

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

It draws an ellipse by drawing a bunch of horizontal lines

Parameters

xx	x position of the ellipse
yy	y position of the ellipse
w	width of the ellipse
h	height of the ellipse
ColorS	A struct that contains the color information.

Returns

the color of the pixel at the specified coordinates.

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

‍Draws a filled ellipse with the specified color

Parameters

Rectangle	The rectangle to draw the ellipse in.
ColorS	A struct that contains the color information.

Definition at line 270 of file Graphics.cs.

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

FillEllipse() [3/3]

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

‍This function takes a rectangle and a color and draws an ellipse inside the rectangle

Parameters

RectangleF	A rectangle with float values
ColorS	A struct that contains a byte for each color channel (R, G, B, A)

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

We draw the polygon onto a new bitmap, then we find a point inside the polygon and flood fill it, then we draw the flood filled bitmap onto the original bitmap

Parameters

pfs	The points of the polygon
Rectangle	The rectangle that contains the polygon.

Definition at line 279 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 Bio.Graphics.Graphics.FillPolygon	(	PointF[]	pfs,
		Rectangle	r,
		ColorS	c )

‍This function takes an array of points, a rectangle, and a color, and fills the polygon with the color

Parameters

pfs	An array of points that make up the polygon
Rectangle	The rectangle that the polygon is in.
ColorS	A struct that contains a color.

Definition at line 350 of file Graphics.cs.

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

FillPolygon() [3/4]

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

‍This function takes a list of points and a rectangle and fills the polygon defined by the points with the rectangle

Parameters

pfs	An array of PointF structures that represent the vertices of the polygon to fill.
RectangleF	A rectangle with float coordinates.

Definition at line 324 of file Graphics.cs.

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

FillPolygon() [4/4]

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

‍This function takes an array of points, a rectangle, and a color, and fills the polygon with the color

Parameters

pfs	An array of points that make up the polygon
RectangleF	The rectangle that the polygon is in.
ColorS	A struct that contains a color.

Definition at line 361 of file Graphics.cs.

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

FillRectangle() [1/2]

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

For every pixel in the rectangle, set the pixel to the color

Parameters

Rectangle	The rectangle to fill
ColorS	A struct that contains the RGB values of a color.

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

‍This function takes a rectangle and a color and fills the rectangle with the color

Parameters

RectangleF	A rectangle with float values
ColorS	A struct that contains a byte for each color channel (R, G, B, A)

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

static

It creates a new Graphics object, sets the buffer to the bitmap passed in, and sets the pen to a white pen with a width of 1 and a color depth of the bitmap's color depth

Parameters

Bitmap

The bitmap to draw on

Returns

A new Graphics object.

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

If the point is on the left side of the line, then the point is inside the polygon

Parameters

x	The x coordinate of the point to test.
y	The y coordinate of the point to test.

Returns

A boolean value.

Definition at line 336 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 Bio.Graphics.Graphics.buf

Definition at line 40 of file Graphics.cs.

pen

Pen Bio.Graphics.Graphics.pen

Definition at line 42 of file Graphics.cs.

---

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

• BioLib/Graphics/Graphics.cs