def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if self.rank == 0:
return self
if len(indices) != self.rank:
print 'indices must be ' + str(self.rank) + ' dimensions!'
return None
ranges = []
flips = []
iszerodim = True
for i in range(0, self.rank):
if isinstance(indices[i], int):
sidx = indices[i]
eidx = indices[i]
step = 1
else:
sidx = 0 if indices[i].start is None else indices[i].start
eidx = self.getshape(
)[i] - 1 if indices[i].stop is None else indices[i].stop - 1
step = 1 if indices[i].step is None else indices[i].step
if sidx != eidx:
iszerodim = False
if step < 0:
step = abs(step)
flips.append(i)
if sidx >= self.shape[i]:
raise IndexError()
rr = Range(sidx, eidx, step)
ranges.append(rr)
r = ArrayMath.section(self.array, ranges)
if iszerodim:
return r.getObject(0)
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape())
MAMath.copy(rr, r)
return MIArray(rr)
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if self.rank == 0:
return self
if len(indices) != self.rank:
print 'indices must be ' + str(self.rank) + ' dimensions!'
return None
ranges = []
flips = []
iszerodim = True
for i in range(0, self.rank):
if isinstance(indices[i], int):
sidx = indices[i]
eidx = indices[i]
step = 1
else:
sidx = 0 if indices[i].start is None else indices[i].start
eidx = self.getshape()[i]-1 if indices[i].stop is None else indices[i].stop-1
step = 1 if indices[i].step is None else indices[i].step
if sidx != eidx:
iszerodim = False
if step < 0:
step = abs(step)
flips.append(i)
if sidx >= self.shape[i]:
raise IndexError()
rr = Range(sidx, eidx, step)
ranges.append(rr)
r = ArrayMath.section(self.array, ranges)
if iszerodim:
return r.getObject(0)
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape());
MAMath.copy(rr, r);
return MIArray(rr)
def __getitem__(self, indices):
if isinstance(indices, slice):
k = indices
if k.start is None and k.stop is None and k.step is None:
r = self.dataset.dataset.read(self.name)
return DimArray(r, self.dims, self.fill_value, self.proj)
if isinstance(indices, tuple):
allnone = True
for k in indices:
if isinstance(k, slice):
if (not k.start is None) or (not k.stop is None) or (not k.step is None):
allnone = False
break
else:
allnone = False
break
if allnone:
r = self.dataset.dataset.read(self.name)
return DimArray(r, self.dims, self.fill_value, self.proj)
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.findMember(indices)
data = rr.getArray(0, m)
return NDArray(data)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
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 = NDArray(rrr)
else:
array = NDArray(rr)
data = DimArray(array, dims, self.fill_value, self.dataset.proj)
return data
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
allint = True
aindex = self.array.getIndex()
i = 0
for ii in indices:
if isinstance(ii, int):
if ii < 0:
ii = self.shape[i] + ii
aindex.setDim(i, ii)
else:
allint = False
break
i += 1
if allint:
return self.array.getObject(aindex)
if self.ndim == 0:
return self
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
ranges = []
flips = []
onlyrange = True
alllist = True
isempty = False
nshape = []
for i in range(0, self.ndim):
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self._shape[i] + k
sidx = k
eidx = k
step = 1
alllist = False
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self._shape[i] + sidx
eidx = self._shape[i] if k.stop is None else k.stop
if eidx < 0:
eidx = self._shape[i] + eidx
eidx -= 1
step = 1 if k.step is None else k.step
alllist = False
elif isinstance(k, (list, tuple, MIArray)):
if isinstance(k, MIArray):
k = k.aslist()
if isinstance(k[0], bool):
kk = []
for i in range(len(k)):
if k[i]:
kk.append(i)
k = kk
onlyrange = False
ranges.append(k)
continue
else:
print k
return None
if step < 0:
step = abs(step)
flips.append(i)
if eidx < sidx:
tempidx = sidx
sidx = eidx + 2
eidx = tempidx
if sidx >= self.shape[i]:
raise IndexError()
if eidx < sidx:
isempty = True
else:
rr = Range(sidx, eidx, step)
ranges.append(rr)
nshape.append(eidx - sidx + 1 if eidx - sidx >= 0 else 0)
if isempty:
r = ArrayUtil.zeros(nshape, 'int')
return MIArray(r)
if onlyrange:
r = ArrayMath.section(self.array, ranges)
else:
if alllist:
r = ArrayMath.takeValues(self.array, ranges)
else:
r = ArrayMath.take(self.array, ranges)
if r.getSize() == 1:
r = r.getObject(0)
if isinstance(r, Complex):
return complex(r.getReal(), r.getImaginary())
else:
return r
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape())
MAMath.copy(rr, r)
return MIArray(rr)
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
allint = True
aindex = self.array.getIndex()
i = 0
for ii in indices:
if isinstance(ii, int):
if ii < 0:
ii = self.shape[i] + ii
aindex.setDim(i, ii)
else:
allint = False
break;
i += 1
if allint:
return self.array.getObject(aindex)
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
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, (tuple, list)):
if isinstance(k, basestring):
xlims = k.split(':')
xlim = [float(xlims[0]), float(xlims[1])]
xidx = i
elif dim.getDimType() == DimensionType.Y:
k = indices[i]
#if isinstance(k, (tuple, list)):
if isinstance(k, basestring):
ylims = k.split(':')
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)
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:
#indices1.append(xlim
indices1.append(str(xlim[0]) + ':' + str(xlim[1]))
elif i == yidx:
#indices1.append(ylim)
indices1.append(str(ylim[0]) + ':' + str(ylim[1]))
else:
indices1.append(indices[i])
indices = indices1
ndims = []
ranges = []
flips = []
iszerodim = True
onlyrange = True
alllist = True
isempty = False
nshape = []
for i in range(0, self.ndim):
isrange = True
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self.dims[i].getLength() + k
sidx = k
eidx = k
step = 1
alllist = False
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.dims[i].getLength() + 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.dims[i].getLength() if k.stop is None else k.stop
if eidx < 0:
eidx = self.dims[i].getLength() + 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
alllist = False
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.dims[i]
kvalues = k.split(':')
sidx = dim.getValueIndex(float(kvalues[0]))
if len(kvalues) == 1:
eidx = sidx
step = 1
else:
eidx = dim.getValueIndex(float(kvalues[1]))
if len(kvalues) == 2:
step = 1
else:
step = int(float(kvalues[2]) / dim.getDeltaValue())
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
alllist = False
else:
print k
raise IndexError()
if isrange:
if sidx >= self.shape[i]:
raise IndexError()
if sidx != eidx:
iszerodim = False
if step < 0:
step = abs(step)
flips.append(i)
if eidx < sidx:
tempidx = sidx
sidx = eidx + 2
eidx = tempidx
if eidx < sidx:
isempty = True
else:
rr = Range(sidx, eidx, step)
ranges.append(rr)
n = eidx - sidx + 1
if n > 1:
dim = self.dims[i]
ndims.append(dim.extract(sidx, eidx, step))
nshape.append(eidx - sidx + 1 if eidx - sidx >= 0 else 0)
else:
if len(k) > 1:
dim = self.dims[i]
ndims.append(dim.extract(k))
if isempty:
r = ArrayUtil.zeros(nshape, 'int')
return MIArray(r)
if onlyrange:
r = ArrayMath.section(self.array, ranges)
else:
if alllist:
r = ArrayMath.takeValues(self.array, ranges)
return MIArray(r)
else:
r = ArrayMath.take(self.array, ranges)
if r.getSize() == 1:
return r.getObject(0)
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape());
MAMath.copy(rr, r);
array = MIArray(rr)
data = DimArray(array, ndims, self.fill_value, self.proj)
return data
def value(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
return None
#origin = []
#size = []
#stride = []
dims = []
ranges = []
flips = []
for i in range(0, self.ndim):
k = indices[i]
if isinstance(indices[i], int):
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
eidx = self.dims[i].getLength()-1 if k.stop is None else k.stop
step = 1 if k.step is None else k.step
elif isinstance(k, tuple) or isinstance(k, list):
dim = self.dims[i]
sidx = dim.getValueIndex(k[0])
if len(k) == 1:
eidx = sidx
step = 1
else:
eidx = dim.getValueIndex(k[1])
if len(k) == 2:
step = 1
else:
step = int(k[2] / dim.getDeltaValue)
else:
print k
return None
if step < 0:
step = abs(step)
flips.append(i)
rr = Range(sidx, eidx, step)
ranges.append(rr)
#origin.append(sidx)
n = eidx - sidx + 1
#size.append(n)
#stride.append(step)
if n > 1:
dim = self.dims[i]
dims.append(dim.extract(sidx, eidx, step))
#r = ArrayMath.section(self.array, origin, size, stride)
r = ArrayMath.section(self.array, ranges)
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape());
MAMath.copy(rr, r);
array = MIArray(rr)
data = DimArray(array, dims, self.fill_value, self.proj)
return data
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
return None
#origin = []
#size = []
#stride = []
dims = []
ranges = []
flips = []
iszerodim = True
for i in range(0, self.ndim):
k = indices[i]
if isinstance(indices[i], int):
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
eidx = self.dims[i].getLength()-1 if k.stop is None else k.stop-1
step = 1 if k.step is None else k.step
elif isinstance(k, tuple) or isinstance(k, list):
dim = self.dims[i]
sidx = dim.getValueIndex(k[0])
if len(k) == 1:
eidx = sidx
step = 1
else:
eidx = dim.getValueIndex(k[1])
if len(k) == 2:
step = 1
else:
step = int(k[2] / dim.getDeltaValue)
else:
print k
return None
if sidx >= self.shape[i]:
raise IndexError()
if sidx != eidx:
iszerodim = False
if step < 0:
step = abs(step)
flips.append(i)
rr = Range(sidx, eidx, step)
ranges.append(rr)
#origin.append(sidx)
n = eidx - sidx + 1
#size.append(n)
#stride.append(step)
if n > 1:
dim = self.dims[i]
dims.append(dim.extract(sidx, eidx, step))
#r = ArrayMath.section(self.array.array, origin, size, stride)
r = ArrayMath.section(self.array.array, ranges)
if iszerodim:
return r.getObject(0)
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape());
MAMath.copy(rr, r);
array = MIArray(rr)
data = DimArray(array, dims, self.fill_value, self.proj)
return data
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
allint = True
aindex = self.array.getIndex()
i = 0
for ii in indices:
if isinstance(ii, int):
if ii < 0:
ii = self.shape[i] + ii
aindex.setDim(i, ii)
else:
allint = False
break;
i += 1
if allint:
return self.array.getObject(aindex)
if self.ndim == 0:
return self
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
ranges = []
flips = []
onlyrange = True
alllist = True
isempty = False
nshape = []
for i in range(0, self.ndim):
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self._shape[i] + k
sidx = k
eidx = k
step = 1
alllist = False
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self._shape[i] + sidx
eidx = self._shape[i] if k.stop is None else k.stop
if eidx < 0:
eidx = self._shape[i] + eidx
eidx -= 1
step = 1 if k.step is None else k.step
alllist = False
elif isinstance(k, (list, tuple, MIArray)):
if isinstance(k, MIArray):
k = k.aslist()
if isinstance(k[0], bool):
kk = []
for i in range(len(k)):
if k[i]:
kk.append(i)
k = kk
onlyrange = False
ranges.append(k)
continue
else:
print k
return None
if step < 0:
step = abs(step)
flips.append(i)
if eidx < sidx:
tempidx = sidx
sidx = eidx + 2
eidx = tempidx
if sidx >= self.shape[i]:
raise IndexError()
if eidx < sidx:
isempty = True
else:
rr = Range(sidx, eidx, step)
ranges.append(rr)
nshape.append(eidx - sidx + 1 if eidx - sidx >= 0 else 0)
if isempty:
r = ArrayUtil.zeros(nshape, 'int')
return MIArray(r)
if onlyrange:
r = ArrayMath.section(self.array, ranges)
else:
if alllist:
r = ArrayMath.takeValues(self.array, ranges)
else:
r = ArrayMath.take(self.array, ranges)
if r.getSize() == 1:
r = r.getObject(0)
if isinstance(r, Complex):
return complex(r.getReal(), r.getImaginary())
else:
return r
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape());
MAMath.copy(rr, r);
return MIArray(rr)
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if self.ndim == 0:
return self
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
ranges = []
flips = []
iszerodim = True
onlyrange = True
for i in range(0, self.ndim):
k = indices[i]
if isinstance(k, int):
if k < 0:
k = self.getshape()[i] + k
sidx = k
eidx = k
step = 1
elif isinstance(k, slice):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.getshape()[i] + sidx
eidx = self.getshape()[i] - 1 if k.stop is None else k.stop - 1
if eidx < 0:
eidx = self.getshape()[i] + eidx
step = 1 if k.step is None else k.step
elif isinstance(k, (list, tuple, MIArray)):
if isinstance(k, MIArray):
k = k.aslist()
onlyrange = False
ranges.append(k)
iszerodim = False
continue
else:
print k
return None
if sidx != eidx:
iszerodim = False
if step < 0:
step = abs(step)
flips.append(i)
if sidx >= self.shape[i]:
raise IndexError()
rr = Range(sidx, eidx, step)
ranges.append(rr)
if onlyrange:
r = ArrayMath.section(self.array, ranges)
else:
r = ArrayMath.take(self.array, ranges)
if iszerodim:
r = r.getObject(0)
if isinstance(r, Complex):
return complex(r.getReal(), r.getImaginary())
else:
return r
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape())
MAMath.copy(rr, r)
return MIArray(rr)
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.findMember(indices)
data = rr.getArray(0, m)
return MIArray(data)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
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 = MIArray(rrr)
else:
array = MIArray(rr)
data = DimArray(array, dims, self.fill_value, self.dataset.proj)
return data
def __getitem__(self, indices):
#print type(indices)
if not isinstance(indices, tuple):
inds = []
inds.append(indices)
indices = inds
if len(indices) != self.ndim:
print 'indices must be ' + str(self.ndim) + ' dimensions!'
raise IndexError()
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, (tuple, list)):
if isinstance(k, basestring):
xlims = k.split(':')
xlim = [float(xlims[0]), float(xlims[1])]
xidx = i
elif dim.getDimType() == DimensionType.Y:
k = indices[i]
#if isinstance(k, (tuple, list)):
if isinstance(k, basestring):
ylims = k.split(':')
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)
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:
#indices1.append(xlim
indices1.append(str(xlim[0]) + ':' + str(xlim[1]))
elif i == yidx:
#indices1.append(ylim)
indices1.append(str(ylim[0]) + ':' + str(ylim[1]))
else:
indices1.append(indices[i])
indices = indices1
#origin = []
#size = []
#stride = []
dims = []
ranges = []
flips = []
iszerodim = True
onlyrange = True
for i in range(0, self.ndim):
isrange = True
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):
sidx = 0 if k.start is None else k.start
if sidx < 0:
sidx = self.dims[i].getLength() + sidx
eidx = self.dims[i].getLength()-1 if k.stop is None else k.stop-1
if eidx < 0:
eidx = self.dims[i].getLength() + eidx
step = 1 if k.step is None else k.step
elif isinstance(k, list):
if not isinstance(k[0], datetime.datetime):
onlyrange = False
isrange = False
ranges.append(k)
else:
sv = k[0]
sv = miutil.date2num(sv)
dim = self.dims[i]
sidx = dim.getValueIndex(sv)
if len(k) == 1:
eidx = sidx
step = 1
else:
ev = k[1]
ev = miutil.date2num(ev)
eidx = dim.getValueIndex(ev)
if len(k) == 2:
step = 1
else:
nv = k[2]
nv = miutil.date2num(k[0] + k[2]) - sv
step = int(nv / dim.getDeltaValue())
if sidx > eidx:
iidx = eidx
eidx = sidx
sidx = iidx
elif isinstance(k, basestring):
dim = self.dims[i]
kvalues = k.split(':')
sidx = dim.getValueIndex(float(kvalues[0]))
if len(kvalues) == 1:
eidx = sidx
step = 1
else:
eidx = dim.getValueIndex(float(kvalues[1]))
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
raise IndexError()
if isrange:
if sidx >= self.shape[i]:
raise IndexError()
if sidx != eidx:
iszerodim = False
if step < 0:
step = abs(step)
flips.append(i)
rr = Range(sidx, eidx, step)
ranges.append(rr)
#origin.append(sidx)
n = eidx - sidx + 1
#size.append(n)
#stride.append(step)
if n > 1:
dim = self.dims[i]
dims.append(dim.extract(sidx, eidx, step))
else:
if len(k) > 1:
dim = self.dims[i]
dims.append(dim.extract(k))
#r = ArrayMath.section(self.array.array, origin, size, stride)
if onlyrange:
r = ArrayMath.section(self.array.array, ranges)
else:
r = ArrayMath.take(self.array.array, ranges)
if r.getSize() == 1:
return r.getObject(0)
else:
for i in flips:
r = r.flip(i)
rr = Array.factory(r.getDataType(), r.getShape());
MAMath.copy(rr, r);
array = MIArray(rr)
data = DimArray(array, dims, self.fill_value, self.proj)
return data