再分享一个自己写的向量和二维坐标变换的类
使用方法如下：
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!");
}
}
}
}