Home | History | Annotate | Download | only in printing 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef PRINTING_IMAGE_H_
      6 #define PRINTING_IMAGE_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/logging.h"
     13 #include "printing/printing_export.h"
     14 #include "ui/gfx/size.h"
     15 
     16 namespace base {
     17 class FilePath;
     18 }
     19 
     20 namespace printing {
     21 
     22 class Metafile;
     23 
     24 // Lightweight raw-bitmap management. The image, once initialized, is immutable.
     25 // The main purpose is testing image contents.
     26 class PRINTING_EXPORT Image {
     27  public:
     28   // Creates the image from the given file on disk.  Uses extension to
     29   // defer file type. PNG and EMF (on Windows) currently supported.
     30   // If image loading fails size().IsEmpty() will be true.
     31   explicit Image(const base::FilePath& path);
     32 
     33   // Creates the image from the metafile.  Deduces bounds based on bounds in
     34   // metafile.  If loading fails size().IsEmpty() will be true.
     35   explicit Image(const Metafile& metafile);
     36 
     37   // Copy constructor.
     38   explicit Image(const Image& image);
     39 
     40   ~Image();
     41 
     42   const gfx::Size& size() const {
     43     return size_;
     44   }
     45 
     46   // Return a checksum of the image (MD5 over the internal data structure).
     47   std::string checksum() const;
     48 
     49   // Save image as PNG.
     50   bool SaveToPng(const base::FilePath& filepath) const;
     51 
     52   // Returns % of pixels different
     53   double PercentageDifferent(const Image& rhs) const;
     54 
     55   // Returns the 0x0RGB or 0xARGB value of the pixel at the given location.
     56   uint32 Color(uint32 color) const {
     57     if (ignore_alpha_)
     58       return color & 0xFFFFFF;  // Strip out A.
     59     else
     60       return color;
     61   }
     62 
     63   uint32 pixel_at(int x, int y) const {
     64     DCHECK(x >= 0 && x < size_.width());
     65     DCHECK(y >= 0 && y < size_.height());
     66     const uint32* data = reinterpret_cast<const uint32*>(&*data_.begin());
     67     const uint32* data_row = data + y * row_length_ / sizeof(uint32);
     68     return Color(data_row[x]);
     69   }
     70 
     71  private:
     72   // Construct from metafile.  This is kept internal since it's ambiguous what
     73   // kind of data is used (png, bmp, metafile etc).
     74   Image(const void* data, size_t size);
     75 
     76   bool LoadPng(const std::string& compressed);
     77 
     78   bool LoadMetafile(const std::string& data);
     79 
     80   bool LoadMetafile(const Metafile& metafile);
     81 
     82   // Pixel dimensions of the image.
     83   gfx::Size size_;
     84 
     85   // Length of a line in bytes.
     86   int row_length_;
     87 
     88   // Actual bitmap data in arrays of RGBAs (so when loaded as uint32, it's
     89   // 0xABGR).
     90   std::vector<unsigned char> data_;
     91 
     92   // Flag to signal if the comparison functions should ignore the alpha channel.
     93   const bool ignore_alpha_;  // Currently always true.
     94 
     95   // Prevent operator= (this function has no implementation)
     96   Image& operator=(const Image& image);
     97 };
     98 
     99 }  // namespace printing
    100 
    101 #endif  // PRINTING_IMAGE_H_
    102