遥感图像数字水印系统优化方案

1. 引言

遥感图像在现代地理信息系统、环境监测、军事侦察等领域发挥着重要作用。为了保护遥感图像的版权和完整性，数字水印技术被广泛应用。然而，现有的遥感图像水印方案往往在不可见性、鲁棒性和容量之间存在权衡，难以同时满足所有要求。

本文针对现有遥感图像水印代码效果不佳的问题，提出了一套全面的优化方案。我们将从算法选择、预处理技术、嵌入策略、提取方法和性能评估等多个方面进行深入分析和优化，旨在提升水印系统的整体性能。

2. 现有问题分析

在优化之前，我们需要全面分析现有代码可能存在的问题：

不可见性差：水印嵌入后导致图像质量明显下降
鲁棒性不足：水印难以抵抗常见图像处理攻击
容量限制：嵌入的水印信息量有限
计算效率低：嵌入和提取过程耗时过长
适应性差：对不同类型遥感图像表现不一致

3. 优化方案设计

3.1 算法选择与改进

3.1.1 离散小波变换(DWT)与奇异值分解(SVD)结合

传统LSB(最低有效位)方法虽然简单，但鲁棒性较差。我们采用DWT+SVD组合算法，在频域中嵌入水印，提高鲁棒性。

import numpy as np
import pywt
import cv2
from scipy.linalg import svd
from skimage.metrics import peak_signal_noise_ratio as psnr
from skimage.metrics import structural_similarity as ssim
import matplotlib.pyplot as pltclass EnhancedWatermark:def __init__(self, wavelet='haar', level=2, alpha=0.1):self.wavelet = waveletself.level = levelself.alpha = alpha  # 水印强度因子def dwt2(self, image):"""二维离散小波变换"""coeffs = pywt.wavedec2(image, self.wavelet, level=self.level)return coeffsdef idwt2(self, coeffs):"""二维离散小波逆变换"""return pywt.waverec2(coeffs, self.wavelet)def svd_embed(self, host_block, watermark_block):"""使用SVD在主机图像块中嵌入水印"""U, S, Vh = svd(host_block, full_matrices=False)# 修改奇异值嵌入水印S_modified = S + self.alpha * watermark_block# 重构图像块host_modified = np.dot(U, np.dot(np.diag(S_modified), Vh))return host_modified, U, S, Vhdef svd_extract(self, host_modified, U, S, Vh):"""从修改后的图像块中提取水印"""U_mod, S_mod, Vh_mod = svd(host_modified, full_matrices=False)watermark_extracted = (S_mod - S) / self.alphareturn watermark_extracted

3.1.2 自适应水印强度调整

根据图像局部特征自适应调整水印强度，在纹理复杂区域使用较强水印，在平滑区域使用较弱水印。

def calculate_texture_map(image, block_size=8):"""计算图像纹理图，用于自适应水印强度"""height, width = image.shapetexture_map = np.zeros_like(image, dtype=np.float32)for i in range(0, height, block_size):for j in range(0, width, block_size):block = image[i:i+block_size, j:j+block_size]if block.size > 0:# 使用标准差作为纹理复杂度的度量texture = np.std(block)texture_map[i:i+block_size, j:j+block_size] = texture# 归一化纹理图texture_map = (texture_map - texture_map.min()) / (texture_map.max() - texture_map.min() + 1e-10)return texture_mapdef adaptive_alpha(texture_map, base_alpha=0.05, max_alpha=0.2):"""根据纹理图计算自适应水印强度"""return base_alpha + (max_alpha - base_alpha) * texture_map

3.2 预处理优化

3.2.1 图像预处理

def preprocess_image(image, target_size=None, normalize=True):"""图像预处理函数:param image: 输入图像:param target_size: 目标尺寸 (width, height):param normalize: 是否归一化到[0,1]:return: 预处理后的图像"""# 转换为灰度图像（如果原是彩色）if len(image.shape) == 3:image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)# 调整尺寸if target_size is not None:image = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)# 归一化if normalize:image = image.astype(np.float32) / 255.0return imagedef preprocess_watermark(watermark, target_shape):"""水印预处理函数:param watermark: 输入水印，可以是二值图像或文本:param target_shape: 目标形状:return: 预处理后的水印图像"""if isinstance(watermark, str):# 文本水印转换为图像watermark_img = text_to_image(watermark, target_shape)else:# 图像水印处理watermark_img = cv2.resize(watermark, (target_shape[1], target_shape[0]))# 二值化处理if len(watermark_img.shape) == 3:watermark_img = cv2.cvtColor(watermark_img, cv2.COLOR_BGR2GRAY)# 归一化到[0,1]watermark_img = watermark_img.astype(np.float32) / 255.0return watermark_imgdef text_to_image(text, shape, font_scale=0.8, thickness=2):"""将文本转换为图像"""img = np.zeros(shape, dtype=np.uint8)font = cv2.FONT_HERSHEY_SIMPLEXtext_size = cv2.getTextSize(text, font, font_scale, thickness)[0]text_x = (shape[1] - text_size[0]) // 2text_y = (shape[0] + text_size[1]) // 2cv2.putText(img, text, (text_x, text_y), font, font_scale, (255, 255, 255), thickness)return img

3.2.2 基于人眼视觉系统(HVS)的优化

利用人眼视觉系统特性，在不易察觉的区域嵌入更强水印。

def calculate_hvs_mask(image, block_size=8):"""基于人眼视觉系统计算掩码在纹理复杂和边缘区域可以嵌入更强水印"""# 计算梯度幅值sobelx = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=3)sobely = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=3)gradient_magnitude = np.sqrt(sobelx**2 + sobely**2)# 计算局部方差local_variance = np.zeros_like(image)for i in range(0, image.shape[0], block_size):for j in range(0, image.shape[1], block_size):block = image[i:i+block_size, j:j+block_size]if block.size > 0:local_variance[i:i+block_size, j:j+block_size] = np.var(block)# 归一化gradient_magnitude = (gradient_magnitude - gradient_magnitude.min()) / (gradient_magnitude.max() - gradient_magnitude.min() + 1e-10)local_variance = (local_variance - local_variance.min()) / (local_variance.max() - local_variance.min() + 1e-10)# 结合梯度和方差信息hvs_mask = 0.7 * gradient_magnitude + 0.3 * local_variancereturn hvs_mask

3.3 水印嵌入优化

def embed_watermark_optimized(host_image, watermark, wavelet='haar', level=2, base_alpha=0.05):"""优化的水印嵌入函数:param host_image: 主机图像:param watermark: 水印图像或文本:param wavelet: 使用的小波基:param level: 小波分解层数:param base_alpha: 基础水印强度:return: 含水印图像、嵌入参数"""# 预处理主机图像host_processed = preprocess_image(host_image)# 预处理水印watermark_processed = preprocess_watermark(watermark, host_processed.shape)# 计算HVS掩码和自适应alphahvs_mask = calculate_hvs_mask(host_processed)alpha_map = adaptive_alpha(hvs_mask, base_alpha=base_alpha)# 小波分解coeffs = pywt.wavedec2(host_processed, wavelet, level=level)cA = coeffs[0]  # 近似系数# 在近似系数中嵌入水印watermark_resized = cv2.resize(watermark_processed, (cA.shape[1], cA.shape[0]))# 使用SVD嵌入U, S, Vh = svd(cA, full_matrices=False)S_modified = S + alpha_map[:S.shape[0], :S.shape[1]] * watermark_resized# 重构近似系数cA_modified = np.dot(U, np.dot(np.diag(S_modified), Vh))# 更新系数coeffs_modified = list(coeffs)coeffs_modified[0] = cA_modified# 小波重构watermarked_image = pywt.waverec2(coeffs_modified, wavelet)# 后处理watermarked_image = np.clip(watermarked_image, 0, 1)# 保存嵌入参数用于提取embed_params = {'U': U,'S': S,'Vh': Vh,'alpha_map': alpha_map,'wavelet': wavelet,'level': level,'watermark_shape': watermark_resized.shape}return watermarked_image, embed_paramsdef block_based_embedding(host_image, watermark, block_size=64, wavelet='haar'):"""基于分块的水印嵌入，提高局部适应性"""height, width = host_image.shapewatermarked_image = np.copy(host_image)embed_params = {}# 确保水印可以被分块整除wm_height, wm_width = watermark.shapeblocks_vertical = height // block_sizeblocks_horizontal = width // block_size# 调整水印尺寸watermark_resized = cv2.resize(watermark, (blocks_horizontal, blocks_vertical))param_blocks = {}for i in range(blocks_vertical):for j in range(blocks_horizontal):# 提取图像块block = host_image[i*block_size:(i+1)*block_size, j*block_size:(j+1)*block_size]if block.size == 0:continue# 计算该块的纹理复杂度texture = np.std(block)alpha = 0.05 + 0.15 * (texture / (np.std(host_image) + 1e-10))# 小波分解coeffs = pywt.wavedec2(block, wavelet, level=2)cA = coeffs[0]# 嵌入水印位if i < watermark_resized.shape[0] and j < watermark_resized.shape[1]:wm_bit = watermark_resized[i, j]# SVD分解U, S, Vh = svd(cA, full_matrices=False)S_modified = S + alpha * wm_bit# 重构cA_modified = np.dot(U, np.dot(np.diag(S_modified), Vh))# 更新系数coeffs_modified = list(coeffs)coeffs_modified[0] = cA_modified# 逆小波变换block_modified = pywt.waverec2(coeffs_modified, wavelet)# 放回图像watermarked_image[i*block_size:(i+1)*block_size, j*block_size:(j+1)*block_size] = block_modified# 保存参数param_blocks[(i, j)] = {'U': U,'S': S,'Vh': Vh,'alpha': alpha}embed_params['param_blocks'] = param_blocksembed_params['block_size'] = block_sizeembed_params['wm_shape'] = watermark_resized.shapereturn watermarked_image, embed_params

3.4 水印提取优化

def extract_watermark_optimized(watermarked_image, embed_params, original_image=None):"""优化的水印提取函数:param watermarked_image: 含水印图像:param embed_params: 嵌入时保存的参数:param original_image: 原始图像（非盲水印时需要）:return: 提取的水印"""# 预处理图像watermarked_processed = preprocess_image(watermarked_image)if 'param_blocks' in embed_params:# 分块水印提取return extract_block_based(watermarked_processed, embed_params, original_image)else:# 全局水印提取return extract_global(watermarked_processed, embed_params, original_image)def extract_global(watermarked_image, embed_params, original_image):"""全局水印提取"""wavelet = embed_params['wavelet']level = embed_params['level']U = embed_params['U']S = embed_params['S']Vh = embed_params['Vh']alpha_map = embed_params['alpha_map']wm_shape = embed_params['watermark_shape']# 小波分解coeffs = pywt.wavedec2(watermarked_image, wavelet, level=level)cA_modified = coeffs[0]# SVD分解修改后的近似系数U_mod, S_mod, Vh_mod = svd(cA_modified, full_matrices=False)# 提取水印watermark_extracted = (S_mod - S) / alpha_map[:S.shape[0], :S.shape[1]]# 调整尺寸watermark_extracted = cv2.resize(watermark_extracted, (wm_shape[1], wm_shape[0]))return watermark_extracteddef extract_block_based(watermarked_image, embed_params, original_image):"""分块水印提取"""param_blocks = embed_params['param_blocks']block_size = embed_params['block_size']wm_shape = embed_params['wm_shape']wavelet = embed_params.get('wavelet', 'haar')height, width = watermarked_image.shapewatermark_extracted = np.zeros(wm_shape)for i in range(wm_shape[0]):for j in range(wm_shape[1]):if (i, j) not in param_blocks:continue# 提取图像块block = watermarked_image[i*block_size:(i+1)*block_size, j*block_size:(j+1)*block_size]if block.size == 0:continue# 获取该块的参数params = param_blocks[(i, j)]U = params['U']S = params['S']Vh = params['Vh']alpha = params['alpha']# 小波分解coeffs = pywt.wavedec2(block, wavelet, level=2)cA_modified = coeffs[0]# SVD分解U_mod, S_mod, Vh_mod = svd(cA_modified, full_matrices=False)# 提取水印wm_value = (S_mod - S) / alphawatermark_extracted[i, j] = np.mean(wm_value)return watermark_extracteddef blind_extraction(watermarked_image, wavelet='haar', level=2, wm_shape=(64, 64)):"""盲水印提取（不需要原始图像）这种方法鲁棒性较差，但适用于某些场景"""# 小波分解coeffs = pywt.wavedec2(watermarked_image, wavelet, level=level)cA = coeffs[0]# 假设水印嵌入在奇异值中U, S, Vh = svd(cA, full_matrices=False)# 使用统计方法估计水印# 这里使用简单的阈值方法，实际应用中可能需要更复杂的方法watermark_estimated = np.zeros_like(cA)mean_S = np.mean(S)std_S = np.std(S)# 假设水印是二值的，通过统计异常值来提取threshold = mean_S + std_Swatermark_estimated = (S > threshold).astype(np.float32)# 调整尺寸watermark_extracted = cv2.resize(watermark_estimated, (wm_shape[1], wm_shape[0]))return watermark_extracted

3.5 后处理与增强

def postprocess_watermark(extracted_watermark, method='threshold', **kwargs):"""后处理提取的水印，增强可读性"""if method == 'threshold':# 二值化threshold = kwargs.get('threshold', 0.5)processed = (extracted_watermark > threshold).astype(np.float32)elif method == 'median_filter':# 中值滤波kernel_size = kwargs.get('kernel_size', 3)processed = cv2.medianBlur((extracted_watermark * 255).astype(np.uint8), kernel_size)processed = processed.astype(np.float32) / 255.0elif method == 'wiener_filter':# 维纳滤波processed = cv2.filter2D(extracted_watermark, -1, wiener_kernel(5))else:processed = extracted_watermarkreturn processeddef wiener_kernel(size=5):"""生成维纳滤波核"""kernel = np.ones((size, size)) / (size * size)return kerneldef enhance_watermark_quality(watermark, enhance_method='histogram_equalization'):"""增强水印质量"""if enhance_method == 'histogram_equalization':# 直方图均衡化watermark_uint8 = (watermark * 255).astype(np.uint8)enhanced = cv2.equalizeHist(watermark_uint8)return enhanced.astype(np.float32) / 255.0elif enhance_method == 'contrast_stretch':# 对比度拉伸min_val = np.min(watermark)max_val = np.max(watermark)if max_val > min_val:enhanced = (watermark - min_val) / (max_val - min_val)else:enhanced = watermarkreturn enhancedelse:return watermark

3.6 鲁棒性测试与评估

def test_robustness(watermarked_image, original_image, embed_params, attacks=None):"""测试水印鲁棒性"""if attacks is None:attacks = {'gaussian_noise': lambda img: add_gaussian_noise(img, mean=0, sigma=0.01),'salt_pepper': lambda img: add_salt_pepper_noise(img, amount=0.01),'gaussian_blur': lambda img: cv2.GaussianBlur(img, (5, 5), 0.5),'jpeg_compression': lambda img: jpeg_compression(img, quality=70),'cropping': lambda img: cropping_attack(img, ratio=0.1),'rotation': lambda img: rotate_image(img, angle=5),'scaling': lambda img: scaling_attack(img, ratio=0.9)}results = {}extracted_watermarks = {}for attack_name, attack_func in attacks.items():# 应用攻击attacked_image = attack_func(watermarked_image.copy())# 提取水印try:extracted_wm = extract_watermark_optimized(attacked_image, embed_params, original_image)extracted_watermarks[attack_name] = extracted_wm# 评估提取质量（如果有原始水印）# 这里需要原始水印信息，实际应用中可能需要调整except Exception as e:print(f"攻击 {attack_name} 失败: {e}")extracted_watermarks[attack_name] = Nonereturn extracted_watermarksdef add_gaussian_noise(image, mean=0, sigma=0.01):"""添加高斯噪声"""noise = np.random.normal(mean, sigma, image.shape)noisy_image = image + noisereturn np.clip(noisy_image, 0, 1)def add_salt_pepper_noise(image, amount=0.01):"""添加椒盐噪声"""noisy_image = np.copy(image)# 盐噪声salt_mask = np.random.random(image.shape) < amount/2noisy_image[salt_mask] = 1# 椒噪声pepper_mask = np.random.random(image.shape) < amount/2noisy_image[pepper_mask] = 0return noisy_imagedef jpeg_compression(image, quality=70):"""JPEG压缩攻击"""# 转换为0-255范围image_uint8 = (image * 255).astype(np.uint8)# JPEG压缩encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality]result, encimg = cv2.imencode('.jpg', image_uint8, encode_param)# 解码decimg = cv2.imdecode(encimg, 0)return decimg.astype(np.float32) / 255.0def cropping_attack(image, ratio=0.1):"""裁剪攻击"""h, w = image.shapecrop_h = int(h * ratio)crop_w = int(w * ratio)cropped = image[crop_h:-crop_h, crop_w:-crop_w]# 恢复原始尺寸return cv2.resize(cropped, (w, h))def rotate_image(image, angle=5):"""旋转攻击"""h, w = image.shapecenter = (w // 2, h // 2)M = cv2.getRotationMatrix2D(center, angle, 1.0)rotated = cv2.warpAffine(image, M, (w, h))return rotateddef scaling_attack(image, ratio=0.9):"""缩放攻击"""h, w = image.shapescaled = cv2.resize(image, (int(w * ratio), int(h * ratio)))# 恢复原始尺寸return cv2.resize(scaled, (w, h))def calculate_metrics(original, watermarked, extracted_wm, original_wm=None):"""计算各种评估指标"""metrics = {}# 图像质量指标metrics['psnr'] = psnr(original, watermarked, data_range=1.0)metrics['ssim'] = ssim(original, watermarked, data_range=1.0)if original_wm is not None and extracted_wm is not None:# 调整尺寸以便比较extracted_resized = cv2.resize(extracted_wm, (original_wm.shape[1], original_wm.shape[0]))# 水印相似度指标metrics['wm_correlation'] = np.corrcoef(original_wm.flatten(), extracted_resized.flatten())[0, 1]metrics['wm_ber'] = calculate_ber(original_wm, extracted_resized)return metricsdef calculate_ber(original, extracted, threshold=0.5):"""计算误码率(Bit Error Rate)"""original_binary = (original > threshold).astype(np.int8)extracted_binary = (extracted > threshold).astype(np.int8)if original_binary.shape != extracted_binary.shape:extracted_binary = cv2.resize(extracted_binary, (original_binary.shape[1], original_binary.shape[0]))error_bits = np.sum(original_binary != extracted_binary)total_bits = original_binary.sizereturn error_bits / total_bits

3.7 完整的水印系统类

class RemoteSensingWatermarkSystem:"""完整的遥感图像水印系统"""def __init__(self, config=None):if config is None:config = {'wavelet': 'haar','level': 2,'base_alpha': 0.05,'max_alpha': 0.2,'block_size': 64,'embed_method': 'adaptive_global'  # 'adaptive_global' or 'block_based'}self.config = configself.embed_params = Nonedef embed(self, host_image, watermark):"""嵌入水印"""# 预处理主机图像host_processed = preprocess_image(host_image)# 预处理水印watermark_processed = preprocess_watermark(watermark, host_processed.shape)if self.config['embed_method'] == 'adaptive_global':watermarked_image, self.embed_params = embed_watermark_optimized(host_processed, watermark_processed,wavelet=self.config['wavelet'],level=self.config['level'],base_alpha=self.config['base_alpha'])elif self.config['embed_method'] == 'block_based':watermarked_image, self.embed_params = block_based_embedding(host_processed, watermark_processed,block_size=self.config['block_size'],wavelet=self.config['wavelet'])else:raise ValueError("不支持的嵌入方法")# 转换为0-255范围输出watermarked_uint8 = (watermarked_image * 255).astype(np.uint8)return watermarked_uint8def extract(self, watermarked_image, original_image=None):"""提取水印"""if self.embed_params is None:raise ValueError("请先嵌入水印或提供嵌入参数")watermarked_processed = preprocess_image(watermarked_image)if original_image is not None:original_processed = preprocess_image(original_image)else:original_processed = Noneextracted_wm = extract_watermark_optimized(watermarked_processed, self.embed_params, original_processed)# 后处理extracted_processed = postprocess_watermark(extracted_wm, method='threshold')extracted_enhanced = enhance_watermark_quality(extracted_processed)# 转换为0-255范围输出extracted_uint8 = (extracted_enhanced * 255).astype(np.uint8)return extracted_uint8def test_robustness(self, watermarked_image, original_image, attacks=None):"""测试鲁棒性"""watermarked_processed = preprocess_image(watermarked_image)original_processed = preprocess_image(original_image)return test_robustness(watermarked_processed, original_processed, self.embed_params, attacks)def evaluate(self, original_image, watermarked_image, original_watermark=None):"""全面评估系统性能"""original_processed = preprocess_image(original_image)watermarked_processed = preprocess_image(watermarked_image)if original_watermark is not None:original_wm_processed = preprocess_watermark(original_watermark, original_processed.shape)else:original_wm_processed = None# 提取水印用于评估extracted_wm = self.extract(watermarked_image, original_image)extracted_processed = preprocess_image(extracted_wm, target_size=original_processed.shape)# 计算指标metrics = calculate_metrics(original_processed, watermarked_processed, extracted_processed, original_wm_processed)return metrics, extracted_wm

3.8 可视化工具

def plot_results(original, watermarked, extracted_wm, original_wm=None, metrics=None):"""可视化结果"""fig, axes = plt.subplots(2, 2, figsize=(12, 10))# 原始图像axes[0, 0].imshow(original, cmap='gray')axes[0, 0].set_title('原始图像')axes[0, 0].axis('off')# 含水印图像axes[0, 1].imshow(watermarked, cmap='gray')axes[0, 1].set_title('含水印图像')axes[0, 1].axis('off')# 提取的水印axes[1, 0].imshow(extracted_wm, cmap='gray')axes[1, 0].set_title('提取的水印')axes[1, 0].axis('off')# 原始水印（如果有）if original_wm is not None:axes[1, 1].imshow(original_wm, cmap='gray')axes[1, 1].set_title('原始水印')else:axes[1, 1].axis('off')# 添加指标文本if metrics is not None:metrics_text = f"PSNR: {metrics.get('psnr', 0):.2f} dB\nSSIM: {metrics.get('ssim', 0):.4f}"if 'wm_correlation' in metrics:metrics_text += f"\n相关系数: {metrics['wm_correlation']:.4f}"if 'wm_ber' in metrics:metrics_text += f"\n误码率: {metrics['wm_ber']:.4f}"plt.figtext(0.5, 0.01, metrics_text, ha='center', fontsize=12, bbox=dict(facecolor='lightgray', alpha=0.5))plt.tight_layout()plt.show()def plot_robustness_test(results, original_wm=None):"""可视化鲁棒性测试结果"""n_attacks = len(results)n_cols = 3n_rows = (n_attacks + n_cols - 1) // n_colsfig, axes = plt.subplots(n_rows, n_cols, figsize=(15, 5 * n_rows))axes = axes.flatten()for i, (attack_name, extracted_wm) in enumerate(results.items()):if extracted_wm is not None:axes[i].imshow(extracted_wm, cmap='gray')axes[i].set_title(attack_name)axes[i].axis('off')# 隐藏多余的子图for j in range(i + 1, len(axes)):axes[j].axis('off')plt.tight_layout()plt.show()

4. 使用示例

# 示例使用代码
if __name__ == "__main__":# 读取遥感图像image_path = "remote_sensing_image.tif"original_image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)# 创建水印（可以是文本或图像）watermark_text = "Copyright 2023"# 初始化水印系统watermark_system = RemoteSensingWatermarkSystem({'wavelet': 'haar','level': 2,'base_alpha': 0.05,'embed_method': 'adaptive_global'})# 嵌入水印watermarked_image = watermark_system.embed(original_image, watermark_text)# 提取水印extracted_watermark = watermark_system.extract(watermarked_image, original_image)# 评估性能metrics, extracted_wm = watermark_system.evaluate(original_image, watermarked_image, watermark_text)# 可视化结果plot_results(original_image, watermarked_image, extracted_wm, text_to_image(watermark_text, original_image.shape), metrics)# 测试鲁棒性attacks = {'高斯噪声': lambda img: add_gaussian_noise(img, sigma=0.02),'椒盐噪声': lambda img: add_salt_pepper_noise(img, amount=0.03),'高斯模糊': lambda img: cv2.GaussianBlur(img, (5, 5), 0.8),'JPEG压缩': lambda img: jpeg_compression(img, quality=60),}robustness_results = watermark_system.test_robustness(watermarked_image, original_image, attacks)plot_robustness_test(robustness_results)