Implementation of principal-component color reduction.

ui/gfx/vector3d_f.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/vector3d_f.h"
 
 #include <cmath>
 
 #include "base/stringprintf.h"
 
@@ skipping 54 matching lines @@
 
 void Vector3dF::Cross(const Vector3dF& other) {
   float x = y_ * other.z() - z_ * other.y();
   float y = z_ * other.x() - x_ * other.z();
   float z = x_ * other.y() - y_ * other.x();
   x_ = x;
   y_ = y;
   z_ = z;
 }
 
-float DotProduct(const Vector3dF& lhs, const Vector3dF& rhs) {
-  return lhs.x() * rhs.x() + lhs.y() * rhs.y() + lhs.z() * rhs.z();
+float DotProduct(const Vector3dF& lhs, float x, float y, float z) {

[Alexei Svitkine (slow), 2013/02/21 16:49:59]

Instead of this, can you make a Vector3dF constructor that takes three floats?
Then you can do DotProduct(a, Vector3dF(x, y, z)).

[motek., 2013/02/21 18:38:43]

Well, I would need to call this, in a typical image process, some 10M times. I
realize the compiler would make a good job of it, but still it will just scream
*wrong*. 
If you particularly dislike this change, I'd rather implement multiplication
in-place. 

[reed1, 2013/02/21 19:36:37]

+1 -- the inner loop is no place to unnecessarily rely on an optional compiler
optimization.

[Alexei Svitkine (slow), 2013/02/21 19:54:31]

I'd be surprised if the compilers we use don't produce equivalent code if the
Vector3dF(x,y,z) ctor is put in the header and marked inline.

I'd like to see evidence to the contrary here, in which case we can add a
comment explaining why it's done this way. If committed this way without any
comment, then it's more than likely someone will end up refactoring it to the
form I suggest if the rationale for doing it this way is not in the code.

[reed1, 2013/02/21 19:57:09]

Possibly, or the reverse, where we would need a comment assuring the reader that
the optimization always occurs (w/ some test to back that up.)

I think here may be a case where we defer to the aesthetics of the author.

+  return lhs.x() * x + lhs.y() * y + lhs.z() * z;
 }
 
 Vector3dF ScaleVector3d(const Vector3dF& v,
                         float x_scale,
                         float y_scale,
                         float z_scale) {
   Vector3dF scaled_v(v);
   scaled_v.Scale(x_scale, y_scale, z_scale);
   return scaled_v;
 }
 
 }  // namespace gfx