文档章节

Android中的Interpolator

新年
 新年
发布于 2015/02/28 13:06
字数 1033
阅读 7
收藏 0
点赞 0
评论 0

Android中的Interpolator

转帖来源:

http://www.cnblogs.com/mengdd/p/3346003.html


  Interpolator用于动画中的时间插值,其作用就是把0到1的浮点值变化映射到另一个浮点值变化。

  本文列出Android API提供的Interpolator的若干种实现,列出源码,并且用一个程序绘制出其数学曲线。(项目链接附在文后)。

 

AccelerateDecelerateInterpolator

复制代码

/**
 * An interpolator where the rate of change starts and ends slowly but
 * accelerates through the middle.
 * 
 */public class AccelerateDecelerateInterpolator implements Interpolator {    public AccelerateDecelerateInterpolator() {
    }
    
    @SuppressWarnings({"UnusedDeclaration"})    public AccelerateDecelerateInterpolator(Context context, AttributeSet attrs) {
    }    
    public float getInterpolation(float input) {        return (float)(Math.cos((input + 1) * Math.PI) / 2.0f) + 0.5f;
    }
}

复制代码

 

 

AccelerateInterpolator

复制代码

/**
 * An interpolator where the rate of change starts out slowly and 
 * and then accelerates.
 * */public class AccelerateInterpolator implements Interpolator {    private final float mFactor;    private final double mDoubleFactor;    public AccelerateInterpolator() {
        mFactor = 1.0f;
        mDoubleFactor = 2.0;
    }    
    /**
     * Constructor
     * 
     * @param factor Degree to which the animation should be eased. Seting
     *        factor to 1.0f produces a y=x^2 parabola. Increasing factor above
     *        1.0f  exaggerates the ease-in effect (i.e., it starts even
     *        slower and ends evens faster)     */
    public AccelerateInterpolator(float factor) {
        mFactor = factor;
        mDoubleFactor = 2 * mFactor;
    }    
    public AccelerateInterpolator(Context context, AttributeSet attrs) {
        TypedArray a =
            context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.AccelerateInterpolator);
        
        mFactor = a.getFloat(com.android.internal.R.styleable.AccelerateInterpolator_factor, 1.0f);
        mDoubleFactor = 2 * mFactor;

        a.recycle();
    }    
    public float getInterpolation(float input) {        if (mFactor == 1.0f) {            return input * input;
        } else {            return (float)Math.pow(input, mDoubleFactor);
        }
    }
}

复制代码

 

AnticipateInterpolator

复制代码

/**
 * An interpolator where the change starts backward then flings forward. */public class AnticipateInterpolator implements Interpolator {    private final float mTension;    public AnticipateInterpolator() {
        mTension = 2.0f;
    }    /**
     * @param tension Amount of anticipation. When tension equals 0.0f, there is
     *                no anticipation and the interpolator becomes a simple
     *                acceleration interpolator.     */
    public AnticipateInterpolator(float tension) {
        mTension = tension;
    }    public AnticipateInterpolator(Context context, AttributeSet attrs) {
        TypedArray a = context.obtainStyledAttributes(attrs,
                com.android.internal.R.styleable.AnticipateInterpolator);

        mTension =
                a.getFloat(com.android.internal.R.styleable.AnticipateInterpolator_tension, 2.0f);

        a.recycle();
    }    public float getInterpolation(float t) {        // a(t) = t * t * ((tension + 1) * t - tension)
        return t * t * ((mTension + 1) * t - mTension);
    }
}

复制代码

 

 

AnticipateOvershootInterpolator

复制代码

/**
 * An interpolator where the change starts backward then flings forward and overshoots
 * the target value and finally goes back to the final value. */public class AnticipateOvershootInterpolator implements Interpolator {    private final float mTension;    public AnticipateOvershootInterpolator() {
        mTension = 2.0f * 1.5f;
    }    /**
     * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
     *                there is no anticipation/overshoot and the interpolator becomes
     *                a simple acceleration/deceleration interpolator.     */
    public AnticipateOvershootInterpolator(float tension) {
        mTension = tension * 1.5f;
    }    /**
     * @param tension Amount of anticipation/overshoot. When tension equals 0.0f,
     *                there is no anticipation/overshoot and the interpolator becomes
     *                a simple acceleration/deceleration interpolator.
     * @param extraTension Amount by which to multiply the tension. For instance,
     *                     to get the same overshoot as an OvershootInterpolator with
     *                     a tension of 2.0f, you would use an extraTension of 1.5f.     */
    public AnticipateOvershootInterpolator(float tension, float extraTension) {
        mTension = tension * extraTension;
    }    public AnticipateOvershootInterpolator(Context context, AttributeSet attrs) {
        TypedArray a = context.obtainStyledAttributes(attrs, AnticipateOvershootInterpolator);

        mTension = a.getFloat(AnticipateOvershootInterpolator_tension, 2.0f) *
                a.getFloat(AnticipateOvershootInterpolator_extraTension, 1.5f);

        a.recycle();
    }    private static float a(float t, float s) {        return t * t * ((s + 1) * t - s);
    }    private static float o(float t, float s) {        return t * t * ((s + 1) * t + s);
    }    public float getInterpolation(float t) {        // a(t, s) = t * t * ((s + 1) * t - s)        // o(t, s) = t * t * ((s + 1) * t + s)        // f(t) = 0.5 * a(t * 2, tension * extraTension), when t < 0.5        // f(t) = 0.5 * (o(t * 2 - 2, tension * extraTension) + 2), when t <= 1.0
        if (t < 0.5f) return 0.5f * a(t * 2.0f, mTension);        else return 0.5f * (o(t * 2.0f - 2.0f, mTension) + 2.0f);
    }
}

复制代码

BounceInterpolator

复制代码

/**
 * An interpolator where the change bounces at the end. */public class BounceInterpolator implements Interpolator {    public BounceInterpolator() {
    }

    @SuppressWarnings({"UnusedDeclaration"})    public BounceInterpolator(Context context, AttributeSet attrs) {
    }    private static float bounce(float t) {        return t * t * 8.0f;
    }    public float getInterpolation(float t) {        // _b(t) = t * t * 8        // bs(t) = _b(t) for t < 0.3535        // bs(t) = _b(t - 0.54719) + 0.7 for t < 0.7408        // bs(t) = _b(t - 0.8526) + 0.9 for t < 0.9644        // bs(t) = _b(t - 1.0435) + 0.95 for t <= 1.0        // b(t) = bs(t * 1.1226)
        t *= 1.1226f;        if (t < 0.3535f) return bounce(t);        else if (t < 0.7408f) return bounce(t - 0.54719f) + 0.7f;        else if (t < 0.9644f) return bounce(t - 0.8526f) + 0.9f;        else return bounce(t - 1.0435f) + 0.95f;
    }
}

复制代码

 

CycleInterpolator

复制代码

/**
 * Repeats the animation for a specified number of cycles. The
 * rate of change follows a sinusoidal pattern.
 * */public class CycleInterpolator implements Interpolator {    public CycleInterpolator(float cycles) {
        mCycles = cycles;
    }    
    public CycleInterpolator(Context context, AttributeSet attrs) {
        TypedArray a =
            context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.CycleInterpolator);
        
        mCycles = a.getFloat(com.android.internal.R.styleable.CycleInterpolator_cycles, 1.0f);
        
        a.recycle();
    }    
    public float getInterpolation(float input) {        return (float)(Math.sin(2 * mCycles * Math.PI * input));
    }    
    private float mCycles;
}

复制代码

 

  参数为2时的曲线:

 

DecelerateInterpolator

复制代码

/**
 * An interpolator where the rate of change starts out quickly and 
 * and then decelerates.
 * */public class DecelerateInterpolator implements Interpolator {    public DecelerateInterpolator() {
    }    /**
     * Constructor
     * 
     * @param factor Degree to which the animation should be eased. Setting factor to 1.0f produces
     *        an upside-down y=x^2 parabola. Increasing factor above 1.0f makes exaggerates the
     *        ease-out effect (i.e., it starts even faster and ends evens slower)     */
    public DecelerateInterpolator(float factor) {
        mFactor = factor;
    }    
    public DecelerateInterpolator(Context context, AttributeSet attrs) {
        TypedArray a =
            context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.DecelerateInterpolator);
        
        mFactor = a.getFloat(com.android.internal.R.styleable.DecelerateInterpolator_factor, 1.0f);
        
        a.recycle();
    }    
    public float getInterpolation(float input) {        float result;        if (mFactor == 1.0f) {
            result = (float)(1.0f - (1.0f - input) * (1.0f - input));
        } else {
            result = (float)(1.0f - Math.pow((1.0f - input), 2 * mFactor));
        }        return result;
    }    
    private float mFactor = 1.0f;
}

复制代码

 

LinearInterpolator

复制代码

/**
 * An interpolator where the rate of change is constant
 * */public class LinearInterpolator implements Interpolator {    public LinearInterpolator() {
    }    
    public LinearInterpolator(Context context, AttributeSet attrs) {
    }    
    public float getInterpolation(float input) {        return input;
    }
}

复制代码

 

OvershootInterpolator

复制代码

/**
 * An interpolator where the change flings forward and overshoots the last value
 * then comes back. */public class OvershootInterpolator implements Interpolator {    private final float mTension;    public OvershootInterpolator() {
        mTension = 2.0f;
    }    /**
     * @param tension Amount of overshoot. When tension equals 0.0f, there is
     *                no overshoot and the interpolator becomes a simple
     *                deceleration interpolator.     */
    public OvershootInterpolator(float tension) {
        mTension = tension;
    }    public OvershootInterpolator(Context context, AttributeSet attrs) {
        TypedArray a = context.obtainStyledAttributes(attrs,
                com.android.internal.R.styleable.OvershootInterpolator);

        mTension =
                a.getFloat(com.android.internal.R.styleable.OvershootInterpolator_tension, 2.0f);

        a.recycle();
    }    public float getInterpolation(float t) {        // _o(t) = t * t * ((tension + 1) * t + tension)        // o(t) = _o(t - 1) + 1
        t -= 1.0f;        return t * t * ((mTension + 1) * t + mTension) + 1.0f;
    }
}

复制代码

 

 

项目链接:

  https://github.com/mengdd/HelloInterpolator.git


本文转载自:http://www.cnblogs.com/mengdd/p/3346003.html

共有 人打赏支持
新年
粉丝 7
博文 83
码字总数 45935
作品 0
海淀
程序员
Android中Activity的切换动画(非overridePendingTransition)

摘自:http://fuyunhe.iteye.com/blog/1834874 我们知道,在Manifest文件中声明Activity时,可以通过android:theme属性设置Activity的主题。主题中定义了关于Activity外观的很多特性。同时,...

HCMore ⋅ 2014/05/11 ⋅ 4

Android的Activity屏幕切换动画(二)-左右滑动深入与实战

上一篇文章讲了 Android的左右滑动切换,实现过程是非常简单,一些新手可能会向深入了了解Activity切换的原理,下面主要对左右滑动进行深入的探讨,并以项目中的一个切换效果来进一步了解。 ...

Binny ⋅ 2011/12/18 ⋅ 8

【Animations】用动画移动视图(5)

原文 概要 屏幕上的对象通常需要重新定位。这可能是由于用户交互或在幕后完成某些处理而发生的。而不是立即更新对象位置,这会导致它从一个区域闪烁到另一个区域,您应该使用动画将其从开始位...

lichong951 ⋅ 05/28 ⋅ 0

android 两个activity实现切换时的滑动效果实现

切换效果主要用到的方法是overridePendingTransition,详解如下: 在startintent 或 finish 的时候调用 getActivity().overridePendingTransition(arg0,arg1) arg0是设置第二个activity进入...

manlianman ⋅ 2014/06/11 ⋅ 0

程序编写完,能在模拟器上运行,将apk装在手机上就不能运行了

MainActivity.java package com.example.a; import android.os.Bundle; import android.app.Activity; import android.view.Menu; import android.view.View; import android.view.animation......

HonorMvp ⋅ 2014/09/28 ⋅ 0

如何设定Activity间切换时的动画

本代码示例介绍如何设定Activity间切换时的动画效果。本示例使用Eclipse的Android工程编译测试。 1. 定义清单文件(AndroidManifest.xml)

长平狐 ⋅ 2012/10/16 ⋅ 0

关于 overridePendingTransition()使用

实现两个 Activity 切换时的动画。在Activity中使用 有两个参数:进入动画和出去的动画。 注意 1、必须在 StartActivity() 或 finish() 之后立即调用。 2、而且在 2.1 以上版本有效 3、手机设...

chuiyuan ⋅ 2014/09/23 ⋅ 0

Android动画效果 translate、scale、alpha、rotate

Android的动画效果分为两种,一种是tweened animation(补间动画),第二种是frame by frame animation。 一般我们用的是第一种。补间动画又分为AlphaAnimation,透明度转换 RotateAnimation,...

黑马108 ⋅ 2012/10/19 ⋅ 0

overridePendingTransition方法

在startActivity后,调用overridePendingTransition方法,例如, 一)实现淡入淡出的效果如下: startActivity(new Intent(SplashActivity.this, MainActivity.class)); SplashActivity.this.f......

今日竹石 ⋅ 2014/12/25 ⋅ 0

Android开发权威指南(第2版)新书发布

《Android开发权威指南(第二版)》是畅销书《Android开发权威指南》的升级版,内容更新超过80%,是一本全面介绍Android应用开发的专著,拥有45章精彩内容供读者学习。  《Android开发权威指...

androidguy ⋅ 2013/09/05 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

mysql5.7系列修改root默认密码

操作系统为centos7 64 1、修改 /etc/my.cnf,在 [mysqld] 小节下添加一行:skip-grant-tables=1 这一行配置让 mysqld 启动时不对密码进行验证 2、重启 mysqld 服务:systemctl restart mysql...

sskill ⋅ 10分钟前 ⋅ 0

Intellij IDEA神器常用技巧六-Debug详解

在调试代码的时候,你的项目得debug模式启动,也就是点那个绿色的甲虫启动服务器,然后,就可以在代码里面断点调试啦。下面不要在意,这个快捷键具体是啥,因为,这个keymap是可以自己配置的...

Mkeeper ⋅ 14分钟前 ⋅ 0

zip压缩工具、tar打包、打包并压缩

zip 支持压缩目录 1.在/tmp/目录下创建目录(study_zip)及文件 root@yolks1 study_zip]# !treetree 11└── 2 └── 3 └── test_zip.txt2 directories, 1 file 2.yum...

蛋黄Yolks ⋅ 16分钟前 ⋅ 0

聊聊HystrixThreadPool

序 本文主要研究一下HystrixThreadPool HystrixThreadPool hystrix-core-1.5.12-sources.jar!/com/netflix/hystrix/HystrixThreadPool.java /** * ThreadPool used to executed {@link Hys......

go4it ⋅ 35分钟前 ⋅ 0

容器之上传镜像到Docker hub

Docker hub在国内可以访问,首先要创建一个账号,这个后面会用到,我是用126邮箱注册的。 1. docker login List-1 Username不能使用你注册的邮箱,要用使用注册时用的username;要输入密码 ...

汉斯-冯-拉特 ⋅ 42分钟前 ⋅ 0

SpringBoot简单使用ehcache

1,SpringBoot版本 2.0.3.RELEASE ①,pom.xml <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.0.3.RELE......

暗中观察 ⋅ 43分钟前 ⋅ 0

监控各项服务

比如有三个服务, 为了减少故障时间,增加监控任务,使用linux的 crontab 实现. 步骤: 1,每个服务写一个ping接口 监控如下内容: 1,HouseServer 是否正常运行,所以需要增加一个ping的接口 ; http...

黄威 ⋅ 46分钟前 ⋅ 0

Spring源码解析(八)——实例创建(下)

前言 来到实例创建的最后一节,前面已经将一个实例通过不同方式(工厂方法、构造器注入、默认构造器)给创建出来了,下面我们要对创建出来的实例进行一些“加工”处理。 源码解读 回顾下之前...

MarvelCode ⋅ 46分钟前 ⋅ 0

nodejs __proto__跟prototype

前言 nodejs中完全没有class的这个概念,这点跟PHP,JAVA等面向对象的语言很不一样,没有class跟object的区分,那么nodejs是怎么样实现继承的呢? 对象 对象是由属性跟方法组成的一个东西,就...

Ai5tbb ⋅ 52分钟前 ⋅ 0

Ubuntu16.04 PHP7.0 不能用MYSQLi方式连接MySQL5.7数据库

Q: Ubuntu16.04 PHP7.0 不能用MYSQLi方式连接MySQL5.7数据库 A: 执行以下2条命令解决: apt-get install php-mysql service apache2 restart php -m 执行后会多以下4个模块: mysqli mysqlnd...

SamXIAO ⋅ 55分钟前 ⋅ 0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部