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

[MakarovDs]

Теперь нужно сделать что-бы каждый кадр каждого пикселя генерировался по сиду программы, и генерировался последовательно получается что в каждом кадре 2 073 600 массивов RGB это 6 220 800 чисел, и каждый массив чисел сида RGB разделить по три числа последовательностью равной количеством 6 220 800 чисел где каждое число может быть от 0 до 256 всевозможные перестановок без повторений, и на ходу в окне обновлять кадр каждую 0.001 секунду на новый сид:

сид 1 кадр 1: [[0, 1, 2], [3, 4, 5], ..., [254,255,256]]
сид 2 кадр 2: [[0, 1, 2], [3, 4, 5], ..., [254,256,255]]
сид 3 кадр 3: [[0, 1, 2], [3, 4, 5], ..., [255,254,256]]

Вот код сида:

https://github.com/MakarovDs777/Proc...seed-search.py

Вот код генератора видео:

import numpy as np
from itertools import permutations
import tkinter as tk
from PIL import Image, ImageTk
import pygame
import threading
import random
import time

pygame.mixer.init()

video_window = None
canvas = None

x, y, z = 0, 0, 0
seed = 0  # Начальный сид
auto_random_running = False 
auto_random_thread = None  
auto_random_delay = 1

def generate_rgb_permutations(numbers):
    return list(permutations(numbers, 3)) 

def generate_video_frame(permutations, index, width=640, height=480):
    frame = np.zeros((height, width, 3), dtype=np.uint8)

    for y in range(height):  
        for x in range(width): 
            rgb_index = (y * width + x + index) % len(permutations)
            frame[y, x] = np.array(permutations[rgb_index]) 

    return frame

def update_frame():
    global current_index
    if canvas:  # Проверяем, что canvas существует
        frame = generate_video_frame(rgb_permutations, current_index)
        if frame is not None:
            frame_image = Image.fromarray(frame)
            frame_image = ImageTk.PhotoImage(frame_image)

            canvas.delete('all')
            canvas.create_image(0, 0, anchor=tk.NW, image=frame_image)
            canvas.image = frame_image 

def auto_update_frames():
    global current_index
    while True:
        update_frame()
        current_index += 1
        time.sleep(0.001)  # Задержка 1 секунда

def display_video():
    global video_window, canvas
    video_window = tk.Toplevel()
    video_window.title("Random Video")

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

    update_frame()  # Первый кадр
    threading.Thread(target=auto_update_frames, daemon=True).start()  # Начало обновления кадров

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
    while True:
        sound = generate_random_audio(sample_rate)
        sound = (sound * 32767).astype(np.int16)
        pygame.mixer.Sound(buffer=sound.tobytes()).play()
        pygame.time.delay(100)

def update_coordinates_display():
    coordinates_label.config(text=f"Координаты - x: {x}, y: {y}, z: {z}, Seed: {seed}")

def move_left():
    global x
    x -= 1
    update_coordinates_display()

def move_right():
    global x
    x += 1
    update_coordinates_display()

def move_up():
    global y
    y += 1
    update_coordinates_display()

def move_down():
    global y
    y -= 1
    update_coordinates_display()

def set_seed():
    global seed
    try:
        seed = int(seed_entry.get())
        update_frame()  
        update_coordinates_display()  
    except ValueError:
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, str(seed)) 

def validate_seed_input(event):
    current_value = seed_entry.get()
    if not current_value.isdigit():
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, ''.join(filter(str.isdigit, current_value)))  # Удалить некорректные символы

def toggle_auto_random():
    global auto_random_running, auto_random_thread
    if auto_random_running:
        auto_random_running = False
        if auto_random_thread is not None:
            auto_random_thread.join()  
        auto_random_button.config(text="Запустить авторандом")
    else:
        auto_random_running = True
        auto_random_button.config(text="Остановить авторандом")
        auto_random_thread = threading.Thread(target=auto_random_coordinates)
        auto_random_thread.start()

def auto_random_coordinates():
    global x, y, z, auto_random_delay
    while auto_random_running:
        x = random.randint(0, 10000)
        y = random.randint(0, 10000)
        z = random.randint(0, 10000)
        update_coordinates_display()
        time.sleep(auto_random_delay)

def set_auto_random_delay():
    global auto_random_delay
    try:
        delay = float(auto_random_delay_entry.get())
        if delay > 0:
            auto_random_delay = delay
    except ValueError:
        auto_random_delay_entry.delete(0, tk.END)
        auto_random_delay_entry.insert(0, str(auto_random_delay)) 

numbers = list(range(10))  # Для примера используем 10 элементов
rgb_permutations = generate_rgb_permutations(numbers)
current_index = 0  # Индекс для отслеживания текущего кадра

# Создание основного окна
root = tk.Tk()
root.title("Procedural Audio and Video")
root.geometry("320x300")

start_button = tk.Button(root, text="Start", command=lambda: [threading.Thread(target=play_sound, daemon=True).start(), display_video()])
start_button.pack()

coordinates_label = tk.Label(root, text=f"Координаты - x: {x}, y: {y}, z: {z}, Seed: {seed}")
coordinates_label.pack()

seed_entry = tk.Entry(root)
seed_entry.pack()
seed_entry.insert(0, str(seed))  # Ввод сида по умолчанию
seed_entry.bind('<KeyRelease>', validate_seed_input)  # Проверка ввода сида

set_seed_button = tk.Button(root, text="Установить сид", command=set_seed)
set_seed_button.pack()

auto_random_delay_entry = tk.Entry(root)
auto_random_delay_entry.pack()
auto_random_delay_entry.insert(0, str(auto_random_delay))  # Ввод задержки по умолчанию

set_delay_button = tk.Button(root, text="Установить задержку", command=set_auto_random_delay)
set_delay_button.pack()

move_buttons_frame = tk.Frame(root)
move_buttons_frame.pack()

left_button = tk.Button(move_buttons_frame, text="Left", command=move_left)
left_button.grid(row=0, column=0)

right_button = tk.Button(move_buttons_frame, text="Right", command=move_right)
right_button.grid(row=0, column=2)

up_button = tk.Button(move_buttons_frame, text="Up", command=move_up)
up_button.grid(row=1, column=1)

down_button = tk.Button(move_buttons_frame, text="Down", command=move_down)
down_button.grid(row=2, column=1)

auto_random_button = tk.Button(root, text="Запустить авторандом", command=toggle_auto_random)
auto_random_button.pack()

root.mainloop()

Гитхаб код -> Полная версия.

[MakarovDs]

Теперь нужно добавить поля координат что-бы можно было перемещаться по координатам.

import random
from PIL import Image, ImageTk
import tkinter as tk

class InfiniteNoiseImage:
    def __init__(self):
        self.image_size = (800, 600)  # Размер изображения
        self.total_pixels = self.image_size[0] * self.image_size[1]  # Общее количество пикселей
        self.x, self.y = 0, 0  # Начальные координаты
        self.seed = random.randint(0, 10000)  # Случайный сид
        self.frames = 10  # Количество кадров для генерации
        self.current_frame_index = 0  # Индекс текущего кадра
        self.rgb_values = self.generate_rgb_values()  # Генерация значений RGB на основе сида
        self.is_moving = False  # Инициализируем переменную для автоматического перемещения

        self.root = tk.Tk()
        self.root.title("Infinite Noise Image")

        self.canvas = tk.Canvas(self.root, width=self.image_size[0], height=self.image_size[1])
        self.canvas.pack()

        # Метка для отображения координат
        self.coordinates_label = tk.Label(self.root, text=f"Координаты - X: {self.x}, Y: {self.y}, Seed: {self.seed}")
        self.coordinates_label.pack()

        # Панель с полями ввода и кнопками (в одну строку)
        controls_frame = tk.Frame(self.root)
        controls_frame.pack(side="top", anchor="w", pady=(10, 0))

        # Поля ввода для координат
        tk.Label(controls_frame, text="X:").grid(row=0, column=0)
        self.x_entry = tk.Entry(controls_frame, width=5)
        self.x_entry.grid(row=0, column=1)
        self.x_entry.insert(0, str(self.x))

        tk.Label(controls_frame, text="Y:").grid(row=0, column=2)
        self.y_entry = tk.Entry(controls_frame, width=5)
        self.y_entry.grid(row=0, column=3)
        self.y_entry.insert(0, str(self.y))

        tk.Label(controls_frame, text="Сид:").grid(row=0, column=4)
        self.seed_entry = tk.Entry(controls_frame, width=10)
        self.seed_entry.grid(row=0, column=5)
        self.seed_entry.insert(0, str(self.seed))

        set_coordinates_button = tk.Button(controls_frame, text="Установить координаты", command=self.set_coordinates)
        set_coordinates_button.grid(row=0, column=6)

        set_seed_button = tk.Button(controls_frame, text="Установить сид", command=self.set_seed)
        set_seed_button.grid(row=0, column=7)

        tk.Label(controls_frame, text="Скорость обновления (мс):").grid(row=0, column=8)
        self.speed_entry = tk.Entry(controls_frame, width=5)
        self.speed_entry.grid(row=0, column=9)
        self.speed_entry.insert(0, "1000")

        # Кнопки для управления
        self.update_button = tk.Button(controls_frame, text="Сгенерировать изображение", command=self.update_image)
        self.update_button.grid(row=0, column=10, padx=(5, 0))

        self.move_button = tk.Button(controls_frame, text="Авто-обновление", command=self.toggle_auto_move)
        self.move_button.grid(row=0, column=11, padx=(5, 0))

        # Добавление кнопок для перемещения
        left_button = tk.Button(controls_frame, text="←", command=self.move_left)
        left_button.grid(row=0, column=12, padx=(5, 0))

        up_button = tk.Button(controls_frame, text="↑", command=self.move_up)
        up_button.grid(row=0, column=13, padx=(5, 0))

        down_button = tk.Button(controls_frame, text="↓", command=self.move_down)
        down_button.grid(row=0, column=14, padx=(5, 0))

        right_button = tk.Button(controls_frame, text="→", command=self.move_right)
        right_button.grid(row=0, column=15, padx=(5, 0))

        self.image = Image.new('RGB', self.image_size)

        self.root.mainloop()

    def generate_rgb_values(self):
        # Генерация RGB значений по заданному сиду для каждого кадра
        rgb_values = []

        for frame in range(self.frames):
            random.seed(self.seed + frame)  # Устанавливаем сид для каждого кадра
            frame_rgb = []
            
            for i in range(self.total_pixels):
                # Генерация по порядку без повторений (в данном случае 3-значные последовательности)
                r = (i * 3) % 256
                g = (i * 3 + 1) % 256
                b = (i * 3 + 2) % 256
                frame_rgb.append((r, g, b))
            
            rgb_values.append(frame_rgb)
        
        return rgb_values

    def update_image(self):
        frame_rgb_colors = self.rgb_values[self.current_frame_index % self.frames]  # Получаем цвета для текущего кадра
        
        for i in range(len(frame_rgb_colors)):
            x = i % self.image_size[0]  # Вычисляем X-координату
            y = i // self.image_size[0]  # Вычисляем Y-координату
            self.image.putpixel((x, y), frame_rgb_colors[i])
        
        self.update_canvas()
        self.update_coordinates_display()  # Обновление отображения координат
        self.current_frame_index += 1  # Переходим к следующему кадру

    def update_canvas(self):
        image_tk = ImageTk.PhotoImage(self.image)
        self.canvas.create_image(0, 0, anchor=tk.NW, image=image_tk)
        self.canvas.image = image_tk  # Сохранение ссылки на изображение

    def update_coordinates_display(self):
        self.coordinates_label.config(text=f"Координаты - X: {self.x}, Y: {self.y}, Seed: {self.seed}")

    def set_coordinates(self):
        try:
            self.x = int(self.x_entry.get())
            self.y = int(self.y_entry.get())
            self.update_image()  # Обновляем изображение при изменении координат
            self.update_coordinates_display()  # Обновляем отображение координат
        except ValueError:
            # Игнорировать некорректные значения
            pass

    def set_seed(self):
        try:
            self.seed = int(self.seed_entry.get())
            self.rgb_values = self.generate_rgb_values()  # Генерация новых значений RGB на основе нового сида
            self.update_image()  # Обновляем изображение
        except ValueError:
            # Игнорировать некорректные значения
            pass

    def toggle_auto_move(self):
        if self.is_moving:
            self.is_moving = False
            self.move_button.config(text="Авто-обновление")
        else:
            self.is_moving = True
            self.move_button.config(text="Остановить обновление")
            self.auto_move()

    def auto_move(self):
        if self.is_moving:
            delta_x = random.randint(-10, 10)  # Случайный сдвиг по X
            delta_y = random.randint(-10, 10)  # Случайный сдвиг по Y
            self.x += delta_x
            self.y += delta_y
            
            self.update_coordinates_display()  # Обновляем табло координат при движении
            self.update_image()  # Обновляем изображение с новыми координатами

            speed = int(self.speed_entry.get()) if self.speed_entry.get().isdigit() else 1000
            self.root.after(speed, self.auto_move)  # Обновление через `speed` мс

    def move_left(self):
        self.x -= 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

    def move_right(self):
        self.x += 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

    def move_up(self):
        self.y += 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

    def move_down(self):
        self.y -= 1
        self.update_coordinates_display()  # Обновляем табло координат после изменения позиции
        self.update_image()

# Пример использования
InfiniteNoiseImage()

Это похоже на металлическую обшивку космического корабля.

Код гитхаб.

[MakarovDs]

Теперь я сделал онлайн версию -> Зацените.
https://codepen.io/HoytII/pen/vEYyqgj

[MakarovDs]

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

Вот что получилось -> спиритрон бесконечная библиотека бэкрумс.

Ещё давно сделал такую версию есть там на python приложение.

Ссылка гитхаб -> ссылка.

[MakarovDs]

теперь мне нужно что-бы сначала шли изображения перестановок всех цветов RGB без повторений, а потом изображения RGB с дубликатами ЧТО-БЫ ЭТО БЫЛО ПО ПОРЯДКУ, и получатся всевозможные вариации создания всевозможных изображений.

Вот что у меня получилось -> Онлайн версия.

[MakarovDs]

Версия приложения на python:

import numpy as np
from itertools import product
import tkinter as tk
from PIL import Image, ImageTk
import threading
import random
import time

# Инициализация переменных
x, y = 0, 0
seed = 0
auto_random_running = False
auto_random_thread = None
auto_random_delay = 1

def generate_rgb_colors():
    """Генерация всех уникальных цветов RGB."""
    return list(product(range(256), repeat=3))

def generate_video_frame(colors, index, width=640, height=480):
    """Генерация одного кадра на основе текущего индекса."""
    frame = np.zeros((height, width, 3), dtype=np.uint8)
    
    for j in range(height):  # Итерируем по строкам (Y)
        for i in range(width):  # Итерируем по столбцам (X)
            # Используем перестановки с повторениями для X (цвет по индексу)
            rgb_index = (j * width + i + index + x) % len(colors)  
            frame[j, i] = np.array(colors[rgb_index])
    
    return frame

def update_frame():
    """Обновление кадра на canvas."""
    global current_index
    if canvas:
        frame = generate_video_frame(rgb_colors, current_index)
        frame_image = Image.fromarray(frame)
        frame_image = ImageTk.PhotoImage(frame_image)

        canvas.delete('all')
        canvas.create_image(0, 0, anchor=tk.NW, image=frame_image)
        canvas.image = frame_image

def auto_update_frames():
    """Автообновление кадров."""
    global current_index
    while auto_random_running:
        update_frame()
        current_index += 1
        time.sleep(0.01)

def display_canvas():
    """Создание окна с холстом."""
    global video_window, canvas
    video_window = tk.Toplevel()
    video_window.title("Infinite Image Map")

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

    update_frame()  # Первый кадр
    threading.Thread(target=auto_update_frames, daemon=True).start()  # Начало обновления кадров

def update_coordinates_display():
    """Обновление отображаемых координат."""
    coordinates_label.config(text=f"Координаты - X: {x}, Y: {y}, Seed: {seed}")

def move_coordinates():
    """Обновление координат X и Y пользователем."""
    global x, y
    try:
        new_x = int(x_entry.get())  # Получаем новое значение для X
        new_y = int(y_entry.get())  # Получаем новое значение для Y
        x = new_x
        y = new_y
        update_coordinates_display()  # Обновляем отображение координат
        update_frame()  # Обновляем изображение при изменении координат
    except ValueError:
        x_entry.delete(0, tk.END)
        y_entry.delete(0, tk.END)

def set_seed():
    """Установка сид для генерации случайных чисел."""
    global seed
    try:
        seed = int(seed_entry.get())
        random.seed(seed)  # Устанавливаем сид генератора случайных чисел
        update_frame()  # Обновляем кадр после изменения сида
        update_coordinates_display()
    except ValueError:
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, str(seed))

def validate_seed_input(event):
    """Проверка ввода сида."""
    current_value = seed_entry.get()
    if not current_value.isdigit():
        seed_entry.delete(0, tk.END)
        seed_entry.insert(0, ''.join(filter(str.isdigit, current_value)))

def toggle_auto_random():
    """Запуск или остановка авторандома."""
    global auto_random_running, auto_random_thread
    if auto_random_running:
        auto_random_running = False
        if auto_random_thread is not None:
            auto_random_thread.join()
        auto_random_button.config(text="Запустить авторандом")
    else:
        auto_random_running = True
        auto_random_button.config(text="Остановить авторандом")
        auto_random_thread = threading.Thread(target=auto_random_coordinates)
        auto_random_thread.start()

def auto_random_coordinates():
    """Случайное изменение координат."""
    global x, y
    while auto_random_running:
        x = random.randint(0, 255)   # Ограничение до 255 для отображения цветов
        y = random.randint(0, 255)
        update_coordinates_display() 
        update_frame()  # Обновляем изображение при случайной генерации координат
        time.sleep(auto_random_delay)

def set_auto_random_delay():
    """Установка задержки для авторандома."""
    global auto_random_delay
    try:
        delay = float(auto_random_delay_entry.get())
        if delay > 0:
            auto_random_delay = delay
    except ValueError:
        auto_random_delay_entry.delete(0, tk.END)
        auto_random_delay_entry.insert(0, str(auto_random_delay))

# Генерация всех возможных комбинаций RGB
rgb_colors = generate_rgb_colors()
current_index = 0  # Индекс для отслеживания текущего кадра

# Создание основного окна интерфейса
root = tk.Tk()
root.title("Infinite Image Map")
root.geometry("320x400")

start_button = tk.Button(root, text="Показать Карту", command=display_canvas)
start_button.pack()

coordinates_label = tk.Label(root, text=f"Координаты - X: {x}, Y: {y}, Seed: {seed}")
coordinates_label.pack()

x_entry = tk.Entry(root, width=10)
x_entry.pack()
x_entry.insert(0, str(x))  # Ввод X по умолчанию

y_entry = tk.Entry(root, width=10)
y_entry.pack()
y_entry.insert(0, str(y))  # Ввод Y по умолчанию

# Кнопка для установки координат
set_coordinates_button = tk.Button(root, text="Установить координаты", command=move_coordinates)
set_coordinates_button.pack()

seed_entry = tk.Entry(root)
seed_entry.pack()
seed_entry.insert(0, str(seed))  # Ввод сида по умолчанию
seed_entry.bind('<KeyRelease>', validate_seed_input)  # Проверка ввода сида

set_seed_button = tk.Button(root, text="Установить сид", command=set_seed)
set_seed_button.pack()

auto_random_delay_entry = tk.Entry(root)
auto_random_delay_entry.pack()
auto_random_delay_entry.insert(0, str(auto_random_delay))  # Ввод задержки по умолчанию

set_delay_button = tk.Button(root, text="Установить задержку", command=set_auto_random_delay)
set_delay_button.pack()

auto_random_button = tk.Button(root, text="Запустить авторандом", command=toggle_auto_random)
auto_random_button.pack()

root.mainloop()

ГОВНО ЭТО ООП ЕБучае никому нахер ненужные классы который лишь нагромождают программу, и делают её зависание, и неработающей...

Код гитхаб.

[MakarovDs]

Итак я сделал конвертер ЭГФ Хоруса из 26 комментария вы можете скачать моё приложение на ПК -> вот ссылка.

Если кому нужны ответы с того света вы можете пообщаться.

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