432 lines
18 KiB
Cython
432 lines
18 KiB
Cython
#
|
|
# PYX file to control Python module interface to underlying CUDA-Ampcor code
|
|
#
|
|
from libcpp.string cimport string
|
|
import numpy as np
|
|
cimport numpy as np
|
|
|
|
|
|
cdef extern from "cudaUtil.h":
|
|
int gpuDeviceInit(int)
|
|
void gpuDeviceList()
|
|
int gpuGetMaxGflopsDeviceId()
|
|
|
|
def listGPU():
|
|
gpuDeviceList()
|
|
|
|
def findGPU():
|
|
return gpuGetMaxGflopsDeviceId()
|
|
|
|
def setGPU(int id):
|
|
return gpuDeviceInit(id)
|
|
|
|
|
|
cdef extern from "cuAmpcorParameter.h":
|
|
cdef cppclass cuAmpcorParameter:
|
|
cuAmpcorParameter() except +
|
|
int algorithm ## Cross-correlation algorithm: 0=freq domain 1=time domain
|
|
int deviceID ## Targeted GPU device ID: use -1 to auto select
|
|
int nStreams ## Number of streams to asynchonize data transfers and compute kernels
|
|
int derampMethod ## Method for deramping 0=None, 1=average, 2=phase gradient
|
|
|
|
## chip or window size for raw data
|
|
int windowSizeHeightRaw ## Template window height (original size)
|
|
int windowSizeWidthRaw ## Template window width (original size)
|
|
int searchWindowSizeHeightRaw ## Search window height (original size)
|
|
int searchWindowSizeWidthRaw ## Search window width (orignal size)
|
|
int halfSearchRangeDownRaw ##(searchWindowSizeHeightRaw-windowSizeHeightRaw)/2
|
|
int halfSearchRangeAcrossRaw ##(searchWindowSizeWidthRaw-windowSizeWidthRaw)/2
|
|
## chip or window size after oversampling
|
|
int rawDataOversamplingFactor ## Raw data overampling factor (from original size to oversampled size)
|
|
|
|
## strides between chips/windows
|
|
int skipSampleDownRaw ## Skip size between neighboring windows in Down direction (original size)
|
|
int skipSampleAcrossRaw ## Skip size between neighboring windows in across direction (original size)
|
|
|
|
## Zoom in region near location of max correlation
|
|
int zoomWindowSize ## Zoom-in window size in correlation surface (same for down and across directions)
|
|
int oversamplingFactor ## Oversampling factor for interpolating correlation surface
|
|
int oversamplingMethod
|
|
|
|
float thresholdSNR ## Threshold of Signal noise ratio to remove noisy data
|
|
|
|
##master image
|
|
string masterImageName ## master SLC image name
|
|
int imageDataType1 ## master image data type, 2=cfloat=complex=float2 1=float
|
|
int masterImageHeight ## master image height
|
|
int masterImageWidth ## master image width
|
|
|
|
##slave image
|
|
string slaveImageName ## slave SLC image name
|
|
int imageDataType2 ## slave image data type, 2=cfloat=complex=float2 1=float
|
|
int slaveImageHeight ## slave image height
|
|
int slaveImageWidth ## slave image width
|
|
|
|
int mmapSizeInGB ## mmap buffer size in unit of Gigabytes
|
|
|
|
## total number of chips/windows
|
|
int numberWindowDown ## number of total windows (down)
|
|
int numberWindowAcross ## number of total windows (across)
|
|
int numberWindows ## numberWindowDown*numberWindowAcross
|
|
|
|
## number of chips/windows in a batch/chunk
|
|
int numberWindowDownInChunk ## number of windows processed in a chunk (down)
|
|
int numberWindowAcrossInChunk ## number of windows processed in a chunk (across)
|
|
int numberWindowsInChunk ## numberWindowDownInChunk*numberWindowAcrossInChunk
|
|
int numberChunkDown ## number of chunks (down)
|
|
int numberChunkAcross ## number of chunks (across)
|
|
int numberChunks
|
|
|
|
int *masterStartPixelDown ## master starting pixels for each window (down)
|
|
int *masterStartPixelAcross ## master starting pixels for each window (across)
|
|
int *slaveStartPixelDown ## slave starting pixels for each window (down)
|
|
int *slaveStartPixelAcross ## slave starting pixels for each window (across)
|
|
int *grossOffsetDown ## Gross offsets between master and slave windows (down) : slaveStartPixel - masterStartPixel
|
|
int *grossOffsetAcross ## Gross offsets between master and slave windows (across)
|
|
int grossOffsetDown0 ## constant gross offset (down)
|
|
int grossOffsetAcross0 ## constant gross offset (across)
|
|
int masterStartPixelDown0 ## the first pixel of master image (down), be adjusted with margins and gross offset
|
|
int masterStartPixelAcross0 ## the first pixel of master image (across)
|
|
int *masterChunkStartPixelDown ## array of starting pixels for all master chunks (down)
|
|
int *masterChunkStartPixelAcross ## array of starting pixels for all master chunks (across)
|
|
int *slaveChunkStartPixelDown ## array of starting pixels for all slave chunks (down)
|
|
int *slaveChunkStartPixelAcross ## array of starting pixels for all slave chunks (across)
|
|
int *masterChunkHeight ## array of heights of all master chunks, required when loading chunk to GPU
|
|
int *masterChunkWidth ## array of width of all master chunks
|
|
int *slaveChunkHeight ## array of width of all master chunks
|
|
int *slaveChunkWidth ## array of width of all slave chunks
|
|
int maxMasterChunkHeight ## max height for all master/slave chunks, determine the size of reading cache in GPU
|
|
int maxMasterChunkWidth ## max width for all master chunks, determine the size of reading cache in GPU
|
|
int maxSlaveChunkHeight
|
|
int maxSlaveChunkWidth
|
|
|
|
string grossOffsetImageName
|
|
string offsetImageName ## Output Offset fields filename
|
|
string snrImageName ## Output SNR filename
|
|
void setStartPixels(int*, int*, int*, int*)
|
|
void setStartPixels(int, int, int*, int*)
|
|
void setStartPixels(int, int, int, int)
|
|
void checkPixelInImageRange() ## check whether
|
|
|
|
void setupParameters() ## Process other parameters after Python Inpu
|
|
|
|
cdef extern from "cuAmpcorController.h":
|
|
cdef cppclass cuAmpcorController:
|
|
cuAmpcorController() except +
|
|
cuAmpcorParameter *param
|
|
void runAmpcor()
|
|
|
|
cdef class PyCuAmpcor(object):
|
|
'''
|
|
Python interface for cuda Ampcor
|
|
'''
|
|
cdef cuAmpcorController c_cuAmpcor
|
|
def __cinit__(self):
|
|
return
|
|
|
|
@property
|
|
def algorithm(self):
|
|
return self.c_cuAmpcor.param.algorithm
|
|
@algorithm.setter
|
|
def algorithm(self, int a):
|
|
self.c_cuAmpcor.param.algorithm = a
|
|
@property
|
|
def deviceID(self):
|
|
return self.c_cuAmpcor.param.deviceID
|
|
@deviceID.setter
|
|
def deviceID(self, int a):
|
|
self.c_cuAmpcor.param.deviceID = a
|
|
@property
|
|
def nStreams(self):
|
|
return self.c_cuAmpcor.param.nStreams
|
|
@nStreams.setter
|
|
def nStreams(self, int a):
|
|
self.c_cuAmpcor.param.nStreams = a
|
|
@property
|
|
def mmapSize(self):
|
|
return self.c_cuAmpcor.param.mmapSizeInGB
|
|
@mmapSize.setter
|
|
def mmapSize(self, int a):
|
|
self.c_cuAmpcor.param.mmapSizeInGB = a
|
|
@property
|
|
def derampMethod(self):
|
|
return self.c_cuAmpcor.param.derampMethod
|
|
@derampMethod.setter
|
|
def derampMethod(self, int a):
|
|
self.c_cuAmpcor.param.derampMethod = a
|
|
@property
|
|
def windowSizeHeight(self):
|
|
return self.c_cuAmpcor.param.windowSizeHeightRaw
|
|
@windowSizeHeight.setter
|
|
def windowSizeHeight(self, int a):
|
|
self.c_cuAmpcor.param.windowSizeHeightRaw = a
|
|
@property
|
|
def windowSizeWidth(self):
|
|
return self.c_cuAmpcor.param.windowSizeWidthRaw
|
|
@windowSizeWidth.setter
|
|
def windowSizeWidth(self, int a):
|
|
self.c_cuAmpcor.param.windowSizeWidthRaw = a
|
|
@property
|
|
def halfSearchRangeDown(self):
|
|
"""half of the search range"""
|
|
return self.c_cuAmpcor.param.halfSearchRangeDownRaw
|
|
@halfSearchRangeDown.setter
|
|
def halfSearchRangeDown(self, int a):
|
|
"""set half of the search range"""
|
|
self.c_cuAmpcor.param.halfSearchRangeDownRaw = a
|
|
@property
|
|
def halfSearchRangeAcross(self):
|
|
"""half of the search range"""
|
|
return self.c_cuAmpcor.param.halfSearchRangeAcrossRaw
|
|
@halfSearchRangeAcross.setter
|
|
def halfSearchRangeAcross(self, int a):
|
|
"""set half of the search range"""
|
|
self.c_cuAmpcor.param.halfSearchRangeAcrossRaw = a
|
|
@property
|
|
def searchWindowSizeHeight(self):
|
|
return self.c_cuAmpcor.param.searchWindowSizeHeightRaw
|
|
@property
|
|
def searchWindowSizeWidth(self):
|
|
return self.c_cuAmpcor.param.searchWindowSizeWidthRaw
|
|
@property
|
|
def skipSampleDown(self):
|
|
return self.c_cuAmpcor.param.skipSampleDownRaw
|
|
@skipSampleDown.setter
|
|
def skipSampleDown(self, int a):
|
|
self.c_cuAmpcor.param.skipSampleDownRaw = a
|
|
@property
|
|
def skipSampleAcross(self):
|
|
return self.c_cuAmpcor.param.skipSampleAcrossRaw
|
|
@skipSampleAcross.setter
|
|
def skipSampleAcross(self, int a):
|
|
self.c_cuAmpcor.param.skipSampleAcrossRaw = a
|
|
|
|
@property
|
|
def rawDataOversamplingFactor(self):
|
|
"""anti-aliasing oversampling factor"""
|
|
return self.c_cuAmpcor.param.rawDataOversamplingFactor
|
|
@rawDataOversamplingFactor.setter
|
|
def rawDataOversamplingFactor(self, int a):
|
|
self.c_cuAmpcor.param.rawDataOversamplingFactor = a
|
|
@property
|
|
def corrSurfaceZoomInWindow(self):
|
|
"""Zoom-In Window Size for correlation surface"""
|
|
return self.c_cuAmpcor.param.zoomWindowSize
|
|
@corrSurfaceZoomInWindow.setter
|
|
def corrSurfaceZoomInWindow(self, int a):
|
|
self.c_cuAmpcor.param.zoomWindowSize = a
|
|
@property
|
|
def corrSurfaceOverSamplingFactor(self):
|
|
"""Oversampling factor for correlation surface"""
|
|
return self.c_cuAmpcor.param.oversamplingFactor
|
|
@corrSurfaceOverSamplingFactor.setter
|
|
def corrSurfaceOverSamplingFactor(self, int a):
|
|
self.c_cuAmpcor.param.oversamplingFactor = a
|
|
@property
|
|
def corrSufaceOverSamplingMethod(self):
|
|
"""Oversampling method for correlation surface(0=fft,1=sinc)"""
|
|
return self.c_cuAmpcor.param.oversamplingMethod
|
|
@corrSufaceOverSamplingMethod.setter
|
|
def corrSufaceOverSamplingMethod(self, int a):
|
|
self.c_cuAmpcor.param.oversamplingMethod = a
|
|
@property
|
|
def masterImageName(self):
|
|
return self.c_cuAmpcor.param.masterImageName
|
|
@masterImageName.setter
|
|
def masterImageName(self, str a):
|
|
self.c_cuAmpcor.param.masterImageName = <string> a.encode()
|
|
@property
|
|
def slaveImageName(self):
|
|
return self.c_cuAmpcor.param.slaveImageName
|
|
@slaveImageName.setter
|
|
def slaveImageName(self, str a):
|
|
self.c_cuAmpcor.param.slaveImageName = <string> a.encode()
|
|
@property
|
|
def masterImageName(self):
|
|
return self.c_cuAmpcor.param.masterImageName
|
|
@masterImageName.setter
|
|
def masterImageName(self, str a):
|
|
self.c_cuAmpcor.param.masterImageName = <string> a.encode()
|
|
@property
|
|
def masterImageHeight(self):
|
|
return self.c_cuAmpcor.param.masterImageHeight
|
|
@masterImageHeight.setter
|
|
def masterImageHeight(self, int a):
|
|
self.c_cuAmpcor.param.masterImageHeight=a
|
|
@property
|
|
def masterImageWidth(self):
|
|
return self.c_cuAmpcor.param.masterImageWidth
|
|
@masterImageWidth.setter
|
|
def masterImageWidth(self, int a):
|
|
self.c_cuAmpcor.param.masterImageWidth=a
|
|
@property
|
|
def slaveImageHeight(self):
|
|
return self.c_cuAmpcor.param.slaveImageHeight
|
|
@slaveImageHeight.setter
|
|
def slaveImageHeight(self, int a):
|
|
self.c_cuAmpcor.param.slaveImageHeight=a
|
|
@property
|
|
def slaveImageWidth(self):
|
|
return self.c_cuAmpcor.param.slaveImageWidth
|
|
@slaveImageWidth.setter
|
|
def slaveImageWidth(self, int a):
|
|
self.c_cuAmpcor.param.slaveImageWidth=a
|
|
|
|
@property
|
|
def numberWindowDown(self):
|
|
return self.c_cuAmpcor.param.numberWindowDown
|
|
@numberWindowDown.setter
|
|
def numberWindowDown(self, int a):
|
|
self.c_cuAmpcor.param.numberWindowDown = a
|
|
@property
|
|
def numberWindowAcross(self):
|
|
return self.c_cuAmpcor.param.numberWindowAcross
|
|
@numberWindowAcross.setter
|
|
def numberWindowAcross(self, int a):
|
|
self.c_cuAmpcor.param.numberWindowAcross = a
|
|
@property
|
|
def numberWindows(self):
|
|
return self.c_cuAmpcor.param.numberWindows
|
|
|
|
@property
|
|
def numberWindowDownInChunk(self):
|
|
return self.c_cuAmpcor.param.numberWindowDownInChunk
|
|
@numberWindowDownInChunk.setter
|
|
def numberWindowDownInChunk(self, int a):
|
|
self.c_cuAmpcor.param.numberWindowDownInChunk = a
|
|
@property
|
|
def numberWindowAcrossInChunk(self):
|
|
return self.c_cuAmpcor.param.numberWindowAcrossInChunk
|
|
@numberWindowAcrossInChunk.setter
|
|
def numberWindowAcrossInChunk(self, int a):
|
|
self.c_cuAmpcor.param.numberWindowAcrossInChunk = a
|
|
@property
|
|
def numberChunkDown(self):
|
|
return self.c_cuAmpcor.param.numberChunkDown
|
|
@property
|
|
def numberChunkAcross(self):
|
|
return self.c_cuAmpcor.param.numberChunkAcross
|
|
@property
|
|
def numberChunks(self):
|
|
return self.c_cuAmpcor.param.numberChunks
|
|
|
|
|
|
## gross offets
|
|
@property
|
|
def grossOffsetImageName(self):
|
|
return self.c_cuAmpcor.param.grossOffsetImageName
|
|
@grossOffsetImageName.setter
|
|
def grossOffsetImageName(self, str a):
|
|
self.c_cuAmpcor.param.grossOffsetImageName = <string> a.encode()
|
|
@property
|
|
def offsetImageName(self):
|
|
return self.c_cuAmpcor.param.offsetImageName
|
|
@offsetImageName.setter
|
|
def offsetImageName(self, str a):
|
|
self.c_cuAmpcor.param.offsetImageName = <string> a.encode()
|
|
@property
|
|
def snrImageName(self):
|
|
return self.c_cuAmpcor.param.snrImageName
|
|
@snrImageName.setter
|
|
def snrImageName(self, str a):
|
|
self.c_cuAmpcor.param.snrImageName = <string> a.encode()
|
|
|
|
@property
|
|
def masterStartPixelDownStatic(self):
|
|
return self.c_cuAmpcor.param.masterStartPixelDown0
|
|
@masterStartPixelDownStatic.setter
|
|
def masterStartPixelDownStatic(self, int a):
|
|
self.c_cuAmpcor.param.masterStartPixelDown0 = a
|
|
@property
|
|
def masterStartPixelAcrossStatic(self):
|
|
return self.c_cuAmpcor.param.masterStartPixelAcross0
|
|
@masterStartPixelAcrossStatic.setter
|
|
def masterStartPixelAcrossStatic(self, int a):
|
|
self.c_cuAmpcor.param.masterStartPixelAcross0 = a
|
|
@property
|
|
def grossOffsetDownStatic(self):
|
|
return self.c_cuAmpcor.param.grossOffsetDown0
|
|
@grossOffsetDownStatic.setter
|
|
def grossOffsetDownStatic(self, int a):
|
|
self.c_cuAmpcor.param.grossOffsetDown0 =a
|
|
@property
|
|
def grossOffsetAcrossStatic(self):
|
|
return self.c_cuAmpcor.param.grossOffsetAcross0
|
|
@grossOffsetAcrossStatic.setter
|
|
def grossOffsetAcrossStatic(self, int a):
|
|
self.c_cuAmpcor.param.grossOffsetAcross0 =a
|
|
|
|
@property
|
|
def grossOffsetDownDynamic(self):
|
|
cdef int *c_data
|
|
c_data = self.c_cuAmpcor.param.grossOffsetDown
|
|
p_data = np.zeros(self.numberWindows, dtype = np.float32)
|
|
for i in range (self.numberWindows):
|
|
p_data[i] = c_data[i]
|
|
return p_data
|
|
@grossOffsetDownDynamic.setter
|
|
def grossOffsetDownDynamic (self, np.ndarray[np.int32_t,ndim=1,mode="c"] pa):
|
|
cdef int *c_data
|
|
cdef int *p_data
|
|
c_data = self.c_cuAmpcor.param.grossOffsetDown
|
|
p_data = <int *> pa.data
|
|
for i in range (self.numberWindows):
|
|
c_data[i] = p_data[i]
|
|
@property
|
|
def grossOffsetAcrossDynamic(self):
|
|
cdef int *c_data
|
|
c_data = self.c_cuAmpcor.param.grossOffsetAcross
|
|
p_data = np.zeros(self.numberWindows, dtype = np.float32)
|
|
for i in range (self.numberWindows):
|
|
p_data[i] = c_data[i]
|
|
return p_data
|
|
@grossOffsetAcrossDynamic.setter
|
|
def grossOffsetAcrossDynamic (self, np.ndarray[np.int32_t,ndim=1,mode="c"] pa):
|
|
cdef int *c_data
|
|
cdef int *p_data
|
|
c_data = self.c_cuAmpcor.param.grossOffsetAcross
|
|
p_data = <int *> pa.data
|
|
for i in range (self.numberWindows):
|
|
c_data[i] = p_data[i]
|
|
return
|
|
|
|
|
|
def setConstantGrossOffset(self, int goDown, int goAcross):
|
|
"""
|
|
constant gross offsets
|
|
param goDown gross offset in azimuth direction
|
|
param goAcross gross offset in range direction
|
|
"""
|
|
self.c_cuAmpcor.param.setStartPixels(<int>self.masterStartPixelDownStatic, <int>self.masterStartPixelAcrossStatic, goDown, goAcross)
|
|
|
|
def setVaryingGrossOffset(self, np.ndarray[np.int32_t,ndim=1,mode="c"] vD, np.ndarray[np.int32_t,ndim=1,mode="c"] vA):
|
|
"""
|
|
varying gross offsets for each window
|
|
param vD numpy 1d array of size numberWindows, gross offsets in azimuth direction
|
|
param vA numpy 1d array of size numberWindows, gross offsets in azimuth direction
|
|
static part should be included
|
|
"""
|
|
self.c_cuAmpcor.param.setStartPixels(<int>self.masterStartPixelDownStatic, <int>self.masterStartPixelAcrossStatic, <int *> vD.data, <int *> vA.data)
|
|
|
|
def checkPixelInImageRange(self):
|
|
""" check whether each window is with image range """
|
|
self.c_cuAmpcor.param.checkPixelInImageRange()
|
|
|
|
def setupParams(self):
|
|
"""
|
|
set up constant parameters and allocate array parameters (offsets)
|
|
should be called after number of windows is set and before setting varying gross offsets
|
|
"""
|
|
self.c_cuAmpcor.param.setupParameters()
|
|
|
|
def runAmpcor(self):
|
|
""" main procedure to run ampcor """
|
|
self.c_cuAmpcor.runAmpcor()
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|