code: def create_settings(self):
      self.image_name = ImageSubscriber(
          "Select the input image",
          "None",
          doc="Choose the image you want to flip or rotate.",
      )
  
      self.output_name = ImageName(
          "Name the output image",
          "FlippedOrigBlue",
          doc="Provide a name for the transformed image.",
      )
  
      self.flip_choice = Choice(
          "Select method to flip image",
          FLIP_ALL,
          doc="""\
  Select how the image is to be flipped.""",
      )
  
      self.rotate_choice = Choice(
          "Select method to rotate image",
          ROTATE_ALL,
          doc="""\
  -  *%(ROTATE_NONE)s:* Leave the image unrotated. This should be used if
     you want to flip the image only.
  -  *%(ROTATE_ANGLE)s:* Provide the numerical angle by which the image
     should be rotated.
  -  *%(ROTATE_COORDINATES)s:* Provide the X,Y pixel locations of two
     points in the image that should be aligned horizontally or
     vertically.
  -  *%(ROTATE_MOUSE)s:* CellProfiler will pause so you can select the
     rotation interactively. When prompted during the analysis run, grab
     the image by clicking the left mouse button, rotate the image by
     dragging with the mouse, then release the mouse button. Press the
     *Done* button on the image after rotating the image appropriately.
  """
          % globals(),
      )
  
      self.wants_crop = Binary(
          "Crop away the rotated edges?",
          True,
          doc="""\
  *(Used only when rotating images)*
  
  When an image is rotated, there will be black space at the
  corners/edges; select *Yes* to crop away the incomplete rows and
  columns of the image, or select *No* to leave it as-is.
  
  This cropping will produce an image that is not exactly the same size as
  the original, which may affect downstream modules.
  """
          % globals(),
      )
  
      self.how_often = Choice(
          "Calculate rotation",
          IO_ALL,
          doc="""\
  *(Used only when using “%(ROTATE_MOUSE)s” to rotate images)*
  
  Select the cycle(s) at which the calculation is requested and
  calculated.
  -  *%(IO_INDIVIDUALLY)s:* Determine the amount of rotation for each image individually, e.g., for each cycle.
  -  *%(IO_ONCE)s:* Define the rotation only once (on the first image), then apply it to all images.
  """
          % globals(),
      )
  
      self.first_pixel = Coordinates(
          "Enter coordinates of the top or left pixel",
          (0, 0),
          doc="""\
  *(Used only when using {ROTATE_COORDINATES} to rotate images)*
  
  After rotation, if the specified points are aligned horizontally, this point on the image will be positioned to the
  left of the other point. If the specified points are aligned vertically, this point of the image will be positioned
  above the other point.
  """.format(
              **{"ROTATE_COORDINATES": ROTATE_COORDINATES}
          ),
      )
  
      self.second_pixel = Coordinates(
          "Enter the coordinates of the bottom or right pixel",
          (0, 100),
          doc="""\
  *(Used only when using {ROTATE_COORDINATES} to rotate images)*
  
  After rotation, if the specified points are aligned horizontally, this point on the image will be positioned to the
  right of the other point. If the specified points are aligned vertically, this point of the image will be positioned
  below the other point.
  """.format(
              **{"ROTATE_COORDINATES": ROTATE_COORDINATES}
          ),
      )
  
      self.horiz_or_vert = Choice(
          "Select how the specified points should be aligned",
          C_ALL,
          doc="""\
  *(Used only when using “%(ROTATE_COORDINATES)s” to rotate images)*
  
  Specify whether you would like the coordinate points that you entered to
  be horizontally or vertically aligned after the rotation is complete."""
          % globals(),
      )
  
      self.angle = Float(
          "Enter angle of rotation",
          0,
          doc="""\
  *(Used only when using “%(ROTATE_ANGLE)s” to rotate images)*
  
  Enter the angle you would like to rotate the image. This setting is in
  degrees, with positive angles corresponding to counterclockwise and
  negative as clockwise."""
          % globals(),
      )
  
imports: import numpy
  import scipy.ndimage
  from cellprofiler_core.constants.measurement import IMAGE, COLTYPE_FLOAT
  from cellprofiler_core.image import Image
  from cellprofiler_core.module import Module
  from cellprofiler_core.setting import Binary
  from cellprofiler_core.setting import Coordinates
  from cellprofiler_core.setting.choice import Choice
  from cellprofiler_core.setting.subscriber import ImageSubscriber
  from cellprofiler_core.setting.text import ImageName, Float
label_desc: Use image node_id 1 for calling the FlipAndRotate obj's underlying member method code with example usage: obj.create_settings() without return types