biomedical-engineering

name	biomedical-engineering
description	Biomedical engineering fundamentals including medical device design, signal processing for physiological data, imaging systems, and clinical instrumentation
license	MIT
compatibility	opencode
metadata	{"audience":"engineers","category":"engineering"}

What I do

• Design medical devices and diagnostic equipment
• Process physiological signals (ECG, EEG, EMG)
• Analyze medical imaging data (CT, MRI, ultrasound)
• Model biological systems and biomechanics
• Design prosthetics and orthotics
• Implement FDA regulatory compliance
• Create clinical decision support systems
• Design implantable medical devices
• Implement medical data security (HIPAA)
• Validate medical device software

When to use me

When designing medical devices, processing physiological signals, implementing healthcare software, or ensuring regulatory compliance for medical products.

Core Concepts

• Physiological signal acquisition and processing
• Medical imaging modalities and analysis
• Biomechanics and rehabilitation engineering
• Medical device design and validation
• FDA and international regulatory requirements
• HIPAA data security and privacy
• Clinical trials and human factors engineering
• Biosensors and instrumentation
• Neural interfaces and brain-computer interfaces
• Biomaterials and tissue engineering

Code Examples

ECG Signal Processing

import numpy as np
from scipy import signal
from scipy.ndimage import uniform_filter1d
from dataclasses import dataclass

@dataclass
class ECGSignal:
    data: np.ndarray
    sampling_rate: float
    patient_id: str

def detect_r_peaks(
    ecg: ECGSignal,
    threshold: float = 0.5,
    min_distance: int = None
) -> np.ndarray:
    """Detect R-peaks in ECG signal using Pan-Tompkins algorithm."""
    fs = ecg.sampling_rate
    
    # Bandpass filter (5-15 Hz)
    nyquist = fs / 2
    low = 5 / nyquist
    high = 15 / nyquist
    b, a = signal.butter(4, [low, high], btype='band')
    filtered = signal.filtfilt(b, a, ecg.data)
    
    # Derivative
    diff = np.diff(filtered)
    diff = np.concatenate([[0], diff])
    
    # Squaring
    squared = diff ** 2
    
    # Moving average (integration window ~150ms)
    window = int(0.15 * fs)
    integrated = uniform_filter1d(squared, size=window)
    
    # Find peaks
    if min_distance is None:
        min_distance = int(0.4 * fs)  # Minimum 40 BPM
    
    peaks, properties = signal.find_peaks(
        integrated,
        height=threshold * np.max(integrated),
        distance=min_distance
    )
    
     peaks

 () -> :
    
     (r_peaks) < :
         
    
    rr_intervals = np.diff(r_peaks) / sampling_rate  
    mean_rr = np.mean(rr_intervals)
      / mean_rr

 () -> :
    
    window_before = ( * ecg.sampling_rate)
    window_after = ( * ecg.sampling_rate)
    
    qrs_data = []
    qrs_widths = []
    qrs_amplitudes = []
    
     r_peak  r_peaks:
        start = (, r_peak - window_before)
        end = ((ecg.data), r_peak + window_after)
        
        segment = ecg.data[start:end]
        qrs_data.append(segment)
        
        
        diff = np.(np.diff(segment))
        qrs_width = np.argmax(np.cumsum(diff) >  * np.(diff))
        qrs_widths.append(qrs_width / ecg.sampling_rate * )  
        
        
        qrs_amplitudes.append(ecg.data[r_peak])
    
     {
        : np.mean(qrs_widths),
        : np.mean(qrs_amplitudes),
        : (r_peaks)
    }

 () -> :
    
     (r_peaks) < :
         []
    
    rr_intervals = np.diff(r_peaks) / sampling_rate
    rr_diff = np.diff(rr_intervals)
    
    arrhythmias = []
    
    
    hr =  / rr_intervals
     np.mean(hr) > :
        arrhythmias.append({
            : ,
            : ,
            : np.mean(hr)
        })
    
    
     np.mean(hr) < :
        arrhythmias.append({
            : ,
            : ,
            : np.mean(hr)
        })
    
    
    rr_std = np.std(rr_intervals)
     rr_std > :  
        arrhythmias.append({
            : ,
            : ,
            : rr_std * 
        })
    
    
    pvc_indices = np.where(rr_intervals[:-] <  * np.median(rr_intervals))[]
     (pvc_indices) > :
        arrhythmias.append({
            : ,
            : (pvc_indices),
            : 
        })
    
     arrhythmias


ecg = ECGSignal(
    data=np.load(),
    sampling_rate=,
    patient_id=
)
r_peaks = detect_r_peaks(ecg)
hr = calculate_heart_rate(r_peaks, )
qrs = detect_qrs_complex(ecg, r_peaks)
arrhythmias = detect_arrhythmia(r_peaks, )
()
()

Medical Imaging Utilities

import numpy as np
from scipy import ndimage
from skimage import exposure, filters

def apply_window_level(
    image: np.ndarray,
    window_center: float,
    window_width: float
) -> np.ndarray:
    """Apply window/level adjustment for medical imaging."""
    min_val = window_center - window_width / 2
    max_val = window_center + window_width / 2
    
    windowed = np.clip(image, min_val, max_val)
    windowed = (windowed - min_val) / (max_val - min_val)
    return windowed

def lung_segmentation(
    ct_slice: np.ndarray
) -> np.ndarray:
    """Simple lung segmentation using thresholding."""
    # Typical HU values: air <-400, lung -400 to -900, tissue >0
    lung_mask = (ct_slice < -200) & (ct_slice > -1000)
    
    # Remove noise
    lung_mask = ndimage.binary_opening(lung_mask, iterations=2)
    
    # Fill holes
    lung_mask = ndimage.binary_closing(lung_mask, iterations=3)
    
    # Label and keep two largest regions (left and right lung)
    labels, num_features = ndimage.label(lung_mask)
    if num_features >= 2:
        sizes = ndimage.sum(lung_mask, labels, range(1, num_features + 1))
        keep = np.argsort(sizes)[-2:] + 1
        lung_mask = np.isin(labels, keep)
    
    return lung_mask.astype(np.uint8)

def enhance_contrast(
    image: np.ndarray,
    method:  = 
) -> np.ndarray:
    
     method == :
         exposure.equalize_adapthist(image / np.(image))
     method == :
         exposure.equalize_hist(image)
     method == :
         exposure.rescale_intensity(image, out_range=(, ))
     image

 () -> :
    
     mask  :
        mask = np.ones_like(ct_image, dtype=)
    
    hu_values = ct_image[mask]
    
     {
        : np.mean(hu_values),
        : np.std(hu_values),
        : np.(hu_values),
        : np.(hu_values),
        : np.median(hu_values),
        : np.(mask)
    }

Biomechanics Calculations

from dataclasses import dataclass
from typing import Tuple

@dataclass
class ForceData:
    force_x: np.ndarray
    force_y: np.ndarray
    force_z: np.ndarray
    sampling_rate: float

@dataclass
class BiomechanicalModel:
    mass_kg: float
    height_m: float
    leg_length_m: float

def calculate_center_of_pressure(
    force_data: ForceData
) -> Tuple[np.ndarray, np.ndarray]:
    """Calculate COP from ground reaction forces."""
    fx, fy, fz = force_data.force_x, force_data.force_y, force_data.force_z
    sampling_rate = force_data.sampling_rate
    
    # COP calculation (assuming force plate at origin)
    cop_x = -fy / fz
    cop_y = -fx / fz
    
    return cop_x, cop_y

def gait_analysis(
    cop_x: np.ndarray,
    cop_y: np.ndarray,
    sampling_rate: float
) -> dict:
    """Analyze gait from COP data."""
    # Find gait cycles (peaks in medial-lateral direction)
    peaks, _ = signal.find_peaks(cop_x, distance=int(0.5 * sampling_rate))
    
    if len(peaks) < 2:
        return {"error": "Insufficient data for gait analysis"}
    
    # Calculate cadence
    step_times = np.diff(peaks) / sampling_rate
    cadence = 60 / np.mean(step_times)  # steps per minute
    
    # Calculate stride length
    stride_lengths = np.(np.diff(cop_y[peaks]))
    stride_length_mean = np.mean(stride_lengths)
    
    
    velocity = np.gradient(cop_y) * sampling_rate
    velocity_rms = np.sqrt(np.mean(velocity ** ))
    
     {
        : cadence,
        : stride_length_mean,
        : velocity_rms,
        : (peaks)
    }

 () -> np.ndarray:
    
     np.cross(moment_arm, force)

 () -> :
    
    normal_stress = force / cross_sectional_area
    bending_stress = moment / section_modulus
    
     {
        : normal_stress,
        : bending_stress
    }

Medical Device Regulatory Compliance

from dataclasses import dataclass
from datetime import datetime
from enum import Enum
from typing import List

class RiskClass(Enum):
    CLASS_I = "Class I"
    CLASS_II = "Class II"
    CLASS_III = "Class III"

@dataclass
class DesignControl:
    design_input: str
    design_output: str
    design_review: str
    verification: str
    validation: str

@dataclass
class DHFEntry:
    document_id: str
    title: str
    date: datetime
    author: str
    reviewer: str
    status: str

class DesignHistoryFile:
    def __init__(self, device_name: str, risk_class: RiskClass):
        self.device_name = device_name
        self.risk_class = risk_class
        self.entries: List[DHFEntry] = []
        self.design_controls: List[DesignControl] = []
    
    def add_entry(self, entry: DHFEntry):
        self.entries.append(entry)
    
     ():
        .design_controls.append(control)
    
     () -> :
        
         {
            : .device_name,
            : .risk_class.value,
            : (.entries),
            : (.design_controls),
            : ._get_required_controls(),
            : ._check_compliance()
        }
    
     () -> []:
         .risk_class == RiskClass.CLASS_I:
             [, ]
         .risk_class == RiskClass.CLASS_II:
             [, , , ]
        :
             [, , , ]
    
     () -> :
        required = ._get_required_controls()
           (.entries) >=   


 :
     ():
        .checks = {
            : ,
            : ,
            : ,
            : ,
            : ,
            : ,
            : ,
            : 
        }
    
     () -> :
        
        score = (.checks.values()) / (.checks) * 
         {
            : score >= ,
            : score,
            : (.checks.values()),
            : (.checks),
            : .checks
        }

Best Practices

• Follow FDA design controls (21 CFR Part 820) for medical devices
• Implement comprehensive risk management per ISO 14971
• Ensure HIPAA compliance for all PHI data
• Use validated software development processes (IEC 62304)
• Perform human factors validation for user-facing devices
• Document all design decisions in Design History File
• Implement traceability from requirements to verification
• Use proper biocompatibility testing for implantables
• Follow cybersecurity best practices for connected devices
• Maintain audit trails for all device modifications