pip install tensorflow opencv-python numpy matplotlib scikit-image

import tensorflow as tf
from tensorflow.keras import layers, models

def FSRCNN(scale_factor=2, num_channels=1, d=56, s=12, m=4):
    """
    FSRCNN模型实现
    参数:
        scale_factor: 超分辨率放大因子
        num_channels: 输入图像的通道数
        d: 特征提取层维度
        s: 收缩层维度
        m: 映射层数量
    """
    # 输入层
    inputs = layers.Input(shape=(None, None, num_channels))

    # 特征提取
    x = layers.Conv2D(d, 5, padding='same', activation='relu')(inputs)

    # 收缩
    x = layers.Conv2D(s, 1, padding='same', activation='relu')(x)

    # 映射层(多个小卷积核)
    for _ in range(m):
        x = layers.Conv2D(s, 3, padding='same', activation='relu')(x)

    # 扩展
    x = layers.Conv2D(d, 1, padding='same', activation='relu')(x)

    # 反卷积(上采样)
    x = layers.Conv2DTranspose(num_channels, 9, strides=scale_factor, 
                              padding='same', activation='linear')(x)

    return models.Model(inputs, x)

import cv2
import numpy as np
from skimage.transform import resize

def prepare_data(hr_images, scale_factor=2):
    """
    准备训练数据
    参数:
        hr_images: 高分辨率图像列表
        scale_factor: 缩放因子
    返回:
        lr_images: 低分辨率图像
        hr_images: 高分辨率图像
    """
    lr_images = []
    processed_hr = []

    for img in hr_images:
        # 归一化
        img = img.astype(np.float32) / 255.0

        # 生成低分辨率图像
        h, w = img.shape[:2]
        lr_img = resize(img, (h//scale_factor, w//scale_factor), 
                       anti_aliasing=True)

        # 上采样回原始尺寸
        lr_img = resize(lr_img, (h, w), anti_aliasing=True)

        lr_images.append(lr_img)
        processed_hr.append(img)

    return np.array(lr_images), np.array(processed_hr)

def train_fsrcnn(hr_images, scale_factor=2, epochs=50, batch_size=16):
    """
    训练FSRCNN模型
    参数:
        hr_images: 高分辨率图像列表
        scale_factor: 缩放因子
        epochs: 训练轮数
        batch_size: 批次大小
    返回:
        训练好的模型
    """
    # 准备数据
    lr_images, hr_images = prepare_data(hr_images, scale_factor)

    # 创建模型
    model = FSRCNN(scale_factor=scale_factor, num_channels=hr_images.shape[-1])

    # 编译模型
    model.compile(optimizer='adam', loss='mse', metrics=['mae'])

    # 训练模型
    model.fit(lr_images, hr_images, 
              batch_size=batch_size, 
              epochs=epochs,
              validation_split=0.2,
              shuffle=True)

    return model

def super_resolve_image(model, lr_image, scale_factor=2):
    """
    使用训练好的模型进行超分辨率重建
    参数:
        model: 训练好的FSRCNN模型
        lr_image: 低分辨率图像
        scale_factor: 缩放因子
    返回:
        超分辨率重建后的图像
    """
    # 预处理
    original_dtype = lr_image.dtype
    lr_image = lr_image.astype(np.float32) / 255.0

    # 如果图像是单通道
    if len(lr_image.shape) == 2:
        lr_image = np.expand_dims(lr_image, axis=-1)

    # 添加批次维度
    lr_image = np.expand_dims(lr_image, axis=0)

    # 预测
    sr_image = model.predict(lr_image)[0]

    # 后处理
    sr_image = np.clip(sr_image * 255.0, 0, 255).astype(original_dtype)

    return sr_image

import cv2
import matplotlib.pyplot as plt

# 加载遥感影像
hr_image = cv2.imread('remote_sensing.jpg', cv2.IMREAD_COLOR)  # 替换为你的遥感图像路径
hr_image = cv2.cvtColor(hr_image, cv2.COLOR_BGR2RGB)

# 训练模型 (实际应用中建议使用大量遥感影像进行训练)
model = train_fsrcnn([hr_image], scale_factor=2, epochs=30, batch_size=1)

# 生成低分辨率测试图像
scale_factor = 2
h, w = hr_image.shape[:2]
lr_image = cv2.resize(hr_image, (w//scale_factor, h//scale_factor))
lr_image = cv2.resize(lr_image, (w, h), interpolation=cv2.INTER_CUBIC)

# 超分辨率重建
sr_image = super_resolve_image(model, lr_image, scale_factor=scale_factor)

# 显示结果
plt.figure(figsize=(15, 5))
plt.subplot(1, 3, 1)
plt.title('Low Resolution')
plt.imshow(lr_image)
plt.axis('off')

plt.subplot(1, 3, 2)
plt.title('Super Resolution')
plt.imshow(sr_image)
plt.axis('off')

plt.subplot(1, 3, 3)
plt.title('Original')
plt.imshow(hr_image)
plt.axis('off')

plt.show()