376 lines
13 KiB
Java
376 lines
13 KiB
Java
package androidx.constraintlayout.motion.utils;
|
|
|
|
import com.google.android.material.shadow.ShadowDrawableWrapper;
|
|
import java.util.Arrays;
|
|
public class ArcCurveFit extends CurveFit {
|
|
public static final int ARC_START_FLIP = 3;
|
|
public static final int ARC_START_HORIZONTAL = 2;
|
|
public static final int ARC_START_LINEAR = 0;
|
|
public static final int ARC_START_VERTICAL = 1;
|
|
private static final int START_HORIZONTAL = 2;
|
|
private static final int START_LINEAR = 3;
|
|
private static final int START_VERTICAL = 1;
|
|
public Arc[] mArcs;
|
|
private final double[] mTime;
|
|
|
|
public static class Arc {
|
|
private static final double EPSILON = 0.001d;
|
|
private static final String TAG = "Arc";
|
|
private static double[] ourPercent = new double[91];
|
|
public boolean linear = false;
|
|
public double mArcDistance;
|
|
public double mArcVelocity;
|
|
public double mEllipseA;
|
|
public double mEllipseB;
|
|
public double mEllipseCenterX;
|
|
public double mEllipseCenterY;
|
|
public double[] mLut;
|
|
public double mOneOverDeltaTime;
|
|
public double mTime1;
|
|
public double mTime2;
|
|
public double mTmpCosAngle;
|
|
public double mTmpSinAngle;
|
|
public boolean mVertical;
|
|
public double mX1;
|
|
public double mX2;
|
|
public double mY1;
|
|
public double mY2;
|
|
|
|
public Arc(int i, double d, double d2, double d3, double d4, double d5, double d6) {
|
|
boolean z2 = false;
|
|
int i2 = 1;
|
|
this.mVertical = i == 1 ? true : z2;
|
|
this.mTime1 = d;
|
|
this.mTime2 = d2;
|
|
this.mOneOverDeltaTime = 1.0d / (d2 - d);
|
|
if (3 == i) {
|
|
this.linear = true;
|
|
}
|
|
double d7 = d5 - d3;
|
|
double d8 = d6 - d4;
|
|
if (this.linear || Math.abs(d7) < EPSILON || Math.abs(d8) < EPSILON) {
|
|
this.linear = true;
|
|
this.mX1 = d3;
|
|
this.mX2 = d5;
|
|
this.mY1 = d4;
|
|
this.mY2 = d6;
|
|
double hypot = Math.hypot(d8, d7);
|
|
this.mArcDistance = hypot;
|
|
this.mArcVelocity = hypot * this.mOneOverDeltaTime;
|
|
double d9 = this.mTime2;
|
|
double d10 = this.mTime1;
|
|
this.mEllipseCenterX = d7 / (d9 - d10);
|
|
this.mEllipseCenterY = d8 / (d9 - d10);
|
|
return;
|
|
}
|
|
this.mLut = new double[101];
|
|
boolean z3 = this.mVertical;
|
|
this.mEllipseA = d7 * ((double) (z3 ? -1 : 1));
|
|
this.mEllipseB = d8 * ((double) (!z3 ? -1 : i2));
|
|
this.mEllipseCenterX = z3 ? d5 : d3;
|
|
this.mEllipseCenterY = z3 ? d4 : d6;
|
|
buildTable(d3, d4, d5, d6);
|
|
this.mArcVelocity = this.mArcDistance * this.mOneOverDeltaTime;
|
|
}
|
|
|
|
private void buildTable(double d, double d2, double d3, double d4) {
|
|
double d5;
|
|
double d6 = d3 - d;
|
|
double d7 = d2 - d4;
|
|
int i = 0;
|
|
double d8 = ShadowDrawableWrapper.COS_45;
|
|
double d9 = ShadowDrawableWrapper.COS_45;
|
|
double d10 = ShadowDrawableWrapper.COS_45;
|
|
while (true) {
|
|
double[] dArr = ourPercent;
|
|
if (i >= dArr.length) {
|
|
break;
|
|
}
|
|
double radians = Math.toRadians((((double) i) * 90.0d) / ((double) (dArr.length - 1)));
|
|
double sin = Math.sin(radians) * d6;
|
|
double cos = Math.cos(radians) * d7;
|
|
if (i > 0) {
|
|
d5 = Math.hypot(sin - d9, cos - d10) + d8;
|
|
ourPercent[i] = d5;
|
|
} else {
|
|
d5 = d8;
|
|
}
|
|
i++;
|
|
d10 = cos;
|
|
d8 = d5;
|
|
d9 = sin;
|
|
}
|
|
this.mArcDistance = d8;
|
|
int i2 = 0;
|
|
while (true) {
|
|
double[] dArr2 = ourPercent;
|
|
if (i2 >= dArr2.length) {
|
|
break;
|
|
}
|
|
dArr2[i2] = dArr2[i2] / d8;
|
|
i2++;
|
|
}
|
|
int i3 = 0;
|
|
while (true) {
|
|
double[] dArr3 = this.mLut;
|
|
if (i3 < dArr3.length) {
|
|
double length = ((double) i3) / ((double) (dArr3.length - 1));
|
|
int binarySearch = Arrays.binarySearch(ourPercent, length);
|
|
if (binarySearch >= 0) {
|
|
this.mLut[i3] = (double) (binarySearch / (ourPercent.length - 1));
|
|
} else if (binarySearch == -1) {
|
|
this.mLut[i3] = 0.0d;
|
|
} else {
|
|
int i4 = -binarySearch;
|
|
int i5 = i4 - 2;
|
|
double[] dArr4 = ourPercent;
|
|
this.mLut[i3] = (((length - dArr4[i5]) / (dArr4[i4 - 1] - dArr4[i5])) + ((double) i5)) / ((double) (dArr4.length - 1));
|
|
}
|
|
i3++;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public double getDX() {
|
|
double d = this.mEllipseA * this.mTmpCosAngle;
|
|
double hypot = this.mArcVelocity / Math.hypot(d, (-this.mEllipseB) * this.mTmpSinAngle);
|
|
if (this.mVertical) {
|
|
d = -d;
|
|
}
|
|
return d * hypot;
|
|
}
|
|
|
|
public double getDY() {
|
|
double d = this.mEllipseA * this.mTmpCosAngle;
|
|
double d2 = (-this.mEllipseB) * this.mTmpSinAngle;
|
|
double hypot = this.mArcVelocity / Math.hypot(d, d2);
|
|
return this.mVertical ? (-d2) * hypot : d2 * hypot;
|
|
}
|
|
|
|
public double getLinearDX(double d) {
|
|
return this.mEllipseCenterX;
|
|
}
|
|
|
|
public double getLinearDY(double d) {
|
|
return this.mEllipseCenterY;
|
|
}
|
|
|
|
public double getLinearX(double d) {
|
|
double d2 = (d - this.mTime1) * this.mOneOverDeltaTime;
|
|
double d3 = this.mX1;
|
|
return ((this.mX2 - d3) * d2) + d3;
|
|
}
|
|
|
|
public double getLinearY(double d) {
|
|
double d2 = (d - this.mTime1) * this.mOneOverDeltaTime;
|
|
double d3 = this.mY1;
|
|
return ((this.mY2 - d3) * d2) + d3;
|
|
}
|
|
|
|
public double getX() {
|
|
return (this.mEllipseA * this.mTmpSinAngle) + this.mEllipseCenterX;
|
|
}
|
|
|
|
public double getY() {
|
|
return (this.mEllipseB * this.mTmpCosAngle) + this.mEllipseCenterY;
|
|
}
|
|
|
|
public double lookup(double d) {
|
|
if (d <= ShadowDrawableWrapper.COS_45) {
|
|
return ShadowDrawableWrapper.COS_45;
|
|
}
|
|
if (d >= 1.0d) {
|
|
return 1.0d;
|
|
}
|
|
double[] dArr = this.mLut;
|
|
double length = d * ((double) (dArr.length - 1));
|
|
int i = (int) length;
|
|
double d2 = length - ((double) i);
|
|
return ((dArr[i + 1] - dArr[i]) * d2) + dArr[i];
|
|
}
|
|
|
|
public void setPoint(double d) {
|
|
double lookup = lookup((this.mVertical ? this.mTime2 - d : d - this.mTime1) * this.mOneOverDeltaTime) * 1.5707963267948966d;
|
|
this.mTmpSinAngle = Math.sin(lookup);
|
|
this.mTmpCosAngle = Math.cos(lookup);
|
|
}
|
|
}
|
|
|
|
public ArcCurveFit(int[] iArr, double[] dArr, double[][] dArr2) {
|
|
this.mTime = dArr;
|
|
this.mArcs = new Arc[(dArr.length - 1)];
|
|
int i = 0;
|
|
int i2 = 1;
|
|
int i3 = 1;
|
|
while (true) {
|
|
Arc[] arcArr = this.mArcs;
|
|
if (i < arcArr.length) {
|
|
int i4 = iArr[i];
|
|
if (i4 == 0) {
|
|
i3 = 3;
|
|
} else if (i4 == 1) {
|
|
i2 = 1;
|
|
i3 = 1;
|
|
} else if (i4 == 2) {
|
|
i2 = 2;
|
|
i3 = 2;
|
|
} else if (i4 == 3) {
|
|
i2 = i2 == 1 ? 2 : 1;
|
|
i3 = i2;
|
|
}
|
|
int i5 = i + 1;
|
|
arcArr[i] = new Arc(i3, dArr[i], dArr[i5], dArr2[i][0], dArr2[i][1], dArr2[i5][0], dArr2[i5][1]);
|
|
i = i5;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.utils.CurveFit
|
|
public double getPos(double d, int i) {
|
|
Arc[] arcArr = this.mArcs;
|
|
int i2 = 0;
|
|
if (d < arcArr[0].mTime1) {
|
|
d = arcArr[0].mTime1;
|
|
} else if (d > arcArr[arcArr.length - 1].mTime2) {
|
|
d = arcArr[arcArr.length - 1].mTime2;
|
|
}
|
|
while (true) {
|
|
Arc[] arcArr2 = this.mArcs;
|
|
if (i2 >= arcArr2.length) {
|
|
return Double.NaN;
|
|
}
|
|
if (d > arcArr2[i2].mTime2) {
|
|
i2++;
|
|
} else if (arcArr2[i2].linear) {
|
|
return i == 0 ? arcArr2[i2].getLinearX(d) : arcArr2[i2].getLinearY(d);
|
|
} else {
|
|
arcArr2[i2].setPoint(d);
|
|
return i == 0 ? this.mArcs[i2].getX() : this.mArcs[i2].getY();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.utils.CurveFit
|
|
public void getPos(double d, double[] dArr) {
|
|
Arc[] arcArr = this.mArcs;
|
|
if (d < arcArr[0].mTime1) {
|
|
d = arcArr[0].mTime1;
|
|
}
|
|
if (d > arcArr[arcArr.length - 1].mTime2) {
|
|
d = arcArr[arcArr.length - 1].mTime2;
|
|
}
|
|
int i = 0;
|
|
while (true) {
|
|
Arc[] arcArr2 = this.mArcs;
|
|
if (i >= arcArr2.length) {
|
|
return;
|
|
}
|
|
if (d > arcArr2[i].mTime2) {
|
|
i++;
|
|
} else if (arcArr2[i].linear) {
|
|
dArr[0] = arcArr2[i].getLinearX(d);
|
|
dArr[1] = this.mArcs[i].getLinearY(d);
|
|
return;
|
|
} else {
|
|
arcArr2[i].setPoint(d);
|
|
dArr[0] = this.mArcs[i].getX();
|
|
dArr[1] = this.mArcs[i].getY();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.utils.CurveFit
|
|
public void getPos(double d, float[] fArr) {
|
|
Arc[] arcArr = this.mArcs;
|
|
if (d < arcArr[0].mTime1) {
|
|
d = arcArr[0].mTime1;
|
|
} else if (d > arcArr[arcArr.length - 1].mTime2) {
|
|
d = arcArr[arcArr.length - 1].mTime2;
|
|
}
|
|
int i = 0;
|
|
while (true) {
|
|
Arc[] arcArr2 = this.mArcs;
|
|
if (i >= arcArr2.length) {
|
|
return;
|
|
}
|
|
if (d > arcArr2[i].mTime2) {
|
|
i++;
|
|
} else if (arcArr2[i].linear) {
|
|
fArr[0] = (float) arcArr2[i].getLinearX(d);
|
|
fArr[1] = (float) this.mArcs[i].getLinearY(d);
|
|
return;
|
|
} else {
|
|
arcArr2[i].setPoint(d);
|
|
fArr[0] = (float) this.mArcs[i].getX();
|
|
fArr[1] = (float) this.mArcs[i].getY();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.utils.CurveFit
|
|
public double getSlope(double d, int i) {
|
|
Arc[] arcArr = this.mArcs;
|
|
int i2 = 0;
|
|
if (d < arcArr[0].mTime1) {
|
|
d = arcArr[0].mTime1;
|
|
}
|
|
if (d > arcArr[arcArr.length - 1].mTime2) {
|
|
d = arcArr[arcArr.length - 1].mTime2;
|
|
}
|
|
while (true) {
|
|
Arc[] arcArr2 = this.mArcs;
|
|
if (i2 >= arcArr2.length) {
|
|
return Double.NaN;
|
|
}
|
|
if (d > arcArr2[i2].mTime2) {
|
|
i2++;
|
|
} else if (arcArr2[i2].linear) {
|
|
return i == 0 ? arcArr2[i2].getLinearDX(d) : arcArr2[i2].getLinearDY(d);
|
|
} else {
|
|
arcArr2[i2].setPoint(d);
|
|
return i == 0 ? this.mArcs[i2].getDX() : this.mArcs[i2].getDY();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.utils.CurveFit
|
|
public void getSlope(double d, double[] dArr) {
|
|
Arc[] arcArr = this.mArcs;
|
|
if (d < arcArr[0].mTime1) {
|
|
d = arcArr[0].mTime1;
|
|
} else if (d > arcArr[arcArr.length - 1].mTime2) {
|
|
d = arcArr[arcArr.length - 1].mTime2;
|
|
}
|
|
int i = 0;
|
|
while (true) {
|
|
Arc[] arcArr2 = this.mArcs;
|
|
if (i >= arcArr2.length) {
|
|
return;
|
|
}
|
|
if (d > arcArr2[i].mTime2) {
|
|
i++;
|
|
} else if (arcArr2[i].linear) {
|
|
dArr[0] = arcArr2[i].getLinearDX(d);
|
|
dArr[1] = this.mArcs[i].getLinearDY(d);
|
|
return;
|
|
} else {
|
|
arcArr2[i].setPoint(d);
|
|
dArr[0] = this.mArcs[i].getDX();
|
|
dArr[1] = this.mArcs[i].getDY();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.motion.utils.CurveFit
|
|
public double[] getTimePoints() {
|
|
return this.mTime;
|
|
}
|
|
}
|