Моделирование симуляции потустороннего мира (создание приложения)

[NetSpace]

вот если бы ваши духи могли говорить про дела минувшие, скажем, про убийства прошлых лет, очевидцами которых они были при жизни, то интересно было бы.
спиритизм как-то уже не в моде. ангелы, демоны и прочие голубые феи как-то остались в сказках далёкого детства.
---------
че-то как-то зелёный шар перемещался из угла в угол по нажатию кнопки "PLAY". ну, рандомно перемещать его - это тривиальная программа для любого новичка, который с графикой дружит.

[MakarovDs]

Сообщение от NetSpace

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

Они и так говорят просто ты даже не пытался с ними говорить. Даже в том видео комментария выше слышно "Привет пукалка!" то есть какая-то потусторонняя сила знает об этом, и решила потроллить... А если ты хочешь какого-то полноценного общения с призраками купи себе spiritbox, и общайся сколько хочешь... Пару примеров:

https://www.youtube.com/watch?v=7YFvj0AcO-w&t=633s

https://www.youtube.com/watch?v=tgazcW6jAc0

[MakarovDs]

Короче чё я подумал нахер эти спиритроны, спириттв, нужно сделать такую программу которая сделает бесконечную звуковую дорожку с бесконечной вариацией всевозможных звуков всеми всевозможными способами без повторений, и дальше сделать ползунок с случайной генерацией времени от 0 до 5 секунд который случайно перемещается по этой бесконечной звуковой дорожке в случайное место.

Но нет идей как сгенерировать число от нуля до бесконечности, была идея сделать массив, и перемешивать его до тех пор пока не наткнешь на определенный символ но тогда чем дальше число от нуля тем меньше шанс на то что оно выпадет:

import random  
from itertools import count  

arr = ["No", "No", "No", "No", "No", "No", "Stop", "No", "No"] 
g=0 
while arr[0] != "Stop": 
    random.shuffle(arr) 
    for i in count(): 
        g+=1 
print(g)

Была идея сделать машинную сеть, и её заучить генерировать число от нуля до бесконечности на основании идеи бесконечности:

import tensorflow as tf 

# Создание нейронной сети с изображением бесконечности 
model = tf.keras.Sequential([ 
    tf.keras.layers.Dense(float('inf'), input_shape=(float('inf'),)) 
]) 

# Сгенерирует случайное число от 0 до бесконечности на основе изображения бесконечности 
random_number = model.predict([[float('inf')]]) 
print(random_number)

Но всё равно программа споткнется о битность переменных (сперва) а потом в нехватку памяти(если справиться с первой задачей).

import sys
import random
sys.set_int_max_str_digits(999999999)
number = int('9'*999999999)
print(random.randint(0, number))

Тогда можно сгенерировать число от нуля до допустимого максимального значения в компиляторе, но в таком случае это число не от нуля до бесконечности а от нуля до очень огромного числа... И хотя мне не нужно симулировать число от нуля до бесконечности так как чтобы оценить, насколько огромным может быть число всевозможных вариаций звуков, нужно рассмотреть несколько аспектов:

[MakarovDs]

Вот что у меня получилось ссылка.

import tkinter as tk
import numpy as np
import pygame
from threading import Thread
from PIL import Image, ImageTk

def generate_random_audio(sample_rate=44100, duration=1):
    audio_data = np.random.uniform(-1, 1, int(sample_rate * duration)).astype(np.float32)
    return audio_data

def play_sound():
    sample_rate = 44100
    pygame.mixer.init(frequency=sample_rate, size=-16, channels=1)
    while True:
        sound = generate_random_audio(sample_rate)
        sound = (sound * 32767).astype(np.int16)  # Приведение к 16-битному формату
        pygame.mixer.Sound(buffer=sound.tobytes()).play()
        pygame.time.delay(100)  # Пауза для возможности восприятия звука

def generate_random_video(width=640, height=480):
    return np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)

def display_video():
    video_window = tk.Toplevel()  # Создание нового окна
    video_window.title("Random Video")

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

    def update_frame():
        frame = generate_random_video()

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

        canvas.create_image(0, 0, anchor=tk.NW, image=frame_image)
        canvas.image = frame_image  # Сохранение ссылки на изображение
        video_window.after(10, update_frame)  # Непрерывное обновление

    update_frame()

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

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

start_button = tk.Button(root, text="Start", command=start_audio_and_video)
start_button.pack()

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

Мы будем перемещаться в процедурных генераторах процедурных генераторов.

[MakarovDs]

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

А по новой ссылке будет старый код который генерирует случайное видео с случайным звуком на ходу.

[MakarovDs]

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

import tkinter as tk
from tkinter import filedialog
import os
import random

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

def bytes_to_video(byte_data, duration_minutes):
    output_path = os.path.join(os.path.expanduser("~"), "Desktop", f"undefined_{duration_minutes}.mp4")
    with open(output_path, 'wb') as file:
        file.write(byte_data)

def select_video_to_bytes():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")
    if file_path:
        byte_data = convert_video_to_bytes(file_path)
        
        # Преобразуем байты в список
        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]
        
        # Объединяем заголовок и перемешанные данные
        shuffled_byte_data = byte_list[:header_length] + shuffled_data
        
        # Преобразование обратно в байты
        shuffled_byte_data = bytes(shuffled_byte_data)

        text_file_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_bytes.txt")
        with open(text_file_path, 'w') as text_file:
            text_file.write(str(shuffled_byte_data))
        print(f"Байты видео сохранены в: {text_file_path}")

def select_bytes_to_video():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с байтами")
    if file_path:
        with open(file_path, 'r') as text_file:
            byte_data = eval(text_file.read())  # Преобразование строки в байты
        duration_minutes = 10  # Задайте длительность видео в минутах
        bytes_to_video(byte_data, duration_minutes)
        print(f"Видео создано на рабочем столе с именем: undefined_{duration_minutes}.mp4")

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

video_to_bytes_button = tk.Button(root, text="Видео в текст", command=select_video_to_bytes)
video_to_bytes_button.pack(pady=10)

bytes_to_video_button = tk.Button(root, text="Текст в видео", command=select_bytes_to_video)
bytes_to_video_button.pack(pady=10)

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

И короче я сделал это с парочкой музыкальных треков, и вот что я получил:

https://disk.yandex.ru/d/0ToC8ynmL-8yGQ

На 0:20 отчётливо слышно "Спаси нас!" на 0:40 "Прости нас!" на 0:52 "Возгена!" 01:08 "Разный ты" чё то в этом духе... 01:17 "Пусти нас" на 01:28 Пизды даш? 02:08 Ты нормальный? 02:12 спокойно... 02:31 вы кто такие? 02:38 Какое дело!? 02:45 Ира!

Это звуковой трек взять за основу KSHMR_Marnik__Bazaar_Official_Sunbu rn_Goa_2015_Anthem_EDM

Есть идея улучшить видео перемешивая не биты в видео, а разбивать их на случайные последовательность мозаик скажем от 1 до 10 битов, и тогда можно более эффективного результата добиться я думаю...

[MakarovDs]

Вот вторая версия по своему хорошая... Только какие-то последовательности наполовину перемешивает, и какие-то не перемешивает и потом смешивает воедино в аудио но с видео не работает.

import tkinter as tk
from tkinter import filedialog
import os
import random

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

def bytes_to_video(byte_data, duration_minutes):
    output_path = os.path.join(os.path.expanduser("~"), "Desktop", f"undefined_{duration_minutes}.mp4")
    with open(output_path, 'wb') as file:
        file.write(byte_data)

def select_video_to_bytes():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")
    if file_path:
        byte_data = convert_video_to_bytes(file_path)
        byte_list = list(byte_data)

        key_length = 100  # Длина ключевой части (например, заголовок)
        data_to_shuffle_start = key_length
        data_to_shuffle_end = len(byte_list)

        # Перемешиваем только 10% от остальной части
        to_shuffle = byte_list[data_to_shuffle_start:data_to_shuffle_end]
        num_bytes_to_shuffle = max(1, len(to_shuffle) // 10)  # Перемешиваем 10%
        
        # Выбираем случайные байты для перемешивания
        indices_to_shuffle = random.sample(range(len(to_shuffle)), num_bytes_to_shuffle)
        shuffled_section = [to_shuffle[i] for i in indices_to_shuffle]
        random.shuffle(shuffled_section)

        for i, index in enumerate(indices_to_shuffle):
            to_shuffle[index] = shuffled_section[i]

        # Объединяем перемешанные и неперемешанные байты
        shuffled_byte_data = byte_list[:data_to_shuffle_start] + to_shuffle
        
        # Преобразование обратно в байты
        shuffled_byte_data = bytes(shuffled_byte_data)
        text_file_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_bytes.txt")
        with open(text_file_path, 'w') as text_file:
            text_file.write(str(shuffled_byte_data))
        print(f"Байты видео сохранены в: {text_file_path}")

def select_bytes_to_video():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с байтами")
    if file_path:
        with open(file_path, 'r') as text_file:
            byte_data = eval(text_file.read())  # Преобразование строки в байты
        duration_minutes = 10  # Задайте длительность видео в минутах
        bytes_to_video(byte_data, duration_minutes)
        print(f"Видео создано на рабочем столе с именем: undefined_{duration_minutes}.mp4")

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

video_to_bytes_button = tk.Button(root, text="Видео в текст", command=select_video_to_bytes)
video_to_bytes_button.pack(pady=10)

bytes_to_video_button = tk.Button(root, text="Текст в видео", command=select_bytes_to_video)
bytes_to_video_button.pack(pady=10)

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

[ViktorR]

MakarovDs

Есть идея улучшить видео перемешивая не биты в видео, а разбивать их на случайные последовательность мозаик скажем от 1 до 10 битов, и тогда можно более эффективного результата добиться я думаю...

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

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

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

PS: Эти ребята делали и подсветку Казанского цирка, когда цветовые изменения зависели от ветра, ...
Над воротами Казанского кремля есть башенка. Там играли малиновые цвета ...
Работает ли это сегодня? Не знаю.

[MakarovDs]

Есть и третья версия которая перемешивает все кадры в видео случайным образом

import cv2
import numpy as np
import tkinter as tk
from tkinter import filedialog
import os
import random

def shuffle_video_frames(video_path, output_video_path):
    cap = cv2.VideoCapture(video_path)
    frames = []

    # Извлечение всех кадров из видео
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        frames.append(frame)
    
    cap.release()

    # Перемешивание кадров
    random.shuffle(frames)

    # Запись перемешанных кадров в новое видео
    height, width, layers = frames[0].shape
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    out = cv2.VideoWriter(output_video_path, fourcc, 30.0, (width, height))

    for frame in frames:
        out.write(frame)

    out.release()
    print(f"Создано новое видео: {output_video_path}")

def select_video():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")
    if file_path:
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "shuffled_video.mp4")
        shuffle_video_frames(file_path, output_path)

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

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

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

Но делает это без звука, и вот версия со звуком

from moviepy.editor import VideoFileClip, concatenate_videoclips, concatenate_audioclips
import tkinter as tk
from tkinter import filedialog
import os
import random

def split_video_and_audio(video_path, duration=1):
    video_clip = VideoFileClip(video_path)
    audio = video_clip.audio
    
    # Разделение видео на 1-секундные фрагменты
    video_clips = []
    audio_clips = []

    for start in range(0, int(video_clip.duration), duration):
        end = min(start + duration, video_clip.duration)
        video_clips.append(video_clip.subclip(start, end))
        audio_clips.append(audio.subclip(start, end))

    return video_clips, audio_clips

def shuffle_video_and_audio(video_path, output_video_path):
    video_clips, audio_clips = split_video_and_audio(video_path)
    
    # Случайное перемешивание видеофрагментов и аудиофрагментов
    random.shuffle(video_clips)
    random.shuffle(audio_clips)

    # Объединение перемешанных видеоклипов в один
    final_video = concatenate_videoclips(video_clips)
    final_audio = concatenate_audioclips(audio_clips)

    # Объединение перемешанных видеоклипов с аудиотреком
    final_video = final_video.set_audio(final_audio)

    # Сохранение итогового видео
    final_video.write_videofile(output_video_path)
    print(f"Создано новое видео: {output_video_path}")

def select_video():
    file_path = filedialog.askopenfilename(title="Выберите видео файл")
    if file_path:
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "shuffled_video.mp4")
        shuffle_video_and_audio(file_path, output_path)

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

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

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

Пример 2 программы -> видео.

[MakarovDs]

Я зашел ещё дальше теперь программа выбирает случайные кадры из видео, и генерирует их на ходу случайные выбранные кадры из этого видео с случайными отрывками аудио, и в 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

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 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
        frame_photo = ImageTk.PhotoImage(frame_image)

        # Обновление canvas с новым изображением
        canvas.create_image(0, 0, anchor=tk.NW, image=frame_photo)
        canvas.image = 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()

my github link