class testMerge(unittest.TestCase):
A = BBox(((-23.5, 456), (56, 532.0)))
B = BBox(((-20.3, 460), (54, 465))) # B should be completely inside A
C = BBox(((-23.5, 456), (58, 540.0))) # up and to the right or A
D = BBox(((-26.5, 12), (56, 532.0)))
def testInside(self):
C = self.A.copy()
C.Merge(self.B)
self.failUnless(C == self.A)
def testFullOutside(self):
C = self.B.copy()
C.Merge(self.A)
self.failUnless(C == self.A)
def testUpRight(self):
A = self.A.copy()
A.Merge(self.C)
self.failUnless(A[0] == self.A[0] and A[1] == self.C[1])
def testDownLeft(self):
A = self.A.copy()
A.Merge(self.D)
self.failUnless(A[0] == self.D[0] and A[1] == self.A[1])
class testNullBBox(unittest.TestCase):
B1 = NullBBox()
B2 = NullBBox()
B3 = BBox( ( (1.0, 2.0), (5.0, 10.0) ) )
def testValues(self):
self.failUnless( np.alltrue(np.isnan(self.B1)) )
def testIsNull(self):
self.failUnless( self.B1.IsNull )
def testEquals(self):
self.failUnless( (self.B1 == self.B2) == True )
def testNotEquals(self):
self.failUnless ( (self.B1 == self.B3) == False,
"NotEquals failed for\n%s,\n %s:%s"%(self.B1, self.B3, (self.B1 == self.B3)) )
def testNotEquals2(self):
self.failUnless ( (self.B3 == self.B1) == False,
"NotEquals failed for\n%s,\n %s:%s"%(self.B3, self.B1, (self.B3 == self.B1)) )
def testMerge(self):
C = self.B1.copy()
C.Merge(self.B3)
self.failUnless( C == self.B3,
"merge failed, got: %s"%C )
def testOverlaps(self):
self.failUnless( self.B1.Overlaps(self.B3) == False)
def testOverlaps2(self):
self.failUnless( self.B3.Overlaps(self.B1) == False)
class testAsPoly(unittest.TestCase):
B = BBox ( ( (5,0), (10,20) ) )
corners = np.array( [( 5., 0.),
( 5., 20.),
(10., 20.),
(10., 0.)], dtype=np.float64 )
def testCorners(self):
print self.B.AsPoly()
self.failUnless ( np.array_equal(self.B.AsPoly(), self.corners ) )
class testCenter(unittest.TestCase):
B = BBox( ( (1.0, 2.0), (5.0, 10.0) ) )
def testCenter(self):
self.failUnless( (self.B.Center == (3.0, 6.0)).all() )
def attemptSetCenter(self):
self.B.Center = (6, 5)
def testSetCenter(self):
self.failUnlessRaises(AttributeError, self.attemptSetCenter)
class testSides(unittest.TestCase):
B = BBox( ( (1.0, 2.0), (5.0, 10.0) ) )
def testLeft(self):
self.failUnless( self.B.Left == 1.0 )
def testRight(self):
self.failUnless( self.B.Right == 5.0 )
def testBottom(self):
self.failUnless( self.B.Bottom == 2.0 )
def testTop(self):
self.failUnless( self.B.Top == 10.0 )
class testInfBBox(unittest.TestCase):
B1 = InfBBox()
B2 = InfBBox()
B3 = BBox(((1.0, 2.0), (5.0, 10.0)))
NB = NullBBox()
def testValues(self):
self.failUnless(N.alltrue(N.isinf(self.B1)))
# def testIsNull(self):
# self.failUnless( self.B1.IsNull )
def testEquals(self):
self.failUnless((self.B1 == self.B2) == True)
def testNotEquals(self):
print(self.B1 == self.B3) == False
self.failUnless(
(self.B1 == self.B3) == False,
"NotEquals failed for\n%s,\n %s:%s" % (self.B1, self.B3,
(self.B1 == self.B3)))
def testNotEquals2(self):
self.failUnless(
(self.B3 == self.B1) == False,
"NotEquals failed for\n%s,\n %s:%s" % (self.B3, self.B1,
(self.B3 == self.B1)))
def testMerge(self):
C = self.B1.copy()
C.Merge(self.B3)
self.failUnless(C == self.B2, "merge failed, got: %s" % C)
def testMerge2(self):
C = self.B3.copy()
C.Merge(self.B1)
self.failUnless(C == self.B1, "merge failed, got: %s" % C)
def testOverlaps(self):
self.failUnless(self.B1.Overlaps(self.B2) == True)
def testOverlaps2(self):
self.failUnless(self.B3.Overlaps(self.B1) == True)
def testOverlaps3(self):
self.failUnless(self.B1.Overlaps(self.B3) == True)
def testOverlaps4(self):
self.failUnless(self.B1.Overlaps(self.NB) == True)
def testOverlaps5(self):
self.failUnless(self.NB.Overlaps(self.B1) == True)
def createQuadTrees(normalTokens):
"""
given a list of tokens we fill their quadTree attributes and cropped image size
"""
for i, token in enumerate(normalTokens):
im_tmp = drawWord(token)
T = BBox.getQuadTree(im_tmp, QUADTREE_MINSIZE, QUADTREE_MINSIZE)
T.compress()
im_tmp = im_tmp.crop(im_tmp.getbbox())
token.quadTree = T
token.imgSize = im_tmp.size
def testQuadTrees(testWord="test", fontSize=200):
# create quadtree of the given test-word with a given font size, and apply tree compression (pruning)
# save the images of colored bounding boxes
T_start = timeit.default_timer()
im = drawWord(testWord, fontSize)
T_stop = timeit.default_timer()
print('\n1. Word image ready in ', T_stop - T_start, 'seconds.')
T_start = timeit.default_timer()
T = BBox.getQuadTree(im, 7, 7)
T_stop = timeit.default_timer()
print('2. Quad tree ready in ', T_stop - T_start, 'seconds.')
T_start = timeit.default_timer()
im_colored_boxes = colorBBoxesBorders(im, T)
T_stop = timeit.default_timer()
print('3. Coloring of the uncompressed tree took ', T_stop - T_start,
'seconds.')
T_start = timeit.default_timer()
T.compress()
T_stop = timeit.default_timer()
print('4. Tree compression ready in ', T_stop - T_start, 'seconds.')
T_start = timeit.default_timer()
im_color_boxes_pruned = colorBBoxesBorders(im, T)
T_stop = timeit.default_timer()
print('5. Coloring of the compressed tree took ', T_stop - T_start,
'seconds.', '\n')
# convert RGBA to RGB allowing the files to be saved as png
im_colored_boxes_back = Image.new('RGB', im_colored_boxes.size, (0, 0, 0))
im_colored_boxes_back.paste(im_colored_boxes)
im_color_boxes_pruned_back = Image.new('RGB', im_color_boxes_pruned.size,
(0, 0, 0))
im_color_boxes_pruned_back.paste(im_color_boxes_pruned)
im_colored_boxes_back.save(testWord + '_BBox.png')
im_color_boxes_pruned_back.save(testWord + '_pruned_BBox.png')
print('The output saved on ', testWord + '_BBox.png', ' and ',
testWord + '_pruned_BBox.png', '\n')
class testWidthHeight(unittest.TestCase):
B = BBox( ( (1.0, 2.0), (5.0, 10.0) ) )
def testWidth(self):
self.failUnless(self.B.Width == 4.0)
def testWidth(self):
self.failUnless(self.B.Height == 8.0)
def attemptSetWidth(self):
self.B.Width = 6
def attemptSetHeight(self):
self.B.Height = 6
def testSetW(self):
self.failUnlessRaises(AttributeError, self.attemptSetWidth)
def testSetH(self):
self.failUnlessRaises(AttributeError, self.attemptSetHeight)
def testLowerRight(self):
B = BBox(((5, 10), (15, 25)))
P = (16, 4)
self.failIf(B.PointInside(P))
def testArrayConstruction(self):
A = N.array(((4, 5), (10, 12)), N.float_)
B = BBox(A)
self.failUnless(isinstance(B, BBox))
def testPointOnBottomRight(self):
B = BBox(((-10.0, -10.0), (-1.0, -1.0)))
P = (-1, -10.0)
self.failUnless(B.PointInside(P))
def testPointOnLeft(self):
B = BBox(((-10.0, -10.0), (-1.0, -1.0)))
P = (-10, -5.0)
self.failUnless(B.PointInside(P))
def testPointOnBottomLine(self):
B = BBox(((1.0, 2.0), (5.0, 10.0)))
P = (3.0, 5.0)
self.failUnless(B.PointInside(P))
def testPointLeftTopLine(self):
B = BBox(((1.0, 2.0), (5.0, 10.0)))
P = (-3.0, 10.0)
self.failIf(B.PointInside(P))
def _get_bounding_box(self):
return BBox.fromPoints(self._PointsArray)
def testPassThrough(self):
B = BBox(((0, 0), (5, 5)))
C = asBBox(B)
self.failUnless(B is C)
def testUpperLeft(self):
B = BBox(((5, 10), (15, 25)))
C = BBox(((0, 12), (10, 32.0)))
self.failUnless(B.Overlaps(C))
def testAbove(self):
B = BBox(((5, 10), (15, 25)))
C = BBox(((-10, 25.001), (8.5, 32)))
self.failIf(B.Inside(C))
def testMinMax(self):
# OK to have a zero-sized BB
B = BBox(((0, 0), (0, 5)))
self.failUnless(isinstance(B, BBox))
def testPointIn(self):
B = BBox(((1.0, 2.0), (5.0, 10.0)))
P = (3.0, 4.0)
self.failUnless(B.PointInside(P))
def testRight(self):
B = BBox(((5, 10), (15, 25)))
C = BBox(((17.1, 8), (17.95, 32)))
self.failIf(B.Inside(C))
def testLeft(self):
B = BBox(((5, 10), (15, 25)))
C = BBox(((4, 8), (4.95, 32)))
self.failIf(B.Inside(C))
def testMinMax2(self):
# OK to have a zero-sized BB
B = BBox(((10.0, -34), (10.0, -34.0)))
self.failUnless(isinstance(B, BBox))
def testLowerLeft(self):
B = BBox(((5, 10), (15, 25)))
P = (-10, 5)
self.failIf(B.PointInside(P))
def testMinMax3(self):
# OK to have a tiny BB
B = BBox(((0, 0), (1e-20, 5)))
self.failUnless(isinstance(B, BBox))
def testBelow(self):
B = BBox(((5, 10), (15, 25)))
P = (10, 5)
self.failIf(B.PointInside(P))
def testSame(self):
B = BBox(((-23.5, 456), (56, 532.0)))
C = BBox(((-23.5, 456), (56, 532.0)))
self.failUnless(B.Overlaps(C))
def testAbove(self):
B = BBox(((5, 10), (15, 25)))
P = (10, 25.001)
self.failIf(B.PointInside(P))
def _get_bounding_box(self):
if len(self._PointsArray) > 0:
return BBox.fromPoints(self._PointsArray)
else:
return None
def testLeft(self):
B = BBox(((5, 10), (15, 25)))
P = (4, 12)
self.failIf(B.PointInside(P))
def bounding_box(self):
return BBox.fromPoints(self)
def testRight(self):
B = BBox(((5, 10), (15, 25)))
P = (17.1, 12.3)
self.failIf(B.PointInside(P))
