Android中的Interpolator

妖狐艹你老母 2022-06-12 21:12 158阅读 0赞

转自：http://www.cnblogs.com/mengdd/p/3346003.html

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

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

# #

## AccelerateDecelerateInterpolator ##

![复制代码][copycode.gif]

/**
     * 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;
        }
    }

![复制代码][copycode.gif]

![29162553-398804596d514dd795c2f19539148ca2.png][]

## AccelerateInterpolator ##

![复制代码][copycode.gif]

/**
     * 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);
            }
        }
    }

![复制代码][copycode.gif]

![29162735-9d46b2da759e4b668a5209557b6ee115.png][]

## AnticipateInterpolator ##

![复制代码][copycode.gif]

/**
     * 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);
        }
    }

![复制代码][copycode.gif]

![29162936-630167d6b6514c6c9fb8f8446b5cd251.png][]

## AnticipateOvershootInterpolator ##

![复制代码][copycode.gif]

/**
     * 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);
        }
    }

![复制代码][copycode.gif]

![29163126-ca9aa8f0018e46ec839430f3c818a0e8.png][]

## BounceInterpolator ##

![复制代码][copycode.gif]

/**
     * 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;
        }
    }

![复制代码][copycode.gif]

![29163251-7079b1bb27c844aa8d007e6899688c2b.png][]

## CycleInterpolator ##

![复制代码][copycode.gif]

/**
     * 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;
    }

![复制代码][copycode.gif]

参数为2时的曲线：

![29163456-495a2721492946f4a4d894443491e4d6.png][]

## DecelerateInterpolator ##

![复制代码][copycode.gif]

/**
     * 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;
    }

![复制代码][copycode.gif]

![29163621-d9ecec56e54a4416a3cbed447f36379b.png][]

## LinearInterpolator ##

![复制代码][copycode.gif]

/**
     * 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;
        }
    }

![复制代码][copycode.gif]

![29163734-b31e9a2dcf84435288ba9188ca81c05a.png][]

## OvershootInterpolator ##

![复制代码][copycode.gif]

/**
     * 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;
        }
    }

![复制代码][copycode.gif]

![29163839-66d3e2c296814c20848807cd05ae63f1.png][]

## 项目链接： ##

[https://github.com/mengdd/HelloInterpolator.git][https_github.com_mengdd_HelloInterpolator.git]

[copycode.gif]: /images/20220613/ec7c11e96b5040fa932646bec4deecdf.png
[29162553-398804596d514dd795c2f19539148ca2.png]: /images/20220613/2a55a410d79948b8b2d010e84b8e263c.png
[29162735-9d46b2da759e4b668a5209557b6ee115.png]: /images/20220613/3a80d249f8794209b811ec6be1cbae91.png
[29162936-630167d6b6514c6c9fb8f8446b5cd251.png]: /images/20220613/32ae0576104f4b1fad93d0f28e9041e4.png
[29163126-ca9aa8f0018e46ec839430f3c818a0e8.png]: /images/20220613/b558701234aa4514a5bc2f5a18f6cfe4.png
[29163251-7079b1bb27c844aa8d007e6899688c2b.png]: /images/20220613/22a40160703945deb57b992f470a58fc.png
[29163456-495a2721492946f4a4d894443491e4d6.png]: /images/20220613/1cc214b6a98a4b7c8294eb17341d7e02.png
[29163621-d9ecec56e54a4416a3cbed447f36379b.png]: /images/20220613/1bcbc0b50e98435ca635398e3b946eb7.png
[29163734-b31e9a2dcf84435288ba9188ca81c05a.png]: /images/20220613/e993c330fd39420db3633cb054d4f1c0.png
[29163839-66d3e2c296814c20848807cd05ae63f1.png]: /images/20220613/e767837c21264dbd975763e2e6674b7f.png
[https_github.com_mengdd_HelloInterpolator.git]: https://github.com/mengdd/HelloInterpolator.git