-
Notifications
You must be signed in to change notification settings - Fork 5
/
AbstractFields.java
94 lines (71 loc) · 2.96 KB
/
AbstractFields.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package org.genericsystem.cv.retriever;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.genericsystem.cv.Img;
import org.opencv.core.Mat;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
public abstract class AbstractFields<F extends AbstractField> implements Iterable<F> {
protected List<F> fields;
protected static final double MIN_SIMILARITY = 0.90;
protected static final double OVERLAP_THRESHOLD = 0.30;
protected static final double OVERLAP_CONFIDENCE = 0.90;
public AbstractFields() {
this.fields = new ArrayList<>();
}
public AbstractFields(List<F> fields) {
this.fields = fields;
}
protected List<F> findMatchingFieldsWithConfidence(F field, double threshold) {
return fields.stream().filter(f -> f.overlapsMoreThanThresh(field.getRect(), threshold)).collect(Collectors.toList());
}
protected List<F> findClusteredFields(F field, double epsilon) {
return fields.stream().filter(f -> f.isClusteredWith(field.getRect(), epsilon)).collect(Collectors.toList());
}
protected List<F> findPossibleMatches(Rect rect, double epsilon) {
return fields.stream().filter(f -> f.isClusteredWith(rect, epsilon)).collect(Collectors.toList());
}
// like findPossibleMatches(Rect, double) but will match only a number of sides (e.g., 3 instead of 4 sides)
protected List<F> findPossibleMatches(Rect rect, double epsilon, int sides) {
return fields.stream().filter(f -> f.isClusteredWith(rect, epsilon, sides)).collect(Collectors.toList());
}
protected List<F> findContainingFields(F field) {
return stream().filter(f -> field.isIn(f)).collect(Collectors.toList());
}
protected List<F> findContainedFields(F field) {
return stream().filter(f -> f.isIn(field)).collect(Collectors.toList());
}
protected F findNewField(Point pt) {
return stream().filter(field -> field.contains(pt)).findFirst().orElse(null);
}
public abstract void performOcr(Img rootImg);
public void drawOcrPerspectiveInverse(Img display, Mat homography, Scalar color, int thickness) {
stream()./* filter(field -> field.getDeadCounter() == 0). */forEach(field -> field.drawOcrPerspectiveInverse(display, homography, color, thickness));
}
public void drawFieldsOnStabilized(Img stabilized) {
stream().forEach(f -> f.drawRect(stabilized, f.getDeadCounter() < 1 ? new Scalar(0, 255, 0) : new Scalar(0, 0, 255), 1));
}
public void drawConsolidated(Img stabilizedDisplay) {
consolidatedFieldStream().forEach(field -> field.drawRect(stabilizedDisplay, new Scalar(0, 255, 0), 1));
}
// public Stream<F> randomOcrStream() {
// return stream().filter(F::needOcr);
// }
public Stream<F> consolidatedFieldStream() {
return stream().filter(f -> f.isConsolidated());
}
public Stream<F> stream() {
return fields.stream();
}
@Override
public Iterator<F> iterator() {
return fields.iterator();
}
public int size() {
return fields.size();
}
}