Upload 17 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+modules/x0.png filter=lfs diff=lfs merge=lfs -text

modules/check.py

@@ -0,0 +1,4 @@
+from img_gen import gen_image,decode_img
+
+
+decode_img("extracted_frames/0.png","x.txt")

modules/frame_creator.py

@@ -0,0 +1,70 @@
+from .img_gen import gen_image, decode_img
+import os
+import re
+import logging
+
+
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+import os
+
+def ensure_dir(directory):
+    """
+    Ensures that the specified directory exists. If it does not exist, it creates the directory.
+
+    Args:
+        directory (str): The path to the directory to ensure.
+    """
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+        print(f"Created directory: {directory}")
+    else:
+        print(f"Directory already exists: {directory}")
+
+ensure_dir("./chunks")
+ensure_dir("./images")
+ensure_dir("./extracted_frames")
+ensure_dir("./recovered")
+
+
+def render_frame():
+    # 📁 Ensure the directories exist
+    if not os.path.exists("./chunks"):
+        logging.error("Error: 'chunks' directory does not exist. 🚫")
+        return
+
+    if not os.path.exists("./images"):
+        os.makedirs("./images")
+        logging.info("Created 'images' directory. 📁")
+
+    # List all files in the directory
+    file_list = os.listdir("./chunks")
+    logging.info(f"Found {len(file_list)} files in 'chunks' directory. 📂")
+
+    # Define a sorting key function that extracts the numeric part of the filename
+    def sort_key(filename):
+        match = re.match(r'(\d+)\.bin', filename)
+        if match:
+            return int(match.group(1))
+        return float('inf')  # Ensure non-matching filenames are sorted last
+
+    # Sort the file list using the custom key function
+    file_list.sort(key=sort_key)
+    logging.info("Sorted file list. 🔢")
+
+    index = 0
+    for f in file_list:
+        if f.endswith('.bin'):
+            try:
+                # Construct the full path to the .bin file
+                bin_file_path = os.path.join("./chunks", f)
+                gen_image(bin_file_path, f"images/{index}.png")
+                logging.info(f"Processed file {f} to images/{index}.png 🖼️")
+                index += 1
+            except Exception as e:
+                logging.error(f"Error processing file {f}: {e} ❌")
+        else:
+            logging.warning(f"Skipping non-bin file: {f} 🚫")
+

modules/frame_decoder.py

@@ -0,0 +1,38 @@
+import os
+from .img_gen import decode_img
+
+def recover_binary_files(directory="extracted_frames", recovered_directory="recovered"):
+    """
+    Recover binary files from PNG images in the specified directory.
+
+    Parameters:
+    directory (str): The directory containing the extracted frames.
+    recovered_directory (str): The directory to save the recovered binary files.
+    """
+    # Ensure the recovered directory exists
+    if not os.path.exists(recovered_directory):
+        os.makedirs(recovered_directory)
+
+    # Get a list of all PNG files in the directory
+    png_files = sorted([f for f in os.listdir(directory) if f.endswith('.png')])
+
+    # Initialize a counter
+    counter = 0
+
+    # Iterate through the sorted list of PNG files
+    for png_file in png_files:
+        # Construct the full path to the PNG file
+        png_path = os.path.join(directory, png_file)
+
+        # Construct the output binary file name using the counter
+        bin_file = os.path.join(recovered_directory, f"{counter}.bin")
+
+        # Decode the image
+        decode_img(png_path, bin_file)
+
+        # Increment the counter
+        counter += 1
+
+# Example usage
+if __name__ == "__main__":
+    recover_binary_files()

modules/img_gen.py

@@ -0,0 +1,96 @@
+import numpy as np
+import cv2
+import os
+from tqdm import tqdm
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def decode_img(image_path, output_file_path):
+    """
+    Decode an image using the size header to remove padding.
+    """
+    if not os.path.isfile(image_path):
+        raise FileNotFoundError(f"The image at {image_path} does not exist.")
+
+    img = cv2.imread(image_path)
+    if img is None:
+        raise ValueError(f"Could not read the image at {image_path}.")
+
+    height, width, _ = img.shape
+    binary_str = []
+
+    # Extract binary string from image
+    for y in tqdm(range(height), desc="Decoding image"):
+        for x in range(width):
+            b, g, r = img[y, x]
+            r_bit = '0' if r == 0 else '1'
+            g_bit = '0' if g == 0 else '1'
+            b_bit = '0' if b == 0 else '1'
+            binary_str.extend([r_bit, g_bit, b_bit])
+
+    binary_str = ''.join(binary_str)
+
+    # Split into bytes
+    byte_array = bytearray()
+    for i in range(0, len(binary_str), 8):
+        byte_bits = binary_str[i:i+8]
+        byte = int(byte_bits, 2)
+        byte_array.append(byte)
+
+    # Extract size from the first 4 bytes (header)
+    original_size = int.from_bytes(byte_array[:4], byteorder='big')
+    decoded_data = byte_array[4:4+original_size]  # Truncate to original size
+
+    # Write to file
+    with open(output_file_path, 'wb') as f:
+        f.write(decoded_data)
+
+    logging.info(f"INFO! Decoded data written to {output_file_path}")
+
+def gen_image(file_path, output_path, width=1280, height=720):
+    """
+    Convert a file to a binary string (with size header) and encode it into an image.
+    """
+    if not os.path.isfile(file_path):
+        raise FileNotFoundError(f"The file at {file_path} does not exist.")
+
+    with open(file_path, 'rb') as f:
+        binary_data = f.read()
+
+    # Add 4-byte header containing the original data size (big-endian)
+    original_size = len(binary_data)
+    size_header = original_size.to_bytes(4, byteorder='big')
+    binary_data = size_header + binary_data  # Prepend header to data
+
+    # Convert to binary string
+    binary_str = ''.join(format(byte, '08b') for byte in binary_data)
+
+    # Calculate required length and pad with zeros
+    required_length = width * height * 3
+    if len(binary_str) > required_length:
+        raise ValueError(f"Data too large for image: {len(binary_str)} > {required_length}")
+    binary_str = binary_str.ljust(required_length, '0')
+
+    # Create and populate image
+    image = np.zeros((height, width, 3), dtype=np.uint8)
+    for y in tqdm(range(height), desc="Generating image"):
+        for x in range(width):
+            index = (y * width + x) * 3
+            r = int(binary_str[index], 2) * 255
+            g = int(binary_str[index + 1], 2) * 255
+            b = int(binary_str[index + 2], 2) * 255
+            image[y, x] = [b, g, r]
+
+    cv2.imwrite(output_path, image)
+    logging.info(f"INFO:👍  Image generated and saved to {output_path}")
+
+if __name__ == "__main__":
+    # Example usage
+    input_file = 'x.png'
+    output_image = 'output.png'
+    decoded_file = 'decoded.txt'
+
+    gen_image(input_file, output_image)
+    decode_img(output_image, decoded_file)

modules/merge.py

@@ -0,0 +1,22 @@
+import os
+
+def merge_cunks(chunk_dir, output_file):
+    """Merges files from the 'chunks' directory into the original file."""
+    # Get a list of chunk files
+    chunk_files = sorted([f for f in os.listdir(chunk_dir) if f.endswith('.bin')])
+
+    with open(output_file, 'wb') as output_f:
+        for chunk_file in chunk_files:
+            chunk_path = os.path.join(chunk_dir, chunk_file)
+            with open(chunk_path, 'rb') as chunk_f:
+                output_f.write(chunk_f.read())
+
+    print(f"Merged {len(chunk_files)} chunks into '{output_file}'")
+
+if __name__ == "__main__":
+    chunk_dir = "chunks"  # Directory containing the chunk files
+    output_file = "merged_output.txt"  # Name of the merged output file
+
+    print("Merging chunks...")
+    merge_cunks(chunk_dir, output_file)
+    print(f"Chunks merged into '{output_file}'")

modules/read_files.py

@@ -0,0 +1,25 @@
+
+
+def file_to_binary(filepath):
+    """
+    Reads a file in binary mode and converts its content into a binary (0s and 1s) string.
+    
+    Args:
+        filepath (str): The path to the file.
+    
+    Returns:
+        str: A string representation of the file's binary content.
+    """
+    try:
+        with open(filepath, 'rb') as file:
+            binary_data = file.read()
+            # Convert bytes to binary string
+            binary_string = ''.join(format(byte, '08b') for byte in binary_data)
+        return binary_string
+    except FileNotFoundError:
+        print("Error: File not found.")
+        return None
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+

modules/split.py

@@ -0,0 +1,31 @@
+import os
+
+def split_file(input_file, chunk_size_mb=0.329, output_dir="chunks"):
+    """Splits a file into 2.6MB chunks and saves them in the 'chunks' directory."""
+    chunk_size_bytes = int(chunk_size_mb * 1024 * 1024)  # Convert MB to Bytes
+
+    # Create chunks directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+
+    chunk_files = []
+    with open(input_file, 'rb') as f:
+        chunk_index = 0
+        while True:
+            chunk = f.read(chunk_size_bytes)
+            if not chunk:
+                break
+            chunk_file = os.path.join(output_dir, f'{chunk_index}.bin')
+            with open(chunk_file, 'wb') as chunk_f:
+                chunk_f.write(chunk)
+            chunk_files.append(chunk_file)
+            chunk_index += 1
+
+    return chunk_files
+
+if __name__ == "__main__":
+    input_file = "input.txt"  # Ensure this file exists
+    output_dir = "chunks"
+
+    print("Splitting file...")
+    chunk_files = split_file(input_file, output_dir=output_dir)
+    print(f"File split into {len(chunk_files)} chunks, saved in '{output_dir}/'")

modules/video.py

@@ -0,0 +1,57 @@
+import cv2
+import os
+import hashlib
+import numpy as np
+from moviepy import ImageSequenceClip
+
+def create_video_from_images(image_folder="images", output_video="videos/output_video.mp4", fps=30):
+    """Create MP4 with lossless encoding using MoviePy"""
+    os.makedirs(os.path.dirname(output_video), exist_ok=True)
+    
+    # Get sorted list of images
+    image_files = sorted([os.path.join(image_folder, f) 
+                         for f in os.listdir(image_folder) if f.endswith('.png')],
+                        key=lambda x: int(os.path.basename(x).split('.')[0]))
+
+    # Create video with lossless settings
+    clip = ImageSequenceClip(image_files, fps=fps)
+    
+    # FFmpeg parameters for lossless encoding
+    clip.write_videofile(
+        output_video,
+        codec='libx264rgb',
+        preset='ultrafast',
+        ffmpeg_params=[
+            '-crf', '0',           # Lossless
+            '-color_range', '2',   # Full color range
+            '-pix_fmt', 'bgr24'    # Match OpenCV's BGR format
+        ]
+    )
+
+
+
+
+def extract_frames_from_video(video_path="videos/output_video.mp4", output_folder="extracted_frames"):
+    """Extract frames with OpenCV and hash verification"""
+    os.makedirs(output_folder, exist_ok=True)
+    
+    cap = cv2.VideoCapture(video_path)
+    frame_count = 0
+
+    while True:
+        success, frame = cap.read()
+        if not success:
+            break
+        
+        output_path = os.path.join(output_folder, f"{frame_count}.png")
+        cv2.imwrite(output_path, frame, [cv2.IMWRITE_PNG_COMPRESSION, 0])
+        
+        with open(output_path, 'rb') as f:
+            current_hash = hashlib.sha256(f.read()).hexdigest()
+        print(f"Frame {frame_count:04d} hash: {current_hash}")
+        
+        frame_count += 1
+
+    cap.release()
+
+