|
|
import torch |
|
|
import torch.nn as nn |
|
|
import numpy as np |
|
|
import matplot.pyplot as plt |
|
|
|
|
|
num_nodes = 100 |
|
|
time_steps = 1000 |
|
|
frequency = 1 |
|
|
amplitude = 1.0 |
|
|
sampling_rate = 1000 |
|
|
infrared_voltage = 0.7 |
|
|
pulse_width_modulatoin_frequency = 50 |
|
|
|
|
|
def generate_spwm_signal(time, frequency, amplitude): |
|
|
sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
pwm_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
|
|
return pwm_signal |
|
|
|
|
|
def infrared_storage(pwm_signal, voltage): |
|
|
stored_signal = pwm_signal * voltage |
|
|
return stored_signal |
|
|
|
|
|
def directional_transmission(stored_signal, phase_shift): |
|
|
transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
|
|
|
time = np.linspace(0, 1, time_steps) |
|
|
|
|
|
spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
|
|
|
infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
|
|
|
transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
plt.figure(figsize=(15, 8)) |
|
|
|
|
|
plt.subplot(3, 1, 1) |
|
|
plt.plot(time, spwm_signal, color='blue', label='SPWM Signal') |
|
|
plt.title('Sinusoidal Pulse Width Modulation (SPWM) Signal') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Amplitude') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.subplot(3, 1, 2) |
|
|
plt.plot(time, infrared_stored_signal, color='red', label='Infrared Stored Signal') |
|
|
plt.title('Data Stored using Infrared Voltage Energy') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Voltage') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.subplot(3, 1, 3) |
|
|
plt.plot(time, tranmitted_signal, color='green', label=Transmitted Signal') |
|
|
plt.title('Transmitted Signal towards a Given Direction') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Amplitude') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.tight_layout() |
|
|
plt.show() |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import numpy as np |
|
|
import matplotlib.pyplot as plt |
|
|
|
|
|
num_nodes = 100 |
|
|
time_steps = 1000 |
|
|
frequency = 1 |
|
|
amplitude = 1.0 |
|
|
sampling_rate = 1000 |
|
|
infrared_voltage = 0.7 |
|
|
pulse_width_modulation_frequency = 50 |
|
|
attenuation_factor = 0.5 |
|
|
noise_intensity = 0.2 |
|
|
multi_path_delay = 50 |
|
|
multi_path_amplitude = 0.3 |
|
|
|
|
|
def generate_spwm_signal(time, frequency, amplitude): |
|
|
sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
pwn_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
|
|
return pwm_signal |
|
|
|
|
|
def infrared_storage(pwm_signal, voltage): |
|
|
stored_signal = pwm_signal * voltage |
|
|
return stored_signal |
|
|
|
|
|
def directional_transmission(stored_signal, phase_shift): |
|
|
transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
return transmitted_signal |
|
|
|
|
|
def attenuate_signal(signal, attenuation_factor): |
|
|
attenuation = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
|
|
attenuated_signal = signal * attenuation |
|
|
return attenuated_signal |
|
|
|
|
|
def add_noise(signal, noise_intensity): |
|
|
noise = noise_intensity * np.random.randn(len(signal)) |
|
|
return noisy_signal |
|
|
|
|
|
def multi_path_effects(signal, delaym amplitude): |
|
|
delayed_signal = np.roll(signal, delay) * amplitude |
|
|
combined_signal = signal + delayed_signal |
|
|
return combined_signal |
|
|
|
|
|
time = np.linspace(0, 1, time_steps) |
|
|
|
|
|
spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
|
|
|
infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
|
|
|
transmitted_signal = directional_transmission(infreared_stored_signal, phase_shift=100) |
|
|
|
|
|
attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
|
|
|
noisy_signal, add_noise(attenuated_signal, noise_intensity) |
|
|
|
|
|
final_signal = multi_path_effects(noisy_signal, multi_path_delay, mutli_path_amplitude |
|
|
|
|
|
plt.figure(figsize=(15, 12)) |
|
|
|
|
|
plt.subplot(4, 1, 1) |
|
|
plt.plot(time, spwm_signal, color='blue', label='SPWM Signal') |
|
|
plt.title('Sinusodial Pulse Width Modulation (SPWM) Signal') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Amplitude') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.subplot(4, 1, 2) |
|
|
plt.plot(time, infrared_stored_signal, color='red', label='Infrared Stored Signal') |
|
|
plt.title('Data Stored using Infrared Voltage Energy') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Voltage') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.subplot(4, 1, 3) |
|
|
plt.plot(time, transmited_signal, color='green', label='Transmitted Signal') |
|
|
plt.title('Transmitted Signal towards a Given Direction') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Amplitude') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.subplot(4, 1, 4) |
|
|
plt.plot(time, final_signal, color='purple', lable='Final Signal with Attenuation, Noise, and Multi-Path Effects') |
|
|
plt.title('Final Signal in Dense Space') |
|
|
plt.xlabel('Time (s)') |
|
|
plt.ylabel('Amplitude') |
|
|
plt.grid(True) |
|
|
plt.legend() |
|
|
|
|
|
plt.tight_layout() |
|
|
plt.show() |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import numpy as np |
|
|
import matplotlib.pyplot as plt |
|
|
from matplotlib.animatoin import FuncAnimation |
|
|
|
|
|
num_nodes = 100 |
|
|
time_steps = 1000 |
|
|
frequency = 1 |
|
|
amplitude = 1.0 |
|
|
sampling_rate = 1000 |
|
|
infrared_voltage = 0.7 |
|
|
pulse_width_modulation_frequency = 50 |
|
|
atenuation_factor = 0.5 |
|
|
noise_intensity = 0.2 |
|
|
multi_path_delay = 50 |
|
|
multi_path_amplitude = 0.3 |
|
|
|
|
|
def generate_spwm_signal(time, frequency, amplitude): |
|
|
sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
|
|
|
pwn_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
|
|
return pwm_signal |
|
|
|
|
|
def infrared_storage(pwm_signal, voltage): |
|
|
stored_signal = pwm_signal * voltage |
|
|
return stored_signal |
|
|
|
|
|
def directional_transmission(stored_signal, phase_shift): |
|
|
transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
return transmitted_signal |
|
|
|
|
|
def add_noise(signal, noise_intensity): |
|
|
noise = noise_intensity * np.random.randn(len(signal)) |
|
|
noisy_signal = signal + noise |
|
|
return noisy_signal |
|
|
|
|
|
def multi_path_effects(signal, delay, amplitude): |
|
|
delayed_signal = np.roll(signal, delay) * amplitude |
|
|
combined_signal = signal + delayed_signal |
|
|
return combined_signal |
|
|
|
|
|
time = np.linspace(0, 1, time_steps) |
|
|
|
|
|
spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
|
|
|
infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
|
|
|
attenuated_signal = attenuated_signal(transmitted_signal, attenuation_factor) |
|
|
|
|
|
noisy_signal = add_noise(attenuated_signal, noise_intensity |
|
|
|
|
|
final_signal = multi_paht_effects(noisy_signal, multi_path_delay, multi_path_amplitude |
|
|
|
|
|
fig, ax = plt.subplots(figsize=(15, 6)) |
|
|
line, = ax.plot([], [], color='purple') |
|
|
ax.set_xlim(0, time_steps) |
|
|
ax.set_ylim(-1.5, 1.5) |
|
|
ax.set_title('Animated Signal Transmission') |
|
|
ax.set_xlabel('Time Step') |
|
|
ax.set_ylabel('Amplitude') |
|
|
ax.grid(True) |
|
|
|
|
|
def animate(frame): |
|
|
current_signal = np.roll(final_signal, frame) |
|
|
line.set_data(np.arange(len(current_signal)), current_signal) |
|
|
return line, |
|
|
|
|
|
ani = FuncAnimation(fig, animate, frames=time_steps, interval=20, blit=True) |
|
|
|
|
|
plt.show() |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import numpy as np |
|
|
import matplotlib.pyplot as plt |
|
|
from matplotlib.animation import FuncAnimation |
|
|
|
|
|
num_nodes = 100 |
|
|
time_steps = 1000 |
|
|
frequency = 1 |
|
|
amplitude = 1.0 |
|
|
sampling_rate = 1000 |
|
|
infrared_voltage = 0.7 |
|
|
pulse_width_modulation_frequency = 50 |
|
|
attenuation_factor = 0.5 |
|
|
noise_intensity = 0.2 |
|
|
mutli_path_delay = 50 |
|
|
multi_path_amplitude = 0.3 |
|
|
|
|
|
encryption_keys = [0.5, 1.2, 0.9] |
|
|
|
|
|
def generate_spwm_signal(time, frequency, amplitude): |
|
|
sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
pwm_signal = np.where(sine_wave > np.random.rand(len(time)), 1, 0) |
|
|
return pwm_signal |
|
|
|
|
|
def infrared_storage(pwm_signal, voltage): |
|
|
stored_signal = pwm_signal * voltage |
|
|
return stored_signal |
|
|
|
|
|
def directional_transmissoin(stored_signal, phase_shift): |
|
|
transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
return transmitted_signal |
|
|
|
|
|
def attenuate_signal(signal, attenuation_factor): |
|
|
attenuatoin = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
|
|
attenuated_signal = signal * attenuation |
|
|
return attenuated_signal |
|
|
|
|
|
def add_noise(signal, noise_intensity): |
|
|
noise = noise_intensity * np.random.randn(len(signal)) |
|
|
noisy_signal = signal + noise |
|
|
return noisy_signal |
|
|
|
|
|
def multi_path_effects(signal, delay, amplitude): |
|
|
delayed_signal = np.roll(signal, delay) * amplitude |
|
|
combined_signal = signal + delayed_signal |
|
|
return combined_signal |
|
|
|
|
|
def layered_encryption(signal, keys): |
|
|
encrypted_signal = signal.copy() |
|
|
for key in keys: |
|
|
encrypted_signal = np.sin(encrypted_signal * key) |
|
|
return encrypted_signal |
|
|
|
|
|
def layered_decryption(encrypted_signal, keys): |
|
|
decrypted_signal = encrypted_signal.copy() |
|
|
for key in reversed(keys): |
|
|
decrypted_signal = np.arcsin(decrypted)signal) / key |
|
|
return decrypted_signal |
|
|
|
|
|
time = np.linspace(0, 1, time_steps) |
|
|
|
|
|
spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
|
|
|
infrared_stored_signla = infrared_storage(spwm_signal, infreared_voltage) |
|
|
|
|
|
transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
|
|
|
attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
|
|
|
noisy_signal = add_noise(attenuated_signal, noise_intensity) |
|
|
|
|
|
final_signal = multi_path_effects(noisy_signal, multi_path_delay, multi_path_amplitude) |
|
|
|
|
|
encrypted_signal = layered_encryption(final_signal, encryption_keys) |
|
|
|
|
|
decrypted_signal = layered_decryption(encrypted_signal, encryption_keys) |
|
|
|
|
|
fig, ax = plt.subplots(2, 1, figsize=(15, 12)) |
|
|
|
|
|
ax[0].plot(np.arange(len(encrypted_signal)), encrypted_signal, color='purple') |
|
|
ax[0].set_title('Encrypted Signal w/Layered VPN Protection') |
|
|
ax[0].set_xlabel('Time Step') |
|
|
ax[0].set_ylabel('Amplitude') |
|
|
ax[0].grid(True) |
|
|
|
|
|
ax[1].plot(np.arange(len(decrypted_signal)), decrypted_signal, color='green') |
|
|
ax[1].set_title('Decrypted Signal w/Layered VPN Decryption') |
|
|
ax[1].set_xlabel('Time Step') |
|
|
ax[1].set_ylabel('Amplitude') |
|
|
ax[1].grid(True) |
|
|
|
|
|
plt.tight_layour() |
|
|
plt.show() |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import numpy as np |
|
|
import matplotlib.pyplot as plt |
|
|
from matplotlib.animation import FuncAnimation |
|
|
|
|
|
num_nodes = 100 |
|
|
time_steps = 1000 |
|
|
frequency = 1 |
|
|
amplitude = 1.0 |
|
|
sampling_rate = 1000 |
|
|
infrared_voltage = 0.7 |
|
|
pulse_width_modulatoin_frequency = 50 |
|
|
attenuation_factor = 0.5 |
|
|
noise_intensity = 0.2 |
|
|
multi_path_delay = 50 |
|
|
multi_path_amplitude = 0.3 |
|
|
|
|
|
encryption_keys = [0.5, 1.2, 0.9] |
|
|
|
|
|
def generate_spwm_signal(time, frequency, amplitude): |
|
|
sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
threshold = np.mean(sine_wave_ |
|
|
pwm_signal = np.where(sine_wave > threshold, 1, 0) |
|
|
return pwm_signal |
|
|
|
|
|
def infrared_storage(pwm_signal, voltage): |
|
|
stored_signal = pwm_signal * voltage |
|
|
return stored_signal |
|
|
|
|
|
def directional_transmissoin(stored_signal, phase_shift): |
|
|
transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
return transmitted_signal |
|
|
|
|
|
def attenuate_signal(signal, attenuation_factor): |
|
|
attenuation = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
|
|
attenuated_signal = signal * attenuation |
|
|
return attenuated_signal |
|
|
|
|
|
def add_noise(signal, noise_intensity): |
|
|
noise = noise_intensity * np.random.randn(len(signal)) |
|
|
noisy_signal = signal + noise |
|
|
return noisy signal |
|
|
|
|
|
def multi_path_effects(signal, delay, amplitude): |
|
|
delayed_signal = np.roll(signal, delay) * amplitude |
|
|
combined_signal = signal + delayed_signal |
|
|
return combined_signal |
|
|
|
|
|
def layered_encryption(signal, keys): |
|
|
encrypted_signal = signal.copy() |
|
|
for key in keys: |
|
|
encrypted_signal = np.sin(encrypted_signal * key) |
|
|
return encrypted_signal |
|
|
|
|
|
def layered_decryption(encrypted_signal, keys): |
|
|
decrypted_signal = encrypted_signal.copy() |
|
|
for key in reversed(keys): |
|
|
decrypted_signal = np.arcsin(decrypted_signal) / key |
|
|
return decrypted_signal |
|
|
|
|
|
def validate_encryption(original_signal, encrypted_signal, decrypted_signal): |
|
|
assert np.allclose(original_signal, decrypted_signal, atol=1e-2), "Decryption failed to recover the original signal." |
|
|
|
|
|
time = np.linspace(0, 1, time_steps) |
|
|
|
|
|
spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
|
|
|
infrared_stored_signal = infrared_storage(spwm_signal, infrared_voltage) |
|
|
|
|
|
transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
|
|
|
attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
|
|
|
noisy_signal = add_noise(attenuated_signal, noise_intensity) |
|
|
|
|
|
final_signal = multi_path_effects(noisy_signal, multi_path_delay, multi_path_amplitude) |
|
|
|
|
|
encrypted_signal = layered_encryption(final_signal, encryption_keys) |
|
|
|
|
|
decrypted_signal = layered_decryption(encrypted_signal, encryption_keys) |
|
|
|
|
|
fig, ax= plt.subplots(2, 1, figsize=(15, 12)) |
|
|
|
|
|
ax[0].plot(np.arant(len(encrypted_signal)), encrypted_signal, color='purple') |
|
|
ax[0].set_title('Encrypted Signal w/Layered VPN Protection') |
|
|
ax[0].set_xlabel('Time Step') |
|
|
ax[0].set_ylabel('Amplitude') |
|
|
ax[0].grid(True) |
|
|
|
|
|
ax[1].plot(np.arange(len(decrypted_signal)), decrypted_signal, color='green') |
|
|
ax[1].set_title('Decrypted Signal w/Layered VPN Decryption') |
|
|
ax[1].set_xlabel('Time Step') |
|
|
ax[1].set_ylabel('Amplitude') |
|
|
ax[1].grid(True) |
|
|
|
|
|
plt.tight_layout() |
|
|
plt.show() |
|
|
|
|
|
import torch |
|
|
import torch.nn as nn |
|
|
import numpy as np |
|
|
import matplotlib.pyplot as plt |
|
|
from matplotlib.animation import FuncAnimation |
|
|
|
|
|
num_nodes = 100 |
|
|
time_steps = 1000 |
|
|
frequency = 1 |
|
|
amplitude = 1.0 |
|
|
sampling_rate = 1000 |
|
|
infrared_voltage = 0.7 |
|
|
pulse_width_modulation_frequency = 50 |
|
|
attenuation_factor = 0.5 |
|
|
noise_intensity = 0.2 |
|
|
multi_path_delay = 50 |
|
|
multi_path_amplitude = 0.3 |
|
|
|
|
|
encryption_keys = [0.5, 1.2, 0.9] |
|
|
|
|
|
def generate_spwm_signal(time, frequency, amplitude): |
|
|
sine_wave = amplitude * np.sin(2 * np.pi * frequency * time) |
|
|
threshold = np.mean(sine_wave) |
|
|
pwm_signal = np.where(sine_wave) |
|
|
return pwm_signal |
|
|
|
|
|
def infrared_storage(pwm_signal, voltage): |
|
|
stored_signal = pwm_signal * voltage |
|
|
return stored_signal |
|
|
|
|
|
def directional_transmission(stored_signal, phase_shift): |
|
|
transmitted_signal = np.roll(stored_signal, phase_shift) |
|
|
return transmited_signal |
|
|
|
|
|
def attenuate_signal(signal, attenuation_factor): |
|
|
attenuation = np.exp(-attenuation_factor * np.arange(len(signal)) / len(signal)) |
|
|
attenuated_signal = signal * attenuation |
|
|
return attenuated_signal |
|
|
|
|
|
def add_noise(signal, noise_intensity): |
|
|
noise = noise_intensity * np.random.randn(len(signal)) |
|
|
noisy_signal = signal + noise |
|
|
return noisy_signal |
|
|
|
|
|
def multi_path_effects(signal, delay, amplitude): |
|
|
delayed_signal = np.roll(signal, delay) * amplitude |
|
|
combined_signal = signal + delayed_signal |
|
|
return combined_signal |
|
|
|
|
|
def layered_encryption(signal, keys): |
|
|
encrypted_signal = signal.copy() |
|
|
for key in keys: |
|
|
encrypted_signal = np.sin(encrypted_signal * key) |
|
|
return encrypted_signal |
|
|
|
|
|
def layered_decryption(encrypted_signal, keys): |
|
|
decrypted_signal = encrypted_signal.copy() |
|
|
for key in reveresed(keys): |
|
|
decrypted_signal = np.arcsin(decrypted_signal) / key |
|
|
return decrypted_signal |
|
|
|
|
|
def validate_encryption(original_signal, encrypted_signal, decrypted_signal): |
|
|
assert np.allclose(original_signal, decrypted_signal, atol=1e-2), "Decryption failed to recover the original signal." |
|
|
|
|
|
time = np.linspace(0, 1, time_steps) |
|
|
|
|
|
spwm_signal = generate_spwm_signal(time, frequency, amplitude) |
|
|
|
|
|
infrared_stored_signal = infrared_storage(spwm_signal, infared_voltage) |
|
|
|
|
|
transmitted_signal = directional_transmission(infrared_stored_signal, phase_shift=100) |
|
|
|
|
|
attenuated_signal = attenuate_signal(transmitted_signal, attenuation_factor) |
|
|
|
|
|
noisy_signal = add_noise(attenuated_signal, noise_intensity) |
|
|
|
|
|
final_signal = multi_path_effects(noisy_signal, multi_path_delay, multi_path_amplitude_ |
|
|
|
|
|
encrypted_signal = layered_encryption(final_signal, encryption_keys) |
|
|
|
|
|
decrypted_signal = layered_decryption(encrypted_signal, encryption_keys) |
|
|
|
|
|
fig, ax = plt.subplots(2, 1, figsize=(15, 12)) |
|
|
|
|
|
ax[0].plot(np.arange(len(encrypted_signal)), encrypted_signal, color='purple') |
|
|
ax[0].set_title('Encrypted Signal w/Layered VPN Protection') |
|
|
ax[0].set_xlabel('Time Step') |
|
|
ax[0].set_ylabel('Amplitude') |
|
|
ax[0].grid(True) |
|
|
|
|
|
ax[1].plot(np.arange(len(decrypted_signal)), decrypted_signal, color='green') |
|
|
ax[1].set_title('Decrypted Signal w/Layered VPN Decryption') |
|
|
ax[1].set_xlabel('Time Step') |
|
|
ax[1].set_ylabel('Amplitude') |
|
|
ax[1].grid(True) |
|
|
|
|
|
plt.tight_layout() |
|
|
plt.show() |
|
|
|
|
|
import matplotlib.pyplot as plt |
|
|
import numpy as np |
|
|
|
|
|
def gradient_color(signal, cmap='viridis'): |
|
|
norm = plt.Normalizer(signal.min(), signal.max()) |
|
|
colors = plt.get_cmap(cmap)norm(signal)) |
|
|
return colors |
|
|
|
|
|
time = np.arange(len(final_signal)) |
|
|
|
|
|
colors = gradient_color(final_signal) |
|
|
|
|
|
fig, ax = plt.subplots(figsize(15, 6)) |
|
|
|
|
|
ax.plot(time, final_signal, color='blue', label='Final Signal') |
|
|
|
|
|
reflection_factor = 0.3 |
|
|
reflection = final_signal * reflection_factor |
|
|
reflection_color = 'lightblue' |
|
|
|
|
|
ax.plot(time, -reflection - reflection.min(), color=reflection_color, linestyle='--', alpha=0.6, label='Signal Reflection') |
|
|
|
|
|
for i in range*len(final_signal) - 1): |
|
|
ax.plot(time[i:i+2], final_signal[i:i+2], color=colors[i], lw=2) |
|
|
|
|
|
ax.set_title('Final Signal with Reflection and Color Gradient') |
|
|
ax.set_ylabel('Amplitude') |
|
|
ax.legend() |
|
|
ax.grid(True) |
|
|
|
|
|
plt.show() |
|
|
|
|
|
import matplotlib.pyplot as plt |
|
|
iport numpy as np |
|
|
import matplotlib.colors as mcolors |
|
|
|
|
|
def gradient_color(signal, cmap='viridis'): |
|
|
norm = plt.Normalize(signal.min(), signal.max()) |
|
|
colors = plt.get_cmap(cmap(norm(signal)) |
|
|
return colors |
|
|
|
|
|
time = np.arange(len(final_signal)) |
|
|
|
|
|
colors = gradient_color(final_signal) |
|
|
|
|
|
fig, ax = plt.subplots(figsize=(15, 6)) |
|
|
|
|
|
for i in range(len(final_signal) - 1): |
|
|
ax.plot(time[i:i+2], final_signal[i:i+2], color=colors[i], lw=2) |
|
|
|
|
|
ax.plot(time, final_signal, color='blue', alpha=0.5, label='Signal') |
|
|
|
|
|
reflection_factor = 0.3 |
|
|
reflection = final_signal * reflection_factor |
|
|
reflection_color = 'lightblue' |
|
|
|
|
|
ax.plot(time, -reflection - reflectoin.min(), color=reflection_color, linestyle='--', alpha=0.6, lable='Reflection') |
|
|
|
|
|
ax.set_title('PulseWavefront') |
|
|
ax.set_xlabel('Time Step') |
|
|
ax.set_ylabel('Amplitude') |
|
|
ax.legend() |
|
|
ax.grid(True) |
|
|
|
|
|
plt.show() |
