// Compute the proximity of all pixels in the image to a set of pixels in the source image
func (src RasterBand) ComputeProximity(
dest RasterBand,
options []string,
progress ProgressFunc,
data interface{},
) error {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
length := len(options)
opts := make([]*C.char, length+1)
for i := 0; i < length; i++ {
opts[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(opts[i]))
}
opts[length] = (*C.char)(unsafe.Pointer(nil))
err := C.GDALComputeProximity(
src.cval,
dest.cval,
(**C.char)(unsafe.Pointer(&opts[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return err
}
// Removes small raster polygons
func (src RasterBand) SieveFilter(
mask, dest RasterBand,
threshold, connectedness int,
options []string,
progress ProgressFunc,
data interface{},
) error {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
length := len(options)
opts := make([]*C.char, length+1)
for i := 0; i < length; i++ {
opts[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(opts[i]))
}
opts[length] = (*C.char)(unsafe.Pointer(nil))
err := C.GDALSieveFilter(
src.cval,
mask.cval,
dest.cval,
C.int(threshold),
C.int(connectedness),
(**C.char)(unsafe.Pointer(&opts[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return error(err)
}
// Fill selected raster regions by interpolation from the edges
func (src RasterBand) FillNoData(
mask RasterBand,
distance float64,
iterations int,
options []string,
progress ProgressFunc,
data interface{},
) error {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
length := len(options)
opts := make([]*C.char, length+1)
for i := 0; i < length; i++ {
opts[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(opts[i]))
}
opts[length] = (*C.char)(unsafe.Pointer(nil))
err := C.GDALFillNodata(
src.cval,
mask.cval,
C.double(distance),
0,
C.int(iterations),
(**C.char)(unsafe.Pointer(&opts[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return error(err)
}
// Create polygon coverage from raster data using a floating point buffer
func (src RasterBand) FPolygonize(
mask RasterBand,
layer Layer,
fieldIndex int,
options []string,
progress ProgressFunc,
data interface{},
) error {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
length := len(options)
opts := make([]*C.char, length+1)
for i := 0; i < length; i++ {
opts[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(opts[i]))
}
opts[length] = (*C.char)(unsafe.Pointer(nil))
err := C.GDALFPolygonize(
src.cval,
mask.cval,
layer.cval,
C.int(fieldIndex),
(**C.char)(unsafe.Pointer(&opts[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return error(err)
}
// Build raster overview(s)
func (dataset Dataset) BuildOverviews(
resampling string,
nOverviews int,
overviewList []int,
nBands int,
bandList []int,
progress ProgressFunc,
data interface{},
) error {
cResampling := C.CString(resampling)
defer C.free(unsafe.Pointer(cResampling))
arg := &goGDALProgressFuncProxyArgs{progress, data}
err := C.GDALBuildOverviews(
dataset.cval,
cResampling,
C.int(nOverviews),
(*C.int)(unsafe.Pointer(&overviewList[0])),
C.int(nBands),
(*C.int)(unsafe.Pointer(&bandList[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
if err != 0 {
return error(err)
}
return nil
}
// Copy all dataset raster data
func (sourceDataset Dataset) CopyWholeRaster(
destDataset Dataset,
options []string,
progress ProgressFunc,
data interface{},
) error {
arg := &goGDALProgressFuncProxyArgs{progress, data}
length := len(options)
cOptions := make([]*C.char, length+1)
for i := 0; i < length; i++ {
cOptions[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(cOptions[i]))
}
cOptions[length] = (*C.char)(unsafe.Pointer(nil))
err := C.GDALDatasetCopyWholeRaster(
sourceDataset.cval,
destDataset.cval,
(**C.char)(unsafe.Pointer(&cOptions[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
if err != 0 {
return error(err)
}
return nil
}
// Fetch default raster histogram
func (rb RasterBand) DefaultHistogram(
force int,
progress ProgressFunc,
data interface{},
) (min, max float64, buckets int, histogram []int, err error) {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
var cHistogram *C.int
cErr := C.GDALGetDefaultHistogram(
rb.cval,
(*C.double)(&min),
(*C.double)(&max),
(*C.int)(unsafe.Pointer(&buckets)),
&cHistogram,
C.int(force),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
if cErr != 0 {
return min, max, buckets, histogram, error(cErr)
}
sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&histogram))
sliceHeader.Cap = buckets
sliceHeader.Len = buckets
sliceHeader.Data = uintptr(unsafe.Pointer(cHistogram))
return min, max, buckets, histogram, nil
}
// Compute raster histogram
func (rb RasterBand) Histogram(
min, max float64,
buckets int,
includeOutOfRange, approxOK int,
progress ProgressFunc,
data interface{},
) ([]int, error) {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
histogram := make([]int, buckets)
err := C.GDALGetRasterHistogram(
rb.cval,
C.double(min),
C.double(max),
C.int(buckets),
(*C.int)(unsafe.Pointer(&histogram[0])),
C.int(includeOutOfRange),
C.int(approxOK),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
if err != 0 {
return nil, error(err)
}
return histogram, nil
}
// Build raster overview(s)
func (dataset Dataset) BuildOverviews(
resampling string,
nOverviews int,
overviewList []int,
nBands int,
bandList []int,
progress ProgressFunc,
data interface{},
) error {
cResampling := C.CString(resampling)
defer C.free(unsafe.Pointer(cResampling))
arg := &goGDALProgressFuncProxyArgs{progress, data}
return C.GDALBuildOverviews(
dataset.cval,
cResampling,
C.int(nOverviews),
(*C.int)(unsafe.Pointer(&IntSliceToCInt(overviewList)[0])),
C.int(nBands),
(*C.int)(unsafe.Pointer(&IntSliceToCInt(bandList)[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
).Err()
}
// Compute raster histogram
func (rb RasterBand) Histogram(
min, max float64,
buckets int,
includeOutOfRange, approxOK int,
progress ProgressFunc,
data interface{},
) ([]int, error) {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
histogram := make([]C.int, buckets)
if err := C.GDALGetRasterHistogramEx(
rb.cval,
C.double(min),
C.double(max),
C.int(buckets),
(*C.GUIntBig)(unsafe.Pointer(&histogram[0])),
C.int(includeOutOfRange),
C.int(approxOK),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
).Err(); err != nil {
return nil, err
} else {
return CIntSliceToInt(histogram), nil
}
}
// Create a copy of a dataset
func (driver Driver) CreateCopy(
filename string,
sourceDataset Dataset,
strict int,
options []string,
progress ProgressFunc,
data interface{},
) Dataset {
name := C.CString(filename)
defer C.free(unsafe.Pointer(name))
length := len(options)
opts := make([]*C.char, length+1)
for i := 0; i < length; i++ {
opts[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(opts[i]))
}
opts[length] = (*C.char)(unsafe.Pointer(nil))
var h C.GDALDatasetH
if progress == nil {
h = C.GDALCreateCopy(
driver.cval, name,
sourceDataset.cval,
C.int(strict),
(**C.char)(unsafe.Pointer(&opts[0])),
nil,
nil,
)
} else {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
h = C.GDALCreateCopy(
driver.cval, name,
sourceDataset.cval,
C.int(strict), (**C.char)(unsafe.Pointer(&opts[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
}
return Dataset{h}
}
// Reproject image
func (src Dataset) ReprojectImage(
srcProjWKT string,
dst Dataset,
dstProjWKT string,
resampleAlg ResampleAlg,
memLimit, maxError float64,
progress ProgressFunc,
data interface{},
options WarpOptions,
) error {
var pf C.GDALProgressFunc
var pa unsafe.Pointer
if progress != nil {
pf = C.goGDALProgressFuncProxyB()
pa = unsafe.Pointer(&goGDALProgressFuncProxyArgs{progress, data})
}
var c_srcWKT, c_dstWKT *C.char
if srcProjWKT != "" {
c_srcWKT = C.CString(srcProjWKT)
defer C.free(unsafe.Pointer(c_srcWKT))
}
if dstProjWKT != "" {
c_dstWKT = C.CString(dstProjWKT)
defer C.free(unsafe.Pointer(c_dstWKT))
}
err := C.GDALReprojectImage(
src.cval,
c_srcWKT,
dst.cval,
c_dstWKT,
C.GDALResampleAlg(resampleAlg),
C.double(memLimit),
C.double(maxError),
pf,
pa,
options,
)
if err != 0 {
return error(err)
}
return nil
}
// Compute image statistics
func (rasterBand RasterBand) ComputeStatistics(
approxOK int,
progress ProgressFunc,
data interface{},
) (min, max, mean, stdDev float64) {
arg := &goGDALProgressFuncProxyArgs{progress, data}
C.GDALComputeRasterStatistics(
rasterBand.cval,
C.int(approxOK),
(*C.double)(unsafe.Pointer(&min)),
(*C.double)(unsafe.Pointer(&max)),
(*C.double)(unsafe.Pointer(&mean)),
(*C.double)(unsafe.Pointer(&stdDev)),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return min, max, mean, stdDev
}
// 24bit to 8bit conversion with dithering
func DitherRGB2PCT(
red, green, blue, target RasterBand,
ct ColorTable,
progress ProgressFunc,
data interface{},
) int {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
err := C.GDALDitherRGB2PCT(
red.cval,
green.cval,
blue.cval,
target.cval,
ct.cval,
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return int(err)
}
// Compute optimal PCT for RGB image
func ComputeMedianCutPCT(
red, green, blue RasterBand,
colors int,
ct ColorTable,
progress ProgressFunc,
data interface{},
) int {
arg := &goGDALProgressFuncProxyArgs{
progress, data,
}
err := C.GDALComputeMedianCutPCT(
red.cval,
green.cval,
blue.cval,
nil,
C.int(colors),
ct.cval,
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
)
return int(err)
}
// Copy all raster band raster data
func (sourceRaster RasterBand) RasterBandCopyWholeRaster(
destRaster RasterBand,
options []string,
progress ProgressFunc,
data interface{},
) error {
arg := &goGDALProgressFuncProxyArgs{progress, data}
length := len(options)
cOptions := make([]*C.char, length+1)
for i := 0; i < length; i++ {
cOptions[i] = C.CString(options[i])
defer C.free(unsafe.Pointer(cOptions[i]))
}
cOptions[length] = (*C.char)(unsafe.Pointer(nil))
return C.GDALRasterBandCopyWholeRaster(
sourceRaster.cval,
destRaster.cval,
(**C.char)(unsafe.Pointer(&cOptions[0])),
C.goGDALProgressFuncProxyB(),
unsafe.Pointer(arg),
).Err()
}
