@getollie/cli 0.0.1

package/library/multimedia_editing-image_editing/html-image-upload-clarity-enhancement-save.json

@@ -0,0 +1,68 @@
+{
+  "index": 1061,
+  "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. Create an HTML page that can upload images, process them for clarity enhancement, and save them.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload functionality fully implemented?",
+      "description": "Review whether the code accurately implements file upload through HTML input elements and JavaScript, including drag-and-drop support, file type validation (JPEG, PNG, GIF, WebP), file size limits, and preview functionality. Score 0 if basic upload is not working, 5 if only basic file selection works without validation, and 10 if all upload features including drag-and-drop, validation, and preview are fully implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the image clarity enhancement processing correctly implemented?",
+      "description": "Check whether the image processing uses Canvas API or WebGL for clarity enhancement algorithms such as sharpening filters, contrast adjustment, brightness optimization, or noise reduction. Evaluate if the processing maintains image quality without artifacts. Deduct 5 points if only basic filters are applied, 3 points if processing causes visible artifacts or quality loss. Full score requires advanced enhancement algorithms with quality preservation.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the processed image saving mechanism properly designed?",
+      "description": "Evaluate whether the save functionality supports multiple formats (PNG, JPEG with quality settings), maintains original resolution, and provides download links or automatic download triggers. Check if the saved file preserves the enhanced quality. Deduct 5 points if only one format is supported, 3 points if quality is degraded during save, and 2 points if filename handling is poor. Full implementation should include format options and quality settings.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the complete image processing workflow constructed?",
+      "description": "Check whether the code includes complete workflow management: before/after comparison view, processing progress indicators, undo/redo functionality, batch processing capability, and processing history. Deduct 5 points if comparison view is missing, 3 points if no progress indication, and 2 points if batch processing is not supported. Give 10 points if the complete workflow with all features is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid file formats, oversized images, memory overflow, processing failures, 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. Real-time processing preview with adjustable parameters 2. AI-powered auto-enhancement suggestions 3. Before/after slider comparison 4. Batch processing with different enhancement profiles). 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 processing libraries for same task) 2. Function modules unrelated to image processing (e.g., built-in games or social features) 3. Fancy effects that affect performance (e.g., excessive animations during processing). 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 upload/processing/UI layers), error handling patterns, and code organization. Deduct 5 points if global state pollution is found or no separation of concerns; deduct 5 points if the code duplication rate is too high (over 30%); deduct 3 points if no proper async/await handling for file operations. 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) 4) Clear visual hierarchy for upload/process/save workflow. 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) Upload feedback delay ≤ 100ms 2) Processing progress indication with smooth updates 3) Transition animations between states controlled between 300-500ms 4) Clear visual focus guidance throughout the workflow. Deduct 5 points for each operation without feedback, 3 points for laggy processing indication, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

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

@@ -0,0 +1,68 @@
+{
+  "index": 478,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure that the generated code is executable for demonstration. Implement an image annotation tool where users can upload images, drag to draw rectangular annotation boxes at specified positions on the image, and write descriptive text for each annotation box. Finally, users should be able to save both the image and annotation information.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload functionality properly implemented?",
+      "description": "Check if the code implements file input for image selection, handles various image formats (JPG, PNG, GIF, etc.), performs client-side validation for file types and size limits, and displays proper feedback during the upload process. Also verify if the uploaded image is rendered correctly with proper aspect ratio preservation. Score 0 if image upload is not implemented, 5 if basic upload exists but lacks validation, and 10 if all features including error handling are present.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the rectangular annotation drawing functionality complete?",
+      "description": "Review if the code accurately implements mouse/touch event handling for drawing rectangular boxes (mousedown, mousemove, mouseup or equivalent touch events), includes visual feedback during drawing, maintains proper coordinate calculation relative to the image (not the viewport), and handles edge cases like drawing outside image boundaries. Deduct 5 points if coordinates are incorrectly calculated, 3 points if visual feedback during drawing is missing, and 5 points if annotation persistence between sessions is not handled. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the annotation text input system well-designed?",
+      "description": "Evaluate whether the code provides a text input mechanism for each annotation box, maintains association between text and specific boxes, includes validation for text input (e.g., character limits, required fields), and handles text positioning relative to boxes appropriately. Check if the system allows editing existing annotations. Score 0 if text annotation is missing, 5 if basic implementation exists but lacks editing capability, and 10 if the system is complete with validation and good UX.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the save functionality comprehensive?",
+      "description": "Check if the code implements proper saving of both image and annotation data, exports in a standard format (JSON, XML, or custom format with documentation), includes metadata like timestamps and image details, and provides clear feedback during the save process. Verify if the saved data structure is well-organized for potential future import. Deduct 5 points if only partial data is saved, 3 points if the format is not standardized, and 5 points if no feedback is provided during saving. 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 uploading invalid files, browser resizing, rapid consecutive actions, network issues during save 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. Annotation templates or presets 2. Keyboard shortcuts for efficient annotation 3. Zooming and panning capabilities for precise annotations 4. Annotation categories with color coding). 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 drawing mechanisms that overlap) 2. Function modules unrelated to image annotation (e.g., built-in filters or effects not needed for annotation) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the annotation process). 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/UI rendering/data management layers), code organization, reusable components, and maintenance considerations. 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 event handling creates memory leaks. 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 with clear distinction between UI elements and annotation elements 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system for annotation labels (body font size ≥ 14px, line height over 1.5 times) 4) Clear visual indication of active/selected annotations. Deduct 3 points for each crowded visual element, 5 points for poor contrast between annotations and image, and 5 points for chaotic tool arrangement. 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 boxes 2) Smooth dragging experience without lag 3) Clear visual indication when hovering over interactive elements 4) Intuitive resizing and repositioning of existing annotation boxes. Deduct 5 points for each operation without feedback, 3 points for jittery drawing experience, and 5 points for unintuitive annotation selection mechanics. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}

package/library/multimedia_editing-image_editing/image-comparison-tool-multiple-modes.json

@@ -0,0 +1,68 @@
+{
+  "index": 616,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that the code you produce is executable when possible. Please design an image comparison tool that allows users to upload two images for visual comparison. The tool needs to support multiple comparison modes: 1) Slide comparison (drag the middle divider to view before and after comparison); 2) Transparency comparison (adjust the transparency of the top image); 3) Flip comparison (click to quickly switch between the two images); 4) Side-by-side comparison. Also provide synchronized zoom and pan functions to ensure that corresponding areas of both images can be precisely compared. This is suitable for designers comparing before and after design modifications or photographers comparing photos before and after processing.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload and display functionality fully implemented?",
+      "description": "Review whether the code properly handles image upload (supporting common formats like JPG, PNG, WebP), validates file types/sizes, and correctly displays the images with proper error handling. Check if images are properly scaled to fit the viewport initially while preserving aspect ratios.0 points if image upload is not implemented; 5 points if basic upload works but lacks validation or proper error handling; 10 points for complete implementation with proper validation, error handling, and responsive display.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are all four comparison modes correctly implemented?",
+      "description": "Verify that all required comparison modes function properly: 1) Slide comparison with draggable divider, 2) Transparency adjustment with smooth opacity control, 3) Flip comparison with clean toggling, and 4) Side-by-side view with consistent alignment. Each mode should handle image differences gracefully.Deduct 2.5 points for each missing or poorly implemented comparison mode. Full 10 points requires all four modes to be fully functional with smooth transitions between modes.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the synchronized zoom and pan functionality implemented effectively?",
+      "description": "Evaluate whether zoom and pan functions maintain perfect synchronization between images across all comparison modes. Check if zoom controls are intuitive (mouse wheel, pinch gesture, or UI controls), if pan works with mouse drag or touch gestures, and if the zoomed area remains properly aligned between images.0 points if zoom/pan is not implemented; 5 points if basic functionality exists but synchronization issues occur; 10 points if zoom/pan works flawlessly with proper event handling and maintains perfect alignment between images.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the UI for switching between comparison modes intuitive and accessible?",
+      "description": "Assess the implementation of mode switching UI: clearly labeled buttons/controls, visual indicators for active mode, smooth transitions between modes, and keyboard shortcuts for accessibility. Mode switching should preserve the current zoom/pan position.Deduct 3 points if mode switching is confusing or lacks visual feedback; deduct 2 points if transitions between modes are jarring; deduct 2 points if keyboard accessibility is missing. Full 10 points for intuitive, accessible controls with smooth transitions.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid image files, extremely large/small images, browser compatibility issues, touch vs mouse input) and provide friendly error prompts or recovery mechanisms. Check if the tool degrades gracefully when features aren't supported.Evaluate whether the code can handle common abnormal situations (such as out-of-bounds input, network interruption, user operation errors, 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 histogram comparison, 2. Hotspot detection highlighting differences, 3. Image metadata display, 4. History of previous comparisons, 5. Integration with common design tools).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 zoom controls with overlapping functionality) 2. Function modules unrelated to image comparison (e.g., unrelated editing tools) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow 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 UI logic/image processing/event handling layers), code reusability, performance optimization for large images, and browser compatibility considerations. Check for proper memory management when handling multiple images.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 image rendering optimization is poor (causing lag with larger images). 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) 4) Clear visual distinction between control elements and image display area.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) Image loading shows clear progress indicators 2) Slide divider moves smoothly with cursor/touch 3) Opacity changes render without stuttering 4) Zoom/pan operates at 60fps without jank 5) Mode transitions use appropriate easing.Deduct 5 points for each operation without feedback, 3 points for visual stuttering during interactions, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/image-comparison-tool-slider-save.json

@@ -0,0 +1,68 @@
+{
+  "index": 618,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration.\n\n======== Role ========\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 and easy-to-understand language. Don't output anything else.\n\n======== Output Rules ========\n1. Always generate complete, runnable project code; please ensure the project is fully executable\n2. Ensure all code files you output are complete, do not omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements involve external API access or need to use user data (images, videos, audio, etc.), please provide simulated data\n\n======== Project Requirements ========\nImplement an image comparison tool where, after a user uploads two images, they can use a horizontal slider to see real-time display of the different areas where the two images overlap. After completion, provide a save function for the comparison screenshot.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the dual image upload functionality fully implemented?",
+      "description": "Review whether the code accurately implements file upload handling through HTML input elements and JavaScript, including drag-and-drop upload support, file type validation (accepting common image formats like JPG, PNG, GIF, WebP), file size limits (recommended ≤10MB), and proper error handling for invalid files. Score 0 if basic upload is not working, 5 if only single upload method is implemented, and 10 if multiple upload methods with comprehensive validation are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the horizontal slider comparison mechanism properly implemented?",
+      "description": "Check whether the slider control accurately divides and displays the two images in real-time, including smooth dragging interaction, proper image alignment and scaling, CSS clip-path or overflow masking for seamless transition effects, and responsive behavior on different screen sizes. Deduct 5 points if images are not properly aligned, 3 points if slider movement is jerky or unresponsive. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the real-time image overlay and difference detection implemented?",
+      "description": "Evaluate whether the system provides real-time visual feedback when images overlap, including proper image scaling to match dimensions, canvas-based pixel-level comparison for highlighting differences, and smooth transition effects during slider movement. Deduct 5 points if images don't scale proportionally, 3 points if difference highlighting is missing or inaccurate. Check for performance optimization during real-time processing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the screenshot save functionality complete and reliable?",
+      "description": "Check whether the code includes complete screenshot capture functionality using HTML5 Canvas API, proper image rendering at current slider position, support for different output formats (PNG/JPG), and reliable download mechanism. Deduct 5 points if screenshot doesn't capture current comparison state, 3 points if download fails on different browsers. Give 10 points if fully implemented with cross-browser compatibility.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted image files, extremely large/small images, network interruption during upload, 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 comparison modes like side-by-side or overlay blend 2. Zoom functionality for detailed inspection 3. Batch comparison support 4. Image metadata display 5. Comparison history). 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 upload handlers coexisting) 2. Function modules unrelated to image comparison (e.g., built-in image editor) 3. Fancy effects that affect performance (e.g., excessive animations during comparison). 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 upload logic/comparison engine/UI components), error handling consistency, 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 memory leaks occur during image processing. 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) 4) Clear visual hierarchy for upload areas and comparison zone. 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) Slider drag response delay ≤ 100ms 2) Image transition animations controlled between 200-400ms 3) Clear visual feedback for upload progress and comparison states 4) Smooth performance during real-time comparison without frame drops. Deduct 5 points for each operation without feedback, 3 points for laggy slider movement, and 5 points for unclear interface states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/image-contour-depth-refractive-texture.json

@@ -0,0 +1,68 @@
+{
+  "index": 1361,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. Create a new code that follows this process: first let the user upload a binary image, identify the contours in the image, then estimate the depth of each layer, and fill different refractive textures for layers with different depths.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload and processing mechanism fully implemented?",
+      "description": "Evaluate whether the code implements a complete image upload functionality, including file input validation (checking if it's a valid binary image), preview capability, and proper error handling for corrupted or invalid files. Check if the image is properly loaded for processing with appropriate resolution/size handling. Score 0 if image upload is not implemented, 5 if basic upload exists but with limitations, 10 if fully implemented with comprehensive error handling and preview functionality.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the contour detection algorithm correctly implemented?",
+      "description": "Review the contour detection implementation. Check if appropriate edge detection algorithms (e.g., Canny edge detector, Sobel operator) are used before contour extraction. Verify if the contours are properly identified and stored as vector paths or coordinate sets. Examine if the code handles various image conditions (high contrast, low contrast, noise). Deduct 5 points if only basic edge detection is implemented without proper contour extraction, 3 points if noise handling is missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the depth estimation logic properly implemented?",
+      "description": "Assess the depth estimation algorithm for nested contours. Check if the code correctly identifies hierarchical relationships between contours and assigns appropriate depth values. Verify if the depth estimation accounts for contour size, position, and nesting level. The algorithm should handle complex cases like islands (contours within contours). Deduct 5 points if the depth estimation is simplistic (e.g., only counting nesting levels), 3 points if it doesn't handle special cases like disconnected contours. Score 10 if the depth estimation is comprehensive and accurate.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are the refractive textures appropriately applied to different depth layers?",
+      "description": "Evaluate how refractive textures are applied based on estimated depths. Check if the code includes a variety of realistic refractive materials (e.g., glass, water, crystal) with physically plausible parameters. Verify if the texturing accounts for depth relationships between layers with appropriate visual outcomes. Deduct 5 points if only basic color filling is used instead of true refractive effects, 3 points if the refraction parameters aren't depth-dependent. Score 10 if the implementation includes advanced features like environment mapping or realistic light interaction.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as processing very large images, images with no clear contours, unexpected user inputs, 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. Interactive adjustment of depth perception 2. Multiple refraction styles/presets 3. Real-time preview of changes 4. Export capabilities to 3D formats). 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 image processing functions (e.g., multiple edge detection algorithms running in sequence) 2. Function modules unrelated to the core task (e.g., unnecessary image filters) 3. Computationally expensive effects that significantly slow processing without proportional quality improvement. 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/image processing/rendering layers), algorithm efficiency for large images, and memory management. Deduct 5 points if global state pollution is found or appropriate design patterns are not used; deduct 5 points if the image processing pipeline isn't optimized for performance; deduct 5 points if memory leaks might occur with large images. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the overall UI design follows modern design principles: 1) Harmonious color scheme that doesn't distract from the image processing results 2) Proper layout with clear separation between controls and preview area 3) Professional visualization of depth layers with appropriate legends. Deduct 3 points for cluttered controls, 5 points for poor visual representation of depth layers, and 5 points for inadequate feedback during processing steps. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the interactive elements provide appropriate feedback: 1) Visual indication during image processing with progress feedback 2) Smooth transitions when switching between original image, contour view, and final result 3) Interactive elements for adjusting depth estimation or refraction parameters with immediate visual feedback. Deduct 5 points for lack of processing indicators on large images, 3 points for jarring transitions between views, and 5 points for sluggish response when adjusting parameters. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/image-format-conversion-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 467,
+  "question": "You are a code expert, please use your professional knowledge to generate accurate and professional responses. Try to ensure the generated code is executable for demonstration.\n\n======== ROLE ========\nYou are an experienced code expert. I'm providing you with a software development requirement description, and you need to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple and easy-to-understand comments, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. Always generate complete, runnable project code, ensuring the project is fully 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 be executed or contains errors, regenerate it\n4. If the requirements involve external API access or user data (images, videos, audio, etc.), please provide simulated data\n\n======== PROJECT REQUIREMENTS ========\nPlease develop an image format conversion tool that supports conversion between various image formats. The tool should have the following features: support formats including JPG, PNG, WEBP, GIF, BMP, TIFF, SVG, etc.; batch conversion functionality; adjustable conversion parameters (such as quality, compression rate, size, etc.); preserve or edit metadata information; provide frame preview and editing for dynamic images (such as GIF); provide basic image optimization options; display size comparison before and after conversion; conversion history records. All processing should be completed locally in the browser without uploading to a server. The interface should be clear and concise with explicit steps for use.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image format conversion core functionality fully implemented?",
+      "description": "Review whether the code implements conversion between all required formats (JPG, PNG, WEBP, GIF, BMP, TIFF, SVG). Check if the conversion logic handles edge cases like transparent backgrounds, color spaces, and alpha channels correctly. Score 0 if fewer than 3 formats are supported, 5 if most basic formats work but with errors, and 10 if all specified formats convert correctly with proper error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the batch conversion functionality properly implemented?",
+      "description": "Evaluate if the code allows users to select and convert multiple files simultaneously. Check for queue management, progress tracking, and parallel processing capabilities. The implementation should handle memory efficiently when processing large batches. Deduct 5 points if batch operations are limited to sequential processing without progress indicators, deduct 3 points if the UI becomes unresponsive during conversion, full score if batch operations are optimized with proper feedback.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Are adjustable conversion parameters implemented effectively?",
+      "description": "Check whether the code provides UI controls for adjusting quality, compression rate, dimensions, and other format-specific settings. Each format should have appropriate parameter options (e.g., JPEG quality slider, PNG compression level). Deduct 3 points if parameters are hardcoded, 5 points if format-specific options are missing, and give 10 points if comprehensive and intuitive parameter controls are implemented with real-time preview capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is metadata preservation and editing functionality implemented?",
+      "description": "Review if the code correctly extracts, displays, preserves, and allows editing of image metadata (EXIF, IPTC, XMP). Check if critical metadata like copyright information and camera data is handled properly. Score 0 if metadata is always stripped, 5 if metadata is preserved but not editable, and 10 if the implementation provides both preservation and comprehensive editing capabilities with proper validation.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (malformed images, unsupported formats, browser limitations, memory constraints, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should validate input files, employ try-catch blocks, and gracefully handle WebAssembly/library failures. Give 10 points for comprehensive error handling, 5 points for basic validation, and 0 points if errors cause the application to crash.",
+      "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-powered automatic optimization suggestions 2. Drag-and-drop workflow builder for complex conversions 3. Visual difference highlighter between original and converted images). 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 implementations of image processing libraries (e.g., including both Sharp and ImageMagick wrappers) 2. Function modules unrelated to image conversion (e.g., a built-in audio player) 3. Expensive computations that don't contribute to core functionality. 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 (separation of conversion logic/UI/file handling), use of appropriate design patterns, and memory management strategies. Examine if the code efficiently uses Web Workers for heavy processing to prevent UI freezing. Deduct 5 points for global state pollution or tight coupling; deduct 5 points for inefficient memory usage with large images; deduct 5 points if intensive operations aren't offloaded from the main thread. 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) Clear visual hierarchy with conversion options and preview areas 2) Consistent spacing and alignment of controls 3) Professional typography with appropriate font sizing for readability. Deduct 3 points for each crowded control panel, 5 points for poor information architecture, and 5 points for unintuitive conversion workflow. 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 files are selected 2) Smooth progress indicators for conversion processes 3) Responsive UI even during heavy conversion tasks. Deduct 5 points for each operation without feedback, 3 points for laggy interactions during processing, and 5 points for unclear conversion status indicators. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "hard"
+}

package/library/multimedia_editing-image_editing/image-matting-tool-with-brush-selection.json

@@ -0,0 +1,68 @@
+{
+  "index": 666,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the code generated is executable for demonstration.\n\n======== ROLE ========\nYou are an experienced code expert. You are provided with a software development requirement description and asked to generate project code based on these requirements. Strictly follow the rules to help users generate complete project code with simple and easy-to-understand comments, without outputting anything else.\n\n======== OUTPUT RULES ========\n1. You should always generate complete, runnable project code, ensuring the project is fully executable\n2. Ensure all code files you output are complete, do not omit any code\n3. Carefully review and check all code before final output, evaluating its executability. If the code cannot be executed or contains errors, it needs to be regenerated\n4. If the requirements include external API access or need to use user data (images, videos, audio, etc.), please provide mock data\n\n======== PROJECT REQUIREMENTS ========\nDevelop an image matting tool where users can select areas to keep in an image by brushing with the mouse. Areas not selected will be made transparent, and users can export images with transparent backgrounds.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the basic image loading and display functionality implemented?",
+      "description": "Check whether the code properly implements image loading from local files or URLs, and displays the image on the canvas. Verify if the canvas sizing is appropriate (adjusts to image dimensions or provides scrolling for large images), and if the image loading includes proper error handling. The code should include loading indicators and fallback mechanisms for failed loads.Score 0 if image loading is not implemented, 5 if basic loading works but lacks error handling, 10 if fully implemented with responsive sizing and comprehensive error handling.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the brush selection tool fully implemented?",
+      "description": "Evaluate the brush tool implementation, including adjustable brush size, smooth path drawing, and precise pixel selection. The brush should have configurable hardness/softness edges and provide visual feedback during operation. Check if the code uses efficient algorithms for path interpolation between mouse/touch points to ensure smooth selection even with rapid movements.Deduct 3 points if the brush size cannot be adjusted, 3 points if path interpolation is jerky or imprecise, and 4 points if there's no visual feedback during selection. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the image matting algorithm properly implemented?",
+      "description": "Verify if the matting algorithm correctly separates foreground from background based on user selections. The algorithm should handle edge detection, anti-aliasing at boundaries, and preserve semi-transparent pixels appropriately. Check whether the implementation includes refinement options for edge quality, and if it can process complex image features like hair or fuzzy edges.Score 0 if matting is not implemented, 5 if basic binary matting works but produces jagged edges, 8 if it handles semi-transparent regions adequately, and 10 if it includes edge refinement capabilities and handles complex boundaries well.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the transparent background export functionality working correctly?",
+      "description": "Check if the code provides functionality to export the matted image with a transparent background in appropriate formats (PNG with alpha channel). Verify if multiple export options are available (resolution, quality settings) and if the export process includes proper error handling. The export function should also provide a preview of the final result before saving.Deduct 5 points if PNG with transparency is not supported, 3 points if export options are limited, and 2 points if there's no preview functionality. 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 oversized images, unsupported formats, memory constraints with large canvases, etc.) and provide friendly error prompts or recovery mechanisms. Check if the application implements auto-save or history tracking to prevent data loss during unexpected issues.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. Smart selection tools similar to 'magic wand', 2. Batch processing capability, 3. Background replacement options, 4. Integration with common image filters, 5. Undo/redo functionality with visual history).Add 2 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 canvas manipulation methods that do the same thing) 2. Function modules unrelated to image matting (e.g., a built-in media player) 3. Fancy effects that affect performance (e.g., unnecessary animations that slow down the UI).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 components, image processing logic, and file handling), unit test coverage, and build process automation. Check for appropriate use of design patterns, code commenting, and proper error handling strategies.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 UI 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 and frequency of use) 4) Visual cues for active tools and modes.Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic tool 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) Brush follows cursor without perceptible lag (≤ 16ms) 2) Preview updates occur within 100ms of user action 3) Progress indicators for operations taking >500ms 4) Smooth transitions between different UI states.Deduct 5 points for each operation without feedback, 3 points for noticeable lag during brush operations, and 5 points for processing operations that block the UI thread. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "medium"
+}

package/library/multimedia_editing-image_editing/image-shadow-editor-tool.json

@@ -0,0 +1,68 @@
+{
+  "index": 593,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable for demonstration. Implement a front-end tool for adding shadows to images. After the user uploads an image, they should be able to set the shadow color, offset, and blur level. The image should display the shadow effect in real-time, and users should be able to save the processed image.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the image upload functionality fully implemented?",
+      "description": "Check if the code provides a complete file input system for image upload, including file type validation (only allowing image formats), proper error handling for invalid files, and visual feedback during the upload process. Score 0 if upload functionality is missing, 5 if basic upload works but lacks validation, and 10 if it includes comprehensive validation, error handling, and loading indicators.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the shadow customization controls properly implemented?",
+      "description": "Evaluate whether all required shadow customization options are available: color picker with alpha channel support, horizontal/vertical offset controls, blur radius adjustment, and spread radius control if applicable. Controls should have appropriate min/max values and step increments. Deduct 3 points for each missing control, 2 points if controls lack proper range limits, and 2 points if the UI doesn't provide visual cues for current values.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the real-time shadow preview work correctly?",
+      "description": "Verify that shadow changes are applied to the image in real-time without noticeable delay (<100ms). The preview should accurately reflect the final output. Deduct 5 points if the preview is delayed (>200ms), 5 points if the preview doesn't match the final output, and 5 points if the preview fails under certain parameter combinations.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the image saving functionality properly implemented?",
+      "description": "Check if users can save the processed image with the applied shadow effect as a common image format (PNG/JPEG). The saved image should maintain the shadow effect and original image quality. Deduct 5 points if saving is limited to screenshots, 5 points if the shadow effect is not preserved in the saved file, and 3 points if there are no options for image format or quality selection.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as large image files, unsupported formats, 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 shadow layering 2. Shadow presets/templates 3. History/undo functionality 4. Batch processing capabilities). 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 adjust the same shadow property) 2. Function modules unrelated to image shadow editing (e.g., unrelated filters) 3. Fancy effects that affect performance (e.g., unnecessary 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 controls/image processing/file handling), error handling coverage, and performance 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 there are no performance optimizations for large images. 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 control placement. 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) Shadow update delay ≤ 100ms 2) Smooth transitions when adjusting parameters 3) Clear visual indicators for active controls. Deduct 5 points for sluggish shadow updates, 3 points for jerky slider movements, and 5 points for confusing interface state feedback. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Multimedia Editing-Image Editing",
+  "difficulty": "easy"
+}