sinusoidal curves and utils

nodes.py

@@ -313,6 +313,8 @@ class KfCurvesMultiply:
         return (curve_1 * curve_2, )
 
 
+## This seems to not be working properly. I think the issue is upstream in Keyframed
+# TODO: set as experimental?
 class KfCurvesDivide:
     CATEGORY = CATEGORY
     FUNCTION = "main"
@@ -331,6 +333,23 @@ class KfCurvesDivide:
         return (curve_1 / curve_2, )
 
 
+class KfCurveConstant:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE",)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "value": ("FLOAT", {"forceInput": True,})
+                }}
+    
+    def main(self, value):
+        curve = kf.Curve(value)
+        return (curve,)
+
+
 ##################################################################
 
 #### Working with parameter groups
@@ -351,6 +370,237 @@ class KfCurvesDivide:
 # extract a time slice from the parameter group
 
 
+##################################################################
+
+### Sinusoidal
+
+class KfSinusoidalWithFrequency:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE", "SINUSOIDAL_CURVE")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "frequency": ("FLOAT",{
+                    "default": 1/12,
+                    "step": 0.01,
+                }),
+                "phase": ("FLOAT", {
+                    "default": 0.0,
+                    #"min": 0.0,
+                    #"max": 6.28318530718, # 2*pi
+                    "step": 0.1308996939, # pi/24
+                }),
+                "amplitude": ("FLOAT",{
+                    "default": 1,
+                    "step": 0.01,
+                }),
+            },
+        }
+
+    def main(self, frequency, phase, amplitude):
+        curve = kf.SinusoidalCurve(frequency=frequency, phase=phase, amplitude=amplitude)
+        return (curve, curve)
+
+class KfSinusoidalWithWavelength:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE", "SINUSOIDAL_CURVE")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "wavelength": ("FLOAT",{
+                    "default": 12,
+                    "step": 0.5,
+                }),
+                "phase": ("FLOAT", {
+                    "default": 0.0,
+                    #"min": 0.0,
+                    #"max": 6.28318530718, # 2*pi
+                    "step": 0.1308996939, # pi/24
+                }),
+                "amplitude": ("FLOAT",{
+                    "default": 1,
+                    "step": 0.01,
+                }),
+            },
+        }
+
+    def main(self, wavelength, phase, amplitude):
+        curve = kf.SinusoidalCurve(wavelength=wavelength, phase=phase, amplitude=amplitude)
+        return (curve, curve)
+
+
+###   #   ###   #   ###   #   ###   #   ###   #   ###   #   ###   #   ###   #   ###   #
+
+
+class KfSinusoidalAdjustWavelength:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE", "SINUSOIDAL_CURVE")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+                "adjustment": ("FLOAT",{
+                    "default": 0.0,
+                    "step": 0.5,
+                }),
+            }}
+
+    def main(self, curve, adjustment):
+        wavelength, phase, amplitude = curve.wavelength, curve.phase, curve.amplitude 
+        wavelength += adjustment
+        curve = kf.SinusoidalCurve(wavelength=wavelength, phase=phase, amplitude=amplitude)
+        return (curve, curve)
+
+
+class KfSinusoidalAdjustPhase:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE", "SINUSOIDAL_CURVE")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+                "adjustment": ("FLOAT", {
+                    "default": 0.0,
+                    "step": 0.1308996939, # pi/24
+                }),
+            }}
+    
+    def main(self, curve, adjustment):
+        wavelength, phase, amplitude = curve.wavelength, curve.phase, curve.amplitude 
+        phase += adjustment
+        curve = kf.SinusoidalCurve(wavelength=wavelength, phase=phase, amplitude=amplitude)
+        return (curve, curve)
+
+
+class KfSinusoidalAdjustFrequency:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE", "SINUSOIDAL_CURVE")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+                "adjustment": ("FLOAT",{
+                    "default": 0,
+                    "step": 0.01,
+                }),
+            }}
+
+    def main(self, curve, adjustment):
+        wavelength, phase, amplitude = curve.wavelength, curve.phase, curve.amplitude
+        frequency = 1/wavelength
+        frequency += adjustment
+        wavelength = 1/frequency
+        curve = kf.SinusoidalCurve(wavelength=wavelength, phase=phase, amplitude=amplitude)
+        return (curve, curve)
+    
+
+class KfSinusoidalAdjustAmplitude:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("KEYFRAMED_CURVE", "SINUSOIDAL_CURVE")
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+                "adjustment": ("FLOAT",{
+                    "default": 0,
+                    "step": 0.01,
+                }),
+            }}
+
+    def main(self, curve, adjustment):
+        wavelength, phase, amplitude = curve.wavelength, curve.phase, curve.amplitude 
+        amplitude += adjustment
+        curve = kf.SinusoidalCurve(wavelength=wavelength, phase=phase, amplitude=amplitude)
+        return (curve, curve)
+
+
+###   #   ###   #   ###   #   ###   #   ###   #   ###   #   ###   #   ###   #   ###   #
+
+
+class KfSinusoidalGetWavelength:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("FLOAT",)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+            }}
+
+    def main(self, curve):
+        return (curve.wavelength,)
+
+
+class KfSinusoidalGetPhase:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("FLOAT",)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+            }}
+
+    def main(self, curve):
+        return (curve.phase,)
+
+
+class KfSinusoidalGetAmplitude:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("FLOAT",)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+            }}
+
+    def main(self, curve):
+        return (curve.amplitude,)
+
+
+class KfSinusoidalGetFrequency:
+    CATEGORY = CATEGORY
+    FUNCTION = "main"
+    RETURN_TYPES = ("FLOAT",)
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "curve": ("SINUSOIDAL_CURVE",{"forceInput": True,}),
+            }}
+
+    def main(self, curve):
+        return (1/curve.wavelength,)
+
+
+
+
 ##################################################################
 
 NODE_CLASS_MAPPINGS = {
@@ -359,13 +609,26 @@ NODE_CLASS_MAPPINGS = {
     "KfEvaluateCurveAtT": KfEvaluateCurveAtT,
     "KfApplyCurveToCond": KfApplyCurveToCond,
     "KfConditioningAdd": KfConditioningAdd,
+    #"KfCurveToAcnLatentKeyframe": KfCurveToAcnLatentKeyframe,
+    #######################################
     #"KfCurveInverse": KfCurveInverse,
     "KfCurveDraw": KfCurveDraw,
     "KfCurvesAdd": KfCurvesAdd,
     "KfCurvesSubtract": KfCurvesSubtract,
     "KfCurvesMultiply": KfCurvesMultiply,
     "KfCurvesDivide": KfCurvesDivide,
-    #"KfCurveToAcnLatentKeyframe": KfCurveToAcnLatentKeyframe,
+    "KfCurveConstant": KfCurveConstant,
+    #########################
+    "KfSinusoidalWithFrequency": KfSinusoidalWithFrequency,
+    "KfSinusoidalWithWavelength": KfSinusoidalWithWavelength,
+    "KfSinusoidalAdjustWavelength": KfSinusoidalAdjustWavelength,
+    "KfSinusoidalAdjustPhase": KfSinusoidalAdjustPhase,
+    "KfSinusoidalAdjustFrequency": KfSinusoidalAdjustFrequency,
+    "KfSinusoidalAdjustAmplitude": KfSinusoidalAdjustAmplitude,
+    "KfSinusoidalGetWavelength": KfSinusoidalGetWavelength,
+    "KfSinusoidalGetPhase": KfSinusoidalGetPhase,
+    "KfSinusoidalGetAmplitude": KfSinusoidalGetAmplitude,
+    "KfSinusoidalGetFrequency": KfSinusoidalGetFrequency,
 }
 
 # A dictionary that contains the friendly/humanly readable titles for the nodes