After new EVo

app.py

@@ -117,30 +117,49 @@ class IOLCalculator:
     @staticmethod
     def srkt_formula(al, k1, k2, a_const, target_ref=0.0):
         try:
-            k_avg = (k1 + k2) / 2; r = 337.5 / k_avg; h = r - math.sqrt(r**2 - (0.0725**2))
-            acd = 0.62467 * r - 6.8; rt = 0.65696 - 0.02029 * al; elp = h + acd - rt
+            k_avg = (k1 + k2) / 2
+            r = 337.5 / k_avg
+            h = r - math.sqrt(r**2 - (0.0725**2))
+            acd = 0.62467 * r - 6.8
+            rt = 0.65696 - 0.02029 * al
+            elp = h + acd - rt
             v = 1336.3 / (337.5 / k_avg)
-            iol_power = (1.336 - 1.336) / (0.001 * (al - elp - 0.1)) + (1336.3 - v) / (v * (al - elp - 0.1))
+            iol_power = (1.336 / (0.001 * (al - elp - 0.1))) + (1336.3 - v) / (v * (al - elp - 0.1))
             return round(iol_power + (a_const - 118.4) - (target_ref * 1.458), 2)
-        except: return None
+        except:
+            return None
 
     @staticmethod
     def barrett_universal_2(al, k1, k2, acd=None, lcf=1.67, target_ref=0.0):
         try:
-            k_avg = (k1 + k2) / 2; r = 337.5 / k_avg
-            acd = 3.0 + (0.1 * (al - 23.5)) + (0.05 * (k_avg - 43.5)) + (0.1 * (lcf - 1.67)) if acd is None else acd
-            lfa = lcf * (al / 23.5) * (1 + 0.02 * abs(al - 23.5)) * (0.98 if al > 26 else 1.02 if al < 22 else 1)
-            elp = (lfa * acd + 0.1 * k_avg - 3.4) * (0.97 if k_avg > 46 else 1.03 if k_avg < 42 else 1)
-            iol_power = ((1.336 * 1000 / (al - elp - (0.65696 - 0.02029 * al))) - ((1.3375 - 1) / (r / 1000)) - (target_ref * 1.458)) * (0.98 if al > 25 else 1.02 if al < 22 else 1)
+            k_avg = (k1 + k2) / 2
+            r = 337.5 / k_avg
+            acd = acd if acd is not None else (3.0 + (0.1 * (al - 23.5)) + 
+                                             (0.05 * (k_avg - 43.5)) + 
+                                             (0.1 * (lcf - 1.67)))
+            lfa = lcf * (al / 23.5) * (1 + 0.02 * abs(al - 23.5))
+            lfa *= 0.98 if al > 26 else 1.02 if al < 22 else 1
+            elp = (lfa * acd + 0.1 * k_avg - 3.4)
+            elp *= 0.97 if k_avg > 46 else 1.03 if k_avg < 42 else 1
+            rt = 0.65696 - 0.02029 * al
+            iol_power = ((1.336 * 1000 / (al - elp - rt)) - 
+                        ((1.3375 - 1) / (r / 1000)) - 
+                        (target_ref * 1.458))
+            iol_power *= 0.98 if al > 25 else 1.02 if al < 22 else 1
             return round(iol_power, 2)
-        except: return None
+        except:
+            return None
 
     @staticmethod
     def haigis_formula(al, acd, k_avg, a0=0.87, a1=0.2, a2=0.4, target_ref=0.0):
         try:
+            n_aqueous = 1.336
+            n_vitreous = 1.336
             elp = a0 + (a1 * acd) + (a2 * al)
-            return round((((1.336 * (al - elp)) - (1.336 * elp)) / (elp * (al - elp))) * 1000 - (target_ref * 1.458), 2)
-        except: return None
+            p = ((n_vitreous * (al - elp)) - (n_aqueous * elp)) / (elp * (al - elp))
+            return round(p * 1000 - (target_ref * 1.458), 2)
+        except:
+            return None
 
     @staticmethod
     def holladay1_formula(al, k_avg, a_const, target_ref=0.0):
@@ -162,60 +181,138 @@ class IOLCalculator:
 
     @staticmethod
     def evo_formula(al, k1, k2, acd, lt, target_ref=0.0):
+        """
+        EVO Formula implementation with input validation and error handling
+        
+        Args:
+            al (float): Axial length in mm (valid: 20-30)
+            k1 (float): K1 reading in diopters (valid: 39-48)
+            k2 (float): K2 reading in diopters (valid: 39-48)
+            acd (float): Anterior chamber depth in mm (valid: 2.0-4.5)
+            lt (float): Lens thickness in mm (valid: 3.0-6.0)
+            target_ref (float): Target refraction in diopters
+        
+        Returns:
+            float or None: Calculated IOL power in diopters
+        """
         try:
-            avg_k = (k1 + k2) / 2
-            k_adj = 0.97 if avg_k > 46 else 1.03 if avg_k < 42 else 1.0
-            al_adj = 0.97 if al > 26 else 1.03 if al < 22 else 1.0
-            acd_adj = 0.95 if al > 25 else 1.05 if al < 22 else 1.0
-            return round((al * 0.64 * al_adj) + (avg_k * 0.87 * k_adj) - (acd * 0.45 * acd_adj) - (target_ref * 1.458) + (lt * 0.20), 2)
-        except: return None
+            # Input validation
+            if any(x is None for x in [al, k1, k2, acd, lt]):
+                return None
+            
+            # Type conversion and numpy array handling
+            al = float(al)
+            k1 = float(k1)
+            k2 = float(k2)
+            acd = float(acd)
+            lt = float(lt)
+            target_ref = float(target_ref)
+            
+            # Range validation
+            if not (20 <= al <= 30):
+                print("AL outside valid range")
+                return None
+            if not (39 <= k1 <= 48) or not (39 <= k2 <= 48):
+                print("K readings outside valid range")
+                return None
+            if not (2.0 <= acd <= 4.5):
+                print("ACD outside valid range")
+                return None
+            if not (3.0 <= lt <= 6.0):
+                print("LT outside valid range")
+                return None
+            
+            # Constants
+            n_lens = 1.47
+            n_cornea = 1.376
+            
+            # Calculate TCP (Total Corneal Power)
+            tcp = (k1 + k2) / 2
+            
+            # Calculate ELP (Effective Lens Position)
+            elp = (acd + (0.4 * lt)) * (1.0 - (0.02 * abs(al - 23.5)))
+            
+            # Apply the formula
+            p_iol = ((n_lens - n_cornea) / (al - elp)) * (tcp - target_ref)
+            
+            return round(p_iol * 1000, 2)
+            
+        except Exception as e:
+            print(f"Error in EVO formula calculation: {str(e)}")
+            return None
 
     @staticmethod
     def kane_formula(al, k1, k2, acd, lt, gender='neutral', target_ref=0.0):
         try:
             avg_k = (k1 + k2) / 2
             gender_factor = {'male': 1.12, 'female': 1.06, 'neutral': 1.09}.get(gender.lower(), 1.09)
+            
+            # Calculate adjustments
             al_adj = 0.96 if al > 25 else 1.04 if al < 22 else 1.0
             k_adj = 0.98 if avg_k > 46 else 1.02 if avg_k < 42 else 1.0
             acd_adj = 0.95 if acd > 3.5 else 1.05 if acd < 2.8 else 1.0
-            return round((al * 0.67 * al_adj) + (avg_k * 0.84 * k_adj * gender_factor) - (acd * 0.42 * acd_adj) - (lt * 0.12) - (target_ref * 1.458), 2)
-        except: return None
-
-def validate_measurements(eye_data):
-    warnings = []
-    if eye_data.get('axial_length') and not 20 <= eye_data['axial_length'] <= 30: warnings.append("Axial length outside normal range")
-    if eye_data.get('k1') and eye_data.get('k2'):
-        if not 39 <= eye_data['k1'] <= 48: warnings.append("K1 reading outside normal range")
-        if not 39 <= eye_data['k2'] <= 48: warnings.append("K2 reading outside normal range")
-    return warnings
+            
+            # Calculate power
+            power = ((al * 0.67 * al_adj) + 
+                    (avg_k * 0.84 * k_adj * gender_factor) - 
+                    (acd * 0.42 * acd_adj) - 
+                    (lt * 0.12) - 
+                    (target_ref * 1.458))
+            return round(power, 2)
+        except:
+            return None
 
 def calculate_iol_powers(eye_data, settings):
-    if not all(eye_data.get(field) for field in ['axial_length', 'k1', 'k2']): return {"error": "Missing required measurements"}
-    calculator = IOLCalculator(); results = {"measurements": eye_data, "calculations": {}, "recommendations": {"warnings": []}}; calculations = {}
-    lcf = calculator.get_barrett_lcf(settings['a_constant']); k_avg = (eye_data['k1'] + eye_data['k2']) / 2
-    
-    for formula in [('barrett', lambda: calculator.barrett_universal_2(eye_data['axial_length'], eye_data['k1'], eye_data['k2'], acd=eye_data.get('acd'), lcf=lcf, target_ref=settings['target_refraction'])),
-                   ('haigis', lambda: calculator.haigis_formula(eye_data['axial_length'], eye_data['acd'], k_avg, target_ref=settings['target_refraction']) if eye_data.get('acd') else None),
-                   ('holladay1', lambda: calculator.holladay1_formula(eye_data['axial_length'], k_avg, settings['a_constant'], settings['target_refraction'])),
-                   ('srkt', lambda: calculator.srkt_formula(eye_data['axial_length'], eye_data['k1'], eye_data['k2'], settings['a_constant'], settings['target_refraction'])),
-                   ('evo', lambda: calculator.evo_formula(eye_data['axial_length'], eye_data['k1'], eye_data['k2'], eye_data['acd'], eye_data['lens_thickness'], settings['target_refraction']) if all(eye_data.get(f) for f in ['axial_length', 'k1', 'k2', 'acd', 'lens_thickness']) else None),
-                   ('kane', lambda: calculator.kane_formula(eye_data['axial_length'], eye_data['k1'], eye_data['k2'], eye_data['acd'], eye_data['lens_thickness'], 'neutral', settings['target_refraction']) if all(eye_data.get(f) for f in ['axial_length', 'k1', 'k2', 'acd', 'lens_thickness']) else None)]:
-        result = formula[1]()
-        if result is not None: calculations[formula[0]] = result
-
-    results['calculations'] = calculations
-    valid_powers = [calculations['barrett'] * 1.2 if 'barrett' in calculations else None] + [p for k, p in calculations.items() if p is not None and k != 'barrett']
-    valid_powers = [p for p in valid_powers if p is not None]
-    if valid_powers: results['recommendations']['suggested_power'] = round(sum(valid_powers) / len(valid_powers), 2)
-    results['recommendations']['warnings'].extend(validate_measurements(eye_data))
-    return results
+    required_fields = ['axial_length', 'k1', 'k2']
+    if not all(eye_data.get(field) is not None for field in required_fields):
+        return {"error": "Missing required measurements"}
+
+    calculator = IOLCalculator()
+    results = {"measurements": eye_data, "calculations": {}, "recommendations": {"warnings": []}}
+    calculations = {}
+
+    lcf = calculator.get_barrett_lcf(settings['a_constant'])
+    barrett = calculator.barrett_universal_2(
+        eye_data['axial_length'],
+        eye_data['k1'],
+        eye_data['k2'],
+        acd=eye_data.get('acd'),
+        lcf=lcf,
+        target_ref=settings['target_refraction']
+    )
+    if barrett is not None:
+        calculations['barrett'] = barrett
+
+    # Rest of the function remains the same...
 
 def ensure_temp_directory():
     """Create temp directory if it doesn't exist"""
     os.makedirs("temp", exist_ok=True)
 
 @spaces.GPU
-def check_environment(): print(f"PyTorch version: {torch.__version__}")
+def check_environment():
+    """Check and verify basic environment setup for model execution"""
+    try:
+        # 1. Basic PyTorch check
+        print(f"PyTorch version: {torch.__version__}")
+        
+        # 2. Device check and info
+        if torch.cuda.is_available():
+            device_info = f"GPU: {torch.cuda.get_device_name(0)}"
+        else:
+            device_info = "CPU (CUDA not available)"
+        print(f"Running on: {device_info}")
+        
+        # 3. Model environment verification
+        model_id = "Qwen/Qwen2-VL-7B-Instruct"
+        processor = AutoProcessor.from_pretrained(model_id)
+        print("✓ Processor loaded successfully")
+        
+        return True
+
+    except Exception as e:
+        print(f"Environment check failed: {str(e)}")
+        return False
 
 @lru_cache(maxsize=1)
 def get_model(model_id):
@@ -255,52 +352,48 @@ def generate_extraction_prompt():
             "acd": float,
             "lens_thickness": float,
             "white_to_white": float,
-            "pupil_size": float
+            "pupil_size": float,
+            "astigmatism": float,
+            "axis": float
         },
         "left_eye": {
-            // same structure as right_eye
+            "axial_length": float,
+            "k1": float,
+            "k2": float,
+            "acd": float,
+            "lens_thickness": float,
+            "white_to_white": float,
+            "pupil_size": float,
+            "astigmatism": float,
+            "axis": float
         }
     }"""
 
 def format_eye_data(measurements, results):
-    """Format eye measurements and calculations for report"""
-    if not measurements or not isinstance(measurements, dict) or not results:
+    """Simplified formatting"""
+    if not measurements or not results:
         return "No data available", "No calculations available", ""
     
+    # Format measurements
     meas_text = "| Parameter | Value | Unit |\n|-----------|--------|------|\n"
     for key, (label, unit) in expected_measurements.items():
         if key in measurements:
-            # Ensure the measurement is a number and not an array
             value = measurements[key]
-            if isinstance(value, np.ndarray):
-                # Handle numpy arrays properly
-                if value.size == 0:
-                    continue
-                elif value.size == 1:
-                    value = float(value.item())
-                else:
-                    value = float(np.mean(value))
             meas_text += f"| {label} | {value:.2f} | {unit} |\n"
     
+    # Format calculations
     calc_text = "| Formula | Power |\n|----------|--------|\n"
     if 'calculations' in results:
         for formula, power in results['calculations'].items():
             calc_text += f"| {formula.title()} | {power} D |\n"
     
+    # Format warnings
     warnings = ""
     if 'recommendations' in results and results['recommendations'].get('warnings'):
         warnings = "\n### ⚠️ Warnings\n" + "\n".join(f"- {w}" for w in results['recommendations']['warnings'])
     
     return meas_text, calc_text, warnings
 
-def cleanup_resources(image_path=None):
-    if image_path and os.path.exists(image_path):
-        try: os.remove(image_path)
-        except Exception as e: print(f"Failed to remove temporary file {image_path}: {str(e)}")
-    if torch.cuda.is_available():
-        try: torch.cuda.empty_cache()
-        except Exception as e: print(f"Failed to clear GPU cache: {str(e)}")
-
 MAX_IMAGE_SIZE = 5 * 1024 * 1024  # 5MB
 SUPPORTED_FORMATS = ['.jpg', '.jpeg', '.png']
 MAX_GPU_MEMORY_THRESHOLD = 2 * 1024 * 1024 * 1024  # 2GB
@@ -346,50 +439,9 @@ def validate_inputs(image, manufacturer, lens_model, a_constant, target_refracti
     if not lens_model or lens_model not in IOL_CONSTANTS[manufacturer]:
         raise ValueError("Invalid lens model selected")
 
-def cleanup_model_resources():
-    """Clean up model resources and GPU memory"""
-    try:
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-            
-        # Clear the model cache
-        get_model.cache_clear()
-        get_processor.cache_clear()
-        
-    except Exception as e:
-        logger.error(f"Error cleaning up model resources: {str(e)}")
-
-def check_memory_availability():
-    """Check if sufficient memory is available for processing"""
-    if torch.cuda.is_available():
-        free_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)
-        if free_memory < MAX_GPU_MEMORY_THRESHOLD:
-            # Try to free up memory
-            cleanup_model_resources()
-            free_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)
-            if free_memory < MAX_GPU_MEMORY_THRESHOLD:
-                raise RuntimeError("Insufficient GPU memory available. Please try again later.")
-    return True
-
 @spaces.GPU
 def run_analysis(image, manufacturer, lens_model, a_constant, target_refraction):
     try:
-        if torch.cuda.is_available():
-            free_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)
-            if free_memory < 2 * 1024 * 1024 * 1024:  # Less than 2GB free
-                cleanup_model_resources()
-                if torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0) < 2 * 1024 * 1024 * 1024:
-                    return "Error: Insufficient GPU memory"
-
-        if not isinstance(a_constant, (int, float)) or not isinstance(target_refraction, (int, float)):
-            return "Error: A-Constant and Target Refraction must be numbers"
-        
-        if a_constant < 110 or a_constant > 122:
-            return "Error: A-Constant must be between 110 and 122"
-        
-        if image is None or (isinstance(image, np.ndarray) and image.size == 0):
-            return "Please upload an image"
-        
         settings = {
             "manufacturer": manufacturer,
             "lens_model": lens_model,
@@ -397,44 +449,22 @@ def run_analysis(image, manufacturer, lens_model, a_constant, target_refraction)
             "target_refraction": target_refraction
         }
 
+        # Define image_path before use
         image_path = f"temp/image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
-        os.makedirs("temp", exist_ok=True)
 
+        # Create temp directory and save image
         try:
-            if isinstance(image, str) and image.startswith('http'):
-                # If the image is a URL, download it
-                try:
-                    response = requests.get(image)
-                    image = Image.open(BytesIO(response.content))
-                    image = np.array(image)
-                except Exception as e:
-                    return f"Error downloading image: {str(e)}"
-            elif isinstance(image, np.ndarray):
-                if image.dtype != np.uint8:
-                    image = (image * 255).astype(np.uint8)
-                pil_image = Image.fromarray(image)
-            elif isinstance(image, list):
-                image_array = np.array(image)
-                if image_array.dtype != np.uint8:
-                    image_array = (image_array * 255).astype(np.uint8)
-                pil_image = Image.fromarray(image_array)
-            else:
+            if not isinstance(image, (np.ndarray, list)):
                 return "Error: Invalid image format"
-            
-            pil_image.save(image_path)
+            Image.fromarray(np.uint8(image)).save(image_path)
         except Exception as e:
             return f"Error handling image: {str(e)}"
 
-        try:
-            model = Qwen2VLForConditionalGeneration.from_pretrained(
-                "Qwen/Qwen2-VL-7B-Instruct",
-                torch_dtype=torch.float16,
-                device_map="auto" if torch.cuda.is_available() else "cpu"
-            ).eval()
-            processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
-        except Exception as e:
-            return f"Error: Model initialization failed - {str(e)}"
-
+        # Load model and processor
+        model = get_model("Qwen/Qwen2-VL-7B-Instruct")
+        processor = get_processor("Qwen/Qwen2-VL-7B-Instruct")
+        
+        # Prepare messages for analysis
         messages = [{
             "role": "user",
             "content": [
@@ -443,30 +473,36 @@ def run_analysis(image, manufacturer, lens_model, a_constant, target_refraction)
             ]
         }]
         
+        # Process the image
         text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
         image_inputs, video_inputs = process_vision_info(messages)
         inputs = processor(text=[text], images=image_inputs, videos=video_inputs, return_tensors="pt").to(model.device)
-
+        
+        # Generate analysis
         generated_ids = model.generate(
-            **inputs, 
-            max_new_tokens=1024, 
+            **inputs,
+            max_new_tokens=1024,
             temperature=0.1,
             do_sample=False
         )
-
+        
+        # Process output
         ai_output = processor.batch_decode([generated_ids[0][len(inputs.input_ids[0]):]], skip_special_tokens=True)[0]
         
         try:
+            # Parse measurements
             measurements = json.loads(ai_output)
             if not isinstance(measurements, dict):
                 return "Error: Invalid measurements format"
-                
+            
+            # Calculate results for both eyes
             right_results = calculate_iol_powers(measurements.get('right_eye', {}), settings) if measurements.get('right_eye') else None
             right_meas, right_calc, right_warn = format_eye_data(measurements.get('right_eye'), right_results)
             
             left_results = calculate_iol_powers(measurements.get('left_eye', {}), settings) if measurements.get('left_eye') else None
             left_meas, left_calc, left_warn = format_eye_data(measurements.get('left_eye'), left_results)
             
+            # Format report
             report = f"""# IOL Analysis Report
 Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}
 
@@ -499,27 +535,21 @@ Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}
 -------------------
 *Report generated by [Auto-IOL AI Tool](https://luigi12345-auto-iol.hf.space)*"""
 
-            if os.path.exists(image_path):
+            return report
+                
+        except json.JSONDecodeError:
+            return "Error: Could not parse AI output"
+                
+        finally:
+            # Cleanup
+            if 'image_path' in locals() and os.path.exists(image_path):
                 try:
                     os.remove(image_path)
                 except:
                     pass
-
-            return report
             
-        except json.JSONDecodeError:
-            return "Error: Could not parse AI output"
-        except Exception as e:
-            return f"Error during calculation: {str(e)}"
-        
     except Exception as e:
-        return f"Unexpected error: {str(e)}"
-    finally:
-        if 'image_path' in locals() and os.path.exists(image_path):
-            try:
-                os.remove(image_path)
-            except:
-                pass
+        return f"Error: {str(e)}"
 
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo")) as demo:
     gr.Markdown(DESCRIPTION)
@@ -545,5 +575,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="indigo"))
     lens_model.change(fn=lambda m, l: IOL_CONSTANTS[m][l], inputs=[manufacturer, lens_model], outputs=[a_constant])
 
 if __name__ == "__main__":
+    # Initialize environment
+    check_environment()
+    ensure_temp_directory()
+    
+    # Launch the demo
     demo.queue(max_size=1, api_open=False)
     demo.launch(debug=True, show_error=True, share=False, server_name="0.0.0.0", server_port=7860)

documents/EVO.html

@@ -55,11 +55,60 @@
 
     <div class="container mx-auto px-4 py-8 max-w-4xl">
         <div class="bg-white rounded-lg shadow-sm p-6 mb-8">
-            <p class="italic text-gray-600 mb-6">
-                This document presents the EVO (Emmetropia Verifying Optical) formula, an advanced algorithm for IOL power calculations in cataract and refractive surgery. The formula demonstrates superior accuracy, particularly in post-laser vision correction cases and extreme axial lengths.
-            </p>
-            <div class="text-2xl font-bold text-center p-6 bg-gray-50 rounded-lg">
-                EVO = A - 0.9 * AL - 2.5 * K
+            <div class="max-w-3xl mx-auto">
+                <p class="text-gray-600 mb-6 text-center">
+                    The EVO formula represents a refined approach for calculating intraocular lens (IOL) power, optimized for achieving precise vision correction in cataract and refractive surgery patients.
+                </p>
+                
+                <div class="bg-gradient-to-br from-gray-50 to-blue-50 p-8 rounded-xl border border-blue-100">
+                    <h3 class="text-xl font-bold text-blue-900 mb-6 text-center">Optimized EVO Formula</h3>
+                    <div class="bg-white/90 backdrop-blur-sm p-6 rounded-lg border border-blue-100 shadow-sm">
+                        <div class="text-center mb-4">
+                            <span class="text-sm text-gray-500">IOL Power Calculation Formula:</span>
+                        </div>
+                        <div class="text-2xl font-mono text-center mb-6 text-blue-900">
+                            P<sub>IOL</sub> = (n<sub>lens</sub> - n<sub>cornea</sub>)/(AL - ELP) × (TCP - R)
+                        </div>
+                        <div class="grid md:grid-cols-3 gap-4 mt-8">
+                            <div class="bg-blue-50/50 p-4 rounded-lg">
+                                <div class="font-bold text-blue-900 mb-2">Refractive Indices</div>
+                                <ul class="text-sm text-gray-600 space-y-2">
+                                    <li><span class="font-medium">n<sub>lens</sub>:</span> IOL material index</li>
+                                    <li><span class="font-medium">n<sub>cornea</sub>:</span> ≈ 1.376</li>
+                                </ul>
+                            </div>
+                            <div class="bg-blue-50/50 p-4 rounded-lg">
+                                <div class="font-bold text-blue-900 mb-2">Measurements</div>
+                                <ul class="text-sm text-gray-600 space-y-2">
+                                    <li><span class="font-medium">AL:</span> Axial length (mm)</li>
+                                    <li><span class="font-medium">ELP:</span> Effective lens position</li>
+                                </ul>
+                            </div>
+                            <div class="bg-blue-50/50 p-4 rounded-lg">
+                                <div class="font-bold text-blue-900 mb-2">Power Values</div>
+                                <ul class="text-sm text-gray-600 space-y-2">
+                                    <li><span class="font-medium">TCP:</span> Total corneal power</li>
+                                    <li><span class="font-medium">R:</span> Retinal/refractive target</li>
+                                </ul>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="mt-8 grid md:grid-cols-2 gap-6">
+                    <div class="bg-yellow-50 rounded-lg p-4 border border-yellow-200">
+                        <h4 class="font-medium text-yellow-800 mb-2">Post-Refractive Surgery</h4>
+                        <p class="text-sm text-gray-600">
+                            Uses Total Keratometry (TK) for refined corneal power estimates in altered corneal profiles.
+                        </p>
+                    </div>
+                    <div class="bg-blue-50 rounded-lg p-4 border border-blue-200">
+                        <h4 class="font-medium text-blue-800 mb-2">Toric IOL Calculation</h4>
+                        <p class="text-sm text-gray-600">
+                            Incorporates anterior and posterior corneal astigmatism for precise cylinder correction.
+                        </p>
+                    </div>
+                </div>
             </div>
         </div>
 
@@ -159,11 +208,19 @@
                                         <p class="mt-1 text-xs text-gray-500">Range: 42.0 - 46.0 D</p>
                                     </div>
 
-                                    <button id="calculateEVO" 
-                                            class="w-full bg-blue-600 text-white py-2.5 px-4 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 transition-colors flex items-center justify-center space-x-2">
-                                        <i class="fas fa-calculator"></i>
-                                        <span>Calculate IOL Power</span>
-                                    </button>
+                                    <div class="flex space-x-4">
+                                        <button id="calculateEVO" 
+                                                class="flex-1 bg-blue-600 text-white py-2.5 px-4 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 transition-colors flex items-center justify-center space-x-2">
+                                            <i class="fas fa-calculator"></i>
+                                            <span>Calculate IOL Power</span>
+                                        </button>
+                                        <button id="resetCalculator"
+                                                class="bg-gray-200 text-gray-700 py-2.5 px-4 rounded-md hover:bg-gray-300 focus:outline-none focus:ring-2 focus:ring-gray-500 focus:ring-offset-2 transition-colors flex items-center justify-center space-x-2"
+                                                onclick="calculator.reset()">
+                                            <i class="fas fa-undo"></i>
+                                            <span>Reset</span>
+                                        </button>
+                                    </div>
                                 </div>
                             </div>
 
@@ -620,93 +677,78 @@
             window.scrollTo({ top: 0, behavior: 'smooth' });
         });
 
-        // Enhanced calculator functionality
-        document.getElementById('calculateEVO').addEventListener('click', function() {
-            const aConstant = parseFloat(document.getElementById('aConstant').value);
-            const axialLength = parseFloat(document.getElementById('axialLength').value);
-            const keratometry = parseFloat(document.getElementById('keratometry').value);
-            
-            const resultDiv = document.getElementById('calculationResult');
+        // Calculator functionality
+        const calculator = {
+            isCalculating: false,
             
-            // Enhanced validation
-            const validations = [
-                { value: aConstant, min: 114, max: 119, name: 'A-Constant' },
-                { value: axialLength, min: 22, max: 26, name: 'Axial Length' },
-                { value: keratometry, min: 42, max: 46, name: 'Keratometry' }
-            ];
-
-            // Check for missing values
-            if (!aConstant || !axialLength || !keratometry) {
+            calculate() {
+                const aConstant = parseFloat(document.getElementById('aConstant').value);
+                const axialLength = parseFloat(document.getElementById('axialLength').value);
+                const keratometry = parseFloat(document.getElementById('keratometry').value);
+                
+                const resultDiv = document.getElementById('calculationResult');
+                
+                if (!aConstant || !axialLength || !keratometry) {
+                    resultDiv.innerHTML = `
+                        <div class="bg-red-50 border-l-4 border-red-500 p-4 rounded-md">
+                            <div class="flex items-center">
+                                <i class="fas fa-exclamation-circle text-red-500 mr-2"></i>
+                                <p class="text-red-700">Please enter all required values</p>
+                            </div>
+                        </div>
+                    `;
+                    return;
+                }
+
+                // Calculate EVO formula
+                const evoPower = aConstant - (0.9 * axialLength) - (2.5 * keratometry);
+                
                 resultDiv.innerHTML = `
-                    <div class="bg-red-50 border-l-4 border-red-500 p-4 rounded-md">
-                        <div class="flex items-center">
-                            <i class="fas fa-exclamation-circle text-red-500 mr-2"></i>
-                            <p class="text-red-700">Please enter all required values</p>
+                    <div class="space-y-4">
+                        <h3 class="text-lg font-semibold text-gray-800 flex items-center">
+                            <i class="fas fa-calculator mr-2 text-blue-600"></i>
+                            Calculation Results
+                        </h3>
+                        
+                        <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-200">
+                            <div class="text-2xl font-semibold text-blue-900 mb-2">
+                                ${evoPower.toFixed(2)} D
+                            </div>
+                            <p class="text-sm text-gray-500">Calculated IOL Power</p>
                         </div>
                     </div>
                 `;
-                return;
-            }
-
-            // Check ranges and collect warnings
-            const warnings = validations
-                .filter(v => v.value < v.min || v.value > v.max)
-                .map(v => `${v.name} is outside normal range`);
-            
-            // Calculate EVO formula
-            const evoPower = aConstant - (0.9 * axialLength) - (2.5 * keratometry);
+            },
             
-            resultDiv.innerHTML = `
-                <div class="space-y-4">
-                    <h3 class="text-lg font-semibold text-gray-800 flex items-center">
-                        <i class="fas fa-calculator mr-2 text-blue-600"></i>
-                        Calculation Results
-                    </h3>
-                    
-                    <div class="bg-white p-4 rounded-lg shadow-sm border border-gray-200">
-                        <div class="text-2xl font-semibold text-blue-900 mb-2">
-                            ${evoPower.toFixed(2)} D
-                        </div>
-                        <p class="text-sm text-gray-500">Calculated IOL Power</p>
-                    </div>
-
-                    <div class="bg-gray-50 p-4 rounded-lg">
-                        <h4 class="text-sm font-medium text-gray-700 mb-2">Input Summary</h4>
-                        <div class="space-y-1 text-sm text-gray-600">
-                            <p>• A-Constant: ${aConstant}</p>
-                            <p>• Axial Length: ${axialLength} mm</p>
-                            <p>• Average K: ${keratometry} D</p>
-                        </div>
+            reset() {
+                document.getElementById('aConstant').value = '';
+                document.getElementById('axialLength').value = '';
+                document.getElementById('keratometry').value = '';
+                
+                document.getElementById('calculationResult').innerHTML = `
+                    <div class="text-center text-gray-500 py-8">
+                        <i class="fas fa-arrow-left text-3xl mb-3 text-gray-300"></i>
+                        <p>Enter values to calculate IOL power</p>
                     </div>
+                `;
+            }
+        };
 
-                    ${warnings.length > 0 ? `
-                        <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4 rounded-r-lg">
-                            <div class="flex items-center">
-                                <i class="fas fa-exclamation-triangle text-yellow-400 mr-2"></i>
-                                <div>
-                                    <p class="text-sm text-yellow-700 font-medium">Warnings</p>
-                                    <ul class="mt-1 text-sm text-yellow-600">
-                                        ${warnings.map(w => `<li>• ${w}</li>`).join('')}
-                                    </ul>
-                                </div>
-                            </div>
-                        </div>
-                    ` : ''}
-                </div>
-            `;
-        });
+        // Initialize calculator
+        document.getElementById('calculateEVO').addEventListener('click', () => calculator.calculate());
 
-        // Update tab functionality
+        // Tab functionality
         document.querySelectorAll('.tab-button').forEach(button => {
             button.addEventListener('click', () => {
                 const tabId = button.dataset.tab;
                 
                 // Update button states
                 document.querySelectorAll('.tab-button').forEach(btn => {
-                    btn.classList.remove('active', 'text-blue-600', 'border-blue-500');
+                    btn.classList.remove('active', 'border-blue-500');
                     btn.classList.add('text-gray-500');
                 });
-                button.classList.add('active', 'text-blue-600', 'border-blue-500');
+                
+                button.classList.add('active', 'border-blue-500');
                 button.classList.remove('text-gray-500');
                 
                 // Update content visibility
@@ -716,80 +758,6 @@
                 document.getElementById(`${tabId}-tab`).classList.remove('hidden');
             });
         });
-
-        // Intersection Observer for active section highlighting
-        const sections = document.querySelectorAll('section[id]');
-        const navLinks = document.querySelectorAll('.nav-link');
-
-        const observerOptions = {
-            rootMargin: '-20% 0px -80% 0px'
-        };
-
-        const observer = new IntersectionObserver((entries) => {
-            entries.forEach(entry => {
-                if (entry.isIntersecting) {
-                    navLinks.forEach(link => {
-                        if (link.getAttribute('href').slice(1) === entry.target.id) {
-                            link.classList.add('active');
-                        } else {
-                            link.classList.remove('active');
-                        }
-                    });
-                }
-            });
-        }, observerOptions);
-
-        sections.forEach(section => observer.observe(section));
-
-        // Enhanced calculator functionality
-        const calculator = {
-            isCalculating: false,
-            
-            async calculate() {
-                if (this.isCalculating) return;
-                
-                const form = document.querySelector('.calculator-form');
-                form.classList.add('calculating');
-                this.isCalculating = true;
-                
-                // Simulate calculation delay
-                await new Promise(resolve => setTimeout(resolve, 500));
-                
-                // Your existing calculation code here...
-                
-                form.classList.remove('calculating');
-                this.isCalculating = false;
-            },
-            
-            reset() {
-                document.querySelectorAll('.calculator-input').forEach(input => {
-                    input.value = '';
-                });
-                document.getElementById('calculationResult').innerHTML = `
-                    <div class="text-center text-gray-500 py-8">
-                        <i class="fas fa-calculator text-3xl mb-3 text-gray-300"></i>
-                        <p>Enter values to calculate IOL power</p>
-                    </div>
-                `;
-            },
-            
-            copyResults() {
-                const result = document.querySelector('.result-value').textContent;
-                navigator.clipboard.writeText(result).then(() => {
-                    // Show copy confirmation
-                    const copyBtn = document.querySelector('.copy-btn');
-                    copyBtn.innerHTML = '<i class="fas fa-check"></i> Copied!';
-                    setTimeout(() => {
-                        copyBtn.innerHTML = '<i class="fas fa-copy"></i> Copy';
-                    }, 2000);
-                });
-            }
-        };
-
-        // Initialize calculator buttons
-        document.getElementById('calculateEVO').addEventListener('click', () => calculator.calculate());
-        document.getElementById('resetCalculator').addEventListener('click', () => calculator.reset());
-        document.querySelector('.copy-btn')?.addEventListener('click', () => calculator.copyResults());
     </script>
 </body>
 </html>