342 lines
12 KiB
Python
342 lines
12 KiB
Python
def process_multiline_text(text, font, max_width, max_height):
|
|
"""Process multiline text with automatic wrapping and fitting"""
|
|
try:
|
|
from PIL import ImageFont, ImageDraw, Image
|
|
|
|
print(f"[Text Processor] Processing multiline text with constraints: {max_width}x{max_height}")
|
|
|
|
# Split text into lines
|
|
lines = text.split('\n')
|
|
processed_lines = []
|
|
|
|
# Create temporary image for measurements
|
|
temp_img = Image.new('RGBA', (1, 1))
|
|
draw = ImageDraw.Draw(temp_img)
|
|
|
|
total_height = 0
|
|
|
|
for line in lines:
|
|
if not line.strip():
|
|
# Empty line
|
|
bbox = draw.textbbox((0, 0), "A", font=font)
|
|
line_height = bbox[3] - bbox[1]
|
|
processed_lines.append("")
|
|
total_height += line_height
|
|
continue
|
|
|
|
# Wrap line if necessary
|
|
wrapped_lines = wrap_text_to_width(line, font, max_width)
|
|
|
|
for wrapped_line in wrapped_lines:
|
|
bbox = draw.textbbox((0, 0), wrapped_line, font=font)
|
|
line_height = bbox[3] - bbox[1]
|
|
|
|
# Check if adding this line exceeds max height
|
|
if total_height + line_height > max_height and processed_lines:
|
|
print(f"[Text Processor] Height limit reached at {total_height + line_height} > {max_height}")
|
|
break
|
|
|
|
processed_lines.append(wrapped_line)
|
|
total_height += line_height
|
|
|
|
# Break if height limit reached
|
|
if total_height >= max_height:
|
|
break
|
|
|
|
print(f"[Text Processor] Processed {len(processed_lines)} lines, total height: {total_height}")
|
|
|
|
return {
|
|
'lines': processed_lines,
|
|
'total_height': total_height,
|
|
'line_count': len(processed_lines)
|
|
}
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error processing multiline text: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return {'lines': [text], 'total_height': 0, 'line_count': 1}
|
|
|
|
def wrap_text_to_width(text, font, max_width):
|
|
"""Wrap text to fit within specified width"""
|
|
try:
|
|
from PIL import ImageDraw, Image
|
|
|
|
if not text.strip():
|
|
return [""]
|
|
|
|
# Create temporary image for measurements
|
|
temp_img = Image.new('RGBA', (1, 1))
|
|
draw = ImageDraw.Draw(temp_img)
|
|
|
|
# Check if entire text fits
|
|
bbox = draw.textbbox((0, 0), text, font=font)
|
|
text_width = bbox[2] - bbox[0]
|
|
|
|
if text_width <= max_width:
|
|
return [text]
|
|
|
|
# Split into words and wrap
|
|
words = text.split()
|
|
lines = []
|
|
current_line = ""
|
|
|
|
for word in words:
|
|
test_line = current_line + (" " if current_line else "") + word
|
|
bbox = draw.textbbox((0, 0), test_line, font=font)
|
|
test_width = bbox[2] - bbox[0]
|
|
|
|
if test_width <= max_width:
|
|
current_line = test_line
|
|
else:
|
|
if current_line:
|
|
lines.append(current_line)
|
|
current_line = word
|
|
else:
|
|
# Single word is too long, force wrap
|
|
lines.append(word)
|
|
current_line = ""
|
|
|
|
if current_line:
|
|
lines.append(current_line)
|
|
|
|
return lines
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error wrapping text: {e}")
|
|
return [text]
|
|
|
|
def render_text_with_stroke(draw, position, text, font, fill_color, stroke_color=None, stroke_width=0):
|
|
"""Render text with optional stroke/outline"""
|
|
try:
|
|
x, y = position
|
|
|
|
if stroke_color and stroke_width > 0:
|
|
# Render stroke by drawing text at offset positions
|
|
for dx in range(-stroke_width, stroke_width + 1):
|
|
for dy in range(-stroke_width, stroke_width + 1):
|
|
if dx != 0 or dy != 0:
|
|
draw.text((x + dx, y + dy), text, font=font, fill=stroke_color)
|
|
|
|
# Render main text
|
|
draw.text((x, y), text, font=font, fill=fill_color)
|
|
|
|
print(f"[Text Processor] Rendered text with stroke: width={stroke_width}")
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error rendering text with stroke: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
def calculate_text_metrics(text, font):
|
|
"""Calculate comprehensive text metrics"""
|
|
try:
|
|
from PIL import ImageDraw, Image
|
|
|
|
# Create temporary image for measurements
|
|
temp_img = Image.new('RGBA', (1, 1))
|
|
draw = ImageDraw.Draw(temp_img)
|
|
|
|
# Get bounding box
|
|
bbox = draw.textbbox((0, 0), text, font=font)
|
|
|
|
metrics = {
|
|
'width': bbox[2] - bbox[0],
|
|
'height': bbox[3] - bbox[1],
|
|
'left_bearing': bbox[0],
|
|
'top_bearing': bbox[1],
|
|
'advance_width': bbox[2],
|
|
'advance_height': bbox[3]
|
|
}
|
|
|
|
# Get additional font metrics if available
|
|
try:
|
|
metrics['ascent'] = font.getmetrics()[0]
|
|
metrics['descent'] = font.getmetrics()[1]
|
|
except:
|
|
metrics['ascent'] = metrics['height']
|
|
metrics['descent'] = 0
|
|
|
|
print(f"[Text Processor] Text metrics: {metrics}")
|
|
return metrics
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error calculating text metrics: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return {'width': 0, 'height': 0}
|
|
|
|
def apply_text_effects(img, text_position, text_size, effects):
|
|
"""Apply various text effects like shadow, glow, etc."""
|
|
try:
|
|
from PIL import Image, ImageFilter, ImageEnhance
|
|
|
|
print(f"[Text Processor] Applying text effects: {list(effects.keys())}")
|
|
|
|
result_img = img.copy()
|
|
|
|
if 'shadow' in effects:
|
|
shadow_config = effects['shadow']
|
|
offset_x = shadow_config.get('offset_x', 2)
|
|
offset_y = shadow_config.get('offset_y', 2)
|
|
blur_radius = shadow_config.get('blur', 0)
|
|
shadow_color = shadow_config.get('color', (0, 0, 0, 128))
|
|
|
|
# Create shadow layer
|
|
shadow_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
# Draw shadow text (this would need the actual text rendering logic)
|
|
|
|
if blur_radius > 0:
|
|
shadow_img = shadow_img.filter(ImageFilter.GaussianBlur(radius=blur_radius))
|
|
|
|
# Composite shadow
|
|
result_img = Image.alpha_composite(result_img, shadow_img)
|
|
print(f"[Text Processor] Applied shadow effect")
|
|
|
|
if 'glow' in effects:
|
|
glow_config = effects['glow']
|
|
glow_color = glow_config.get('color', (255, 255, 255, 128))
|
|
glow_radius = glow_config.get('radius', 3)
|
|
|
|
# Create glow effect
|
|
glow_img = Image.new('RGBA', img.size, (0, 0, 0, 0))
|
|
# Apply glow rendering logic here
|
|
|
|
result_img = Image.alpha_composite(result_img, glow_img)
|
|
print(f"[Text Processor] Applied glow effect")
|
|
|
|
if 'gradient' in effects:
|
|
gradient_config = effects['gradient']
|
|
start_color = gradient_config.get('start', (255, 255, 255))
|
|
end_color = gradient_config.get('end', (0, 0, 0))
|
|
direction = gradient_config.get('direction', 'horizontal')
|
|
|
|
# Apply gradient to text
|
|
print(f"[Text Processor] Applied gradient effect")
|
|
|
|
return result_img
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error applying text effects: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return img
|
|
|
|
def optimize_text_layout(text_blocks, canvas_width, canvas_height):
|
|
"""Optimize layout of multiple text blocks to minimize overlap"""
|
|
try:
|
|
print(f"[Text Processor] Optimizing layout for {len(text_blocks)} text blocks")
|
|
|
|
optimized_blocks = []
|
|
|
|
for i, block in enumerate(text_blocks):
|
|
x = block.get('x', 0)
|
|
y = block.get('y', 0)
|
|
width = block.get('width', 0)
|
|
height = block.get('height', 0)
|
|
|
|
# Check for overlaps with previous blocks
|
|
overlap_found = False
|
|
for prev_block in optimized_blocks:
|
|
if rectangles_overlap(
|
|
(x, y, width, height),
|
|
(prev_block['x'], prev_block['y'], prev_block['width'], prev_block['height'])
|
|
):
|
|
overlap_found = True
|
|
break
|
|
|
|
if overlap_found:
|
|
# Find new position
|
|
new_x, new_y = find_non_overlapping_position(
|
|
width, height, optimized_blocks, canvas_width, canvas_height
|
|
)
|
|
x, y = new_x, new_y
|
|
print(f"[Text Processor] Moved block {i} to avoid overlap: ({x}, {y})")
|
|
|
|
optimized_block = block.copy()
|
|
optimized_block.update({'x': x, 'y': y})
|
|
optimized_blocks.append(optimized_block)
|
|
|
|
print(f"[Text Processor] Layout optimization complete")
|
|
return optimized_blocks
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error optimizing text layout: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return text_blocks
|
|
|
|
def rectangles_overlap(rect1, rect2):
|
|
"""Check if two rectangles overlap"""
|
|
x1, y1, w1, h1 = rect1
|
|
x2, y2, w2, h2 = rect2
|
|
|
|
return not (x1 + w1 <= x2 or x2 + w2 <= x1 or y1 + h1 <= y2 or y2 + h2 <= y1)
|
|
|
|
def find_non_overlapping_position(width, height, existing_blocks, canvas_width, canvas_height):
|
|
"""Find a position that doesn't overlap with existing blocks"""
|
|
# Try positions from top-left, moving right then down
|
|
for y in range(0, canvas_height - height, 20):
|
|
for x in range(0, canvas_width - width, 20):
|
|
rect = (x, y, width, height)
|
|
|
|
overlap = False
|
|
for block in existing_blocks:
|
|
if rectangles_overlap(rect, (block['x'], block['y'], block['width'], block['height'])):
|
|
overlap = True
|
|
break
|
|
|
|
if not overlap:
|
|
return x, y
|
|
|
|
# If no position found, return original or default
|
|
return 0, 0
|
|
|
|
def validate_text_rendering(img, text_positions):
|
|
"""Validate that text rendering was successful"""
|
|
try:
|
|
print(f"[Text Processor] Validating text rendering for {len(text_positions)} positions")
|
|
|
|
validation_results = []
|
|
|
|
for i, pos in enumerate(text_positions):
|
|
result = {
|
|
'position_index': i,
|
|
'x': pos.get('x', 0),
|
|
'y': pos.get('y', 0),
|
|
'width': pos.get('width', 0),
|
|
'height': pos.get('height', 0),
|
|
'valid': True,
|
|
'issues': []
|
|
}
|
|
|
|
# Check bounds
|
|
if pos.get('x', 0) < 0 or pos.get('y', 0) < 0:
|
|
result['valid'] = False
|
|
result['issues'].append('Negative position')
|
|
|
|
if pos.get('x', 0) + pos.get('width', 0) > img.width:
|
|
result['valid'] = False
|
|
result['issues'].append('Exceeds image width')
|
|
|
|
if pos.get('y', 0) + pos.get('height', 0) > img.height:
|
|
result['valid'] = False
|
|
result['issues'].append('Exceeds image height')
|
|
|
|
# Check for zero dimensions
|
|
if pos.get('width', 0) == 0 or pos.get('height', 0) == 0:
|
|
result['valid'] = False
|
|
result['issues'].append('Zero dimensions')
|
|
|
|
validation_results.append(result)
|
|
|
|
valid_count = sum(1 for r in validation_results if r['valid'])
|
|
print(f"[Text Processor] Validation complete: {valid_count}/{len(text_positions)} positions valid")
|
|
|
|
return validation_results
|
|
|
|
except Exception as e:
|
|
print(f"[Text Processor] Error validating text rendering: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return [] |