Implement DPI for perspective bitmaps in PDF - we save the bitmap at the resolution requested.

src/pdf/SkPDFDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPDFDevice.h"
 
 #include "SkAnnotation.h"
@@ skipping 31 matching lines @@
     int upperBounds;
 
     bool operator==(const TypefaceFallbackData& b) const {
         return typeface == b.typeface &&
                lowerBounds == b.lowerBounds &&
                upperBounds == b.upperBounds;
     }
 };
 #endif
 
+#define DPI_FOR_RASTER_SCALE_ONE 72
+
 // Utility functions
 
 static void emit_pdf_color(SkColor color, SkWStream* result) {
     SkASSERT(SkColorGetA(color) == 0xFF);  // We handle alpha elsewhere.
     SkScalar colorMax = SkIntToScalar(0xFF);
     SkPDFScalar::Append(
             SkScalarDiv(SkIntToScalar(SkColorGetR(color)), colorMax), result);
     result->writeText(" ");
     SkPDFScalar::Append(
             SkScalarDiv(SkIntToScalar(SkColorGetG(color)), colorMax), result);
@@ skipping 1971 matching lines @@
                                      const SkPaint& paint) {
     SkMatrix matrix = origMatrix;
     SkRegion perspectiveBounds;
     const SkRegion* clipRegion = &origClipRegion;
     SkBitmap perspectiveBitmap;
     const SkBitmap* bitmap = &origBitmap;
     SkBitmap tmpSubsetBitmap;
 
     // Rasterize the bitmap using perspective in a new bitmap.
     if (origMatrix.hasPerspective()) {
+        if (fRasterDpi == 0) {
+            return;
+        }
         SkBitmap* subsetBitmap;
         if (srcRect) {
             if (!origBitmap.extractSubset(&tmpSubsetBitmap, *srcRect)) {
                return;
             }
             subsetBitmap = &tmpSubsetBitmap;
         } else {
             subsetBitmap = &tmpSubsetBitmap;
             *subsetBitmap = origBitmap;
         }
         srcRect = NULL;
 
         // Transform the bitmap in the new space.
         SkPath perspectiveOutline;
         perspectiveOutline.addRect(
                 SkRect::MakeWH(SkIntToScalar(subsetBitmap->width()),
                                SkIntToScalar(subsetBitmap->height())));
         perspectiveOutline.transform(origMatrix);
 
         // TODO(edisonn): perf - use current clip too.
         // Retrieve the bounds of the new shape.
         SkRect bounds = perspectiveOutline.getBounds();
+        float scaleX = fRasterDpi / (float)DPI_FOR_RASTER_SCALE_ONE;

[vandebo (ex-Chrome), 2013/10/31 23:20:36]

This should probably use SkScalar instead of float.

[edisonn, 2013/11/01 15:00:08]

Done.

+        float scaleY = scaleX;
 
-        // TODO(edisonn): add DPI settings. Currently 1 pixel/point, which does
-        // not look great, but it is not producing large PDFs.
+        scaleX *= SkScalarToFloat(fInitialTransform.getScaleX());
+        scaleY *= SkScalarToFloat(fInitialTransform.getScaleY());
+
+        scaleX = fabs(scaleX);

[vandebo (ex-Chrome), 2013/10/31 23:20:36]

SkScalarAbs

[edisonn, 2013/11/01 15:00:08]

Done.

+        scaleY = fabs(scaleY);

[vandebo (ex-Chrome), 2013/10/31 23:20:36]

Actually, I don't think you want to do this.  When *bitmap is drawn on line
2150, fInitialTransform is in effect. I suspect that the values you're getting
in the gm are all 1 or -1 and thus your fabs() is correcting for that.  I think
you need to unapply the intialtransform (after you calculate the resolution for
the desired DPI) on line 2113.  You could prove this by using an initial
transform in the gm (with a manual perspective).

[edisonn, 2013/11/01 15:00:08]

Yes, but getScaleX()/Y() can can return anything, as initial transform can have
anything (except perspective)

 I think
This seems to work fast and correct. I am not sure why I would choose something
that might work slower, and has a more complex logic, unless it is clearly
providing better results

  You could prove this by using an initial
Initial transform does not support perspective

[vandebo (ex-Chrome), 2013/11/01 22:13:42]

True, you do need to use Abs for the bitmap.setConfig()
Because it will give the wrong result if the initial transform has a scale other
than 1 or -1.
Initial transform doesn't need perspective - just a non unit scale factor.  With
gm, you've use the force-perspective flag with an initial transform, but you
could use a gm that uses perspective to test. 

[edisonn, 2013/11/04 18:04:58]

Incorrect, the initial transform is not affected by perspective. And actually we
assert if initial transform has perspective. The perspective is in the canvas's
matrix

but you
Algorithm: 
1) take the rect of the bitmap, apply perspective on it (origMatrix), the
resulting shape needs now only initial matrix transformation
2) compute scale for given DPI and initial transform
3) correct scale to be positive

now the scale takes in account DPI, the initial transform, and the
orogMatrix(cariing perspective) and the bitmap size

 
         // TODO(edisonn): A better approach would be to use a bitmap shader
         // (in clamp mode) and draw a rect over the entire bounding box. Then
         // intersect perspectiveOutline to the clip. That will avoid introducing
         // alpha to the image while still giving good behavior at the edge of
         // the image.  Avoiding alpha will reduce the pdf size and generation
         // CPU time some.
 
-        perspectiveBitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                                    SkScalarCeilToInt(bounds.width()),
-                                    SkScalarCeilToInt(bounds.height()));
+        perspectiveBitmap.setConfig(
+                SkBitmap::kARGB_8888_Config,
+                SkScalarCeilToInt(scaleX * bounds.width()),
+                SkScalarCeilToInt(scaleY * bounds.height()));
         perspectiveBitmap.allocPixels();
         perspectiveBitmap.eraseColor(SK_ColorTRANSPARENT);
 
         SkBitmapDevice device(perspectiveBitmap);
         SkCanvas canvas(&device);
 
         SkScalar deltaX = bounds.left();
         SkScalar deltaY = bounds.top();
 
         SkMatrix offsetMatrix = origMatrix;
         offsetMatrix.postTranslate(-deltaX, -deltaY);
+        offsetMatrix.postScale(scaleX, scaleY);
 
         // Translate the draw in the new canvas, so we perfectly fit the
         // shape in the bitmap.
         canvas.setMatrix(offsetMatrix);
 
         canvas.drawBitmap(*subsetBitmap, SkIntToScalar(0), SkIntToScalar(0));
 
         // Make sure the final bits are in the bitmap.
         canvas.flush();
 
-        // In the new space, we use the identity matrix translated.
-        matrix.setTranslate(deltaX, deltaY);
+        // In the new space, we use the identity matrix translated
+        // and scaled to reflect DPI.
+        matrix.setScale(1 / scaleX, 1 / scaleY);
+        matrix.postTranslate(deltaX, deltaY);
         perspectiveBounds.setRect(
                 SkIRect::MakeXYWH(SkScalarFloorToInt(bounds.x()),
                                   SkScalarFloorToInt(bounds.y()),
                                   SkScalarCeilToInt(bounds.width()),
                                   SkScalarCeilToInt(bounds.height())));
         clipRegion = &perspectiveBounds;
         srcRect = NULL;
         bitmap = &perspectiveBitmap;
     }
 
@@ skipping 26 matching lines @@
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }