Ejemplo n.º 1
0
 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
Ejemplo n.º 2
0
    def __getitem__(self, indices):
        if indices is None:
            rr = self.dataset.read(self.name)
            if rr.getDataType().isNumeric():
                ArrayMath.missingToNaN(rr, self.fill_value)
                array = MIArray(rr)
                data = DimArray(array, self.dims, self.fill_value,
                                self.dataset.proj)
                return data
            else:
                return rr

        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

        origin = []
        size = []
        stride = []
        dims = []
        for i in range(0, self.ndim):
            dimlen = self.dimlen(i)
            k = indices[i]
            if isinstance(k, int):
                sidx = k
                eidx = k
                step = 1
            elif isinstance(k, slice):
                sidx = 0 if k.start is None else k.start
                eidx = self.dimlen(i) - 1 if k.stop is None else k.stop
                step = 1 if k.step is None else k.step
            elif isinstance(k, (tuple, list)):
                dim = self.variable.getDimension(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)
                    if sidx > eidx:
                        iidx = eidx
                        eidx = sidx
                        sidx = iidx
            else:
                print k
                return None
            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
                dims.append(dim.extract(sidx, eidx, step))
            stride.append(step)
        rr = self.dataset.read(self.name, origin, size, stride).reduce()
        if rr.getSize() == 1:
            return rr.getObject(0)
        ArrayMath.missingToNaN(rr, self.fill_value)
        array = MIArray(rr)
        data = DimArray(array, dims, self.fill_value, self.dataset.proj)
        return data
Ejemplo n.º 3
0
 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
Ejemplo n.º 4
0
 def __getitem__(self, indices):
     if indices is None:
         rr = self.dataset.read(self.name)
         if rr.getDataType().isNumeric():
             ArrayMath.missingToNaN(rr, self.fill_value)
             array = MIArray(rr)
             data = DimArray(array, self.dims, self.fill_value, self.dataset.proj)
             return data
         else:
             return rr
             
     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
         
     origin = []
     size = []
     stride = []
     dims = []
     for i in range(0, self.ndim):  
         dimlen = self.dimlen(i)
         k = indices[i]
         if isinstance(k, int):
             sidx = k
             eidx = k
             step = 1
         elif isinstance(k, slice):
             sidx = 0 if k.start is None else k.start
             eidx = self.dimlen(i)-1 if k.stop is None else k.stop
             step = 1 if k.step is None else k.step
         elif isinstance(k, (tuple, list)):
             dim = self.variable.getDimension(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)
                 if sidx > eidx:
                     iidx = eidx
                     eidx = sidx
                     sidx = iidx
         else:
             print k
             return None
         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
             dims.append(dim.extract(sidx, eidx, step))
         stride.append(step) 
     rr = self.dataset.read(self.name, origin, size, stride).reduce()
     if rr.getSize() == 1:
         return rr.getObject(0)
     ArrayMath.missingToNaN(rr, self.fill_value)
     array = MIArray(rr)
     data = DimArray(array, dims, self.fill_value, self.dataset.proj)
     return data