feat: Added extended SDXL resolution nodes

src/comfymath/graphics.py

@@ -1,4 +1,5 @@
-from typing import Any, Mapping
+from abc import ABC, abstractmethod
+from typing import Any, Mapping, Sequence, Tuple
 
 
 SDXL_SUPPORTED_RESOLUTIONS = [
@@ -13,15 +14,60 @@
     (640, 1536, 0.4166666666666667),
 ]
 
+SDXL_EXTENDED_RESOLUTIONS = [
+    (512, 2048, 0.25),
+    (512, 1984, 0.26),
+    (512, 1920, 0.27),
+    (512, 1856, 0.28),
+    (576, 1792, 0.32),
+    (576, 1728, 0.33),
+    (576, 1664, 0.35),
+    (640, 1600, 0.4),
+    (640, 1536, 0.42),
+    (704, 1472, 0.48),
+    (704, 1408, 0.5),
+    (704, 1344, 0.52),
+    (768, 1344, 0.57),
+    (768, 1280, 0.6),
+    (832, 1216, 0.68),
+    (832, 1152, 0.72),
+    (896, 1152, 0.78),
+    (896, 1088, 0.82),
+    (960, 1088, 0.88),
+    (960, 1024, 0.94),
+    (1024, 1024, 1.0),
+    (1024, 960, 1.8),
+    (1088, 960, 1.14),
+    (1088, 896, 1.22),
+    (1152, 896, 1.30),
+    (1152, 832, 1.39),
+    (1216, 832, 1.47),
+    (1280, 768, 1.68),
+    (1344, 768, 1.76),
+    (1408, 704, 2.0),
+    (1472, 704, 2.10),
+    (1536, 640, 2.4),
+    (1600, 640, 2.5),
+    (1664, 576, 2.90),
+    (1728, 576, 3.0),
+    (1792, 576, 3.12),
+    (1856, 512, 3.63),
+    (1920, 512, 3.76),
+    (1984, 512, 3.89),
+    (2048, 512, 4.0),
+]
+
+
+class Resolution(ABC):
+    @classmethod
+    @abstractmethod
+    def resolutions(cls) -> Sequence[Tuple[int, int, float]]: ...
 
-class SDXLResolution:
     @classmethod
     def INPUT_TYPES(cls) -> Mapping[str, Any]:
         return {
             "required": {
-                "resolution": (
-                    [f"{res[0]}x{res[1]}" for res in SDXL_SUPPORTED_RESOLUTIONS],
-                )
+                "resolution": ([f"{res[0]}x{res[1]}" for res in cls.resolutions()],)
             }
         }
 
@@ -35,7 +81,11 @@ def op(self, resolution: str) -> tuple[int, int]:
         return (int(width), int(height))
 
 
-class NearestSDXLResolution:
+class NearestResolution(ABC):
+    @classmethod
+    @abstractmethod
+    def resolutions(cls) -> Sequence[Tuple[int, int, float]]: ...
+
     @classmethod
     def INPUT_TYPES(cls) -> Mapping[str, Any]:
         return {"required": {"image": ("IMAGE",)}}
@@ -52,7 +102,7 @@ def op(self, image) -> tuple[int, int]:
         image_ratio = image_width / image_height
         differences = [
             (abs(image_ratio - resolution[2]), resolution)
-            for resolution in SDXL_SUPPORTED_RESOLUTIONS
+            for resolution in self.resolutions()
         ]
         smallest = None
         for difference in differences:
@@ -67,11 +117,37 @@ def op(self, image) -> tuple[int, int]:
         else:
             width = 1024
             height = 1024
-        print(f"Selected SDXL resolution: {width}x{height}")
+        print(f"Selected resolution: {width}x{height}")
         return (width, height)
 
 
+class SDXLResolution(Resolution):
+    @classmethod
+    def resolutions(cls):
+        return SDXL_SUPPORTED_RESOLUTIONS
+
+
+class SDXLExtendedResolution(Resolution):
+    @classmethod
+    def resolutions(cls):
+        return SDXL_EXTENDED_RESOLUTIONS
+
+
+class NearestSDXLResolution(NearestResolution):
+    @classmethod
+    def resolutions(cls):
+        return SDXL_SUPPORTED_RESOLUTIONS
+
+
+class NearestSDXLExtendedResolution(NearestResolution):
+    @classmethod
+    def resolutions(cls):
+        return SDXL_EXTENDED_RESOLUTIONS
+
+
 NODE_CLASS_MAPPINGS = {
     "CM_SDXLResolution": SDXLResolution,
     "CM_NearestSDXLResolution": NearestSDXLResolution,
+    "CM_SDXLExtendedResolution": SDXLExtendedResolution,
+    "CM_NearestSDXLExtendedResolution": NearestSDXLExtendedResolution,
 }