diff --git a/__init__.py b/__init__.py index 480d6ec..7cf92ef 100644 --- a/__init__.py +++ b/__init__.py @@ -2,20 +2,27 @@ """ """ +import typing as _t + from .nodes_simple import * from .nodes_upscale import * +from .nodes_prims import * -NODE_CLASS_MAPPINGS = { +NODE_CLASS_MAPPINGS: _t.Dict[str, type] = { "BestResolutionFromArea": BestResolutionFromArea, "BestResolutionFromAreaUpscale": BestResolutionFromAreaUpscale, "BestResolutionFromAspectRatio": BestResolutionFromAspectRatio, "BestResolutionSimple": BestResolutionSimple, + + "BestResolutionPrimResPriority": BestResolutionPrimResPriority, } -NODE_DISPLAY_NAME_MAPPINGS = { +NODE_DISPLAY_NAME_MAPPINGS: _t.Dict[str, str] = { "BestResolutionFromArea": "Best-Res (area)", "BestResolutionFromAreaUpscale": "Best-Res (area+scale)", "BestResolutionFromAspectRatio": "Best-Res (ratio)", "BestResolutionSimple": "Best-Res (simple)", + + "BestResolutionPrimResPriority": "Priority (Best-Res)", } __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"] diff --git a/nodes_prims.py b/nodes_prims.py new file mode 100644 index 0000000..1844027 --- /dev/null +++ b/nodes_prims.py @@ -0,0 +1,88 @@ +# encoding: utf-8 +""" +Supporting primitive nodes for the pack. +""" + +import typing as _t + +from inspect import cleandoc as _cleandoc + +from frozendict import deepfreeze as _deepfreeze + +from .enums import * + +# ---------------------------------------------------------- + +_res_priority_data_type = RoundingPriority.all_values() +_res_priority_data_type_set = set(_res_priority_data_type) + +# _priority_in_type = (_IO.BOOLEAN, { +# 'default': True, 'label_on': 'upscaled', 'label_off': 'original', +# 'tooltip': ( +# "Which of the resolutions is more important to be as close to the desired as possible:\n\n" +# "When ON, the rounded with/height are first calculated for the UPSCALED resolution - and " +# "only then the original ones are back-tracked from them.\n" +# "When OFF, they're first calculated for the ORIGINAL resolution - and " +# "the upscaled ones are tracked forward from them." +# ) +# }) +_res_priority_in_type = ( + _res_priority_data_type, + { + 'default': RoundingPriority.DESIRED.value, + 'tooltip': ( + "Defines what resolution to prioritize, as well as which order to perform rounding in:\n\n" + "• desired - first, approximate resolutions are calculated for both initial and upscaled size; " + "then, both are rounded. In both cases, the rounded resolution is closest to the desired one, " + "but aspect ratio might differ the most between sizes.\n\n" + "• original - first, initial resolution is calculated and rounded; then, upscaled one is detected from it. " + "Upscaled resolution might differ the most from the desired aspect ratio, but it follows the ratio from " + "initial size as much as possible.\n\n" + "• upscaled - vice versa: first, the rounded upscaled resolution is calculated; then, the initial one " + "back-tracked from it." + ) + } +) + +_input_types_prim_priority = _deepfreeze({ + 'required': { + 'priority': _res_priority_in_type + }, + # 'hidden': { + # 'unique_id': 'UNIQUE_ID', + # }, + # 'optional': {}, +}) + + +class BestResolutionPrimResPriority: + """ + 'priority' selector for "Best Resolution" upscale-nodes. + """ + NODE_NAME = 'BestResolutionPrimResPriority' + CATEGORY = "utils/resolution" + DESCRIPTION = _cleandoc(__doc__) + + OUTPUT_NODE = False + + FUNCTION = 'main' + RETURN_TYPES = (_res_priority_data_type,) + RETURN_NAMES = ('priority', ) + # OUTPUT_TOOLTIPS = ('', ) + + @classmethod + def INPUT_TYPES(cls): + return _input_types_prim_priority + + def main( + self, priority: _t.Union[RoundingPriority, str], + # show: bool, + # unique_id: str = None + ): + return (_res_priority_verify(priority), ) + + +def _res_priority_verify(priority: _t.Union[RoundingPriority, str]) -> str: + if priority not in _res_priority_data_type_set: + raise ValueError(f"Invalid value for resolution priority: {priority!r}\nExpected one of: {_res_priority_data_type!r}") + return str(priority) diff --git a/nodes_upscale.py b/nodes_upscale.py index 28a4b69..83c25b6 100644 --- a/nodes_upscale.py +++ b/nodes_upscale.py @@ -21,6 +21,7 @@ from ._funcs import ( from .enums import * from .node_types import * from .nodes_simple import _input_types_area +from .nodes_prims import _res_priority_in_type, _res_priority_verify # ---------------------------------------------------------- @@ -43,35 +44,8 @@ _return_ttips_upscale = _frozendict({ ), }) -# __priority_type = (_IO.BOOLEAN, { -# 'default': True, 'label_on': 'upscaled', 'label_off': 'original', -# 'tooltip': ( -# "Which of the resolutions is more important to be as close to the desired as possible:\n\n" -# "When ON, the rounded with/height are first calculated for the UPSCALED resolution - and " -# "only then the original ones are back-tracked from them.\n" -# "When OFF, they're first calculated for the ORIGINAL resolution - and " -# "the upscaled ones are tracked forward from them." -# ) -# }) -__priority_type = ( - RoundingPriority.all_values(), - { - 'default': RoundingPriority.DESIRED.value, - 'tooltip': ( - "Defines what resolution to prioritize, as well as which order to perform rounding in:\n\n" - "• desired - first, approximate resolutions are calculated for both initial and upscaled size; " - "then, both are rounded. In both cases, the rounded resolution is closest to the desired one, " - "but aspect ratio might differ the most between sizes.\n\n" - "• original - first, initial resolution is calculated and rounded; then, upscaled one is detected from it. " - "Upscaled resolution might differ the most from the desired aspect ratio, but it follows the ratio from " - "initial size as much as possible.\n\n" - "• upscaled - vice versa: first, the rounded upscaled resolution is calculated; then, the initial one " - "back-tracked from it." - ) - } -) __extra_inputs_for_upscale_only = { - 'priority': __priority_type, + 'priority': _res_priority_in_type, 'upscale': (_IO.FLOAT, { 'default': 1.5, 'min': 1.0, 'max': _sys.float_info.max, 'step': 0.25, 'round': 0.001, # 'tooltip': "", # TODO @@ -135,7 +109,7 @@ class BestResolutionFromAreaUpscale: width_f, height_f = _float_width_height_from_area(square_size, landscape, aspect_a, aspect_b) return _upscale_result_from_approx_wh( width_f, height_f, step, - priority, upscale, up_step, + _res_priority_verify(priority), upscale, up_step, # show, unique_id=unique_id, target_square_size=square_size )