R光栅包分割图像成倍数
R raster package split image into multiples
我有一张图片如下。它是 2579*2388 像素。假设它的左下角位于 0,0。从该图像我想创建多个图像如下并将它们保存在工作文件夹中。每张图片的大小为 100*100 像素。每张图片将按其左下角坐标保存。
- 第一张图片的左下角为 0,0。右上
手角将为 100,100，图像将另存为
0-0.jpg
- second 的左下角位于 10,0。右上角
角将在 110,100，图像将保存为 10-0.jpg
- 底行完成后，Y坐标将移动10。在
在第二行的情况下，第一张图像将位于 0,10 并且该图像
将保存为 0-10.jpg
最快的方法是什么？有没有可以非常快地完成的 R 包？
我了解到在当前图像的情况下，它会将其拆分为大约 257*238 个图像。但是我有足够的磁盘 space 并且我需要每个图像来执行文本检测。
可以使用gdal和r，如图link。
然后您将修改第 23 行以进行适当的偏移以允许生成的图块之间重叠。
这是一种方法，通过 gdalUtils 使用 GDAL，并根据需要进行并行化。
library(gdalUtils)
# Get the dimensions of the jpg
dims <- as.numeric(
strsplit(gsub('Size is|\s+', '', grep('Size is', gdalinfo('R1fqE.jpg'), value=TRUE)),
',')[[1]]
)
# Set the window increment, width and height
incr <- 10
win_width <- 100
win_height <- 100
# Create a data.frame containing coordinates of the lower-left
# corners of the windows, and the corresponding output filenames.
xy <- setNames(expand.grid(seq(0, dims[1], incr), seq(dims[2], 0, -incr)),
c('llx', 'lly'))
xy$nm <- paste0(xy$llx, '-', dims[2] - xy$lly, '.png')
# Create a function to split the raster using gdalUtils::gdal_translate
split_rast <- function(infile, outfile, llx, lly, win_width, win_height) {
library(gdalUtils)
gdal_translate(infile, outfile,
srcwin=c(llx, lly - win_height, win_width, win_height))
}
将函数应用于单个 window 的示例：
split_rast('R1fqE.jpg', xy$nm[1], xy$llx[1], xy$lly[1], 100, 100)
将其应用于前 10 个的示例 windows:
mapply(split_rast, 'R1fqE.jpg', xy$nm[1:10], xy$llx[1:10], xy$lly[1:10], 100, 100)
并行使用 parLapply 到 运行 的示例：
library(parallel)
cl <- makeCluster(4) # e.g. use 4 cores
clusterExport(cl, c('split_rast', 'xy'))
system.time({
parLapply(cl, seq_len(nrow(xy)), function(i) {
split_rast('R1fqE.jpg', xy$nm[i], xy$llx[i], xy$lly[i], 100, 100)
})
})
stopCluster(cl)
找不到直接使用 r I used the following approach using raster 其他人可能感兴趣的操作的直接实现。它生成范围并将原始栅格裁剪到它们。希望这对您有所帮助！
## create dummy raster
n <- 50
r <- raster(ncol=n, nrow=n, xmn=4, xmx=10, ymn=52, ymx=54)
projection(r) <- "+proj=longlat +datum=WGS84 +ellps=WGS84 +towgs84=0,0,0"
values(r) <- 1:n^2+rnorm(n^2)
n.side <- 2 # number of tiles per side
dx <- (extent(r)[2]- extent(r)[1])/ n.side # extent of one tile in x direction
dy <- (extent(r)[4]- extent(r)[3])/ n.side # extent of one tile in y direction
xs <- seq(extent(r)[1], by= dx, length= n.side) #lower left x-coordinates
ys <- seq(extent(r)[3], by= dy, length= n.side) #lower left y-coordinates
cS <- expand.grid(x= xs, y= ys)
## loop over extents and crop
for(i in 1:nrow(cS)) {
ex1 <- c(cS[i,1], cS[i,1]+dx, cS[i,2], cS[i,2]+dy) # create extents for cropping raster
cl1 <- crop(r, ex1) # crop raster by extent
writeRaster(x = cl1, filename=paste("test",i,".tif", sep=""), format="GTiff", overwrite=T) # write to file
}
## check functionality...
test <- raster(paste("test1.tif", sep=""))
plot(test)
这是使用 "raster" 包的另一种方法。该函数在空间上聚合要切割的栅格，将聚合的栅格像元转换为多边形，然后使用每个多边形的范围来裁剪输入栅格。
我确信有复杂而紧凑的方法可以做到这一点，但这种方法对我很有效，而且我发现它也很直观。我希望你也觉得它有用。请注意，下面的第 4 部分和第 5 部分仅用于测试，它们不是函数的一部分。
第 1 部分：加载和绘制样本栅格数据
logo <- raster(system.file("external/rlogo.grd", package="raster"))
plot(logo,axes=F,legend=F,bty="n",box=FALSE)
第 2 部分：函数本身：
# The function spatially aggregates the original raster
# it turns each aggregated cell into a polygon
# then the extent of each polygon is used to crop
# the original raster.
# The function returns a list with all the pieces
# in case you want to keep them in the memory.
# it saves and plots each piece
# The arguments are:
# raster = raster to be chopped (raster object)
# ppside = pieces per side (integer)
# save = write raster (TRUE or FALSE)
# plot = do you want to plot the output? (TRUE or FALSE)
SplitRas <- function(raster,ppside,save,plot){
h <- ceiling(ncol(raster)/ppside)
v <- ceiling(nrow(raster)/ppside)
agg <- aggregate(raster,fact=c(h,v))
agg[] <- 1:ncell(agg)
agg_poly <- rasterToPolygons(agg)
names(agg_poly) <- "polis"
r_list <- list()
for(i in 1:ncell(agg)){
e1 <- extent(agg_poly[agg_poly$polis==i,])
r_list[[i]] <- crop(raster,e1)
}
if(save==T){
for(i in 1:length(r_list)){
writeRaster(r_list[[i]],filename=paste("SplitRas",i,sep=""),
format="GTiff",datatype="FLT4S",overwrite=TRUE)
}
}
if(plot==T){
par(mfrow=c(ppside,ppside))
for(i in 1:length(r_list)){
plot(r_list[[i]],axes=F,legend=F,bty="n",box=FALSE)
}
}
return(r_list)
}
第 3 部分：测试函数
SplitRas(raster=logo,ppside=3,save=TRUE,plot=TRUE)
# in this example we chopped the raster in 3 pieces per side
# so 9 pieces in total
# now the raster pieces should be ready
# to be processed in the default directory
# A feature I like about this function is that it plots
# the pieces in the original order.
第 4 部分：运行 每件作品上的代码并将它们保存回目录中
# notice if you cropped a rasterbrick
# use "brick" instead of "raster" to read
# the piece back in R
list2 <- list()
for(i in 1:9){ # change this 9 depending on your number of pieces
rx <- raster(paste("SplitRas",i,".tif",sep=""))
# piece_processed <- HERE YOU RUN YOUR CODE
writeRaster(piece_processed,filename=paste("SplitRas",i,sep=""),
format="GTiff",datatype="FLT4S",overwrite=TRUE)
}
# once a code has been ran on those pieces
# we save them back in the directory
# with the same name for convenience
第 5 部分：让我们把碎片重新组合起来
# read each piece back in R
list2 <- list()
for(i in 1:9){ # change this 9 depending on your number of pieces
rx <- raster(paste("SplitRas",i,".tif",sep=""))
list2[[i]] <- rx
}
# mosaic them, plot mosaic & save output
list2$fun <- max
rast.mosaic <- do.call(mosaic,list2)
plot(rast.mosaic,axes=F,legend=F,bty="n",box=FALSE)
writeRaster(rast.mosaic,filename=paste("Mosaicked_ras",sep=""),
format="GTiff",datatype="FLT4S",overwrite=TRUE)
这有点晚了，但可能对其他遇到这个问题的人有用。 SpaDES package has a handy function called splitRaster() 可以满足您的需求。
一个例子：
library(raster)
library(SpaDES)
# Create grid
the_grid=raster(xmn=0, xmx=100, ymn=0, ymx=100, resolution=1)
# Set some values
the_grid[0:50,0:50] <- 1
the_grid[51:100,51:100] <- 2
the_grid[51:100,0:50] <- 3
the_grid[0:50,51:100] <- 4
这给了你这个：
现在使用 SpaDES package 进行拆分。根据您想要的沿 x 轴和 y 轴的瓷砖数量设置 nx 和 ny - 如果我们想要 4 个瓷砖，将它们设置为 nx=2 和 ny=2。如果您不设置 path，它应该将文件写入您的当前目录。还提供其他功能，例如缓冲 - 请参阅 ?splitRaster:
# Split into sections - saves automatically to path
sections=splitRaster(the_grid, nx=2, ny=2, path="/your_output_path/")
变量 sections 是一个栅格列表，每个栅格对应 the_grid - 访问它们：
split_1=sections[[1]]
如果你想专门保存它们，就用writeRaster()。
要再次创建组合栅格，请使用 mergeRaster()。
我认为您需要为您的处理部分创建一个函数（我们称之为 "fnc"）和一个 table 列出您制作的瓷砖数量（我们称之为"tile.tbl") 并且假设您的地理大数据名为 "obj"
obj=GDALinfo("/pathtodata.tif")
tile.tbl <- getSpatialTiles(obj, block.x= your size of interest, return.SpatialPolygons=FALSE)
然后使用降雪包将其并行化。这是一个例子：
library(snowfall)
sfInit(parallel=TRUE, cpus=parallel::detectCores())
sfExport("tile.tbl", "fnc")
sfLibrary(rgdal)
sfLibrary(raster)
out.lst <- sfClusterApplyLB(1:nrow(tile.tbl), function(x){ fnc(x, tile.tbl) })
sfStop()
详细解释请看HERE
@Shepherd 提出的方法可行，但是您需要预先定义图像将被划分的块数（ppside 参数）。我们经常需要获得相同大小的补丁（例如训练 CNN）。此外，将@Shepherd 方法应用于具有不同尺寸的图像列表可能会出现问题。
这是使用 raster 包将图像划分为相等块的方法。
我们要创建一些玩具数据。 35x64 光栅。我们想将栅格分成 10x10 块。 patch_size = 10.
my_img = raster(nrow=64, ncol=35)
values(my_img) = 1:ncell(my_img)
我们定义 patchifyR 函数将执行以下操作：
patchifyR <- function(img, patch_size){
# load raster
if (!require("raster")) install.packages("raster")
suppressPackageStartupMessages({library(raster)})
# create image divisible by the patch_size
message(paste0("Cropping original image. ", "Making it divisible by ", patch_size, "."))
x_max <- patch_size*trunc(nrow(img)/patch_size)
y_max <- patch_size*trunc(ncol(img)/patch_size)
img <- crop(img, extent(img, 1, x_max, 1, y_max))
# initializers
lx = 1; ly = 1; p = 1
ls.patches <- list()
ls.coordinates <- list()
# extract patches
for(i in 1:(nrow(img)/patch_size)){
for(j in 1:(ncol(img)/patch_size)){
ls.patches[[p]] <- crop(img, extent(img, lx, (lx+patch_size)-1, ly, (ly+patch_size)-1))
ls.coordinates[[p]] <- as.character(paste0("P_", p, "_X0_", lx, "_X1_", (lx+patch_size)-1, "_Y0_", ly, "_Y1_", (ly+patch_size)-1))
message(paste0("Patch ", p, " created. Coordinates: ", "X0_", lx, "_X1_", (lx+patch_size)-1, "_Y0_", ly, "_Y1_", (ly+patch_size)-1))
p = p + 1
ly = ly + patch_size
}
ly = 1
lx = lx + patch_size
}
# merge results: $patches and $names
message("Matching results ... ")
patchify <- list("patches"=ls.patches, "names"=ls.coordinates)
# return
message("Successfully completed.")
return(patchify)
}
首先，我们将裁剪光栅以创建可被 patch_size 整除的图像。如果我们的图块重叠度大于 patch_size，我们将不会丢失信息。
然后我们使用 crop 函数和双 for 循环来遍历坐标来创建不同的补丁。
patchifyR函数接收两个参数：
img: 输入图像。 RasterLayer 或 RasterStack。
patch_size: 路径大小。 10 创建 10x10 像素块。
patchifyR函数returns两个列表：
patchify$patches: 包含所有补丁的列表（RasterLayer 或 RasterStack）
patchify$names: 包含每个补丁的名称及其坐标。
我们来测试一下函数：
my_patches <- patchifyR(img=my_img, patch_size=10)
最后我们可以使用以下方法将结果保存到磁盘：
output_directory <- "D:/my_output/"
for(i in 1:length(my_patches$patches)){
writeRaster(my_patches$patches[[i]], paste0(output_directory, my_patches$names[[i]], ".tif"), drivername="Gtiff", overwrite=TRUE)
}
我有一张图片如下。它是 2579*2388 像素。假设它的左下角位于 0,0。从该图像我想创建多个图像如下并将它们保存在工作文件夹中。每张图片的大小为 100*100 像素。每张图片将按其左下角坐标保存。
- 第一张图片的左下角为 0,0。右上 手角将为 100,100，图像将另存为 0-0.jpg
- second 的左下角位于 10,0。右上角 角将在 110,100，图像将保存为 10-0.jpg
- 底行完成后，Y坐标将移动10。在 在第二行的情况下，第一张图像将位于 0,10 并且该图像 将保存为 0-10.jpg
最快的方法是什么？有没有可以非常快地完成的 R 包？
我了解到在当前图像的情况下，它会将其拆分为大约 257*238 个图像。但是我有足够的磁盘 space 并且我需要每个图像来执行文本检测。
可以使用gdal和r，如图link。
然后您将修改第 23 行以进行适当的偏移以允许生成的图块之间重叠。
这是一种方法，通过 gdalUtils 使用 GDAL，并根据需要进行并行化。
library(gdalUtils)
# Get the dimensions of the jpg
dims <- as.numeric(
strsplit(gsub('Size is|\s+', '', grep('Size is', gdalinfo('R1fqE.jpg'), value=TRUE)),
',')[[1]]
)
# Set the window increment, width and height
incr <- 10
win_width <- 100
win_height <- 100
# Create a data.frame containing coordinates of the lower-left
# corners of the windows, and the corresponding output filenames.
xy <- setNames(expand.grid(seq(0, dims[1], incr), seq(dims[2], 0, -incr)),
c('llx', 'lly'))
xy$nm <- paste0(xy$llx, '-', dims[2] - xy$lly, '.png')
# Create a function to split the raster using gdalUtils::gdal_translate
split_rast <- function(infile, outfile, llx, lly, win_width, win_height) {
library(gdalUtils)
gdal_translate(infile, outfile,
srcwin=c(llx, lly - win_height, win_width, win_height))
}
将函数应用于单个 window 的示例：
split_rast('R1fqE.jpg', xy$nm[1], xy$llx[1], xy$lly[1], 100, 100)
将其应用于前 10 个的示例 windows:
mapply(split_rast, 'R1fqE.jpg', xy$nm[1:10], xy$llx[1:10], xy$lly[1:10], 100, 100)
并行使用 parLapply 到 运行 的示例：
library(parallel)
cl <- makeCluster(4) # e.g. use 4 cores
clusterExport(cl, c('split_rast', 'xy'))
system.time({
parLapply(cl, seq_len(nrow(xy)), function(i) {
split_rast('R1fqE.jpg', xy$nm[i], xy$llx[i], xy$lly[i], 100, 100)
})
})
stopCluster(cl)
找不到直接使用 r I used the following approach using raster 其他人可能感兴趣的操作的直接实现。它生成范围并将原始栅格裁剪到它们。希望这对您有所帮助！
## create dummy raster
n <- 50
r <- raster(ncol=n, nrow=n, xmn=4, xmx=10, ymn=52, ymx=54)
projection(r) <- "+proj=longlat +datum=WGS84 +ellps=WGS84 +towgs84=0,0,0"
values(r) <- 1:n^2+rnorm(n^2)
n.side <- 2 # number of tiles per side
dx <- (extent(r)[2]- extent(r)[1])/ n.side # extent of one tile in x direction
dy <- (extent(r)[4]- extent(r)[3])/ n.side # extent of one tile in y direction
xs <- seq(extent(r)[1], by= dx, length= n.side) #lower left x-coordinates
ys <- seq(extent(r)[3], by= dy, length= n.side) #lower left y-coordinates
cS <- expand.grid(x= xs, y= ys)
## loop over extents and crop
for(i in 1:nrow(cS)) {
ex1 <- c(cS[i,1], cS[i,1]+dx, cS[i,2], cS[i,2]+dy) # create extents for cropping raster
cl1 <- crop(r, ex1) # crop raster by extent
writeRaster(x = cl1, filename=paste("test",i,".tif", sep=""), format="GTiff", overwrite=T) # write to file
}
## check functionality...
test <- raster(paste("test1.tif", sep=""))
plot(test)
这是使用 "raster" 包的另一种方法。该函数在空间上聚合要切割的栅格，将聚合的栅格像元转换为多边形，然后使用每个多边形的范围来裁剪输入栅格。
我确信有复杂而紧凑的方法可以做到这一点，但这种方法对我很有效，而且我发现它也很直观。我希望你也觉得它有用。请注意，下面的第 4 部分和第 5 部分仅用于测试，它们不是函数的一部分。
第 1 部分：加载和绘制样本栅格数据
logo <- raster(system.file("external/rlogo.grd", package="raster"))
plot(logo,axes=F,legend=F,bty="n",box=FALSE)
第 2 部分：函数本身：
# The function spatially aggregates the original raster
# it turns each aggregated cell into a polygon
# then the extent of each polygon is used to crop
# the original raster.
# The function returns a list with all the pieces
# in case you want to keep them in the memory.
# it saves and plots each piece
# The arguments are:
# raster = raster to be chopped (raster object)
# ppside = pieces per side (integer)
# save = write raster (TRUE or FALSE)
# plot = do you want to plot the output? (TRUE or FALSE)
SplitRas <- function(raster,ppside,save,plot){
h <- ceiling(ncol(raster)/ppside)
v <- ceiling(nrow(raster)/ppside)
agg <- aggregate(raster,fact=c(h,v))
agg[] <- 1:ncell(agg)
agg_poly <- rasterToPolygons(agg)
names(agg_poly) <- "polis"
r_list <- list()
for(i in 1:ncell(agg)){
e1 <- extent(agg_poly[agg_poly$polis==i,])
r_list[[i]] <- crop(raster,e1)
}
if(save==T){
for(i in 1:length(r_list)){
writeRaster(r_list[[i]],filename=paste("SplitRas",i,sep=""),
format="GTiff",datatype="FLT4S",overwrite=TRUE)
}
}
if(plot==T){
par(mfrow=c(ppside,ppside))
for(i in 1:length(r_list)){
plot(r_list[[i]],axes=F,legend=F,bty="n",box=FALSE)
}
}
return(r_list)
}
第 3 部分：测试函数
SplitRas(raster=logo,ppside=3,save=TRUE,plot=TRUE)
# in this example we chopped the raster in 3 pieces per side
# so 9 pieces in total
# now the raster pieces should be ready
# to be processed in the default directory
# A feature I like about this function is that it plots
# the pieces in the original order.
第 4 部分：运行 每件作品上的代码并将它们保存回目录中
# notice if you cropped a rasterbrick
# use "brick" instead of "raster" to read
# the piece back in R
list2 <- list()
for(i in 1:9){ # change this 9 depending on your number of pieces
rx <- raster(paste("SplitRas",i,".tif",sep=""))
# piece_processed <- HERE YOU RUN YOUR CODE
writeRaster(piece_processed,filename=paste("SplitRas",i,sep=""),
format="GTiff",datatype="FLT4S",overwrite=TRUE)
}
# once a code has been ran on those pieces
# we save them back in the directory
# with the same name for convenience
第 5 部分：让我们把碎片重新组合起来
# read each piece back in R
list2 <- list()
for(i in 1:9){ # change this 9 depending on your number of pieces
rx <- raster(paste("SplitRas",i,".tif",sep=""))
list2[[i]] <- rx
}
# mosaic them, plot mosaic & save output
list2$fun <- max
rast.mosaic <- do.call(mosaic,list2)
plot(rast.mosaic,axes=F,legend=F,bty="n",box=FALSE)
writeRaster(rast.mosaic,filename=paste("Mosaicked_ras",sep=""),
format="GTiff",datatype="FLT4S",overwrite=TRUE)
这有点晚了，但可能对其他遇到这个问题的人有用。 SpaDES package has a handy function called splitRaster() 可以满足您的需求。
一个例子：
library(raster)
library(SpaDES)
# Create grid
the_grid=raster(xmn=0, xmx=100, ymn=0, ymx=100, resolution=1)
# Set some values
the_grid[0:50,0:50] <- 1
the_grid[51:100,51:100] <- 2
the_grid[51:100,0:50] <- 3
the_grid[0:50,51:100] <- 4
这给了你这个：
nx 和 ny - 如果我们想要 4 个瓷砖，将它们设置为 nx=2 和 ny=2。如果您不设置 path，它应该将文件写入您的当前目录。还提供其他功能，例如缓冲 - 请参阅 ?splitRaster:
# Split into sections - saves automatically to path
sections=splitRaster(the_grid, nx=2, ny=2, path="/your_output_path/")
变量 sections 是一个栅格列表，每个栅格对应 the_grid - 访问它们：
split_1=sections[[1]]
如果你想专门保存它们，就用writeRaster()。
要再次创建组合栅格，请使用 mergeRaster()。
我认为您需要为您的处理部分创建一个函数（我们称之为 "fnc"）和一个 table 列出您制作的瓷砖数量（我们称之为"tile.tbl") 并且假设您的地理大数据名为 "obj"
obj=GDALinfo("/pathtodata.tif")
tile.tbl <- getSpatialTiles(obj, block.x= your size of interest, return.SpatialPolygons=FALSE)
然后使用降雪包将其并行化。这是一个例子：
library(snowfall)
sfInit(parallel=TRUE, cpus=parallel::detectCores())
sfExport("tile.tbl", "fnc")
sfLibrary(rgdal)
sfLibrary(raster)
out.lst <- sfClusterApplyLB(1:nrow(tile.tbl), function(x){ fnc(x, tile.tbl) })
sfStop()
详细解释请看HERE
@Shepherd 提出的方法可行，但是您需要预先定义图像将被划分的块数（ppside 参数）。我们经常需要获得相同大小的补丁（例如训练 CNN）。此外，将@Shepherd 方法应用于具有不同尺寸的图像列表可能会出现问题。
这是使用 raster 包将图像划分为相等块的方法。
我们要创建一些玩具数据。 35x64 光栅。我们想将栅格分成 10x10 块。 patch_size = 10.
my_img = raster(nrow=64, ncol=35)
values(my_img) = 1:ncell(my_img)
我们定义 patchifyR 函数将执行以下操作：
patchifyR <- function(img, patch_size){
# load raster
if (!require("raster")) install.packages("raster")
suppressPackageStartupMessages({library(raster)})
# create image divisible by the patch_size
message(paste0("Cropping original image. ", "Making it divisible by ", patch_size, "."))
x_max <- patch_size*trunc(nrow(img)/patch_size)
y_max <- patch_size*trunc(ncol(img)/patch_size)
img <- crop(img, extent(img, 1, x_max, 1, y_max))
# initializers
lx = 1; ly = 1; p = 1
ls.patches <- list()
ls.coordinates <- list()
# extract patches
for(i in 1:(nrow(img)/patch_size)){
for(j in 1:(ncol(img)/patch_size)){
ls.patches[[p]] <- crop(img, extent(img, lx, (lx+patch_size)-1, ly, (ly+patch_size)-1))
ls.coordinates[[p]] <- as.character(paste0("P_", p, "_X0_", lx, "_X1_", (lx+patch_size)-1, "_Y0_", ly, "_Y1_", (ly+patch_size)-1))
message(paste0("Patch ", p, " created. Coordinates: ", "X0_", lx, "_X1_", (lx+patch_size)-1, "_Y0_", ly, "_Y1_", (ly+patch_size)-1))
p = p + 1
ly = ly + patch_size
}
ly = 1
lx = lx + patch_size
}
# merge results: $patches and $names
message("Matching results ... ")
patchify <- list("patches"=ls.patches, "names"=ls.coordinates)
# return
message("Successfully completed.")
return(patchify)
}
首先，我们将裁剪光栅以创建可被 patch_size 整除的图像。如果我们的图块重叠度大于 patch_size，我们将不会丢失信息。
然后我们使用 crop 函数和双 for 循环来遍历坐标来创建不同的补丁。
patchifyR函数接收两个参数：
img: 输入图像。 RasterLayer 或 RasterStack。
patch_size: 路径大小。 10 创建 10x10 像素块。
patchifyR函数returns两个列表：
patchify$patches: 包含所有补丁的列表（RasterLayer 或 RasterStack）
patchify$names: 包含每个补丁的名称及其坐标。
我们来测试一下函数：
my_patches <- patchifyR(img=my_img, patch_size=10)
最后我们可以使用以下方法将结果保存到磁盘：
output_directory <- "D:/my_output/"
for(i in 1:length(my_patches$patches)){
writeRaster(my_patches$patches[[i]], paste0(output_directory, my_patches$names[[i]], ".tif"), drivername="Gtiff", overwrite=TRUE)
}