计算机视觉算法实现——岩石纹理识别

喵了个AI

于 2025-04-18 08:00:00 发布

阅读量1.1k

点赞数 25

分类专栏：计算机视觉实战项目文章标签：深度学习

本文链接：https://blog.csdn.net/m0_65481401/article/details/147314459

版权

计算机视觉实战项目专栏收录该内容

116 篇文章

订阅专栏

✨个人主页欢迎您的访问 ✨期待您的三连 ✨

✨个人主页欢迎您的访问 ✨期待您的三连✨

1. 岩石纹理识别领域概述

岩石纹理识别是计算机视觉在地质学和矿物学中的重要应用领域，它通过分析岩石表面的视觉特征来自动识别和分类岩石类型。这项技术在矿产资源勘探、地质调查、岩土工程和行星地质学等领域具有广泛的应用价值。

传统岩石识别主要依赖地质学家的经验判断，存在主观性强、效率低下等局限性。而基于计算机视觉的岩石纹理识别技术能够提供客观、一致且高效的解决方案，具有以下优势：

标准化分析：消除人为判断的主观差异
高效率：可快速处理大量样本
定量化：提供精确的纹理特征度量
非破坏性：无需破坏样本即可进行分析
可追溯性：完整记录分析过程和结果

随着深度学习技术的发展，岩石纹理识别的准确率已从早期的70%左右提升到现在的90%以上，使得这项技术在实际应用中变得更加可靠。

2. 岩石纹理识别算法基本原理

2.1 岩石纹理特征分析

岩石纹理特征主要包括：

结构特征：颗粒大小、形状、排列方式
统计特征：灰度分布、对比度、熵值
频谱特征：傅里叶变换、小波变换特征
深度特征：卷积神经网络提取的高层语义特征

2.2 传统图像处理方法

2.2.1 纹理分析算法

灰度共生矩阵(GLCM)：
- 计算像素对的空间关系
- 提取对比度、相关性、能量、同质性等特征
局部二值模式(LBP)：
- 描述局部纹理模式
- 对光照变化具有鲁棒性
Gabor滤波器：
- 模拟人类视觉系统
- 多尺度多方向纹理分析

2.2.2 特征融合与分类

融合多种特征提高识别率
使用SVM、随机森林等分类器

2.3 深度学习方法

2.3.1 卷积神经网络(CNN)

ResNet：解决深层网络退化问题
DenseNet：特征重用，参数高效
EfficientNet：均衡缩放网络维度

2.3.2 注意力机制

Squeeze-and-Excitation Networks：通道注意力
CBAM：结合通道和空间注意力
Vision Transformers：全局自注意力机制

2.3.3 多尺度特征融合

Feature Pyramid Network：融合不同层次特征
U-Net：编码器-解码器结构，保留空间信息

3. 岩石纹理数据集介绍

3.1 公开可用数据集

RockTexture Dataset
- 包含25类常见岩石的纹理图像
- 每类500张高分辨率图像(2560×1920)
- 包含火成岩、沉积岩和变质岩三大类
- 下载链接：RockTexture Dataset
GeoTexture Database
- 专注于微观岩石纹理
- 包含薄片显微图像和对应的矿物组成
- 下载链接：GeoTexture Database
OpenRock Dataset
- 野外采集的岩石图像
- 包含不同光照和天气条件下的图像
- 下载链接：OpenRock Dataset
PetroRock Benchmark
- 石油勘探领域的岩石样本
- 包含孔隙结构分析数据
- 下载链接：PetroRock Benchmark

3.2 数据增强策略

由于岩石样本获取困难，常采用数据增强：

几何变换：旋转、翻转、裁剪
颜色变换：亮度、对比度调整
噪声注入：高斯噪声、椒盐噪声
混合样本：CutMix、MixUp

4. 代码实现

以下是一个基于PyTorch的岩石纹理识别系统完整实现：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, models
import os
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns

# 1. 数据准备
class RockTextureDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.classes = sorted(os.listdir(root_dir))
        self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
        self.images = self._load_images()
    
    def _load_images(self):
        images = []
        for cls in self.classes:
            cls_dir = os.path.join(self.root_dir, cls)
            for img_name in os.listdir(cls_dir):
                img_path = os.path.join(cls_dir, img_name)
                images.append((img_path, self.class_to_idx[cls]))
        return images
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        img_path, label = self.images[idx]
        image = Image.open(img_path).convert('RGB')
        
        if self.transform:
            image = self.transform(image)
            
        return image, label

# 数据增强和归一化
data_transforms = {
    'train': transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.RandomVerticalFlip(),
        transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

# 2. 模型定义
class RockTextureModel(nn.Module):
    def __init__(self, num_classes=25):
        super(RockTextureModel, self).__init__()
        # 使用预训练的ResNet50作为基础网络
        self.backbone = models.resnet50(pretrained=True)
        # 替换最后的全连接层
        in_features = self.backbone.fc.in_features
        self.backbone.fc = nn.Sequential(
            nn.Linear(in_features, 1024),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(1024, num_classes)
        )
    
    def forward(self, x):
        return self.backbone(x)

# 3. 训练函数
def train_model(model, dataloaders, criterion, optimizer, num_epochs=25):
    best_acc = 0.0
    train_loss, val_loss = [], []
    train_acc, val_acc = [], []
    
    for epoch in range(num_epochs):
        print(f'Epoch {epoch}/{num_epochs-1}')
        print('-' * 10)
        
        # 每个epoch都有训练和验证阶段
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            
            running_loss = 0.0
            running_corrects = 0
            
            # 迭代数据
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)
                
                # 梯度清零
                optimizer.zero_grad()
                
                # 前向传播
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)
                    
                    # 训练阶段反向传播+优化
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                
                # 统计
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)
            
            epoch_loss = running_loss / len(dataloaders[phase].dataset)
            epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)
            
            if phase == 'train':
                train_loss.append(epoch_loss)
                train_acc.append(epoch_acc.cpu().numpy())
            else:
                val_loss.append(epoch_loss)
                val_acc.append(epoch_acc.cpu().numpy())
            
            print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
            
            # 深拷贝模型
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())
        
        print()
    
    # 训练结束后加载最佳模型权重
    model.load_state_dict(best_model_wts)
    return model, train_loss, val_loss, train_acc, val_acc

# 4. 主程序
if __name__ == '__main__':
    # 设置设备
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    
    # 准备数据集
    data_dir = 'path_to_your_dataset'  # 替换为你的数据集路径
    image_datasets = {x: RockTextureDataset(os.path.join(data_dir, x),
                                          data_transforms[x])
                     for x in ['train', 'val']}
    
    dataloaders = {x: DataLoader(image_datasets[x], batch_size=32,
                                 shuffle=True, num_workers=4)
                  for x in ['train', 'val']}
    
    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
    class_names = image_datasets['train'].classes
    
    # 初始化模型
    model = RockTextureModel(num_classes=len(class_names)).to(device)
    
    # 定义损失函数和优化器
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    
    # 训练模型
    model, train_loss, val_loss, train_acc, val_acc = train_model(
        model, dataloaders, criterion, optimizer, num_epochs=25)
    
    # 可视化训练过程
    plt.figure(figsize=(12, 5))
    plt.subplot(1, 2, 1)
    plt.plot(train_loss, label='Train Loss')
    plt.plot(val_loss, label='Validation Loss')
    plt.legend()
    plt.title('Loss over epochs')
    
    plt.subplot(1, 2, 2)
    plt.plot(train_acc, label='Train Accuracy')
    plt.plot(val_acc, label='Validation Accuracy')
    plt.legend()
    plt.title('Accuracy over epochs')
    plt.show()
    
    # 在测试集上评估
    model.eval()
    all_preds = []
    all_labels = []
    
    with torch.no_grad():
        for inputs, labels in dataloaders['val']:
            inputs = inputs.to(device)
            labels = labels.to(device)
            
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)
            
            all_preds.extend(preds.cpu().numpy())
            all_labels.extend(labels.cpu().numpy())
    
    # 生成混淆矩阵
    cm = confusion_matrix(all_labels, all_preds)
    plt.figure(figsize=(10, 8))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
                xticklabels=class_names, yticklabels=class_names)
    plt.xlabel('Predicted')
    plt.ylabel('True')
    plt.title('Confusion Matrix')
    plt.show()
    
    # 打印分类报告
    print(classification_report(all_labels, all_preds, target_names=class_names))

5. 优秀论文及资源

"Deep Learning for Rock Texture Classification" (IEEE Transactions on Geoscience and Remote Sensing, 2021)
- 全面比较了不同深度学习模型在岩石纹理分类中的表现
- 下载链接：[DOI: 10.1109/TGRS.2021.3056412]
"Multi-Scale Feature Fusion for Rock Texture Analysis" (Computers & Geosciences, 2022)
- 提出了一种多尺度特征融合网络
- 下载链接：[DOI: 10.1016/j.cageo.2022.105012]
"Vision Transformers for Mineral Recognition" (Nature Scientific Reports, 2022)
- 首次将Vision Transformer应用于岩石矿物识别
- 下载链接：[DOI: 10.1038/s41598-022-13589-0]
"Self-Supervised Learning for Rock Texture Representation" (ISPRS Journal of Photogrammetry, 2023)
- 提出自监督学习方法解决标注数据稀缺问题
- 下载链接：[DOI: 10.1016/j.isprsjprs.2023.02.015]
"Field Guide to Rock Texture Classification" (地质出版社, 2020)
- 岩石纹理分类的实用指南
- 下载链接：[出版社官网]