Fix double to float truncation warnings with MSVC

hughbe · robryk · commit 2b11bd9e241b · 2017-04-03T15:36:35.000+02:00
diff --git a/guetzli/butteraugli_comparator.cc b/guetzli/butteraugli_comparator.cc
@@ -35,7 +35,7 @@ ButteraugliComparator::ButteraugliComparator(const int width, const int height,
       rgb_linear_pregamma_(3, std::vector<float>(width_ * height_)),
       comparator_(width_, height_, kButteraugliStep),
       distance_(0.0),
-      distmap_(width_, height_),
+      distmap_(width_, static_cast<float>(height_)),
       stats_(stats) {
   const double* lut = Srgb8ToLinearTable();
   for (int c = 0; c < 3; ++c) {
@@ -180,7 +180,7 @@ void ButteraugliComparator::ComputeBlockErrorAdjustmentWeights(
   for (int block_y = 0; block_y < block_height; ++block_y) {
     for (int block_x = 0; block_x < block_width; ++block_x) {
       int block_ix = block_y * block_width + block_x;
-      float max_local_dist = target_distance;
+      float max_local_dist = static_cast<float>(target_distance);
       int x_min = std::max(0, block_x - max_block_dist);
       int y_min = std::max(0, block_y - max_block_dist);
       int x_max = std::min(block_width, block_x + 1 + max_block_dist);
diff --git a/guetzli/guetzli.cc b/guetzli/guetzli.cc
@@ -270,8 +270,8 @@ int main(int argc, char** argv) {
   std::string out_data;
 
   guetzli::Params params;
-  params.butteraugli_target =
-      guetzli::ButteraugliScoreForQuality(quality);
+  params.butteraugli_target = static_cast<float>(
+      guetzli::ButteraugliScoreForQuality(quality));
 
   guetzli::ProcessStats stats;
 
diff --git a/guetzli/output_image.cc b/guetzli/output_image.cc
@@ -113,7 +113,7 @@ void OutputImageComponent::ToFloatPixels(float* out, int stride) const {
           int y = block_y * 8 + iy;
           int x = block_x * 8 + ix;
           if (y >= height_ || x >= width_) continue;
-          out[(y * width_ + x) * stride] = blockd[8 * iy + ix] + 128.0;
+          out[(y * width_ + x) * stride] = static_cast<float>(blockd[8 * iy + ix] + 128.0);
         }
       }
     }
@@ -430,7 +430,7 @@ void OutputImage::ToLinearRGB(int xmin, int ymin, int xsize, int ysize,
   std::vector<uint8_t> rgb_pixels = ToSRGB(xmin, ymin, xsize, ysize);
   for (int p = 0; p < xsize * ysize; ++p) {
     for (int i = 0; i < 3; ++i) {
-      (*rgb)[i][p] = lut[rgb_pixels[3 * p + i]];
+      (*rgb)[i][p] = static_cast<float>(lut[rgb_pixels[3 * p + i]]);
     }
   }
 }
diff --git a/guetzli/preprocess_downsample.cc b/guetzli/preprocess_downsample.cc
@@ -42,7 +42,7 @@ std::vector<float> Convolve2D(const std::vector<float>& image, int w, int h,
     for (int j = 0; j < size * size; j++) {
       int x2 = x + j % size - size2;
       int y2 = y + j / size - size2;
-      v += kernel[j] * image[y2 * w + x2];
+      v += static_cast<float>(kernel[j]) * image[y2 * w + x2];
     }
     result[i] = v;
   }
@@ -62,9 +62,9 @@ std::vector<float> Convolve2X(const std::vector<float>& image, int w, int h,
     float v = 0;
     for (int j = 0; j < size; j++) {
       int x2 = x + j - size2;
-      v += kernel[j] * image[y * w + x2];
+      v += static_cast<float>(kernel[j]) * image[y * w + x2];
     }
-    temp[i] = v * mul;
+    temp[i] = v * static_cast<float>(mul);
   }
   auto result = temp;
   for (size_t i = 0; i < temp.size(); i++) {
@@ -75,9 +75,9 @@ std::vector<float> Convolve2X(const std::vector<float>& image, int w, int h,
     float v = 0;
     for (int j = 0; j < size; j++) {
       int y2 = y + j - size2;
-      v += kernel[j] * temp[y2 * w + x];
+      v += static_cast<float>(kernel[j]) * temp[y2 * w + x];
     }
-    result[i] = v * mul;
+    result[i] = v * static_cast<float>(mul);
   }
   return result;
 }
diff --git a/guetzli/processor.cc b/guetzli/processor.cc
@@ -390,8 +390,8 @@ void Processor::ComputeBlockZeroingOrder(
         if (params_.new_zeroing_model) {
           score = std::abs(orig_block[idx]) * csf[idx] + bias[idx];
         } else {
-          score = (std::abs(orig_block[idx]) - kJPEGZigZagOrder[k] / 64.0) *
-                  kWeight[c] / oldCsf[k];
+          score = static_cast<float>((std::abs(orig_block[idx]) - kJPEGZigZagOrder[k] / 64.0) *
+                  kWeight[c] / oldCsf[k]);
         }
         input_order.push_back(std::make_pair(idx, score));
       }
@@ -425,7 +425,7 @@ void Processor::ComputeBlockZeroingOrder(
           int block_xx = block_x * factor_x + ix;
           int block_yy = block_y * factor_y + iy;
           if (8 * block_xx < img->width() && 8 * block_yy < img->height()) {
-            float err = comparator_->CompareBlock(*img, ix, iy);
+            float err = static_cast<float>(comparator_->CompareBlock(*img, ix, iy));
             max_err = std::max(max_err, err);
           }
         }
diff --git a/third_party/butteraugli/butteraugli/butteraugli.cc b/third_party/butteraugli/butteraugli/butteraugli.cc
@@ -86,7 +86,7 @@ static void Convolution(size_t xsize, size_t ysize,
       for (int j = minx; j <= maxx; ++j) {
         sum += inp[y * xsize + j] * multipliers[j - x + offset];
       }
-      result[ox * ysize + y] = sum * scale;
+      result[ox * ysize + y] = static_cast<float>(sum * scale);
     }
   }
 }
@@ -101,7 +101,7 @@ void Blur(size_t xsize, size_t ysize, float* channel, double sigma,
   const int expn_size = 2 * diff + 1;
   std::vector<float> expn(expn_size);
   for (int i = -diff; i <= diff; ++i) {
-    expn[i + diff] = exp(scaler * i * i);
+    expn[i + diff] = static_cast<float>(exp(scaler * i * i));
   }
   const int xstep = std::max(1, int(sigma / 3));
   const int ystep = xstep;
@@ -818,8 +818,8 @@ void MaskHighIntensityChange(
       // Interpolate lineraly between the average color and the actual
       // color -- to reduce the importance of this pixel.
       for (int i = 0; i < 3; ++i) {
-        xyb0[i][ix] = mix[i] * c0[i][ix] + (1 - mix[i]) * ave[i];
-        xyb1[i][ix] = mix[i] * c1[i][ix] + (1 - mix[i]) * ave[i];
+        xyb0[i][ix] = static_cast<float>(mix[i] * c0[i][ix] + (1 - mix[i]) * ave[i]);
+        xyb1[i][ix] = static_cast<float>(mix[i] * c1[i][ix] + (1 - mix[i]) * ave[i]);
       }
     }
   }
@@ -915,12 +915,12 @@ static inline float GammaPolynomial(float value) {
     12.262350348616792, 20.557285797683576, 12.161463238367844,
     4.711532733641639, 0.899112889751053, 0.035662329617191,
   }};
-  return r(value);
+  return static_cast<float>(r(value));
 }
 
 static inline double Gamma(double v) {
   // return SimpleGamma(v);
-  return GammaPolynomial(v);
+  return GammaPolynomial(static_cast<float>(v));
 }
 
 void OpsinDynamicsImage(size_t xsize, size_t ysize,
@@ -950,16 +950,16 @@ void OpsinDynamicsImage(size_t xsize, size_t ysize,
     cur_mixed[2] *= sensitivity[2];
     double x, y, z;
     RgbToXyb(cur_mixed[0], cur_mixed[1], cur_mixed[2], &x, &y, &z);
-    rgb[0][i] = x;
-    rgb[1][i] = y;
-    rgb[2][i] = z;
+    rgb[0][i] = static_cast<float>(x);
+    rgb[1][i] = static_cast<float>(y);
+    rgb[2][i] = static_cast<float>(z);
   }
 }
 
 static void ScaleImage(double scale, std::vector<float> *result) {
   PROFILER_FUNC;
   for (size_t i = 0; i < result->size(); ++i) {
-    (*result)[i] *= scale;
+    (*result)[i] *= static_cast<float>(scale);
   }
 }
 
@@ -1015,7 +1015,7 @@ void CalculateDiffmap(const size_t xsize, const size_t ysize,
     for (size_t y = 0; y < ysize - s; ++y) {
       for (size_t x = 0; x < xsize - s; ++x) {
         (*diffmap)[(y + s2) * xsize + x + s2]
-            += mul1 * blurred[y * (xsize - s) + x];
+            += static_cast<float>(mul1) * blurred[y * (xsize - s) + x];
       }
     }
     ScaleImage(scale, diffmap);
@@ -1084,8 +1084,8 @@ void ButteraugliComparator::BlockDiffMap(
       ButteraugliBlockDiff(block0, block1,
                            diff_xyb_dc, diff_xyb_ac, diff_xyb_edge_dc);
       for (int i = 0; i < 3; ++i) {
-        (*block_diff_dc)[3 * res_ix + i] = diff_xyb_dc[i];
-        (*block_diff_ac)[3 * res_ix + i] = diff_xyb_ac[i];
+        (*block_diff_dc)[3 * res_ix + i] = static_cast<float>(diff_xyb_dc[i]);
+        (*block_diff_ac)[3 * res_ix + i] = static_cast<float>(diff_xyb_ac[i]);
       }
     }
   }
@@ -1117,7 +1117,7 @@ void ButteraugliComparator::EdgeDetectorMap(
                                            blurred0, blurred1,
                                            diff_xyb);
       for (int i = 0; i < 3; ++i) {
-        (*edge_detector_map)[3 * res_ix + i] = diff_xyb[i];
+        (*edge_detector_map)[3 * res_ix + i] = static_cast<float>(diff_xyb[i]);
       }
     }
   }
@@ -1173,7 +1173,7 @@ void ButteraugliComparator::EdgeDetectorLowFreq(
         }
       }
       for (int i = 0; i < 3; ++i) {
-        (*block_diff_ac)[3 * res_ix + i] += kMul * max_diff_xyb[i];
+        (*block_diff_ac)[3 * res_ix + i] += static_cast<float>(kMul * max_diff_xyb[i]);
       }
     }
   }
@@ -1197,8 +1197,8 @@ void ButteraugliComparator::CombineChannels(
         mask[i] = mask_xyb[i][(res_y + 3) * xsize_ + (res_x + 3)];
         dc_mask[i] = mask_xyb_dc[i][(res_y + 3) * xsize_ + (res_x + 3)];
       }
-      (*result)[res_ix] =
-          (DotProduct(&block_diff_dc[3 * res_ix], dc_mask) +
+      (*result)[res_ix] = static_cast<float>(
+           DotProduct(&block_diff_dc[3 * res_ix], dc_mask) +
            DotProduct(&block_diff_ac[3 * res_ix], mask) +
            DotProduct(&edge_detector_map[3 * res_ix], mask));
     }
@@ -1319,7 +1319,7 @@ void MinSquareVal(size_t square_size, size_t offset,
       for (size_t j = minh + 1; j < maxh; ++j) {
         min = fmin(min, values[x + j * xsize]);
       }
-      tmp[x + y * xsize] = min;
+      tmp[x + y * xsize] = static_cast<float>(min);
     }
   }
   for (size_t x = 0; x < xsize; ++x) {
@@ -1330,7 +1330,7 @@ void MinSquareVal(size_t square_size, size_t offset,
       for (size_t j = minw + 1; j < maxw; ++j) {
         min = fmin(min, tmp[j + y * xsize]);
       }
-      values[x + y * xsize] = min;
+      values[x + y * xsize] = static_cast<float>(min);
     }
   }
 }
@@ -1438,7 +1438,7 @@ void DiffPrecompute(
         double sup0 = fabs(valsh0[i]) + fabs(valsv0[i]);
         double sup1 = fabs(valsh1[i]) + fabs(valsv1[i]);
         double m = std::min(sup0, sup1);
-        (*mask)[i][ix] = m;
+        (*mask)[i][ix] = static_cast<float>(m);
       }
     }
   }
@@ -1483,12 +1483,12 @@ void Mask(const std::vector<std::vector<float> > &xyb0,
       const double p1 = w11 * s1;
       const double p2 = w22 * s2;
 
-      (*mask)[0][idx] = MaskX(p0);
-      (*mask)[1][idx] = MaskY(p1);
-      (*mask)[2][idx] = MaskB(p2);
-      (*mask_dc)[0][idx] = MaskDcX(p0);
-      (*mask_dc)[1][idx] = MaskDcY(p1);
-      (*mask_dc)[2][idx] = MaskDcB(p2);
+      (*mask)[0][idx] = static_cast<float>(MaskX(p0));
+      (*mask)[1][idx] = static_cast<float>(MaskY(p1));
+      (*mask)[2][idx] = static_cast<float>(MaskB(p2));
+      (*mask_dc)[0][idx] = static_cast<float>(MaskDcX(p0));
+      (*mask_dc)[1][idx] = static_cast<float>(MaskDcY(p1));
+      (*mask_dc)[2][idx] = static_cast<float>(MaskDcB(p2));
     }
   }
   for (int i = 0; i < 3; ++i) {

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ void OutputImageComponent::ToFloatPixels(float* out, int stride) const {`
`113`	`113`	`int y = block_y * 8 + iy;`
`114`	`114`	`int x = block_x * 8 + ix;`
`115`	`115`	`if (y >= height_ \|\| x >= width_) continue;`
`116`		`- out[(y * width_ + x) * stride] = blockd[8 * iy + ix] + 128.0;`
	`116`	`+ out[(y * width_ + x) * stride] = static_cast<float>(blockd[8 * iy + ix] + 128.0);`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`@@ -430,7 +430,7 @@ void OutputImage::ToLinearRGB(int xmin, int ymin, int xsize, int ysize,`
`430`	`430`	`std::vector<uint8_t> rgb_pixels = ToSRGB(xmin, ymin, xsize, ysize);`
`431`	`431`	`for (int p = 0; p < xsize * ysize; ++p) {`
`432`	`432`	`for (int i = 0; i < 3; ++i) {`
`433`		`- (rgb)[i][p] = lut[rgb_pixels[3 p + i]];`
	`433`	`+ (rgb)[i][p] = static_cast<float>(lut[rgb_pixels[3 p + i]]);`
`434`	`434`	`}`
`435`	`435`	`}`
`436`	`436`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ std::vector<float> Convolve2D(const std::vector<float>& image, int w, int h,`
`42`	`42`	`for (int j = 0; j < size * size; j++) {`
`43`	`43`	`int x2 = x + j % size - size2;`
`44`	`44`	`int y2 = y + j / size - size2;`
`45`		`- v += kernel[j] * image[y2 * w + x2];`
	`45`	`+ v += static_cast<float>(kernel[j]) * image[y2 * w + x2];`
`46`	`46`	`}`
`47`	`47`	`result[i] = v;`
`48`	`48`	`}`
`@@ -62,9 +62,9 @@ std::vector<float> Convolve2X(const std::vector<float>& image, int w, int h,`
`62`	`62`	`float v = 0;`
`63`	`63`	`for (int j = 0; j < size; j++) {`
`64`	`64`	`int x2 = x + j - size2;`
`65`		`- v += kernel[j] * image[y * w + x2];`
	`65`	`+ v += static_cast<float>(kernel[j]) * image[y * w + x2];`
`66`	`66`	`}`
`67`		`- temp[i] = v * mul;`
	`67`	`+ temp[i] = v * static_cast<float>(mul);`
`68`	`68`	`}`
`69`	`69`	`auto result = temp;`
`70`	`70`	`for (size_t i = 0; i < temp.size(); i++) {`
`@@ -75,9 +75,9 @@ std::vector<float> Convolve2X(const std::vector<float>& image, int w, int h,`
`75`	`75`	`float v = 0;`
`76`	`76`	`for (int j = 0; j < size; j++) {`
`77`	`77`	`int y2 = y + j - size2;`
`78`		`- v += kernel[j] * temp[y2 * w + x];`
	`78`	`+ v += static_cast<float>(kernel[j]) * temp[y2 * w + x];`
`79`	`79`	`}`
`80`		`- result[i] = v * mul;`
	`80`	`+ result[i] = v * static_cast<float>(mul);`
`81`	`81`	`}`
`82`	`82`	`return result;`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -390,8 +390,8 @@ void Processor::ComputeBlockZeroingOrder(`
`390`	`390`	`if (params_.new_zeroing_model) {`
`391`	`391`	`score = std::abs(orig_block[idx]) * csf[idx] + bias[idx];`
`392`	`392`	`} else {`
`393`		`- score = (std::abs(orig_block[idx]) - kJPEGZigZagOrder[k] / 64.0) *`
`394`		`- kWeight[c] / oldCsf[k];`
	`393`	`+ score = static_cast<float>((std::abs(orig_block[idx]) - kJPEGZigZagOrder[k] / 64.0) *`
	`394`	`+ kWeight[c] / oldCsf[k]);`
`395`	`395`	`}`
`396`	`396`	`input_order.push_back(std::make_pair(idx, score));`
`397`	`397`	`}`
`@@ -425,7 +425,7 @@ void Processor::ComputeBlockZeroingOrder(`
`425`	`425`	`int block_xx = block_x * factor_x + ix;`
`426`	`426`	`int block_yy = block_y * factor_y + iy;`
`427`	`427`	`if (8 * block_xx < img->width() && 8 * block_yy < img->height()) {`
`428`		`- float err = comparator_->CompareBlock(*img, ix, iy);`
	`428`	`+ float err = static_cast<float>(comparator_->CompareBlock(*img, ix, iy));`
`429`	`429`	`max_err = std::max(max_err, err);`
`430`	`430`	`}`
`431`	`431`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,7 +86,7 @@ static void Convolution(size_t xsize, size_t ysize,`
`86`	`86`	`for (int j = minx; j <= maxx; ++j) {`
`87`	`87`	`sum += inp[y * xsize + j] * multipliers[j - x + offset];`
`88`	`88`	`}`
`89`		`- result[ox * ysize + y] = sum * scale;`
	`89`	`+ result[ox * ysize + y] = static_cast<float>(sum * scale);`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`	`}`
`@@ -101,7 +101,7 @@ void Blur(size_t xsize, size_t ysize, float* channel, double sigma,`
`101`	`101`	`const int expn_size = 2 * diff + 1;`
`102`	`102`	`std::vector<float> expn(expn_size);`
`103`	`103`	`for (int i = -diff; i <= diff; ++i) {`
`104`		`- expn[i + diff] = exp(scaler * i * i);`
	`104`	`+ expn[i + diff] = static_cast<float>(exp(scaler * i * i));`
`105`	`105`	`}`
`106`	`106`	`const int xstep = std::max(1, int(sigma / 3));`
`107`	`107`	`const int ystep = xstep;`
`@@ -818,8 +818,8 @@ void MaskHighIntensityChange(`
`818`	`818`	`// Interpolate lineraly between the average color and the actual`
`819`	`819`	`// color -- to reduce the importance of this pixel.`
`820`	`820`	`for (int i = 0; i < 3; ++i) {`
`821`		`- xyb0[i][ix] = mix[i] * c0[i][ix] + (1 - mix[i]) * ave[i];`
`822`		`- xyb1[i][ix] = mix[i] * c1[i][ix] + (1 - mix[i]) * ave[i];`
	`821`	`+ xyb0[i][ix] = static_cast<float>(mix[i] * c0[i][ix] + (1 - mix[i]) * ave[i]);`
	`822`	`+ xyb1[i][ix] = static_cast<float>(mix[i] * c1[i][ix] + (1 - mix[i]) * ave[i]);`
`823`	`823`	`}`
`824`	`824`	`}`
`825`	`825`	`}`
`@@ -915,12 +915,12 @@ static inline float GammaPolynomial(float value) {`
`915`	`915`	`12.262350348616792, 20.557285797683576, 12.161463238367844,`
`916`	`916`	`4.711532733641639, 0.899112889751053, 0.035662329617191,`
`917`	`917`	`}};`
`918`		`- return r(value);`
	`918`	`+ return static_cast<float>(r(value));`
`919`	`919`	`}`
`920`	`920`
`921`	`921`	`static inline double Gamma(double v) {`
`922`	`922`	`// return SimpleGamma(v);`
`923`		`- return GammaPolynomial(v);`
	`923`	`+ return GammaPolynomial(static_cast<float>(v));`
`924`	`924`	`}`
`925`	`925`
`926`	`926`	`void OpsinDynamicsImage(size_t xsize, size_t ysize,`
`@@ -950,16 +950,16 @@ void OpsinDynamicsImage(size_t xsize, size_t ysize,`
`950`	`950`	`cur_mixed[2] *= sensitivity[2];`
`951`	`951`	`double x, y, z;`
`952`	`952`	`RgbToXyb(cur_mixed[0], cur_mixed[1], cur_mixed[2], &x, &y, &z);`
`953`		`- rgb[0][i] = x;`
`954`		`- rgb[1][i] = y;`
`955`		`- rgb[2][i] = z;`
	`953`	`+ rgb[0][i] = static_cast<float>(x);`
	`954`	`+ rgb[1][i] = static_cast<float>(y);`
	`955`	`+ rgb[2][i] = static_cast<float>(z);`
`956`	`956`	`}`
`957`	`957`	`}`
`958`	`958`
`959`	`959`	`static void ScaleImage(double scale, std::vector<float> *result) {`
`960`	`960`	`PROFILER_FUNC;`
`961`	`961`	`for (size_t i = 0; i < result->size(); ++i) {`
`962`		`- (result)[i] = scale;`
	`962`	`+ (result)[i] = static_cast<float>(scale);`
`963`	`963`	`}`
`964`	`964`	`}`
`965`	`965`
`@@ -1015,7 +1015,7 @@ void CalculateDiffmap(const size_t xsize, const size_t ysize,`
`1015`	`1015`	`for (size_t y = 0; y < ysize - s; ++y) {`
`1016`	`1016`	`for (size_t x = 0; x < xsize - s; ++x) {`
`1017`	`1017`	`(diffmap)[(y + s2) xsize + x + s2]`
`1018`		`- += mul1 * blurred[y * (xsize - s) + x];`
	`1018`	`+ += static_cast<float>(mul1) * blurred[y * (xsize - s) + x];`
`1019`	`1019`	`}`
`1020`	`1020`	`}`
`1021`	`1021`	`ScaleImage(scale, diffmap);`
`@@ -1084,8 +1084,8 @@ void ButteraugliComparator::BlockDiffMap(`
`1084`	`1084`	`ButteraugliBlockDiff(block0, block1,`
`1085`	`1085`	`diff_xyb_dc, diff_xyb_ac, diff_xyb_edge_dc);`
`1086`	`1086`	`for (int i = 0; i < 3; ++i) {`
`1087`		`- (block_diff_dc)[3 res_ix + i] = diff_xyb_dc[i];`
`1088`		`- (block_diff_ac)[3 res_ix + i] = diff_xyb_ac[i];`
	`1087`	`+ (block_diff_dc)[3 res_ix + i] = static_cast<float>(diff_xyb_dc[i]);`
	`1088`	`+ (block_diff_ac)[3 res_ix + i] = static_cast<float>(diff_xyb_ac[i]);`
`1089`	`1089`	`}`
`1090`	`1090`	`}`
`1091`	`1091`	`}`
`@@ -1117,7 +1117,7 @@ void ButteraugliComparator::EdgeDetectorMap(`
`1117`	`1117`	`blurred0, blurred1,`
`1118`	`1118`	`diff_xyb);`
`1119`	`1119`	`for (int i = 0; i < 3; ++i) {`
`1120`		`- (edge_detector_map)[3 res_ix + i] = diff_xyb[i];`
	`1120`	`+ (edge_detector_map)[3 res_ix + i] = static_cast<float>(diff_xyb[i]);`
`1121`	`1121`	`}`
`1122`	`1122`	`}`
`1123`	`1123`	`}`
`@@ -1173,7 +1173,7 @@ void ButteraugliComparator::EdgeDetectorLowFreq(`
`1173`	`1173`	`}`
`1174`	`1174`	`}`
`1175`	`1175`	`for (int i = 0; i < 3; ++i) {`
`1176`		`- (block_diff_ac)[3 res_ix + i] += kMul * max_diff_xyb[i];`
	`1176`	`+ (block_diff_ac)[3 res_ix + i] += static_cast<float>(kMul * max_diff_xyb[i]);`
`1177`	`1177`	`}`
`1178`	`1178`	`}`
`1179`	`1179`	`}`
`@@ -1197,8 +1197,8 @@ void ButteraugliComparator::CombineChannels(`
`1197`	`1197`	`mask[i] = mask_xyb[i][(res_y + 3) * xsize_ + (res_x + 3)];`
`1198`	`1198`	`dc_mask[i] = mask_xyb_dc[i][(res_y + 3) * xsize_ + (res_x + 3)];`
`1199`	`1199`	`}`
`1200`		`- (*result)[res_ix] =`
`1201`		`- (DotProduct(&block_diff_dc[3 * res_ix], dc_mask) +`
	`1200`	`+ (*result)[res_ix] = static_cast<float>(`
	`1201`	`+ DotProduct(&block_diff_dc[3 * res_ix], dc_mask) +`
`1202`	`1202`	`DotProduct(&block_diff_ac[3 * res_ix], mask) +`
`1203`	`1203`	`DotProduct(&edge_detector_map[3 * res_ix], mask));`
`1204`	`1204`	`}`
`@@ -1319,7 +1319,7 @@ void MinSquareVal(size_t square_size, size_t offset,`
`1319`	`1319`	`for (size_t j = minh + 1; j < maxh; ++j) {`
`1320`	`1320`	`min = fmin(min, values[x + j * xsize]);`
`1321`	`1321`	`}`
`1322`		`- tmp[x + y * xsize] = min;`
	`1322`	`+ tmp[x + y * xsize] = static_cast<float>(min);`
`1323`	`1323`	`}`
`1324`	`1324`	`}`
`1325`	`1325`	`for (size_t x = 0; x < xsize; ++x) {`
`@@ -1330,7 +1330,7 @@ void MinSquareVal(size_t square_size, size_t offset,`
`1330`	`1330`	`for (size_t j = minw + 1; j < maxw; ++j) {`
`1331`	`1331`	`min = fmin(min, tmp[j + y * xsize]);`
`1332`	`1332`	`}`
`1333`		`- values[x + y * xsize] = min;`
	`1333`	`+ values[x + y * xsize] = static_cast<float>(min);`
`1334`	`1334`	`}`
`1335`	`1335`	`}`
`1336`	`1336`	`}`
`@@ -1438,7 +1438,7 @@ void DiffPrecompute(`
`1438`	`1438`	`double sup0 = fabs(valsh0[i]) + fabs(valsv0[i]);`
`1439`	`1439`	`double sup1 = fabs(valsh1[i]) + fabs(valsv1[i]);`
`1440`	`1440`	`double m = std::min(sup0, sup1);`
`1441`		`- (*mask)[i][ix] = m;`
	`1441`	`+ (*mask)[i][ix] = static_cast<float>(m);`
`1442`	`1442`	`}`
`1443`	`1443`	`}`
`1444`	`1444`	`}`
`@@ -1483,12 +1483,12 @@ void Mask(const std::vector<std::vector<float> > &xyb0,`
`1483`	`1483`	`const double p1 = w11 * s1;`
`1484`	`1484`	`const double p2 = w22 * s2;`
`1485`	`1485`
`1486`		`- (*mask)[0][idx] = MaskX(p0);`
`1487`		`- (*mask)[1][idx] = MaskY(p1);`
`1488`		`- (*mask)[2][idx] = MaskB(p2);`
`1489`		`- (*mask_dc)[0][idx] = MaskDcX(p0);`
`1490`		`- (*mask_dc)[1][idx] = MaskDcY(p1);`
`1491`		`- (*mask_dc)[2][idx] = MaskDcB(p2);`
	`1486`	`+ (*mask)[0][idx] = static_cast<float>(MaskX(p0));`
	`1487`	`+ (*mask)[1][idx] = static_cast<float>(MaskY(p1));`
	`1488`	`+ (*mask)[2][idx] = static_cast<float>(MaskB(p2));`
	`1489`	`+ (*mask_dc)[0][idx] = static_cast<float>(MaskDcX(p0));`
	`1490`	`+ (*mask_dc)[1][idx] = static_cast<float>(MaskDcY(p1));`
	`1491`	`+ (*mask_dc)[2][idx] = static_cast<float>(MaskDcB(p2));`
`1492`	`1492`	`}`
`1493`	`1493`	`}`
`1494`	`1494`	`for (int i = 0; i < 3; ++i) {`