202 lines
8.1 KiB
Java
202 lines
8.1 KiB
Java
package com.kofax.kmc.kut.utilities;
|
|
|
|
import android.graphics.Point;
|
|
import android.graphics.Rect;
|
|
import com.kofax.kmc.ken.engines.data.BoundingTetragon;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.List;
|
|
|
|
/* loaded from: classes3.dex */
|
|
public final class RectUtil {
|
|
public static final void fit(Rect rect, Rect rect2, Point point, double d, double d2) throws IllegalArgumentException {
|
|
double d3;
|
|
double d4;
|
|
if (rect == null || rect.width() <= 0 || rect.height() <= 0) {
|
|
throw new IllegalArgumentException("outer rect cannot be null or empty");
|
|
}
|
|
if (rect2 == null) {
|
|
throw new IllegalArgumentException("inner rect cannot be null");
|
|
}
|
|
double c = c(d) * 0.02d;
|
|
double width = rect.width() - (rect.width() * c);
|
|
double height = rect.height() - (rect.height() * c);
|
|
int round = (int) Math.round((rect.width() - width) / 2.0d);
|
|
int round2 = (int) Math.round(round + width);
|
|
int round3 = (int) Math.round((rect.height() - height) / 2.0d);
|
|
int round4 = (int) Math.round(round3 + height);
|
|
if (point.x <= round || point.x >= round2) {
|
|
throw new IllegalArgumentException("center.x is not inside outer, less padding");
|
|
}
|
|
if (point.y <= round3 || point.y >= round4) {
|
|
throw new IllegalArgumentException("center.y is not inside outer, less padding");
|
|
}
|
|
double min = Math.min(point.x - round, round2 - point.x) << 1;
|
|
double min2 = Math.min(point.y - round3, round4 - point.y) << 1;
|
|
if (0.0d >= d2 || d2 >= 1.0d) {
|
|
if (d2 > 1.0d) {
|
|
d4 = min / d2;
|
|
d3 = min;
|
|
} else if (d2 == 1.0d) {
|
|
d3 = min > min2 ? min2 : min;
|
|
d4 = d3;
|
|
} else {
|
|
d3 = min;
|
|
}
|
|
if (d3 <= min || d4 > min2) {
|
|
double min3 = Math.min(min / d3, min2 / d4);
|
|
d3 *= min3;
|
|
d4 *= min3;
|
|
}
|
|
int round5 = (int) Math.round(point.x - (d3 / 2.0d));
|
|
int round6 = (int) Math.round(point.y - (d4 / 2.0d));
|
|
rect2.set(round5, round6, (int) Math.round(round5 + d3), (int) Math.round(round6 + d4));
|
|
}
|
|
d3 = d2 * min2;
|
|
d4 = min2;
|
|
if (d3 <= min) {
|
|
}
|
|
double min32 = Math.min(min / d3, min2 / d4);
|
|
d3 *= min32;
|
|
d4 *= min32;
|
|
int round52 = (int) Math.round(point.x - (d3 / 2.0d));
|
|
int round62 = (int) Math.round(point.y - (d4 / 2.0d));
|
|
rect2.set(round52, round62, (int) Math.round(round52 + d3), (int) Math.round(round62 + d4));
|
|
}
|
|
|
|
public static boolean containsPoint(Point point, Rect rect, double d) {
|
|
if (point == null) {
|
|
throw new IllegalArgumentException("point is null");
|
|
}
|
|
if (rect == null) {
|
|
throw new IllegalArgumentException("rect is null");
|
|
}
|
|
double c = c(d) * 0.02d;
|
|
double width = rect.width() - (rect.width() * c);
|
|
double height = rect.height() - (rect.height() * c);
|
|
int round = (int) Math.round((rect.width() - width) / 2.0d);
|
|
int round2 = (int) Math.round(round + width);
|
|
int round3 = (int) Math.round((rect.height() - height) / 2.0d);
|
|
return round < point.x && point.x < round2 && round3 < point.y && point.y < ((int) Math.round(((double) round3) + height));
|
|
}
|
|
|
|
private static double c(double d) {
|
|
return Math.min(Math.max(d, 0.0d), 50.0d);
|
|
}
|
|
|
|
public static List<Point> sort(Point point, Point point2, Point point3, Point point4, Rect rect) {
|
|
if (rect == null) {
|
|
rect = new Rect();
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
arrayList.add(point);
|
|
arrayList.add(point2);
|
|
arrayList.add(point3);
|
|
arrayList.add(point4);
|
|
List<Point> sort = sort(arrayList, rect);
|
|
Collections.swap(sort, 0, 3);
|
|
Collections.swap(sort, 1, 2);
|
|
return sort;
|
|
}
|
|
|
|
public static List<Point> sort(List<Point> list, Rect rect) {
|
|
bound(list, rect);
|
|
Collections.sort(list, new a(new Point(rect.centerX(), rect.centerY())));
|
|
return list;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes3.dex */
|
|
public static class a implements Comparator<Point> {
|
|
private final Point nS;
|
|
|
|
public a(Point point) {
|
|
if (point == null) {
|
|
throw new IllegalArgumentException("center cannot be null");
|
|
}
|
|
this.nS = point;
|
|
}
|
|
|
|
@Override // java.util.Comparator
|
|
/* renamed from: f, reason: merged with bridge method [inline-methods] */
|
|
public int compare(Point point, Point point2) {
|
|
if (point == null || point2 == null) {
|
|
throw new IllegalArgumentException("neither a nor b can be null");
|
|
}
|
|
if (point.x - this.nS.x >= 0 && point2.x - this.nS.x < 0) {
|
|
return -1;
|
|
}
|
|
if (point.x - this.nS.x < 0 && point2.x - this.nS.x >= 0) {
|
|
return 1;
|
|
}
|
|
if (point.x - this.nS.x == 0 && point2.x - this.nS.x == 0) {
|
|
return (point.y - this.nS.y >= 0 || point2.y - this.nS.y >= 0) ? point.y <= point2.y ? 1 : -1 : point2.y > point.y ? 1 : -1;
|
|
}
|
|
int i = ((point.x - this.nS.x) * (point2.y - this.nS.y)) - ((point2.x - this.nS.x) * (point.y - this.nS.y));
|
|
if (i < 0) {
|
|
return -1;
|
|
}
|
|
if (i > 0) {
|
|
return 1;
|
|
}
|
|
return ((point.x - this.nS.x) * (point.x - this.nS.x)) + ((point.y - this.nS.y) * (point.y - this.nS.y)) > ((point2.x - this.nS.x) * (point2.x - this.nS.x)) + ((point2.y - this.nS.y) * (point2.y - this.nS.y)) ? 1 : -1;
|
|
}
|
|
}
|
|
|
|
public static void bound(List<Point> list, Rect rect) {
|
|
if (list == null || list.size() != 4) {
|
|
throw new IllegalArgumentException("points list must be of size equal to 4");
|
|
}
|
|
if (list.indexOf(null) != -1) {
|
|
throw new IllegalArgumentException("No point in points may be null");
|
|
}
|
|
if (rect == null) {
|
|
throw new IllegalArgumentException("bound may not be null");
|
|
}
|
|
Point point = list.get(0);
|
|
Point point2 = list.get(1);
|
|
Point point3 = list.get(2);
|
|
Point point4 = list.get(3);
|
|
rect.set(Math.min(point.x, Math.min(Math.min(point2.x, point3.x), point4.x)), Math.min(point.y, Math.min(Math.min(point2.y, point3.y), point4.y)), Math.max(point.x, Math.max(Math.max(point2.x, point3.x), point4.x)), Math.max(point.y, Math.max(Math.max(point2.y, point3.y), point4.y)));
|
|
}
|
|
|
|
public static Rect scale(Rect rect, double d, double d2) {
|
|
rect.left = (int) (rect.left * d);
|
|
rect.right = (int) (rect.right * d);
|
|
rect.top = (int) (rect.top * d2);
|
|
rect.bottom = (int) (rect.bottom * d2);
|
|
return rect;
|
|
}
|
|
|
|
public static Rect createTargetRect(double d, double d2, Point point, int i, int i2) {
|
|
Point point2;
|
|
if (i < i2 && d2 != 0.0d) {
|
|
d2 = 1.0d / d2;
|
|
}
|
|
double d3 = d2;
|
|
Rect rect = new Rect(0, 0, i, i2);
|
|
Point point3 = new Point();
|
|
if (point == null) {
|
|
point3.set((int) Math.round(i / 2.0d), (int) Math.round(i2 / 2.0d));
|
|
point2 = point3;
|
|
} else {
|
|
point2 = point;
|
|
}
|
|
if (!containsPoint(point2, rect, d)) {
|
|
throw new IllegalArgumentException("target frame is invalid: the center point is not inside the area defined by the padding");
|
|
}
|
|
Rect rect2 = new Rect();
|
|
fit(rect, rect2, point2, d, d3);
|
|
return rect2;
|
|
}
|
|
|
|
public static BoundingTetragon buildBoundingTetragon(List<Point> list) {
|
|
if (list == null || list.size() != 4) {
|
|
return null;
|
|
}
|
|
List<Point> sort = sort(list.get(0), list.get(1), list.get(2), list.get(3), null);
|
|
return new BoundingTetragon(sort.get(1), sort.get(2), sort.get(0), sort.get(3));
|
|
}
|
|
}
|