再分享一个自己写的向量和二维坐标变换的类

使用方法如下：

Matrix2D matrix2D = new Matrix2D(m_CADCooridate, m_OtherCooridateInfo.CADCooridate, m_SDRQCooridate, m_OtherCooridateInfo.SDRQCooridate);

gpdPt = matrix2D.GetNewPt(cadPt);

可以用于CAD坐标与实际平面坐标的转换

/**以下是源码

* @author xuhaiyan

* @copyright opensource

* @date 2012-12-26

* @version 4.0

* @description

* @dependence .net 2.0

*/

using System;

using System.Collections.Generic;

using System.Text;

namespace Common.Algorithm

{

public class Vector

{

public static readonly double ZERO = 1e-6;

private double m_Length;

private double m_Angle;

private Point2D m_StartPt=new Point2D(0,0);

private Point2D m_EndPt =null;

public double Length

{

get { return m_Length; }

set

{

checkLength(value);

m_Length = value;

calculateEndPt();

}

}

public double Angle

{

get { return m_Angle; }

set

{

checkAngle(value);

m_Angle = value;

calculateEndPt();

}

}

public Point2D StartPt

{

get { return m_StartPt; }

set {

checkPoint2D(value);

m_StartPt = value;

calculateEndPt();

}

}

public Point2D EndPt

{

get { return m_EndPt; }

}

public Vector()

{

}

public Vector(double length,double angle)

{

checkAngle(angle);

checkLength(length);

m_Angle = angle;

m_Length = length;

m_StartPt = new Point2D(0, 0);

calculateEndPt();

}

public Vector(double length, double angle,Point2D startPt)

{

checkAngle(angle);

checkLength(length);

checkPoint2D(startPt);

m_Angle = angle;

m_Length = length;

m_StartPt = startPt;

calculateEndPt();

}

public Vector( Point2D startPt,Point2D endPt)

{

checkPoint2D(startPt);

checkPoint2D(endPt);



m_StartPt = startPt;

m_EndPt = endPt;

calculateParameter();

}

private void checkPoint2D(Point2D pt)

{

if (pt == null )

{

throw new Exception("point invalid!");

}

}

private void checkLength(double length)

{

if (length <= 0)

{

throw new Exception("length must lager than 0!");

}

}

private void checkAngle(double angle)

{

if (angle < 0 || angle >= 2 * Math.PI)

{

throw new Exception("angle must be between [0 , 2π)!");

}

}

private void calculateEndPt()

{

if (m_StartPt!= null)

{

double deltaX = m_Length * Math.Sin(m_Angle);

double deltaY = m_Length * Math.Cos(m_Angle);

m_EndPt = new Point2D(m_StartPt.X + deltaX, m_StartPt.Y + deltaY);

}

}

private void calculateParameter()

{

if (m_StartPt != null && m_EndPt != null)

{

m_Length = Math.Sqrt(

Math.Pow((m_EndPt.X - m_StartPt.X), 2)

+ Math.Pow((m_EndPt.Y - m_StartPt.Y), 2));

double deltaX = m_EndPt.X - m_StartPt.X;

double deltaY = m_EndPt.Y - m_StartPt.Y;

if (deltaY > -ZERO && deltaY < ZERO) //same y

{

if (deltaX > 0)

{

m_Angle = 0.5 * Math.PI;

}

else

{

m_Angle = 1.5 * Math.PI;

}

}else

{

m_Angle = Math.Atan(deltaX / deltaY);

if (deltaX> 0 && deltaY <0) //2

{

m_Angle += Math.PI;

}

else if (deltaX < 0 && deltaY < 0) //3

{

m_Angle += Math.PI;

}

else if (deltaX < 0 && deltaY > 0) //4

{

m_Angle += 2 * Math.PI;

}

}

}

}

}

public class Matrix2D

{

private Point2D m_OldPt1;

private Point2D m_OldPt2;

private Point2D m_NewPt1;

private Point2D m_NewPt2;

private Vector m_OldVector = null;

private Vector m_NewVector = null;

private double m_Angle;

private double m_Scale;

private double m_TranslationX;

private double m_TranslationY;

public double Scale

{

get { return m_Scale; }

}

public double Angle

{

get { return m_Angle; }

}

public Matrix2D()

{

}

public Matrix2D(Point2D oldPt1, Point2D oldPt2, Point2D newPt1, Point2D newPt2)

{

m_OldPt1 = oldPt1;

m_OldPt2 = oldPt2;

m_NewPt1 = newPt1;

m_NewPt2 = newPt2;

m_OldVector = new Vector(oldPt1, oldPt2);

m_NewVector = new Vector(newPt1, newPt2);

m_Angle = m_NewVector.Angle - m_OldVector.Angle;

if ( m_Angle<0)

{

m_Angle += 2 * Math.PI;

}

m_Scale = m_NewVector.Length / m_OldVector.Length;

m_TranslationX = m_NewPt1.X - m_OldPt1.X;

m_TranslationY = m_NewPt1.Y - m_OldPt1.Y;

}

public Point2D GetNewPt(Point2D oldPt)

{

checkVector();



Vector oldV= new Vector(m_OldPt1, oldPt);

double newAngle = oldV.Angle + m_Angle;

if (newAngle >= 2*Math.PI) //only maybe lager than 2PI

{

newAngle -= 2 * Math.PI;

}

oldV.Angle = newAngle;

oldV.Length *= m_Scale;

oldV.StartPt = m_NewPt1;

Point2D pt = oldV.EndPt;

return pt;

}

public Point2D GetOldPt(Point2D newPt)

{

checkVector();

Vector newV = new Vector(m_NewPt1, newPt);

double angle = newV.Angle - m_Angle;

if (angle <0)

{

angle += 2 * Math.PI;

}

newV.Length /= m_Scale;

newV.StartPt = m_OldPt1;

Point2D pt = newV.EndPt;

return pt;

}

public void checkVector()

{

if (m_OldVector == null||m_NewVector == null)

{

throw new Exception("calculate Vector first!");

}

}

}

}