docstr: Calculate a local blur measurement and a image-wide one
docstr_tok: ["Calculate","a","local","blur","measurement","and","a","image-wide","one"]
code: def calculate_focus_scores(self, image_group, workspace):
      """Calculate a local blur measurement and a image-wide one"""
  
      result = []
      for image_name in self.images_to_process(image_group, workspace):
          image = workspace.image_set.get_image(
              image_name, must_be_grayscale=True
          )
          pixel_data = image.pixel_data
          shape = image.pixel_data.shape
          if image.has_mask:
              pixel_data = pixel_data[image.mask]
  
          local_focus_score = []
          for scale_group in image_group.scale_groups:
              scale = scale_group.scale.value
  
              focus_score = 0
              if len(pixel_data):
                  mean_image_value = numpy.mean(pixel_data)
                  squared_normalized_image = (
                      pixel_data - mean_image_value
                  ) ** 2
                  if mean_image_value > 0:
                      focus_score = numpy.sum(
                          squared_normalized_image
                      ) / (
                          numpy.product(pixel_data.shape)
                          * mean_image_value
                      )
              #
              # Create a labels matrix that grids the image to the dimensions
              # of the window size
              #
              if image.dimensions == 2:
                  i, j = numpy.mgrid[0 : shape[0], 0 : shape[1]].astype(
                      float
                  )
                  m, n = (numpy.array(shape) + scale - 1) // scale
                  i = (i * float(m) / float(shape[0])).astype(int)
                  j = (j * float(n) / float(shape[1])).astype(int)
                  grid = i * n + j + 1
                  grid_range = numpy.arange(
                      0, m * n + 1, dtype=numpy.int32
                  )
              else:
                  k, i, j = numpy.mgrid[
                      0 : shape[0], 0 : shape[1], 0 : shape[2]
                  ].astype(float)
                  o, m, n = (numpy.array(shape) + scale - 1) // scale
                  k = (k * float(o) / float(shape[0])).astype(int)
                  i = (i * float(m) / float(shape[1])).astype(int)
                  j = (j * float(n) / float(shape[2])).astype(int)
                  grid = k * o + i * n + j + 1  # hmm
                  grid_range = numpy.arange(
                      0, m * n * o + 1, dtype=numpy.int32
                  )
  
              if image.has_mask:
                  grid[numpy.logical_not(image.mask)] = 0
  
              #
              # Do the math per label
              #
              local_means = (
                  centrosome.cpmorphology.fixup_scipy_ndimage_result(
                      scipy.ndimage.mean(
                          image.pixel_data, grid, grid_range
                      )
                  )
              )
              local_squared_normalized_image = (
                  image.pixel_data - local_means[grid]
              ) ** 2
              #
              # Compute the sum of local_squared_normalized_image values for each
              # grid for means > 0. Exclude grid label = 0 because that's masked
              #
              grid_mask = (local_means != 0) & ~numpy.isnan(local_means)
              nz_grid_range = grid_range[grid_mask]
              if len(nz_grid_range) and nz_grid_range[0] == 0:
                  nz_grid_range = nz_grid_range[1:]
                  local_means = local_means[1:]
                  grid_mask = grid_mask[1:]
              local_focus_score += [
                  0
              ]  # assume the worst - that we can't calculate it
              if len(nz_grid_range):
                  sums = centrosome.cpmorphology.fixup_scipy_ndimage_result(
                      scipy.ndimage.sum(
                          local_squared_normalized_image,
                          grid,
                          nz_grid_range,
                      )
                  )
                  pixel_counts = centrosome.cpmorphology.fixup_scipy_ndimage_result(
                      scipy.ndimage.sum(
                          numpy.ones(shape), grid, nz_grid_range
                      )
                  )
                  local_norm_var = sums / (
                      pixel_counts * local_means[grid_mask]
                  )
                  local_norm_median = numpy.median(local_norm_var)
                  if (
                      numpy.isfinite(local_norm_median)
                      and local_norm_median > 0
                  ):
                      local_focus_score[-1] = (
                          numpy.var(local_norm_var) / local_norm_median
                      )
  
          #
          # Add the measurements
          #
          focus_score_name = "{}_{}_{}".format(
              C_IMAGE_QUALITY, F_FOCUS_SCORE, image_name
          )
          workspace.add_measurement(
              "Image", focus_score_name, focus_score
          )
          result += [
              [
                  "{} focus score @{:d}".format(image_name, scale),
                  focus_score,
              ]
          ]
  
          for idx, scale_group in enumerate(image_group.scale_groups):
              scale = scale_group.scale.value
              local_focus_score_name = "{}_{}_{}_{:d}".format(
                  C_IMAGE_QUALITY,
                  F_LOCAL_FOCUS_SCORE,
                  image_name,
                  scale,
              )
              workspace.add_measurement(
                  "Image",
                  local_focus_score_name,
                  local_focus_score[idx],
              )
              result += [
                  [
                      "{} local focus score @{:d}".format(
                          image_name, scale
                      ),
                      local_focus_score[idx],
                  ]
              ]
  
      return result
  
imports: import itertools
  import logging
  import cellprofiler_core.utilities.image
  import centrosome.cpmorphology
  import centrosome.haralick
  import centrosome.radial_power_spectrum
  import centrosome.threshold
  import centrosome.threshold
  import numpy
  import scipy.linalg.basic
  import scipy.ndimage
  from cellprofiler_core.constants.image import C_SCALING
  from cellprofiler_core.constants.measurement import COLTYPE_FLOAT, EXPERIMENT, MCA_AVAILABLE_POST_RUN
  from cellprofiler_core.constants.module._identify import O_WEIGHTED_VARIANCE, O_ENTROPY, O_FOREGROUND, O_BACKGROUND
  from cellprofiler_core.module import Module
  from cellprofiler_core.preferences import get_headless
  from cellprofiler_core.setting import Divider, HiddenCount, SettingsGroup, Binary, ValidationError
  from cellprofiler_core.setting.choice import Choice
  from cellprofiler_core.setting.do_something import DoSomething, RemoveSettingButton
  from cellprofiler_core.setting.subscriber import ImageListSubscriber
  from cellprofiler_core.setting.text import ImageName, Integer, Float
  from cellprofiler.modules.threshold import O_THREE_CLASS, O_TWO_CLASS
label_desc: Use image node_id 28 for calling the MeasureImageQuality obj's underlying member method code with example usage: obj.calculate_focus_scores(image_group, workspace) and returns: result