本章实际操作使用ps来进行切图,分成四部分来讲解：
1.切图的常规步骤
2.如何只保留某一部分
3.删除切片
4去掉默认切片线




切图的常规步骤
我现在有一张登录框的psd，拿到psd后首先要思考怎么构图。也就是切图的思路。我这里只是演示步骤，所以就不详细推理了。






在工具栏中选择切片工具




然后用切片工具画出三个部分，如果觉得切片工具不好画的话 可以右键切片 编辑切片 直接输入参数。




点击文件----》存储为web和设备所用格式




这里可以调节一些参数和图片格式，或者直接点击存储并选择保存路径即可。






存储后到保存的路径看到我们的3个切片已经有了








如何只保留某一部分
我们上面已经了解了正常的流程，不过有时候我们需要某一部分的图片，不能一次性全部切好。比如我们需要蓝色按钮单独作一张图片。那怎么单独切出这个按钮呢。
步骤如下:
选择切片工具，画出按钮。




文件--》存储为web和设备所用格式，关键是在调节页面的时候 需要点击选中按钮部分。然后点存储。




选择好路径后 选择 只输出 选中切片 也就是只输出 按钮。




结果文件夹中就只输出了按钮图






ps:这里只是演示步骤,正规流程中 按钮这些单独的图层 最好使用 图层切片，这样得到的图才是最完整无混合边界的图。
步骤是 在右侧图层面板中选中图层 ----》选取图层---》新建基于图层的切片






删除切片
在画切片的时候 经常有画错的时候， 除了后退之外我们还可以删除切片。
对着切片直接右键可以看到 删除切片。 
仅仅是用户切片才能 使用 删除切片。
非用户切片的删除切片是灰色的。只能先右键点击提升为用户切片之后才能删除。
所谓的用户切片就是 我们画的切片，非用户切片是我们画了一部分之后 系统补充的另一部分。










去掉默认切片线
前面我们讲到删除切片 只能删除用户切片  那么系统默认的切片 和 切片线应该怎么去掉 删除呢。
视图-----》清除切片即可。

之前看到多利用苹果开发的OpenGL接口实现的帧动画，原理是利用 Edward Patel 封装 EPGLTransitionView，绘制百叶窗的不同时间帧，实现动画效果。
考虑过将其移植到自己的代码中，但因为对OpenGL完全不懂，不能很好的切合到自己的代码里，放弃了。


后来，想到一个方法，将UIView截屏成图片，然后将图片等份切割成6份（我的代码里是6份），然后用6个UIImageView容纳这些切割后的UIImage图片,每个UIImageView代表一个扇叶，每个扇叶均沿着自己的Y轴旋转90度，这样模拟百叶窗的动画就完成了。


具体实现上有几个需要注意的地方
1、旋转要是绕着左边轴，右边轴，还是中轴旋转；如果是两边轴，那么在做仿射矩阵变化时需要做些处理。
2、6个UIImageView的动画启动有时间差。这个问题，我才用动画关键帧的方法处理（animateKeyframesWithDuration ，addKeyframeWithRelativeStartTime）
3、切割图片，要注意UIImge.scale属性


因为主要变换都是仿射矩阵变化，所以其他平台、其他语言也应该可以用相同的方式处理



具体实现代码如下：


截屏代码
UIImage* screenShotForView(UIView* view)
{
    //[UIScreen mainScreen].scale,保持截屏的图片精度
    UIGraphicsBeginImageContextWithOptions(view.bounds.size, YES, [UIScreen mainScreen].scale);
    [view.layer renderInContext:UIGraphicsGetCurrentContext()];
    UIImage *img = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return img;
}

切割图片代码
UIImage* UIImage_getSubImage(UIImage * srcImg , CGRect subRect)
{
    CGImageRef subImageRef = CGImageCreateWithImageInRect(srcImg.CGImage, subRect);
    UIImage *subImg = [UIImage imageWithCGImage:subImageRef];
    CGImageRelease(subImageRef);
    return subImg;
}




围绕XY平面任意点旋转的代码

CATransform3D CATransform3DMakeRotateAroundPoint(UIView *view ,CGPoint point ,CGFloat radian ,CGFloat x ,CGFloat y, CGFloat z)
{//point 是view坐标系的点
    //矩阵变换是相对与layer.anchorPoint为原点的坐标系进行的
    //计算x ,y 在layer.anchorPoint为原点的坐标系下的坐标
    const CGPoint anchor = view.layer.anchorPoint;
    point.x -= view.bounds.size.width * anchor.x;
    point.y -= view.bounds.size.height * anchor.y;
    //矩阵变换
    CATransform3D rotate = CATransform3DMakeTranslation( point.x , point.y , 0);
    rotate = CATransform3DRotate(rotate, radian, x, y, z);
    rotate = CATransform3DTranslate(rotate, -point.x , -point.y , 0);
    return rotate;
}

动画代码
(void)blindForView:(UIView *blindView)
{
    NSMutableArray * imgVlist = [NSMutableArray array];
    {
        const int blindCount = 6;//扇叶数量
        
        CGFloat oneViweWidth = blindView.bounds.size.width / blindCount;
        CGRect viewBounds = blindView.bounds;
        
        UIImage * viewShot = screenShotForView(blindView);
        CGFloat oneImgWidth = viewShot.size.width * viewShot.scale / blindCount;
        CGRect imgBounds = (CGRect){0,0,viewShot.size.width * viewShot.scale ,viewShot.size.height * viewShot.scale };
        //切割图片，并创建UIImageView
        for (int i =0 ; i< blindCount ; i++)
        {
            UIImageView * imgV = [[UIImageView alloc] initWithFrame: LeftRect(viewBounds, oneViweWidth, oneViweWidth * i)];
            imgV.contentMode = UIViewContentModeScaleToFill;
            imgV.image = UIImage_getSubImage(viewShot, LeftRect(imgBounds, oneImgWidth, oneImgWidth * i));
            [blindView.superView addSubview:imgV];
            [imgVlist addObject:imgV];
            [imgV release];
        }
    }
    blindView.hidden = YES;
    [UIView animateKeyframesWithDuration:2 delay:0 options:UIViewKeyframeAnimationOptionCalculationModeLinear animations:^{
        
        for (int i = 0 ; i < imgVlist.count ;i++)
        {
            UIView *view  = imgVlist[i];
            [UIView addKeyframeWithRelativeStartTime:0.1 *i relativeDuration:2-(0.1 *i) animations:^{
                
                CGPoint point = {view.bounds.size.width/2 ,view.bounds.size.height/2};
                CATransform3D rotate = CATransform3DMakeRotateAroundPoint(view, point, M_PI /2, 0, 1, 0);
                view.layer.transform = rotate;
            }];
        }
    } completion:^(BOOL finished) {
        
        for (UIView *view in imgVlist)
        {
            [view removeFromSuperview];
        }
    }];
}

百度API提供了在地图上画圆形的类，但画出圆只能是实心圆，也就是不能实现让圆内没有颜色而圆外有颜色的镂空圆。那么我们应该实现镂空圆呢？
首先我发现API还提供一个画多边形的类。而一个镂空圆分解成两个多边形，即横着一刀切在这个镂空圆上，上下两部分各为一个多边形。于是我试着用这种方法画了一个镂空圆，代码详见：百度api中实现 内嵌圆
但实现上述镂空圆时我的思路还是讲经纬度看出笛卡尔坐标系上的x,y，然而经纬度在并不是均匀分布的，这也导致了用上述方法画出的圆一旦离开了赤道就会变成椭圆。
这个问题很棘手，首先我们分析问题，圆的失真是由于经纬度分布不均匀导致的，所以我们不能用笛卡尔坐标系来思考问题，而应该将经纬度转换成球坐标系。维度的范围是大于-90度而小于90度，而球坐标系中的φ的范围是0到180，同理，经度的范围是-180，180，而θ的范围是0,360。很容易找到他们的关系，即φ
 = 90-维度，
θ
 = 180-经度；转换公式：（维度，经度） = （φ，θ，R）其中R
 = 地球半径；

但是得到球坐标系坐标之后分析问题还是十分困难，我们应该将问题转换成我们熟悉的，即将球坐标系转换吃笛卡尔坐标系：
公式如下：
r
 = √(x²+y²+z²)
θ = arccos[z/√(x²+y²+z²)]
φ = arctan(y/x)
代码实现：
static V3 changeToXyz(LatLng lng){
		 V3 v = new V3();
		if (lng.latitude<0){
			v.var1 = 90 + Math.abs(lng.latitude);
		}else {
			v.var1 = 90 - lng.latitude ;
		 }
		 if(lng.longitude<0){
			 v.var2 = 180 + Math.abs(lng.longitude);
		 }else {
			 v.var2 = 180 - lng.longitude;
		 }
		 v.var3 = R;
		 V3 temp = new V3();
		 temp.var1 = v.var3*Math.sin(Math.PI*v.var1/180)*Math.cos(Math.PI*v.var2/180);
		 temp.var2 = v.var3*Math.sin(Math.PI*v.var1/180)*Math.sin(Math.PI*v.var2/180);
		 temp.var3 = v.var3*Math.cos(Math.PI*v.var1/180);
		 return temp;
	}
V3类是我实现vector3的类（即3维向量）
代码如下：
static class V3 {
		double var1 = 0.0;
		double var2 = 0.0;
		double var3 = 0.0;
		V3(){

		}
		V3(Double var1,Double var2, Double var3){
			this.var1 = var1;
			this.var2 = var2;
			this.var3 = var3;
		}
		public static V3 add(V3 v1, V3 v2){
			return new V3(v1.var1+v2.var1,v1.var2+v2.var2,v1.var3+v2.var3);
		}


	}
得到笛卡尔坐标系之后我们终于可以分析问题了，在地图上画圆实际上就是在球体上画圆，我们可以令vector1为地图上的球心（0,0,0）到圆心center的向量，我们在vector1上任意取一点half，过这点垂直于vector1的平面与球面相交的部分我们要求的圆形，而这个圆形正是以half为圆心的圆形，我们设这个圆形的半径是r。通过r我们能求出half的坐标。
Double rate =  Math.sqrt(R*R-r*r)/R;
V3 half = new V3(rate*center.var1,rate*center.var2,rate*center.var3);
我们知道这个圆任意一条半径都是和vector1垂直的，即我们只要知道任意一条半径所在的向量的表达式遍可以通过旋转角θ1求出所有半径所在的向量的表达式。为了方便我们选择一条在x，y平面上的向量作为这个起始向量vector2（这样的目的是为了让起始映射到经纬度坐标系之后与精度轴平行）.
公式：
（x,y,z）
 = (1,-center.x/center.y,0)
然后我们让这条向量绕着center旋转，向量旋转公式：




 
ax,ay,az为center的x,y,z，I是单位矩阵，θ 是旋转角度，P是需要选择的向量即vector2；（注意这里必须将center的变成膜为1的单位向量）
代码如下
public static V3 getTemp(V3 center,Double ang){
		center = getmR(center,1.0);
		Double x = center.var1;
		Double y = center.var2;
		Double z = center.var3;
		Matrix a = new Matrix(3,3);
		Matrix b = new Matrix(3,3);
		Matrix i = new Matrix(3,3);
		double[][] A = new double[3][3];
		A[0][0] = x * x;    A[0][1] = x * y;    A[0][2] = x * z;
		A[1][0] = y * x;    A[1][1] = y * y;    A[1][2] = y * z;
		A[2][0] = z * x;    A[2][1] = z * y;    A[2][2] = z * z;
		double[][] B = new double[3][3];
		B[0][0] =  0;       B[0][1] = -z;       B[0][2] = y;
		B[1][0] =  z;       B[1][1] =  0;       B[1][2] = -x;
		B[2][0] = -y;       B[2][1] =  x;       B[2][2] =  0;
		double[][] I = new double[3][3];
		I[0][0] =  1;       I[0][1] =  0;       I[0][2] = 0;
		I[1][0] =  0;       I[1][1] =  1;       I[1][2] = 0;
		I[2][0] =  0;       I[2][1] =  0;       I[2][2] =  1;
		a.init(A);
		b.init(B);
		i.init(I);
		Matrix m = new Matrix(3,3);
		m = i.Minus(a);
		m = m.mMultiply(Math.cos(ang));
		Matrix t = new Matrix(3,3);
		t = b;
		t = t.mMultiply(Math.sin(ang));
		m = m.Plus(t);
		m = m.Plus(a);
		m = m.Trans();
		t = new Matrix(3,1);
		double[][] T = new double[3][1];
		T[0][0] = 1.0;T[1][0] =-1*center.var1/center.var2;T[2][0] =0.0;
		t.init(T);
		m = m.Multiply(t);
		m = m.Trans();
		return new V3(m.mat[0][0],m.mat[0][1],m.mat[0][2]);

	}
介绍一下用到的Matrix 类
import java.util.Random;
public class Matrix {
	public  int row;
	public  int rank;
	public  double[][] mat;

	public Matrix(int a, int b) {
		row = a;
		rank = b;
		mat = new double[row][rank];
	}
	public void New(){
		Random rand=new Random();
		for (int i = 0; i < row; i++)
			for (int j = 0; j < rank; j++)
				mat[i][j]=rand.nextInt(100);
	}
	public void init(double[][] in){
		mat = in;
	}
	public void Output() {
		System.out.println("Matrix=:");
		for (int i = 0; i < row; i++) {
			for (int j = 0; j < rank; j++)
				System.out.print(mat[i][j] + " ");
			System.out.println();
		}
		System.out.println();
	}

	public  Matrix Plus(Matrix a) {
		Matrix c=new Matrix(row,rank);
		if (a.row == row && a.rank == rank) {
			for (int i = 0; i < row; i++)
				for (int j = 0; j < rank; j++)
					c.mat[i][j] = mat[i][j] + a.mat[i][j];
		} else {
			System.out.println("matrixAdd error!");
		}
		return c;
	}

	public  Matrix Minus(Matrix a) {
		Matrix c=new Matrix(row,rank);
		if (a.row == row && a.rank == rank) {
			for (int i = 0; i <row; i++)
				for (int j = 0; j <rank; j++)
					c.mat[i][j] = mat[i][j] - a.mat[i][j];
		} else {
			System.out.println("matrixMinus error!");
		}
		return c;
	}
	public Matrix mMultiply(double a){
		for(int i=0;i<row;i++){
			for(int j=0;j<rank;j++){
				mat[i][j] *= a;
			}
		}
		return this;
	}
	public Matrix Multiply(Matrix a) {
		Matrix c = new Matrix(row, a.rank);
		if (rank == a.row) {
			for (int i = 0; i < c.row; i++)
				for (int j = 0; j < c.rank; j++) {
					double sum = 0;
					for (int k = 0; k < rank; k++)
						sum += mat[i][k] * a.mat[k][j];
					c.mat[i][j] = sum;
				}
		} else {
			System.out.println("matrix Multiply errors!");
		}
		return c;
	}

	public Matrix Trans() {
		Matrix c = new Matrix(rank,row);
		for (int i = 0; i < c.row; i++)
			for (int j = 0; j < c.rank; j++)
				c.mat[i][j] = mat[j][i];
		return c;
	}

	public Matrix Invs() {
		int rw = row, rk = rank;
		Matrix imat = new Matrix(rw, rk);
		Matrix jmat = new Matrix(rw, rk);
		for (int i = 0; i < rw; i++)
			for (int j = 0; j < rw; j++)
				jmat.mat[i][j] = mat[i][j];
		for (int i = 0; i < rw; i++)
			for (int j = 0; j < rw; j++)
				imat.mat[i][j] = 0;
		for (int i = 0; i < rw; i++)
			imat.mat[i][i] = 1;

		for (int i = 0; i < rw; i++) {
			for (int j = 0; j < rw; j++) {
				if (i != j) {
					double t = jmat.mat[j][i] / jmat.mat[i][i];
					for (int k = 0; k < rw; k++) {
						jmat.mat[j][k] -= jmat.mat[i][k] * t;
						imat.mat[j][k] -= imat.mat[i][k] * t;
					}
				}
			}
		}
		for (int i = 0; i < rw; i++)
			if (jmat.mat[i][i] != 1) {
				double t = jmat.mat[i][i];
				for (int j = 0; j < rw; j++) {
					jmat.mat[i][j] = jmat.mat[i][j] / t;
					imat.mat[i][j] = imat.mat[i][j] / t;
				}
			}
		return imat;
	}
}

好了，既然已经求到了每一个半径向量，那么我们用这个向量转换成膜为1的向量，然后加上half就能求出对应的点，把点连起来就是一个圆了。
以下是源码：
package com.example.administrator.pass.tools;

import com.baidu.mapapi.map.OverlayOptions;
import com.baidu.mapapi.map.PolygonOptions;
import com.baidu.mapapi.map.Stroke;
import com.baidu.mapapi.model.LatLng;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 11/10 0010.
 */

public class smoke  {

	static Double  R = 6371004.0;

	 static V3 changeToXyz(LatLng lng){
		 V3 v = new V3();
		if (lng.latitude<0){
			v.var1 = 90 + Math.abs(lng.latitude);
		}else {
			v.var1 = 90 - lng.latitude ;
		 }
		 if(lng.longitude<0){
			 v.var2 = 180 + Math.abs(lng.longitude);
		 }else {
			 v.var2 = 180 - lng.longitude;
		 }
		 v.var3 = R;
		 V3 temp = new V3();
		 temp.var1 = v.var3*Math.sin(Math.PI*v.var1/180)*Math.cos(Math.PI*v.var2/180);
		 temp.var2 = v.var3*Math.sin(Math.PI*v.var1/180)*Math.sin(Math.PI*v.var2/180);
		 temp.var3 = v.var3*Math.cos(Math.PI*v.var1/180);
		 return temp;
	}
	static LatLng getLatLng(V3 in){
		Double x = in.var1;
		Double y = in.var2;
		Double z = in.var3;
		Double r = Math.sqrt(x*x+y*y+z*z);
		Double ceta =    Math.atan(y/x);//x
		Double gama = Math.acos(z/r); //z
		if (x==0.0&&y==0.0){
			ceta = 0.0;
		}
		ceta = Math.abs(ceta);
		if(x>0&&y>=0){
			ceta  = ceta;
		}
		if(x<=0&&y>0){
			ceta = Math.PI/2-ceta;
			ceta += Math.PI/2;
		}
		if(x<0&&y<=0){
			ceta += Math.PI;
		}
		if(x>=0&&y<0){
			ceta = Math.PI/2-ceta;
			ceta += Math.PI/2*3;
		}
		Double latitude = (gama/Math.PI)*180;
		Double longitude = (ceta/Math.PI)*180;
		if (latitude >= 90){
			latitude = -1*(latitude-90);
		}else {
			latitude = 90 - latitude;
		}
		if (longitude >=180){
			longitude = -1*(longitude-180);
		}else {
			longitude = 180 - longitude;
		}
		return new LatLng(latitude,longitude);

	}
	V3 test(V3 in){
		Double x = in.var1;
		Double y = in.var2;
		Double z = in.var3;
		Double r = Math.sqrt(x*x+y*y+z*z);
		Double ceta =   Math.PI/2 + Math.atan(y/x);
		Double gama = Math.acos(z/r);
		return (new V3(ceta,gama,r));
	}



	public static OverlayOptions getOverlayOptions(LatLng Center, Double r, int acc){
		List<LatLng> pts = new ArrayList<LatLng>();
		getLatLng(changeToXyz(new LatLng(0.0,0.0)));
		V3 center = changeToXyz(Center);
		Double rate =  Math.sqrt(R*R-r*r)/R;
		V3 half = new V3(rate*center.var1,rate*center.var2,rate*center.var3);
		V3 temp = new V3();
		V3 mR = new V3();
		LatLng lat = new LatLng(0.0,0.0);
		for(int i=0;i<acc/2+1;i++){

//				temp = new V3(R*Math.cos((2*Math.PI)/acc*i),R*Math.sin((2*Math.PI)/acc*i),0.0);
				temp = getTemp(center,(2*Math.PI)/acc*i);
//				mR = getvertical(center,temp,r);
				mR = getmR(temp,r);
//			System.out.println(mR.var1+"%%%%%%%"+mR.var2+"%%%%%%%%"+mR.var3);
				mR = V3.add(mR,half);
				lat = getLatLng(mR);
				System.out.println(lat.latitude+"**********"+lat.longitude);
				pts.add(lat);

		}


		LatLng pt1 = new LatLng(lat.latitude,180);
		pts.add(pt1);
		LatLng pt2 = new LatLng(90,180);
		pts.add(pt2);
		LatLng pt3 = new LatLng(90,-180);
		pts.add(pt3);
		LatLng pt4 = new LatLng( getPoint(center,acc,0,r,half).latitude,-180);
		pts.add(pt4);
		for(int i=acc/2;i<acc+1;i++){

				temp = getTemp(center,(2*Math.PI)/acc*i);
//				mR = getvertical(center,temp,r);
				mR = getmR(temp,r);

				mR = V3.add(mR,half);
//			System.out.println(mR.var1+"%%%%%%%"+mR.var2+"%%%%%%%%"+mR.var3);
				lat = getLatLng(mR);
				System.out.println(lat.latitude+"**********"+lat.longitude);
				pts.add(lat);
		}

		pt1 = new LatLng(lat.latitude,180);
		pts.add(pt1);
		pt2 = new LatLng(-90,180);
		pts.add(pt2);
		pt3 = new LatLng(-90,-180);
		pts.add(pt3);
		pt4 = new LatLng(getPoint(center,acc,acc/2,r,half).latitude,-180);
		pts.add(pt4);
		OverlayOptions polygonOption = new PolygonOptions()
				.points(pts)
				.stroke(new Stroke(4,0))
				.fillColor(0x99999900);
		return polygonOption;
	}

	public static OverlayOptions hhh(){
		List<LatLng> pts = new ArrayList<LatLng>();
		LatLng p = new LatLng(20.0,30.0);
		pts.add(p);
		p = new LatLng(30.0,45.0);
		pts.add(p);
		p = new LatLng(40.0,20.0);
		pts.add(p);
		p = new LatLng(40.0,20.0);
		pts.add(p);
		p = new LatLng(40.0,20.0);
		pts.add(p);
		OverlayOptions polygonOption = new PolygonOptions()
				.points(pts)
				.stroke(new Stroke(4,0))
				.fillColor(0x99999900);
		return polygonOption;
	}









	static class V3 {
		double var1 = 0.0;
		double var2 = 0.0;
		double var3 = 0.0;
		V3(){

		}
		V3(Double var1,Double var2, Double var3){
			this.var1 = var1;
			this.var2 = var2;
			this.var3 = var3;
		}
		public static V3 add(V3 v1, V3 v2){
			return new V3(v1.var1+v2.var1,v1.var2+v2.var2,v1.var3+v2.var3);
		}


	}
	public static V3 getTemp(V3 center,Double ang){
		center = getmR(center,1.0);
		Double x = center.var1;
		Double y = center.var2;
		Double z = center.var3;
		Matrix a = new Matrix(3,3);
		Matrix b = new Matrix(3,3);
		Matrix i = new Matrix(3,3);
		double[][] A = new double[3][3];
		A[0][0] = x * x;    A[0][1] = x * y;    A[0][2] = x * z;
		A[1][0] = y * x;    A[1][1] = y * y;    A[1][2] = y * z;
		A[2][0] = z * x;    A[2][1] = z * y;    A[2][2] = z * z;
		double[][] B = new double[3][3];
		B[0][0] =  0;       B[0][1] = -z;       B[0][2] = y;
		B[1][0] =  z;       B[1][1] =  0;       B[1][2] = -x;
		B[2][0] = -y;       B[2][1] =  x;       B[2][2] =  0;
		double[][] I = new double[3][3];
		I[0][0] =  1;       I[0][1] =  0;       I[0][2] = 0;
		I[1][0] =  0;       I[1][1] =  1;       I[1][2] = 0;
		I[2][0] =  0;       I[2][1] =  0;       I[2][2] =  1;
		a.init(A);
//		System.out.println("A:");
//		a.Output();
		b.init(B);
//		System.out.println("B:");
//		b.Output();
		i.init(I);
//		System.out.println("I:");
//		i.Output();
		Matrix m = new Matrix(3,3);
		m = i.Minus(a);
//		m.Output();
		m = m.mMultiply(Math.cos(ang));
//		m.Output();
		Matrix t = new Matrix(3,3);
		t = b;
		t = t.mMultiply(Math.sin(ang));
//		m.Output();
		m = m.Plus(t);
//		m.Output();
		m = m.Plus(a);
//		m.Output();
		m = m.Trans();
//		m.Output();
		t = new Matrix(3,1);
		double[][] T = new double[3][1];

//		T[0][0] = 1.0;T[1][0] =1.0;//T[0][2] = -1*(center.var1*center.var2)/center.var3;
//		T[2][0] = -1*(center.var1*center.var2)/center.var3;
		T[0][0] = 1.0;T[1][0] =-1*center.var1/center.var2;T[2][0] =0.0;
				t.init(T);
		m = m.Multiply(t);
		m = m.Trans();
//		m.Output();
		return new V3(m.mat[0][0],m.mat[0][1],m.mat[0][2]);

	}
	public static V3 getvertical(V3 v1, V3 v2, Double r){
		Double a1 = v1.var1;
		Double a2 = v1.var2;
		Double a3 = v1.var3;
		Double b1 = v2.var1;
		Double b2 = v2.var2;
		Double b3 = v2.var3;
		Double dy = (a1*b3-b1*a3)/(b2*a3-b3*a2);
		Double dz =  (a1*b2-a2*b1)/(a2*b3-a3*b2);
		Double x = Math.sqrt((r*r)/(1+dy*dy+dz*dz));
		if ((b2*a3-b3*a2) == 0){
			x = 0.0;
			Double z = Math.sqrt((r*r)/((a3*a3)/(a2*a2)+1));
			Double y = -1*(a3/a2)*z;
			if(x*a1+y*a2+z*a3 != 0||x*b1+y*b2+z*b3 != 0){
//				System.out.println("ERROR!");
			}
			return new V3(x,y,z);
		}

		if(x*a1+dy*x*a2+dz*x*a3 != 0||x*b1+dy*x*b2+dz*x*b3 != 0){
			Double e1 = x*a1+dy*x*a2+dz*x*a3;
			Double e2 = x*b1+dy*x*b2+dz*x*b3;
//			System.out.println("ERROR!     "+e1+"    "+"ERROR!     "+e2);
		}

		return new V3(x,dy*x,dz*x);
	}
	public static V3 getmR(V3 v,double r){
		double x = v.var1;
		double y = v.var2;
		double z = v.var3;
		double sum = x*x + y*y + z*z;
		double k = Math.sqrt(sum/(r*r));
		x = x/k;
		y = y/k;
		z = z/k;
		return new V3(x,y,z);
	}
	public static LatLng getPoint(V3 center,double acc,int i,double r,V3 half){
		V3 temp = getTemp(center,(2*Math.PI)/acc*i);
//				mR = getvertical(center,temp,r);
		V3 mR = getmR(temp,r);
//			System.out.println(mR.var1+"%%%%%%%"+mR.var2+"%%%%%%%%"+mR.var3);
		mR = V3.add(mR,half);
		LatLng lat = getLatLng(mR);
		return lat;
	}

}

CART（Classification And Regression Tree），是一种基于局部的回归算法，通过将数据集切分为多份，在每一份数据中单独建模。
CART回归树的主要步骤：1、 CART树的生成 2、 回归树的剪枝
CART分类树用Gini指数作为划分属性的指标，但在CART回归树中，样本的标签是一系列的连续值，不能再使用Gini指数作为指标，因此使用均方差作为回归树的指标。设有m个数据，则CART回归树的指标是：

# coding:UTF-8
'''
Date:20161030
@author: zhaozhiyong
'''
import numpy as np
import pickle as pickle
import pdb 
from graphviz import Digraph
#from Draw import BTree

class node:
    '''树的节点的类
    '''
    def __init__(self, fea=-1, value=None, results=None, right=None, left=None):
        self.fea = fea  # 用于切分数据集的属性的列索引值
        self.value = value  # 设置划分的值
        self.results = results  # 存储叶节点的值
        self.right = right  # 右子树
        self.left = left  # 左子树

def load_data(data_file):
    '''导入训练数据
    input:  data_file(string):保存训练数据的文件
    output: data(list):训练数据
    '''
    data = []
    f = open(data_file)
    for line in f.readlines():
        sample = []
        lines = line.strip().split("\t")
        for x in lines:
            sample.append(float(x))  # 转换成float格式
        data.append(sample)
    f.close()
    
    return data
        
def split_tree(data, fea, value):
    '''根据特征fea中的值value将数据集data划分成左右子树
    input:  data(list):训练样本
            fea(float):需要划分的特征index
            value(float):指定的划分的值
    output: (set_1, set_2)(tuple):左右子树的聚合
    '''
    set_1 = []  # 右子树的集合
    set_2 = []  # 左子树的集合
    for x in data:
        if x[fea] >= value:
            set_1.append(x)
        else:
            set_2.append(x)
    return (set_1, set_2)

def leaf(dataSet):
    '''计算叶节点的值
    input:  dataSet(list):训练样本
    output: np.mean(data[:, -1])(float):均值
    '''
    data = np.mat(dataSet)
    return np.mean(data[:, -1])

def err_cnt(dataSet):
    '''回归树的划分指标
    input:  dataSet(list):训练数据
    output: m*s^2(float):总方差
    '''
    data = np.mat(dataSet)
    return np.var(data[:, -1]) * np.shape(data)[0]
    

def build_tree(data, min_sample, min_err):
    '''构建树
    input:  data(list):训练样本
            min_sample(int):叶子节点中最少的样本数
            min_err(float):最小的error
    output: node:树的根结点
    '''
    # 构建决策树，函数返回该决策树的根节点
    if len(data) <= min_sample:
        return node(results=leaf(data))
    
    # 1、初始化
    best_err = err_cnt(data)
    bestCriteria = None  # 存储最佳切分属性以及最佳切分点
    bestSets = None  # 存储切分后的两个数据集
    
    # 2、开始构建CART回归树
    feature_num = len(data[0]) - 1
    for fea in range(0, feature_num):
        feature_values = {}
        for sample in data:
            feature_values[sample[fea]] = 1
        
        for value in feature_values.keys():
            # 2.1、尝试划分
            (set_1, set_2) = split_tree(data, fea, value)
            if len(set_1) < 2 or len(set_2) < 2:
                continue
            # 2.2、计算划分后的error值
            now_err = err_cnt(set_1) + err_cnt(set_2)
            # 2.3、更新最优划分
            
            if now_err < best_err and len(set_1) > 0 and len(set_2) > 0:
                best_err = now_err
                print("-----err : ",best_err)
                bestCriteria = (fea, value)
                bestSets = (set_1, set_2)

    # 3、判断划分是否结束
#    pdb.set_trace()
    if best_err > min_err:
        right = build_tree(bestSets[0], min_sample, min_err)
        left = build_tree(bestSets[1], min_sample, min_err)
        return node(fea=bestCriteria[0], value=bestCriteria[1], \
                    right=right, left=left)
    else:
        return node(results=leaf(data))  # 返回当前的类别标签作为最终的类别标签
        
def predict(sample, tree):
    '''对每一个样本sample进行预测
    input:  sample(list):样本
            tree:训练好的CART回归树模型
    output: results(float):预测值
    '''
    # 1、只是树根
    if tree.results != None:
        return tree.results
    else:
    # 2、有左右子树
        val_sample = sample[tree.fea]  # fea处的值
        branch = None
        # 2.1、选择右子树
        if val_sample >= tree.value:
            branch = tree.right
        # 2.2、选择左子树
        else:
            branch = tree.left
        return predict(sample, branch)
   
def cal_error(data, tree):
    ''' 评估CART回归树模型
    input:  data(list):
            tree:训练好的CART回归树模型
    output: err/m(float):均方误差
    '''
    m = len(data)  # 样本的个数   
    n = len(data[0]) - 1  # 样本中特征的个数
    err = 0.0
    for i in range(m):
        tmp = []
        for j in range(n):
            tmp.append(data[i][j])
        pre = predict(tmp, tree)  # 对样本计算其预测值
        # 计算残差
        err += (data[i][-1] - pre) * (data[i][-1] - pre)
    return err / m

def save_model(regression_tree, result_file):
    '''将训练好的CART回归树模型保存到本地
    input:  regression_tree:回归树模型
            result_file(string):文件名
    '''
    with open(result_file, 'wb') as f:
        pickle.dump(regression_tree, f)
        
######################获取二叉树的深度 ####################
class Solution(object):  
    def isBalanced(self, root): #获取二叉树的深度 
        if root==None:  
            return 0  
        leftheight=self.isBalanced(root.left)  
        rightheight=self.isBalanced(root.right)  
        if leftheight>=rightheight:  
            return leftheight+1  
        else:  
            return rightheight+1
    
if __name__ == "__main__":
    # 1、导入训练数据
    print ("----------- 1、load data -------------")
    data = load_data("sine.txt")
    y = []
    for i in range(len(data)):
        y_tmp = data[i][1]
        y.append(y_tmp)
    ss = set(y)
    print(len(ss))
    # 2、构建CART树
    print ("----------- 2、build CART ------------")
#    pdb.set_trace()
    regression_tree = build_tree(data, 20, 0.3)
    
    # 3、评估CART树
    print ("----------- 3、cal err -------------")
    err = cal_error(data, regression_tree)
    print ("\t--------- err : ", err)
    # 4、保存最终的CART模型
    print("----------4、save result -----------")  
    save_model(regression_tree, "regression_tree")
    
对训练好的CART回归树，画图代码如下：
# -*- coding: utf-8 -*-
"""
Created on Thu May 24 16:16:59 2018

@author: Administrator
"""
from graphviz import Digraph
import pickle as pickle

def load_model(tree_file):
    '''导入训练好的CART回归树模型
    input:  tree_file(list):保存CART回归树模型的文件
    output: regression_tree:CART回归树
    '''
    with open(tree_file, 'rb') as f:
        regression_tree = pickle.load(f)
    return regression_tree 

class node:
    '''树的节点的类
    '''
    def __init__(self, fea=-1, value=None, results=None, right=None, left=None):
        self.fea = fea  # 用于切分数据集的属性的列索引值
        self.value = value  # 设置划分的值
        self.results = results  # 存储叶节点的值
        self.right = right  # 右子树
        self.left = left  # 左子树
        
######################获取二叉树的深度 ####################
class Solution(object):  
    def isBalanced(self, root): #获取二叉树的深度 
        if root==None:  
            return 0  
        leftheight=self.isBalanced(root.left)  
        rightheight=self.isBalanced(root.right)  
        if leftheight>=rightheight:  
            return leftheight+1  
        else:  
            return rightheight+1 
#####################遍历二叉树########################
class BTree(object):

    def __init__(self,dot):
        self.dot = dot

    def preorder(self,pre_treenode ,treenode,orientation):
        '前序（pre-order，NLR）遍历'
        if treenode.results != None:  #只有树根
            a = str(pre_treenode.value)
            self.dot.node(a, a)
            result = str(treenode.results)
            self.dot.node(result, result,shape = 'box',stytle = 'filled',color = ".7.3 1.0")
            self.dot.edge(a, result)
            return
        else:  #有左右子树
            a = str(treenode.value)
            self.dot.node(a, a)
            if treenode.left.results == None:
                left = str(treenode.left.value)
                self.dot.node(left, left)  #dot.node(节点名，节点标签（显示出来的）)
                self.dot.edge(a, left)
            if treenode.right.results == None:
                right = str(treenode.right.value)
                self.dot.node(right, right)
                self.dot.edge(a, right)

        self.preorder(treenode,treenode.left,'left')
        self.preorder(treenode,treenode.right,'right')



root = load_model("regression_tree")
dot = Digraph(comment='The Test Table')
bt = BTree(dot)
bt.preorder('',root,'root')    
#print(dot.source)
dot.render('test-output/test-table.gv', view=True)
        
本数据训练的CART树如下图：椭圆形的框中的数据代表分界点，将数据分为左右两部分，矩形框代表叶子节点，也就是该节点所包含的数据的y的平均值，也即最后的回归值。