-
Notifications
You must be signed in to change notification settings - Fork 5
/
AbstractFields.java
94 lines (70 loc) · 2.92 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.classifier;
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.Scalar;
public abstract class AbstractFields implements Iterable<AbstractField> {
protected List<AbstractField> 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<AbstractField> fields) {
this.fields = fields;
}
protected abstract AbstractField getIntersection(AbstractField field1, AbstractField field2);
protected abstract AbstractField getUnion(AbstractField field1, AbstractField field2);
protected List<AbstractField> findMatchingFieldsWithConfidence(AbstractField field, double threshold) {
return fields.stream().filter(f -> f.overlapsMoreThanThresh(field.getRect(), threshold)).collect(Collectors.toList());
}
protected List<AbstractField> findClusteredFields(AbstractField field, double epsilon) {
return fields.stream().filter(f -> f.isClusteredWith(field.getRect(), epsilon)).collect(Collectors.toList());
}
protected List<AbstractField> findContainingFields(AbstractField field) {
return stream().filter(f -> field.isIn(f)).collect(Collectors.toList());
}
protected List<AbstractField> findContainedFields(AbstractField field) {
return stream().filter(f -> f.isIn(field)).collect(Collectors.toList());
}
protected AbstractField findNewField(Point pt) {
return stream().filter(field -> field.contains(pt)).findFirst().orElse(null);
}
public void consolidateOcr(Img rootImg) {
randomOcrStream().forEach(f -> f.ocr(rootImg));
}
public void drawRectsPerspective(Img display, Mat homography, Scalar color, int thickness) {
stream().forEach(field -> field.drawRectsPerspective(display, homography, color, thickness));
}
public void drawOcrPerspectiveInverse(Img display, Mat homography, Scalar color, int thickness) {
consolidatedFieldStream().forEach(field -> field.drawOcrPerspectiveInverse(display, homography, color, thickness));
}
public void drawConsolidated(Img stabilizedDisplay) {
consolidatedFieldStream().forEach(field -> field.draw(stabilizedDisplay, new Scalar(0, 0, 255)));
}
public Stream<AbstractField> randomOcrStream() {
return stream().filter(AbstractField::needOcr);
}
public Stream<AbstractField> consolidatedFieldStream() {
return stream().filter(f -> f.isConsolidated());
}
public Stream<AbstractField> stream() {
return fields.stream();
}
public Stream<AbstractField> parallelStream() {
return fields.parallelStream();
}
@Override
public Iterator<AbstractField> iterator() {
return fields.iterator();
}
public int size() {
return fields.size();
}
}