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

[MakarovDs]

И это вторая версия выбиратора случайных изображений

import os
import random
import time
import threading
import numpy as np
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageShuffler:
    def __init__(self, root):
        self.root = root
        self.root.title("Выбиратор случайных изображений")
        self.root.geometry("820x920")  # Размер для сетки

        # Поле для выбора папки
        self.select_folder_button = tk.Button(root, text="Выбрать папку", command=self.select_folder)
        self.select_folder_button.pack(pady=5)

        # Поле для настройки скорости
        self.speed_label = tk.Label(root, text="Скорость (сек):")
        self.speed_label.pack()
        self.speed_var = tk.DoubleVar(value=1.0)
        self.speed_entry = tk.Entry(root, textvariable=self.speed_var, width=5)
        self.speed_entry.pack()

        # Поле для количества изображений в ряду
        self.count_label = tk.Label(root, text="Количество изображений в ряду:")
        self.count_label.pack()
        self.count_var = tk.IntVar(value=5)
        self.count_entry = tk.Entry(root, textvariable=self.count_var, width=5)
        self.count_entry.pack()

        # Поле для количества рядов
        self.rows_label = tk.Label(root, text="Количество рядов:")
        self.rows_label.pack()
        self.rows_var = tk.IntVar(value=3)
        self.rows_entry = tk.Entry(root, textvariable=self.rows_var, width=5)
        self.rows_entry.pack()

        # Область для отображения изображений
        self.canvas = tk.Canvas(root, width=800, height=600, bg='white')
        self.canvas.pack(pady=10)

        # Кнопки "Запуск" и "Стоп"
        self.control_frame = tk.Frame(root)
        self.control_frame.pack(pady=5)

        self.start_button = tk.Button(self.control_frame, text="Запуск", command=self.start_shuffling)
        self.start_button.pack(side='left', padx=5)

        self.stop_button = tk.Button(self.control_frame, text="Стоп", command=self.stop_shuffling)
        self.stop_button.pack(side='left', padx=5)

        self.images = []
        self.thread = None
        self.running = False

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

    def display_images(self, images):
        """Отображает изображения в виде сетки на канвасе, распределяя по рядам."""
        self.canvas.delete("all")
        width, height = 100, 100  # Размер каждого изображения
        spacing = 2  # Расстояние между изображениями

        count_rows = self.rows_var.get()
        total_images = len(images)
        images_per_row = total_images // count_rows
        remainder = total_images % count_rows

        index = 0
        self.canvas.images = []  # Обнуляем список ссылок
        for row in range(count_rows):
            count_in_this_row = images_per_row + (1 if row < remainder else 0)
            for col in range(count_in_this_row):
                if index >= total_images:
                    break
                img = images[index]
                if img is not None:
                    pil_img = Image.fromarray(img)
                    pil_img = pil_img.resize((width, height))
                    img_tk = ImageTk.PhotoImage(pil_img)
                    x = col * (width + spacing)
                    y = row * (height + spacing)
                    self.canvas.create_image(x, y, anchor='nw', image=img_tk)
                    self.canvas.images.append(img_tk)
                index += 1

    def shuffle_display_images(self, images):
        """Обновляет изображения в виде сетки с заданной скоростью."""
        self.running = True
        while self.running:
            total_images = self.count_var.get() * self.rows_var.get()
            selected_images = []
            for _ in range(total_images):
                img_path = random.choice(images)
                image = self.load_image(img_path)
                selected_images.append(image)
            self.display_images(selected_images)
            time.sleep(self.speed_var.get())

    def start_shuffling(self):
        """Запускает поток ретрансляции изображений."""
        if self.thread and self.thread.is_alive():
            self.running = False
            self.thread.join()
        if self.images:
            self.thread = threading.Thread(target=self.shuffle_display_images, args=(self.images,), daemon=True)
            self.thread.start()

    def stop_shuffling(self):
        """Останавливает поток ретрансляции изображений."""
        self.running = False
        if self.thread and self.thread.is_alive():
            self.thread.join()

    def select_folder(self):
        """Выбор папки и автоматический запуск ретрансляции."""
        folder_path = filedialog.askdirectory(title="Выберите папку")
        if folder_path:
            self.images = [os.path.join(folder_path, f) for f in os.listdir(folder_path)
                           if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif'))]
            if self.images:
                self.start_shuffling()
            else:
                print("В выбранной папке нет изображений.")

# Создание интерфейса
root = tk.Tk()
app = ImageShuffler(root)

# Запуск интерфейса
root.mainloop()

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



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

[MakarovDs]

Хотел сделать мгновенный режим но больше нет желания ебаться с этим говном выбиратора.. Да, и нет у меня такой цели...

import os
import random
import threading
import time
import numpy as np
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageDisplayWindow(tk.Toplevel):
    def __init__(self, master):
        super().__init__(master)
        self.title("Облако изображений")
        self.canvas = tk.Canvas(self, width=800, height=600, bg='white')
        self.canvas.pack()
        self.images_tk = []

    def show_images(self, images, rows):
        self.canvas.delete("all")
        width, height = 100, 100
        spacing = 2
        total_images = len(images)
        images_per_row = total_images // rows
        remainder = total_images % rows
        index = 0
        self.images_tk.clear()
        for row in range(rows):
            count_in_row = images_per_row + (1 if row < remainder else 0)
            for col in range(count_in_row):
                if index >= total_images:
                    break
                img = images[index]
                if img is not None:
                    pil_img = Image.fromarray(img)
                    pil_img = pil_img.resize((width, height))
                    img_tk = ImageTk.PhotoImage(pil_img)
                    x = col * (width + spacing)
                    y = row * (height + spacing)
                    self.canvas.create_image(x, y, anchor='nw', image=img_tk)
                    self.images_tk.append(img_tk)
                index += 1

class ImageShuffler:
    def __init__(self, root):
        self.root = root
        self.root.title("Управление изображениями")
        self.images = []
        self.display_window = None
        self.thread = None
        self.running = False
        self.auto_mode = False  # флаг для автоматического режима

        # Управление
        tk.Button(root, text="Выбрать папку", command=self.select_folder).pack(pady=5)

        self.speed_var = tk.StringVar(value="1.0")
        tk.Label(root, text="Скорость (сек):").pack()
        tk.Entry(root, textvariable=self.speed_var, width=5).pack()

        tk.Label(root, text="Количество изображений в ряду:").pack()
        self.count_var = tk.IntVar(value=5)
        tk.Entry(root, textvariable=self.count_var, width=5).pack()

        tk.Label(root, text="Количество рядов:").pack()
        self.rows_var = tk.IntVar(value=3)
        tk.Entry(root, textvariable=self.rows_var, width=5).pack()

        # Режимы
        self.mode_frame = tk.Frame(root)
        self.mode_frame.pack(pady=5)
        self.mode_var = tk.StringVar(value="instant")
        tk.Radiobutton(self.mode_frame, text="Мгновенно", variable=self.mode_var, value="instant").pack(side='left', padx=5)
        tk.Radiobutton(self.mode_frame, text="Поочередно", variable=self.mode_var, value="sequential").pack(side='left', padx=5)

        # Кнопки
        control_frame = tk.Frame(root)
        control_frame.pack(pady=5)
        tk.Button(control_frame, text="Запуск", command=self.start).pack(side='left', padx=5)
        tk.Button(control_frame, text="Стоп", command=self.stop).pack(side='left', padx=5)
        tk.Button(control_frame, text="Открыть окно изображений", command=self.open_display_window).pack(side='left', padx=5)

    def select_folder(self):
        folder = filedialog.askdirectory(title="Выберите папку")
        if folder:
            self.images = [os.path.join(folder, f) for f in os.listdir(folder)
                           if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif'))]
            if self.images:
                self.start()

    def open_display_window(self):
        if self.display_window is None or not self.display_window.winfo_exists():
            self.display_window = ImageDisplayWindow(self.root)

    def load_image(self, path):
        try:
            img = Image.open(path)
            img = img.convert("RGB")
            return np.array(img)
        except:
            return None

    def update_images(self, images):
        if self.display_window and self.display_window.winfo_exists():
            rows = self.rows_var.get()
            self.display_window.show_images(images, rows)

    def run_instant_mode(self):
        total = self.count_var.get() * self.rows_var.get()
        imgs = []
        for _ in range(total):
            path = random.choice(self.images)
            img = self.load_image(path)
            imgs.append(img)
        self.update_images(imgs)

    def run_sequential_mode(self):
        self.running = True
        while self.running:
            total = self.count_var.get() * self.rows_var.get()
            imgs = []
            for _ in range(total):
                path = random.choice(self.images)
                img = self.load_image(path)
                imgs.append(img)
            self.update_images(imgs)
            try:
                speed = float(self.speed_var.get())
                if speed <= 0:
                    speed = 0.1
            except:
                speed = 1.0
            time.sleep(speed)

    def auto_instant_mode(self):
        """Автоматически обновлять изображения через интервал."""
        self.auto_mode = True
        while self.auto_mode:
            self.run_instant_mode()
            try:
                speed = float(self.speed_var.get())
                if speed <= 0:
                    speed = 0.1
            except:
                speed = 1.0
            time.sleep(speed)

    def start(self):
        self.stop()
        if not self.images:
            return
        mode = self.mode_var.get()
        if mode == "instant":
            # Запускаем автоматический цикл
            self.auto_mode = True
            self.thread = threading.Thread(target=self.auto_instant_mode, daemon=True)
            self.thread.start()
        else:
            # Запускаем поочередное обновление
            self.thread = threading.Thread(target=self.run_sequential_mode, daemon=True)
            self.thread.start()

    def stop(self):
        self.auto_mode = False
        self.running = False
        if hasattr(self, 'thread') and self.thread and self.thread.is_alive():
            self.thread.join()

def change_mode(self):
    # при смене режима, если выбран "Мгновенно", автоматически запускать цикл
    if self.mode_var.get() == "instant":
        self.start()
    else:
        self.stop()

# Создаем окно
root = tk.Tk()
app = ImageShuffler(root)
root.mainloop()

Может есть у кого какие идеи как решить эту проблему...

[MakarovDs]

Седьмая версия ЭГФ Хоруса - Просто лютейшая бомба от Gemeni ! Такого ЭГФ я ещё не встречал!

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, 'wb') as text_file:  # Changed 'w' to 'wb'
            text_file.write(shuffled_byte_data)  # Write bytes directly
        print(f"Байты видео сохранены в: {text_file_path}")


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


def convert_video_to_ef():
    """Комбинированная функция: видео -> байты -> видео"""
    file_path = filedialog.askopenfilename(title="Выберите видео файл для преобразования в ЭГФ")
    if file_path:
        # Шаг 1: Видео в байты
        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)
        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]

        # Объединяем
        byte_list[:data_to_shuffle_start] = byte_list[:data_to_shuffle_start]
        byte_list[data_to_shuffle_start:data_to_shuffle_end] = to_shuffle
        shuffled_byte_data = bytes(byte_list)

        # Шаг 2: байты обратно в видео
        output_path = os.path.join(os.path.expanduser("~"), "Desktop", "evp_video.mp4")
        with open(output_path, 'wb') as f:
            f.write(shuffled_byte_data)
        print(f"Видео в формате ЭГФ сохранено: {output_path}")


def bytes_to_binary_string(byte_data):
    """Преобразует байты в строку из 0 и 1."""
    binary_string = ''.join(format(byte, '08b') for byte in byte_data)
    return binary_string

def binary_string_to_bytes(binary_string):
    """Преобразует строку из 0 и 1 обратно в байты."""
    byte_list = []
    for i in range(0, len(binary_string), 8):
        byte_string = binary_string[i:i+8]
        byte = int(byte_string, 2)
        byte_list.append(byte)
    return bytes(byte_list)


def convert_bytes_to_binary_file():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с байтами")
    if file_path:
        try:
            with open(file_path, 'rb') as byte_file: # Read the file as bytes
                byte_data = byte_file.read()
            binary_string = bytes_to_binary_string(byte_data)
            output_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_binary.txt")
            with open(output_path, 'w') as binary_file:
                binary_file.write(binary_string)
            print(f"Двоичный код сохранен в: {output_path}")
        except Exception as e:
            print(f"Ошибка при преобразовании в двоичный код: {e}")


def convert_binary_file_to_bytes():
    file_path = filedialog.askopenfilename(title="Выберите текстовый файл с двоичным кодом")
    if file_path:
        try:
            with open(file_path, 'r') as binary_file:
                binary_string = binary_file.read()
            byte_data = binary_string_to_bytes(binary_string)
            output_path = os.path.join(os.path.expanduser("~"), "Desktop", "video_bytes_restored.txt")
            with open(output_path, 'wb') as byte_file: # Write the bytes back
                byte_file.write(byte_data)
            print(f"Байты восстановлены и сохранены в: {output_path}")
        except Exception as e:
            print(f"Ошибка при восстановлении байтов: {e}")



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

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

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

convert_to_ef_button = tk.Button(root, text="Превратить видео в ЭГФ", command=convert_video_to_ef)
convert_to_ef_button.pack(pady=5)

# Новые кнопки для преобразования в двоичный код и обратно
bytes_to_binary_button = tk.Button(root, text="Текст байтов в 0 и 1", command=convert_bytes_to_binary_file)
bytes_to_binary_button.pack(pady=5)

binary_to_bytes_button = tk.Button(root, text="Текст 0 и 1 в текст байтов", command=convert_binary_file_to_bytes)
binary_to_bytes_button.pack(pady=5)


# Запуск интерфейса
root.mainloop()

Код Github там же и пример.