From dd771b10353c14ee001395fc53de576f8492dfd2 Mon Sep 17 00:00:00 2001
From: Limitex <76650151+Limitex@users.noreply.github.com>
Date: Tue, 26 Dec 2023 01:35:30 +0900
Subject: [PATCH] Added CenterCalculationNode

---
 example_node.py | 105 +++++++++---------------------------------------
 1 file changed, 19 insertions(+), 86 deletions(-)

diff --git a/example_node.py b/example_node.py
index 733014f..f0fabb6 100644
--- a/example_node.py
+++ b/example_node.py
@@ -1,102 +1,35 @@
-class Example:
-    """
-    A example node
-
-    Class methods
-    -------------
-    INPUT_TYPES (dict): 
-        Tell the main program input parameters of nodes.
-
-    Attributes
-    ----------
-    RETURN_TYPES (`tuple`): 
-        The type of each element in the output tulple.
-    RETURN_NAMES (`tuple`):
-        Optional: The name of each output in the output tulple.
-    FUNCTION (`str`):
-        The name of the entry-point method. For example, if `FUNCTION = "execute"` then it will run Example().execute()
-    OUTPUT_NODE ([`bool`]):
-        If this node is an output node that outputs a result/image from the graph. The SaveImage node is an example.
-        The backend iterates on these output nodes and tries to execute all their parents if their parent graph is properly connected.
-        Assumed to be False if not present.
-    CATEGORY (`str`):
-        The category the node should appear in the UI.
-    execute(s) -> tuple || None:
-        The entry point method. The name of this method must be the same as the value of property `FUNCTION`.
-        For example, if `FUNCTION = "execute"` then this method's name must be `execute`, if `FUNCTION = "foo"` then it must be `foo`.
-    """
-    def __init__(self):
-        pass
-    
+class CenterCalculationNode:
     @classmethod
     def INPUT_TYPES(s):
-        """
-            Return a dictionary which contains config for all input fields.
-            Some types (string): "MODEL", "VAE", "CLIP", "CONDITIONING", "LATENT", "IMAGE", "INT", "STRING", "FLOAT".
-            Input types "INT", "STRING" or "FLOAT" are special values for fields on the node.
-            The type can be a list for selection.
-
-            Returns: `dict`:
-                - Key input_fields_group (`string`): Can be either required, hidden or optional. A node class must have property `required`
-                - Value input_fields (`dict`): Contains input fields config:
-                    * Key field_name (`string`): Name of a entry-point method's argument
-                    * Value field_config (`tuple`):
-                        + First value is a string indicate the type of field or a list for selection.
-                        + Secound value is a config for type "INT", "STRING" or "FLOAT".
-        """
         return {
             "required": {
-                "image": ("IMAGE",),
-                "int_field": ("INT", {
-                    "default": 0, 
-                    "min": 0, #Minimum value
-                    "max": 4096, #Maximum value
-                    "step": 64, #Slider's step
-                    "display": "number" # Cosmetic only: display as "number" or "slider"
-                }),
-                "float_field": ("FLOAT", {
-                    "default": 1.0,
-                    "min": 0.0,
-                    "max": 10.0,
-                    "step": 0.01,
-                    "round": 0.001, #The value represeting the precision to round to, will be set to the step value by default. Can be set to False to disable rounding.
-                    "display": "number"}),
-                "print_to_screen": (["enable", "disable"],),
-                "string_field": ("STRING", {
-                    "multiline": False, #True if you want the field to look like the one on the ClipTextEncode node
-                    "default": "Hello World!"
-                }),
+                "outer_with": ("INT", {"default": 0}),
+                "outer_height": ("INT", {"default": 0}),
+                "inner_with": ("INT", {"default": 0}),
+                "inner_height": ("INT", {"default": 0}),
+                "x_position": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0,}),
+                "y_position": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0,}),
             },
         }
 
-    RETURN_TYPES = ("IMAGE",)
-    #RETURN_NAMES = ("image_output_name",)
+    RETURN_TYPES = ("INT", "INT", "INT", "INT", "INT", "INT", )
+    RETURN_NAMES = ("outer_with", "outer_height", "inner_with", "inner_height", "inner_x", "inner_y", )
 
-    FUNCTION = "test"
+    FUNCTION = "center_calc"
 
-    #OUTPUT_NODE = False
+    CATEGORY = "Calculation"
 
-    CATEGORY = "Example"
+    def center_calc(self, outer_with: int, outer_height: int, inner_with: int, inner_height: int, x_position: float, y_position: float):
+        center_x = (outer_with - inner_with) / 2
+        center_y = (outer_height - inner_height) / 2
+        center_x += x_position * center_x
+        center_y += y_position * center_y
+        return (outer_with, outer_height, inner_with, inner_height, int(center_x), int(center_y), )
 
-    def test(self, image, string_field, int_field, float_field, print_to_screen):
-        if print_to_screen == "enable":
-            print(f"""Your input contains:
-                string_field aka input text: {string_field}
-                int_field: {int_field}
-                float_field: {float_field}
-            """)
-        #do some processing on the image, in this example I just invert it
-        image = 1.0 - image
-        return (image,)
-
-
-# A dictionary that contains all nodes you want to export with their names
-# NOTE: names should be globally unique
 NODE_CLASS_MAPPINGS = {
-    "Example": Example
+    "CenterCalculation": CenterCalculationNode
 }
 
-# A dictionary that contains the friendly/humanly readable titles for the nodes
 NODE_DISPLAY_NAME_MAPPINGS = {
-    "Example": "Example Node"
+    "CenterCalculation": "Center Calculation"
 }