Spaces:
Sleeping
Sleeping
| import os | |
| import tempfile | |
| import base64 | |
| import gradio as gr | |
| from PIL import Image, ImageDraw, ImageFont | |
| # --- Image Generation Logic (from coverter.py) --- | |
| def draw_horizontal_lines(draw, width, height, spacing=60, color=(230, 230, 230)): | |
| """Draws horizontal lines on the image.""" | |
| for y in range(0, height, spacing): | |
| draw.line([(0, y), (width, y)], fill=color, width=2) | |
| def draw_dot_grid(draw, width, height, spacing=50, color=(220, 220, 220)): | |
| """Draws a dot grid on the image.""" | |
| for x in range(0, width, spacing): | |
| for y in range(0, height, spacing): | |
| draw.ellipse([(x-2, y-2), (x+2, y+2)], fill=color) | |
| def draw_lattice_grid(draw, width, height, spacing=100, color=(235, 235, 235)): | |
| """Draws a lattice/graph paper grid on the image.""" | |
| # Draw vertical lines | |
| for x in range(0, width, spacing): | |
| draw.line([(x, 0), (x, height)], fill=color, width=2) | |
| # Draw horizontal lines | |
| for y in range(0, height, spacing): | |
| draw.line([(0, y), (width, y)], fill=color, width=2) | |
| def text_to_images_generator(text_content, style='lines'): | |
| """ | |
| Converts a given string of text into a single combined image and returns the file path. | |
| This is compatible with both UI and MCP. | |
| Args: | |
| text_content (str): The text to be converted. | |
| style (str): The background style ('plain', 'lines', 'dots', 'grid'). | |
| Returns: | |
| str: Message with the path to the generated combined image file. | |
| """ | |
| if not text_content or not text_content.strip(): | |
| return "Error: Input text is empty. Please enter some text to generate images." | |
| # --- Configuration --- | |
| IMG_WIDTH = 1080 | |
| IMG_HEIGHT = 1080 | |
| BACKGROUND_COLOR = (255, 255, 255) | |
| TEXT_COLOR = (10, 10, 10) | |
| STYLE_COLOR = (225, 225, 225) # Color for lines/dots/grid | |
| PADDING_X = 80 | |
| PADDING_Y = 80 | |
| FONT_SIZE = 48 | |
| LINE_SPACING = 20 | |
| # --- Font Loading --- | |
| font = None | |
| try: | |
| font_paths_to_try = [ | |
| "Arial.ttf", "arial.ttf", "DejaVuSans.ttf", | |
| "/System/Library/Fonts/Supplemental/Arial.ttf", | |
| "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf", | |
| "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf" | |
| ] | |
| for f_path in font_paths_to_try: | |
| try: | |
| font = ImageFont.truetype(f_path, FONT_SIZE) | |
| break | |
| except IOError: | |
| continue | |
| if not font: | |
| font = ImageFont.load_default() | |
| except Exception as e: | |
| print(f"An unexpected error occurred during font loading: {e}") | |
| font = ImageFont.load_default() | |
| # --- Text Wrapping Logic --- | |
| drawable_width = IMG_WIDTH - 2 * PADDING_X | |
| paragraphs = [p.strip() for p in text_content.strip().split('\n') if p.strip()] | |
| all_lines_and_breaks = [] | |
| for i, paragraph in enumerate(paragraphs): | |
| words = paragraph.split() | |
| current_line = "" | |
| for word in words: | |
| if font.getlength(word) > drawable_width: | |
| temp_word = "" | |
| for char in word: | |
| if font.getlength(temp_word + char) > drawable_width: | |
| all_lines_and_breaks.append(temp_word) | |
| temp_word = char | |
| else: | |
| temp_word += char | |
| word = temp_word | |
| if font.getlength(current_line + " " + word) <= drawable_width: | |
| current_line += " " + word | |
| else: | |
| all_lines_and_breaks.append(current_line.strip()) | |
| current_line = word | |
| all_lines_and_breaks.append(current_line.strip()) | |
| if i < len(paragraphs) - 1: | |
| all_lines_and_breaks.append(None) | |
| # --- Image Generation --- | |
| try: | |
| line_height = font.getbbox("A")[3] - font.getbbox("A")[1] | |
| except AttributeError: | |
| line_height = 12 | |
| PARAGRAPH_SPACING = line_height | |
| # Calculate pages and total height needed | |
| pages_content = [] | |
| current_page = [] | |
| y_text = PADDING_Y | |
| for item in all_lines_and_breaks: | |
| is_break = item is None | |
| item_height = PARAGRAPH_SPACING if is_break else line_height | |
| if y_text + item_height > IMG_HEIGHT - PADDING_Y: | |
| pages_content.append(current_page) | |
| current_page = [item] | |
| y_text = PADDING_Y + item_height + (0 if is_break else LINE_SPACING) | |
| else: | |
| current_page.append(item) | |
| y_text += item_height + (0 if is_break else LINE_SPACING) | |
| if current_page: | |
| pages_content.append(current_page) | |
| # Create a single combined image with all pages | |
| total_height = len(pages_content) * IMG_HEIGHT | |
| combined_img = Image.new('RGB', (IMG_WIDTH, total_height), color=BACKGROUND_COLOR) | |
| for page_idx, page_content in enumerate(pages_content): | |
| # Create individual page | |
| page_img = Image.new('RGB', (IMG_WIDTH, IMG_HEIGHT), color=BACKGROUND_COLOR) | |
| draw = ImageDraw.Draw(page_img) | |
| if style == 'lines': | |
| line_style_spacing = line_height + LINE_SPACING | |
| draw_horizontal_lines(draw, IMG_WIDTH, IMG_HEIGHT, spacing=line_style_spacing, color=STYLE_COLOR) | |
| elif style == 'dots': | |
| draw_dot_grid(draw, IMG_WIDTH, IMG_HEIGHT, color=STYLE_COLOR) | |
| elif style == 'grid': | |
| draw_lattice_grid(draw, IMG_WIDTH, IMG_HEIGHT, color=STYLE_COLOR) | |
| current_y = PADDING_Y | |
| for page_item in page_content: | |
| if page_item is not None: | |
| draw.text((PADDING_X, current_y), page_item, font=font, fill=TEXT_COLOR) | |
| current_y += line_height + LINE_SPACING | |
| else: | |
| current_y += PARAGRAPH_SPACING | |
| # Paste this page onto the combined image | |
| combined_img.paste(page_img, (0, page_idx * IMG_HEIGHT)) | |
| # Save combined image to temporary file and also encode as base64 | |
| temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png') | |
| combined_img.save(temp_file.name, format='PNG') | |
| temp_file.close() | |
| # Convert to base64 for inline viewing | |
| import io | |
| img_buffer = io.BytesIO() | |
| combined_img.save(img_buffer, format='PNG') | |
| img_buffer.seek(0) | |
| img_base64 = base64.b64encode(img_buffer.getvalue()).decode('utf-8') | |
| return f"""Image successfully generated and saved to: {temp_file.name} | |
| Image details: | |
| - Total pages: {len(pages_content)} | |
| - Image dimensions: {IMG_WIDTH} x {total_height} pixels | |
| - Style: {style} | |
| - Format: PNG | |
| Base64 encoded image (you can copy this and paste into a base64 image viewer): | |
| data:image/png;base64,{img_base64} | |
| To view the image: | |
| 1. Copy the entire data:image/png;base64,... string above | |
| 2. Paste it into your browser's address bar, or | |
| 3. Use an online base64 image viewer like: https://base64.guru/converter/decode/image""" | |
| # --- Gradio Interface --- | |
| example_text = """In the heart of a bustling city, there lived a clockmaker named Alistair. His shop, a quaint corner of tranquility amidst the urban chaos, was filled with the gentle ticking of countless timepieces. Each clock was a masterpiece, a testament to his dedication and skill. | |
| One day, a young girl with eyes as curious as a cat's wandered into his shop. She wasn't interested in the shiny new watches but was drawn to the grandfather clock in the corner. "What's its story?" she asked, her voice soft. Alistair smiled, for he knew he had found the next guardian of the stories. The legacy of the whispering clock would live on.""" | |
| demo = gr.Interface( | |
| fn=text_to_images_generator, | |
| inputs=[ | |
| gr.Textbox(lines=15, label="Text Content", placeholder="Paste your long-form text here...", value=example_text), | |
| gr.Radio(['lines', 'dots', 'grid', 'plain'], label="Background Style", value='lines') | |
| ], | |
| outputs=gr.Textbox(label="Result", show_label=True), | |
| title="Text-to-Image Converter", | |
| description="Transforms long-form text into a single combined image with multiple pages. Paste your text, choose a style, and click 'Submit'. The result will show the file path where your image was saved.", | |
| allow_flagging="never" | |
| ) | |
| # --- Main Execution --- | |
| if __name__ == "__main__": | |
| demo.launch(mcp_server=True) | |