impro

custom_logger.py

@@ -0,0 +1,9 @@
+class LoggerConfig:
+    def info(self, msg):
+        print(f"INFO: {msg}")
+    def warning(self, msg):
+        print(f"WARNING: {msg}")
+    def error(self, msg):
+        print(f"ERROR: {msg}")
+
+logger_config = LoggerConfig()

image/convert.html

@@ -472,6 +472,16 @@
                             <option value="gif">GIF</option>
                         </select>
                     </div>
+                    <div class="setting-group">
+                        <label class="setting-label">Quality: <span id="quality-value">100</span>%</label>
+                        <input type="range" class="setting-input" id="quality-slider" min="1" max="100" value="100"
+                            style="padding: 0;">
+                    </div>
+                    <div class="setting-group">
+                        <label class="setting-label">Resize: <span id="scale-value">100</span>%</label>
+                        <input type="range" class="setting-input" id="scale-slider" min="10" max="100" value="100"
+                            step="10" style="padding: 0;">
+                    </div>
                 </div>
             </div>
 
@@ -505,6 +515,14 @@
         function secret_sauce_url() {
             return '/image/convert';
         }
+
+        // Update slider values
+        document.getElementById('quality-slider').addEventListener('input', function (e) {
+            document.getElementById('quality-value').textContent = e.target.value;
+        });
+        document.getElementById('scale-slider').addEventListener('input', function (e) {
+            document.getElementById('scale-value').textContent = e.target.value;
+        });
     </script>
 </body>
 

image/converter.py

@@ -50,12 +50,13 @@ class Converter(ImageBase):
             
         return self.supported_formats[format_clean]
     
-    def _get_optimal_save_settings(self, format_name: str) -> Dict:
+    def _get_optimal_save_settings(self, format_name: str, quality: int = 100) -> Dict:
         """
         Get optimal save settings for maximum quality preservation.
         
         Args:
             format_name: PIL format name (e.g., 'JPEG', 'PNG')
+            quality: Quality setting (1-100)
             
         Returns:
             Dictionary of save settings for the format
@@ -64,28 +65,28 @@ class Converter(ImageBase):
         
         if format_name == 'JPEG':
             settings = {
-                'quality': 100,        # Maximum quality
-                'optimize': False,     # Don't optimize (can reduce quality)
-                'progressive': False,  # Standard baseline JPEG
-                'subsampling': 0       # No chroma subsampling (4:4:4)
+                'quality': quality,
+                'optimize': True,
+                'progressive': True,
+                'subsampling': 0
             }
             
         elif format_name == 'PNG':
             settings = {
-                'optimize': False,     # Don't optimize to preserve exact quality
-                'compress_level': 1    # Minimal compression for maximum quality
+                'optimize': True,
+                'compress_level': 9 if quality < 100 else 1
             }
             
         elif format_name == 'WEBP':
             settings = {
-                'lossless': True,      # Lossless compression
-                'quality': 100,        # Maximum quality (for fallback)
-                'method': 6            # Best compression method
+                'lossless': quality == 100,
+                'quality': quality,
+                'method': 6
             }
             
         elif format_name == 'TIFF':
             settings = {
-                'compression': None    # No compression for perfect quality
+                'compression': 'tiff_lzw' if quality < 100 else None
             }
             
         elif format_name == 'BMP':
@@ -93,12 +94,12 @@ class Converter(ImageBase):
             
         elif format_name == 'GIF':
             settings = {
-                'optimize': False      # Don't optimize palette
+                'optimize': True
             }
             
         elif format_name == 'HEIC':
             settings = {
-                'quality': 100         # Maximum quality for HEIC
+                'quality': quality
             }
             
         return settings
@@ -215,13 +216,14 @@ class Converter(ImageBase):
         file_size = os.path.getsize(output_path)
         logger_config.info(f"✓ SVG file created: {file_size:,} bytes")
     
-    def _verify_conversion_quality(self, original_size: Tuple[int, int], output_path: str) -> bool:
+    def _verify_conversion_quality(self, original_size: Tuple[int, int], output_path: str, scale: float = 1.0) -> bool:
         """
         Verify that the converted image maintains original quality and dimensions.
         
         Args:
             original_size: Original image dimensions (width, height)
             output_path: Path to converted image
+            scale: Scale factor used
             
         Returns:
             True if verification passes
@@ -236,22 +238,28 @@ class Converter(ImageBase):
         file_size = os.path.getsize(output_path)
         logger_config.info(f"✓ Output file created: {file_size:,} bytes")
         
+        # Calculate expected size
+        expected_size = (int(original_size[0] * scale), int(original_size[1] * scale))
+        
         # Verify dimensions are preserved
         with Image.open(output_path) as verify_img:
-            if verify_img.size != original_size:
-                raise Exception(f"Dimensions changed! Expected: {original_size}, Got: {verify_img.size}")
+            # Allow for slight rounding differences (±1 pixel)
+            if abs(verify_img.size[0] - expected_size[0]) > 1 or abs(verify_img.size[1] - expected_size[1]) > 1:
+                raise Exception(f"Dimensions changed! Expected: {expected_size}, Got: {verify_img.size}")
             
-            logger_config.info(f"✓ Aspect ratio preserved: {verify_img.size}")
+            logger_config.info(f"✓ Dimensions verified: {verify_img.size}")
             
         return True
     
-    def convert_image(self, input_file_name: str, output_format: str) -> str:
+    def convert_image(self, input_file_name: str, output_format: str, quality: int = 100, scale: float = 1.0) -> str:
         """
         Convert an image to the specified format with maximum quality and ratio preservation.
         
         Args:
             input_file: Path to the input image file
             output_format: Target image format
+            quality: Quality setting (1-100)
+            scale: Scale factor (0.1-1.0)
             
         Returns:
             Path to the converted output file
@@ -268,7 +276,7 @@ class Converter(ImageBase):
             self._validate_input_file()
             target_format = self._validate_output_format(output_format)
             
-            logger_config.info(f"Starting conversion: {self.input_file_path}")
+            logger_config.info(f"Starting conversion: {self.input_file_path} (Quality: {quality}, Scale: {scale})")
             
             # Open and analyze original image
             with Image.open(self.input_file_path) as original_image:
@@ -281,9 +289,11 @@ class Converter(ImageBase):
                 # Convert color mode if necessary
                 converted_image = self._convert_color_mode(original_image, target_format)
                 
-                # Verify size preservation (safety check)
-                if converted_image.size != original_size:
-                    raise Exception(f"Size changed during conversion! Original: {original_size}, Current: {converted_image.size}")
+                # Apply scaling if needed
+                if scale < 1.0:
+                    new_size = (int(original_size[0] * scale), int(original_size[1] * scale))
+                    logger_config.info(f"Resizing image to {new_size}")
+                    converted_image = converted_image.resize(new_size, Image.Resampling.LANCZOS)
                 
                 # Generate output path
                 output_path = self._generate_output_path(output_format)
@@ -291,22 +301,22 @@ class Converter(ImageBase):
                 # Handle SVG conversion specially
                 if target_format == 'SVG':
                     logger_config.info(f"Converting to SVG (embedding as base64)")
-                    self._convert_to_svg(converted_image, output_path, original_size)
+                    self._convert_to_svg(converted_image, output_path, converted_image.size)
                 else:
                     # Get optimal save settings
-                    save_settings = self._get_optimal_save_settings(target_format)
+                    save_settings = self._get_optimal_save_settings(target_format, quality)
                     
                     # Preserve metadata
                     metadata = self._preserve_metadata(original_image, target_format)
                     save_settings.update(metadata)
                     
-                    logger_config.info(f"Converting to {target_format} with maximum quality")
+                    logger_config.info(f"Converting to {target_format} with quality {quality}")
                     
                     # Perform conversion with quality preservation
                     converted_image.save(output_path, format=target_format, **save_settings)
                     
                     # Verify conversion quality
-                    self._verify_conversion_quality(original_size, output_path)
+                    self._verify_conversion_quality(original_size, output_path, scale)
 
                 logger_config.info(f"✓ Conversion completed successfully: {output_path}")
                 return output_path
@@ -318,4 +328,4 @@ class Converter(ImageBase):
 # Example usage
 if __name__ == "__main__":
     converter = Converter()
-    converter.convert_image("image/test.HEIC", "png")
+    converter.convert_image("image/test.HEIC", "png", quality=80, scale=0.5)

image/javascript/image.js

@@ -414,7 +414,9 @@ async function upload(file) {
 
 function getSettingsData() {
 	return {
-		to_format: document.getElementById('output-format')?.value
+		to_format: document.getElementById('output-format')?.value,
+		quality: document.getElementById('quality-slider')?.value,
+		scale: document.getElementById('scale-slider')?.value ? document.getElementById('scale-slider').value / 100 : null
 	};
 }
 

main.py

@@ -192,7 +192,9 @@ async def upload_image(
 @app.post("/image/convert")
 async def convert_image(
     id: str = Form(...),
-    to_format: str = Form(...)
+    to_format: str = Form(...),
+    quality: int = Form(100),
+    scale: float = Form(1.0)
 ):
     try:
         # Check if input is SVG - PIL cannot read SVG files
@@ -200,7 +202,7 @@ async def convert_image(
             raise ValueError("SVG files cannot be converted. SVG is only available as an output format.")
         
         converter = Converter()
-        output_path = converter.convert_image(id, to_format)
+        output_path = converter.convert_image(id, to_format, quality=quality, scale=scale)
         
         # Check if conversion failed
         if output_path is None:

test_convert_options.py

@@ -0,0 +1,41 @@
+import requests
+import os
+
+url = "http://localhost:8000/image/convert"
+input_dir = "image/input"
+file_path = os.path.join(input_dir, "test_quality.jpg")
+output_dir = "image/output"
+
+# Ensure directories exist
+os.makedirs(input_dir, exist_ok=True)
+os.makedirs(output_dir, exist_ok=True)
+
+# Create test image
+from PIL import Image
+Image.new('RGB', (100, 100), color='red').save(file_path)
+
+# Test case 1: Quality 50, Scale 0.5
+data = {
+    "id": "test_quality.jpg",
+    "to_format": "jpg",
+    "quality": 50,
+    "scale": 0.5
+}
+
+try:
+    response = requests.post(url, data=data)
+    if response.status_code == 200:
+        result = response.json()
+        print(f"Success: {result}")
+        
+        # Verify output file
+        output_file = os.path.join(output_dir, result['new_filename'])
+        if os.path.exists(output_file):
+            print(f"Output file created: {output_file}")
+            print(f"Output file size: {os.path.getsize(output_file)} bytes")
+        else:
+            print("Error: Output file not found")
+    else:
+        print(f"Failed: {response.status_code} - {response.text}")
+except Exception as e:
+    print(f"Error: {e}")