精华内容
下载资源
问答
  • 本章实际操作使用ps来进行切图,分成四部分来讲解: 1.切图的常规步骤 2.如何只保留某一部分 3.删除切片 4去掉默认切片线 ...我现在有一张登录框的psd,拿到psd后首先要...然后切片工具出三个部分,如果觉得切片



    本章实际操作使用ps来进行切图,分成四部分来讲解:

    1.切图的常规步骤

    2.如何只保留某一部分

    3.删除切片

    4去掉默认切片线



    切图的常规步骤

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




    在工具栏中选择切片工具



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



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



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




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





    如何只保留某一部分

    我们上面已经了解了正常的流程,不过有时候我们需要某一部分的图片,不能一次性全部切好。比如我们需要蓝色按钮单独作一张图片。那怎么单独切出这个按钮呢。

    步骤如下:

    选择切片工具,画出按钮。



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



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



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




    ps:这里只是演示步骤,正规流程中 按钮这些单独的图层 最好使用 图层切片,这样得到的图才是最完整无混合边界的图。

    步骤是 在右侧图层面板中选中图层 ----》选取图层---》新建基于图层的切片




    删除切片

    在画切片的时候 经常有画错的时候, 除了后退之外我们还可以删除切片。

    对着切片直接右键可以看到 删除切片。 

    仅仅是用户切片才能 使用 删除切片。

    非用户切片的删除切片是灰色的。只能先右键点击提升为用户切片之后才能删除。

    所谓的用户切片就是 我们画的切片,非用户切片是我们画了一部分之后 系统补充的另一部分。






    去掉默认切片线

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

    视图-----》清除切片即可。





    展开全文
  • 怎样切割铁氧体材料? 铁氧体材料硬而且脆,要想切割铁氧体材料钢锯都锯不动,锤子砸,虽然能砸开但一般都会碎成好儿段...操作时人体不能碰触220V电路任何裸露部分,否则有触电危险。  图:电切割铁氧体方法 
  • IOS 百叶窗动画

    千次阅读 2015-11-09 18:44:14
    考虑过将其移植到自己的代码,但因为对OpenGL完全不懂,不能很好的切合到自己的代码里,放弃了。 后来,想到一个方法,将UIView截屏成图片,然后将图片等份切割成6份(我的代码里是6份),然后6个UIIma

    之前看到多利用苹果开发的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];
            }
        }];
    }


    展开全文
  • 的加密狗才可以打开/编辑自己设计的EXE,而别人只能播放EXE而不能打开EXE, 杜绝了骗图、偷图等盗版行为,并底阻止他人非法提取自己的TOL、图片及动画效果. ======================================================...
  • Neon2013动画软件

    2012-12-22 22:10:52
    NEON2013自动对输出的EXE动画文件进行加密处理,这是一个重要升级,意味着只有自己的加密狗才可以打开/编辑自己设计的EXE,而别人只能播放EXE而不能打开EXE,杜绝了骗图、偷图等盗版行为,并底阻止他人非法提取自己的...
  • 如何在百度地图上镂空圆 Android

    千次阅读 2016-11-12 15:24:52
    百度API提供了在地图上圆形的类,但出圆只能是实心圆,也就是不能实现让圆内没有颜色而圆外有颜色的镂空圆。那么我们应该实现镂空圆呢? 首先我发现API还提供一个多边形的类。而一个镂空圆分解成两个多边形,...

    百度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回归预测+二叉树

    千次阅读 2018-06-04 14:29:48
    CART回归树的主要步骤:1、 CART树的生成 2、 回归树的剪枝CART分类树Gini指数作为划分属性的指标,但在CART回归树,样本的标签是一系列的连续值,不能再使用Gini指数作为指标,因此使用均方差作为回归树的指标...

    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的平均值,也即最后的回归值。


    展开全文
  • 4.0 リリース計

    2020-12-31 00:29:15
    4.0のリリース計について、検討の事項をまとめていきます。 変更などあれば随時アップデートしていきます。 機要望やご意見は新規にIssueを立てていただくか、関連するIssueがあればそちらにお願いします。 ...
  • 3.0.14 リリース計

    2020-12-27 22:53:17
    <div><h3><a href="https://github.com/EC-CUBE/ec-cube/milestone/23">EC-CUBE 3.0.14</a> のリリース内容・計のまとめや目安箱Issueです。 このIssueを次のスコープにいれてほしいなどのご意見ありましたらコメ...
  • 2. 如果不能运行,请安装.net4.5框架,推荐下载地址:http://www.crsky.com/soft/4818.html 常见问题: 1.切片规则 2.操作流程 小程序关键词: 小程序前端制作 小程序前端代码生成 小程序前端模板制作 小程序...
  • 最近接到一个任务,就是要修改原来的官方support包TabLayout的指示器线宽,改成固定值,当然网上有什么反射加padding什么的,可是治标治本,Tab过渡动画也加了,什么?你告诉我github又xxx类似控件,可是...
  • 或者到别的tab去看看新闻啊,看看美女帅哥啊,过个半分一分钟再回到这两个页面来看看。 我想会突然好像知道了什么事情。。。 <p><strong>setInterval 和 setTimeout 在非当前窗口,或者浏览器...
  • raw矩阵就是200\*200\*150的灰度图像,大概就是有150张图,每张200\*200,能用imshow出图像: ![图片说明](https://img-ask.csdn.net/upload/202004/30/1588248228_446011.png) 然后问题来了,我理解的是...
  • 返回 e 的指定次幂 对数 数字 x 的 y 次幂 返回较大者 第3页 C#(WINFORM)学习 Math.Min(x,y) 返回较小者 枚举型 一般为字符串,可以定义带数字的枚举型,示例为: enum Color { Red=1, Blue=2, Green=3 } ...
  • GSP5.exe

    2020-04-01 09:16:40
    注:单独使用的“文本”工具,创建的“注释”类型文本,不能进行数学格式编辑。只有对象标签或度量的文本才可以进行“数学格式编辑”。 移动与动画编辑 几何画板出的各类对象可以运动,这是它之所以称为“动态几何...
  • 这里图片切割我用的画布,事件用的拖放,只需要改一下img的引用就能用。 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>拖放</title> <style type...
  • 09-17 用户分析

    2020-09-17 22:33:51
    它的核心主要是 利用存储在服务器上的海量日志和数据库里的大量数据进行分析和挖掘,给用户贴标签,而标签是表示用户某一维度特征的标识,主要过与业务的运营和数据分析。 2、用户画像的作用? 精准营销...
  • 第一步安装参考百度经验:点击这里,鉴于其中提供的文件全部不能用,替换成了上面的,亲测Intel Core I5 4200M 可用。 二.优化 这里给出一些我个人的优化方式,在I5 CPU, 8G虚拟机内存,SSD的基础上,已经能流畅的...
  • 前端开发过程,下面这样的图标经常会遇到,当然,最简单的方法是找UI个背景图,但是,代码的世界也不能完全靠图,那么,css又该如何实现呢,研究了网上的大多数方法,核心就是:定位+拼图 第一步,先个...
  • 步骤一:因为是登录系统的首页,一般来说将页面分成上下三个部分,但是公司这次的图标body是一张有一只右手的图片,不能切,所以分成了上下两部分。dreamwaver画框架,效率高,虽然看起来不好
  • 我们在中学的时候常常碰到对一个圆做各种内接或者外图形的题目,那么这些图形在几何画板中能不能实现绘制呢?答案是肯定的。下面我们使用几何画板来绘制一个圆的内接正三角形。几何画板如何绘制一个圆的内接正...
  • flash shiti

    2014-03-14 10:32:41
    影片不能有Loading B. 中间 C. 后面 D. 前面 2.Flash设置属性的命令是? A. Set Polity B. Polity C. Property D. Set Property 3.Flash action“while”意义是? A. 卸载动画片段符号 B. 声明局部变量...
  • 本强强系列插件

    2013-03-19 19:47:02
    7:zq_cutObj.ms --用布尔的方法切割物体,简单的物体能用,复杂的和max的布尔一样容易出错。 8:zq_disturbSel.ms --打乱选择的物体。随机旋转、移动、缩放物体。我用来在动画场景种种树 9:zq_explodeElement.ms --...
  • myeclipse修改uml字体

    千次阅读 2011-04-04 19:15:00
     最近再做一个项目时需要uml,以前是利用euml2,一个中国公司开发的eclipse插件,结果现在用到eclipse3.4了以后,那个插件不能继续了,估计那个公司亏得够呛,后来忽然发现myeclipse实际上自带了一个还...
  • 功夫

    2009-04-15 17:39:00
    功夫,它是长时间的苦练和用功得来的!画家有他的功夫,可以指尖作画,杀猪的也有他的功夫...功夫只能意会不能言传,它就像是水!因为水是无孔不入的,正所谓滴水可以穿石,它不与对手正面抗衡,而是从对手身边穿过去
  • ghostcat源码(附带实例)

    热门讨论 2011-09-08 10:14:36
    -完整功能的自定制过渡,不仅能用,也能创造。如果不会用,可以使用Creater的模板 -粒子,物理,景深 -像QQ那样截屏! -流方式读取文本和图片。HTML可以,FLASH也可以 -和FXG类似的道理,用对象保存绘制操作,简化...
  • jQuery权威指南-源代码

    2013-11-11 14:36:34
    如果读者在阅读本书的过程逐一亲手实现这些案例,在实际开发应该就具备相当的动手能力了。 本书面向的读者 本书适合所有希望迅速掌握jQuery并将之付诸实践的Web开发者阅读。 如何阅读本书 由于本书的结构是...
  • NB几何画板 v101.zip

    2019-07-13 00:38:55
    对图形进行自由拖动、切割、组合、粘合、复制、旋转等操作,将抽象的公式推理过程变得简单形象化,人性化设计,操作简单,功能强大,虚实结合。支持在android、苹果平板或手机上进行使用。软件界面美观简洁、...
  • arcgis工具

    2012-10-22 22:37:31
    在做外联如EXCEL等的时候对数据有一些要求,确保第一行包含字段名,这些字段名不能超过十个字母,不能出现特殊字符。最好把EXCEL保存为.csv文件去除一些不兼容的内容再连接。 转载ESRI论坛Lucy1114帖子说明: 12...
  • 高级参数设置:(提示:下面的参数一般很少用到,通常情况下你可以无视它们^^)自动播放: 是 否 , 显示自带边框(如果有的话): 是 否 , 开始显示的图片顺序: (0表示第一张,不能大于总数) 按钮悬停(mouseover)模式下的...

空空如也

空空如也

1 2 3 4
收藏数 65
精华内容 26
关键字:

切画中画不能用