绘制直线和直线剪切

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
namespace XnaGeometric
{
public class CLine : IGeometric
{
enum PtDirection
{
//None = 0,
N = 1,//North
E = 2,//East
S = 4,//South
W = 8,//West
NE = N | E,//NorthEast
SE = S | E,//SouthEast
SW = S | W,//SouthWest
NW = N | W,//NorthWest
C = 0,//Center
}

private Color m_color = Color.Green;
private CPoint m_P0;//起始点
private CPoint m_P1;//结束点

public Color Color
{
get { return this.m_color; }
set { this.m_color = value; }
}

public CPoint P0
{
get { return this.m_P0; }
set { this.m_P0 = value; }
}

public CPoint P1
{
get { return this.m_P1; }
set { this.m_P1 = value; }
}

public CLine(CPoint P0, CPoint P1)
{

this.m_P0 = P0;
this.m_P1 = P1;
}

/// <summary>
/// 通过此直线方程计算x坐标
/// //x = (y - y0)*(x1 - x0)/(y1 - y0) + x0
/// </summary>
private void ComputeX(ref float x, float y,
float dx, float dy,
float x0, float y0)
{
x = (y - y0) * dx / dy + x0;
//x = (int)(x + ((float)Math.Sign(x)) * 0.5f);
}
/// <summary>
/// y = (x - x0)*(y1 - y0)/(x1 - x0) + y0
/// </summary>
private void ComputeY(float x, ref float y,
float dx, float dy,
float x0, float y0)
{
y = (x - x0) * dy / dx + y0;
//y = (int)(y + ((float)Math.Sign(y)) * 0.5f);
}

private int Round(float value)
{
return (int)(value + ((float)Math.Sign(value)) * 0.5f);
}

private bool IsAtLR(Rectangle rect, float x) { return x >= rect.Left && x <= rect.Right; }
private bool IsAtTB(Rectangle rect, float y) { return y >= rect.Top && y <= rect.Bottom; }

private bool IsSameDir(PtDirection src, PtDirection dest)
{
return ((PtDirection)(src & dest) == dest);
}

private bool Clip(ref CPoint ptCliped,
PtDirection ptDir,
Rectangle rect,
float x0, float y0,
float x1, float y1,
float dx, float dy)
{
float clipX = ptCliped.X, clipY = ptCliped.Y;
if (IsSameDir(ptDir, PtDirection.N))
{
clipY = rect.Top;
this.ComputeX(ref clipX, clipY, dx, dy, x0, y0);
//NE
if (clipX > rect.Right)
{
clipX = rect.Right;
this.ComputeY(clipX, ref clipY, dx, dy, x0, y0);
if (!IsAtTB(rect, clipY)) return false;
}//NW
else if (clipX < rect.Left)
{
clipX = rect.Left;
this.ComputeY(clipX, ref clipY, dx, dy, x0, y0);
if (!IsAtTB(rect, clipY)) return false;
}
//else { //true}
}
else if (IsSameDir(ptDir, PtDirection.E))
{
clipX = rect.Right;
ComputeY(clipX, ref clipY, dx, dy, x0, y0);
if (clipY < rect.Top)
{
clipY = rect.Y;
this.ComputeX(ref  clipX, clipY, dx, dy, x0, y0);
if (!IsAtLR(rect, clipX)) return false;
}
else if (clipY > rect.Bottom)
{
clipY = rect.Bottom;
this.ComputeX(ref  clipX, clipY, dx, dy, x0, y0);
if (!IsAtLR(rect, clipX)) return false;
}
}
else if (IsSameDir(ptDir, PtDirection.S))
{
clipY = rect.Bottom;
this.ComputeX(ref clipX, clipY, dx, dy, x0, y0);
//NE
if (clipX > rect.Right)
{
clipX = rect.Right;
this.ComputeY(clipX, ref clipY, dx, dy, x0, y0);
if (!IsAtTB(rect, clipY)) return false;
}//NW
else if (clipX < rect.Left)
{
clipX = rect.Left;
this.ComputeY(clipX, ref clipY, dx, dy, x0, y0);
if (!IsAtTB(rect, clipY)) return false;
}
}
else if (IsSameDir(ptDir, PtDirection.W))
{
clipX = rect.Left;
ComputeY(clipX, ref clipY, dx, dy, x0, y0);
if (clipY < rect.Top)
{
clipY = rect.Y;
this.ComputeX(ref  clipX, clipY, dx, dy, x0, y0);
if (!IsAtLR(rect, clipX)) return false;
}
else if (clipY > rect.Bottom)
{
clipY = rect.Bottom;
this.ComputeX(ref  clipX, clipY, dx, dy, x0, y0);
if (!IsAtLR(rect, clipX)) return false;
}
}
ptCliped.X = this.Round(clipX);
ptCliped.Y = this.Round(clipY);
return true;
}

private bool ClipLine(ref CPoint newP0, ref CPoint newP1, Rectangle rect)
{
Point tmpP0 = new Point(newP0.X, newP0.Y);
Point tmpP1 = new Point(newP1.X, newP1.Y);
//两个点在绘制区域里面
bool bContainP0 = rect.Contains(tmpP0);
bool bContainP1 = rect.Contains(tmpP1);
if (bContainP0 && bContainP1)
{
return true;
}
#region Relate
//       *                       *
//  NW   *          N            *  NE
//       *                       *
//***************************************
//       *                       *
//       *                       *
//       *                       *
//   W   *         C             *   E
//       *                       *
//       *                       *
//       *                       *
//***************************************
//       *                       *
//  SW   *          S            *   SE
//       *                       *
#endregion
//获取P0, P1的所在的方位
PtDirection dir0 = PtDirection.C;
PtDirection dir1 = PtDirection.C;
this.GetPtDir(rect, ref dir0, tmpP0);
this.GetPtDir(rect, ref dir1, tmpP1);
float x0 = tmpP0.X, y0 = tmpP0.Y;
float x1 = tmpP1.X, y1 = tmpP1.Y;
float dx = x1 - x0;
float dy = y1 - y0;
bool bP0Clip = Clip(ref newP0, dir0, rect, x0, y0, x1, y1, dx, dy);
bool bP1Clip = Clip(ref newP1, dir1, rect, x0, y0, x1, y1, dx, dy);
return (bP0Clip && bP1Clip);
}
/// <summary>
/// 获取线的形状
/// </summary>
/// <param name="buffer">绘线的缓冲区</param>
/// <param name="rectSrc">源区域（一般是剪切区域）</param>
/// <param name="rectDest">目标区域（一般是屏幕缓冲区域）</param>
public void Get(ref Color[] buffer, Rectangle rectSrc, Rectangle rectDest)
{
CPoint newP0 = P0.Copy();
CPoint newP1 = P1.Copy();
Rectangle rectCliped = AdjustClipRect(rectSrc, rectDest);
if (!ClipLine(ref newP0, ref newP1, rectCliped)) return;
this.GetLine(newP0, newP1, ref buffer, rectDest.Width);
}

/// <summary>
/// 调整剪切区域
/// </summary>
/// <param name="rectSrc">源区域(即剪切区域)</param>
/// <param name="rectDest">目标区域（例如屏幕）</param>
/// <returns>返回调整后的剪切区域</returns>
private Rectangle AdjustClipRect(Rectangle rectSrc, Rectangle rectDest)
{
Rectangle rectCliped = rectSrc;
if (rectCliped.Left < rectDest.Left)
{
rectCliped.X = rectDest.Left;
}
if (rectCliped.Right > rectDest.Right)
{
rectCliped.Width = rectCliped.Right - rectDest.Right + 1;
}
if (rectCliped.Top < rectDest.Top)
{
rectCliped.Y = rectDest.Top;
}
if (rectCliped.Bottom > rectDest.Bottom)
{
rectCliped.Height = rectCliped.Bottom - rectDest.Bottom;
}
return rectCliped;
}

private void GetPtDir(Rectangle rect, ref PtDirection ptDir, Point pt)
{
if (rect.Contains(pt))
{
ptDir = PtDirection.C;
return;
}
else
{
if (pt.Y < rect.Top) { ptDir |= PtDirection.N; }
else if (pt.Y > rect.Bottom) { ptDir |= PtDirection.S;}

if (pt.X < rect.Left) { ptDir |= PtDirection.W; }
else if (pt.X > rect.Right) { ptDir |= PtDirection.E; }
}
}

/// <summary>
/// 没有剪切的版本
/// </summary>
private void GetLine(CPoint P0, CPoint P1,
ref Color[] buffer, int scrWidth)
{
CPoint ptExtra = P1 - P0;
int dx = ptExtra.X, dy = ptExtra.Y;
int yStep = 1, xStep = 1;
if (dx < 0) { dx = -dx; xStep = -1; }
if (dy < 0) { dy = -dy; yStep = -1; }
int dx2 = dx << 1;
int dy2 = dy << 1;

//int yStart = P0.Y, yEnd = P1.Y,
//    xStart = P0.X, xEnd = P1.X;
int xi = 0, yi = 0;
int x = P0.X, y = P0.Y;
//int ix = xStart, iy = yStart;

int index = 0;

if (dx >= dy)
{//0 <= 斜率的绝对值 < 1,以x为增量
int error = -dx;
//if (dy > 0) { yStep = 1; }
//else { yStep = -1; }
//yStep = dy > 0 ? 1 : -1;
for (xi = 0; xi <= dx; xi++)
{
index = x + y * scrWidth;
buffer[index] = this.Color;
error += dy2;
if (error >= 0)
{
y += yStep;
error -= dx2;
}
x += xStep;
}
}
else
{//斜率的绝对值 >= 1,以y为增量
int error = -dy;
for (yi = 0; yi <= dy; yi++)
{
index = x + y * scrWidth;
buffer[index] = this.Color;
error += dx2;
if (error >= 0)
{
x += xStep;
error -= dy2;
}
y += yStep;
}
}
}
}
}