338 lines
8.1 KiB
Go
338 lines
8.1 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/landaiqing/freezelib"
|
|
"os"
|
|
)
|
|
|
|
func main() {
|
|
fmt.Println("📊 Output Format Examples")
|
|
fmt.Println("=========================")
|
|
|
|
// Create output directory
|
|
os.MkdirAll("output", 0755)
|
|
|
|
// Run format examples
|
|
svgVsPngExample()
|
|
qualityComparisonExample()
|
|
dimensionExamples()
|
|
formatOptimizationExample()
|
|
|
|
fmt.Println("\n✅ Format examples completed!")
|
|
fmt.Println("📁 Check the 'output' directory for generated files.")
|
|
fmt.Println("📏 Compare file sizes and visual quality between formats.")
|
|
}
|
|
|
|
// SVG vs PNG comparison
|
|
func svgVsPngExample() {
|
|
fmt.Println("\n🆚 SVG vs PNG Comparison")
|
|
fmt.Println("-------------------------")
|
|
|
|
freeze := freezelib.New().
|
|
WithTheme("github-dark").
|
|
WithFont("JetBrains Mono", 14).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(15, 0, 8)
|
|
|
|
code := `package main
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"log"
|
|
)
|
|
|
|
func handler(w http.ResponseWriter, r *http.Request) {
|
|
fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
|
|
}
|
|
|
|
func main() {
|
|
http.HandleFunc("/", handler)
|
|
fmt.Println("Server starting on :8080")
|
|
log.Fatal(http.ListenAndServe(":8080", nil))
|
|
}`
|
|
|
|
// Generate SVG
|
|
svgData, err := freeze.GenerateFromCode(code, "go")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error generating SVG: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Generate PNG
|
|
pngData, err := freeze.GeneratePNGFromCode(code, "go")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error generating PNG: %v\n", err)
|
|
return
|
|
}
|
|
|
|
// Save files
|
|
svgPath := "output/comparison.svg"
|
|
pngPath := "output/comparison.png"
|
|
|
|
os.WriteFile(svgPath, svgData, 0644)
|
|
os.WriteFile(pngPath, pngData, 0644)
|
|
|
|
// Show file size comparison
|
|
svgInfo, _ := os.Stat(svgPath)
|
|
pngInfo, _ := os.Stat(pngPath)
|
|
|
|
fmt.Printf("✅ Generated: %s (%d bytes)\n", svgPath, svgInfo.Size())
|
|
fmt.Printf("✅ Generated: %s (%d bytes)\n", pngPath, pngInfo.Size())
|
|
fmt.Printf("📊 Size ratio: PNG is %.1fx larger than SVG\n",
|
|
float64(pngInfo.Size())/float64(svgInfo.Size()))
|
|
}
|
|
|
|
// Quality comparison with different settings
|
|
func qualityComparisonExample() {
|
|
fmt.Println("\n🎨 Quality Comparison")
|
|
fmt.Println("---------------------")
|
|
|
|
baseCode := `def quicksort(arr):
|
|
if len(arr) <= 1:
|
|
return arr
|
|
|
|
pivot = arr[len(arr) // 2]
|
|
left = [x for x in arr if x < pivot]
|
|
middle = [x for x in arr if x == pivot]
|
|
right = [x for x in arr if x > pivot]
|
|
|
|
return quicksort(left) + middle + quicksort(right)
|
|
|
|
# Example usage
|
|
numbers = [3, 6, 8, 10, 1, 2, 1]
|
|
sorted_numbers = quicksort(numbers)
|
|
print(f"Original: {numbers}")
|
|
print(f"Sorted: {sorted_numbers}")`
|
|
|
|
// Different quality settings
|
|
configs := []struct {
|
|
name string
|
|
width float64
|
|
height float64
|
|
fontSize float64
|
|
theme string
|
|
}{
|
|
{"low_quality", 400, 300, 10, "github"},
|
|
{"medium_quality", 800, 600, 14, "github-dark"},
|
|
{"high_quality", 1200, 900, 16, "dracula"},
|
|
{"ultra_quality", 1600, 1200, 18, "monokai"},
|
|
}
|
|
|
|
for _, config := range configs {
|
|
fmt.Printf("🔧 Generating %s...\n", config.name)
|
|
|
|
freeze := freezelib.New().
|
|
WithTheme(config.theme).
|
|
WithFont("JetBrains Mono", config.fontSize).
|
|
WithDimensions(config.width, config.height).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(10, 0, 5)
|
|
|
|
// Generate PNG for quality comparison
|
|
pngData, err := freeze.GeneratePNGFromCode(baseCode, "python")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/quality_%s.png", config.name)
|
|
err = os.WriteFile(filename, pngData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
// Show file info
|
|
info, _ := os.Stat(filename)
|
|
fmt.Printf("✅ Generated: %s (%dx%d, %d bytes)\n",
|
|
filename, config.width, config.height, info.Size())
|
|
}
|
|
}
|
|
|
|
// Different dimension examples
|
|
func dimensionExamples() {
|
|
fmt.Println("\n📏 Dimension Examples")
|
|
fmt.Println("---------------------")
|
|
|
|
code := `SELECT u.name, u.email, COUNT(o.id) as order_count
|
|
FROM users u
|
|
LEFT JOIN orders o ON u.id = o.user_id
|
|
WHERE u.created_at >= '2024-01-01'
|
|
GROUP BY u.id, u.name, u.email
|
|
HAVING COUNT(o.id) > 0
|
|
ORDER BY order_count DESC
|
|
LIMIT 10;`
|
|
|
|
dimensions := []struct {
|
|
name string
|
|
width float64
|
|
height float64
|
|
desc string
|
|
}{
|
|
{"square", 600, 600, "Square format"},
|
|
{"wide", 1000, 400, "Wide format (presentations)"},
|
|
{"tall", 400, 800, "Tall format (mobile)"},
|
|
{"standard", 800, 600, "Standard 4:3 ratio"},
|
|
{"widescreen", 1200, 675, "Widescreen 16:9 ratio"},
|
|
}
|
|
|
|
for _, dim := range dimensions {
|
|
fmt.Printf("📐 Creating %s format (%fx%f)...\n", dim.name, dim.width, dim.height)
|
|
|
|
freeze := freezelib.New().
|
|
WithTheme("nord").
|
|
WithFont("Cascadia Code", 13).
|
|
WithDimensions(dim.width, dim.height).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithPadding(20)
|
|
|
|
svgData, err := freeze.GenerateFromCode(code, "sql")
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
filename := fmt.Sprintf("output/dimension_%s.svg", dim.name)
|
|
err = os.WriteFile(filename, svgData, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("✅ Generated: %s - %s\n", filename, dim.desc)
|
|
}
|
|
}
|
|
|
|
// Format optimization examples
|
|
func formatOptimizationExample() {
|
|
fmt.Println("\n⚡ Format Optimization")
|
|
fmt.Println("----------------------")
|
|
|
|
code := `import React, { useState, useEffect } from 'react';
|
|
|
|
const TodoApp = () => {
|
|
const [todos, setTodos] = useState([]);
|
|
const [input, setInput] = useState('');
|
|
|
|
useEffect(() => {
|
|
// Load todos from localStorage
|
|
const saved = localStorage.getItem('todos');
|
|
if (saved) {
|
|
setTodos(JSON.parse(saved));
|
|
}
|
|
}, []);
|
|
|
|
const addTodo = () => {
|
|
if (input.trim()) {
|
|
const newTodo = {
|
|
id: Date.now(),
|
|
text: input,
|
|
completed: false
|
|
};
|
|
setTodos([...todos, newTodo]);
|
|
setInput('');
|
|
}
|
|
};
|
|
|
|
return (
|
|
<div className="todo-app">
|
|
<h1>Todo List</h1>
|
|
<input
|
|
value={input}
|
|
onChange={(e) => setInput(e.target.value)}
|
|
placeholder="Add a todo..."
|
|
/>
|
|
<button onClick={addTodo}>Add</button>
|
|
</div>
|
|
);
|
|
};
|
|
|
|
export default TodoApp;`
|
|
|
|
// Optimized for different use cases
|
|
optimizations := []struct {
|
|
name string
|
|
format string
|
|
description string
|
|
config func() *freezelib.Freeze
|
|
}{
|
|
{
|
|
"web_optimized",
|
|
"svg",
|
|
"Optimized for web (small, scalable)",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("system-ui", 12).
|
|
WithPadding(15).
|
|
WithWindow(false) // No window for smaller size
|
|
},
|
|
},
|
|
{
|
|
"print_optimized",
|
|
"png",
|
|
"Optimized for print (high DPI)",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("github").
|
|
WithFont("Times New Roman", 14).
|
|
WithDimensions(1200, 900).
|
|
WithWindow(true).
|
|
WithLineNumbers(true).
|
|
WithShadow(0, 0, 0) // No shadow for print
|
|
},
|
|
},
|
|
{
|
|
"social_optimized",
|
|
"png",
|
|
"Optimized for social media",
|
|
func() *freezelib.Freeze {
|
|
return freezelib.New().
|
|
WithTheme("dracula").
|
|
WithFont("Fira Code", 16).
|
|
WithDimensions(1080, 1080). // Square for Instagram
|
|
WithWindow(true).
|
|
WithShadow(20, 0, 15).
|
|
WithPadding(30)
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, opt := range optimizations {
|
|
fmt.Printf("🎯 Creating %s (%s)...\n", opt.name, opt.description)
|
|
|
|
freeze := opt.config()
|
|
|
|
var data []byte
|
|
var err error
|
|
var filename string
|
|
|
|
if opt.format == "svg" {
|
|
data, err = freeze.GenerateFromCode(code, "javascript")
|
|
filename = fmt.Sprintf("output/optimized_%s.svg", opt.name)
|
|
} else {
|
|
data, err = freeze.GeneratePNGFromCode(code, "javascript")
|
|
filename = fmt.Sprintf("output/optimized_%s.png", opt.name)
|
|
}
|
|
|
|
if err != nil {
|
|
fmt.Printf("❌ Error: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
err = os.WriteFile(filename, data, 0644)
|
|
if err != nil {
|
|
fmt.Printf("❌ Error saving: %v\n", err)
|
|
continue
|
|
}
|
|
|
|
info, _ := os.Stat(filename)
|
|
fmt.Printf("✅ Generated: %s (%d bytes)\n", filename, info.Size())
|
|
}
|
|
}
|