基于python将遥感影像裁剪成深度学习数据集并拼接

最新推荐文章于 2024-07-30 21:09:58 发布
最新推荐文章于 2024-07-30 21:09:58 发布
阅读量4.6k 收藏 148
点赞数 19
文章标签： python 深度学习 人工智能 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moringacui/article/details/126508834
版权

基于python将遥感影像裁剪成深度学习数据集并拼接

更改二分类mask为0-255

import os, sys
try:
    import gdal
except:
    from osgeo import gdal
import numpy as np
from osgeo import gdal_array
from numba import jit

# 保存tif文件函数
def writeTiff(im_data, im_geotrans, im_proj, path):
    if 'int8' in im_data.dtype.name:
        datatype = gdal.GDT_Byte
    elif 'int16' in im_data.dtype.name:
        datatype = gdal.GDT_UInt16
    else:
        datatype = gdal.GDT_Float32
    if len(im_data.shape) == 3:
        im_bands, im_height, im_width = im_data.shape
    elif len(im_data.shape) == 2:
        im_data = np.array([im_data])
        im_bands, im_height, im_width = im_data.shape
    # 创建文件
    driver = gdal.GetDriverByName("GTiff")
    dataset = driver.Create(path, int(im_width), int(im_height), int(im_bands), datatype)
    if (dataset != None):
        dataset.SetGeoTransform(im_geotrans)  # 写入仿射变换参数
        dataset.SetProjection(im_proj)  # 写入投影
    for i in range(im_bands):
        dataset.GetRasterBand(i + 1).WriteArray(im_data[i])
    del dataset

'''
更改标签图像像素
TifPath 影像路径
'''
def changemaskpixel(TifPath, SavePath):
    dataset_img = gdal.Open(TifPath)
    if dataset_img == None:
        print(TifPath + "文件无法打开")


    width = dataset_img.RasterXSize  # 获取行列数
    height = dataset_img.RasterYSize
    bands = dataset_img.RasterCount  # 获取波段数
    print("行数为：", height)
    print("列数为：", width)
    print("波段数为：", bands)

    proj = dataset_img.GetProjection()  # 获取投影信息
    geotrans = dataset_img.GetGeoTransform()  # 获取仿射矩阵信息
    img = dataset_img.ReadAsArray(0, 0, width, height)  # 获取数据
    # print(img.shape[0], img.shape[1])

    go_fast(img)

    # 生成Tif图像
    writeTiff(img, geotrans, proj, SavePath)
    # gdal_array.SaveArray(img.astype(gdal_array.numpy.uint8),
    #                      SavePath, format="GTIFF", prototype='')

# 循环加速，将标签影像赋值为0-255
@jit(nopython=True)
def go_fast(img):
    for row in range(img.shape[0]):
        for col in range(img.shape[1]):
            # print(img[row, col])
            if img[row, col] == 1:
                img[row, col] = 255
            else:
                img[row, col] = 0
    return img


if __name__ == '__main__':
    # # 更改标签图像的像素为0-255
    changemaskpixel("F:/internship/code/accuracy/results/mask.tif",
                    "F:/internship/code/accuracy/results/groundtruth.tif")

裁剪

裁剪代码参考：python遥感图像裁剪成深度学习样本_支持多波段

import os
import sys
try:
    import gdal
except:
    from osgeo import gdal
import numpy as np
from PIL import Image



# 保存tif文件函数
def writeTiff(im_data, im_geotrans, im_proj, path):
    if 'int8' in im_data.dtype.name:
        datatype = gdal.GDT_Byte
    elif 'int16' in im_data.dtype.name:
        datatype = gdal.GDT_UInt16
    else:
        datatype = gdal.GDT_Float32
    if len(im_data.shape) == 3:
        im_bands, im_height, im_width = im_data.shape
    elif len(im_data.shape) == 2:
        im_data = np.array([im_data])
        im_bands, im_height, im_width = im_data.shape
    # 创建文件
    driver = gdal.GetDriverByName("GTiff")
    dataset = driver.Create(path, int(im_width), int(im_height), int(im_bands), datatype)
    if (dataset != None):
        dataset.SetGeoTransform(im_geotrans)  # 写入仿射变换参数
        dataset.SetProjection(im_proj)  # 写入投影
    for i in range(im_bands):
        dataset.GetRasterBand(i + 1).WriteArray(im_data[i])
    del dataset



# 像素坐标和地理坐标仿射变换
def CoordTransf(Xpixel, Ypixel, GeoTransform):
    XGeo = GeoTransform[0] + GeoTransform[1] * Xpixel + Ypixel * GeoTransform[2]
    YGeo = GeoTransform[3] + GeoTransform[4] * Xpixel + Ypixel * GeoTransform[5]
    return XGeo, YGeo


'''
滑动窗口裁剪Tif影像
TifPath 影像路径
SavePath 裁剪后影像保存目录
CropSize 裁剪尺寸
RepetitionRate 重叠度
'''
def TifCrop(TifPath, SavePath, CropSize, RepetitionRate):
    print("--------------------裁剪影像-----------------------")
    CropSize = int(CropSize)
    RepetitionRate = float(RepetitionRate)
    dataset_img = gdal.Open(TifPath)
    if dataset_img == None:
        print(TifPath + "文件无法打开")

    if not os.path.exists(SavePath):
        os.makedirs(SavePath)

    width = dataset_img.RasterXSize     # 获取行列数
    height = dataset_img.RasterYSize
    bands = dataset_img.RasterCount  # 获取波段数
    print("行数为：", height)
    print("列数为：", width)
    print("波段数为：", bands)

    proj = dataset_img.GetProjection()      # 获取投影信息
    geotrans = dataset_img.GetGeoTransform()        # 获取仿射矩阵信息
    img = dataset_img.ReadAsArray(0, 0, width, height)  # 获取数据

    #  行上图像块数目
    RowNum = int((height - CropSize * RepetitionRate) / (CropSize * (1 - RepetitionRate)))
    #  列上图像块数目
    ColumnNum = int((width - CropSize * RepetitionRate) / (CropSize * (1 - RepetitionRate)))
    print("裁剪后行影像数为：", RowNum)
    print("裁剪后列影像数为：", ColumnNum)

    # 获取当前文件夹的文件个数len,并以len+1命名即将裁剪得到的图像
    new_name = len(os.listdir(SavePath)) + 1

    # 裁剪图片,重复率为RepetitionRate
    for i in range(RowNum):
        for j in range(ColumnNum):
            # 如果图像是单波段
            if (bands == 1):
                cropped = img[
                          int(i * CropSize * (1 - RepetitionRate)): int(i * CropSize * (1 - RepetitionRate)) + CropSize,
                          int(j * CropSize * (1 - RepetitionRate)): int(j * CropSize * (1 - RepetitionRate)) + CropSize]
            # 如果图像是多波段
            else:
                cropped = img[:,
                          int(i * CropSize * (1 - RepetitionRate)): int(i * CropSize * (1 - RepetitionRate)) + CropSize,
                          int(j * CropSize * (1 - RepetitionRate)): int(j * CropSize * (1 - RepetitionRate)) + CropSize]
            # 获取地理坐标
            XGeo, YGeo = CoordTransf(int(j * CropSize * (1 - RepetitionRate)),
                                     int(i * CropSize * (1 - RepetitionRate)),
                                     geotrans)
            crop_geotrans = (XGeo, geotrans[1], geotrans[2], YGeo, geotrans[4], geotrans[5])

            # 生成Tif图像
            writeTiff(cropped, crop_geotrans, proj, SavePath + "/%d.tif" % new_name)

            # 文件名 + 1
            new_name = new_name + 1
    # 向前裁剪最后一行
    for i in range(RowNum):
        if (bands == 1):
            cropped = img[int(i * CropSize * (1 - RepetitionRate)): int(i * CropSize * (1 - RepetitionRate)) + CropSize,
                      (width - CropSize): width]
        else:
            cropped = img[:,
                      int(i * CropSize * (1 - RepetitionRate)): int(i * CropSize * (1 - RepetitionRate)) + CropSize,
                      (width - CropSize): width]
        # 获取地理坐标
        XGeo, YGeo = CoordTransf(width - CropSize,
                                 int(i * CropSize * (1 - RepetitionRate)),
                                 geotrans)
        crop_geotrans = (XGeo, geotrans[1], geotrans[2], YGeo, geotrans[4], geotrans[5])

        # 生成Tif影像
        writeTiff(cropped, crop_geotrans, proj, SavePath + "/%d.tif" % new_name)

        new_name = new_name + 1
    # 向前裁剪最后一列
    for j in range(ColumnNum):
        if (bands == 1):
            cropped = img[(height - CropSize): height,
                      int(j * CropSize * (1 - RepetitionRate)): int(j * CropSize * (1 - RepetitionRate)) + CropSize]
        else:
            cropped = img[:,
                      (height - CropSize): height,
                      int(j * CropSize * (1 - RepetitionRate)): int(j * CropSize * (1 - RepetitionRate)) + CropSize]
        # 获取地理坐标
        XGeo, YGeo = CoordTransf(int(j * CropSize * (1 - RepetitionRate)),
                                 height - CropSize,
                                 geotrans)
        crop_geotrans = (XGeo, geotrans[1], geotrans[2], YGeo, geotrans[4], geotrans[5])
        # 生成tif影像
        writeTiff(cropped, crop_geotrans, proj, SavePath + "/%d.tif" % new_name)

        # 文件名 + 1
        new_name = new_name + 1
    # 裁剪右下角
    if (bands == 1):
        cropped = img[(height - CropSize): height,
                  (width - CropSize): width]
    else:
        cropped = img[:,
                  (height - CropSize): height,
                  (width - CropSize): width]

    XGeo, YGeo = CoordTransf(width - CropSize,
                             height - CropSize,
                             geotrans)
    crop_geotrans = (XGeo, geotrans[1], geotrans[2], YGeo, geotrans[4], geotrans[5])
    # 生成Tif影像
    writeTiff(cropped, crop_geotrans, proj, SavePath + "/%d.tif" % new_name)

    new_name = new_name + 1


if __name__ == '__main__':
    # 将影像裁剪为重复率为0.3的2048×2048的数据集
    TifCrop(r"F:/test/baiyun_ml.tif",
            r"F:/test/img", 2048, 0.3)

剔除全为背景的图像

import os, sys
try:
    import gdal
except:
    from osgeo import gdal
from numba import jit
import numpy as np

# 保存tif文件函数
def writeTiff(im_data, im_geotrans, im_proj, path):
    if 'int8' in im_data.dtype.name:
        datatype = gdal.GDT_Byte
    elif 'int16' in im_data.dtype.name:
        datatype = gdal.GDT_UInt16
    else:
        datatype = gdal.GDT_Float32
    if len(im_data.shape) == 3:
        im_bands, im_height, im_width = im_data.shape
    elif len(im_data.shape) == 2:
        im_data = np.array([im_data])
        im_bands, im_height, im_width = im_data.shape
    # 创建文件
    driver = gdal.GetDriverByName("GTiff")
    dataset = driver.Create(path, int(im_width), int(im_height), int(im_bands), datatype)
    if (dataset != None):
        dataset.SetGeoTransform(im_geotrans)  # 写入仿射变换参数
        dataset.SetProjection(im_proj)  # 写入投影
    for i in range(im_bands):
        dataset.GetRasterBand(i + 1).WriteArray(im_data[i])
    del dataset

'''
水体影像筛选函数
OriTifArrayPath 原始影像路径
MaskTifArrayPath 标签影像路径
EndImg 筛选后的原始影像路径
EndMask 筛选后的标签影像路径
'''
def TifScreen(OriTifArrayPath, MaskTifArrayPath, EndImg, EndMask):
    if not os.path.exists(EndImg):
        os.makedirs(EndImg)
    if not os.path.exists(EndMask):
        os.makedirs(EndMask)
    imgList = os.listdir(OriTifArrayPath)  # 读入文件夹
    imgList.sort(key=lambda x: int(x.split('.')[0]))  # 按照数字进行排序后按顺序读取文件夹下的图片
    ImgArray = []   #创建队列
    geotransArray = []
    projArray = []
    num_img = len(imgList)
    for TifPath in imgList:
        dataset_img = gdal.Open(OriTifArrayPath + TifPath)
        width_crop = dataset_img.RasterXSize  # 获取行列数
        height_crop = dataset_img.RasterYSize
        bands = dataset_img.RasterCount  # 获取波段数
        proj = dataset_img.GetProjection()  # 获取投影信息
        geotrans = dataset_img.GetGeoTransform()  # 获取仿射矩阵信息
        img = dataset_img.ReadAsArray(0, 0, width_crop, height_crop)  # 获取数据
        # print(TifPath)
        ImgArray.append(img)    # 将影像按顺序存入队列
        geotransArray.append(geotrans)
        projArray.append(proj)
    print("行数为：", height_crop)
    print("列数为：", width_crop)
    print("波段数为：", bands)
    print("读取全部影像数量为：", len(ImgArray))

    MaskList = os.listdir(MaskTifArrayPath)  # 读入文件夹
    MaskList.sort(key=lambda x: int(x.split('.')[0]))  # 按照数字进行排序后按顺序读取文件夹下的图片
    MaskArray = []
    geotrans_maskArray = []
    proj_maskArray = []
    for MaskTifPath in MaskList:
        dataset_mask = gdal.Open(MaskTifArrayPath + MaskTifPath)
        width_mask = dataset_mask.RasterXSize  # 获取行列数
        height_mask = dataset_mask.RasterYSize
        bands_mask = dataset_mask.RasterCount  # 获取波段数
        proj_mask = dataset_mask.GetProjection()  # 获取投影信息
        geotrans_mask = dataset_mask.GetGeoTransform()  # 获取仿射矩阵信息
        mask = dataset_mask.ReadAsArray(0, 0, width_mask, height_mask)  # 获取数据
        MaskArray.append(mask)    # 将影像按顺序存入队列
        geotrans_maskArray.append(geotrans_mask)
        proj_maskArray.append(proj_mask)
    print("行数为：", height_mask)
    print("列数为：", width_mask)
    print("波段数为：", bands_mask)
    print("读取全部掩膜数量为：", len(MaskArray))

    for i in range(len(MaskArray)):
        count = test_fast(MaskArray[i])
        name = i + 1
        if count != 0:
            print("图像保存成功")
            writeTiff(ImgArray[i], geotransArray[i], projArray[i], EndImg + "/%d.tif" % name)
            writeTiff(MaskArray[i], geotrans_maskArray[i], proj_maskArray[i], EndMask + "/%d.tif" % name)

# 循环加速，判断影像中是否含有水体
@jit(nopython=True)
def test_fast(img):
    count = 0
    for row in range(img.shape[0]):
        for col in range(img.shape[1]):
            if img[row, col] != 0:
                count = count + 1
    return count

if __name__ == '__main__':
    # 筛选出包含水体的图像
    TifScreen(r"F:/internship/code/ImagePreprocessing/data/test/img/",
              r"F:/internship/code/ImagePreprocessing/data/test/mask/",
              r"F:/internship/code/ImagePreprocessing/data/test/imgend",
              r"F:/internship/code/ImagePreprocessing/data/test/maskend")

拼接

import os
import sys
try:
    import gdal
except:
    from osgeo import gdal
import numpy as np

import os
from PIL import Image
import matplotlib.pyplot as plt



# 保存tif文件函数
def writeTiff(im_data, im_geotrans, im_proj, path):
    if 'int8' in im_data.dtype.name:
        datatype = gdal.GDT_Byte
    elif 'int16' in im_data.dtype.name:
        datatype = gdal.GDT_Uint16
    else:
        datatype = gdal.GDT_Float32
    if len(im_data.shape) == 3:
        im_bands, im_height, im_width = im_data.shape
    elif len(im_data.shape) == 2:
        im_data = np.array([im_data])
        im_bands, im_height, im_width = im_data.shape
    # 创建文件
    driver = gdal.GetDriverByName("GTiff")
    dataset = driver.Create(path, int(im_width), int(im_height), int(im_bands), datatype)
    if (dataset != None):
        dataset.SetGeoTransform(im_geotrans)  # 写入仿射变换参数
        dataset.SetProjection(im_proj)  # 写入投影
    for i in range(im_bands):
        dataset.GetRasterBand(i + 1).WriteArray(im_data[i])
    del dataset


# 像素坐标和地理坐标仿射变换
def CoordTransf(Xpixel, Ypixel, GeoTransform):
    XGeo = GeoTransform[0] + GeoTransform[1] * Xpixel + Ypixel * GeoTransform[2]
    YGeo = GeoTransform[3] + GeoTransform[4] * Xpixel + Ypixel * GeoTransform[5]
    return XGeo, YGeo
    
'''
影像拼接函数
OriTif 原始影像——提供地理坐标和拼接后的影像长宽
TifArrayPath 要拼接的影像
ResultPath 输出的结果影像
RepetitionRate 重叠度
'''
def TifStitch(OriTif, TifArrayPath, ResultPath, RepetitionRate):
    RepetitionRate = float(RepetitionRate)
    print("--------------------拼接影像-----------------------")
    dataset_img = gdal.Open(OriTif)
    width = dataset_img.RasterXSize  # 获取行列数
    height = dataset_img.RasterYSize
    bands = dataset_img.RasterCount  # 获取波段数
    proj = dataset_img.GetProjection()  # 获取投影信息
    geotrans = dataset_img.GetGeoTransform()  # 获取仿射矩阵信息
    ori_img = dataset_img.ReadAsArray(0, 0, width, height)  # 获取数据
    print("波段数为：", bands)

    # 先创建一个空矩阵
    if bands == 1:
        shape = [height, width]
    else:
        shape = [bands, height, width]
    result = np.zeros(shape, dtype='uint8')

    # 读取裁剪后的影像
    OriImgArray = []   #创建队列
    NameArray = []
    imgList = os.listdir(TifArrayPath)  # 读入文件夹
    imgList.sort(key=lambda x: int(x.split('.')[0]))  # 按照数字进行排序后按顺序读取文件夹下的图片
    for TifPath in imgList:
        # 读取tif影像
        # dataset_img = gdal.Open(TifArrayPath + TifPath)
        # width_crop = dataset_img.RasterXSize  # 获取行列数
        # height_crop = dataset_img.RasterYSize
        # bands_crop = dataset_img.RasterCount  # 获取波段数
        # img = dataset_img.ReadAsArray(0, 0, width_crop, height_crop)  # 获取数据

        # 读取png影像
        img = Image.open(TifArrayPath + TifPath)
        height_crop = img.height
        width_crop = img.width
        img = np.array(img)

        OriImgArray.append(img)    # 将影像按顺序存入队列
        name = TifPath.split('.')[0]
        # print(name)
        NameArray.append(name)
    print("读取全部影像数量为：", len(OriImgArray))

    #  行上图像块数目
    RowNum = int((height - height_crop * RepetitionRate) / (height_crop * (1 - RepetitionRate)))
    #  列上图像块数目
    ColumnNum = int((width - width_crop * RepetitionRate) / (width_crop * (1 - RepetitionRate)))
    # 获取图像总数
    sum_img = RowNum * ColumnNum + RowNum + ColumnNum + 1
    print("行影像数为：", RowNum)
    print("列影像数为：", ColumnNum)
    print("图像总数为：", sum_img)

	# 前面读取的是剔除了背景影像的剩余影像，拼接按照图像名称拼接，因此需再创建全为背景的影像，填充影像列表
    # 创建空矩阵
    if bands_crop == 1:
        shape_crop = [height_crop, width_crop]
    else:
        shape_crop = [bands_crop, height_crop, width_crop]
    img_crop = np.zeros(shape_crop)  # 创建空矩阵
    # 创建整体图像列表
    ImgArray = []
    count = 0
    for i in range(sum_img):
        img_name = i + 1
        for j in range(len(OriImgArray)):
            if img_name == int(NameArray[j]):
                image = OriImgArray[j]
                count = count + 1
                break
            else:
                image = img_crop
        ImgArray.append(image)

    print("包含水体的图象数量为：", count)
    print("整个影像列表数量为：", len(ImgArray))


 # 开始赋值
    num = 0
    for i in range(RowNum):
        for j in range(ColumnNum):
            # 如果图像是单波段
            if (bands == 1):
                result[int(i * height_crop * (1 - RepetitionRate)): int(i * height_crop * (1 - RepetitionRate)) + height_crop,
                            int(j * width_crop * (1 - RepetitionRate)): int(j * width_crop * (1 - RepetitionRate)) + width_crop] = ImgArray[num]
            # 如果图像是多波段
            else:
                result[:,
                            int(i * height_crop * (1 - RepetitionRate)): int(i * height_crop * (1 - RepetitionRate)) + height_crop,
                            int(j * width_crop * (1 - RepetitionRate)): int(j * width_crop * (1 - RepetitionRate)) + width_crop] = ImgArray[num]
            num = num + 1
    # 最后一行
    for i in range(RowNum):
        if (bands == 1):
            result[int(i * height_crop * (1 - RepetitionRate)): int(i * height_crop * (1 - RepetitionRate)) + height_crop,
                      (width - width_crop): width] = ImgArray[num]
        else:
            result[:,
                      int(i * height_crop * (1 - RepetitionRate)): int(i * height_crop * (1 - RepetitionRate)) + height_crop,
                      (width - width_crop): width] = ImgArray[num]
        num = num + 1
    # 最后一列
    for j in range(ColumnNum):
        if (bands == 1):
            result[(height - height_crop): height,
                      int(j * width_crop * (1 - RepetitionRate)): int(j * width_crop * (1 - RepetitionRate)) + width_crop] = ImgArray[num]
        else:
            result[:,
                      (height - height_crop): height,
                      int(j * width_crop * (1 - RepetitionRate)): int(j * width_crop * (1 - RepetitionRate)) + width_crop] = ImgArray[num]
        num = num + 1
    # 右下角
    if (bands == 1):
        result[(height - height_crop): height,
                        (width - width_crop): width] = ImgArray[num]
    else:
        result[:,
                    (height - height_crop): height,
                    (width - width_crop): width] = ImgArray[num]
    num = num + 1
    # 生成Tif影像

    writeTiff(result, geotrans, proj, ResultPath)


if __name__ == '__main__':
    # 拼接影像
    TifStitch(r"G:/水体提取/LY/baiyun.tif",
              r"F:/test/mask2/",
              r"F:/test/merge.tif", 0.3)

Tiff转PNG

import os,sys
import cv2
import numpy as np
from skimage import io#使用IO库读取tif图片


def tif_png_transform(file_path_name, bgr_savepath_name):
    img = io.imread(file_path_name)#读取文件名
    img = img / img.max()#使其所有值不大于一
    img = img * 255 - 0.001  # 减去0.001防止变成负整型
    img = img.astype(np.uint8)#强制转换成8位整型
    # img = np.array([img,img,img])
    # img = img.transpose(1,2,0)
    # print(img.shape)  # 显示图片大小和深度
    if len(img.shape) == 3:
        b = img[:, :, 0]  # 读取蓝通道
        g = img[:, :, 1]  # 读取绿通道
        r = img[:, :, 2]  # 读取红通道
        bgr = cv2.merge([r, g, b])  # 通道拼接
        cv2.imwrite(bgr_savepath_name, bgr)#图片存储
        # print("tif转png")
    elif len(img.shape) == 2:
        cv2.imwrite(bgr_savepath_name, img)  # 图片存储


tif_file_path = r'F:/internship/code/ImagePreprocessing/data/test/maskend'# 为tif图片的文件夹路径
png_path = r'F:/internship/code/ImagePreprocessing/data/test/maskpng'
if not os.path.exists(png_path):
    os.makedirs(png_path)
tif_fileList = os.listdir(tif_file_path)
for tif_file in tif_fileList:
    file_path_name = tif_file_path + '/' + tif_file
    png_path_name = png_path + '/' + tif_file.split('.')[0] + '.png' #.png图片的保存路径
    tif_png_transform(file_path_name, png_path_name)

最终结果

在这里插入图片描述
在这里插入图片描述

一只盒饭
关注
  • 19
    点赞
  • 踩
  • 148
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
深度学习预测中的裁剪拼接去除接缝解决方案（遥感影像）
rae2019的博客
07-21 1080
采用影像分块叠加策略，逐块预测，块与块之间按一定的步长进行重叠，最后有价值的预测结果只取块的中间一圈。这样就避免了块边缘区域的预测不准造成的拼接痕迹。
python：多波段遥感影像镶嵌与裁剪
weixin_57058676的博客
04-15 855
首先，我们需要在内存中创建一个“空”的镶嵌结果栅格，来接收我们的遥感数据。这个栅格有多大、几个波段、数据类型是什么都需要设置，以及给它添加坐标意义（投影、地理转换信息）。接下来，我们需要将每一幅输入影像的数据写入到我们创建的“空”栅格中。这个过程需要对每一幅影像进行遍历，并计算其在镶嵌结果栅格中的位置。影像镶嵌是指将多幅相邻的遥感影像拼接成一个连续的、无缝的大范围影像的过程。tiffiles_path_list是一个有多个遥感影像路径的列表。在Python中，我们可以使用GDAL的。
python+gdal+遥感图像拼接(mosaic)的实例
09-17
主要介绍了python+gdal+遥感图像拼接(mosaic)的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
使用 Python进行数据集分割：简洁完美的数据集划分脚本
lythinking的博客
01-01 1955
在机器学习的世界中，正确准备数据集与您选择的算法一样重要。将数据集划分为训练集、验证集和测试集的过程是构建稳健模型的基本步骤。本文深入研究了专门为此目的设计的 Python 脚本，展示了如何有效地分割机器学习项目的数据集，特别是 YOLOv5 PyTorch 模型。
遥感数据集制作（Potsdam数据集为例）：TIF图像转JPG，TIF标签转PNG，图像重叠裁剪
lalula的博客
05-15 1411
遥感图像不同于一般的自然图像，由于波段数量、图像位深度等原因，TIF图像数据不能使用简单的格式转换方法。本文以Potsdam数据集为例，制作能够直接用于深度学习的数据集。Potsdam数据集的内容如下：本文使用2_Ortho_RGB（图像数据RGB通道顺序）和5_Labels_all（标签数据）作为示例进行数据集制作。
基于大遥感影像的目标检测数据集的裁剪
自度度人 自觉觉他
08-17 1774
遥感影像一般比较大，对于高分辨率的影像会更大。从百度地球下载的一个县的高分辨率的影像（0.3米）可能包括几十万行几十万列。 这种几万行列甚至几十万行列的影像不利于模型的训练，有必要进行分块裁剪、分片处理，例如切分成512*512或者1024*1024的影像。影像分片，对于语义分割的标注是很容易裁剪，只需按照固定的顺序裁剪即可。但是对于目标检测的裁剪，标注框的裁剪有点麻烦。 如下图所示，影像对应的标注框。本文介绍一下影像进行分块裁剪和标注框分块生成的思路。 ...
遥感图像变化检测数据集的制作（深度学习）
qq_41627642的博客
09-10 2132
一、大幅的遥感影像（TIF）格式裁剪到2048后，转化为png格式 ### 2.1 tif格式图像的切 '''- 切割环境：**python3、gdal、windows** - **Gdal的安装：** - **tif格式图像的切割代码：**''' import os import numpy from osgeo import gdal from PIL import Image Image.MAX_IMAGE_PIXELS = None class GRID: # 读TIF图像文件
使用python的geopands和rasterio批量裁剪遥感数据
心中有梦，眼里有光
05-19 2484
文章目录前言一、geopandas和rasterio的安装二、批量裁剪和镶嵌1.数据准备2.镶嵌总结 前言 这几天在跑模型的时候，需要对遥感影像批量裁剪和镶嵌，本来想使用arcpy完成，但是由于arcpy裁剪工具Spatial Analyst-Extraction-Extract by Mask工具裁剪出来是栅格数据集的形式，不能直接得到tif文件，于是就想直接用python完成。想着以后可能会经常用到这个工具，于是把裁剪和镶嵌代码一起实现了。 一、geopandas和rasterio的安装 这里建议在
【Python&RS】基于GDAL镶嵌拼接遥感影像
Remote Sensing迷途小书童
06-29 3487
处理高分辨率影像时，数据高达几十G。用ENVI或者ArcGIS进行影像的拼接时，往往会出现未响应的情况。本博文基于Python的GDAL库实现遥感影像的镶嵌拼接，稳定性和处理速度都有所提高。
Python遥感图像处理指南(5)-投影、镶嵌、裁剪和叠加
gis收藏家的博客
12-20 968
在前几章中，我们可以提取到水体掩膜，但我们的算法有时候不是很准确，需要其他数据源来进行对比分析，本章我们将利用来进行教学操作，该数据提供了过去三十六年全球范围内水面的位置和时间分布图，并提供了有关水面范围和变化的统计数据，这是一个非常实用的全球水资源研究数据库。
gdal裁剪tif_tif遥感图像_GDAL裁剪_遥感影像_GDAL_gdal批量裁剪_
10-01
本教程将深入探讨如何使用GDAL进行TIFF图像的裁剪，尤其是针对遥感影像的批量裁剪。 1. **GDAL简介** GDAL是多平台的数据转换工具，支持读取、写入和处理各种地理空间数据。它提供了一个丰富的API，允许开发者编写...
MOD06.rar_MOD06_MODIS_python_tiff_影像拼接
07-14
对tiff格式影像实现批量拼接、裁剪和提取有效值，以MODIS数据的MOD06产品为例
基于Deeplab-v3算法实现对遥感图像的语义分割python源码(带详细注释+项目说明+数据集+模型).zip
12-20
- [x] 将原始的遥感图像裁成大小为(256x256)的图片块，裁剪的方法为随机采样，并进行数据扩增 - [x] 搭建Deeplab-v3模型，使用预训练的 resnet-v2-50 迁移学习 - [x] 完整的训练测试程序，使用 tensorboard 监控模型...
拼接与裁剪.rar
07-02
本话题主要涉及的是一个名为“拼接与裁剪.rar”的压缩包文件，其中包含了一个用于图像拼接与裁剪的小工具。这个工具利用了GDAL（Geospatial Data Abstraction Library）库，一个强大的开源地理空间数据处理库，不仅...
python影像裁剪并保存成tiff格式（滑动窗口法）
m0_50294896的博客
05-22 4671
博主在上一篇文章python影像裁剪并保存成tiff格式（规则网格法）中介绍了将遥感影像按照网格切分，本章介绍滑动窗口的切分方法。 介绍 滑动窗口和规则网格的区别如下 规则网格： 滑动窗口： 此外，还有一种随机裁剪的方法 读取tiff文件数据，整理成我们需要的数组格式，将数组保存成tiff文件，和波段的叠加，mask矩阵的构建等等请参考博主之前的文章python影像裁剪并保存成tiff格式（规则网格法），内容不再重复，我们直接基于上篇文章开始修改，将规则网格升级为滑动窗口。当滑动窗口的重叠率为0时，就
【Python】pandas：排序、重复值、缺省值处理、合并、分组
yannan20190313的博客
07-30 1293
【Python】pandas：排序（sort_index,sort_values,nsmallest,nlargest）、重复值（duplicated,drop_duplicates,value_counts,nunique）、缺省值处理（isna,isnull,notna,notnull,fillna,dropna,replace）、合并（join,merge,append,concat）、分组（groupby）
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 523
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
十个好用到爆炸的Python技巧
最新发布
qq_36807888的博客
07-30 758
生成器表达式与列表推导式类似，但它创建的是一个迭代器，而不是一个完整的列表。zip(names, ages) 创建一个迭代器，该迭代器生成由 names 和 ages 列表中对应位置的元素组成的元组。defaultdict(int) 创建一个字典，如果访问的键不存在，则默认值为 0 (int 类型的默认值)。惰性求值: 元素是在需要时才计算的，而不是预先计算好存储在内存中，这在处理包含复杂计算的序列时非常有用。wrapper 函数是装饰器函数内部定义的函数，它调用被装饰的函数，并将结果转换为大写。
用python滑动裁剪遥感影像，然后拼接起来
06-03
以下是使用 Python 对遥感影像进行滑动裁剪并拼接的代码示例： ```python import numpy as np from PIL import Image # 加载图像 image = Image.open('test_image.jpg') image = np.array(image) # 定义裁剪大小和步长 crop_size = 512 stride = 256 # 滑动裁剪 rows, cols, _ = image.shape crop_rows = (rows - crop_size) // stride + 1 crop_cols = (cols - crop_size) // stride + 1 crop_images = [] for i in range(crop_rows): for j in range(crop_cols): x = i * stride y = j * stride crop_image = image[x:x+crop_size, y:y+crop_size, :] crop_images.append(crop_image) # 拼接图像 col_images = [] for i in range(crop_rows): col_images.append(np.concatenate(crop_images[i*crop_cols:(i+1)*crop_cols], axis=1)) merged_image = np.concatenate(col_images, axis=0) # 保存图像 merged_image = Image.fromarray(merged_image.astype(np.uint8)) merged_image.save('merged_image.jpg') ``` 在这个示例中，我们首先加载了一张遥感影像作为测试图像，然后定义了裁剪大小和步长。接着，对测试图像进行了滑动裁剪，将裁剪后的小图像存储在 crop_images 列表中。最后，对裁剪后的小图像进行拼接，生成完整的图像，并保存为一张图像文件。你可以根据自己的需求修改代码，进行不同大小和步长的裁剪和拼接。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值