From 9514c083c695dc753dcf8226e0c1ef7fb7e7406f Mon Sep 17 00:00:00 2001 From: Benjamin A Narum Date: Mon, 10 Jun 2024 18:55:23 +0200 Subject: [PATCH] Delete SigmaWaveFormNode directory --- SigmaWaveFormNode/__init__.py | 22 - .../__pycache__/__init__.cpython-311.pyc | Bin 807 -> 0 bytes .../sigma_waveform_node.cpython-311.pyc | Bin 28258 -> 0 bytes SigmaWaveFormNode/requirements.txt | 2 - SigmaWaveFormNode/sigma_waveform_node.py | 601 ------------------ 5 files changed, 625 deletions(-) delete mode 100644 SigmaWaveFormNode/__init__.py delete mode 100644 SigmaWaveFormNode/__pycache__/__init__.cpython-311.pyc delete mode 100644 SigmaWaveFormNode/__pycache__/sigma_waveform_node.cpython-311.pyc delete mode 100644 SigmaWaveFormNode/requirements.txt delete mode 100644 SigmaWaveFormNode/sigma_waveform_node.py diff --git a/SigmaWaveFormNode/__init__.py b/SigmaWaveFormNode/__init__.py deleted file mode 100644 index 0fb325f..0000000 --- a/SigmaWaveFormNode/__init__.py +++ /dev/null @@ -1,22 +0,0 @@ -from .sigma_waveform_node import SigmaWaveFormNodeSimple, SigmaWaveFormNode, SigmaWaveFormNodeAdvanced, FourierFilterNode, PhaseLockedLoopNode, AttenuatorNode - - -# Node class mappings -NODE_CLASS_MAPPINGS = { - "SigmaWaveFormNodeSimple": SigmaWaveFormNodeSimple, - "SigmaWaveFormNode": SigmaWaveFormNode, - "SigmaWaveFormNodeAdvanced": SigmaWaveFormNodeAdvanced, - "FourierFilterNode": FourierFilterNode, - "PhaseLockedLoopNode": PhaseLockedLoopNode, - "AttenuatorNode": AttenuatorNode -} - -# Node display name mappings -NODE_DISPLAY_NAME_MAPPINGS = { - "SigmaWaveFormNodeSimple": "Sigma Waveform Node Simple", - "SigmaWaveFormNode": "Sigma Waveform Node", - "SigmaWaveFormNodeAdvanced": "Sigma Waveform Node Advanced", - "FourierFilterNode": "Fourier Filter Node", - "PhaseLockedLoopNode": "Phase Locked Loop Node", - "AttenuatorNode": "Attenuator Node" -} diff --git a/SigmaWaveFormNode/__pycache__/__init__.cpython-311.pyc b/SigmaWaveFormNode/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 758a86ceb4b06c1a5cb64e3b0ca6a0a0e678526c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 807 zcmcJM&uiN-6vrk1N?OQDF{C6N#f8Dh4!P_wC}qPW&B#c-fGK0fAiPNF%p%Lkc0+yL zAF&;FA3N-S+0ppA({6^|dYWV>+n~Kph_9vZdw%bO-q%iN7l`$FvRr;t0r)8|+tu0} zZeEGQCx8KlD?p(Ksp2VA^;D{P8r40W8lC|GfkYuH(TGkA48Is&3oBT~8rHFaTeZ{1 zZ5Ir7enC-iV3Y@Lcu9jd!4;V>P927c8`5}1%KbZmvUkU_@l_Bl2rl<0EaM^JlW>(1 zF3XhW{C$v+8C!fHc*a;4ifjY^B1=+6Yq-R(ALQQw`Ur(lm?AWcuW#F@l;Lbe zp7TA?R1Q7)E~HW+gp~pyQYvBpC*1|sv!eH;I6jejI4ru4s!r=bv=s6Km{k{8r$ujA Z9KVoy__XLg770f(;YcL(o6S3d_&2gZ^D+Pc diff --git a/SigmaWaveFormNode/__pycache__/sigma_waveform_node.cpython-311.pyc b/SigmaWaveFormNode/__pycache__/sigma_waveform_node.cpython-311.pyc deleted file mode 100644 index 9e70e8853dcfc7de49150ab9983b1c61538a4707..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 28258 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 Np&ks?$}el{{})3zh)Dnd diff --git a/SigmaWaveFormNode/requirements.txt b/SigmaWaveFormNode/requirements.txt deleted file mode 100644 index cb7cce0..0000000 --- a/SigmaWaveFormNode/requirements.txt +++ /dev/null @@ -1,2 +0,0 @@ -numpy -torch diff --git a/SigmaWaveFormNode/sigma_waveform_node.py b/SigmaWaveFormNode/sigma_waveform_node.py deleted file mode 100644 index f53435a..0000000 --- a/SigmaWaveFormNode/sigma_waveform_node.py +++ /dev/null @@ -1,601 +0,0 @@ -import numpy as np -import torch - - -def loglinear_interp(t_steps, num_steps): - """ - Performs log-linear interpolation of a given array of decreasing numbers. - """ - xs = np.linspace(0, 1, len(t_steps)) - ys = np.log(t_steps[::-1]) - - new_xs = np.linspace(0, 1, num_steps) - new_ys = np.interp(new_xs, xs, ys) - - interped_ys = np.exp(new_ys)[::-1].copy() - return interped_ys - -def RESDECoeffsSecondOrder(h): - """ - Calculate the coefficients for the RES solver. - """ - b1 = 1.0 - 0.5 * h - b2 = 0.5 * h - return b1, b2 - -class SigmaWaveFormNodeSimple: - def __init__(self): - self.steps = 200 - self.amplitude = 3.0 - self.frequency = 0.1 - self.damping_factor = 0.03 - self.waveform_type = "sine" - self.enable_unidirectional = True - - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "steps": ("INT", {"default": 200, "min": 1, "max": 1000, "step": 1}), - "amplitude": ("FLOAT", {"default": 3.0, "min": 0.1, "max": 10.0, "step": 0.1}), - "frequency": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 1.0, "step": 0.01}), - "damping_factor": ("FLOAT", {"default": 0.03, "min": 0.001, "max": 0.1, "step": 0.001}), - "waveform_type": (["sine", "sawtooth", "stepped", "square", "random"], {"default": "sine"}), - "enable_unidirectional": ("BOOLEAN", {"default": True, "description": "Whether to make the waveform unidirectional"}), - }, - } - - RETURN_TYPES = ("SIGMAS",) - RETURN_NAMES = ("sigmas",) - FUNCTION = "generate_sigma_sequence" - CATEGORY = "sampling/custom_sampling/schedulers" - - def generate_sine_wave(self, t): - return self.amplitude * np.exp(-self.damping_factor * t) * np.sin(2 * np.pi * self.frequency * t) - - def generate_sawtooth_wave(self, t): - return self.amplitude * np.exp(-self.damping_factor * t) * 2 * (t * self.frequency - np.floor(0.5 + t * self.frequency)) - - def generate_stepped_wave(self, t): - steps_per_segment = self.steps // 10 - return np.repeat(np.linspace(self.amplitude, -self.amplitude, 10), steps_per_segment) - - def generate_square_wave(self, t): - return self.amplitude * np.exp(-self.damping_factor * t) * np.sign(np.sin(2 * np.pi * self.frequency * t)) - - def generate_random_wave(self, t): - return self.amplitude * np.exp(-self.damping_factor * t) * (2 * np.random.rand(self.steps) - 1) - - def make_unidirectional(self, sigma): - return sigma - np.min(sigma) - - def generate_sigma_sequence(self, steps, amplitude, frequency, damping_factor, waveform_type, enable_unidirectional): - self.steps = steps - self.amplitude = amplitude - self.frequency = frequency - self.damping_factor = damping_factor - self.waveform_type = waveform_type - self.enable_unidirectional = enable_unidirectional - - t = np.linspace(0, steps, steps) - if waveform_type == "sine": - sigma = self.generate_sine_wave(t) - elif waveform_type == "sawtooth": - sigma = self.generate_sawtooth_wave(t) - elif waveform_type == "stepped": - sigma = self.generate_stepped_wave(t) - elif waveform_type == "square": - sigma = self.generate_square_wave(t) - elif waveform_type == "random": - sigma = self.generate_random_wave(t) - else: - sigma = np.zeros(steps) # Default case - - if enable_unidirectional: - sigma = self.make_unidirectional(sigma) - - # Ensure sigma values are in the correct format - sigma_tensor = torch.tensor(sigma, dtype=torch.float64) - return (sigma_tensor,) - - def update_parameters(self, steps=None, amplitude=None, frequency=None, damping_factor=None, waveform_type=None, enable_unidirectional=None): - if steps is not None: - self.steps = steps - if amplitude is not None: - self.amplitude = amplitude - if frequency is not None: - self.frequency = frequency - if damping_factor is not None: - self.damping_factor = damping_factor - if waveform_type is not None: - self.waveform_type = waveform_type - if enable_unidirectional is not None: - self.enable_unidirectional = enable_unidirectional - - return self.generate_sigma_sequence( - self.steps, - self.amplitude, - self.frequency, - self.damping_factor, - self.waveform_type, - self.enable_unidirectional - ) - - -class SigmaWaveFormNode: - def __init__(self): - self.steps = 60 - self.amplitude = 3.0 - self.frequency = 0.1 - self.damping_factor = 0.03 - self.waveform_type = "sine" - self.enable_damping = True - self.min_sigma = 0.0 - self.apply_fourier = False - self.horizontal_length = 0.1 - self.enable_unidirectional = True - - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "steps": ("INT", {"default": 60, "min": 1, "max": 1000, "step": 1}), - "amplitude": ("FLOAT", {"default": 3.0, "min": 0.1, "max": 100.0, "step": 0.1, "description": "Amplitude of the waveform"}), - "frequency": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 10.0, "step": 0.01, "description": "Frequency of the waveform"}), - "waveform_type": (["sine", "sawtooth", "stepped", "square", "random", "triangle", "rectangular"], {"default": "sine", "description": "Type of the waveform"}), - "damping_factor": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 0.1, "step": 0.001, "description": "Damping factor for the waveform"}), - "enable_damping": ("BOOLEAN", {"default": True, "description": "Whether to apply damping to the waveform"}), - "min_sigma": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.1, "description": "Minimum sigma value"}), - "apply_fourier": ("BOOLEAN", {"default": False, "description": "Whether to apply Fourier transform to the waveform"}), - "horizontal_length": ("FLOAT", {"default": 0.1, "min": 0.00, "max": 1.0, "step": 0.01, "description": "Proportion of each horizontal segment length in the stepped waveform"}), - "enable_unidirectional": ("BOOLEAN", {"default": True, "description": "Whether to make the waveform unidirectional"}), - }, - } - - RETURN_TYPES = ("SIGMAS",) - RETURN_NAMES = ("sigmas",) - FUNCTION = "generate_sigma_sequence" - CATEGORY = "sampling/custom_sampling/schedulers" - - def apply_damping(self, t, values): - if self.enable_damping: - return values * np.exp(-self.damping_factor * t) - return values - - def generate_waveform(self, waveform_type, amplitude, frequency, t): - if waveform_type == "sine": - values = amplitude * np.sin(2 * np.pi * frequency * t) - elif waveform_type == "sawtooth": - values = amplitude * 2 * (t * frequency - np.floor(0.5 + t * frequency)) - elif waveform_type == "stepped": - num_segments = int(1 / self.horizontal_length) - steps_per_segment = self.steps // num_segments - values = np.repeat(np.linspace(amplitude, -amplitude, num_segments), steps_per_segment) - values = np.resize(values, self.steps) - elif waveform_type == "square": - values = amplitude * np.sign(np.sin(2 * np.pi * frequency * t)) - elif waveform_type == "random": - values = amplitude * (2 * np.random.rand(self.steps) - 1) - elif waveform_type == "triangle": - values = amplitude * (2 * np.abs(2 * (t * frequency - np.floor(t * frequency + 0.5))) - 1) - elif waveform_type == "rectangular": - values = amplitude * (np.mod(t * frequency, 1) < 0.5).astype(float) - else: - values = np.zeros(self.steps) - return values - - def apply_fourier_transform(self, values): - fft_vals = np.fft.fft(values) - fft_vals[5:] = 0 - values = np.fft.ifft(fft_vals).real - return values - - def make_unidirectional(self, values): - return values - np.min(values) + self.min_sigma - - def generate_sigma_sequence(self, steps, amplitude, frequency, waveform_type, damping_factor, enable_damping, min_sigma, apply_fourier, horizontal_length, enable_unidirectional): - self.steps = steps - self.amplitude = amplitude - self.frequency = frequency - self.waveform_type = waveform_type - self.damping_factor = damping_factor - self.enable_damping = enable_damping - self.min_sigma = min_sigma - self.apply_fourier = apply_fourier - self.horizontal_length = horizontal_length - self.enable_unidirectional = enable_unidirectional - - t = np.linspace(0, 1, steps) - - sigma = self.generate_waveform(waveform_type, amplitude, frequency, t) - - if enable_unidirectional: - sigma = self.make_unidirectional(sigma) - - if enable_damping: - sigma = self.apply_damping(t, sigma) - - if apply_fourier: - sigma = self.apply_fourier_transform(sigma) - - sigma_tensor = torch.tensor(sigma, dtype=torch.float64) - return (sigma_tensor,) - - def update_parameters(self, steps=None, amplitude=None, frequency=None, waveform_type=None, damping_factor=None, enable_damping=None, min_sigma=None, apply_fourier=None, horizontal_length=None, enable_unidirectional=None): - if steps is not None: - self.steps = steps - if amplitude is not None: - self.amplitude = amplitude - if frequency is not None: - self.frequency = frequency - if waveform_type is not None: - self.waveform_type = waveform_type - if damping_factor is not None: - self.damping_factor = damping_factor - if enable_damping is not None: - self.enable_damping = enable_damping - if min_sigma is not None: - self.min_sigma = min_sigma - if apply_fourier is not None: - self.apply_fourier = apply_fourier - if horizontal_length is not None: - self.horizontal_length = horizontal_length - if enable_unidirectional is not None: - self.enable_unidirectional = enable_unidirectional - - return self.generate_sigma_sequence( - self.steps, - self.amplitude, - self.frequency, - self.waveform_type, - self.damping_factor, - self.enable_damping, - self.min_sigma, - self.apply_fourier, - self.horizontal_length, - self.enable_unidirectional - ) - - -class SigmaWaveFormNodeAdvanced: - def __init__(self): - self.steps = 60 - self.amplitude1 = 3.0 - self.frequency1 = 0.1 - self.amplitude2 = 3.0 - self.frequency2 = 0.1 - self.damping_factor = 0.03 - self.waveform_type1 = "sine" - self.waveform_type2 = "sine" - self.blend_factor = 0.5 - self.enable_damping = True - self.min_sigma = 0.0 - self.apply_fourier = False - self.horizontal_length = 0.1 - self.apply_loglinear = False - self.noise_fine_tune = 1.0 - self.enable_unidirectional = True - - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "steps": ("INT", {"default": 60, "min": 1, "max": 1000, "step": 1}), - "noise_fine_tune": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.1, "description": "Fine-tuning factor for noise levels"}), - "waveform_type1": (["sine", "sawtooth", "stepped", "square", "random", "triangle", "rectangular"], {"default": "sine", "description": "Type of the first waveform"}), - "waveform_type2": (["sine", "sawtooth", "stepped", "square", "random", "triangle", "rectangular"], {"default": "sine", "description": "Type of the second waveform"}), - "blend_factor": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01, "description": "Blending factor between the two waveforms"}), - "amplitude1": ("FLOAT", {"default": 3.0, "min": 0.1, "max": 100.0, "step": 0.1, "description": "Amplitude of the first waveform"}), - "amplitude2": ("FLOAT", {"default": 3.0, "min": 0.1, "max": 100.0, "step": 0.1, "description": "Amplitude of the second waveform"}), - "frequency1": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 10.0, "step": 0.01, "description": "Frequency of the first waveform"}), - "frequency2": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 10.0, "step": 0.01, "description": "Frequency of the second waveform"}), - "horizontal_length": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 1.0, "step": 0.01, "description": "Proportion of each horizontal segment length in the stepped waveform"}), - "min_sigma": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.1, "description": "Minimum sigma value"}), - "apply_fourier": ("BOOLEAN", {"default": False, "description": "Whether to apply Fourier transform to the waveform"}), - "apply_loglinear": ("BOOLEAN", {"default": False, "description": "Whether to apply log-linear interpolation to the sigma values"}), - "enable_damping": ("BOOLEAN", {"default": True, "description": "Whether to apply damping to the waveform"}), - "damping_factor": ("FLOAT", {"default": 0.03, "min": 0.0, "max": 0.1, "step": 0.001, "description": "Damping factor for the waveform"}), - "enable_unidirectional": ("BOOLEAN", {"default": True, "description": "Whether to make the waveform unidirectional"}) - - - }, - } - - RETURN_TYPES = ("SIGMAS",) - RETURN_NAMES = ("sigmas",) - FUNCTION = "generate_sigma_sequence" - CATEGORY = "sampling/custom_sampling/schedulers" - - def apply_damping(self, t, values): - if self.enable_damping: - return values * np.exp(-self.damping_factor * t) - return values - - def generate_waveform(self, waveform_type, amplitude, frequency, t): - if waveform_type == "sine": - values = amplitude * np.sin(2 * np.pi * frequency * t) - elif waveform_type == "sawtooth": - values = amplitude * 2 * (t * frequency - np.floor(0.5 + t * frequency)) - elif waveform_type == "stepped": - num_segments = int(1 / self.horizontal_length) - steps_per_segment = self.steps // num_segments - values = np.repeat(np.linspace(amplitude, -amplitude, num_segments), steps_per_segment) - values = np.resize(values, self.steps) - elif waveform_type == "square": - values = amplitude * np.sign(np.sin(2 * np.pi * frequency * t)) - elif waveform_type == "random": - values = amplitude * (2 * np.random.rand(self.steps) - 1) - elif waveform_type == "triangle": - values = amplitude * (2 * np.abs(2 * (t * frequency - np.floor(t * frequency + 0.5))) - 1) - elif waveform_type == "rectangular": - values = amplitude * (np.mod(t * frequency, 1) < 0.5).astype(float) - else: - values = np.zeros(self.steps) - return values - - def apply_fourier_transform(self, values): - fft_vals = np.fft.fft(values) - fft_vals[5:] = 0 - values = np.fft.ifft(fft_vals).real - return values - - def make_unidirectional(self, values): - return values - np.min(values) + self.min_sigma - - def refined_exponential_solver(self, sigma, steps): - """ - Apply the refined exponential solver for the sigma sequence. - """ - h = 1 / steps - b1, b2 = RESDECoeffsSecondOrder(h) - x = np.zeros(steps) - for n in range(steps - 1): - x[n + 1] = x[n] + h * (b1 * sigma[n] + b2 * sigma[n + 1]) - return x - - def generate_sigma_sequence(self, steps, amplitude1, frequency1, waveform_type1, amplitude2, frequency2, waveform_type2, blend_factor, damping_factor, enable_damping, min_sigma, apply_fourier, horizontal_length, apply_loglinear, noise_fine_tune, enable_unidirectional): - self.steps = steps - self.amplitude1 = amplitude1 - self.frequency1 = frequency1 - self.waveform_type1 = waveform_type1 - self.amplitude2 = amplitude2 - self.frequency2 = frequency2 - self.waveform_type2 = waveform_type2 - self.blend_factor = blend_factor - self.damping_factor = damping_factor - self.enable_damping = enable_damping - self.min_sigma = min_sigma - self.apply_fourier = apply_fourier - self.horizontal_length = horizontal_length - self.apply_loglinear = apply_loglinear - self.noise_fine_tune = noise_fine_tune - self.enable_unidirectional = enable_unidirectional - - t = np.linspace(0, 1, steps) - - sigma1 = self.generate_waveform(waveform_type1, amplitude1, frequency1, t) - sigma2 = self.generate_waveform(waveform_type2, amplitude2, frequency2, t) - sigma = blend_factor * sigma1 + (1 - blend_factor) * sigma2 - - if self.enable_unidirectional: - sigma = self.make_unidirectional(sigma) - - if enable_damping: - sigma = self.apply_damping(t, sigma) - - if apply_fourier: - sigma = self.apply_fourier_transform(sigma) - - if apply_loglinear: - sigma = loglinear_interp(sigma, steps) - - sigma *= noise_fine_tune - - sigma = self.refined_exponential_solver(sigma, steps) - - sigma_tensor = torch.tensor(sigma, dtype=torch.float64) - return (sigma_tensor,) - - def update_parameters(self, amplitude1=None, frequency1=None, amplitude2=None, frequency2=None, blend_factor=None, damping_factor=None, horizontal_length=None, apply_loglinear=None, noise_fine_tune=None, enable_unidirectional=None): - if amplitude1 is not None: - self.amplitude1 = amplitude1 - if frequency1 is not None: - self.frequency1 = frequency1 - if amplitude2 is not None: - self.amplitude2 = amplitude2 - if frequency2 is not None: - self.frequency2 = frequency2 - if blend_factor is not None: - self.blend_factor = blend_factor - if damping_factor is not None: - self.damping_factor = damping_factor - if horizontal_length is not None: - self.horizontal_length = horizontal_length - if apply_loglinear is not None: - self.apply_loglinear = apply_loglinear - if noise_fine_tune is not None: - self.noise_fine_tune = noise_fine_tune - if enable_unidirectional is not None: - self.enable_unidirectional = enable_unidirectional - - self.generate_sigma_sequence( - self.steps, - self.amplitude1, - self.frequency1, - self.waveform_type1, - self.amplitude2, - self.frequency2, - self.waveform_type2, - self.blend_factor, - self.damping_factor, - self.enable_damping, - self.min_sigma, - self.apply_fourier, - self.horizontal_length, - self.apply_loglinear, - self.noise_fine_tune, - self.enable_unidirectional - ) - -import numpy as np -import torch - -class FourierFilterNode: - def __init__(self): - self.filter_type = "lowpass" - self.cutoff_frequency = 0.1 - self.apply_inverse_fourier = True - - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "sigmas": ("SIGMAS", {"description": "Input sigma sequence"}), - "filter_type": (["lowpass", "highpass", "bandpass", "bandstop"], {"default": "lowpass", "description": "Type of frequency filter to apply"}), - "cutoff_frequency": ("FLOAT", {"default": 0.1, "min": 0.01, "max": 0.5, "step": 0.01, "description": "Cutoff frequency for the filter"}), - "apply_inverse_fourier": ("BOOLEAN", {"default": True, "description": "Whether to apply inverse Fourier transform"}), - }, - } - - RETURN_TYPES = ("SIGMAS",) - RETURN_NAMES = ("filtered_sigmas",) - FUNCTION = "apply_filter" - CATEGORY = "sampling/custom_sampling/filters" - - def apply_filter(self, sigmas, filter_type, cutoff_frequency, apply_inverse_fourier): - self.filter_type = filter_type - self.cutoff_frequency = cutoff_frequency - self.apply_inverse_fourier = apply_inverse_fourier - - # Convert input tensor to numpy array - sigma = sigmas.numpy() - - # Apply Fourier Transform - fft_vals = np.fft.fft(sigma) - - # Apply the selected filter - filtered_fft_vals = self.apply_frequency_filter(fft_vals, filter_type, cutoff_frequency) - - # Optionally apply inverse Fourier transform - if apply_inverse_fourier: - filtered_sigma = np.fft.ifft(filtered_fft_vals).real - else: - filtered_sigma = filtered_fft_vals - - # Convert filtered result back to tensor - filtered_sigma_tensor = torch.tensor(filtered_sigma, dtype=torch.float32) - return (filtered_sigma_tensor,) - - def apply_frequency_filter(self, fft_vals, filter_type, cutoff_frequency): - freqs = np.fft.fftfreq(len(fft_vals)) - filtered_fft_vals = np.copy(fft_vals) - - if filter_type == "lowpass": - filtered_fft_vals[np.abs(freqs) > cutoff_frequency] = 0 - elif filter_type == "highpass": - filtered_fft_vals[np.abs(freqs) < cutoff_frequency] = 0 - elif filter_type == "bandpass": - band = (cutoff_frequency, cutoff_frequency * 2) # Example band range, can be adjusted - filtered_fft_vals[(np.abs(freqs) < band[0]) | (np.abs(freqs) > band[1])] = 0 - elif filter_type == "bandstop": - band = (cutoff_frequency, cutoff_frequency * 2) # Example band range, can be adjusted - filtered_fft_vals[(np.abs(freqs) > band[0]) & (np.abs(freqs) < band[1])] = 0 - - return filtered_fft_vals - - - -class AttenuatorNode: - def __init__(self): - self.attenuation_factor = 1.0 - - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "sigmas": ("SIGMAS", {"description": "Input sigma sequence"}), - "attenuation_factor": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.1, "description": "Factor by which to attenuate the sigma sequence"}), - }, - } - - RETURN_TYPES = ("SIGMAS",) - RETURN_NAMES = ("attenuated_sigmas",) - FUNCTION = "apply_attenuation" - CATEGORY = "sampling/custom_sampling/attenuators" - - def apply_attenuation(self, sigmas, attenuation_factor): - self.attenuation_factor = attenuation_factor - - # Apply attenuation - attenuated_sigma = sigmas * attenuation_factor - - return (attenuated_sigma,) - - -class PhaseLockedLoopNode: - def __init__(self): - self.lock_factor = 0.5 - self.frequency_range = 1.0 - - @classmethod - def INPUT_TYPES(cls): - return { - "required": { - "input_sigmas": ("SIGMAS", {"description": "Input sigma sequence"}), - "reference_sigmas": ("SIGMAS", {"description": "Reference sigma sequence"}), - "lock_factor": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01, "description": "Factor by which to lock the phase"}), - "frequency_range": ("FLOAT", {"default": 1.0, "min": 0.1, "max": 10.0, "step": 0.1, "description": "Frequency range for the PLL"}), - }, - } - - RETURN_TYPES = ("SIGMAS",) - RETURN_NAMES = ("locked_sigmas",) - FUNCTION = "lock_phase" - CATEGORY = "sampling/custom_sampling/phase_locked_loop" - - def lock_phase(self, input_sigmas, reference_sigmas, lock_factor, frequency_range): - self.lock_factor = lock_factor - self.frequency_range = frequency_range - - # Convert tensors to numpy arrays - input_sigma = input_sigmas.numpy() - reference_sigma = reference_sigmas.numpy() - - # Initialize output signal - locked_sigma = np.zeros_like(input_sigma) - - # Phase Locked Loop logic (simplified example) - phase_error = 0 - for i in range(len(input_sigma)): - phase_error += reference_sigma[i] - input_sigma[i] - correction = self.lock_factor * phase_error - locked_sigma[i] = input_sigma[i] + correction - - # Apply frequency range limits - locked_sigma = np.clip(locked_sigma, -self.frequency_range, self.frequency_range) - - # Convert the locked sigma back to a tensor - locked_sigma_tensor = torch.tensor(locked_sigma, dtype=torch.float32) - return (locked_sigma_tensor,) - - -# Node class mappings -NODE_CLASS_MAPPINGS = { - "SigmaWaveFormNodeSimple": SigmaWaveFormNodeSimple, - "SigmaWaveFormNode": SigmaWaveFormNode, - "SigmaWaveFormNodeAdvanced": SigmaWaveFormNodeAdvanced, - "FourierFilterNode": FourierFilterNode, - "PhaseLockedLoopNode": PhaseLockedLoopNode, - "AttenuatorNode": AttenuatorNode -} - -# Node display name mappings -NODE_DISPLAY_NAME_MAPPINGS = { - "SigmaWaveFormNodeSimple": "Sigma Waveform Node Simple", - "SigmaWaveFormNode": "Sigma Waveform Node", - "SigmaWaveFormNodeAdvanced": "Sigma Waveform Node Advanced", - "FourierFilterNode": "Fourier Filter Node", - "PhaseLockedLoopNode": "Phase Locked Loop Node", - "AttenuatorNode": "Attenuator Node" -} -