@getollie/cli 0.0.1

package/library/multimedia_editing-image_editing/image-text-annotation-tool-with-save.json

@@ -0,0 +1,68 @@
+{
+  "index": 525,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, expert responses. Be sure to ensure that the generated code is executable for demonstration purposes. Develop a front-end project with image text annotation functionality. After users upload an image, they should be able to input text at specified positions on the image, with options to set font, color, and size. When the input is complete, users should be able to save the image with the added text to their local device.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload and display functionality fully implemented?",
+      "description": "Review whether the code correctly handles image file upload through HTML file input, includes proper file type validation (JPEG, PNG, GIF, WebP), file size limitations, and displays the uploaded image with proper scaling and positioning on canvas or similar element. Score 0 if basic upload is not working, 5 if only basic upload without validation is implemented, and 10 if complete upload with validation, preview, and error handling is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the text positioning and input system accurately implemented?",
+      "description": "Check whether the code provides precise click-to-position text input functionality with coordinate mapping between display and actual image dimensions. Must include visual indicators for text placement, input field positioning, and coordinate transformation handling for different image scales. Deduct 5 points if coordinate mapping is inaccurate, and 3 points if visual feedback for positioning is missing. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are comprehensive text styling options provided?",
+      "description": "Evaluate whether the implementation includes complete font customization controls: font family selection, size adjustment (with reasonable range limits), color picker with hex/RGB support, and real-time preview of styling changes. Deduct 3 points for each missing styling option, 5 points if real-time preview is not implemented. Check for proper styling persistence and rendering accuracy. Full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the image saving and export functionality properly constructed?",
+      "description": "Check whether the code implements canvas-based image rendering that combines the original image with overlaid text, maintains original image quality and resolution, and provides download functionality with proper filename handling. Deduct 5 points if text rendering quality is poor, 3 points if original image resolution is not preserved, and 5 points if download mechanism fails. Give 10 points if fully implemented with high-quality output.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid file uploads, oversized images, special characters in text input, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Text shadow and outline effects 2. Multiple text layers with drag-and-drop repositioning 3. Batch text styling 4. Undo/redo functionality 5. Text templates or presets). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple file upload handlers) 2. Function modules unrelated to image annotation (e.g., built-in image filters unrelated to text overlay) 3. Fancy effects that affect performance (e.g., complex animations during text input). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating image handling/text rendering/UI control layers), proper event handling, and code organization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if no proper separation of concerns is implemented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching for UI controls (no more than 3 primary colors) 2) Proper layout spacing with clear tool organization (element spacing follows the 8px multiple principle) 3) Professional typography in interface (body font size ≥ 14px, line height over 1.5 times) 4) Clear visual hierarchy between image area and control panels. Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click-to-position feedback delay ≤ 100ms 2) Text input responsiveness and real-time preview updates 3) Smooth styling control interactions 4) Clear visual focus guidance for active text elements 5) Intuitive cursor changes and hover states. Deduct 5 points for each operation without proper feedback, 3 points for laggy text positioning, and 5 points for unclear interaction states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}

package/library/multimedia_editing-image_editing/image-text-watermark-frontend-project.json

@@ -0,0 +1,68 @@
+{
+  "index": 584,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration. Create a frontend project for adding text watermarks to images. After users upload an image, they can input the text they want to add, select the text color, font size, and position on the page. When they click the \"Add Watermark\" button, the image will display with the watermark effect. Users should be able to save the watermarked image.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic image upload functionality properly implemented?",
+      "description": "Review whether the code includes proper file input handling with image format validation (.jpg, .png, etc.), size limitation, error handling for invalid files, and a preview display. Check if the uploaded image is correctly rendered on the canvas before watermark application. Score 0 if no upload functionality exists, 5 if basic upload works without validation, and 10 if all validations and preview are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the text watermark configuration system comprehensive?",
+      "description": "Evaluate if the code allows users to fully customize watermark text with all required options: text input, color picker with hex/rgba support, font family selection with at least 3 options, font size control with proper limits (10-72pt), opacity adjustment (0-100%), and positioning control. Deduct 2 points for each missing feature. Must include proper input validation and real-time preview of changes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the watermark application mechanism correctly implemented?",
+      "description": "Check if the code properly applies text watermark to the image using Canvas API or appropriate alternative. Verify that text rendering maintains quality at different sizes, preserves transparency settings, and implements proper positioning according to user selection (9-point grid or free positioning). Deduct 5 points if text becomes pixelated when applied, 3 points if positioning is limited/inaccurate, and 5 points if text styling is not properly rendered. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the image export/save functionality properly implemented?",
+      "description": "Review if the code provides a working mechanism to save the watermarked image in original quality, with appropriate file format options (.jpg, .png), maintains aspect ratio, and preserves metadata when needed. Check for proper use of canvas.toDataURL() or canvas.toBlob() with correct parameters, and implementation of download attributes. Deduct 5 points if image quality is degraded during saving, 3 points if format options are missing, and 5 points if the save mechanism is browser-incompatible. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as unsupported image formats, oversized files, failure to load images, browser compatibility issues, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Multiple watermark layers support 2. Watermark templates with quick apply options 3. Batch processing for multiple images 4. Advanced text effects like shadows/outline/gradient). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple image rendering methods) 2. Function modules unrelated to watermarking (e.g., unnecessary image filters) 3. Fancy effects that affect performance (e.g., excessive animations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating UI/logic/file handling), performance optimization for large images, memory management, and proper use of async operations. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if large images cause noticeable performance issues. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Watermark preview updates in real-time (≤ 100ms) 2) Proper loading indicators for time-consuming operations 3) Clear visual feedback for all user actions. Deduct 5 points for laggy watermark previews, 3 points for missing loading states during image processing, and 5 points for poor discoverability of key functions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}

package/library/multimedia_editing-image_editing/image-watermark-remover-responsive-design.json

@@ -0,0 +1,68 @@
+{
+  "index": 460,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the code you generate is executable for demonstration. I want to create an application that can remove watermarks from images, with the ability to either freely select areas or automatically detect areas for removal. Please provide me with code that I can use on both computer and mobile devices, with responsive design that adapts to different screen sizes.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Core Image Processing Implementation",
+      "description": "Evaluate whether the code properly implements fundamental image processing techniques for watermark removal, including algorithms such as inpainting, exemplar-based texture synthesis, or frequency domain filtering. Check if the implementation allows for adjusting parameters to handle different types of watermarks (semi-transparent, opaque, pattern-based).0 points if basic image processing is missing, 5 points if only simple opacity-based removal is implemented, 10 points for comprehensive multi-technique approach with parameter adjustments.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Area Selection Mechanisms",
+      "description": "Review the implementation of both manual selection tools (rectangular, lasso, polygon) and automatic watermark detection algorithms. Check if the manual selection includes precision tools like edge refinement and feathering controls. Verify that automatic detection can handle common watermark types through methods like frequency analysis or pattern recognition.Deduct 5 points if only rectangular selection is available, 3 points if automatic detection is unreliable across different image types. Full 10 points requires both flexible manual selection and effective automatic detection.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Preview and Comparison Features",
+      "description": "Assess whether the application provides real-time or near-real-time preview of watermark removal results, and includes before/after comparison tools. Check for features like split-screen view, opacity slider for comparison, and zoom capabilities to examine details.Deduct 5 points if preview is only available after processing, 3 points if comparison tools are limited. Give 10 points for interactive, real-time preview with comprehensive comparison features.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Cross-platform Responsiveness",
+      "description": "Evaluate if the implementation truly works across desktop and mobile platforms with appropriate UI adjustments. Check if the code uses responsive design principles, touch-friendly controls for mobile, and maintains functionality across different screen sizes and input methods.Deduct 5 points if mobile experience is significantly compromised, 3 points if desktop-specific features don't gracefully degrade on smaller screens. Award 10 points for seamless experience across all device types.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Code Robustness",
+      "description": "Evaluate whether the code can handle edge cases like extremely large images, unusual formats, memory constraints, and browser limitations. Check for graceful degradation when optimal performance isn't possible.Evaluate whether the code handles common abnormal situations (such as invalid images, memory overflow, browser compatibility issues) and provides friendly error prompts or recovery mechanisms. Code with strong robustness should effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Innovative Features",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted watermark type detection 2. Batch processing capabilities 3. History of edits with non-destructive workflow 4. Export with metadata preservation).Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Feature Relevance and Optimization",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar removal algorithms 2. Function modules unrelated to image processing (e.g., excessive social sharing features) 3. Memory-intensive features that affect performance on mobile devices.Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Engineering Quality",
+      "description": "Review modular design (such as separating processing logic/UI/state management), lazy loading of heavy resources, and code reusability.Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if heavy processing isn't handled with workers or async operations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Interface Design Quality",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times) 4) Clear indication of processing status and progress.Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Interaction Experience",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Processing feedback with visual progress indicators 2) Smooth transitions between states (selection to processing to result) 3) Intuitive controls with appropriate touch targets for mobile.Deduct 5 points for operations without feedback, 3 points for laggy responses during image processing, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "hard"
+}

package/library/multimedia_editing-image_editing/javascript-drawing-board-with-magnified-pixel-grid.json

@@ -0,0 +1,68 @@
+{
+  "index": 1408,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and expert responses. Be sure that the code you generate is executable for demonstration purposes. Write a drawing board in JavaScript that offers features like pens, brushes, erasers, etc., and where each pixel in the image can be magnified to a 3x3 pixel grid.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the core drawing functionality fully implemented?",
+      "description": "Review whether the code accurately implements basic drawing tools through HTML Canvas/JavaScript: pen, brush, and eraser with different sizes and opacity. Check if the drawing engine correctly captures user input events (mouse/touch) and renders strokes with proper anti-aliasing. Score 0 if core drawing functionality is absent, 5 if only basic drawing is implemented, and 10 if multiple tools with adjustable parameters are fully included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the pixel magnification feature correctly implemented?",
+      "description": "Evaluate the implementation of the 3x3 pixel grid magnification. Check if the code properly handles the translation between normal view and magnified view, maintains pixel data consistency, and updates the magnified view in real-time as the user draws. Verify if the magnification logic works correctly without artifacts or performance issues. Deduct 5 points if magnification is inconsistent, and 3 points if there's noticeable lag during magnified drawing operations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are drawing state management and history operations implemented?",
+      "description": "Check if the drawing board implements undo/redo functionality with a proper history stack. Verify if the state management handles complex operations like brush strokes, eraser use, and color changes correctly. Ensure the history mechanism is memory-efficient (using incremental changes rather than full canvas snapshots). Deduct 5 points if undo/redo is limited to only a few steps, and 3 points if certain operations can't be undone. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is a comprehensive toolset provided with proper UI controls?",
+      "description": "Evaluate the range of drawing tools offered beyond basic requirements. Check for color pickers, brush size selectors, opacity controls, shape tools, fill tools, and other creative options. Examine if the UI controls are intuitive and properly integrated with the canvas functionality. Deduct 2 points for each essential missing tool (color picker, size selector, etc.), and give full points only if the toolset is comprehensive and well-organized. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as out-of-bounds drawing, rapid tool switching, browser resizing, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle edge cases like drawing outside canvas boundaries and prevent memory leaks, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Layer system for complex drawings 2. Export/import functionality with multiple formats 3. Custom brushes or pattern stamps 4. Symmetry drawing modes). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple color picker implementations) 2. Function modules unrelated to drawing (e.g., unrelated animations) 3. Fancy effects that affect drawing performance (e.g., unnecessary visual effects during drawing). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating drawing logic/UI/state management), code reusability, and event handling patterns. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between UI events and drawing logic. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching for the UI (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional tool organization (grouped by function, with clear visual hierarchy). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic tool arrangement. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the drawing interaction smooth and responsive?",
+      "description": "Judge whether the drawing experience conforms to human expectations: 1) Drawing latency ≤ 16ms (60fps) 2) Smooth brush strokes without jitter 3) Responsive tool switching without delay. Deduct 5 points for noticeable lag during drawing, 3 points for stroke jitter or inconsistencies, and 5 points for delayed response when switching between tools or canvas modes. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/merge-upload-images-uniapp-canvas.json

@@ -0,0 +1,68 @@
+{
+  "index": 246,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for demonstration. Please provide code for merging two images using canvas in uniapp and uploading them to the server.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image merging functionality correctly implemented using canvas in UniApp?",
+      "description": "Verify that the code correctly loads and merges two images on a canvas element compatible with UniApp. Check if it handles different image sizes (scaling/positioning), maintains aspect ratios, and processes images without distortion. Score 0 if canvas merging is not implemented, 5 if basic merging is done without handling edge cases, and 10 if the solution is comprehensive with proper error handling for image loading.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image upload mechanism to server properly implemented?",
+      "description": "Evaluate whether the code includes complete HTTP/HTTPS upload functionality using UniApp's upload APIs (uni.uploadFile). Check if it properly handles authentication, includes progress tracking, manages timeouts, and implements retry mechanisms. Deduct 5 points if upload error handling is missing, and 3 points if there's no upload progress indication. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the solution handle the UniApp cross-platform compatibility?",
+      "description": "Assess if the code accounts for platform differences in canvas API implementation across different platforms (iOS, Android, H5, mini-programs). Check if conditional code is used to handle platform-specific issues, and if polyfills are implemented where needed. Deduct 5 points if the solution works on only one platform, 3 points if minor platform-specific adjustments are missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the image processing optimization implemented?",
+      "description": "Review whether the solution includes image optimization techniques such as compression before upload, proper memory management for large images, and canvas size optimization. Check if the code handles different image formats and converts them appropriately. Deduct 5 points if there's no compression implementation, 3 points if memory management is poor. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as image loading failures, network issues during upload, unsupported image formats, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Image filters or effects during merging 2. Drag-and-drop positioning of images before merging 3. Preview functionality with adjustable parameters). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant image processing operations that could be optimized 2. Function modules unrelated to image merging and uploading 3. Unnecessary canvas operations that impact performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating image processing/UI/network layers), error handling practices, and code reusability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no separation between business logic and UI components. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the UI elements for image selection, merging preview, and upload progress follow modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Visual feedback during image loading and processing ≤ 100ms 2) Smooth transitions between selection, preview, and upload states 3) Clear upload progress indication. Deduct 5 points for each operation without feedback, 3 points for jerky animations during processing, and 5 points for unclear upload status indication. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/multi-functional-image-creation-tool-webpage.json

@@ -0,0 +1,68 @@
+{
+  "index": 355,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable for demonstration purposes. Help me create a multi-functional image creation tool webpage that doesn't require login. Please provide a specific product solution.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic image creation functionality fully implemented?",
+      "description": "Review whether the code implements core drawing capabilities through HTML5 Canvas/SVG, including basic tools (pen, shapes, text, eraser), color selection, and layer management. Score 0 if the core drawing functionality is missing, 5 if only basic tools are implemented, and 10 if comprehensive drawing features with proper event handling are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the implementation include advanced image editing features?",
+      "description": "Check for implementation of advanced features like filters, transformations (resize, rotate, crop), blend modes, and image adjustment controls (brightness, contrast, saturation). Deduct 3 points if only basic transformations exist, 5 points if filters are missing, and 7 points if no image adjustments are available. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there a mechanism for saving/exporting created images?",
+      "description": "Evaluate whether the tool provides options to export in different formats (PNG, JPEG, SVG), with customizable quality settings and dimensions. Check if temporary local storage is implemented for auto-saving work. Deduct 5 points if only one export format is supported, and 8 points if no export functionality exists. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the image creation tool usable without login requirements?",
+      "description": "Verify that all functionality works without authentication while still preserving user work through local storage or temporary session mechanisms. Check if the implementation uses browser storage APIs appropriately. Deduct 10 points if any core functionality requires authentication, 5 points if local storage is not utilized for preserving work. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid image uploads, browser compatibility issues, memory limitations with large canvases, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted drawing tools 2. Community template gallery without login 3. One-click image enhancement algorithms). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple color picker systems) 2. Function modules unrelated to image creation (e.g., a news feed) 3. Fancy effects that affect performance (e.g., excessive animations that slow down the drawing experience). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating drawing logic/UI/storage layers), component reusability, and build process optimization. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not optimized for performance. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional tool organization (grouped by function with clear visual hierarchy). Deduct 3 points for cluttered toolbars, 5 points for poor color contrast affecting usability, and 5 points for inconsistent icon styles. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the drawing interactions conform to human perception characteristics: 1) No lag between input and drawing (≤ 20ms) 2) Smooth canvas zooming/panning 3) Intuitive tool selection and parameter adjustment. Deduct 5 points for noticeable drawing lag, 3 points for jerky canvas manipulation, and 5 points for confusing tool interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/online-dynamic-image-sticker-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 640,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure the code you generate is executable for demonstration. Please develop an online dynamic sticker tool where users can upload images and add animated stickers (such as animated emojis, dynamic text effects, etc.) to their images. Users should be able to adjust the position, size, and animation effects of the stickers, preview the dynamic effects, and then download the processed image in GIF or video format.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload and processing system fully implemented?",
+      "description": "Review whether the code supports multiple image formats (JPEG, PNG, WebP) with proper file validation, size limits, and error handling. Check if image preview, canvas rendering, and memory management are properly implemented. Score 0 if basic upload is missing, 5 if only basic upload works without validation, and 10 if complete image processing pipeline with optimization is included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the animated sticker library and management system complete?",
+      "description": "Evaluate whether the system includes a comprehensive sticker library with categorized animated emojis, dynamic text effects, and custom animation templates. Check if stickers support multiple formats (GIF, CSS animations, Canvas animations) and include proper loading states. Deduct 5 points if animation performance is poor (>16ms frame time), 3 points if sticker categories are limited (<10 types). Full score requires 20+ animated stickers with smooth performance.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are the sticker manipulation controls precise and intuitive?",
+      "description": "Check whether users can accurately position, resize, rotate, and layer stickers with touch/mouse controls. Evaluate if the system includes snap-to-grid, multi-select, undo/redo, and transform handles. Require smooth drag-and-drop with visual feedback. Deduct 5 points if transformation controls are clunky or imprecise, 3 points if layering/z-index management is missing. Full score needs pixel-perfect control with gesture support.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the real-time preview and export functionality robust?",
+      "description": "Assess whether the system provides real-time preview of animated compositions with accurate timing and synchronization. Check if export supports multiple formats (GIF, MP4, WebM) with quality/size options and progress indicators. Deduct 5 points if preview doesn't match final export, 5 points if export quality is poor or fails frequently. Require frame-accurate preview and reliable multi-format export.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as oversized files, corrupted images, browser compatibility issues, memory limitations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like network failures during upload, canvas memory limits, and animation conflicts, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the creative experience (e.g., 1. AI-powered sticker suggestions based on image content 2. Collaborative editing with real-time sharing 3. Advanced animation timeline editor 4. Social sharing with custom templates 5. Voice-to-text animated captions). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar animation engines (e.g., multiple canvas renderers coexisting) 2. Function modules unrelated to sticker editing (e.g., built-in photo filters or games) 3. Performance-heavy effects that don't add value (e.g., excessive particle systems or 3D transforms). Deduct 3 points for each redundancy found, and directly deduct 10 points if core sticker functionality is compromised by bloated features.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separating upload/canvas/animation/export modules), performance optimization for canvas operations, and proper asset management. Deduct 5 points if memory leaks are found in animation loops or canvas operations; deduct 5 points if code duplication rate is high (over 30%); deduct 5 points if no performance monitoring or optimization is implemented. Full score requires clean architecture with efficient rendering pipeline.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the creative tool interface follows modern design principles: 1) Intuitive toolbar layout with clear iconography 2) Consistent spacing and visual hierarchy (8px grid system) 3) Professional color scheme suitable for creative work 4) Proper typography with readable labels (≥14px). Deduct 3 points for each cluttered interface element, 5 points for poor contrast or accessibility issues, and 5 points for confusing navigation or tool organization. Full score requires polished, designer-friendly interface.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the creative workflow feels responsive and natural: 1) Sticker drag operations with <50ms latency 2) Animation preview at consistent 30+ FPS 3) Smooth zoom/pan controls for canvas navigation 4) Immediate visual feedback for all tool interactions. Deduct 5 points for each laggy interaction, 3 points for animation stuttering or frame drops, and 5 points for unresponsive touch/click areas. Full score requires fluid, professional-grade creative tool performance.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "hard"
+}

package/library/multimedia_editing-image_editing/online-image-annotation-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 641,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. You Are A Code Expert\n\nYou are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable and demonstrable.\n\n## Role\n\nYou are an experienced code expert. You are provided with a software development requirement description and asked to generate project code according to this requirement. Strictly follow the rules to help users generate complete project code that is fully commented in simple, easy-to-understand language. Don't output anything else.\n\n## Output Rules\n\n1. Always generate complete, runnable project code. Please ensure the project is complete and executable\n2. Ensure all code files you output are complete, don't omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot execute or contains errors, regenerate it\n4. If the requirements include external API access needs or require user data (images, videos, audio, etc.), please provide simulated data\n\n## Project Requirements Description\n\nDesign an online image annotation tool where users can upload images and add annotations (such as rectangles, circles, text) on the images. Support editing and deleting annotations, and enable exporting the annotated images.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic image upload functionality properly implemented?",
+      "description": "Check whether the code includes a complete image upload function with proper file validation (type, size), preview capabilities, and error handling. The upload component should support drag-and-drop and file browser dialog. Score 0 if image upload is missing, 5 if basic upload exists but lacks validation or error handling, and 10 if fully implemented with all features and feedback mechanisms.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all required annotation tools implemented?",
+      "description": "Evaluate whether the code implements all necessary annotation tools (rectangles, circles, text) with proper drawing capabilities. Each tool should have clear selection states and visual feedback. Score 2 points for each well-implemented tool type (rectangle, circle, text). Add 2 points if the annotation tools have configuration options (color, line width, etc.). Add 2 points if the tool implementation includes snapping or alignment guides for precise positioning.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is annotation editing and manipulation functionality complete?",
+      "description": "Check if users can select, move, resize, and rotate existing annotations. Review whether the code includes proper event handling for manipulation (mouse/touch events), transformation calculations, and state management. Score 0 if editing is missing, 5 if basic editing exists but lacks some features (e.g., rotation), and 10 if fully implemented with all manipulation capabilities and proper visual feedback during edits.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the annotation deletion and history management implemented?",
+      "description": "Verify if the code includes functionality to delete annotations and whether it implements undo/redo operations. Check if the annotation state history is properly tracked for these operations. Score 3 points for basic deletion functionality, 3 points for proper history state management, and 4 points for complete undo/redo implementation with keyboard shortcuts support.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid image formats, browser compatibility issues, large images, multiple concurrent operations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 5,
+      "title": "Are there any innovative features that are eye-catching?",
+      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Auto-save functionality 2. Keyboard shortcuts for all operations 3. Annotation templates or presets 4. Collaborative editing features). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
+      "maxScore": 10
+    },
+    {
+      "id": 6,
+      "title": "Are there any redundant features?",
+      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple ways to handle the same event) 2. Function modules unrelated to image annotation (e.g., a built-in photo editor) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down annotation rendering). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (such as separating annotation logic/view/data models), code reusability, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate visual feedback when drawing annotations 2) Smooth selection and manipulation of objects 3) Clear visual focus guidance for active tools and selected annotations. Deduct 5 points for each operation without feedback, 3 points for laggy annotation rendering during manipulation, and 5 points for confusing tool state indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "hard"
+}