342 lines
11 KiB
Cython
342 lines
11 KiB
Cython
#
|
|
# Author: Joshua Cohen
|
|
# Copyright 2016
|
|
#
|
|
|
|
from libc.stdint cimport uint64_t
|
|
from libcpp cimport bool
|
|
from libcpp.vector cimport vector
|
|
|
|
cdef extern from "Poly2d.h":
|
|
cdef cppclass Poly2d:
|
|
int rangeOrder
|
|
int azimuthOrder
|
|
double rangeMean
|
|
double azimuthMean
|
|
double rangeNorm
|
|
double azimuthNorm
|
|
vector[double] coeffs
|
|
|
|
Poly2d() except +
|
|
Poly2d(int,int,double,double,double,double) except +
|
|
Poly2d(const Poly2d&) except +
|
|
void setCoeff(int,int,double)
|
|
void getCoeff(int,int)
|
|
double eval(double,double)
|
|
void printPoly()
|
|
|
|
cdef class PyPoly2d:
|
|
cdef Poly2d *c_poly2d
|
|
cdef bool owner
|
|
|
|
def __cinit__(self, int azimuthOrder=-1, int rangeOrder=-1, double azimuthMean=0., double rangeMean=0., double azimuthNorm=1., double rangeNorm=1.):
|
|
self.c_poly2d = new Poly2d(rangeOrder, azimuthOrder, rangeMean, azimuthMean, rangeNorm, azimuthNorm)
|
|
self.owner = True
|
|
def __dealloc__(self):
|
|
if (self.owner):
|
|
del self.c_poly2d
|
|
|
|
@property
|
|
def azimuthOrder(self):
|
|
return self.c_poly2d.azimuthOrder
|
|
@azimuthOrder.setter
|
|
def azimuthOrder(self, int a):
|
|
if (a < 0):
|
|
return
|
|
else:
|
|
c = self.coeffs
|
|
for i in range((a-self.azimuthOrder)*(self.rangeOrder+1)):
|
|
c.append(0.)
|
|
nc = []
|
|
for i in range((a+1)*(self.rangeOrder+1)):
|
|
nc.append(c[i])
|
|
self.c_poly2d.azimuthOrder = a
|
|
self.c_poly2d.coeffs.resize((self.azimuthOrder+1)*(self.rangeOrder+1))
|
|
self.coeffs = nc
|
|
@property
|
|
def rangeOrder(self):
|
|
return self.c_poly2d.rangeOrder
|
|
@rangeOrder.setter
|
|
def rangeOrder(self, int a):
|
|
if (a < 0):
|
|
return
|
|
else:
|
|
c = self.coeffs
|
|
nc = []
|
|
# Cleanest is to first form 2D array of coeffs from 1D
|
|
for i in range(self.azimuthOrder+1):
|
|
ncs = []
|
|
for j in range(self.rangeOrder+1):
|
|
ncs.append(c[i*(self.rangeOrder+1)+j])
|
|
nc.append(ncs)
|
|
# nc is now the 2D reshape of coeffs
|
|
for i in range(self.azimuthOrder+1): # Go row-by-row...
|
|
for j in range(a-self.rangeOrder): # Add 0s to each row (if
|
|
nc[i].append(0.) # a > self.rangeOrder)
|
|
self.c_poly2d.rangeOrder = a
|
|
self.c_poly2d.coeffs.resize((self.azimuthOrder+1)*(self.rangeOrder+1))
|
|
c = []
|
|
for i in range(self.azimuthOrder+1):
|
|
for j in range(self.rangeOrder+1):
|
|
c.append(nc[i][j])
|
|
self.coeffs = c
|
|
@property
|
|
def azimuthMean(self):
|
|
return self.c_poly2d.azimuthMean
|
|
@azimuthMean.setter
|
|
def azimuthMean(self, double a):
|
|
self.c_poly2d.azimuthMean = a
|
|
@property
|
|
def rangeMean(self):
|
|
return self.c_poly2d.rangeMean
|
|
@rangeMean.setter
|
|
def rangeMean(self, double a):
|
|
self.c_poly2d.rangeMean = a
|
|
@property
|
|
def azimuthNorm(self):
|
|
return self.c_poly2d.azimuthNorm
|
|
@azimuthNorm.setter
|
|
def azimuthNorm(self, double a):
|
|
self.c_poly2d.azimuthNorm = a
|
|
@property
|
|
def rangeNorm(self):
|
|
return self.c_poly2d.rangeNorm
|
|
@rangeNorm.setter
|
|
def rangeNorm(self, double a):
|
|
self.c_poly2d.rangeNorm = a
|
|
@property
|
|
def coeffs(self):
|
|
a = []
|
|
for i in range((self.azimuthOrder+1)*(self.rangeOrder+1)):
|
|
a.append(self.c_poly2d.coeffs[i])
|
|
return a
|
|
@coeffs.setter
|
|
def coeffs(self, a):
|
|
if ((self.azimuthOrder+1)*(self.rangeOrder+1) != len(a)):
|
|
print("Error: Invalid input size (expected 1D list of length "+str(self.azimuthOrder+1)+"*"+str(self.rangeOrder+1)+")")
|
|
return
|
|
for i in range((self.azimuthOrder+1)*(self.rangeOrder+1)):
|
|
self.c_poly2d.coeffs[i] = a[i]
|
|
def dPrint(self):
|
|
self.printPoly()
|
|
@staticmethod
|
|
cdef boundTo(Poly2d *poly):
|
|
cdef PyPoly2d newpoly = PyPoly2d()
|
|
del newpoly.c_poly2d
|
|
newpoly.c_poly2d = poly
|
|
newpoly.owner = False
|
|
return newpoly
|
|
|
|
def setCoeff(self, int a, int b, double c):
|
|
self.c_poly2d.setCoeff(a,b,c)
|
|
def getCoeff(self, int a, int b):
|
|
return self.c_poly2d.getCoeff(a,b)
|
|
def eval(self, double a, double b):
|
|
return self.c_poly2d.eval(a,b)
|
|
def printPoly(self):
|
|
self.c_poly2d.printPoly()
|
|
|
|
cdef extern from "ResampSlc.h":
|
|
cdef cppclass ResampSlc:
|
|
uint64_t slcInAccessor, slcOutAccessor, residRgAccessor, residAzAccessor
|
|
double wvl, slr, r0, refwvl, refslr, refr0
|
|
int outWidth, outLength, inWidth, inLength
|
|
bool isComplex, flatten, usr_enable_gpu
|
|
Poly2d *rgCarrier
|
|
Poly2d *azCarrier
|
|
Poly2d *rgOffsetsPoly
|
|
Poly2d *azOffsetsPoly
|
|
Poly2d *dopplerPoly
|
|
|
|
ResampSlc() except +
|
|
ResampSlc(const ResampSlc&) except +
|
|
void setRgCarrier(Poly2d*)
|
|
void setAzCarrier(Poly2d*)
|
|
void setRgOffsets(Poly2d*)
|
|
void setAzOffsets(Poly2d*)
|
|
void setDoppler(Poly2d*)
|
|
Poly2d* releaseRgCarrier()
|
|
Poly2d* releaseAzCarrier()
|
|
Poly2d* releaseRgOffsets()
|
|
Poly2d* releaseAzOffsets()
|
|
Poly2d* releaseDoppler()
|
|
void clearPolys()
|
|
void resetPolys()
|
|
void resamp()
|
|
|
|
|
|
cdef class PyResampSlc:
|
|
cdef ResampSlc *c_resamp
|
|
|
|
def __cinit__(self):
|
|
self.c_resamp = new ResampSlc()
|
|
def __dealloc__(self):
|
|
del self.c_resamp
|
|
|
|
@property
|
|
def slcInAccessor(self):
|
|
return self.c_resamp.slcInAccessor
|
|
@slcInAccessor.setter
|
|
def slcInAccessor(self, uint64_t a):
|
|
self.c_resamp.slcInAccessor = a
|
|
@property
|
|
def slcOutAccessor(self):
|
|
return self.c_resamp.slcOutAccessor
|
|
@slcOutAccessor.setter
|
|
def slcOutAccessor(self, uint64_t a):
|
|
self.c_resamp.slcOutAccessor = a
|
|
@property
|
|
def residRgAccessor(self):
|
|
return self.c_resamp.residRgAccessor
|
|
@residRgAccessor.setter
|
|
def residRgAccessor(self, uint64_t a):
|
|
self.c_resamp.residRgAccessor = a
|
|
@property
|
|
def residAzAccessor(self):
|
|
return self.c_resamp.residAzAccessor
|
|
@residAzAccessor.setter
|
|
def residAzAccessor(self, uint64_t a):
|
|
self.c_resamp.residAzAccessor = a
|
|
@property
|
|
def wvl(self):
|
|
return self.c_resamp.wvl
|
|
@wvl.setter
|
|
def wvl(self, double a):
|
|
self.c_resamp.wvl = a
|
|
@property
|
|
def slr(self):
|
|
return self.c_resamp.slr
|
|
@slr.setter
|
|
def slr(self, double a):
|
|
self.c_resamp.slr = a
|
|
@property
|
|
def r0(self):
|
|
return self.c_resamp.r0
|
|
@r0.setter
|
|
def r0(self, double a):
|
|
self.c_resamp.r0 = a
|
|
@property
|
|
def refwvl(self):
|
|
return self.c_resamp.refwvl
|
|
@refwvl.setter
|
|
def refwvl(self, double a):
|
|
self.c_resamp.refwvl = a
|
|
@property
|
|
def refslr(self):
|
|
return self.c_resamp.refslr
|
|
@refslr.setter
|
|
def refslr(self, double a):
|
|
self.c_resamp.refslr = a
|
|
@property
|
|
def refr0(self):
|
|
return self.c_resamp.refr0
|
|
@refr0.setter
|
|
def refr0(self, double a):
|
|
self.c_resamp.refr0 = a
|
|
@property
|
|
def outWidth(self):
|
|
return self.c_resamp.outWidth
|
|
@outWidth.setter
|
|
def outWidth(self, int a):
|
|
self.c_resamp.outWidth = a
|
|
@property
|
|
def outLength(self):
|
|
return self.c_resamp.outLength
|
|
@outLength.setter
|
|
def outLength(self, int a):
|
|
self.c_resamp.outLength = a
|
|
@property
|
|
def inWidth(self):
|
|
return self.c_resamp.inWidth
|
|
@inWidth.setter
|
|
def inWidth(self, int a):
|
|
self.c_resamp.inWidth = a
|
|
@property
|
|
def inLength(self):
|
|
return self.c_resamp.inLength
|
|
@inLength.setter
|
|
def inLength(self, int a):
|
|
self.c_resamp.inLength = a
|
|
@property
|
|
def isComplex(self):
|
|
return self.c_resamp.isComplex
|
|
@isComplex.setter
|
|
def isComplex(self, bool a):
|
|
self.c_resamp.isComplex = a
|
|
@property
|
|
def flatten(self):
|
|
return self.c_resamp.flatten
|
|
@flatten.setter
|
|
def flatten(self, bool a):
|
|
self.c_resamp.flatten = a
|
|
@property
|
|
def usr_enable_gpu(self):
|
|
return self.c_resamp.usr_enable_gpu
|
|
@usr_enable_gpu.setter
|
|
def usr_enable_gpu(self, bool a):
|
|
self.c_resamp.usr_enable_gpu = a
|
|
# Note: The property accessors here return a PyPoly2d object that is
|
|
# "bound" to the ResampSlc's Poly2d object. That means when the
|
|
# returned PyPoly2d object goes out of scope, it will not try
|
|
# to delete the contained Poly2d object.
|
|
@property
|
|
def rgCarrier(self):
|
|
return PyPoly2d.boundTo(self.c_resamp.rgCarrier)
|
|
@rgCarrier.setter
|
|
def rgCarrier(self, PyPoly2d poly):
|
|
self.c_resamp.setRgCarrier(poly.c_poly2d)
|
|
@property
|
|
def azCarrier(self):
|
|
return PyPoly2d.boundTo(self.c_resamp.azCarrier)
|
|
@azCarrier.setter
|
|
def azCarrier(self, PyPoly2d poly):
|
|
self.c_resamp.setAzCarrier(poly.c_poly2d)
|
|
@property
|
|
def rgOffsetsPoly(self):
|
|
return PyPoly2d.boundTo(self.c_resamp.rgOffsetsPoly)
|
|
@rgOffsetsPoly.setter
|
|
def rgOffsetsPoly(self, PyPoly2d poly):
|
|
self.c_resamp.setRgOffsets(poly.c_poly2d)
|
|
@property
|
|
def azOffsetsPoly(self):
|
|
return PyPoly2d.boundTo(self.c_resamp.azOffsetsPoly)
|
|
@azOffsetsPoly.setter
|
|
def azOffsetsPoly(self, PyPoly2d poly):
|
|
self.c_resamp.setAzOffsets(poly.c_poly2d)
|
|
@property
|
|
def dopplerPoly(self):
|
|
return PyPoly2d.boundTo(self.c_resamp.dopplerPoly)
|
|
@dopplerPoly.setter
|
|
def dopplerPoly(self, PyPoly2d poly):
|
|
self.c_resamp.setDoppler(poly.c_poly2d)
|
|
|
|
# Note: The "release" functions will return a PyPoly2d object that is bound
|
|
# to the corresponding ResampSlc's Poly2d, but the difference between
|
|
# this and the regular PyPoly2d property is that the PyPoly2d object
|
|
# becomes "unbound" (i.e. when the PyPoly2d object goes out of scope,
|
|
# it will destroy the Poly2d it's bound to)
|
|
def releaseRgCarrier(self):
|
|
cdef PyPoly2d poly = PyPoly2d.boundTo(self.c_resamp.releaseRgCarrier())
|
|
poly.owner = True
|
|
return poly
|
|
def releaseAzCarrier(self):
|
|
cdef PyPoly2d poly = PyPoly2d.boundTo(self.c_resamp.releaseAzCarrier())
|
|
poly.owner = True
|
|
return poly
|
|
def releaseRgOffsets(self):
|
|
cdef PyPoly2d poly = PyPoly2d.boundTo(self.c_resamp.releaseRgOffsets())
|
|
poly.owner = True
|
|
return poly
|
|
def releaseAzOffsets(self):
|
|
cdef PyPoly2d poly = PyPoly2d.boundTo(self.c_resamp.releaseAzOffsets())
|
|
poly.owner = True
|
|
return poly
|
|
def releaseDoppler(self):
|
|
cdef PyPoly2d poly = PyPoly2d.boundTo(self.c_resamp.releaseDoppler())
|
|
poly.owner = True
|
|
return poly
|
|
|
|
def resamp_slc(self):
|
|
self.c_resamp.resamp()
|
|
|