diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..2e9440b --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,32 @@ +# V1.1.1 + +- This `CHANGELOG.md` file. +- Prim-node rename (class and internal name, too): `Upscale Strategy (Best-Res)` -> `Crop-Pad Strategy (Best-Res)` +- Inputs/outputs for upscale-related nodes are renamed to be more intuitive. +- `Best-Res (area+scale)`: change (restore) the value returned by `upscale` output. +- Upscale-related nodes: change some defaults. + +āš ļø Active `TODO:` +- Add `upscale` versions for `simple` and `ratio` nodes, too. +- Add options for `crop/pad` node - to determine the order of [crop/pad] -> upscale -> [crop/pad]. + +# V1.1.0 + +The minimally-complete version (full workflow coverage for my own use-case). +- Significant internal refactor. +- New group/category name: `Best Resolution` +- New nodes: + - `Best-Res (area+scale)` + - `Upscaled Crop/Pad (Best-Res)` +- New primitive nodes: + - `Priority (Best-Res)` + - `Upscale Strategy (Best-Res)` + +# v1.0.0 + +The MVP. Contains nodes: +- `Best-Res (simple)` +- `Best-Res (ratio)` +- `Best-Res (area+scale)` + +`TODO: supporting utility nodes (primitives for combo-selectors, calculators for post-upscale res-tweaks with pad/crop).` diff --git a/README.md b/README.md index 652f388..e0599f0 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,9 @@ A small modular pack ā€” nodes for semi-automatic calculation of the best (most optimal) sampling resolution: - ... model-agnostic ā€” i.e., compatible with **ANY** model (from now **or** the future), - ... accounting for upscale, -- ... and for (the essential) pixel-step. +- ... and for (the essential) pixel-step. + +[šŸ”„ Updates ChangeLog](CHANGELOG.md) ![image](img/screenshot1.png) @@ -43,6 +45,14 @@ All you need to know is a size (one side) of square images the model was trained - match the total resolution (i.e., image area, number of pixels) as close to the training one as possible, - ... while still respecting aspect ratio, image orientation and step size. +### Advanced: Upscale support (aka "HD-fix") + +![image](img/screenshot2.png) + +`Best-Res` nodes have a special version _(currently, only `area` node has one)_, which also account for very first upscale aka HD-fix - to ensure the upscaled resolution is also divisible by the step value. + +Additionally, they're accompanied by utility node to also auto-detect any necessary cropping/padding (for out-paint) to perform on the upscaled image before second KSampler (the "HD-fix" itself). + ## Tooltips Each parameter is self-documented in the shortest possible, yet exhaustive detail - just hover mouse over it. If you're new to Comfy and Stable Diffusion, this might be especially helpful. diff --git a/__init__.py b/__init__.py index 0ba59ab..e8a0590 100644 --- a/__init__.py +++ b/__init__.py @@ -15,8 +15,8 @@ NODE_CLASS_MAPPINGS: _t.Dict[str, type] = { "BestResolutionFromAspectRatio": BestResolutionFromAspectRatio, "BestResolutionSimple": BestResolutionSimple, + "BestResolutionPrimCropPadStrategy": BestResolutionPrimCropPadStrategy, "BestResolutionPrimResPriority": BestResolutionPrimResPriority, - "BestResolutionPrimUpStrategy": BestResolutionPrimUpStrategy, "BestResolutionUpscaledCropPad": BestResolutionUpscaledCropPad, } @@ -26,8 +26,8 @@ NODE_DISPLAY_NAME_MAPPINGS: _t.Dict[str, str] = { "BestResolutionFromAspectRatio": "Best-Res (ratio)", "BestResolutionSimple": "Best-Res (simple)", + "BestResolutionPrimCropPadStrategy": "Crop-Pad Strategy (Best-Res)", "BestResolutionPrimResPriority": "Priority (Best-Res)", - "BestResolutionPrimUpStrategy": "Upscale Strategy (Best-Res)", "BestResolutionUpscaledCropPad": "Upscaled Crop/Pad (Best-Res)", } diff --git a/_funcs.py b/_funcs.py index 13c75d9..f701058 100644 --- a/_funcs.py +++ b/_funcs.py @@ -179,56 +179,58 @@ def simple_result_from_approx_wh( return result -def _need_post_resize(width: int, height: int, up_width: int, up_height: int): +def _need_post_resize(width: int, height: int, hd_width: int, hd_height: int): """ Detect whether the final init-res CAN NOT be uniformly scaled to the higher res, and thus would require cropping/out-painting. """ - real_upscale_x: float = float(up_width) / width - real_upscale_y: float = float(up_height) / height + real_upscale_x: float = float(hd_width) / width + real_upscale_y: float = float(hd_height) / height real_upscale_avg: float = (real_upscale_x + real_upscale_y) * 0.5 needs_resize: bool = ( - round_pos_int(real_upscale_avg * width) != up_width or - round_pos_int(real_upscale_avg * height) != up_height + round_pos_int(real_upscale_avg * width) != hd_width or + round_pos_int(real_upscale_avg * height) != hd_height ) return needs_resize, real_upscale_avg, real_upscale_x, real_upscale_y def upscale_result_from_approx_wh( width_f: float, height_f: _t_number, step: int, - priority: _t.Union[RoundingPriority, str], upscale: float, up_step:int, + priority: _t.Union[RoundingPriority, str], upscale: float, hd_step:int, show: bool = True, unique_id: str = None, target_square_size: _t_number = None ) -> ResultUpscaled: """Primary part of the main func for nodes with upscaling - when desired initial-width/height are already calculated.""" upscale = max(float(upscale), 1.0) - up_width_f: float = upscale * width_f - up_height_f: float = upscale * height_f + hd_width_f: float = upscale * width_f + hd_height_f: float = upscale * height_f width_f = float(width_f) step = number_to_int(step) - up_step = number_to_int(up_step) + hd_step = number_to_int(hd_step) if priority == RoundingPriority.DESIRED: width, n_steps_x, height, n_steps_y = round_width_and_height_closest_to_the_ratio(width_f, height_f, step) - up_width, up_steps_x, up_height, up_steps_y = round_width_and_height_closest_to_the_ratio( - up_width_f, up_height_f, up_step + hd_width, hd_steps_x, hd_height, hd_steps_y = round_width_and_height_closest_to_the_ratio( + hd_width_f, hd_height_f, hd_step ) elif priority == RoundingPriority.ORIGINAL: width, n_steps_x, height, n_steps_y = round_width_and_height_closest_to_the_ratio(width_f, height_f, step) - up_width, up_steps_x, up_height, up_steps_y = round_width_and_height_closest_to_the_ratio( - upscale * width, upscale * height, up_step + hd_width, hd_steps_x, hd_height, hd_steps_y = round_width_and_height_closest_to_the_ratio( + upscale * width, upscale * height, hd_step ) else: - up_width, up_steps_x, up_height, up_steps_y = round_width_and_height_closest_to_the_ratio( - up_width_f, up_height_f, up_step + hd_width, hd_steps_x, hd_height, hd_steps_y = round_width_and_height_closest_to_the_ratio( + hd_width_f, hd_height_f, hd_step ) width, n_steps_x, height, n_steps_y = round_width_and_height_closest_to_the_ratio( - float(up_width) / upscale, float(up_height) / upscale, step + float(hd_width) / upscale, float(hd_height) / upscale, step ) - result = ResultUpscaled(upscale, width, height, up_width, up_height) + needs_resize, real_upscale_avg, real_upscale_x, real_upscale_y = _need_post_resize(width, height, hd_width, hd_height) + + result = ResultUpscaled(upscale if needs_resize else real_upscale_avg, width, height, hd_width, hd_height) if not unique_id: return result @@ -240,21 +242,19 @@ def upscale_result_from_approx_wh( report_parts: _t.List[str] = list() for prefix, w_f, h_f, s, w, n_x, h, n_y, trg_sq in [ ('ā—»ļø ', width_f, height_f, step, width, n_steps_x, height, n_steps_y, target_square_size), - ('šŸ”² ', up_width_f, up_height_f, up_step, up_width, up_steps_x, up_height, up_steps_y, _sqrt(up_width_f * up_height_f)) + ('šŸ”² ', hd_width_f, hd_height_f, hd_step, hd_width, hd_steps_x, hd_height, hd_steps_y, _sqrt(hd_width_f * hd_height_f)) ]: cur_report = format_report_simple(w_f, h_f, s, w, n_x, h, n_y, trg_sq) report_parts.append('\n'.join( f"{prefix}{x}" for x in cur_report.split('\n') )) - needs_resize, real_upscale_avg, real_upscale_x, real_upscale_y = _need_post_resize(width, height, up_width, up_height) - separator_line: str = ( # Real upscale factor in X and Y differ enough so we can't get the up-res from init-res with ANY uniform value: f"\n--- āš ļø x{real_upscale_x:.3f} / x{real_upscale_y:.3f} ---\n" if needs_resize # The upscale is uniform: - else f"\n--- x{real_upscale_avg:.3f} ---\n" + else f"\n--- x{real_upscale_avg:.3f}āœ… ---\n" ) text = separator_line.join(report_parts) diff --git a/_funcs_crop_pad.py b/_funcs_crop_pad.py index efc59bb..cdc2d10 100644 --- a/_funcs_crop_pad.py +++ b/_funcs_crop_pad.py @@ -19,10 +19,10 @@ class _CropPadInput: """ upscale: float - orig_w: int - orig_h: int - up_w: int - up_h: int + init_w: int + init_h: int + hd_w: int + hd_h: int strategy: str align_x: float @@ -36,14 +36,14 @@ def _upscaled_crop_xy_offset(extra_w: int, extra_h: int, align_x: float, align_y def _upscaled_crop(_in: _CropPadInput, real_upscale: float) -> ResultUpscaledCropPad: - raw_upscaled_w = _round_pos_int(real_upscale * _in.orig_w) - raw_upscaled_h = _round_pos_int(real_upscale * _in.orig_h) - extra_w = max(raw_upscaled_w - _in.up_w, 0) - extra_h = max(raw_upscaled_h - _in.up_h, 0) + raw_upscaled_w = _round_pos_int(real_upscale * _in.init_w) + raw_upscaled_h = _round_pos_int(real_upscale * _in.init_h) + extra_w = max(raw_upscaled_w - _in.hd_w, 0) + extra_h = max(raw_upscaled_h - _in.hd_h, 0) crop_x_offset, crop_y_offset = _upscaled_crop_xy_offset(extra_w, extra_h, _in.align_x, _in.align_y) return ResultUpscaledCropPad( real_upscale, - True, _in.up_w, _in.up_h, crop_x_offset, crop_y_offset, + True, _in.hd_w, _in.hd_h, crop_x_offset, crop_y_offset, False, 0, 0, 0, 0, ) @@ -57,10 +57,10 @@ def _upscaled_pad_side_values(extra_w: int, extra_h: int, align_x: float, align_ def _upscaled_pad(_in: _CropPadInput, real_upscale: float) -> ResultUpscaledCropPad: - raw_upscaled_w = _round_pos_int(real_upscale * _in.orig_w) - raw_upscaled_h = _round_pos_int(real_upscale * _in.orig_h) - pad_w = max(_in.up_w - raw_upscaled_w, 0) - pad_h = max(_in.up_h - raw_upscaled_h, 0) + raw_upscaled_w = _round_pos_int(real_upscale * _in.init_w) + raw_upscaled_h = _round_pos_int(real_upscale * _in.init_h) + pad_w = max(_in.hd_w - raw_upscaled_w, 0) + pad_h = max(_in.hd_h - raw_upscaled_h, 0) return ResultUpscaledCropPad( real_upscale, False, raw_upscaled_w, raw_upscaled_h, 0, 0, @@ -70,8 +70,8 @@ def _upscaled_pad(_in: _CropPadInput, real_upscale: float) -> ResultUpscaledCrop def _upscaled_crop_delta_pixels(_in: _CropPadInput, result: ResultUpscaledCropPad) -> int: """Calculate the area of total cropped patch for crop-only mode.""" - raw_upscaled_w = _round_pos_int(result.upscale * _in.orig_w) - raw_upscaled_h = _round_pos_int(result.upscale * _in.orig_h) + raw_upscaled_w = _round_pos_int(result.upscale * _in.init_w) + raw_upscaled_h = _round_pos_int(result.upscale * _in.init_h) cropped_w = min(result.crop_width, raw_upscaled_w) cropped_h = min(result.crop_height, raw_upscaled_h) return abs(raw_upscaled_w * raw_upscaled_h - cropped_w * cropped_h) @@ -79,8 +79,8 @@ def _upscaled_crop_delta_pixels(_in: _CropPadInput, result: ResultUpscaledCropPa def _upscaled_pad_delta_pixels(_in: _CropPadInput, result: ResultUpscaledCropPad) -> int: """Calculate the area of total out-painted patch for pad-only mode.""" - raw_upscaled_w = _round_pos_int(result.upscale * _in.orig_w) - raw_upscaled_h = _round_pos_int(result.upscale * _in.orig_h) + raw_upscaled_w = _round_pos_int(result.upscale * _in.init_w) + raw_upscaled_h = _round_pos_int(result.upscale * _in.init_h) padded_w = raw_upscaled_w + max(result.pad_left, 0) + max(result.pad_right, 0) padded_h = raw_upscaled_h + max(result.pad_top, 0) + max(result.pad_bottom, 0) return abs(padded_w * padded_h - raw_upscaled_w * raw_upscaled_h) @@ -88,11 +88,11 @@ def _upscaled_pad_delta_pixels(_in: _CropPadInput, result: ResultUpscaledCropPad def _upscaled_crop_pad(_in: _CropPadInput) -> ResultUpscaledCropPad: """The actual function for "Upscaled Crop/Pad" node - extracted to wrap it with displaying the message.""" - needs_resize, real_upscale_avg, real_upscale_x, real_upscale_y = _need_post_resize(_in.orig_w, _in.orig_h, _in.up_w, _in.up_h) + needs_resize, real_upscale_avg, real_upscale_x, real_upscale_y = _need_post_resize(_in.init_w, _in.init_h, _in.hd_w, _in.hd_h) if not needs_resize: return ResultUpscaledCropPad( real_upscale_avg, - False, _in.up_w, _in.up_h, 0, 0, + False, _in.hd_w, _in.hd_h, 0, 0, False, 0, 0, 0, 0, ) @@ -117,19 +117,19 @@ def _upscaled_crop_pad(_in: _CropPadInput) -> ResultUpscaledCropPad: assert _in.strategy == UpscaledCropPadStrategy.EXACT_UPSCALE upscale = _in.upscale - raw_upscaled_w = _round_pos_int(upscale * _in.orig_w) - raw_upscaled_h = _round_pos_int(upscale * _in.orig_h) + raw_upscaled_w = _round_pos_int(upscale * _in.init_w) + raw_upscaled_h = _round_pos_int(upscale * _in.init_h) # We're in the most complex case. These ^ can be both below and above the target up-res. # So, we need to follow the whole upscale->crop->pad chain: we'll just get zeroes where there will be nothing to do. - cropped_w = min(_in.up_w, raw_upscaled_w) - cropped_h = min(_in.up_h, raw_upscaled_h) + cropped_w = min(_in.hd_w, raw_upscaled_w) + cropped_h = min(_in.hd_h, raw_upscaled_h) crop_extra_w = raw_upscaled_w - cropped_w crop_extra_h = raw_upscaled_h - cropped_h crop_x_offset, crop_y_offset = _upscaled_crop_xy_offset(crop_extra_w, crop_extra_h, _in.align_x, _in.align_y) - pad_extra_w = _in.up_w - cropped_w - pad_extra_h = _in.up_h - cropped_h + pad_extra_w = _in.hd_w - cropped_w + pad_extra_h = _in.hd_h - cropped_h pad_side_values = _upscaled_pad_side_values(pad_extra_w, pad_extra_h, _in.align_x, _in.align_y) return ResultUpscaledCropPad( upscale, @@ -140,7 +140,7 @@ def _upscaled_crop_pad(_in: _CropPadInput) -> ResultUpscaledCropPad: def upscaled_crop_pad( upscale: float, - orig_w: int, orig_h: int, up_w: int, up_h: int, + init_w: int, init_h: int, hd_w: int, hd_h: int, strategy: str, align_x: float, align_y: float, show: bool = True, @@ -153,7 +153,7 @@ def upscaled_crop_pad( # noinspection PyArgumentList result = _upscaled_crop_pad(_CropPadInput( upscale, - orig_w, orig_h, up_w, up_h, + init_w, init_h, hd_w, hd_h, strategy, align_x, align_y, )) @@ -173,8 +173,8 @@ def upscaled_crop_pad( text_parts: _t.List[str] = [f"x{result.upscale:.3f}", ] if result.do_crop: - crop_r = up_w - (result.crop_x_origin + result.crop_width) - crop_b = up_h - (result.crop_y_origin + result.crop_height) + crop_r = hd_w - (result.crop_x_origin + result.crop_width) + crop_b = hd_h - (result.crop_y_origin + result.crop_height) text_parts.append(f"Crop:\nL {result.crop_x_origin}, R {crop_r}, B {crop_b}, T {result.crop_y_origin}") if result.do_padding: diff --git a/enums.py b/enums.py index f3fce28..da1422a 100644 --- a/enums.py +++ b/enums.py @@ -42,16 +42,16 @@ class UpscaledCropPadStrategy(__BaseEnum): how to tweak the image to get there: - ā€¢ pad - upscale the image to fit it into the desired frame on one side, + ā€¢ pad only - upscale the image to fit it into the desired frame on one side, then add missing pixels on the other one for outpaint. - ā€¢ crop - upscale the image to fill the entire frame, then crop extra pixels on one side. + ā€¢ crop only - upscale the image to fill the entire frame, then crop extra pixels on one side. ā€¢ nearest - automatically choose one of the above, to crop/pad the least number of pixels (by area). ā€¢ exact-upscale - follow the provided upscale-value precisely. This is the only option that uses it. Also, it's the only one that might require both outpainting and crop. In case when both are required, the output values assume this order: upscale -> crop -> pad. """ - PAD = 'pad' - CROP = 'crop' + PAD = 'pad only' + CROP = 'crop only' NEAREST = 'nearest' EXACT_UPSCALE = 'exact-upscale' diff --git a/img/screenshot2.png b/img/screenshot2.png new file mode 100644 index 0000000..b06e453 Binary files /dev/null and b/img/screenshot2.png differ diff --git a/node_crop_pad.py b/node_crop_pad.py index 97e3d3b..db8c74f 100644 --- a/node_crop_pad.py +++ b/node_crop_pad.py @@ -50,10 +50,10 @@ _input_types_crop_pad = _deepfreeze({ 'upscale': (_IO.FLOAT, dict(_upscale_in_type[1], **{ 'tooltip': f"Only used when {UpscaledCropPadStrategy.EXACT_UPSCALE!r} strategy selected." })), - 'orig_w': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['orig_w']})), - 'orig_h': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['orig_h']})), - 'up_w': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['up_w']})), - 'up_h': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['up_h']})), + 'init_width': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['init_width']})), + 'init_height': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['init_height']})), + 'HD_width': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['HD_width'], 'default': 1536})), + 'HD_height': (_IO.INT, dict(_type_dict_res, **{'tooltip': _return_ttips_upscale['HD_height'], 'default': 1536})), 'strategy': _up_strategy_in_type, 'align_x': (_IO.FLOAT, dict(_rel_pos_in_type[1], **{ 'tooltip': ( @@ -103,7 +103,7 @@ class BestResolutionUpscaledCropPad: def main( self, upscale: float, - orig_w: int, orig_h: int, up_w: int, up_h: int, + init_width: int, init_height: int, HD_width: int, HD_height: int, strategy: _t.Union[UpscaledCropPadStrategy, str], align_x: float, align_y: float, # show: bool, @@ -111,7 +111,7 @@ class BestResolutionUpscaledCropPad: ): return _upscaled_crop_pad( upscale, - orig_w, orig_h, up_w, up_h, + init_width, init_height, HD_width, HD_height, _up_strategy_verify(strategy), align_x, align_y, # show, diff --git a/nodes_prims.py b/nodes_prims.py index 3d7fe71..0d398a1 100644 --- a/nodes_prims.py +++ b/nodes_prims.py @@ -23,7 +23,7 @@ _res_priority_data_type_set = set(_res_priority_data_type) _res_priority_in_type = ( _res_priority_data_type, { - 'default': RoundingPriority.DESIRED.value, + 'default': RoundingPriority.ORIGINAL, 'tooltip': _format_object_docstring(RoundingPriority), } ) @@ -77,7 +77,7 @@ _up_strategy_data_type_set = set(_up_strategy_data_type) _up_strategy_in_type = ( _up_strategy_data_type, { - 'default': UpscaledCropPadStrategy.EXACT_UPSCALE.value, + 'default': UpscaledCropPadStrategy.PAD, 'tooltip': _format_object_docstring(UpscaledCropPadStrategy), } ) @@ -98,11 +98,11 @@ def _up_strategy_verify(strategy: _t.Union[RoundingPriority, str]) -> str: return str(strategy) -class BestResolutionPrimUpStrategy: +class BestResolutionPrimCropPadStrategy: """ 'strategy' selector for "Upscaled Crop/Pad" node in "Best Resolution" pack. """ - NODE_NAME = 'BestResolutionPrimUpStrategy' + NODE_NAME = 'BestResolutionPrimCropPadStrategy' CATEGORY = _meta.category DESCRIPTION = _format_docstring(_cleandoc(__doc__)) diff --git a/nodes_upscale.py b/nodes_upscale.py index 52d0e37..bff096b 100644 --- a/nodes_upscale.py +++ b/nodes_upscale.py @@ -32,18 +32,27 @@ from .slot_types import ( _return_types_upscale = (_IO.FLOAT, _IO.INT, _IO.INT, _IO.INT, _IO.INT) _return_ttips_upscale = _frozendict({ - 'upscale': "Simply outputs the same upscale-value you've set on the node.", - 'orig_w': "Width for original/initial image", - 'orig_h': "Height for original/initial image", - 'up_w': "Width for the (main) upscaled image", - 'up_h': "Height for the (main) upscaled image", + 'upscale': ( + "If the HD resolution can be achieved by uniformly scaling the initial one " + "(there is \"āœ…\" and not \"āš ļø\" in the upscale-line of the status message), " + "outputs this precise upscale-value (might be different from the one originally set on the node itself).\n\n" + "Otherwise, outputs the original upscale-value intact.\n" + "In this case, you shouldn't use it directly and instead should pass it " + "to the \"Upscaled Crop/Pad (Best-Res)\" node and use the upscale-output from it.\n\n" + "In both cases, it won't hurt to use the \"Upscaled Crop/Pad (Best-Res)\" node and just rely " + "on it's `do_crop` and `do_padding` toggle-outputs." + ), + 'init_width': "Width for original/initial image", + 'init_height': "Height for original/initial image", + 'HD_width': "Width for the (main/upscaled) HD-image", + 'HD_height': "Height for the (main/upscaled) HD-image", }) __extra_inputs_for_upscale_only = { 'priority': _res_priority_in_type, 'upscale': _upscale_in_type, - 'up_step': (_IO.INT, dict(_type_dict_step_upscale1, **{ - 'tooltip': "Same as the main `step`, but for the upscaled resolution.", + 'HD_step': (_IO.INT, dict(_type_dict_step_upscale1, **{ + 'tooltip': "Same as the main `step`, but for the upscaled resolution.\n144 = 8 * 2 * 3 * 3", })), } @@ -94,7 +103,7 @@ class BestResolutionFromAreaUpscale: def main( self, square_size: int, step: int, landscape: bool, aspect_a: float, aspect_b: float, - priority: _t.Union[RoundingPriority, str], upscale: float, up_step:int, + priority: _t.Union[RoundingPriority, str], upscale: float, HD_step:int, # show: bool, unique_id: str = None ): @@ -102,7 +111,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, - _res_priority_verify(priority), upscale, up_step, + _res_priority_verify(priority), upscale, HD_step, # show, unique_id=unique_id, target_square_size=square_size ) diff --git a/pyproject.toml b/pyproject.toml index 3d638e3..260fe20 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,7 +1,7 @@ [project] name = "best-resolution" description = "QoL nodes for semi-automatic calculation of the best (most optimal) sampling resolution \nā€¢ compatible with ANY model (from now or the future), \nā€¢ accounting for upscale... \nā€¢ ...and pixel-step." -version = "1.1.0" +version = "1.1.1" authors = [ {name = "Lex Darlog"} ] diff --git a/return_tuples.py b/return_tuples.py index f8d1e3f..5bfab47 100644 --- a/return_tuples.py +++ b/return_tuples.py @@ -15,10 +15,10 @@ class ResultSimple(_t.NamedTuple): class ResultUpscaled(_t.NamedTuple): """Returned NamedTuple for nodes with upscaling.""" upscale: float - orig_width: int - orig_height: int - up_width: int - up_height: int + init_width: int + init_height: int + hd_width: int + hd_height: int class ResultUpscaledCropPad(_t.NamedTuple): diff --git a/slot_types.py b/slot_types.py index 7118d6c..d79a56a 100644 --- a/slot_types.py +++ b/slot_types.py @@ -23,8 +23,8 @@ def number_type_dict(default: int = 512, min: int = 1, max: int = _sys.maxsize, type_dict_res = number_type_dict(1024) -type_dict_step_init = number_type_dict(48) -type_dict_step_upscale1 = number_type_dict(128) +type_dict_step_init = number_type_dict(8*2*3) +type_dict_step_upscale1 = number_type_dict(8*2*3*3) upscale_in_type = (_IO.FLOAT, { 'default': 1.5, 'min': 1.0, 'max': _sys.float_info.max, 'step': 0.25, 'round': 0.001, @@ -32,4 +32,5 @@ upscale_in_type = (_IO.FLOAT, { }) rel_pos_in_type = (_IO.FLOAT, { 'default': 0.5, 'min': 0.0, 'max': 1.0, 'step': 0.125, 'round': 0.0001, + # 'display': 'slider', # Cosmetic only: display as 'number' or 'slider' })