nodes/Amorano-Jovimetrix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

trans check

Browse Source 
calc check
vars check
This commit is contained in:
Alexander G. Morano
2025-05-16 03:14:27 -04:00
parent c97e5a8648
commit e7c4363417
4 changed files with 98 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/calc.py
+65 -80
View File
@@ -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,)
core/trans.py
+13 -23
View File
@@ -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):
core/vars.py
+18 -25
View File
@@ -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)
web/widget_vector.js
+2 -1
View File
@@ -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;