[telemetry] bitmaptools as a standalone executable

tools/telemetry/telemetry/core/bitmap.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.
+import array

[M-A Ruel, 2014/01/17 14:01:37]

insert an empty line

What's the purpose of this file? Add it in a docstring here.

[szym, 2014/01/17 20:38:20]

Done.

 import base64
 import cStringIO
+import struct
+import subprocess
+import sys
 
 from telemetry.core import util
 
 util.AddDirToPythonPath(util.GetTelemetryDir(), 'third_party', 'png')
 import png  # pylint: disable=F0401
 
 
 class RgbaColor(object):
   """Encapsulates an RGBA color retreived from a Bitmap"""
 
@@ skipping 20 matching lines @@
     assert self.IsEqual(RgbaColor(r, g, b), tolerance)
 
   def AssertIsRGBA(self, r, g, b, a, tolerance=0):
     assert self.IsEqual(RgbaColor(r, g, b, a), tolerance)
 
 
 WEB_PAGE_TEST_ORANGE = RgbaColor(222, 100,  13)
 WHITE =                RgbaColor(255, 255, 255)
 
 
+class _BitmapTools(object):
+  CROP_PIXELS = 0
+  HISTOGRAM = 1
+  BOUNDING_BOX = 2
+
+  def __init__(self, bitmap):
+    suffix = '.exe' if sys.platform == 'win32' else ''
+    binary = util.FindSupportBinary('bitmaptools' + suffix)
+    assert binary, 'You must build bitmaptools first!'
+
+    self.popen = subprocess.Popen([binary],
+                                  stdin=subprocess.PIPE,
+                                  stdout=subprocess.PIPE,
+                                  stderr=subprocess.PIPE)
+    dimensions, pixels = bitmap
+    # dimensions are: bpp, width, height, boxleft, boxtop, boxwidth, boxheight
+    packed_dims = struct.pack('iiiiiii', *dimensions)
+    self.popen.stdin.write(packed_dims)
+    self.popen.stdin.write(pixels)

[bulach, 2014/01/17 10:43:44]

nit: perhaps a self.popen.flush() here?

[M-A Ruel, 2014/01/17 14:01:37]

well, keep in mind this code could dead lock.

[szym, 2014/01/17 20:38:20]

We don't read from popen.stdout until _RunCommand where we popen.close(), so I
don't think a flush is necessary here.

I also don't think there's a chance of deadlock here. The bitmaptools binary
reads the whole expected input before writing anything out.

+
+  def _RunCommand(self, *command):
+    packed_command = struct.pack('i' * len(command), *command)
+    self.popen.stdin.write(packed_command)
+    self.popen.stdin.close()

[M-A Ruel, 2014/01/17 14:01:37]

So the object can only have one call done on it and then it is invalid? I feel
like you want a function, not a class.

[szym, 2014/01/17 20:38:20]

I want to reuse _RunCommand and __init__. I tried with @classmethod but it's
awkward to start each function with:
popen = _BitmapTools._Init(bitmap), and there is no way to curry the call, e.g.,
self._PrepareTools().CropPixels()

+    length_packed = self.popen.stdout.read(struct.calcsize('i'))
+    if not length_packed:
+      raise Exception(self.popen.stderr.read())
+    length = struct.unpack('i', length_packed)[0]
+    return self.popen.stdout.read(length)
+
+  def CropPixels(self):
+    return self._RunCommand(_BitmapTools.CROP_PIXELS)
+
+  def Histogram(self, ignore_color, tolerance):
+    ignore_color = -1 if ignore_color is None else int(ignore_color)
+    response = self._RunCommand(_BitmapTools.HISTOGRAM, ignore_color, tolerance)
+    out = array.array('i')
+    out.fromstring(response)
+    return out
+
+  def BoundingBox(self, color, tolerance):
+    response = self._RunCommand(_BitmapTools.BOUNDING_BOX, int(color),
+                                tolerance)
+    unpacked = struct.unpack('iiiii', response)
+    box, count = unpacked[:4], unpacked[-1]
+    if box[2] < 0 or box[3] < 0:
+      box = None
+    return box, count
+
+
 class Bitmap(object):
   """Utilities for parsing and inspecting a bitmap."""
 
   def __init__(self, bpp, width, height, pixels, metadata=None):
     assert bpp in [3, 4], 'Invalid bytes per pixel'
     assert width > 0, 'Invalid width'
     assert height > 0, 'Invalid height'
     assert pixels, 'Must specify pixels'
     assert bpp * width * height == len(pixels), 'Dimensions and pixels mismatch'
 
     self._bpp = bpp
     self._width = width
     self._height = height
     self._pixels = pixels
     self._metadata = metadata or {}
+    self._crop_box = None
 
   @property
   def bpp(self):
     """Bytes per pixel."""
     return self._bpp
 
   @property
   def width(self):
     """Width of the bitmap."""
+    if self._crop_box:

[M-A Ruel, 2014/01/17 14:01:37]

optionally, if you want to save space, you do this:
return self._crop_box[2] if self._crop_box else self._width

[szym, 2014/01/17 20:38:20]

Done.

+      return self._crop_box[2]
     return self._width
 
   @property
   def height(self):
     """Height of the bitmap."""
+    if self._crop_box:
+      return self._crop_box[3]
     return self._height
 
   @property
+  def _packed(self):
+    # If we got a list of ints, we need to convert it into a byte buffer.

[M-A Ruel, 2014/01/17 14:01:37]

As a docstring?

[szym, 2014/01/17 20:38:20]

This part describes just the |pixels| conversion, but added a docstring.

Done.

+    pixels = self._pixels
+    if type(pixels) is not bytearray:
+      pixels = bytearray(pixels)
+    if type(pixels) is not bytes:
+      pixels = bytes(pixels)
+    crop_box = self._crop_box or (0, 0, self._width, self._height)
+    return (self._bpp, self._width, self._height) + crop_box, pixels
+
+  @property
   def pixels(self):
     """Flat pixel array of the bitmap."""
+    if self._crop_box:
+      self._pixels = _BitmapTools(self._packed).CropPixels()
+      _, _, self._width, self._height = self._crop_box
+      self._crop_box = None
     if type(self._pixels) is not bytearray:
       self._pixels = bytearray(self._pixels)
     return self._pixels
 
   @property
   def metadata(self):
     self._metadata['size'] = (self.width, self.height)
     self._metadata['alpha'] = self.bpp == 4
     self._metadata['bitdepth'] = 8
     return self._metadata
 
   def GetPixelColor(self, x, y):
     """Returns a RgbaColor for the pixel at (x, y)."""
+    pixels = self.pixels
     base = self._bpp * (y * self._width + x)
     if self._bpp == 4:
-      return RgbaColor(self._pixels[base + 0], self._pixels[base + 1],
-                       self._pixels[base + 2], self._pixels[base + 3])
-    return RgbaColor(self._pixels[base + 0], self._pixels[base + 1],
-                     self._pixels[base + 2])
+      return RgbaColor(pixels[base + 0], pixels[base + 1],
+                       pixels[base + 2], pixels[base + 3])
+    return RgbaColor(pixels[base + 0], pixels[base + 1],
+                     pixels[base + 2])
 
   def WritePngFile(self, path):
     with open(path, "wb") as f:
       png.Writer(**self.metadata).write_array(f, self.pixels)
 
   @staticmethod
   def FromPng(png_data):
     width, height, pixels, meta = png.Reader(bytes=png_data).read_flat()
     return Bitmap(4 if meta['alpha'] else 3, width, height, pixels, meta)
 
@@ skipping 63 matching lines @@
       diff = Bitmap.FromPng(output.getvalue())
     finally:
       output.close()
 
     return diff
 
   def GetBoundingBox(self, color, tolerance=0):
     """Finds the minimum box surrounding all occurences of |color|.
     Returns: (top, left, width, height), match_count
     Ignores the alpha channel."""
-    # TODO(szym): Implement this.
-    raise NotImplementedError("GetBoundingBox not yet implemented.")
+    return _BitmapTools(self._packed).BoundingBox(color, tolerance)
 
   def Crop(self, left, top, width, height):
-    """Crops the current bitmap down to the specified box.
-    TODO(szym): Make this O(1).
-    """
+    """Crops the current bitmap down to the specified box."""
+    cur_box = self._crop_box or (0, 0, self._width, self._height)
+    cur_left, cur_top, cur_width, cur_height = cur_box
+
     if (left < 0 or top < 0 or
-        (left + width) > self.width or
-        (top + height) > self.height):
+        (left + width) > cur_width or
+        (top + height) > cur_height):
       raise ValueError('Invalid dimensions')
 
-    img_data = [[0 for x in xrange(width * self.bpp)]
-                for y in xrange(height)]
-
-    # Copy each pixel in the sub-rect.
-    # TODO(tonyg): Make this faster by avoiding the copy and artificially
-    # restricting the dimensions.
-    for y in range(height):
-      for x in range(width):
-        c = self.GetPixelColor(x + left, y + top)
-        offset = x * self.bpp
-        img_data[y][offset] = c.r
-        img_data[y][offset + 1] = c.g
-        img_data[y][offset + 2] = c.b
-        if self.bpp == 4:
-          img_data[y][offset + 3] = c.a
-
-    # This particular method can only save to a file, so the result will be
-    # written into an in-memory buffer and read back into a Bitmap
-    crop_img = png.from_array(img_data, mode='RGBA' if self.bpp == 4 else 'RGB')
-    output = cStringIO.StringIO()
-    try:
-      crop_img.save(output)
-      width, height, pixels, meta = png.Reader(
-          bytes=output.getvalue()).read_flat()
-      self._width = width
-      self._height = height
-      self._pixels = pixels
-      self._metadata = meta
-    finally:
-      output.close()
-
+    self._crop_box = cur_left + left, cur_top + top, width, height
     return self
 
   def ColorHistogram(self, ignore_color=None, tolerance=0):
     """Computes a histogram of the pixel colors in this Bitmap.
     Args:
       ignore_color: An RgbaColor to exclude from the bucket counts.
       tolerance: A tolerance for the ignore_color.
 
     Returns:
       A list of 3x256 integers formatted as
       [r0, r1, ..., g0, g1, ..., b0, b1, ...].
     """
-    # TODO(szym): Implement this.
-    raise NotImplementedError("ColorHistogram not yet implemented.")
+    return _BitmapTools(self._packed).Histogram(ignore_color, tolerance)