|
|
from langchain_core.tools import tool |
|
|
from tools.image import decode_image, encode_image, save_image |
|
|
|
|
|
@tool |
|
|
def analyze_image(image_base64: str) -> Dict[str, Any]: |
|
|
""" |
|
|
Analyze basic properties of an image (size, mode, color analysis, thumbnail preview). |
|
|
Args: |
|
|
image_base64 (str): Base64 encoded image string |
|
|
Returns: |
|
|
Dictionary with analysis result |
|
|
""" |
|
|
try: |
|
|
img = decode_image(image_base64) |
|
|
width, height = img.size |
|
|
mode = img.mode |
|
|
|
|
|
if mode in ("RGB", "RGBA"): |
|
|
arr = np.array(img) |
|
|
avg_colors = arr.mean(axis=(0, 1)) |
|
|
dominant = ["Red", "Green", "Blue"][np.argmax(avg_colors[:3])] |
|
|
brightness = avg_colors.mean() |
|
|
color_analysis = { |
|
|
"average_rgb": avg_colors.tolist(), |
|
|
"brightness": brightness, |
|
|
"dominant_color": dominant, |
|
|
} |
|
|
else: |
|
|
color_analysis = {"note": f"No color analysis for mode {mode}"} |
|
|
|
|
|
thumbnail = img.copy() |
|
|
thumbnail.thumbnail((100, 100)) |
|
|
thumb_path = save_image(thumbnail, "thumbnails") |
|
|
thumbnail_base64 = encode_image(thumb_path) |
|
|
|
|
|
return { |
|
|
"dimensions": (width, height), |
|
|
"mode": mode, |
|
|
"color_analysis": color_analysis, |
|
|
"thumbnail": thumbnail_base64, |
|
|
} |
|
|
except Exception as e: |
|
|
return {"error": str(e)} |
|
|
|
|
|
@tool |
|
|
def generate_simple_image( |
|
|
image_type: str, |
|
|
width: int = 500, |
|
|
height: int = 500, |
|
|
params: Optional[Dict[str, Any]] = None, |
|
|
) -> Dict[str, Any]: |
|
|
""" |
|
|
Generate a simple image (gradient, noise, pattern, chart). |
|
|
Args: |
|
|
image_type (str): Type of image |
|
|
width (int), height (int) |
|
|
params (Dict[str, Any], optional): Specific parameters |
|
|
Returns: |
|
|
Dictionary with generated image (base64) |
|
|
""" |
|
|
try: |
|
|
params = params or {} |
|
|
|
|
|
if image_type == "gradient": |
|
|
direction = params.get("direction", "horizontal") |
|
|
start_color = params.get("start_color", (255, 0, 0)) |
|
|
end_color = params.get("end_color", (0, 0, 255)) |
|
|
|
|
|
img = Image.new("RGB", (width, height)) |
|
|
draw = ImageDraw.Draw(img) |
|
|
|
|
|
if direction == "horizontal": |
|
|
for x in range(width): |
|
|
r = int( |
|
|
start_color[0] + (end_color[0] - start_color[0]) * x / width |
|
|
) |
|
|
g = int( |
|
|
start_color[1] + (end_color[1] - start_color[1]) * x / width |
|
|
) |
|
|
b = int( |
|
|
start_color[2] + (end_color[2] - start_color[2]) * x / width |
|
|
) |
|
|
draw.line([(x, 0), (x, height)], fill=(r, g, b)) |
|
|
else: |
|
|
for y in range(height): |
|
|
r = int( |
|
|
start_color[0] + (end_color[0] - start_color[0]) * y / height |
|
|
) |
|
|
g = int( |
|
|
start_color[1] + (end_color[1] - start_color[1]) * y / height |
|
|
) |
|
|
b = int( |
|
|
start_color[2] + (end_color[2] - start_color[2]) * y / height |
|
|
) |
|
|
draw.line([(0, y), (width, y)], fill=(r, g, b)) |
|
|
|
|
|
elif image_type == "noise": |
|
|
noise_array = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8) |
|
|
img = Image.fromarray(noise_array, "RGB") |
|
|
|
|
|
else: |
|
|
return {"error": f"Unsupported image_type {image_type}"} |
|
|
|
|
|
result_path = save_image(img) |
|
|
result_base64 = encode_image(result_path) |
|
|
return {"generated_image": result_base64} |
|
|
|
|
|
except Exception as e: |
|
|
return {"error": str(e)} |
|
|
|
