[Telemetry] Migrate bitmap.py from bitmaptools.cc to numpy

tools/telemetry/telemetry/core/bitmap_unittest.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+from __future__ import division
+
+import cv2
 import os
 import tempfile
 import unittest
 
-from telemetry import benchmark
 from telemetry.core import bitmap
 from telemetry.core import util
 
 # This is a simple base64 encoded 2x2 PNG which contains, in order, a single
 # Red, Yellow, Blue, and Green pixel.
 test_png = """
 iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAIAAAD91
-JpzAAAAAXNSR0IArs4c6QAAAAlwSFlzAAALEwAACx
-MBAJqcGAAAABZJREFUCNdj/M/AwPCfgYGB4T/DfwY
-AHAAD/iOWZXsAAAAASUVORK5CYII=
+JpzAAAAFklEQVR4Xg3EAQ0AAABAMP1LY3YI7l8l6A
+T8tgwbJAAAAABJRU5ErkJggg==
 """
+
 test_png_path = os.path.join(util.GetUnittestDataDir(), 'test_png.png')
 test_png_2_path = os.path.join(util.GetUnittestDataDir(), 'test_png_2.png')
 
 
 class HistogramDistanceTest(unittest.TestCase):
+
   def testNoData(self):
     hist1 = []
     hist2 = []
     self.assertRaises(
         ValueError, lambda: bitmap.HistogramDistance(hist1, hist2))
 
     hist1 = [0, 0, 0]
     hist2 = [0, 0, 0]
     self.assertRaises(
         ValueError, lambda: bitmap.HistogramDistance(hist1, hist2))
 
   def testWrongSizes(self):
     hist1 = [1]
     hist2 = [1, 0]
     self.assertRaises(
         ValueError, lambda: bitmap.HistogramDistance(hist1, hist2))
 
   def testNoDistance(self):
-    hist1 = [2, 4, 1, 8, 0, -1]
-    hist2 = [2, 4, 1, 8, 0, -1]
+    hist1 = [2, 4, 1, 8, 0, 0]
+    hist2 = [2, 4, 1, 8, 0, 0]
     self.assertEqual(bitmap.HistogramDistance(hist1, hist2), 0)
 
   def testNormalizeCounts(self):
     hist1 = [0, 0, 1, 0, 0]
     hist2 = [0, 0, 0, 0, 7]
-    self.assertEqual(bitmap.HistogramDistance(hist1, hist2), 2)
-    self.assertEqual(bitmap.HistogramDistance(hist2, hist1), 2)
+    self.assertAlmostEqual(bitmap.HistogramDistance(hist1, hist2), 2)
+    self.assertAlmostEqual(bitmap.HistogramDistance(hist2, hist1), 2)
 
   def testDistance(self):
     hist1 = [2, 0, 1, 3, 4]
     hist2 = [3, 1, 2, 4, 0]
     self.assertEqual(bitmap.HistogramDistance(hist1, hist2), 1)
     self.assertEqual(bitmap.HistogramDistance(hist2, hist1), 1)
 
     hist1 = [0, 1, 3, 1]
     hist2 = [2, 2, 1, 0]
-    self.assertEqual(bitmap.HistogramDistance(hist1, hist2), 1.2)
-    self.assertEqual(bitmap.HistogramDistance(hist2, hist1), 1.2)
+    self.assertAlmostEqual(bitmap.HistogramDistance(hist1, hist2), 1.2)
+    self.assertAlmostEqual(bitmap.HistogramDistance(hist2, hist1), 1.2)
 
 
 class BitmapTest(unittest.TestCase):
 
-  # pylint: disable=C0324
+  def testRGBAColorAsInt(self):
+    self.assertEqual(bitmap.BGRAColorAsInt((254, 255, 255, 255)), (1 << 32) - 2)
+    self.assertEqual(bitmap.BGRAColorAsInt((255, 254, 255, 255)),
+                     (1 << 32) - (1 << 8) - 1)
+    self.assertEqual(bitmap.BGRAColorAsInt((255, 255, 254, 255)),
+                     (1 << 32) - (1 << 16) - 1)
+    self.assertEqual(bitmap.BGRAColorAsInt((255, 255, 255, 254)),
+                     (1 << 32) - (1 << 24) - 1)
 
   def testReadFromBase64Png(self):
     bmp = bitmap.Bitmap.FromBase64Png(test_png)
 
     self.assertEquals(2, bmp.width)
     self.assertEquals(2, bmp.height)
 
-    bmp.GetPixelColor(0, 0).AssertIsRGB(255, 0, 0)
-    bmp.GetPixelColor(1, 1).AssertIsRGB(0, 255, 0)
-    bmp.GetPixelColor(0, 1).AssertIsRGB(0, 0, 255)
-    bmp.GetPixelColor(1, 0).AssertIsRGB(255, 255, 0)
+    self.assertTrue(bitmap.ColorsAreEqual(bmp.image[0][0], (0, 0, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(bmp.image[1][1], (0, 255, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(bmp.image[1][0], (255, 0, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(bmp.image[0][1], (0, 255, 255)))
 
   def testReadFromPngFile(self):
-    file_bmp = bitmap.Bitmap.FromPngFile(test_png_path)
+    file_bmp = bitmap.Bitmap.FromImageFile(test_png_path)
 
     self.assertEquals(2, file_bmp.width)
     self.assertEquals(2, file_bmp.height)
 
-    file_bmp.GetPixelColor(0, 0).AssertIsRGB(255, 0, 0)
-    file_bmp.GetPixelColor(1, 1).AssertIsRGB(0, 255, 0)
-    file_bmp.GetPixelColor(0, 1).AssertIsRGB(0, 0, 255)
-    file_bmp.GetPixelColor(1, 0).AssertIsRGB(255, 255, 0)
+    self.assertTrue(bitmap.ColorsAreEqual(file_bmp.image[0][0], (0, 0, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(file_bmp.image[1][1], (0, 255, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(file_bmp.image[1][0], (255, 0, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(file_bmp.image[0][1], (0, 255, 255)))
 
   def testWritePngToPngFile(self):
-    orig = bitmap.Bitmap.FromPngFile(test_png_path)
-    temp_file = tempfile.NamedTemporaryFile().name
-    orig.WritePngFile(temp_file)
-    new_file = bitmap.Bitmap.FromPngFile(temp_file)
+    orig = bitmap.Bitmap.FromImageFile(test_png_path)
+    temp_file = tempfile.NamedTemporaryFile(suffix='.png').name
+    cv2.imwrite(temp_file, orig.image)
+    new_file = bitmap.Bitmap.FromImageFile(temp_file)
     self.assertTrue(orig.IsEqual(new_file))
 
-  @benchmark.Disabled
   def testWriteCroppedBmpToPngFile(self):
     pixels = [255,0,0, 255,255,0, 0,0,0,
               255,255,0, 0,255,0, 0,0,0]
-    orig = bitmap.Bitmap(3, 3, 2, pixels)
+    orig = bitmap.Bitmap.FromRGBPixels(3, 2, pixels, 3)
     orig.Crop(0, 0, 2, 2)
-    temp_file = tempfile.NamedTemporaryFile().name
-    orig.WritePngFile(temp_file)
-    new_file = bitmap.Bitmap.FromPngFile(temp_file)
+    temp_file = tempfile.NamedTemporaryFile(suffix='.png').name
+    cv2.imwrite(temp_file, orig.image)
+    new_file = bitmap.Bitmap.FromImageFile(temp_file)
     self.assertTrue(orig.IsEqual(new_file))
 
-  def testIsEqual(self):
-    bmp = bitmap.Bitmap.FromBase64Png(test_png)
-    file_bmp = bitmap.Bitmap.FromPngFile(test_png_path)
-    self.assertTrue(bmp.IsEqual(file_bmp))
+  def testDiff(self):
+    file_bmp = bitmap.Bitmap.FromImageFile(test_png_path)
+    file_bmp_2 = bitmap.Bitmap.FromImageFile(test_png_2_path)
 
-  def testDiff(self):
-    file_bmp = bitmap.Bitmap.FromPngFile(test_png_path)
-    file_bmp_2 = bitmap.Bitmap.FromPngFile(test_png_2_path)
+    diff = file_bmp.Diff(file_bmp)
 
-    diff_bmp = file_bmp.Diff(file_bmp)
+    self.assertEquals(2, diff.width)
+    self.assertEquals(2, diff.height)
 
-    self.assertEquals(2, diff_bmp.width)
-    self.assertEquals(2, diff_bmp.height)
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[0][0], (0, 0, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[1][1], (0, 0, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[1][0], (0, 0, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[0][1], (0, 0, 0)))
 
-    diff_bmp.GetPixelColor(0, 0).AssertIsRGB(0, 0, 0)
-    diff_bmp.GetPixelColor(1, 1).AssertIsRGB(0, 0, 0)
-    diff_bmp.GetPixelColor(0, 1).AssertIsRGB(0, 0, 0)
-    diff_bmp.GetPixelColor(1, 0).AssertIsRGB(0, 0, 0)
+    diff = file_bmp.Diff(file_bmp_2)
 
-    diff_bmp = file_bmp.Diff(file_bmp_2)
+    self.assertEquals(3, diff.width)
+    self.assertEquals(3, diff.height)
 
-    self.assertEquals(3, diff_bmp.width)
-    self.assertEquals(3, diff_bmp.height)
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[0][0], (255, 255, 0)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[1][1], (255, 0, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[1][0], (0, 255, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[0][1], (255, 0, 0)))
 
-    diff_bmp.GetPixelColor(0, 0).AssertIsRGB(0, 255, 255)
-    diff_bmp.GetPixelColor(1, 1).AssertIsRGB(255, 0, 255)
-    diff_bmp.GetPixelColor(0, 1).AssertIsRGB(255, 255, 0)
-    diff_bmp.GetPixelColor(1, 0).AssertIsRGB(0, 0, 255)
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[2][0], (255, 255, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[2][1], (255, 255, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[0][2], (255, 255, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[1][2], (255, 255, 255)))
+    self.assertTrue(bitmap.ColorsAreEqual(diff.image[2][2], (255, 255, 255)))
 
-    diff_bmp.GetPixelColor(0, 2).AssertIsRGB(255, 255, 255)
-    diff_bmp.GetPixelColor(1, 2).AssertIsRGB(255, 255, 255)
-    diff_bmp.GetPixelColor(2, 0).AssertIsRGB(255, 255, 255)
-    diff_bmp.GetPixelColor(2, 1).AssertIsRGB(255, 255, 255)
-    diff_bmp.GetPixelColor(2, 2).AssertIsRGB(255, 255, 255)
-
-  @benchmark.Disabled
   def testGetBoundingBox(self):
     pixels = [0,0,0, 0,0,0, 0,0,0, 0,0,0,
               0,0,0, 1,0,0, 1,0,0, 0,0,0,
               0,0,0, 0,0,0, 0,0,0, 0,0,0]
-    bmp = bitmap.Bitmap(3, 4, 3, pixels)
-    box, count = bmp.GetBoundingBox(bitmap.RgbaColor(1, 0, 0))
+    bmp = bitmap.Bitmap.FromRGBPixels(4, 3, pixels)
+    box, count = bmp.GetBoundingBox((0, 0, 1))
     self.assertEquals(box, (1, 1, 2, 1))
     self.assertEquals(count, 2)
 
-    box, count = bmp.GetBoundingBox(bitmap.RgbaColor(0, 1, 0))
+    box, count = bmp.GetBoundingBox((0, 1, 0))
     self.assertEquals(box, None)
     self.assertEquals(count, 0)
 
-  @benchmark.Disabled
   def testCrop(self):
     pixels = [0,0,0, 1,0,0, 2,0,0, 3,0,0,
               0,1,0, 1,1,0, 2,1,0, 3,1,0,
               0,2,0, 1,2,0, 2,2,0, 3,2,0]
-    bmp = bitmap.Bitmap(3, 4, 3, pixels)
+    bmp = bitmap.Bitmap.FromRGBPixels(4, 3, pixels)
     bmp.Crop(1, 2, 2, 1)
 
     self.assertEquals(bmp.width, 2)
     self.assertEquals(bmp.height, 1)
-    bmp.GetPixelColor(0, 0).AssertIsRGB(1, 2, 0)
-    bmp.GetPixelColor(1, 0).AssertIsRGB(2, 2, 0)
-    self.assertEquals(bmp.pixels, bytearray([1,2,0, 2,2,0]))
 
-  @benchmark.Disabled
+    self.assertTrue(bitmap.ColorsAreEqual(bmp.image[0][0], (0, 2, 1)))
+    self.assertTrue(bitmap.ColorsAreEqual(bmp.image[0][1], (0, 2, 2)))
+
   def testHistogram(self):
     pixels = [1,2,3, 1,2,3, 1,2,3, 1,2,3,
               1,2,3, 8,7,6, 5,4,6, 1,2,3,
               1,2,3, 8,7,6, 5,4,6, 1,2,3]
-    bmp = bitmap.Bitmap(3, 4, 3, pixels)
+    bmp = bitmap.Bitmap.FromRGBPixels(4, 3, pixels)
     bmp.Crop(1, 1, 2, 2)
 
     histogram = bmp.ColorHistogram()
     for i in xrange(3):
       self.assertEquals(sum(histogram[i]), bmp.width * bmp.height)
     self.assertEquals(histogram.r[1], 0)
     self.assertEquals(histogram.r[5], 2)
     self.assertEquals(histogram.r[8], 2)
     self.assertEquals(histogram.g[2], 0)
     self.assertEquals(histogram.g[4], 2)
     self.assertEquals(histogram.g[7], 2)
     self.assertEquals(histogram.b[3], 0)
     self.assertEquals(histogram.b[6], 4)
 
-  @benchmark.Disabled
   def testHistogramIgnoreColor(self):
     pixels = [1,2,3, 1,2,3, 1,2,3, 1,2,3,
               1,2,3, 8,7,6, 5,4,6, 1,2,3,
-              1,2,3, 8,7,6, 5,4,6, 1,2,3]
-    bmp = bitmap.Bitmap(3, 4, 3, pixels)
+              1,2,3, 8,7,6, 5,4,6, 1,2,3,
+              1,2,3, 1,2,2, 2,2,3, 1,2,3]
+    bmp = bitmap.Bitmap.FromRGBPixels(4, 4, pixels)
 
-    histogram = bmp.ColorHistogram(ignore_color=bitmap.RgbaColor(1, 2, 3))
-    self.assertEquals(histogram.r[1], 0)
+    histogram = bmp.ColorHistogram(ignore_color=(3, 2, 1))
+    self.assertEquals(histogram.r[1], 1)
+    self.assertEquals(histogram.r[2], 1)
     self.assertEquals(histogram.r[5], 2)
     self.assertEquals(histogram.r[8], 2)
-    self.assertEquals(histogram.g[2], 0)
+    self.assertEquals(histogram.g[2], 2)
     self.assertEquals(histogram.g[4], 2)
     self.assertEquals(histogram.g[7], 2)
-    self.assertEquals(histogram.b[3], 0)
+    self.assertEquals(histogram.b[2], 1)
+    self.assertEquals(histogram.b[3], 1)
     self.assertEquals(histogram.b[6], 4)
 
-  @benchmark.Disabled
   def testHistogramIgnoreColorTolerance(self):
     pixels = [1,2,3, 4,5,6,
               7,8,9, 8,7,6]
-    bmp = bitmap.Bitmap(3, 2, 2, pixels)
+    bmp = bitmap.Bitmap.FromRGBPixels(2, 2, pixels)
 
-    histogram = bmp.ColorHistogram(ignore_color=bitmap.RgbaColor(0, 1, 2),
-                                   tolerance=1)
+    histogram = bmp.ColorHistogram(ignore_color=(2, 1, 0), tolerance=1)
     self.assertEquals(histogram.r[1], 0)
     self.assertEquals(histogram.r[4], 1)
     self.assertEquals(histogram.r[7], 1)
     self.assertEquals(histogram.r[8], 1)
     self.assertEquals(histogram.g[2], 0)
     self.assertEquals(histogram.g[5], 1)
     self.assertEquals(histogram.g[7], 1)
     self.assertEquals(histogram.g[8], 1)
     self.assertEquals(histogram.b[3], 0)
     self.assertEquals(histogram.b[6], 2)
     self.assertEquals(histogram.b[9], 1)
 
-  @benchmark.Disabled
   def testHistogramDistanceIgnoreColor(self):
     pixels = [1,2,3, 1,2,3,
               1,2,3, 1,2,3]
-    bmp = bitmap.Bitmap(3, 2, 2, pixels)
+    bmp = bitmap.Bitmap.FromRGBPixels(2, 2, pixels)
 
-    hist1 = bmp.ColorHistogram(ignore_color=bitmap.RgbaColor(1, 2, 3))
+    hist1 = bmp.ColorHistogram(ignore_color=(1, 2, 3))
     hist2 = bmp.ColorHistogram()
 
     self.assertEquals(hist1.Distance(hist2), 0)