Type conversion fixes, ui/gfx/ edition.

ui/gfx/color_analysis.cc

 // Copyright (c) 2012 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.
 
 #include "ui/gfx/color_analysis.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 50 matching lines @@
   inline bool IsAtCentroid(uint8_t r, uint8_t g, uint8_t b) {
     return r == centroid[0] && g == centroid[1] && b == centroid[2];
   }
 
   // Recomputes the centroid of the cluster based on the aggregate data. The
   // number of points used to calculate this center is stored for weighting
   // purposes. The aggregate and counter are then cleared to be ready for the
   // next iteration.
   inline void RecomputeCentroid() {
     if (counter > 0) {
-      centroid[0] = aggregate[0] / counter;
-      centroid[1] = aggregate[1] / counter;
-      centroid[2] = aggregate[2] / counter;
+      centroid[0] = static_cast<uint8_t>(aggregate[0] / counter);
+      centroid[1] = static_cast<uint8_t>(aggregate[1] / counter);
+      centroid[2] = static_cast<uint8_t>(aggregate[2] / counter);
 
       aggregate[0] = aggregate[1] = aggregate[2] = 0;
       weight = counter;
       counter = 0;
     }
   }
 
   inline void AddPoint(uint8_t r, uint8_t g, uint8_t b) {
     aggregate[0] += r;
     aggregate[1] += g;
@@ skipping 27 matching lines @@
   inline uint32_t GetWeight() const {
     return weight;
   }
 
   static bool SortKMeanClusterByWeight(const KMeanCluster& a,
                                        const KMeanCluster& b) {
     return a.GetWeight() > b.GetWeight();
   }
 
  private:
   uint8_t centroid[3];

[danakj, 2014/10/18 18:40:06]

huh, these should be _ suffix'd..

[Peter Kasting, 2014/10/20 23:38:56]

Done.

 
   // Holds the sum of all the points that make up this cluster. Used to
   // generate the next centroid as well as to check for convergence.
   uint32_t aggregate[3];
   uint32_t counter;
 
   // The weight of the cluster, determined by how many points were used
   // to generate the previous centroid.
   uint32_t weight;
 };
@@ skipping 329 matching lines @@
       gb_sum += g * b;
     }
   }
 
   // Covariance (not normalized) is E(X*X.t) - m * m.t and this is how it
   // is calculated below.
   // Each row below represents a row of the matrix describing (co)variances
   // of R, G and B channels with (R, G, B)
   int pixel_n = bitmap.width() * bitmap.height();
   covariance.set(
-      (static_cast<double>(rr_sum) / pixel_n -
-       static_cast<double>(r_sum * r_sum) / pixel_n / pixel_n),
-      (static_cast<double>(rg_sum) / pixel_n -
-       static_cast<double>(r_sum * g_sum) / pixel_n / pixel_n),
-      (static_cast<double>(rb_sum) / pixel_n -
-       static_cast<double>(r_sum * b_sum) / pixel_n / pixel_n),
-      (static_cast<double>(rg_sum) / pixel_n -
-       static_cast<double>(r_sum * g_sum) / pixel_n / pixel_n),
-      (static_cast<double>(gg_sum) / pixel_n -
-       static_cast<double>(g_sum * g_sum) / pixel_n / pixel_n),
-      (static_cast<double>(gb_sum) / pixel_n -
-       static_cast<double>(g_sum * b_sum) / pixel_n / pixel_n),
-      (static_cast<double>(rb_sum) / pixel_n -
-       static_cast<double>(r_sum * b_sum) / pixel_n / pixel_n),
-      (static_cast<double>(gb_sum) / pixel_n -
-       static_cast<double>(g_sum * b_sum) / pixel_n / pixel_n),
-      (static_cast<double>(bb_sum) / pixel_n -
-       static_cast<double>(b_sum * b_sum) / pixel_n / pixel_n));
+      static_cast<float>(
+          static_cast<double>(rr_sum) / pixel_n -
+              static_cast<double>(r_sum * r_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rg_sum) / pixel_n -
+              static_cast<double>(r_sum * g_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rb_sum) / pixel_n -
+              static_cast<double>(r_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rg_sum) / pixel_n -
+              static_cast<double>(r_sum * g_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(gg_sum) / pixel_n -
+              static_cast<double>(g_sum * g_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(gb_sum) / pixel_n -
+              static_cast<double>(g_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(rb_sum) / pixel_n -
+              static_cast<double>(r_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(gb_sum) / pixel_n -
+              static_cast<double>(g_sum * b_sum) / pixel_n / pixel_n),
+      static_cast<float>(
+          static_cast<double>(bb_sum) / pixel_n -
+              static_cast<double>(b_sum * b_sum) / pixel_n / pixel_n));
   return covariance;
 }
 
 bool ApplyColorReduction(const SkBitmap& source_bitmap,
                          const gfx::Vector3dF& color_transform,
                          bool fit_to_range,
                          SkBitmap* target_bitmap) {
   DCHECK(target_bitmap);
   SkAutoLockPixels source_lock(source_bitmap);
   SkAutoLockPixels target_lock(*target_bitmap);
@@ skipping 23 matching lines @@
       const SkPMColor* source_color_row = static_cast<SkPMColor*>(
           source_bitmap.getAddr32(0, y));
       for (int x = 0; x < source_bitmap.width(); ++x) {
         SkColor c;
         int alpha = SkGetPackedA32(source_color_row[x]);
         if (alpha != 0 && alpha != 255)
           c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
         else
           c = source_color_row[x];
 
-        float r = SkColorGetR(c);
-        float g = SkColorGetG(c);
-        float b = SkColorGetB(c);
+        U8CPU r = SkColorGetR(c);

[danakj, 2014/10/18 18:40:06]

uint8?

[Peter Kasting, 2014/10/20 23:38:56]

Done.

+        U8CPU g = SkColorGetG(c);
+        U8CPU b = SkColorGetB(c);
         float gray_level = tr * r + tg * g + tb * b;
         max_val = std::max(max_val, gray_level);
         min_val = std::min(min_val, gray_level);
       }
     }
 
     // Adjust the transform so that the result is scaling.
     float scale = 0.0;
     t0 = -min_val;
     if (max_val > min_val)
-      scale = 255.0 / (max_val - min_val);
+      scale = 255.0f / (max_val - min_val);
     t0 *= scale;
     tr *= scale;
     tg *= scale;
     tb *= scale;
   }
 
   for (int y = 0; y < source_bitmap.height(); ++y) {
     const SkPMColor* source_color_row = static_cast<SkPMColor*>(
         source_bitmap.getAddr32(0, y));
     uint8_t* target_color_row = target_bitmap->getAddr8(0, y);
     for (int x = 0; x < source_bitmap.width(); ++x) {
       SkColor c;
       int alpha = SkGetPackedA32(source_color_row[x]);
       if (alpha != 0 && alpha != 255)
         c = SkUnPreMultiply::PMColorToColor(source_color_row[x]);
       else
         c = source_color_row[x];
 
-      float r = SkColorGetR(c);
-      float g = SkColorGetG(c);
-      float b = SkColorGetB(c);
+      U8CPU r = SkColorGetR(c);

[danakj, 2014/10/18 18:40:06]

uint8?

[Peter Kasting, 2014/10/20 23:38:56]

Done.

+      U8CPU g = SkColorGetG(c);
+      U8CPU b = SkColorGetB(c);
 
       float gl = t0 + tr * r + tg * g + tb * b;
       if (gl < 0)
         gl = 0;
       if (gl > 0xFF)
         gl = 0xFF;
       target_color_row[x] = static_cast<uint8_t>(gl);
     }
   }
 
@@ skipping 10 matching lines @@
   gfx::Matrix3F covariance = ComputeColorCovariance(source_bitmap);
   gfx::Matrix3F eigenvectors = gfx::Matrix3F::Zeros();
   gfx::Vector3dF eigenvals = covariance.SolveEigenproblem(&eigenvectors);
   gfx::Vector3dF principal = eigenvectors.get_column(0);
   if (eigenvals == gfx::Vector3dF() || principal == gfx::Vector3dF())
     return false;  // This may happen for some edge cases.
   return ApplyColorReduction(source_bitmap, principal, true, target_bitmap);
 }
 
 }  // color_utils