def convert_array(a):
'''
Convert netcdf Array to NDArray or conversely.
:param a: (*netcdf Array or NDArray*) Input array.
:returns: (*NDArray or netcdf Array) Output array.
'''
if isinstance(a, Array):
return NDArray(NCUtil.convertArray(a))
else:
return NCUtil.convertArray(a._array)
def dtype(self):
"""
Get array data type.
:return: (*DataType*) Array data type.
"""
return NCUtil.convertDataType(self._array.getDataType())
def member_array(self, member, indices=None):
'''
Extract member array. Only valid for Structure data type.
:param member: (*string*) Member name.
:param indices: (*slice*) Indices.
:returns: (*array*) Extracted member array.
'''
a = self.read()
if a._array.getDataType() != DataType.STRUCTURE:
print 'This method is only valid for structure array!'
return None
a = a._array.getArrayObject()
if isinstance(member, basestring):
member = a.findMember(member)
if member is None:
raise KeyError('The member %s not exists!' % member)
self.dataset.reopen()
a = a.extractMemberArray(member)
if a.getDataType() in [NCDataType.SEQUENCE, NCDataType.STRUCTURE]:
return StructureArray(a)
a = NCUtil.convertArray(a)
r = np.array(a)
if r.size == 1:
return r[0]
if not indices is None:
r = r.__getitem__(indices)
return r
def write(self, variable, value, origin=None):
'''
Write variable value.
:param variable: (*Variable*) Variable object.
:param value: (*array_like*) Data array to be write.
:param origin: (*list*) Dimensions origin indices. None means all from 0.
'''
if isinstance(value, (list, tuple)):
value = np.array(value)
if isinstance(value, np.NDArray):
value = NCUtil.convertArray(value._array)
if isinstance(variable, DimVariable):
if self.access == 'c':
ncvariable = variable.ncvariable
if ncvariable is None:
ncvariable = self.ncfile.findVariable(variable.name)
if ncvariable is None:
ncvariable = variable.name
else:
ncvariable = self.dataset.getDataInfo().findNCVariable(
variable.name)
else:
ncvariable = variable
if origin is None:
self.ncfile.write(ncvariable, value)
else:
origin = jarray.array(origin, 'i')
self.ncfile.write(ncvariable, origin, value)
def addattr(self, attrname, attrvalue):
if self.ncvariable is None:
if self.attributes is None:
self.attributes = []
self.attributes.append(Attribute(attrname, attrvalue))
else:
if isinstance(attrvalue, np.NDArray):
attrvalue = NCUtil.convertArray(attrvalue._array)
self.ncvariable.addAttribute(NCAttribute(attrname, attrvalue))
def addgroupattr(self, attrname, attrvalue, group=None, float=False):
'''
Add a global attribute.
:param attrname: (*string*) Attribute name.
:param attrvalue: (*object*) Attribute value.
:param group: None means global attribute.
:param float: (*boolean*) Transfer data as float or not.
'''
if float:
if isinstance(attrvalue, (list, tuple)):
for i in range(len(attrvalue)):
attrvalue[i] = Float(attrvalue[i])
else:
attrvalue = Float(attrvalue)
if isinstance(attrvalue, np.NDArray):
attrvalue = NCUtil.convertArray(attrvalue._array)
return self.ncfile.addGroupAttribute(group, NCAttribute(attrname, attrvalue))
def __getdatatype(self, datatype):
if isinstance(datatype, str):
if datatype == 'string':
dt = NCDataType.STRING
elif datatype == 'int':
dt = NCDataType.INT
elif datatype == 'long':
dt = NCDataType.LONG
elif datatype == 'float':
dt = NCDataType.FLOAT
elif datatype == 'double':
dt = NCDataType.DOUBLE
elif datatype == 'char':
dt = NCDataType.CHAR
else:
dt = NCDataType.STRING
return dt
else:
if isinstance(datatype, DataType):
datatype = NCUtil.convertDataType(datatype._dtype)
return datatype
def member_array(self, member, indices=None, rec=0):
'''
Extract member array. Only valid for Structure data type.
:param member: (*string*) Member name.
:param indices: (*slice*) Indices.
:param rec: (*int*) Record index.
:returns: (*array*) Extracted member array.
'''
is_structure = isinstance(self._array, ArrayStructure)
if isinstance(member, basestring):
if is_structure:
member = self._array.findMember(member)
else:
member = self._array.getObject(rec).findMember(member)
if member is None:
raise KeyError('The member %s not exists!' % member)
if is_structure:
a = self._array.extractMemberArray(member)
else:
a = self._array.getObject(rec).extractMemberArray(member)
if a.getDataType() in [NCDataType.SEQUENCE, NCDataType.STRUCTURE]:
return StructureArray(a)
a = NCUtil.convertArray(a)
r = np.array(a)
if r.size == 1:
return r[0]
if not indices is None:
r = r.__getitem__(indices)
return r
def addattr(self, attrname, attrvalue):
if isinstance(attrvalue, np.NDArray):
attrvalue = NCUtil.convertArray(attrvalue._array)
self.ncvariable.addAttribute(NCAttribute(attrname, attrvalue))
def __getitem__(self, indices):
if indices is None:
inds = []
for i in range(self.ndim):
inds.append(slice(None))
indices = tuple(inds)
if isinstance(indices, str): #metadata
rr = self.dataset.read(self.name)
m = rr.getArrayObject().findMember(indices)
data = rr.getArrayObject().getArray(0, m)
data = NCUtil.convertArray(data)
return np.array(data)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) < self.ndim:
for i in range(self.ndim - len(indices)):
indices.append(slice(None))
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
return None
if not self.proj is None and not self.proj.isLonLat():
xlim = None
ylim = None
xidx = -1
yidx = -1
for i in range(0, self.ndim):
dim = self.dims[i]
if dim.getDimType() == DimensionType.X:
k = indices[i]
if isinstance(k, basestring):
xlims = k.split(':')
if len(xlims) == 1:
xlim = [float(xlims[0])]
else:
xlim = [float(xlims[0]), float(xlims[1])]
xidx = i
elif dim.getDimType() == DimensionType.Y:
k = indices[i]
if isinstance(k, basestring):
ylims = k.split(':')
if len(ylims) == 1:
ylim = [float(ylims[0])]
else:
ylim = [float(ylims[0]), float(ylims[1])]
yidx = i
if not xlim is None and not ylim is None:
fromproj=KnownCoordinateSystems.geographic.world.WGS1984
inpt = PointD(xlim[0], ylim[0])
outpt1 = Reproject.reprojectPoint(inpt, fromproj, self.proj)
if len(xlim) == 1:
xlim = [outpt1.X]
ylim = [outpt1.Y]
else:
inpt = PointD(xlim[1], ylim[1])
outpt2 = Reproject.reprojectPoint(inpt, fromproj, self.proj)
xlim = [outpt1.X, outpt2.X]
ylim = [outpt1.Y, outpt2.Y]
indices1 = []
for i in range(0, self.ndim):
if i == xidx:
if len(xlim) == 1:
indices1.append(str(xlim[0]))
else:
indices1.append(str(xlim[0]) + ':' + str(xlim[1]))
elif i == yidx:
if len(ylim) == 1:
indices1.append(str(ylim[0]))
else:
indices1.append(str(ylim[0]) + ':' + str(ylim[1]))
else:
indices1.append(indices[i])
indices = indices1
origin = []
size = []
stride = []
ranges = []
dims = []
flips = []
onlyrange = True
for i in range(0, self.ndim):
isrange = True
dimlen = self.dimlen(i)
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self.dims[i].getLength() + k
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
if isinstance(k.start, basestring):
sv = float(k.start)
sidx = self.dims[i].getValueIndex(sv)
elif isinstance(k.start, datetime.datetime):
sv = miutil.date2num(k.start)
sidx = self.dims[i].getValueIndex(sv)
else:
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.dimlen(i) + sidx
if isinstance(k.stop, basestring):
ev = float(k.stop)
eidx = self.dims[i].getValueIndex(ev)
elif isinstance(k.stop, datetime.datetime):
ev = miutil.date2num(k.stop)
eidx = self.dims[i].getValueIndex(ev)
else:
eidx = self.dimlen(i) if k.stop is None else k.stop
if eidx < 0:
eidx = self.dimlen(i) + eidx
eidx -= 1
if isinstance(k.step, basestring):
nv = float(k.step) + self.dims[i].getDimValue()[0]
nidx = self.dims[i].getValueIndex(nv)
step = nidx - sidx
elif isinstance(k.step, datetime.timedelta):
nv = miutil.date2num(k.start + k.step)
nidx = self.dims[i].getValueIndex(nv)
step = nidx - sidx
else:
step = 1 if k.step is None else k.step
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
elif isinstance(k, list):
onlyrange = False
isrange = False
if not isinstance(k[0], datetime.datetime):
ranges.append(k)
else:
tlist = []
for tt in k:
sv = miutil.date2num(tt)
idx = self.dims[i].getValueIndex(sv)
tlist.append(idx)
ranges.append(tlist)
k = tlist
elif isinstance(k, basestring):
dim = self.variable.getDimension(i)
kvalues = k.split(':')
sv = float(kvalues[0])
sidx = dim.getValueIndex(sv)
if len(kvalues) == 1:
eidx = sidx
step = 1
else:
ev = float(kvalues[1])
eidx = dim.getValueIndex(ev)
if len(kvalues) == 2:
step = 1
else:
step = int(float(kvalues[2]) / dim.getDeltaValue())
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
else:
print k
return None
if isrange:
if eidx >= dimlen:
print 'Index out of range!'
return None
origin.append(sidx)
n = eidx - sidx + 1
size.append(n)
if n > 1:
dim = self.variable.getDimension(i)
if dim.isReverse():
step = -step
dim = dim.extract(sidx, eidx, step)
dim.setReverse(False)
dims.append(dim)
stride.append(step)
if step < 0:
step = abs(step)
flips.append(i)
rr = Range(sidx, eidx, step)
ranges.append(rr)
else:
if len(k) > 1:
dim = self.variable.getDimension(i)
dim = dim.extract(k)
dim.setReverse(False)
dims.append(dim)
#rr = self.dataset.read(self.name, origin, size, stride).reduce()
if onlyrange:
rr = self.dataset.dataset.read(self.name, ranges)
else:
rr = self.dataset.dataset.take(self.name, ranges)
if rr.getSize() == 1:
return rr.getObject(0)
else:
for i in flips:
rr = rr.flip(i)
rr = rr.reduce()
ArrayMath.missingToNaN(rr, self.fill_value)
if len(flips) > 0:
rrr = Array.factory(rr.getDataType(), rr.getShape())
MAMath.copy(rrr, rr)
array = np.array(rrr)
else:
array = np.array(rr)
data = np.DimArray(array, dims, self.fill_value, self.dataset.proj)
return data
