      "histograms between the source and destination faces."
  )
  
  
  _DEFAULTS = {
      "clip": {
          "default": True,
          "info": "Should components of L*a*b* image be scaled by np.clip before converting "
                  "back to BGR color space?\nIf False then components will be min-max scaled "
                  "appropriately.\nClipping will keep target image brightness truer to the "
                  "input.\nScaling will adjust image brightness to avoid washed out portions in "
                  "the resulting color transfer that can be caused by clipping.",
          "datatype": bool,
          "group": "method",
          "rounding": None,
          "min_max": None,
          "choices": [],
          "gui_radio": False,
          "fixed": True,
      },
      "preserve_paper": {
          "default": True,
          "info": "Should color transfer strictly follow methodology layed out in original "
                  "paper?\nThe method does not always produce aesthetically pleasing results.\n"
                  "If False then L*a*b* components will be scaled using the reciprocal of the "
                  "scaling factor proposed in the paper. This method seems to produce more "
                  "consistently aesthetically pleasing results.",
          "datatype": bool,
          "group": "method",
          "rounding": None,
          "min_max": None,
          "choices": [],
          "gui_radio": False,
          "fixed": True,
      },
  }
 
</s> remove _DEFAULTS = {
    "threshold": {
        "default": 99.0,
        "info": "Adjust the threshold for histogram matching. Can reduce extreme colors "
                "leaking in by filtering out colors at the extreme ends of the histogram "
                "spectrum.",
        "datatype": float,
        "rounding": 1,
        "min_max": (90.0, 100.0),
        "choices": [],
        "gui_radio": False,
        "fixed": True,
    }
}
 </s> add _DEFAULTS = dict(
    threshold=dict(
        default=99.0,
        info="Adjust the threshold for histogram matching. Can reduce extreme colors leaking in "
             "by filtering out colors at the extreme ends of the histogram spectrum.",
        datatype=float,
        rounding=1,
        min_max=(90.0, 100.0),
        choices=[],
        gui_radio=False,
        group="settings",
        fixed=True,
    )
) </s> remove         chk_frame = ttk.Frame(frame, name="chkbuttons", style=f"{self._style}TFrame")
 </s> add         chk_frame = ttk.Frame(frame, name="chkbuttons", style="Group.TFrame") </s> remove         frame = ttk.Frame(self.frame)
 </s> add         frame = ttk.Frame(self.frame, style="Group.TFrame")
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
      "histograms between the source and destination faces."
  )
  
  
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
_DEFAULTS = dict(
    clip=dict(
        default=True,
        info="Should components of L*a*b* image be scaled by np.clip before converting back to "
             "BGR color space?\nIf False then components will be min-max scaled appropriately.\n"
             "Clipping will keep target image brightness truer to the input.\nScaling will adjust "
             "image brightness to avoid washed out portions in the resulting color transfer that "
             "can be caused by clipping.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
    preserve_paper=dict(
        default=True,
        info="Should color transfer strictly follow methodology layed out in original paper?\nThe "
             "method does not always produce aesthetically pleasing results.\nIf False then "
             "L*a*b* components will be scaled using the reciprocal of the scaling factor "
             "proposed in the paper. This method seems to produce more consistently aesthetically "
             "pleasing results.",
        datatype=bool,
        group="method",
        rounding=None,
        min_max=None,
        choices=[],
        gui_radio=False,
        fixed=True,
    ),
)
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace
 GUI updates
  - Control panel fixes
  - Basic themeing support
  - Fix tools to display more natively
  - Give all config items a group 
plugins/convert/color/color_transfer_defaults.py