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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
// (C) Copyright 2017, Google Inc.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <memory>
#include "tabvector.h"
#include "include_gunit.h"
namespace tesseract {
class TabVectorTest : public testing::Test {
protected:
void SetUp() override {
std::locale::global(std::locale(""));
vector_.reset();
}
void TearDown() override {}
void MakeSimpleTabVector(int x1, int y1, int x2, int y2) {
vector_ = std::make_unique<TabVector>();
vector_->set_startpt(ICOORD(x1, y1));
vector_->set_endpt(ICOORD(x2, y2));
}
std::unique_ptr<TabVector> vector_;
};
TEST_F(TabVectorTest, SetStartEndPointsMatch) {
vector_ = std::make_unique<TabVector>();
ICOORD start(51, 65);
ICOORD end(7568, 234);
// Test coordinates individually to avoid adding an ostream operator
// explicitly to the ICOORD class (Droid doesn't support it).
vector_->set_startpt(start);
EXPECT_EQ(start.x(), vector_->startpt().x());
EXPECT_EQ(start.y(), vector_->startpt().y());
vector_->set_endpt(end);
EXPECT_EQ(end.x(), vector_->endpt().x());
EXPECT_EQ(end.y(), vector_->endpt().y());
}
TEST_F(TabVectorTest, XAtY45DegreeSlopeInRangeExact) {
MakeSimpleTabVector(0, 0, 100, 100);
for (int y = 0; y <= 100; ++y) {
int x = vector_->XAtY(y);
EXPECT_EQ(y, x);
}
}
TEST_F(TabVectorTest, XAtYVerticalInRangeExact) {
const int x = 120; // Arbitrary choice
MakeSimpleTabVector(x, 0, x, 100);
for (int y = 0; y <= 100; ++y) {
int result_x = vector_->XAtY(y);
EXPECT_EQ(x, result_x);
}
}
TEST_F(TabVectorTest, XAtYHorizontal) {
const int y = 76; // arbitrary
MakeSimpleTabVector(0, y, 100, y);
EXPECT_EQ(0, vector_->XAtY(y));
// TODO(nbeato): What's the failure condition?
// Undefined! Should not pass! Allow until resolved answer.
EXPECT_EQ(0, vector_->XAtY(10));
}
TEST_F(TabVectorTest, XAtYRoundingSimple) {
MakeSimpleTabVector(0, 0, 2, 10000);
int x = vector_->XAtY(1);
EXPECT_EQ(0, x);
x = vector_->XAtY(4999);
EXPECT_EQ(0, x);
x = vector_->XAtY(5001);
EXPECT_EQ(1, x);
x = vector_->XAtY(9999);
EXPECT_EQ(1, x);
}
TEST_F(TabVectorTest, XAtYLargeNumbers) {
// Assume a document is 800 DPI,
// the width of a page is 10 inches across (8000 pixels), and
// the height of the page is 15 inches (12000 pixels).
MakeSimpleTabVector(7804, 504, 7968, 11768); // Arbitrary for vertical line
int x = vector_->XAtY(6136); // test mid point
EXPECT_EQ(7886, x);
}
TEST_F(TabVectorTest, XAtYHorizontalInRangeExact) {
const int y = 120; // Arbitrary choice
MakeSimpleTabVector(50, y, 150, y);
int x = vector_->XAtY(y);
EXPECT_EQ(50, x);
}
TEST_F(TabVectorTest, VOverlapInRangeSimple) {
MakeSimpleTabVector(0, 0, 100, 100);
int overlap = vector_->VOverlap(90, 10);
EXPECT_EQ(80, overlap);
overlap = vector_->VOverlap(100, 0);
EXPECT_EQ(100, overlap);
}
TEST_F(TabVectorTest, VOverlapOutOfRange) {
MakeSimpleTabVector(0, 10, 100, 90);
int overlap = vector_->VOverlap(100, 0);
EXPECT_EQ(80, overlap);
}
TEST_F(TabVectorTest, XYFlip) {
MakeSimpleTabVector(1, 2, 3, 4);
vector_->XYFlip();
EXPECT_EQ(2, vector_->startpt().x());
EXPECT_EQ(1, vector_->startpt().y());
EXPECT_EQ(4, vector_->endpt().x());
EXPECT_EQ(3, vector_->endpt().y());
}
} // namespace tesseract
|
