Ejemplo n.º 1
0
    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)
Ejemplo n.º 2
0
    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)
Ejemplo n.º 3
0
    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)
Ejemplo n.º 4
0
    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        
Ejemplo n.º 5
0
 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
Ejemplo n.º 6
0
    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
Ejemplo n.º 7
0
    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)
Ejemplo n.º 8
0
    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)
Ejemplo n.º 9
0
 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