color: general transformation -> affine transformation

ui/gfx/color_transform.cc

 // Copyright (c) 2016 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_transform.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "ui/gfx/color_space.h"
@@ skipping 634 matching lines @@
                        c.custom_primary_matrix_[4], c.custom_primary_matrix_[5],
                        c.custom_primary_matrix_[6], c.custom_primary_matrix_[7],
                        c.custom_primary_matrix_[8], c.custom_primary_matrix_[9],
                        c.custom_primary_matrix_[10],
                        c.custom_primary_matrix_[11], 0.0f, 0.0f, 0.0f, 1.0f);
     } else {
       return GetPrimaryMatrix(c.primaries_);
     }
   }
 
-  void transform(TriStim* colors, size_t num) override {
+  void transform(TriStim* colors, size_t num) const override {
     for (size_t i = 0; i < num; i++) {
       TriStim c = colors[i];
       a_.TransformPoint(&c);
       c = ToLinear(from_.transfer_, c);
       b_.TransformPoint(&c);
       c.set_x(FromLinear(to_.transfer_, c.x()));
       c.set_y(FromLinear(to_.transfer_, c.y()));
       c.set_z(FromLinear(to_.transfer_, c.z()));
       c_.TransformPoint(&c);
       colors[i] = c;
@@ skipping 12 matching lines @@
 
 class QCMSColorTransform : public ColorTransform {
  public:
   // Takes ownership of the profiles
   QCMSColorTransform(qcms_profile* from, qcms_profile* to)
       : from_(from), to_(to) {}
   ~QCMSColorTransform() override {
     qcms_profile_release(from_);
     qcms_profile_release(to_);
   }
-  void transform(TriStim* colors, size_t num) override {
+  void transform(TriStim* colors, size_t num) const override {
     CHECK(sizeof(TriStim) == sizeof(float[3]));
     // QCMS doesn't like numbers outside 0..1
     for (size_t i = 0; i < num; i++) {
       colors[i].set_x(fmin(1.0f, fmax(0.0f, colors[i].x())));
       colors[i].set_y(fmin(1.0f, fmax(0.0f, colors[i].y())));
       colors[i].set_z(fmin(1.0f, fmax(0.0f, colors[i].z())));
     }
     qcms_chain_transform(from_, to_, reinterpret_cast<float*>(colors),
                          reinterpret_cast<float*>(colors), num * 3);
   }
 
  private:
   qcms_profile *from_, *to_;
 };
 
 class ChainColorTransform : public ColorTransform {
  public:
   ChainColorTransform(std::unique_ptr<ColorTransform> a,
                       std::unique_ptr<ColorTransform> b)
       : a_(std::move(a)), b_(std::move(b)) {}
 
  private:
-  void transform(TriStim* colors, size_t num) override {
+  void transform(TriStim* colors, size_t num) const override {
     a_->transform(colors, num);
     b_->transform(colors, num);
   }
   std::unique_ptr<ColorTransform> a_;
   std::unique_ptr<ColorTransform> b_;
 };
 
 qcms_profile* GetQCMSProfileIfAvailable(const ColorSpace& color_space) {
   ICCProfile icc_profile = ICCProfile::FromColorSpace(color_space);
   if (icc_profile.GetData().empty())
@@ skipping 47 matching lines @@
               from, ColorSpace::CreateXYZD50(), intent)),
           std::unique_ptr<ColorTransform>(
               new QCMSColorTransform(GetXYZD50Profile(), to_profile))));
     } else {
       return std::unique_ptr<ColorTransform>(
           new ColorSpaceToColorSpaceTransform(from, to, intent));
     }
   }
 }
 
+namespace {
+
+float TriStimChannel(const ColorTransform::TriStim& t, int c) {
+  switch (c) {
+    case 0:
+      return t.x();
+    case 1:
+      return t.y();
+    case 2:
+      return t.z();
+    case 3:
+      return 1.0f;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return 0.0f;
+};
+
+}  // namespace
+
+bool ColorTransform::GetAffineApproximation(Transform* transform) const {
+  const int num_points = 4;
+  std::vector<TriStim> input(num_points * num_points * num_points);
+  int i = 0;
+  float offset = 0.1;
+  float mult = 0.8 / num_points;
+  for (int x = 0; x < num_points; x++) {
+    for (int y = 0; y < num_points; y++) {
+      for (int z = 0; z < num_points; z++) {
+        input[i++] = ColorTransform::TriStim(
+            offset + x * mult, offset + y * mult, offset + z * mult);
+      }
+    }
+  }
+
+  std::vector<TriStim> output(input);
+  this->transform(output.data(), output.size());
+  SkMatrix44 XtX;
+  for (int x = 0; x < 4; x++) {
+    for (int y = 0; y < 4; y++) {
+      double tmp = 0.0;
+      for (int z = 0; z < num_points * num_points * num_points; z++) {
+        tmp += TriStimChannel(input[z], x) * TriStimChannel(input[z], y);
+      }
+      XtX.setDouble(x, y, tmp);
+    }
+  }
+
+  SkMatrix44 XtXinv;
+  if (!XtX.invert(&XtXinv))
+    return false;
+
+  SkVector4 results[4];
+
+  for (int x = 0; x < 4; x++) {
+    double Xty[4];
+    for (int y = 0; y < 4; y++) {
+      double tmp = 0.0;
+      for (int z = 0; z < num_points * num_points * num_points; z++) {
+        tmp += TriStimChannel(output[z], x) * TriStimChannel(input[z], y);
+      }
+      Xty[y] = tmp;
+    }
+    results[x] = XtXinv * SkVector4(Xty[0], Xty[1], Xty[2], Xty[3]);
+  }
+
+  *transform =
+      Transform(results[0].fData[0], results[0].fData[1], results[0].fData[2],
+                results[0].fData[3], results[1].fData[0], results[1].fData[1],
+                results[1].fData[2], results[1].fData[3], results[2].fData[0],
+                results[2].fData[1], results[2].fData[2], results[2].fData[3],
+                results[3].fData[0], results[3].fData[1], results[3].fData[2],
+                results[3].fData[3]);
+  return true;
+}
+
 }  // namespace gfx