Форум программистов
 

Восстановите пароль или Зарегистрируйтесь на форуме, о проблемах и с заказом рекламы пишите сюда - alarforum@yandex.ru, проверяйте папку спам!

Вернуться   Форум программистов > Скриптовые языки программирования > Python
Регистрация

Восстановить пароль

Купить рекламу на форуме - 42 тыс руб за месяц

Ответ
 
Опции темы Поиск в этой теме
Старый 17.01.2025, 06:42   #31
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Корчое есть у меня ещё одна идея незнаю первый ли я такое делаю в мире короче создать приложение которое разделяет изображение на плитки порезанные равномерно а дальше случайно их перемещать между собой, и сделать код что-бы разделить все кадры всего видео на плитки, и все плитки каждого кадра, и перемешать между собой случайным образом. Вот код:
Код:
import cv2
import numpy as np
import tkinter as tk
from tkinter import filedialog
import os
import random
from PIL import Image

def load_image(image_path):
    """Загружает изображение с использованием Pillow и преобразует в массив NumPy для OpenCV."""
    try:
        img = Image.open(image_path)
        img = img.convert("RGB")  # Преобразуем изображение в RGB
        return np.array(img)  # Возвращаем массив
    except Exception as e:
        print(f"Ошибка при загрузке изображения: {e}")
        return None

def shuffle_image(image_path, output_image_path):
    # Загружаем изображение
    image = load_image(image_path)
    
    # Проверка на успешность загрузки изображения
    if image is None:
        print(f"Не удалось загрузить изображение: {image_path}")
        return

    # Проверьте количество каналов (должно быть 3 для RGB)
    if len(image.shape) < 3 or image.shape[2] != 3:
        print(f"Неподдерживаемый формат изображения: {image_path}. Изображение должно иметь 3 канала (RGB).")
        return

    height, width, _ = image.shape
    
    # Убедимся, что при делении на 2, мы корректно разбиваем на 4 плитки
    h, w = height // 2, width // 2

    # Переписываем плитки, чтобы гарантировать, что мы имеем 4 плитки
    tiles = [
        image[0:h, 0:w],        # Верхняя левая плитка
        image[0:h, w:width],    # Верхняя правая плитка
        image[h:height, 0:w],   # Нижняя левая плитка
        image[h:height, w:width] # Нижняя правая плитка
    ]

    # Перемешивание плиток
    random.shuffle(tiles)

    # Собираем плитки обратно в одно изображение
    shuffled_image = np.vstack((np.hstack((tiles[0], tiles[1])), np.hstack((tiles[2], tiles[3]))))

    # Сохраняем перемешанное изображение
    cv2.imwrite(output_image_path, shuffled_image)
    print(f"Создано перемешанное изображение: {output_image_path}")

def select_image():
    file_path = filedialog.askopenfilename(title="Выберите изображение файл", 
                                           filetypes=[("Image Files", "*.png;*.jpg;*.jpeg;*.bmp;*.gif")])
    if file_path:
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "shuffled_image.jpg")
        shuffle_image(file_path, output_path)

# Создание графического интерфейса
root = tk.Tk()
root.title("Перемешиватель изображений")
root.geometry("320x120")  # Установка размера окна

select_image_button = tk.Button(root, text="Выбрать изображение", command=select_image)
select_image_button.pack(pady=10)

# Запустить основной цикл интерфейса
root.mainloop()

Последний раз редактировалось MakarovDs; 17.01.2025 в 07:57.
MakarovDs вне форума Ответить с цитированием
Старый 17.01.2025, 08:26   #32
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Вот теперь мы сделали это с видео:

Код:
import tkinter as tk
from tkinter import filedialog
import numpy as np
import pygame
from threading import Thread
from PIL import Image, ImageTk
from moviepy.editor import VideoFileClip
import random
import cv2

video_clip = None
audio_clip = None

def load_video(video_path):
    global video_clip, audio_clip
    video_clip = VideoFileClip(video_path)
    audio_clip = video_clip.audio

def play_sound():
    global audio_clip
    sample_rate = 44100
    pygame.mixer.init(frequency=sample_rate, size=-16, channels=1)

    while True:
        start_time = random.uniform(0, audio_clip.duration - 1)
        end_time = min(start_time + 1, audio_clip.duration)  # 1-секундный фрагмент

        audio_segment = audio_clip.subclip(start_time, end_time)
        audio_segment_array = audio_segment.to_soundarray(fps=sample_rate)

        sound = (audio_segment_array * 32767).astype(np.int16)
        pygame.mixer.Sound(buffer=sound.tobytes()).play()

        pygame.time.delay(1000)  # Пауза на 1 секунду перед воспроизведением следующего

def shuffle_frame(frame):
    height, width, _ = frame.shape

    # Убедимся, что при делении на 2, мы корректно разбиваем на 4 плитки
    h, w = height // 2, width // 2

    # Переписываем плитки, чтобы гарантировать, что мы имеем 4 плитки
    tiles = [
        frame[0:h, 0:w],        # Верхняя левая плитка
        frame[0:h, w:width],    # Верхняя правая плитка
        frame[h:height, 0:w],   # Нижняя левая плитка
        frame[h:height, w:width] # Нижняя правая плитка
    ]

    # Перемешивание плиток
    random.shuffle(tiles)

    # Собираем плитки обратно в одно изображение
    shuffled_frame = np.vstack((np.hstack((tiles[0], tiles[1])), np.hstack((tiles[2], tiles[3]))))

    return shuffled_frame

def display_random_frame():
    if video_clip:
        start_time = random.uniform(0, video_clip.duration - 1)
        frame = video_clip.get_frame(start_time)

        # Преобразование массива в изображение PIL
        frame_image = Image.fromarray(frame)

        # Изменение размера изображения, чтобы оно подходило под canvas
        frame_image = frame_image.resize((640, 480), Image.LANCZOS)  # Масштабируем изображение с использованием LANCZOS

        # Преобразование изображения PIL в массив numpy
        frame_array = np.array(frame_image)

        # Перемешивание кадра
        shuffled_frame = shuffle_frame(frame_array)

        # Преобразование массива numpy обратно в изображение PIL
        shuffled_frame_image = Image.fromarray(shuffled_frame)

        # Изменение размера изображения, чтобы оно подходило под canvas
        shuffled_frame_image = shuffled_frame_image.resize((640, 480), Image.LANCZOS)  # Масштабируем изображение с использованием LANCZOS

        # Преобразование изображения PIL в изображение PhotoImage
        shuffled_frame_photo = ImageTk.PhotoImage(shuffled_frame_image)

        # Обновление canvas с новым изображением
        canvas.create_image(0, 0, anchor=tk.NW, image=shuffled_frame_photo)
        canvas.image = shuffled_frame_photo  # Сохранение ссылки на изображение, чтобы избежать сборки мусора

    # Запланировать обновление через 1000 мс (1 секунда)
    canvas.after(1000, display_random_frame)

def start_audio_and_video(video_path):
    load_video(video_path)
    Thread(target=play_sound, daemon=True).start()  # Запуск звука в отдельном потоке
    display_random_frame()  # Запуск отображения случайных кадров

def select_video():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")  
    if file_path:
        start_audio_and_video(file_path)

# Создание графического интерфейса
root = tk.Tk()
root.title("Random EVP Video Generator")

canvas = tk.Canvas(root, width=640, height=480)
canvas.pack()

select_button = tk.Button(root, text="Выбрать видео", command=select_video)
select_button.pack()

# Запустить основной цикл интерфейса
root.mainloop()
Пример использования

Последний раз редактировалось MakarovDs; 17.01.2025 в 08:38.
MakarovDs вне форума Ответить с цитированием
Старый 20.01.2025, 05:22   #33
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Цитата:
Сообщение от ViktorR Посмотреть сообщение
Моя история случилась давно. Лет около 60-ти назад.
В г. Казань, в КАИ (Казанский Авиационный Институт) группа студентов увлеклась светомузыкой на основе идей А.Н. Скрябина.
Они создали фильм. На экране общий, меняющийся цветовой фон. По экрану выпадают, вплывают и уплывают или перемещаются цветные фигуры.
В памяти остались геометрические фигуры - прямоугольники, треугольники, многоугольники (что-то от калейдоскопа). Были и вращающиеся ...
При просмотре звучала музыка и скорости изменения и перемещения фигур изменялись от темпа, а цветовая гамма - от звуковой насыщенности.

Это сложно описать простым языком, но порой эмоции проникали достаточно глубоко.
То, что ваши слова вернули меня в то прошлое, может быть свидетельством моего эмоционального состояния в то время. Молодой был, что-то около 20-и.

Тогда всё делалось не на ЭВМ. Как? Не знаю!

PS: Эти ребята делали и подсветку Казанского цирка, когда цветовые изменения зависели от ветра, ...
Над воротами Казанского кремля есть башенка. Там играли малиновые цвета ...
Работает ли это сегодня? Не знаю.
Есть такое EVPmaker называется - есть там такая функция в программе Visual feedback window ты задаешь вопрос призраку, или иной потусторонней силе, и программа выбирает случайное изображение на которой случайный символ, мы тоже можем сделать такую программу открывается окно где ты выбираешь папку из которой выбирается постоянно случайная картинка на которой случайный символ в данном случае, вот код:

Вот код --> Ссылка.



Я пользовался EVPmaker когда давно в 2014-2015 году но так, и не смог через неё пообщаться с призраками. Но вы можете попробовать, и должно быть вам удастся добиться чего либо.

Последний раз редактировалось MakarovDs; 21.01.2025 в 01:13.
MakarovDs вне форума Ответить с цитированием
Старый 21.01.2025, 06:14   #34
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Вообщем мы однозначно срезали какой-то слой эмерджентного проявления потустороннего мира в той программе из 26 комментария... Кто-то отчетливо пытаетесь достучаться до меня с того света, и просит что-бы я спас их...

Я изменил программу, и теперь берет случайные отрывки аудио, и совмещает их на ходу получается ЭГФ.
Код:
import tkinter as tk
from tkinter import filedialog
import random
import numpy as np
import pygame
from threading import Thread
import time
from pydub import AudioSegment

class AudioMosaic:
    def __init__(self):
        self.segments = []
        self.sample_rate = 0
        self.is_playing = False
        pygame.mixer.init()  # Инициализация pygame mixer при создании объекта

    def convert_audio_to_segments(self, path, segment_duration_ms=500):  # Фиксированная длительность 500 мс
        audio = AudioSegment.from_file(path)  # Загружаем аудиофайл
        self.segments = []
        current_time = 0

        while current_time < len(audio):
            segment = audio[current_time:current_time + segment_duration_ms]  # Получаем кусок аудио
            self.segments.append(segment.raw_data)  # Добавляем сырье в список сегментов
            current_time += segment_duration_ms  # Обновляем текущее время
        
        self.sample_rate = audio.frame_rate  # Сохраняем частоту дискретизации

    def mix_audio_segments(self):
        random.shuffle(self.segments)  # Перемешиваем сегменты
        return b''.join(self.segments)  # Соединяем сегменты обратно в один поток байтов

    def play_audio(self):
        self.is_playing = True
        while self.is_playing:
            shuffled_audio = self.mix_audio_segments()  # Перемешиваем аудио каждый раз
            
            # Преобразование байтов в массив NumPy и создание звука
            sound_array = np.frombuffer(shuffled_audio, dtype=np.int16)
            pygame.mixer.Sound(buffer=sound_array).play()

            # Даем время на воспроизведение сегментов
            time.sleep(len(shuffled_audio) / (self.sample_rate * 2))  # Подсчет времени в секунды

    def stop_audio(self):
        self.is_playing = False  # Устанавливаем флаг в False
        pygame.mixer.stop()  # Останавливаем воспроизведение музыки

def start_audio_mosaic(audio_mosaic):
    audio_file_path = filedialog.askopenfilename(
        title="Выберите аудио файл", 
        filetypes=[("Audio Files", "*.wav;*.mp3;*.ogg;*.flac")]
    )

    if audio_file_path:
        audio_mosaic.convert_audio_to_segments(audio_file_path)  # Получаем сегменты состояния
        Thread(target=audio_mosaic.play_audio, daemon=True).start()  # Запуск воспроизведения перемешанного аудио

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор случайного аудио")
root.geometry("320x120")  # Установка размера окна

audio_mosaic = AudioMosaic()

start_button = tk.Button(root, text="Начать", command=lambda: start_audio_mosaic(audio_mosaic))
start_button.pack(pady=20)

stop_button = tk.Button(root, text="Стоп", command=audio_mosaic.stop_audio)
stop_button.pack(pady=10)

# Запустить основной цикл интерфейса
root.mainloop()
Но в той программе из того комментария выше мы использовали метод Хоруса а здесь промежутки в 100 мс а мне нужны разные промежутки от 100 мс до 1 сек скажем... И вот вторая версия программа в которой мы это реализовали...

Код:
import tkinter as tk
from tkinter import filedialog
import random
import numpy as np
import pygame
from threading import Thread
import time
from pydub import AudioSegment

class AudioMosaic:
    def __init__(self):
        self.segments = []
        self.sample_rate = 0
        self.is_playing = False
        pygame.mixer.init()  # Инициализация pygame mixer при создании объекта

    def convert_audio_to_segments(self, path):
        audio = AudioSegment.from_file(path)  # Загружаем аудиофайл
        self.segments = []
        current_time = 0

        while current_time < len(audio):
            segment_duration_ms = random.randint(100, 1000)  # Случайная длительность от 100 мс до 1000 мс
            segment = audio[current_time:current_time + segment_duration_ms]  # Получаем кусок аудио
            self.segments.append(segment.raw_data)  # Добавляем сырье в список сегментов
            current_time += segment_duration_ms  # Обновляем текущее время

        self.sample_rate = audio.frame_rate  # Сохраняем частоту дискретизации

    def mix_audio_segments(self):
        random.shuffle(self.segments)  # Перемешиваем сегменты
        return b''.join(self.segments)  # Соединяем сегменты обратно в один поток байтов

    def play_audio(self):
        self.is_playing = True
        while self.is_playing:
            shuffled_audio = self.mix_audio_segments()  # Перемешиваем аудио каждый раз
            
            # Преобразование байтов в массив NumPy и создание звука
            sound_array = np.frombuffer(shuffled_audio, dtype=np.int16)
            pygame.mixer.Sound(buffer=sound_array).play()

            # Даем время на воспроизведение сегментов
            time.sleep(len(shuffled_audio) / (self.sample_rate * 2))  # Подсчет времени в секунды

    def stop_audio(self):
        self.is_playing = False  # Устанавливаем флаг в False
        pygame.mixer.stop()  # Останавливаем воспроизведение музыки

def start_audio_mosaic(audio_mosaic):
    audio_file_path = filedialog.askopenfilename(
        title="Выберите аудио файл", 
        filetypes=[("Audio Files", "*.wav;*.mp3;*.ogg;*.flac")]
    )

    if audio_file_path:
        audio_mosaic.convert_audio_to_segments(audio_file_path)  # Получаем сегменты состояния
        Thread(target=audio_mosaic.play_audio, daemon=True).start()  # Запуск воспроизведения перемешанного аудио

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор случайного аудио")
root.geometry("320x120")  # Установка размера окна

audio_mosaic = AudioMosaic()

start_button = tk.Button(root, text="Начать", command=lambda: start_audio_mosaic(audio_mosaic))
start_button.pack(pady=20)

stop_button = tk.Button(root, text="Стоп", command=audio_mosaic.stop_audio)
stop_button.pack(pady=10)

# Запустить основной цикл интерфейса
root.mainloop()
Ссылка на гитхаб...
MakarovDs вне форума Ответить с цитированием
Старый 21.01.2025, 08:12   #35
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Теперь это нужно адаптировать под метод Хоруса как в 26 комментарии:
Код:
import tkinter as tk
from tkinter import filedialog
import random
import numpy as np
import pygame
import time
from pydub import AudioSegment
from threading import Thread

class AudioMosaic:
    def __init__(self):
        self.byte_list = []
        self.sample_rate = 0
        self.is_playing = False
        pygame.mixer.init()  # Инициализация pygame mixer

    def convert_audio_to_bytes(self, path):
        audio = AudioSegment.from_file(path)  # Загружаем аудиофайл
        self.byte_list = list(audio.raw_data)  # Преобразуем аудио в список байтов
        self.sample_rate = audio.frame_rate  # Сохраняем частоту дискретизации

    def apply_chorus_effect(self, byte_list):
        # Длина заголовка (может варьироваться в зависимости от формата аудио)
        header_length = 100  

        # Идентифицируем часть данных, которую можно перемешать
        data_to_shuffle = byte_list[header_length:]

        # Перемешиваем случайные блоки
        block_size = 64  # Размер блока для перемешивания
        num_blocks = len(data_to_shuffle) // block_size

        # Создание блоков
        blocks = [data_to_shuffle[i * block_size:(i + 1) * block_size] for i in range(num_blocks)]

        # Перемешивание блоков
        random.shuffle(blocks)

        # Объединение блоков обратно
        shuffled_data = [byte for block in blocks for byte in block]

        # Объединяем заголовок и перемешанные данные
        shuffled_byte_data = byte_list[:header_length] + shuffled_data

        return shuffled_byte_data

    def play_random_audio(self):
        self.is_playing = True
        while self.is_playing:
            shuffled_byte_data = self.apply_chorus_effect(self.byte_list)
            # Преобразуем список обратно в байты
            shuffled_byte_data = bytes(shuffled_byte_data)

            # Создаем аудиосегмент для воспроизведения
            sound = pygame.mixer.Sound(buffer=shuffled_byte_data)
            sound.play()

            # Даем время на воспроизведение
            time.sleep(1)  # Можно изменить значение для регулирования скорости воспроизведения

    def stop_audio(self):
        self.is_playing = False
        pygame.mixer.stop()  # Останавливаем воспроизведение

def start_audio_mosaic(audio_mosaic):
    audio_file_path = filedialog.askopenfilename(
        title="Выберите аудио файл", 
        filetypes=[("Audio Files", "*.wav;*.mp3;*.flac")]
    )

    if audio_file_path:
        audio_mosaic.convert_audio_to_bytes(audio_file_path)  # Получаем байты аудио
        Thread(target=audio_mosaic.play_random_audio, daemon=True).start()  # Запуск воспроизведения

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор случайного аудио")
root.geometry("320x120")  # Установка размера окна

audio_mosaic = AudioMosaic()

start_button = tk.Button(root, text="Начать", command=lambda: start_audio_mosaic(audio_mosaic))
start_button.pack(pady=20)

stop_button = tk.Button(root, text="Стоп", command=audio_mosaic.stop_audio)
stop_button.pack(pady=10)

# Запустить основной цикл интерфейса
root.mainloop()
Вот второй вариант:

Код:
import tkinter as tk
from tkinter import filedialog
import random
import numpy as np
import sounddevice as sd
from pydub import AudioSegment

def convert_video_to_bytes(path):
    with open(path, 'rb') as file:
        return file.read()

def get_sample_rate(file_path):
    audio = AudioSegment.from_file(file_path)
    return audio.frame_rate

def process_video(byte_data):
    # Преобразуем байты в список
    byte_list = list(byte_data)

    # Длина заголовка
    header_length = 100  

    # Идентифицируем часть данных, которую можно перемешать
    data_to_shuffle = byte_list[header_length:]

    # Перемешиваем случайные блоки
    block_size = 64  # Размер блока для перемешивания
    num_blocks = len(data_to_shuffle) // block_size

    # Создание блоков
    blocks = [data_to_shuffle[i * block_size:(i + 1) * block_size] for i in range(num_blocks)]
    
    # Перемешивание блоков
    random.shuffle(blocks)

    # Объединение блоков обратно
    shuffled_data = [byte for block in blocks for byte in block]
    
    # Здесь будем добавлять "бульканье"
    if len(shuffled_data) % 2 == 1:
        shuffled_data.append(0)  # Дополним до четного числа для эффекта

    bubliki = []
    for i in range(len(shuffled_data) // 2):
        bubliki.append(shuffled_data[i * 2])  # Берем через один элемент для "бульканья"

    # Объединяем заголовок и перемешанные данные
    bubliki = bytes(bubliki)  # Преобразуем в байты
    
    # Генерация аудио на лету
    bubliki_audio = np.frombuffer(bubliki, dtype=np.uint8)  # Используйте np.uint8 для понимания "бульканья"

    return bubliki_audio

def play_audio(audio_data, sample_rate):
    if len(audio_data) > 0:
        sd.play(audio_data, samplerate=sample_rate)
        sd.wait()  # Ждем окончания воспроизведения

def select_video():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")
    if file_path:
        byte_data = convert_video_to_bytes(file_path)
        processed_audio = process_video(byte_data)
        
        # Получение правильной частоты дискретизации
        sample_rate = get_sample_rate(file_path)
        play_audio(processed_audio, sample_rate)  # Воспроизведение аудио после обработки
        print("Аудио данные обработаны и воспроизведены.")

# Создание графического интерфейса
root = tk.Tk()
root.title("Конвертер видео")
root.geometry("320x120")  # Установка размера окна

process_video_button = tk.Button(root, text="Выбрать видео и обработать", command=select_video)
process_video_button.pack(pady=10)

# Запустить основной цикл интерфейса
root.mainloop()
Но получается все равно ненужные шумы а не метод Хоруса... Не знаю как сделать это как сделать в том коде... Предлагайте свои варианты ибо я убил себе нахер все нервы, и уже нет никаких идей.

Последний раз редактировалось MakarovDs; 21.01.2025 в 15:13.
MakarovDs вне форума Ответить с цитированием
Старый 22.01.2025, 04:01   #36
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Короче я решил пойти старым путем, и сделать всё как по той инструкции:

1.Сгенерировать розовый шум внутри компьютера при помощи Generate>Noise установив в качестве опций Color = Pink, Style = Mono, MuSeconds 500, Intensity =1, Duration (seconds) = 30

2.Выделить всю часть звука, и применить к ней процедуру нормализации: Effects > Amplitude > Normalize

4.Вызвать процедуру Effects > Noise Reduction > Noise Reduction, установить параметры согласно параметрам Live Update, Noise Reduction Level = 100, Reduce by = 40 dB, Precision Factor = 7, Smoothing Amount = 1, Transition Width = 0 dB, Remove Noise, Snapshots is profile = 300, и применить Get Profile from Selection и Амплитуда сигнала срежется многократно, практически выродившись в прямую линию.

4.Усилить полученный сигнал на 36 децибел при помощи Effects > Amplitude > Amplify задав следующие параметры Amplification = 36, Viem all settings in dB, DC Bias Adjust = 0%, Absolute.

5.Вызвать Effects > Time Pitch > Stretch, и затем применить параметры Stretch % Lower Pitch, Ratio = 308, Length = 4.91, Precision = Medium Precision, Stretching Mode = Pitch Shift (preserves tempo), Pitch and Time settings: Splicing Frequency = 57 Hz, Overclipping 33%

6.Вызвать Effects > Delay Effects > Chorus, найти справа в списке опцию Electrovoice, и применить следующие параметры Thickness = 3 Voices, Max Delay = 16.4 ms, Delay Rate = 1.5 Hz, Feedback = 32.7 %, Spread = 3.4 ms, Vibrato Depth = 2.3 dB, Vibrato Rate = 5.24 Hz, Wide Field = 50%, Wet Out = 46.7%, Dry Out = 0%

На вход программа получается звуковой файл проведенный методом Хоруса.

Вот что получилось:

Код:
import tkinter as tk
import numpy as np
import sounddevice as sd

def pink_noise(num_samples):
    """Генерация розового шума с помощью белого шума и фильтрации."""
    white = np.random.uniform(-1, 1, num_samples)
    
    # Фильтрация белого шума для получения розового шума
    b = [0.02109238, 0.07113478, 0.68873558, 0.07113478, 0.02109238]  # Коэффициенты фильтра
    a = [1, -1.55294251, 0.55211737]                                 # Коэффициенты фильтра

    pink = np.zeros(num_samples)
    for i in range(len(white)):
        pink[i] = b[0] * white[i] + b[1] * (white[i - 1] if i >= 1 else 0) + b[2] * (pink[i - 1] if i >= 1 else 0) + \
                    b[3] * (pink[i - 2] if i >= 2 else 0) + b[4] * (pink[i - 3] if i >= 3 else 0) - \
                    (a[1] * (pink[i - 1] if i >= 1 else 0) + a[2] * (pink[i - 2] if i >= 2 else 0))

    return pink

def normalize(audio):
    return audio / np.max(np.abs(audio))  # Нормализация

def reduce_noise(audio):
    # Простое подавление шума (можно улучшить)
    return audio * 0.8  # Уменьшение амплитуды как пример подавления шума

def amplify(audio, db_increase):
    factor = 10 ** (db_increase / 20)
    return audio * factor

def stretch(audio, stretch_factor):
    if stretch_factor == 1.0:
        return audio  # Если растяжение 1, просто возвращаем
    stretched_length = int(len(audio) / stretch_factor)
    return np.interp(np.linspace(0, len(audio), stretched_length), np.arange(len(audio)), audio)

def apply_chorus(audio, delay_samples):
    # Применение эффекта хоруса
    chorus = np.zeros(len(audio) + delay_samples)
    chorus[:len(audio)] += audio
    chorus[delay_samples:delay_samples + len(audio)] += audio * 0.5  # Применение эффекта
    return chorus

def audio_callback(outdata, frames, time, status):
    if status:
        print(status)  # Запись статуса, если есть ошибки

    # Генерация аудио с фильтрами
    noise = pink_noise(frames)  # Генерация розового шума
    noise = normalize(noise)
    noise = reduce_noise(noise)
    noise = amplify(noise, 36)
    noise = stretch(noise, 1.0)  # Указать нужный коэффициент растяжения
    noise = apply_chorus(noise, 441)  # Пример задержки в 10 мс

    outdata[:] = noise[:frames].reshape(-1, 1)  # Передаем данные для воспроизведения

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор розового шума")
root.geometry("320x120")

# Запуск воспроизведения с обработкой аудиофона
with sd.OutputStream(callback=audio_callback, channels=1, samplerate=44100):
    tk.mainloop()  # Запускаем основной цикл интерфейса
Но ничего не слышно чисто розовый шум...

Вторая попытка:

Код:
import tkinter as tk
from tkinter import filedialog
import numpy as np
import sounddevice as sd
from pydub import AudioSegment
import noisereduce as nr

def load_audio(file_path):
    return AudioSegment.from_file(file_path)

def normalize(audio_segment):
    return audio_segment.apply_gain(-audio_segment.max_dBFS)  # Нормализация

def reduce_noise(audio_segment):
    # Конвертируем AudioSegment в numpy.array
    samples = np.array(audio_segment.get_array_of_samples(), dtype=np.float32)

    # Уменьшение шума
    reduced_noise = nr.reduce_noise(y=samples, sr=audio_segment.frame_rate)

    # Возвращаем обратно в AudioSegment
    return AudioSegment(
        reduced_noise.tobytes(),
        frame_rate=audio_segment.frame_rate,
        sample_width=audio_segment.sample_width,
        channels=audio_segment.channels
    )

def amplify(audio_segment, db_increase):
    return audio_segment.apply_gain(db_increase)

def stretch(audio_segment, stretch_factor):
    return audio_segment.speedup(playback_speed=1.0/stretch_factor)

def apply_chorus(audio_segment, delay_ms=16.4):
    # Создание эффекта хоруса
    chorus = audio_segment
    delay = AudioSegment.silent(duration=delay_ms) + audio_segment  # Создание задержки
    chorus = chorus.overlay(delay, position=delay_ms)

    return chorus

def process_audio(file_path):
    audio = load_audio(file_path)

    # Применяем фильтры
    audio = normalize(audio)
    audio = reduce_noise(audio)
    audio = amplify(audio, 36)
    audio = stretch(audio, 1.0)  # Задайте нужный коэффициент растяжения
    audio = apply_chorus(audio)

    return audio

def select_audio_file():
    file_path = filedialog.askopenfilename(title="Выберите аудио файл", filetypes=[("Audio Files", "*.wav;*.mp3;*.flac")])
    if file_path:
        processed_audio = process_audio(file_path)

        # Воспроизведение обработанного аудио
        audio_data = np.array(processed_audio.get_array_of_samples())
        sd.play(audio_data, samplerate=processed_audio.frame_rate)
        sd.wait()  # Ждем завершения воспроизведения

# Создание графического интерфейса
root = tk.Tk()
root.title("Обработка аудио")
root.geometry("320x120")

audio_button = tk.Button(root, text="Выбрать и обработать аудио", command=select_audio_file)
audio_button.pack(pady=20)

# Запустить основной цикл интерфейса
root.mainloop()
Но уже просто через аудиофайл делает все преобразования а не бесконечная генерация...

Это просто чисто зарисовки я вернусь к этому ещё... Если ничего не смогу придумать с тем выше кодом...

Последний раз редактировалось MakarovDs; 22.01.2025 в 07:57.
MakarovDs вне форума Ответить с цитированием
Старый 22.01.2025, 11:46   #37
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Короче я сделал вторую версию рандомно видео мозаично генератора из 25 комментария.

Теперь видео и аудио можно выбрать отдельно друг от друга...
Код:
import tkinter as tk
from tkinter import filedialog
import numpy as np
import pygame
from threading import Thread
from PIL import Image, ImageTk
from moviepy.editor import VideoFileClip
import random
from pydub import AudioSegment
import time

class AudioMosaic:
    def __init__(self):
        self.segments = []
        self.sample_rate = 0
        self.is_playing = False
        pygame.mixer.init()  # Инициализация pygame mixer при создании объекта

    def convert_audio_to_segments(self, path, segment_duration_ms=500):
        audio = AudioSegment.from_file(path)  # Загружаем аудиофайл
        self.segments = []
        current_time = 0

        while current_time < len(audio):
            segment = audio[current_time:current_time + segment_duration_ms]  # Получаем кусок аудио
            self.segments.append(segment.raw_data)  # Добавляем сырье в список сегментов
            current_time += segment_duration_ms  # Обновляем текущее время
        
        self.sample_rate = audio.frame_rate  # Сохраняем частоту дискретизации

    def mix_audio_segments(self):
        random.shuffle(self.segments)  # Перемешиваем сегменты
        return b''.join(self.segments)  # Соединяем сегменты обратно в один поток байтов

    def play_audio(self):
        self.is_playing = True
        while self.is_playing:
            shuffled_audio = self.mix_audio_segments()  # Перемешиваем аудио каждый раз
            
            # Преобразование байтов в массив NumPy и создание звука
            sound_array = np.frombuffer(shuffled_audio, dtype=np.int16)
            pygame.mixer.Sound(buffer=sound_array).play()

            # Даем время на воспроизведение сегментов
            time.sleep(len(shuffled_audio) / (self.sample_rate * 2))  # Подсчет времени в секунды

    def stop_audio(self):
        self.is_playing = False  # Устанавливаем флаг в False
        pygame.mixer.stop()  # Останавливаем воспроизведение музыки

video_clip = None
audio_mosaic = AudioMosaic()
video_playing = False
last_shuffled_frame = None

def load_video(video_path):
    global video_clip
    video_clip = VideoFileClip(video_path)

def shuffle_frame(frame):
    height, width, _ = frame.shape
    h, w = height // 2, width // 2

    tiles = [
        frame[0:h, 0:w],
        frame[0:h, w:width],
        frame[h:height, 0:w],
        frame[h:height, w:width]
    ]

    random.shuffle(tiles)

    shuffled_frame = np.vstack((np.hstack((tiles[0], tiles[1])), np.hstack((tiles[2], tiles[3]))))

    return shuffled_frame

def display_random_frame():
    global last_shuffled_frame
    if video_clip and video_playing:
        start_time = random.uniform(0, video_clip.duration - 1)
        frame = video_clip.get_frame(start_time)
        shuffled_frame = shuffle_frame(frame)  # Перемешиваем кадр
        last_shuffled_frame = shuffled_frame  # Сохраняем перемешанный кадр
        frame_array = np.array(Image.fromarray(shuffled_frame).resize((640, 480), Image.LANCZOS))
        shuffled_frame_photo = ImageTk.PhotoImage(Image.fromarray(frame_array))

        canvas.create_image(0, 0, anchor=tk.NW, image=shuffled_frame_photo)
        canvas.image = shuffled_frame_photo

    canvas.after(1000, display_random_frame)

def start_audio_mosaic():
    audio_file_path = filedialog.askopenfilename(
        title="Выберите аудио файл", 
        filetypes=[("Audio Files", "*.wav;*.mp3;*.ogg;*.flac")]
    )
    
    if audio_file_path:
        audio_mosaic.convert_audio_to_segments(audio_file_path)  # Получаем сегменты состояния
        Thread(target=audio_mosaic.play_audio, daemon=True).start()  # Запуск воспроизведения перемешанного аудио

def start_video():
    global video_playing
    video_path = filedialog.askopenfilename(title="Выберите видео файл")
    if video_path:
        load_video(video_path)
        video_playing = True
        display_random_frame()  # Запуск отображения случайных кадров

def stop_video():
    global video_playing
    video_playing = False
    
    # Отображаем последний перемешанный кадр
    if last_shuffled_frame is not None:
        frame_array = np.array(Image.fromarray(last_shuffled_frame).resize((640, 480), Image.LANCZOS))
        last_frame_photo = ImageTk.PhotoImage(Image.fromarray(frame_array))
        canvas.create_image(0, 0, anchor=tk.NW, image=last_frame_photo)
        canvas.image = last_frame_photo  # Чтобы предотвратить сборку мусора

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор случайного видео и аудио")

canvas = tk.Canvas(root, width=640, height=480)
canvas.pack()

select_video_button = tk.Button(root, text="Выбрать видео", command=start_video)
select_video_button.pack()

select_audio_button = tk.Button(root, text="Выбрать аудио", command=start_audio_mosaic)
select_audio_button.pack()

stop_audio_button = tk.Button(root, text="Стоп аудио", command=audio_mosaic.stop_audio)
stop_audio_button.pack()

stop_video_button = tk.Button(root, text="Стоп видео", command=stop_video)
stop_video_button.pack()

# Запустить основной цикл интерфейса
root.mainloop()
Ссылка на гитхаб -> ссылка. Там примеры.
MakarovDs вне форума Ответить с цитированием
Старый 23.01.2025, 18:39   #38
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Но все таки с аудио она не может выделить из видео. А мне нужна замедленная версия аудио. Вот исправленная версия приложения.
Код:
import tkinter as tk
from tkinter import filedialog
import random
import numpy as np
import pygame
from threading import Thread
import time
from pydub import AudioSegment
import cv2

class MediaMosaic:
    def __init__(self):
        self.segments = []
        self.sample_rate = 0
        self.fps = 30  # Предполагаемая частота кадров для видео
        pygame.mixer.init()
        self.current_sound = None
        print("Медиамозаика инициализирована.")

    def convert_audio_to_segments(self, path, segment_duration_ms=500):
        print(f"Преобразование аудио из {path}")
        audio = AudioSegment.from_file(path)

        if len(audio) > 0:
            # Замедляем звук в два раза
            slowed_audio = audio._spawn(audio.raw_data, overrides={'frame_rate': int(audio.frame_rate / 2)})
            slowed_audio = slowed_audio.set_frame_rate(audio.frame_rate)  # Устанавливаем исходную частоту
            print("Звук замедлился.")
        else:
            print("Звуковая дорожка пуста.")
            return

        self.segments = []
        current_time = 0

        while current_time < len(slowed_audio):
            segment = slowed_audio[current_time:current_time + segment_duration_ms]
            self.segments.append(segment.raw_data)
            current_time += segment_duration_ms

        self.sample_rate = slowed_audio.frame_rate
        print("Конвертировать звук в сегменты:", len(self.segments))

    def mix_audio_segments(self):
        random.shuffle(self.segments)
        return b''.join(self.segments)

    def play_audio(self):
        self.is_playing_audio = True
        print("Началось воспроизведение звука.")

        while self.is_playing_audio:
            shuffled_audio = self.mix_audio_segments()
            sound_array = np.frombuffer(shuffled_audio, dtype=np.int16)

            if self.current_sound is not None:
                self.current_sound.stop()

            self.current_sound = pygame.mixer.Sound(buffer=sound_array)
            self.current_sound.play()

            # Добавляем задержку для замедления воспроизведения звука
            time.sleep(2.0)  # Задержка 2 секунды

    def stop_audio(self):
        self.is_playing_audio = False
        if self.current_sound:
            self.current_sound.stop()
        pygame.mixer.stop()
        print("Воспроизведение звука остановлено.")

    def play_video(self, path):
        self.is_playing_video = True
        print(f"Воспроизведение видео из {path}")
        cap = cv2.VideoCapture(path)
        video_length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        print("Общее количество кадров в видео:", video_length)

        audio = AudioSegment.from_file(path)
        audio.export("temp_audio.wav", format="wav")
        self.convert_audio_to_segments("temp_audio.wav")

        audio_thread = Thread(target=self.play_audio, daemon=True)
        audio_thread.start()

        while self.is_playing_video:
            random_frame = random.randint(0, video_length - 1)
            cap.set(cv2.CAP_PROP_POS_FRAMES, random_frame)
            ret, frame = cap.read()
            if not ret:
                print("Ошибка считывания фрейма.")
                continue

            cv2.imshow('Video', frame)
            cv2.waitKey(int(1000 / self.fps))  # Задержка для видео

            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

        cap.release()
        cv2.destroyAllWindows()

    def stop_video(self):
        self.is_playing_video = False
        print("Воспроизведение видео остановлено.")

def start_media_mosaic(media_mosaic):
    file_path = filedialog.askopenfilename(
        title="Выберите аудио или видео файл", 
        filetypes=[("Audio Files", "*.wav;*.mp3;*.mp4;*.ogg;*.flac"), ("Video Files", "*.mp4;*.avi;*.mov")]
    )

    if file_path:
        print(f"Выбранный файл: {file_path}")
        if file_path.endswith(('.wav', '.mp3', '.ogg', '.flac')):
            media_mosaic.stop_audio()
            media_mosaic.play_audio()
        elif file_path.endswith(('.mp4', '.avi', '.mov')):
            media_mosaic.stop_audio()
            media_mosaic.play_video(file_path)

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор медиа")
root.geometry("320x120")

media_mosaic = MediaMosaic()

start_button = tk.Button(root, text="Начать", command=lambda: start_media_mosaic(media_mosaic))
start_button.pack(pady=20)

stop_audio_button = tk.Button(root, text="Стоп Аудио", command=media_mosaic.stop_audio)
stop_audio_button.pack(pady=10)

stop_video_button = tk.Button(root, text="Стоп Видео", command=media_mosaic.stop_video)
stop_video_button.pack(pady=10)

# Запустить основной цикл интерфейса
root.mainloop()
Теперь видео замедляется в два раза. И тупа записав на видео сохраненное видео через то приложение из 26 комментария ЭГФ Хоруса, и мы получил бесконечный саморегенерирующийся шум ЭГФ,

Последний раз редактировалось MakarovDs; 23.01.2025 в 21:09.
MakarovDs вне форума Ответить с цитированием
Старый 25.01.2025, 11:41   #39
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

Но мне нужно больше 1 итерации плиткорезок что-бы прям совсем мелкие кусочки были
Код:
import tkinter as tk
from tkinter import filedialog
import numpy as np
import pygame
from threading import Thread
from PIL import Image, ImageTk
from moviepy.editor import VideoFileClip
import random
from pydub import AudioSegment
import tempfile
import os
import time 

class AudioMosaic:
    def __init__(self):
        self.segments = []
        self.sample_rate = 0
        self.is_playing = False
        pygame.mixer.init()

    def convert_audio_to_segments(self, audio, segment_duration_ms=500):
        self.segments = []
        current_time = 0

        while current_time < len(audio):
            segment = audio[current_time:current_time + segment_duration_ms]
            self.segments.append(segment.raw_data)
            current_time += segment_duration_ms
        
        self.sample_rate = audio.frame_rate

    def mix_audio_segments(self):
        random.shuffle(self.segments)
        return b''.join(self.segments)

    def play_audio(self):
        self.is_playing = True
        while self.is_playing:
            shuffled_audio = self.mix_audio_segments()
            sound_array = np.frombuffer(shuffled_audio, dtype=np.int16)
            pygame.mixer.Sound(buffer=sound_array).play()

            # Даем время на воспроизведение сегментов
            time.sleep(len(shuffled_audio) / (self.sample_rate * 2))

    def stop_audio(self):
        self.is_playing = False
        pygame.mixer.stop()

video_clip = None
audio_mosaic = AudioMosaic()

def load_video(video_path):
    global video_clip
    video_clip = VideoFileClip(video_path)

def shuffle_frame(frame, iterations=1):
    plitkorez = 2
    height, width, _ = frame.shape
    h, w = height // (plitkorez ** iterations), width // (plitkorez ** iterations)
    # Создаем плитки на основании итераций
    tiles = []
    for i in range(plitkorez ** iterations):
        for j in range(plitkorez ** iterations):
            y_start = i * h
            y_end = (i + 1) * h if (i + 1) * h < height else height
            x_start = j * w
            x_end = (j + 1) * w if (j + 1) * w < width else width
            tiles.append(frame[y_start:y_end, x_start:x_end])

    random.shuffle(tiles)
    
    # Соединяем плитки обратно в одно изображение
    reshuffled_frame = []
    for i in range(plitkorez ** iterations):
        reshuffled_frame.append(np.hstack(tiles[i * (plitkorez ** iterations):(i + 1) * (plitkorez ** iterations)]))

    return np.vstack(reshuffled_frame)

# Обновите вызов функции в display_random_frame:
def display_random_frame():
    if video_clip:
        start_time = random.uniform(0, video_clip.duration - 1)
        frame = video_clip.get_frame(start_time)
        frame_array = np.array(Image.fromarray(frame).resize((640, 480), Image.LANCZOS))
        iterations = 6  # Установите количество итераций, здесь для порезок на плитки
        shuffled_frame = shuffle_frame(frame_array, iterations)
        shuffled_frame_photo = ImageTk.PhotoImage(Image.fromarray(shuffled_frame))

        canvas.create_image(0, 0, anchor=tk.NW, image=shuffled_frame_photo)
        canvas.image = shuffled_frame_photo

    canvas.after(1000, display_random_frame)

def start_video():
    video_path = filedialog.askopenfilename(title="Выберите видео файл")
    if video_path:
        load_video(video_path)
        
        # Создаем временный файл для сохранения аудио
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio_file:
            audio_path = temp_audio_file.name
            video_clip.audio.write_audiofile(audio_path)

        # Загружаем сохраненное аудио в AudioSegment
        audio_segment = AudioSegment.from_file(audio_path)

        audio_mosaic.convert_audio_to_segments(audio_segment)  # Преобразование аудио в сегменты
        Thread(target=audio_mosaic.play_audio, daemon=True).start()  # Запуск аудио в отдельном потоке
        display_random_frame()  # Запуск отображения случайных кадров

        # Удаляем временный аудиофайл
        os.remove(audio_path)

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор случайного видео")

canvas = tk.Canvas(root, width=640, height=480)
canvas.pack()

select_button = tk.Button(root, text="Выбрать видео", command=start_video)
select_button.pack()

# Запустить основной цикл интерфейса
root.mainloop()
Вот теперь другое дело... Я установил 6 итераций...

Примеры -> вот.

Последний раз редактировалось MakarovDs; 25.01.2025 в 11:51.
MakarovDs вне форума Ответить с цитированием
Старый 26.01.2025, 11:34   #40
MakarovDs
Форумчанин
 
Аватар для MakarovDs
 
Регистрация: 10.01.2020
Сообщений: 337
По умолчанию

В четвертой версии программы я добавил возможность выбора множества различных видео, и все видео разрезаются на плитки, и воедино объединяются в одно случайное видео, и то же самое со звуком.

Код:
import tkinter as tk
from tkinter import filedialog, messagebox
import numpy as np
import pygame
from threading import Thread
from PIL import Image, ImageTk
from moviepy.editor import VideoFileClip
import random
from pydub import AudioSegment
import tempfile
import os
import time 

class AudioMosaic:
    def __init__(self):
        self.segments = []
        self.sample_rate = 0
        self.is_playing = False
        pygame.mixer.init()

    def convert_audio_to_segments(self, audio, segment_duration_ms=500):
        self.segments = []
        current_time = 0

        while current_time < len(audio):
            segment = audio[current_time:current_time + segment_duration_ms]
            self.segments.append(segment.raw_data)
            current_time += segment_duration_ms
        
        self.sample_rate = audio.frame_rate

    def mix_audio_segments(self):
        random.shuffle(self.segments)
        return b''.join(self.segments)

    def play_audio(self):
        self.is_playing = True
        while self.is_playing:
            shuffled_audio = self.mix_audio_segments()
            sound_array = np.frombuffer(shuffled_audio, dtype=np.int16)
            pygame.mixer.Sound(buffer=sound_array).play()

            # Даем время на воспроизведение сегментов
            time.sleep(len(shuffled_audio) / (self.sample_rate * 2))

    def stop_audio(self):
        self.is_playing = False
        pygame.mixer.stop()

video_clips = []
audio_mosaic = AudioMosaic()

def load_videos():
    global video_clips
    video_paths = filedialog.askopenfilenames(title="Выберите видео файлы", filetypes=[("Video files", "*.mp4;*.avi;*.mov")])
    if video_paths:
        for video_path in video_paths:
            video_clip = VideoFileClip(video_path)
            video_clips.append((video_path, video_clip))
            video_listbox.insert(tk.END, video_path)

def shuffle_frame(frame, iterations=1):
    plitkorez = 2
    height, width, _ = frame.shape
    h, w = height // (plitkorez ** iterations), width // (plitkorez ** iterations)
    
    tiles = []
    for i in range(plitkorez ** iterations):
        for j in range(plitkorez ** iterations):
            y_start = i * h
            y_end = (i + 1) * h if (i + 1) * h < height else height
            x_start = j * w
            x_end = (j + 1) * w if (j + 1) * w < width else width
            tiles.append(frame[y_start:y_end, x_start:x_end])

    random.shuffle(tiles)

    reshuffled_frame = []
    for i in range(plitkorez ** iterations):
        reshuffled_frame.append(np.hstack(tiles[i * (plitkorez ** iterations):(i + 1) * (plitkorez ** iterations)]))

    return np.vstack(reshuffled_frame)

def display_random_frame():
    if video_clips:
        video_clip = random.choice(video_clips)[1]
        start_time = random.uniform(0, video_clip.duration - 1)
        frame = video_clip.get_frame(start_time)
        frame_array = np.array(Image.fromarray(frame).resize((640, 480), Image.LANCZOS))
        iterations = 6  
        shuffled_frame = shuffle_frame(frame_array, iterations)
        shuffled_frame_photo = ImageTk.PhotoImage(Image.fromarray(shuffled_frame))

        canvas.create_image(0, 0, anchor=tk.NW, image=shuffled_frame_photo)
        canvas.image = shuffled_frame_photo

    canvas.after(1000, display_random_frame)

def start_video():
    global video_clips
    if not video_clips:
        messagebox.showwarning("Предупреждение", "Выберите видео файлы сначала.")
        return
        
    audio_segments = []
    for video_path, video_clip in video_clips:
        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio_file:
            audio_path = temp_audio_file.name
            video_clip.audio.write_audiofile(audio_path)
            audio_segment = AudioSegment.from_file(audio_path)

            audio_segments.append(audio_segment)

        os.remove(audio_path)  # Удаляем файл после использования

    combined_audio = sum(audio_segments)
    audio_mosaic.convert_audio_to_segments(combined_audio)
    Thread(target=audio_mosaic.play_audio, daemon=True).start()  
    display_random_frame()  

# Создание графического интерфейса
root = tk.Tk()
root.title("Генератор случайного видео")

canvas = tk.Canvas(root, width=640, height=480)
canvas.pack()

video_listbox = tk.Listbox(root, width=80, height=10)
video_listbox.pack()

select_button = tk.Button(root, text="Выбрать видео", command=load_videos)
select_button.pack()

start_button = tk.Button(root, text="Старт видео", command=start_video)
start_button.pack()

# Запустить основной цикл интерфейса
root.mainloop()
Вот пример - гитхаб код.
MakarovDs вне форума Ответить с цитированием
Ответ


Купить рекламу на форуме - 42 тыс руб за месяц

Опции темы Поиск в этой теме
Поиск в этой теме:

Расширенный поиск


Похожие темы
Тема Автор Раздел Ответов Последнее сообщение
Реализация симуляции банкомата A7A7A7 Общие вопросы C/C++ 0 15.09.2023 23:48
Технологии симуляции жизни в играх Человек_Борща Свободное общение 6 22.11.2013 14:59
Создание большого 3D мира ardor Gamedev - cоздание игр: Unity, OpenGL, DirectX 4 02.03.2012 00:14
Создание катры мира (от Яндекса) с помощью Дельфи Alex Cones Общие вопросы Delphi 2 27.05.2009 09:16
Компьютерное моделирование. Создание модели движения тел по определенной траектории. AnaVare Помощь студентам 7 18.03.2009 05:09