1 package com.github.mikephil.charting.animation; 2 3 import android.animation.TimeInterpolator; 4 import androidx.annotation.RequiresApi; 5 6 /** 7 * Easing options. 8 * 9 * @author Daniel Cohen Gindi 10 * @author Mick Ashton 11 */ 12 @SuppressWarnings("WeakerAccess") 13 @RequiresApi(11) 14 public class Easing { 15 16 public interface EasingFunction extends TimeInterpolator { 17 @Override getInterpolation(float input)18 float getInterpolation(float input); 19 } 20 21 private static final float DOUBLE_PI = 2f * (float) Math.PI; 22 23 @SuppressWarnings("unused") 24 public static final EasingFunction Linear = new EasingFunction() { 25 public float getInterpolation(float input) { 26 return input; 27 } 28 }; 29 30 @SuppressWarnings("unused") 31 public static final EasingFunction EaseInQuad = new EasingFunction() { 32 public float getInterpolation(float input) { 33 return input * input; 34 } 35 }; 36 37 @SuppressWarnings("unused") 38 public static final EasingFunction EaseOutQuad = new EasingFunction() { 39 public float getInterpolation(float input) { 40 return -input * (input - 2f); 41 } 42 }; 43 44 @SuppressWarnings("unused") 45 public static final EasingFunction EaseInOutQuad = new EasingFunction() { 46 public float getInterpolation(float input) { 47 input *= 2f; 48 49 if (input < 1f) { 50 return 0.5f * input * input; 51 } 52 53 return -0.5f * ((--input) * (input - 2f) - 1f); 54 } 55 }; 56 57 @SuppressWarnings("unused") 58 public static final EasingFunction EaseInCubic = new EasingFunction() { 59 public float getInterpolation(float input) { 60 return (float) Math.pow(input, 3); 61 } 62 }; 63 64 @SuppressWarnings("unused") 65 public static final EasingFunction EaseOutCubic = new EasingFunction() { 66 public float getInterpolation(float input) { 67 input--; 68 return (float) Math.pow(input, 3) + 1f; 69 } 70 }; 71 72 @SuppressWarnings("unused") 73 public static final EasingFunction EaseInOutCubic = new EasingFunction() { 74 public float getInterpolation(float input) { 75 input *= 2f; 76 if (input < 1f) { 77 return 0.5f * (float) Math.pow(input, 3); 78 } 79 input -= 2f; 80 return 0.5f * ((float) Math.pow(input, 3) + 2f); 81 } 82 }; 83 84 @SuppressWarnings("unused") 85 public static final EasingFunction EaseInQuart = new EasingFunction() { 86 87 public float getInterpolation(float input) { 88 return (float) Math.pow(input, 4); 89 } 90 }; 91 92 @SuppressWarnings("unused") 93 public static final EasingFunction EaseOutQuart = new EasingFunction() { 94 public float getInterpolation(float input) { 95 input--; 96 return -((float) Math.pow(input, 4) - 1f); 97 } 98 }; 99 100 @SuppressWarnings("unused") 101 public static final EasingFunction EaseInOutQuart = new EasingFunction() { 102 public float getInterpolation(float input) { 103 input *= 2f; 104 if (input < 1f) { 105 return 0.5f * (float) Math.pow(input, 4); 106 } 107 input -= 2f; 108 return -0.5f * ((float) Math.pow(input, 4) - 2f); 109 } 110 }; 111 112 @SuppressWarnings("unused") 113 public static final EasingFunction EaseInSine = new EasingFunction() { 114 public float getInterpolation(float input) { 115 return -(float) Math.cos(input * (Math.PI / 2f)) + 1f; 116 } 117 }; 118 119 @SuppressWarnings("unused") 120 public static final EasingFunction EaseOutSine = new EasingFunction() { 121 public float getInterpolation(float input) { 122 return (float) Math.sin(input * (Math.PI / 2f)); 123 } 124 }; 125 126 @SuppressWarnings("unused") 127 public static final EasingFunction EaseInOutSine = new EasingFunction() { 128 public float getInterpolation(float input) { 129 return -0.5f * ((float) Math.cos(Math.PI * input) - 1f); 130 } 131 }; 132 133 @SuppressWarnings("unused") 134 public static final EasingFunction EaseInExpo = new EasingFunction() { 135 public float getInterpolation(float input) { 136 return (input == 0) ? 0f : (float) Math.pow(2f, 10f * (input - 1f)); 137 } 138 }; 139 140 @SuppressWarnings("unused") 141 public static final EasingFunction EaseOutExpo = new EasingFunction() { 142 public float getInterpolation(float input) { 143 return (input == 1f) ? 1f : (-(float) Math.pow(2f, -10f * (input + 1f))); 144 } 145 }; 146 147 @SuppressWarnings("unused") 148 public static final EasingFunction EaseInOutExpo = new EasingFunction() { 149 public float getInterpolation(float input) { 150 if (input == 0) { 151 return 0f; 152 } else if (input == 1f) { 153 return 1f; 154 } 155 156 input *= 2f; 157 if (input < 1f) { 158 return 0.5f * (float) Math.pow(2f, 10f * (input - 1f)); 159 } 160 return 0.5f * (-(float) Math.pow(2f, -10f * --input) + 2f); 161 } 162 }; 163 164 @SuppressWarnings("unused") 165 public static final EasingFunction EaseInCirc = new EasingFunction() { 166 public float getInterpolation(float input) { 167 return -((float) Math.sqrt(1f - input * input) - 1f); 168 } 169 }; 170 171 @SuppressWarnings("unused") 172 public static final EasingFunction EaseOutCirc = new EasingFunction() { 173 public float getInterpolation(float input) { 174 input--; 175 return (float) Math.sqrt(1f - input * input); 176 } 177 }; 178 179 @SuppressWarnings("unused") 180 public static final EasingFunction EaseInOutCirc = new EasingFunction() { 181 public float getInterpolation(float input) { 182 input *= 2f; 183 if (input < 1f) { 184 return -0.5f * ((float) Math.sqrt(1f - input * input) - 1f); 185 } 186 return 0.5f * ((float) Math.sqrt(1f - (input -= 2f) * input) + 1f); 187 } 188 }; 189 190 @SuppressWarnings("unused") 191 public static final EasingFunction EaseInElastic = new EasingFunction() { 192 public float getInterpolation(float input) { 193 if (input == 0) { 194 return 0f; 195 } else if (input == 1) { 196 return 1f; 197 } 198 199 float p = 0.3f; 200 float s = p / DOUBLE_PI * (float) Math.asin(1f); 201 return -((float) Math.pow(2f, 10f * (input -= 1f)) 202 *(float) Math.sin((input - s) * DOUBLE_PI / p)); 203 } 204 }; 205 206 @SuppressWarnings("unused") 207 public static final EasingFunction EaseOutElastic = new EasingFunction() { 208 public float getInterpolation(float input) { 209 if (input == 0) { 210 return 0f; 211 } else if (input == 1) { 212 return 1f; 213 } 214 215 float p = 0.3f; 216 float s = p / DOUBLE_PI * (float) Math.asin(1f); 217 return 1f 218 + (float) Math.pow(2f, -10f * input) 219 * (float) Math.sin((input - s) * DOUBLE_PI / p); 220 } 221 }; 222 223 @SuppressWarnings("unused") 224 public static final EasingFunction EaseInOutElastic = new EasingFunction() { 225 public float getInterpolation(float input) { 226 if (input == 0) { 227 return 0f; 228 } 229 230 input *= 2f; 231 if (input == 2) { 232 return 1f; 233 } 234 235 float p = 1f / 0.45f; 236 float s = 0.45f / DOUBLE_PI * (float) Math.asin(1f); 237 if (input < 1f) { 238 return -0.5f 239 * ((float) Math.pow(2f, 10f * (input -= 1f)) 240 * (float) Math.sin((input * 1f - s) * DOUBLE_PI * p)); 241 } 242 return 1f + 0.5f 243 * (float) Math.pow(2f, -10f * (input -= 1f)) 244 * (float) Math.sin((input * 1f - s) * DOUBLE_PI * p); 245 } 246 }; 247 248 @SuppressWarnings("unused") 249 public static final EasingFunction EaseInBack = new EasingFunction() { 250 public float getInterpolation(float input) { 251 final float s = 1.70158f; 252 return input * input * ((s + 1f) * input - s); 253 } 254 }; 255 256 @SuppressWarnings("unused") 257 public static final EasingFunction EaseOutBack = new EasingFunction() { 258 public float getInterpolation(float input) { 259 final float s = 1.70158f; 260 input--; 261 return (input * input * ((s + 1f) * input + s) + 1f); 262 } 263 }; 264 265 @SuppressWarnings("unused") 266 public static final EasingFunction EaseInOutBack = new EasingFunction() { 267 public float getInterpolation(float input) { 268 float s = 1.70158f; 269 input *= 2f; 270 if (input < 1f) { 271 return 0.5f * (input * input * (((s *= (1.525f)) + 1f) * input - s)); 272 } 273 return 0.5f * ((input -= 2f) * input * (((s *= (1.525f)) + 1f) * input + s) + 2f); 274 } 275 }; 276 277 @SuppressWarnings("unused") 278 public static final EasingFunction EaseInBounce = new EasingFunction() { 279 public float getInterpolation(float input) { 280 return 1f - EaseOutBounce.getInterpolation(1f - input); 281 } 282 }; 283 284 @SuppressWarnings("unused") 285 public static final EasingFunction EaseOutBounce = new EasingFunction() { 286 public float getInterpolation(float input) { 287 float s = 7.5625f; 288 if (input < (1f / 2.75f)) { 289 return s * input * input; 290 } else if (input < (2f / 2.75f)) { 291 return s * (input -= (1.5f / 2.75f)) * input + 0.75f; 292 } else if (input < (2.5f / 2.75f)) { 293 return s * (input -= (2.25f / 2.75f)) * input + 0.9375f; 294 } 295 return s * (input -= (2.625f / 2.75f)) * input + 0.984375f; 296 } 297 }; 298 299 @SuppressWarnings("unused") 300 public static final EasingFunction EaseInOutBounce = new EasingFunction() { 301 public float getInterpolation(float input) { 302 if (input < 0.5f) { 303 return EaseInBounce.getInterpolation(input * 2f) * 0.5f; 304 } 305 return EaseOutBounce.getInterpolation(input * 2f - 1f) * 0.5f + 0.5f; 306 } 307 }; 308 309 } 310