code: def create_settings(self):
      super(EnhanceOrSuppressFeatures, self).create_settings()
  
      self.method = Choice(
          "Select the operation",
          [ENHANCE, SUPPRESS],
          doc="""\
  Select whether you want to enhance or suppress the features you
  designate.
  
  -  *{ENHANCE}:* Produce an image whose intensity is largely composed
     of the features of interest.
  -  *{SUPPRESS}:* Produce an image with the features largely removed.
  """.format(
              **{"ENHANCE": ENHANCE, "SUPPRESS": SUPPRESS}
          ),
      )
  
      self.enhance_method = Choice(
          "Feature type",
          [
              E_SPECKLES,
              E_NEURITES,
              E_DARK_HOLES,
              E_CIRCLES,
              E_TEXTURE,
              E_DIC,
          ],
          doc="""\
  *(Used only if "{ENHANCE}" is selected)*
  
  This module can enhance several kinds of image features:
  
  -  *{E_SPECKLES}:* A speckle is an area of enhanced intensity
     relative to its immediate neighborhood. The module enhances speckles
     using a white tophat filter, which is the image minus the
     morphological grayscale opening of the image. The opening operation
     first suppresses the speckles by applying a grayscale erosion to
     reduce everything within a given radius to the lowest value within
     that radius, then uses a grayscale dilation to restore objects larger
     than the radius to an approximation of their former shape. The white
     tophat filter enhances speckles by subtracting the effects of opening
     from the original image.
  -  *{E_NEURITES}:* Neurites are taken to be long, thin features of
     enhanced intensity. Choose this option to enhance the intensity of
     the neurites using the {N_GRADIENT} or {N_TUBENESS} methods
     described in a later setting.
  -  *{E_DARK_HOLES}:* The module uses morphological reconstruction
     (the rolling-ball algorithm) to identify dark holes within brighter
     areas, or brighter ring shapes. The image is inverted so that the
     dark holes turn into bright peaks. The image is successively eroded
     and the eroded image is reconstructed at each step, resulting in an
     image that is missing the peaks. Finally, the reconstructed image is
     subtracted from the previous reconstructed image. This leaves
     circular bright spots with a radius equal to the number of iterations
     performed.
  -  *{E_CIRCLES}:* The module calculates the circular Hough transform
     of the image at the diameter given by the feature size. The Hough
     transform will have the highest intensity at points that are centered
     within a ring of high intensity pixels where the ring diameter is the
     feature size. You may want to use the **EnhanceEdges** module to find
     the edges of your circular object and then process the output by
     enhancing circles. You can use **IdentifyPrimaryObjects** to find the
     circle centers and then use these centers as seeds in
     **IdentifySecondaryObjects** to find whole, circular objects using a
     watershed.
  -  *{E_TEXTURE}:* This option produces an image
     whose intensity is the variance among nearby pixels. The method
     weights pixel contributions by distance using a Gaussian to calculate
     the weighting. You can use this method to separate foreground from
     background if the foreground is textured and the background is not.
  -  *{E_DIC}:* This method recovers the optical density of a DIC image
     by integrating in a direction perpendicular to the shear direction of
     the image.
  
  """.format(
              **{
                  "E_CIRCLES": E_CIRCLES,
                  "E_DARK_HOLES": E_DARK_HOLES,
                  "E_DIC": E_DIC,
                  "N_GRADIENT": N_GRADIENT,
                  "E_NEURITES": E_NEURITES,
                  "E_SPECKLES": E_SPECKLES,
                  "E_TEXTURE": E_TEXTURE,
                  "ENHANCE": ENHANCE,
                  "N_TUBENESS": N_TUBENESS,
              }
          ),
      )
  
      self.object_size = Integer(
          "Feature size",
          10,
          2,
          doc="""\
  *(Used only if “{E_CIRCLES}”, “{E_SPECKLES}” or “{E_NEURITES}” are
  selected, or if suppressing features)*
  
  Enter the diameter of the largest speckle, the width of the circle, or
  the width of the neurites to be enhanced or suppressed, which will be
  used to calculate an appropriate filter size.
  
  {HELP_ON_MEASURING_DISTANCES}
  """.format(
              **{
                  "E_CIRCLES": E_CIRCLES,
                  "E_NEURITES": E_NEURITES,
                  "E_SPECKLES": E_SPECKLES,
                  "HELP_ON_MEASURING_DISTANCES": _help.HELP_ON_MEASURING_DISTANCES,
              }
          ),
      )
  
      self.hole_size = IntegerRange(
          "Range of hole sizes",
          value=(1, 10),
          minval=1,
          doc="""\
  *(Used only if "{E_DARK_HOLES}" is selected)*
  
  The range of hole sizes to be enhanced. The algorithm will identify only
  holes whose diameters fall between these two values.
  """.format(
              **{"E_DARK_HOLES": E_DARK_HOLES}
          ),
      )
  
      self.smoothing = Float(
          "Smoothing scale",
          value=2.0,
          minval=0.0,
          doc="""\
  *(Used only for the "{E_TEXTURE}", "{E_DIC}" or "{E_NEURITES}" methods)*
  
  -  *{E_TEXTURE}*: This is roughly the scale of the texture features, in
     pixels. The algorithm uses the smoothing value entered as the sigma
     of the Gaussian used to weight nearby pixels by distance in the
     variance calculation.
  -  *{E_DIC}:* Specifies the amount of smoothing of the image in the
     direction parallel to the shear axis of the image. The line
     integration method will leave streaks in the image without smoothing
     as it encounters noisy pixels during the course of the integration.
     The smoothing takes contributions from nearby pixels, which decreases
     the noise but smooths the resulting image. Increase the smoothing to eliminate streakiness and
     decrease the smoothing to sharpen the image.
  -  *{E_NEURITES}:* The *{N_TUBENESS}* option uses this scale as the
     sigma of the Gaussian used to smooth the image prior to gradient
     detection.
  
  |image0| Smoothing can be turned off by entering a value of zero, but
  this is not recommended.
  
  .. |image0| image:: {PROTIP_AVOID_ICON}
  """.format(
              **{
                  "E_DIC": E_DIC,
                  "E_NEURITES": E_NEURITES,
                  "E_TEXTURE": E_TEXTURE,
                  "N_TUBENESS": N_TUBENESS,
                  "PROTIP_AVOID_ICON": _help.PROTIP_AVOID_ICON,
              }
          ),
      )
  
      self.angle = Float(
          "Shear angle",
          value=0,
          doc="""\
  *(Used only for the "{E_DIC}" method)*
  
  The shear angle is the direction of constant value for the shadows and
  highlights in a DIC image. The gradients in a DIC image run in the
  direction perpendicular to the shear angle. For example, if the shadows
  run diagonally from lower left to upper right and the highlights appear
  above the shadows, the shear angle is 45°. If the shadows appear on top,
  the shear angle is 180° + 45° = 225°.
  """.format(
              **{"E_DIC": E_DIC}
          ),
      )
  
      self.decay = Float(
          "Decay",
          value=0.95,
          minval=0.1,
          maxval=1,
          doc="""\
  *(Used only for the "{E_DIC}" method)*
  
  The decay setting applies an exponential decay during the process of
  integration by multiplying the accumulated sum by the decay at each
  step. This lets the integration recover from accumulated error during
  the course of the integration, but it also results in diminished
  intensities in the middle of large objects. Set the decay to a large
  value, on the order of 1 - 1/diameter of your objects if the intensities
  decrease toward the middle. Set the decay to a small value if there
  appears to be a bias in the integration direction.
  """.format(
              **{"E_DIC": E_DIC}
          ),
      )
  
      self.neurite_choice = Choice(
          "Enhancement method",
          [N_TUBENESS, N_GRADIENT],
          doc="""\
  *(Used only for the "{E_NEURITES}" method)*
  
  Two methods can be used to enhance neurites:
  
  -  *{N_TUBENESS}*: This method is an adaptation of the method used by
     the `ImageJ Tubeness plugin`_. The image is smoothed with a Gaussian.
     The Hessian is then computed at every point to measure the intensity
     gradient and the eigenvalues of the Hessian are computed to determine
     the magnitude of the intensity. The absolute maximum of the two
     eigenvalues gives a measure of the ratio of the intensity of the
     gradient in the direction of its most rapid descent versus in the
     orthogonal direction. The output image is the absolute magnitude of
     the highest eigenvalue if that eigenvalue is negative (white neurite
     on dark background), otherwise, zero.
  -  *{N_GRADIENT}*: The module takes the difference of the white and
     black tophat filters (a white tophat filtering is the image minus the
     morphological grayscale opening of the image; a black tophat
     filtering is the morphological grayscale closing of the image minus
     the image). The effect is to enhance lines whose width is the
     feature size.
  
  .. _ImageJ Tubeness plugin: http://www.longair.net/edinburgh/imagej/tubeness/
  """.format(
              **{
                  "E_NEURITES": E_NEURITES,
                  "N_GRADIENT": N_GRADIENT,
                  "N_TUBENESS": N_TUBENESS,
              }
          ),
      )
  
      self.speckle_accuracy = Choice(
          "Speed and accuracy",
          choices=[S_FAST, S_SLOW],
          doc="""\
  *(Used only for the "{E_SPECKLES}" method)*
  
  *{E_SPECKLES}* can use a fast or slow algorithm to find speckles.
  
  -  *{S_FAST}:* Select this option for speckles that have a large radius
     (greater than 10 pixels) and need not be exactly circular.
  -  *{S_SLOW}:* Use for speckles of small radius.
  """.format(
              **{
                  "E_SPECKLES": E_SPECKLES,
                  "S_FAST": S_FAST,
                  "S_SLOW": S_SLOW,
              }
          ),
      )
  
      self.wants_rescale = Binary(
          "Rescale result image",
          False,
          doc="""\
  *(Used only for the "{E_NEURITES}" method)*
  
  *{E_NEURITES}* can rescale the resulting values to use the 
  whole intensity range of the image (0-1). This can make 
  the output easier to display.
  """.format(
              **{"E_NEURITES": E_NEURITES}
          ),
      )
  
imports: import centrosome.filter
  import numpy
  import scipy.ndimage
  import skimage.exposure
  import skimage.filters
  import skimage.morphology
  import skimage.transform
  from cellprofiler_core.image import Image
  from cellprofiler_core.module import ImageProcessing
  from cellprofiler_core.setting import Binary
  from cellprofiler_core.setting.choice import Choice
  from cellprofiler_core.setting.range import IntegerRange
  from cellprofiler_core.setting.text import Float
  from cellprofiler_core.setting.text import Integer
  from cellprofiler.modules import _help
label_desc: Use image node_id 1 for calling the EnhanceOrSuppressFeatures obj's underlying member method code with example usage: obj.create_settings() without return types