Function main

tools/compute_mean/uniform_mean.cpp:125–197

int main(int argc, char** argv) {
  if ((argc < 2) || (7 < argc)) {
    show_help(argv[0]);
    return 0;
  }

  int width = 0;         // The width of the output image
  int height = 0;        // The height of the output image
  int num_channels = 0;  // The number of channels of the output image
  int in_depth = CV_8U;  // The depth of the input pixel. The default is unsigned 8-bit [0 255]
  cv::Mat mean_image;    // The mean image to output
  cv::Scalar pixel_m(0.0); // The mean pixel value (in double precision)
  cv::Scalar pixel(0.0); // The pixel value converted to integers to populate the output image
  int out_depth = CV_8U; // The depth of output image. The default is unsigned 8-bit [0 255]


  if ((argc % 2) != 0) { // The depth code of output image is specified
    out_depth = atoi(argv[argc-1]);
    if ((out_depth != CV_8U) && (out_depth != CV_16U)) {
      std::cerr << "Invalid opencv depth code: " << out_depth << std::endl;
      return 0;
    }
    argc --; // so that the rest of argument parsing does not
    // need to care of the presence of the optional argument
  }

  if (argc < 4) { // Given an image, compute the mean pixel value out of the input image
    // Load the image
    cv::Mat mean_image = read_image(argv[1]);
    if (mean_image.empty()) {
      std::cerr << "Could not read the image file: " << argv[1] << std::endl;
      return 0;
    }
    width = mean_image.cols;
    height = mean_image.rows;
    num_channels = mean_image.channels();

    // Compute the mean pixel of the input image, reducing to one value per channel
    pixel_m = reduce_image(mean_image);

    in_depth = mean_image.depth();
  } else { // The pixel value is given
    width = atoi(argv[1]);
    height = atoi(argv[2]);
    num_channels = argc - 3;

    bool is_unit_scaled = true;

    // Set the mean pixel value given in the command-line arguments
    for (int c = 0; c < num_channels; ++c) {
      pixel_m[c] = atof(argv[c+3]);
      if ((pixel_m[c] < 0.0) || (std::numeric_limits<_depth_type(CV_8U)>::max() < pixel_m[c])) {
        std::cerr << "Pixel value must be specified in the scale [0.0 255.0] or in the unit scale [0.0 1.0]";
        return 0;
      }
      // Assume the unit scale if all the channel values are within the range [0.0 1.0]
      if (1.0 < pixel_m[c]) is_unit_scaled = false;
    }