Where is the continuity? I made this code a long time ago, but I rarely use it, because it doesn’t give continuity. The fundamental problem is that each DALL-E image is generated independently, without visual “memory”.
For example, I have a cake recipe. And I gave it a prompt there: everything takes place in a single kitchen, with the same chef, with the same design, with the same tools, etc.
The big problem is that when the images are generated, they are created without connection. For example, in one picture the kitchen looks one way, in another picture, it’s another kitchen. Or, in one picture a male chef appears, in another picture another chef appears or even a female chef. So the code generates different images, without continuity. If you put a 45-year-old male chef in all the pictures, it has to be exactly the same man. If you put a kitchen, absolutely everything in the kitchen has to look the same in every picture.
Please see my code:
import openai
import time
import numpy as np
from tqdm import tqdm
import os
from datetime import datetime
from pydub import AudioSegment
from moviepy.editor import *
from PIL import Image
import cv2
from pathlib import Path
import requests
import re
import json
import base64
# Set up configurations
openai.api_key = 'YOUR-API-KEY' # ÎNLOCUIEȘTE CU API KEY-UL TĂU VALID
VIDEO_RESOLUTION = (1920, 1080)
VIDEO_FPS = 30
# Configurare FFmpeg și ImageMagick
os.environ["PATH"] += os.pathsep + r"D:\ffmpeg-master-latest-win64-gpl-shared\bin"
os.environ['IMAGEMAGICK_BINARY'] = r"d:\Program Files\ImageMagick-7.1.1-Q16-HDRI\magick.exe"
# Configurare explicită pentru pydub
AudioSegment.converter = r"D:\ffmpeg-master-latest-win64-gpl-shared\bin\ffmpeg.exe"
AudioSegment.ffmpeg = r"D:\ffmpeg-master-latest-win64-gpl-shared\bin\ffmpeg.exe"
AudioSegment.ffprobe = r"D:\ffmpeg-master-latest-win64-gpl-shared\bin\ffprobe.exe"
# Configurare pentru MoviePy
from moviepy.config import change_settings
change_settings({"IMAGEMAGICK_BINARY": r"d:\Program Files\ImageMagick-7.1.1-Q16-HDRI\magick.exe"})
class VisualConsistencyManager:
def __init__(self):
self.master_description = None
self.consistency_template = ""
self.master_image_path = None
def encode_image_to_base64(self, image_path):
"""Convertește imaginea în base64 pentru GPT-4 Vision"""
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode('utf-8')
def analyze_master_image(self, image_path):
"""Analizează prima imagine pentru a extrage toate detaliile vizuale"""
print("🔍 Analizez imaginea master pentru consistență...")
try:
# Encodează imaginea
base64_image = self.encode_image_to_base64(image_path)
analysis_prompt = """
Analizează această imagine foarte detaliat pentru a putea recrea exact aceleași elemente vizuale în imagini viitoare.
Descrie FOARTE DETALIAT:
1. PERSONAJE (dacă există):
- Sex, vârstă aproximativă, culoarea părului, stilul părului
- Culoarea ochilor, forma feței, înălțimea aproximativă
- Îmbrăcămintea exactă (culori, stil, texturi)
- Poziția corpului, gesturile
2. LOCAȚIA/DECORUL:
- Tipul de cameră/spațiu exact
- Materialele suprafețelor (marmură, lemn, metal, etc.)
- Culorile dominante ale pereților, mobilierii
- Obiectele de fundal vizibile
- Arhitectura și stilul
3. ILUMINAREA:
- Tipul de lumină (naturală/artificială)
- Direcția luminii
- Intensitatea și temperatura culorii
- Umbrele și reflexii
4. STILUL VIZUAL:
- Tipul de fotografie (profesională, casual, artistică)
- Calitatea imaginii (HD, cinematografic, etc.)
- Filtre sau efecte vizuale
- Perspectiva camerei (unghi, distanță)
5. PALETA DE CULORI:
- Culorile dominante exacte
- Culorile secundare
- Saturația și luminozitatea
Răspunde cu o descriere EXTREM DE DETALIATĂ care să permită recrearea exactă a acestor elemente în imagini viitoare.
"""
response = openai.chat.completions.create(
model="gpt-4-vision-preview",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": analysis_prompt},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{base64_image}",
"detail": "high"
}
}
]
}
],
max_tokens=1000,
temperature=0.1
)
self.master_description = response.choices[0].message.content
# Creează template-ul de consistență
self.create_consistency_template()
# Salvează analiza
with open('master_image_analysis.json', 'w', encoding='utf-8') as f:
json.dump({
'master_image_path': image_path,
'detailed_description': self.master_description,
'consistency_template': self.consistency_template,
'timestamp': datetime.now().isoformat()
}, f, indent=2, ensure_ascii=False)
print("✅ Analiză master completă - template de consistență creat!")
print(f"💾 Salvat în master_image_analysis.json")
return True
except Exception as e:
print(f"❌ Eroare la analiza imaginii master: {e}")
return False
def create_consistency_template(self):
"""Creează template-ul de consistență bazat pe analiza master"""
template_prompt = f"""
Bazându-te pe această descriere detaliată a imaginii master:
{self.master_description}
Creează un template concis (maxim 300 caractere) pentru DALL-E care să mențină consistența vizuală EXACTĂ.
Template-ul trebuie să includă:
- Personajele exacte (dacă există)
- Locația exactă
- Iluminarea exactă
- Stilul vizual exact
- Paleta de culori exactă
Răspunde DOAR cu template-ul, fără explicații suplimentare.
"""
try:
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "Creezi template-uri de consistență foarte precise pentru DALL-E."},
{"role": "user", "content": template_prompt}
],
temperature=0.1,
max_tokens=200
)
self.consistency_template = response.choices[0].message.content.strip()
print(f"🎨 Template de consistență: {self.consistency_template}")
except Exception as e:
print(f"⚠️ Eroare la crearea template-ului: {e}")
self.consistency_template = "Păstrează exact același stil vizual, personaje, locație și iluminare ca în imaginea anterioară."
class ContentProcessor:
def __init__(self, consistency_manager):
self.image_folder = "generated_images"
self.consistency_manager = consistency_manager
self.is_first_image = True
os.makedirs(self.image_folder, exist_ok=True)
def split_into_sentences(self, text):
"""Split text into meaningful sentences"""
text = text.strip()
sentences = [s.strip() for s in text.split('.') if s.strip()]
return sentences
def get_image_path(self, index):
"""Get the expected image path for an index"""
return os.path.join(self.image_folder, f"{index+1:02d}_generated.png")
def create_first_image_prompt(self, text, first_sentence):
"""Creează prompt-ul pentru prima imagine care va deveni master"""
setup_prompt = f"""
Analizează acest text complet pentru a crea o scenă master care să servească ca bază pentru toate imaginile următoare:
TEXTUL COMPLET: {text}
PRIMA PROPOZIȚIE: {first_sentence}
Creează un prompt DALL-E pentru PRIMA imagine care să:
1. Stabilească o locație specifică și detaliată
2. Definească personajele exacte (dacă există)
3. Seteze iluminarea și atmosfera
4. Creeze un stil vizual consistent
5. Focalizeze pe prima acțiune din text
FOARTE IMPORTANT: Această imagine va fi template-ul pentru TOATE imaginile următoare, deci trebuie să fie foarte specifică și detaliată pentru a permite replicarea exactă.
Răspunde cu un prompt detaliat pentru DALL-E (maxim 400 caractere).
"""
try:
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "Creezi prompt-uri master pentru DALL-E care stabilesc template-uri vizuale consistente."},
{"role": "user", "content": setup_prompt}
],
temperature=0.2,
max_tokens=200
)
master_prompt = response.choices[0].message.content.strip()
print(f"🎯 Prompt master creat: {master_prompt}")
return master_prompt
except Exception as e:
print(f"⚠️ Eroare la crearea prompt-ului master: {e}")
return f"Creează o scenă detaliată pentru: {first_sentence}. Stil fotorealistic, iluminare naturală, detalii precise."
def create_consistent_prompt(self, sentence):
"""Creează prompt consistent bazat pe template-ul master"""
if not self.consistency_manager.consistency_template:
return f"Creează o imagine pentru: {sentence}"
action_prompt = f"""
Folosind EXACT acest template vizual:
{self.consistency_manager.consistency_template}
Creează o imagine care păstrează IDENTIC toate elementele vizuale (personaje, locație, iluminare, stil) dar focalizează pe această acțiune specifică:
"{sentence}"
CRUCIAL: Menține absolut IDENTICE:
- Aceleași personaje exact (dacă există)
- Aceeași locație exact
- Aceeași iluminare exact
- Același stil vizual exact
Schimbă DOAR focusul pe acțiunea din propoziție.
Răspunde cu un prompt concis pentru DALL-E (maxim 350 caractere).
"""
try:
response = openai.chat.completions.create(
model="gpt-4",
messages=[
{"role": "system", "content": "Creezi prompt-uri DALL-E care mențin consistența vizuală perfectă cu template-ul master."},
{"role": "user", "content": action_prompt}
],
temperature=0.1,
max_tokens=150
)
consistent_prompt = response.choices[0].message.content.strip()
print(f" 🎨 Prompt consistent: {consistent_prompt[:80]}...")
return consistent_prompt
except Exception as e:
print(f" ⚠️ Eroare la crearea prompt-ului consistent: {e}")
return f"{self.consistency_manager.consistency_template}. Focalizat pe: {sentence}"
def generate_image(self, sentence, index, total_sentences, full_text):
"""Generate an image using DALL-E"""
image_path = self.get_image_path(index)
# Check if image already exists
if os.path.exists(image_path):
print(f"\n✓ Imaginea {index + 1} există deja: {image_path}")
# Dacă e prima imagine și nu avem template, analizează-o
if self.is_first_image and not self.consistency_manager.master_description:
print("🔍 Analizez prima imagine existentă...")
if self.consistency_manager.analyze_master_image(image_path):
self.consistency_manager.master_image_path = image_path
self.is_first_image = False
return image_path
try:
print(f"\n🎨 Generez imaginea {index + 1}/{total_sentences}")
print(f" 📝 Propoziție: {sentence[:80]}...")
# Creează prompt-ul potrivit
if self.is_first_image:
# Prima imagine - creează master template
prompt = self.create_first_image_prompt(full_text, sentence)
print(" 🎯 PRIMA IMAGINE - Stabilesc template master")
else:
# Imaginile următoare - folosesc template-ul consistent
prompt = self.create_consistent_prompt(sentence)
print(" 🔄 Folosesc template de consistență")
# Generează imaginea
response = openai.images.generate(
model="dall-e-3",
prompt=prompt,
size="1024x1024",
quality="hd",
n=1,
)
image_url = response.data[0].url
response = requests.get(image_url)
with open(image_path, 'wb') as f:
f.write(response.content)
print(f" ✅ Imagine generată: {image_path}")
# Dacă e prima imagine, analizează-o pentru template
if self.is_first_image:
print("🔍 Analizez prima imagine pentru a crea template-ul...")
time.sleep(3) # Așteaptă să se salveze complet
if self.consistency_manager.analyze_master_image(image_path):
self.consistency_manager.master_image_path = image_path
print("✅ Template master creat cu succes!")
else:
print("⚠️ Nu s-a putut crea template-ul master")
self.is_first_image = False
# Pauză pentru rate limiting
time.sleep(3)
return image_path
except Exception as e:
print(f" ❌ Eroare la generarea imaginii: {str(e)}")
return None
def generate_audio(self, sentence, index):
"""Generate audio for a sentence using OpenAI TTS"""
output_file = f"audio_{index+1:02d}.mp3"
if os.path.exists(output_file):
print(f"✓ Audio {index + 1} există deja: {output_file}")
audio = AudioSegment.from_mp3(output_file)
duration = len(audio) / 1000.0
return output_file, duration
try:
response = openai.audio.speech.create(
model="tts-1-hd",
voice="nova",
input=sentence,
speed=0.9
)
response.stream_to_file(output_file)
audio = AudioSegment.from_mp3(output_file)
duration = len(audio) / 1000.0
print(f"✓ Audio generat: {output_file} ({duration:.1f}s)")
return output_file, duration
except Exception as e:
print(f"❌ Eroare la generarea audio: {str(e)}")
return None, 0
class VideoCreator:
def __init__(self, resolution=VIDEO_RESOLUTION, fps=VIDEO_FPS):
self.resolution = resolution
self.fps = fps
self.end_pause = 3
def create_text_clip(self, text, duration):
"""Create text clip with improved styling"""
txt_clip = TextClip(
text,
fontsize=48,
color='white',
size=(self.resolution[0]-160, None),
method='caption',
font='Arial-Bold',
stroke_color='black',
stroke_width=2,
align='center'
)
txt_clip = txt_clip.set_position(('center', 0.82), relative=True)
txt_clip = txt_clip.set_duration(duration)
txt_clip = txt_clip.crossfadein(0.8).crossfadeout(0.8)
return txt_clip
def create_video_segment(self, image_path, text, duration, is_last=False):
"""Create a video segment with image and text"""
img = Image.open(image_path)
if img.mode != 'RGB':
img = img.convert('RGB')
img_clip = ImageClip(np.array(img))
# Scale to fit
aspect_ratio = img_clip.w / img_clip.h
if aspect_ratio > self.resolution[0] / self.resolution[1]:
new_height = self.resolution[1]
new_width = int(new_height * aspect_ratio)
else:
new_width = self.resolution[0]
new_height = int(new_width / aspect_ratio)
img_clip = img_clip.resize((new_width, new_height))
# Crop to target resolution
x_center = new_width / 2
y_center = new_height / 2
x1 = int(x_center - self.resolution[0] / 2)
y1 = int(y_center - self.resolution[1] / 2)
img_clip = img_clip.crop(x1=x1, y1=y1,
x2=x1+self.resolution[0],
y2=y1+self.resolution[1])
final_duration = duration + (self.end_pause if is_last else 0)
img_clip = img_clip.set_duration(final_duration)
img_clip = img_clip.crossfadein(0.8).crossfadeout(0.8)
txt_clip = self.create_text_clip(text, final_duration)
return CompositeVideoClip([img_clip, txt_clip])
def create_final_video(self, segments):
"""Create the final video from all segments"""
clips = []
current_time = 0
for i, segment in enumerate(segments):
is_last = (i == len(segments) - 1)
clip = self.create_video_segment(
segment['image'],
segment['text'],
segment['duration'],
is_last=is_last
)
clip = clip.set_start(current_time)
clips.append(clip)
current_time += segment['duration'] + (self.end_pause if is_last else 0)
final = concatenate_videoclips(clips)
audio_clips = [AudioFileClip(segment['audio']) for segment in segments]
final_audio = concatenate_audioclips(audio_clips)
final = final.set_audio(final_audio)
output_file = f"final_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
print(f"\n🎬 Creez videoul final: {output_file}")
final.write_videofile(
output_file,
fps=self.fps,
codec='libx264',
audio_codec='aac',
threads=6,
preset='medium',
bitrate="12000k"
)
return output_file
def main():
# Text input - SCHIMBĂ DOAR TEXTUL DE AICI! ⬇️⬇️⬇️
text = """
Pentru acest deliciu culinar și vizual, ai nevoie de:
✓ 4 ouă
✓ 300 de grame de fulgi de cocos
✓ 400 de grame de iaurt grecesc 10%
✓ Merișoare
✓ Sos de curmale
✓ Semințe de floarea-soarelui
Cum se prepara:
1. Am spart ouăle.
2. Am adăugat iaurtul grecesc 10% grăsime.
2. Apoi am adaugat fulgii de cocos.
3. Am amestecat totul cu dragoste si am turnat intr-un vas de Yena, apoi am presărat semințe de floarea soarelui.
4. Am pus tava la cuptor la 180°C, pentru 25-30 de minute, și am lăsat minunea divină sa se manifeste în toată splendoarea ei.
"""
# ⬆️⬆️⬆️ SCHIMBĂ DOAR TEXTUL DE AICI!
print("🚀 GENERATOR VIDEO CU ADEVĂRATĂ CONTINUITATE VIZUALĂ")
print("=" * 70)
print("🎯 Sistem: Prima imagine = Master template pentru toate următoarele")
# Initialize all components
consistency_manager = VisualConsistencyManager()
content_processor = ContentProcessor(consistency_manager)
video_creator = VideoCreator()
# Split text into sentences
sentences = content_processor.split_into_sentences(text)
print(f"\n📝 Găsite {len(sentences)} propoziții pentru procesare")
# Process each sentence
segments = []
for i, sentence in enumerate(sentences):
print(f"\n▶️ Procesez propoziția {i+1} din {len(sentences)}")
# Generate image with true consistency
image_path = content_processor.generate_image(sentence, i, len(sentences), text)
if not image_path:
print(f"⚠️ Sar peste propoziția {i+1} - imagine lipsă")
continue
# Generate audio
audio_path, duration = content_processor.generate_audio(sentence, i)
if not audio_path:
print(f"⚠️ Sar peste propoziția {i+1} - audio lipsă")
continue
segments.append({
'text': sentence,
'image': image_path,
'audio': audio_path,
'duration': duration
})
# Create final video
if segments:
print(f"\n🎬 Creez videoul cu {len(segments)} segmente...")
output_file = video_creator.create_final_video(segments)
print(f"\n🎉 VIDEO CU CONTINUITATE VIZUALĂ PERFECTĂ CREAT!")
print(f"📁 Fișier: {output_file}")
print(f"📊 Segmente: {len(segments)}")
print(f"⏱️ Durată: {sum([s['duration'] for s in segments]):.1f} secunde")
print(f"🎨 Template master salvat în: master_image_analysis.json")
print(f"🔗 Imaginea master: {consistency_manager.master_image_path}")
else:
print("\n❌ Nu s-au putut procesa segmentele!")
if __name__ == "__main__":
main()
