From e7c4363417723553a1b92687fdeccccc46e88332 Mon Sep 17 00:00:00 2001 From: "Alexander G. Morano" Date: Fri, 16 May 2025 03:14:27 -0400 Subject: [PATCH] trans check calc check vars check --- core/calc.py | 145 +++++++++++++++++++------------------------ core/trans.py | 36 ++++------- core/vars.py | 43 ++++++------- web/widget_vector.js | 3 +- 4 files changed, 98 insertions(+), 129 deletions(-) diff --git a/core/calc.py b/core/calc.py index 936a728..4f0d14d 100644 --- a/core/calc.py +++ b/core/calc.py @@ -183,7 +183,7 @@ OP_UNARY = { # === SUPPORT === # ============================================================================== -def to_bits(value): +def to_bits(value: Any): if isinstance(value, int): return bin(value)[2:] elif isinstance(value, float): @@ -194,22 +194,32 @@ def to_bits(value): else: raise TypeError(f"Unsupported type: {type(value)}") -def vector_swap(pA: Any, pB: Any, swap_x: EnumSwizzle, x:float, swap_y:EnumSwizzle, y:float, - swap_z:EnumSwizzle, z:float, swap_w:EnumSwizzle, w:float) -> List[float]: +def vector_swap(pA: Any, pB: Any, swap_x: EnumSwizzle, swap_y:EnumSwizzle, + swap_z:EnumSwizzle, swap_w:EnumSwizzle, default:List[float]) -> List[float]: """Swap out a vector's values with another vector's values, or a constant fill.""" + def parse(target, targetB, swap, val) -> float: if swap == EnumSwizzle.CONSTANT: return val if swap in [EnumSwizzle.B_X, EnumSwizzle.B_Y, EnumSwizzle.B_Z, EnumSwizzle.B_W]: target = targetB swap = int(swap.value / 10) - return target[swap] if swap < len(target) else 0 + return target[swap] + + while len(pA) < 4: + pA.append(0) + + while len(pB) < 4: + pB.append(0) + + while len(default) < 4: + default.append(0) return [ - parse(pA, pB, swap_x, x), - parse(pA, pB, swap_y, y), - parse(pA, pB, swap_z, z), - parse(pA, pB, swap_w, w) + parse(pA, pB, swap_x, default[0]), + parse(pA, pB, swap_y, default[1]), + parse(pA, pB, swap_z, default[2]), + parse(pA, pB, swap_w, default[3]) ] # ============================================================================== @@ -241,33 +251,27 @@ IMAGE and MASK will return a TRUE bit for any non-black pixel, as a stream of bi Lexicon.VALUE: (COZY_TYPE_NUMERICAL, { "default": None, "tooltip": "Value to convert into bits"}), - Lexicon.BIT: ("INT", { - "default": 8, "min": 1, "max": 64, - "tooltip": "Number of output bits requested"}), - Lexicon.MSB: ("BOOLEAN", { - "default": False}) + Lexicon.BITS: ("INT", { + "default": 8, "min": 0, "max": 64, + "tooltip": "Number of output bits requested"}) } }) return Lexicon._parse(d) def run(self, **kw) -> tuple[List[int], List[bool]]: - value = parse_param(kw, Lexicon.VALUE, EnumConvertType.ANY, 0) - bits = parse_param(kw, Lexicon.BIT, EnumConvertType.INT, 8, 1, 64) - msb = parse_param(kw, Lexicon.MSB, EnumConvertType.INT, False) + value = parse_param(kw, Lexicon.VALUE, EnumConvertType.LIST, 0) + bits = parse_param(kw, Lexicon.BITS, EnumConvertType.INT, 8) params = list(zip_longest_fill(value, bits)) pbar = ProgressBar(len(params)) results = [] for idx, (value, bits) in enumerate(params): - bit_repr = to_bits(value) - if len(bit_repr) > bits: - if msb: - bit_repr = bit_repr[bits] + bit_repr = to_bits(value[0])[::-1] + if bits > 0: + if len(bit_repr) > bits: + bit_repr = bit_repr[0:bits] else: - bit_repr = bit_repr[-bits:] - elif msb: - bit_repr = bit_repr.zfill(bits) - else: - bit_repr = bit_repr.ljust(bits, '0') + bit_repr = bit_repr.ljust(bits, '0') + int_bits = [] bool_bits = [] for b in bit_repr: @@ -314,7 +318,8 @@ Evaluates two inputs (A and B) with a specified comparison operators and optiona "default": EnumComparison.EQUAL.name, "tooltip": "Comparison function. Sends the data in PASS on successful comparison to OUT, otherwise sends the value in FAIL"}), Lexicon.SWAP: ("BOOLEAN", { - "default": False,}), + "default": False, + "tooltip": "Reverse the A and B inputs"}), Lexicon.INVERT: ("BOOLEAN", { "default": False, "tooltip": "Reverse the PASS and FAIL inputs"}), @@ -407,6 +412,7 @@ Evaluates two inputs (A and B) with a specified comparison operators and optiona outs = torch.stack(outs) else: outs = outs[0].unsqueeze(0) + outs = [outs] else: outs = list(outs) return outs, *vals, @@ -443,14 +449,10 @@ Additionally, you can specify the easing function (EASE) and the desired output Lexicon.TYPE: (EnumConvertType._member_names_[:6], { "default": EnumConvertType.FLOAT.name, "tooltip": "Output type desired from resultant operation"}), - Lexicon.EASE: (EnumEase._member_names_, { - "default": EnumEase.LINEAR.name}), Lexicon.DEFAULT_A: ("VEC4", { "default": (0, 0, 0, 0)}), Lexicon.DEFAULT_B: ("VEC4", { - "default": (1,1,1,1)}), - Lexicon.FILL: (EnumFillOperation._member_names_, { - "default": EnumFillOperation.DEFAULT.name}), + "default": (1,1,1,1)}) } }) return Lexicon._parse(d) @@ -458,16 +460,14 @@ Additionally, you can specify the easing function (EASE) and the desired output def run(self, **kw) -> tuple[Any, Any]: A = parse_param(kw, Lexicon.IN_A, EnumConvertType.ANY, 0) B = parse_param(kw, Lexicon.IN_B, EnumConvertType.ANY, 0) - alpha = parse_param(kw, Lexicon.ALPHA,EnumConvertType.VEC4, (0.5,0.5,0.5,0.5), 0, 1) + alpha = parse_param(kw, Lexicon.ALPHA,EnumConvertType.VEC4, (0.5,0.5,0.5,0.5)) typ = parse_param(kw, Lexicon.TYPE, EnumConvertType, EnumConvertType.FLOAT.name) - op = parse_param(kw, Lexicon.EASE, EnumEase, EnumEase.LINEAR.name) a_xyzw = parse_param(kw, Lexicon.DEFAULT_A, EnumConvertType.VEC4, (0, 0, 0, 0)) b_xyzw = parse_param(kw, Lexicon.DEFAULT_B, EnumConvertType.VEC4, (1, 1, 1, 1)) - fill = parse_param(kw, Lexicon.FILL, EnumConvertType.BOOLEAN, False) values = [] - params = list(zip_longest_fill(A, B, alpha, typ, op, a_xyzw, b_xyzw, fill,)) + params = list(zip_longest_fill(A, B, alpha, typ, a_xyzw, b_xyzw)) pbar = ProgressBar(len(params)) - for idx, (A, B, alpha, typ, op, a_xyzw, b_xyzw, fill,) in enumerate(params): + for idx, (A, B, alpha, typ, a_xyzw, b_xyzw) in enumerate(params): size = int(typ.value / 10) if A is None: @@ -486,14 +486,7 @@ Additionally, you can specify the easing function (EASE) and the desired output val_a = [val_a[0]] val_b = [val_b[0]] - # logger.debug([A, B, val_a, val_b, alpha, size]) - - if op == "NONE": - val = [val_b[x] * alpha[x] + val_a[x] * (1 - alpha[x]) for x in range(size)] - else: - # ease = EnumEase[op] - val = [ease_op(op, val_a[x], val_b[x], alpha=alpha[x]) for x in range(size)] - + val = [val_b[x] * alpha[x] + val_a[x] * (1 - alpha[x]) for x in range(size)] convert = int if "INT" in typ.name else float ret = [] for v in val: @@ -538,9 +531,7 @@ Perform single function operations like absolute value, mean, median, mode, magn Lexicon.DEFAULT_A: ("VEC4", { "default": (0,0,0,0), "mij": -sys.maxsize, "maj": sys.maxsize, "precision": 2, - "label": ["X", "Y", "Z", "W"]}), - Lexicon.FILL: (EnumFillOperation._member_names_, { - "default": EnumFillOperation.DEFAULT.name}) + "label": ["X", "Y", "Z", "W"]}) } }) return Lexicon._parse(d) @@ -551,15 +542,14 @@ Perform single function operations like absolute value, mean, median, mode, magn op = parse_param(kw, Lexicon.FUNCTION, EnumUnaryOperation, EnumUnaryOperation.ABS.name) out = parse_param(kw, Lexicon.TYPE, EnumConvertType, EnumConvertType.FLOAT.name) a_xyzw = parse_param(kw, Lexicon.DEFAULT_A, EnumConvertType.VEC4, (0, 0, 0, 0)) - fill = parse_param(kw, Lexicon.FILL, EnumConvertType.BOOLEAN, False) - params = list(zip_longest_fill(A, op, out, a_xyzw, fill)) + params = list(zip_longest_fill(A, op, out, a_xyzw)) pbar = ProgressBar(len(params)) - for idx, (A, op, out, a_xyzw, fill) in enumerate(params): - size = min(3, max(0 if not isinstance(A, (list,)) else len(A))) - best_type = [EnumConvertType.FLOAT, EnumConvertType.VEC2, EnumConvertType.VEC3, EnumConvertType.VEC4][size] + for idx, (A, op, out, a_xyzw) in enumerate(params): + if not isinstance(A, (list, tuple,)): + A = [A] + best_type = [EnumConvertType.FLOAT, EnumConvertType.VEC2, EnumConvertType.VEC3, EnumConvertType.VEC4][len(A)-1] val = parse_value(A, best_type, a_xyzw) val = parse_value(val, EnumConvertType.VEC4, a_xyzw) - # val = [float(v) for v in val] match op: case EnumUnaryOperation.MEAN: val = [sum(val) / len(val)] @@ -595,10 +585,6 @@ Perform single function operations like absolute value, mean, median, mode, magn ret.append(v) val = ret - if fill: - while len(val) < 4: - val.append(val[-1]) - val = parse_value(val, out, 0) results.append(val) pbar.update_absolute(idx) @@ -638,15 +624,10 @@ Execute binary operations like addition, subtraction, multiplication, division, "default": False}), Lexicon.DEFAULT_A: ("VEC4", { "default": (0,0,0,0), "mij": -sys.maxsize, "maj": sys.maxsize, - "precision": 2, "label": ["X", "Y", "Z", "W"]}), Lexicon.DEFAULT_B: ("VEC4", { "default": (0,0,0,0), "mij": -sys.maxsize, "maj": sys.maxsize, - "precision": 2, - "label": ["X", "Y", "Z", "W"]}), - Lexicon.FILL: (EnumFillOperation._member_names_, { - "default": EnumFillOperation.DEFAULT.name}), - + "label": ["X", "Y", "Z", "W"]}) } }) return Lexicon._parse(d) @@ -660,20 +641,20 @@ Execute binary operations like addition, subtraction, multiplication, division, swap = parse_param(kw, Lexicon.SWAP, EnumConvertType.BOOLEAN, False) a_xyzw = parse_param(kw, Lexicon.DEFAULT_A, EnumConvertType.VEC4, (0, 0, 0, 0)) b_xyzw = parse_param(kw, Lexicon.DEFAULT_B, EnumConvertType.VEC4, (0, 0, 0, 0)) - fill = parse_param(kw, Lexicon.FILL, EnumConvertType.BOOLEAN, False) - params = list(zip_longest_fill(A, B, a_xyzw, b_xyzw, op, typ, swap, fill)) + params = list(zip_longest_fill(A, B, a_xyzw, b_xyzw, op, typ, swap)) pbar = ProgressBar(len(params)) - for idx, (A, B, a_xyzw, b_xyzw, op, typ, swap, fill) in enumerate(params): - size = min(3, max(0 if not isinstance(A, (list,)) else len(A), 0 if not isinstance(B, (list,)) else len(B))) + for idx, (A, B, a_xyzw, b_xyzw, op, typ, swap) in enumerate(params): + if not isinstance(A, (list, tuple,)): + A = [A] + if not isinstance(B, (list, tuple,)): + B = [B] + size = min(3, max(len(A)-1, len(B)-1)) best_type = [EnumConvertType.FLOAT, EnumConvertType.VEC2, EnumConvertType.VEC3, EnumConvertType.VEC4][size] val_a = parse_value(A, best_type, a_xyzw) val_a = parse_value(val_a, EnumConvertType.VEC4, a_xyzw) val_b = parse_value(B, best_type, b_xyzw) val_b = parse_value(val_b, EnumConvertType.VEC4, b_xyzw) - #val_a = parse_value(A, EnumConvertType.VEC4, A if A is not None else a_xyzw) - #val_b = parse_value(B, EnumConvertType.VEC4, B if B is not None else b_xyzw) - if swap: val_a, val_b = val_b, val_a @@ -848,7 +829,7 @@ Swap components between two vectors based on specified swizzle patterns and valu Lexicon.IN_A: (COZY_TYPE_NUMERICAL, {}), Lexicon.IN_B: (COZY_TYPE_NUMERICAL, {}), Lexicon.TYPE: (names_convert, { - "default": names_convert[2]}), + "default": names_convert[0]}), Lexicon.SWAP_X: (EnumSwizzle._member_names_, { "default": EnumSwizzle.A_X.name,}), Lexicon.SWAP_Y: (EnumSwizzle._member_names_, { @@ -863,20 +844,24 @@ Swap components between two vectors based on specified swizzle patterns and valu }) return Lexicon._parse(d) - def run(self, **kw) -> tuple[TensorType, ...]: - pA = parse_param(kw, Lexicon.IN_A, EnumConvertType.VEC4, (0,0,0,0)) - pB = parse_param(kw, Lexicon.IN_B, EnumConvertType.VEC4, (0,0,0,0)) + def run(self, **kw) -> tuple[float, ...]: + pA = parse_param(kw, Lexicon.IN_A, EnumConvertType.LIST, None) + pB = parse_param(kw, Lexicon.IN_B, EnumConvertType.LIST, None) + typ = parse_param(kw, Lexicon.TYPE, EnumConvertType, EnumConvertType.VEC2.name) swap_x = parse_param(kw, Lexicon.SWAP_X, EnumSwizzle, EnumSwizzle.A_X.name) swap_y = parse_param(kw, Lexicon.SWAP_Y, EnumSwizzle, EnumSwizzle.A_Y.name) swap_z = parse_param(kw, Lexicon.SWAP_Z, EnumSwizzle, EnumSwizzle.A_W.name) swap_w = parse_param(kw, Lexicon.SWAP_W, EnumSwizzle, EnumSwizzle.A_Z.name) - default = parse_param(kw, Lexicon.DEFAULT, EnumConvertType.VEC4, 0, -sys.maxsize, sys.maxsize) - - params = list(zip_longest_fill(pA, pB, swap_x, x, swap_y, y, swap_z, z, swap_w, w)) + default = parse_param(kw, Lexicon.DEFAULT, EnumConvertType.VEC4, 0) + params = list(zip_longest_fill(pA, pB, typ, swap_x, swap_y, swap_z, swap_w, default)) results = [] pbar = ProgressBar(len(params)) - for idx, (pA, pB, swap_x, x, swap_y, y, swap_z, z, swap_w, w) in enumerate(params): - val = vector_swap(pA, pB, swap_x, x, swap_y, y, swap_z, z, swap_w, w) + for idx, (pA, pB, typ, swap_x, swap_y, swap_z, swap_w, default) in enumerate(params): + default = list(default) + pA = pA + default[len(pA):] + pB = pB + default[len(pB):] + val = vector_swap(pA, pB, swap_x, swap_y, swap_z, swap_w, default) + val = parse_value(val, typ, val) results.append(val) pbar.update_absolute(idx) - return results + return (results,) diff --git a/core/trans.py b/core/trans.py index 006dd09..6e5ad29 100644 --- a/core/trans.py +++ b/core/trans.py @@ -51,8 +51,6 @@ class EnumCropMode(Enum): CENTER = 20 XY = 0 FREE = 10 - HEAD = 15 - BODY = 25 # ============================================================================== # === CLASS === @@ -75,7 +73,7 @@ Extract a portion of an input image or resize it. It supports various cropping m Lexicon.FUNCTION: (EnumCropMode._member_names_, { "default": EnumCropMode.CENTER.name}), Lexicon.XY: ("VEC2", { - "default": (0, 0), "mij": 0.5, "maj": 0.5, + "default": (0, 0), "mij": 0., "maj": 1., "label": ["X", "Y"]}), Lexicon.WH: ("VEC2", { "default": (512, 512), "mij": IMAGE_SIZE_MIN, "int": True, @@ -96,11 +94,11 @@ Extract a portion of an input image or resize it. It supports various cropping m pA = parse_param(kw, Lexicon.IMAGE, EnumConvertType.IMAGE, None) func = parse_param(kw, Lexicon.FUNCTION, EnumCropMode, EnumCropMode.CENTER.name) # if less than 1 then use as scalar, over 1 = int(size) - xy = parse_param(kw, Lexicon.XY, EnumConvertType.VEC2, (0, 0,), 0, 1) - wihi = parse_param(kw, Lexicon.WH, EnumConvertType.VEC2INT, (512, 512), IMAGE_SIZE_MIN) - tltr = parse_param(kw, Lexicon.TLTR, EnumConvertType.VEC4, (0, 0, 0, 1,), 0, 1) - blbr = parse_param(kw, Lexicon.BLBR, EnumConvertType.VEC4, (1, 0, 1, 1,), 0, 1) - matte = parse_param(kw, Lexicon.MATTE, EnumConvertType.VEC4INT, (0, 0, 0, 255), 0, 255) + xy = parse_param(kw, Lexicon.XY, EnumConvertType.VEC2, (0, 0,)) + wihi = parse_param(kw, Lexicon.WH, EnumConvertType.VEC2INT, (512, 512)) + tltr = parse_param(kw, Lexicon.TLTR, EnumConvertType.VEC4, (0, 0, 0, 1,)) + blbr = parse_param(kw, Lexicon.BLBR, EnumConvertType.VEC4, (1, 0, 1, 1,)) + matte = parse_param(kw, Lexicon.MATTE, EnumConvertType.VEC4INT, (0, 0, 0, 255)) params = list(zip_longest_fill(pA, func, xy, wihi, tltr, blbr, matte)) images = [] pbar = ProgressBar(len(params)) @@ -122,10 +120,6 @@ Extract a portion of an input image or resize it. It supports various cropping m pA[..., 3] = alpha[..., 0][:,:] elif func == EnumCropMode.XY: pA = image_crop(pA, width, height, xy) - elif func == EnumCropMode.HEAD: - pass - elif func == EnumCropMode.BODY: - pass else: pA = image_crop_center(pA, width, height) images.append(cv_to_tensor_full(pA, matte)) @@ -166,18 +160,14 @@ Combine multiple input images into a single image by summing their pixel values. # be less dumb when merging pA = [tensor_to_cv(i) for i in imgs] - mode = parse_param(kw, Lexicon.MODE, EnumScaleMode, EnumScaleMode.MATTE.name) - wihi = parse_param(kw, Lexicon.WH, EnumConvertType.VEC2INT, (512, 512), IMAGE_SIZE_MIN) - sample = parse_param(kw, Lexicon.SAMPLE, EnumInterpolation, EnumInterpolation.LANCZOS4.name) - matte = parse_param(kw, Lexicon.MATTE, EnumConvertType.VEC4INT, (0, 0, 0, 255), 0, 255) - + mode = parse_param(kw, Lexicon.MODE, EnumScaleMode, EnumScaleMode.MATTE.name)[0] + wihi = parse_param(kw, Lexicon.WH, EnumConvertType.VEC2INT, (512, 512), IMAGE_SIZE_MIN)[0] + sample = parse_param(kw, Lexicon.SAMPLE, EnumInterpolation, EnumInterpolation.LANCZOS4.name)[0] + matte = parse_param(kw, Lexicon.MATTE, EnumConvertType.VEC4INT, (0, 0, 0, 255))[0] + w, h = wihi + current = image_flatten(pA, w, h, mode=mode, sample=sample) images = [] - params = list(zip_longest_fill(mode, sample, wihi, matte)) - pbar = ProgressBar(len(params)) - for idx, (mode, sample, wihi, matte) in enumerate(params): - current = image_flatten(pA) - images.append(cv_to_tensor_full(current, matte)) - pbar.update_absolute(idx) + images.append(cv_to_tensor_full(current, matte)) return image_stack(images) class StackNode(CozyImageNode): diff --git a/core/vars.py b/core/vars.py index f5accb8..15c6764 100644 --- a/core/vars.py +++ b/core/vars.py @@ -65,13 +65,11 @@ Supplies raw or default values for various data types, supporting vector input w Lexicon.TYPE: (typ, { "default": EnumConvertType.BOOLEAN.name}), Lexicon.DEFAULT_A: ("VEC4", { - "default": (0, 0, 0, 0), #"mij": -sys.maxsize, "maj": sys.maxsize, + "default": (0, 0, 0, 0), "mij": -sys.maxsize, "maj": sys.maxsize, "label": [Lexicon.X, Lexicon.Y, Lexicon.Z, Lexicon.W]}), Lexicon.DEFAULT_B: ("VEC4", { - "default": (1,1,1,1), #"mij": -sys.maxsize, "maj": sys.maxsize, + "default": (1,1,1,1), "mij": -sys.maxsize, "maj": sys.maxsize, "label": [Lexicon.X, Lexicon.Y, Lexicon.Z, Lexicon.W]}), - Lexicon.FILL: (EnumFillOperation._member_names_, { - "default": EnumFillOperation.DEFAULT.name}), Lexicon.SEED: ("INT", { "default": 0, "min": 0, "max": sys.maxsize}), } @@ -80,20 +78,19 @@ Supplies raw or default values for various data types, supporting vector input w def run(self, **kw) -> tuple[tuple[Any, ...]]: raw = parse_param(kw, Lexicon.IN_A, EnumConvertType.ANY, 0) - r_x = parse_param(kw, Lexicon.X, EnumConvertType.FLOAT, None, -sys.maxsize, sys.maxsize) - r_y = parse_param(kw, Lexicon.Y, EnumConvertType.FLOAT, None, -sys.maxsize, sys.maxsize) - r_z = parse_param(kw, Lexicon.Z, EnumConvertType.FLOAT, None, -sys.maxsize, sys.maxsize) - r_w = parse_param(kw, Lexicon.W, EnumConvertType.FLOAT, None, -sys.maxsize, sys.maxsize) + r_x = parse_param(kw, Lexicon.X, EnumConvertType.FLOAT, None) + r_y = parse_param(kw, Lexicon.Y, EnumConvertType.FLOAT, None) + r_z = parse_param(kw, Lexicon.Z, EnumConvertType.FLOAT, None) + r_w = parse_param(kw, Lexicon.W, EnumConvertType.FLOAT, None) typ = parse_param(kw, Lexicon.TYPE, EnumConvertType, EnumConvertType.BOOLEAN.name) xyzw = parse_param(kw, Lexicon.DEFAULT_A, EnumConvertType.VEC4, (0, 0, 0, 0)) yyzw = parse_param(kw, Lexicon.DEFAULT_B, EnumConvertType.VEC4, (1, 1, 1, 1)) - fill = parse_param(kw, Lexicon.FILL, EnumConvertType.BOOLEAN, False) - seed = parse_param(kw, Lexicon.SEED, EnumConvertType.INT, 0, 0) - params = list(zip_longest_fill(raw, r_x, r_y, r_z, r_w, typ, xyzw, yyzw, fill, seed)) + seed = parse_param(kw, Lexicon.SEED, EnumConvertType.INT, 0) + params = list(zip_longest_fill(raw, r_x, r_y, r_z, r_w, typ, xyzw, yyzw, seed)) results = [] pbar = ProgressBar(len(params)) old_seed = -1 - for idx, (raw, r_x, r_y, r_z, r_w, typ, xyzw, yyzw, fill, seed) in enumerate(params): + for idx, (raw, r_x, r_y, r_z, r_w, typ, xyzw, yyzw, seed) in enumerate(params): # default = [x_str] default2 = None a, b, c, d = xyzw @@ -109,10 +106,11 @@ Supplies raw or default values for various data types, supporting vector input w # check if set to randomize.... self.UPDATE = False - if seed != 0 and isinstance(val, (tuple, list,)) and isinstance(val2, (tuple, list,)): + if seed != 0: self.UPDATE = True - # mutable to update - val = list(val) + val = list(val) if isinstance(val, (tuple, list,)) else [val] + val2 = list(val2) if isinstance(val2, (tuple, list,)) else [val2] + for i in range(len(val)): mx = max(val[i], val2[i]) mn = min(val[i], val2[i]) @@ -122,18 +120,13 @@ Supplies raw or default values for various data types, supporting vector input w if old_seed != seed: random.seed(seed) old_seed = seed - if typ in [EnumConvertType.VEC2, EnumConvertType.VEC3, EnumConvertType.VEC4]: - val[i] = mn + random.random() * (mx - mn) - else: + if typ in [EnumConvertType.INT, EnumConvertType.BOOLEAN]: val[i] = random.randint(mn, mx) + else: + val[i] = mn + random.random() * (mx - mn) - out = parse_value(val, typ, val) or 0. - items = [0.,0.,0.,0.] - if not isinstance(out, (list, tuple,)): - items[0] = out - else: - for i in range(len(out)): - items[i] = out[i] + out = parse_value(val, typ, val) + items = [out,0,0,0] if not isinstance(out, (tuple, list,)) else out results.append([out, *items]) pbar.update_absolute(idx) diff --git a/web/widget_vector.js b/web/widget_vector.js index 29e2622..e2c39eb 100644 --- a/web/widget_vector.js +++ b/web/widget_vector.js @@ -267,7 +267,8 @@ const VectorWidget = (app, inputName, options, initial) => { const rawValues = Array.isArray(widget.value) ? widget.value : Object.values(widget.value); - return rawValues.map(v => parseFloat(v)); + const funct = widget.options?.int ? Number : parseFloat; + return rawValues.map(v => funct(v)); }; return widget;