Changeset 911

Timestamp:

02/16/12 12:28:34 (15 months ago)

Author:

jjr8

Message:

Fixed/implemented:
* #517: Interpolate OSCAR Currents At Points tool fails with AttributeError?: 'NoneType?' object has no attribute 'lower'
* #518: MGET tools should utilize the ArcGIS progress bar (ArcGIS 9.3 and higher)
* #519: Ocean currents tools (Aviso, OSCAR, HYCOM, ROMS-CoSiNE) should calculate eddy kinetic energy, current direction, and current magnitude grids
* #520: Add tools for Chelton et al. (2011) study "Global observations of nonlinear mesoscale eddies"
Some are not completely done.

Location:

MGET/Branches/Jason/PythonPackage/src/GeoEco

Files:

• DataProducts/Aviso.py (modified) (7 diffs)
• DataProducts/NOAA/OSCAR.py (modified) (19 diffs)
• DataProducts/OSU/MesoscaleEddies.py (modified) (9 diffs)
• Datasets/Collections.py (modified) (2 diffs)
• Datasets/Virtual.py (modified) (3 diffs)
• Datasets/__init__.py (modified) (5 diffs)
• Logging.py (modified) (9 diffs)
• SpatialAnalysis/Interpolation.py (modified) (1 diff)

MGET/Branches/Jason/PythonPackage/src/GeoEco/DataProducts/Aviso.py

@@ -194 +194 @@
         
         if rotationOffset is not None:
-            if u'-global-' not in grid.ParentCollection.URL:
+            if grid.ParentCollection is not None and u'-global-' not in grid.ParentCollection.URL:
                 raise ValueError(_(u'The Rotate Raster parameter may only be used with global products. Please omit the Rotate Raster parameter and try again.'))
 
@@ -504 +504 @@
 
     @classmethod
-    def CreateArcGISRasters(cls, username, password, productName, vectorComponent, temporalResolution,
+    def _ConstructGridForParameter(cls, productName, parameter, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory):
+
+        # If the caller just wants u or v, construct and return a
+        # AvisoGriddedGeostrophicCurrents instance.
+        
+        if parameter in [u'u', u'v']:
+            AvisoGriddedGeostrophicCurrents(productName, parameter, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
+
+        # The caller wants something derived from both u and v. First
+        # create u and v component grids.
+        
+        uGrid = AvisoGriddedGeostrophicCurrents(productName, u'u', temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
+        vGrid = AvisoGriddedGeostrophicCurrents(productName, u'v', temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
+
+        # Now construct and return the appropriate DerivedGrid
+        # instance.
+
+        qav = {}
+        for qa in uGrid.GetAllQueryableAttributes():
+            qav[qa.Name] = uGrid.GetQueryableAttributeValue(qa.Name)
+
+        from GeoEco.Datasets.Virtual import DerivedGrid
+
+        if parameter == u'dir':
+            qav[u'Variable'] = qav[u'Variable'].split(u'_')[0] + u'_dir'
+            
+            return DerivedGrid([uGrid, vGrid],
+                               'numpy.arctan2(0 - self._Grids[0].Data.__getitem__(tuple(sliceList)), 0 - self._Grids[1].Data.__getitem__(tuple(sliceList))) / numpy.pi * 180 + 180',    # north = 0, east = 90, south = 180, west = 270
+                               _(u'Aviso %(product)s geostrophic current magnitude') % {u'product': productName},
+                               u'float32',
+                               noDataValue=uGrid.NoDataValue,
+                               queryableAttributes=tuple(uGrid.GetAllQueryableAttributes()),
+                               queryableAttributeValues=qav)
+
+        if parameter == u'eke':
+            if not productName.lower().endswith('madt'):
+                raise ValueError(_(u'In order to compute eddy kinetic energy, an MADT product must be used.'))
+            
+            qav[u'Variable'] = qav[u'Variable'].split(u'_')[0] + u'_eke'
+            
+            return DerivedGrid([uGrid, vGrid],
+                               '0.5 * (self._Grids[0].Data.__getitem__(tuple(sliceList))**2 + self._Grids[1].Data.__getitem__(tuple(sliceList))**2)',
+                               _(u'Aviso %(product)s eddy kinetic energy') % {u'product': productName},
+                               u'float32',
+                               noDataValue=uGrid.NoDataValue,
+                               queryableAttributes=tuple(uGrid.GetAllQueryableAttributes()),
+                               queryableAttributeValues=qav)
+
+        if parameter == u'mag':
+            qav[u'Variable'] = qav[u'Variable'].split(u'_')[0] + u'_mag'
+            
+            return DerivedGrid([uGrid, vGrid],
+                               '(self._Grids[0].Data.__getitem__(tuple(sliceList))**2 + self._Grids[1].Data.__getitem__(tuple(sliceList))**2) ** 0.5',
+                               _(u'Aviso %(product)s geostrophic current magnitude') % {u'product': productName},
+                               u'float32',
+                               noDataValue=uGrid.NoDataValue,
+                               queryableAttributes=tuple(uGrid.GetAllQueryableAttributes()),
+                               queryableAttributeValues=qav)
+            
+        raise RuntimeError(_(u'Programming error in this tool: AvisoGriddedGeostrophicCurrents._ConstructGridForParameter() does not recognize parameter "%(parameter)s". Please contact the author of this tool for assistance.') % {u'parameter': parameter})
+
+    @classmethod
+    def CreateArcGISRasters(cls, username, password, productName, parameter, temporalResolution,
                             outputWorkspace, mode=u'add', rasterNameExpressions=['%(Region)s', '%(DataSeries)s', '%(Satellites)s', '%(TemporalResolution)s', '%(Variable)s', '%%Y', '%(DataSeries)s_%(Satellites)s_%(Variable)s_%%Y%%j.img'],
                             rotationOffset=None, spatialExtent=None, linearUnit=u'Degrees', startDate=None, endDate=None,
@@ -510 +572 @@
                             calculateStatistics=True, buildPyramids=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
-        grid = AvisoGriddedGeostrophicCurrents(productName, vectorComponent, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
+        grid = cls._ConstructGridForParameter(productName, parameter, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
         _AvisoGriddedProduct.CreateArcGISRasters(grid, outputWorkspace, mode, rasterNameExpressions, rotationOffset, spatialExtent, linearUnit, startDate, endDate, calculateStatistics, buildPyramids)
         return outputWorkspace
 
     @classmethod
-    def CreateClimatologicalArcGISRasters(cls, username, password, productName, vectorComponent, temporalResolution,
+    def CreateClimatologicalArcGISRasters(cls, username, password, productName, parameter, temporalResolution,
                                           statistic, binType,
                                           outputWorkspace, mode=u'add', rasterNameExpressions=['%(Region)s', '%(DataSeries)s', '%(Satellites)s', '%(TemporalResolution)s', '%(Variable)s', u'%(ClimatologyBinType)s_Climatology', u'%(DataSeries)s_%(Satellites)s_%(Variable)s_%(ClimatologyBinName)s_%(Statistic)s.img'],
@@ -523 +585 @@
                                           calculateStatistics=True, buildPyramids=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
-        grid = AvisoGriddedGeostrophicCurrents(productName, vectorComponent, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
+        grid = cls._ConstructGridForParameter(productName, parameter, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
         _AvisoGriddedProduct.CreateClimatologicalArcGISRasters(grid, statistic, binType, outputWorkspace, mode, rasterNameExpressions, binDuration, startDayOfYear, rotationOffset, spatialExtent, linearUnit, startDate, endDate, calculateStatistics, buildPyramids)
         return outputWorkspace
 
     @classmethod
-    def InterpolateAtArcGISPoints(cls, username, password, productName, vectorComponent, temporalResolution,
+    def InterpolateAtArcGISPoints(cls, username, password, productName, parameter, temporalResolution,
                                    points, valueField, tField, method=u'Nearest', where=None, noDataValue=None,
                                    timeout=60, maxRetryTime=120, cacheDirectory=None,
                                    orderByFields=None, numBlocksToCacheInMemory=128, xBlockSize=16, yBlockSize=16, tBlockSize=3):
         cls.__doc__.Obj.ValidateMethodInvocation()
-        grid = AvisoGriddedGeostrophicCurrents(productName, vectorComponent, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
+        grid = cls._ConstructGridForParameter(productName, parameter, temporalResolution, username, password, timeout, maxRetryTime, cacheDirectory)
         _AvisoGriddedProduct.InterpolateAtArcGISPoints(grid, points, valueField, tField, method, where, noDataValue, orderByFields, numBlocksToCacheInMemory, xBlockSize, yBlockSize, tBlockSize)
         return points
@@ -1944 +2006 @@
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'password', AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'password')
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'productName', AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'productName')
-CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'vectorComponent', AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'vectorComponent')
+
+AddArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'parameter',
+    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'dir', u'eke', u'mag', u'u', u'v'], makeLowercase=True),
+    description=_(
+u"""Geophysical parameter to use, one of:
+
+* dir - Direction of geostrophic water flow, in degrees. Due north is
+  0, due east is 90, due south is 180, due west is 270.
+
+* eke - Eddy kinetic energy, in cm^2/s^2, computed as 0.5*(u^2 + v^2).
+
+* mag - Absolute magnitude (or modulus) of the geostrophic water
+  velocity vector, in cm/s.
+
+* u - Eastward geostrophic water velocity, in cm/s.
+
+* v - Northward geostrophic water velocity, in cm/s.
+"""),
+    arcGISDisplayName=_(u'Geophysical parameter'))
+
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'temporalResolution', AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'temporalResolution')
 CopyArgumentMetadata(AvisoGriddedSSH.CreateArcGISRasters, u'outputWorkspace', AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'outputWorkspace')
@@ -1978 +2059 @@
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'password', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'password')
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'productName', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'productName')
-CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'vectorComponent', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'vectorComponent')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'parameter', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'parameter')
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'temporalResolution', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'temporalResolution')
 CopyArgumentMetadata(AvisoGriddedSSH.CreateClimatologicalArcGISRasters, u'statistic', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'statistic')
@@ -2173 +2254 @@
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'password', AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints, u'password')
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'productName', AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints, u'productName')
-CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'vectorComponent', AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints, u'vectorComponent')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'parameter', AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints, u'parameter')
 CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'temporalResolution', AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints, u'temporalResolution')
 CopyArgumentMetadata(AvisoGriddedSSH.InterpolateAtArcGISPoints, u'points', AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints, u'points')

MGET/Branches/Jason/PythonPackage/src/GeoEco/DataProducts/NOAA/OSCAR.py

@@ -79 +79 @@
             self.ParentCollection._Open()
             self._CachedTCenterCoords = numpy.array(map(lambda days: datetime.timedelta(int(days)) + datetime.datetime(1992, 10, 5), list(self.ParentCollection._PydapDataset['time'][:])), dtype='object')
+            self._CachedTMinCoords = numpy.array([self._CachedTCenterCoords[0] - (self._CachedTCenterCoords[1] - self._CachedTCenterCoords[0])/2] + map(lambda a, b: a + (b-a)/2, self._CachedTCenterCoords[:-1], self._CachedTCenterCoords[1:]))
+            self._CachedTMaxCoords = numpy.array(map(lambda a, b: a + (b-a)/2, self._CachedTCenterCoords[:-1], self._CachedTCenterCoords[1:]) + [self._CachedTCenterCoords[-1] + (self._CachedTCenterCoords[-1] - self._CachedTCenterCoords[-2])/2])
+
         if slices is None:
-            result = self._CachedTCenterCoords.copy()
-        else:
-            result = self._CachedTCenterCoords.__getitem__(*slices)
-        if fixedIncrementOffset != 0:
-            result += datetime.timedelta(fixedIncrementOffset)
-
-        return result
+            if fixedIncrementOffset < 0:
+                return self._CachedTMinCoords.copy()
+            if fixedIncrementOffset == 0:
+                return self._CachedTCenterCoords.copy()
+            return self._CachedTMaxCoords.copy()
+            
+        if fixedIncrementOffset < 0:
+            return self._CachedTMinCoords.__getitem__(*slices)
+        if fixedIncrementOffset == 0:
+            return self._CachedTCenterCoords.__getitem__(*slices)
+        return self._CachedTMaxCoords.__getitem__(*slices)
 
     def _ReadNumpyArray(self, sliceList):
@@ -103 +110 @@
     __doc__ = DynamicDocString()
 
-    def _GetVariableName(self):
-        return self._VectorComponent
-
-    VectorComponent = property(_GetVariableName, doc=DynamicDocString())
-
-    def __init__(self, vectorComponent, timeout=60, maxRetryTime=120, cacheDirectory=None):
+    def _GetParameter(self):
+        return self._Parameter
+
+    Parameter = property(_GetParameter, doc=DynamicDocString())
+
+    def __init__(self, parameter, timeout=60, maxRetryTime=120, cacheDirectory=None):
         self.__doc__.Obj.ValidateMethodInvocation()
 
         # Initialize our properties.
 
-        self._VectorComponent = vectorComponent
-        self._DisplayName = _(u'%(name)s component of the OSCAR 5-day unfiltered 1/3 degree ocean surface currents') % {u'name': vectorComponent}
+        self._Parameter = parameter
         self._Timeout = timeout
         self._MaxRetryTime = maxRetryTime
@@ -120 +126 @@
         self._Grid = None
 
+        if parameter == u'eke':
+            self._DisplayName = _(u'eddy kinetic energy calcuated from the OSCAR 5-day unfiltered 1/3 degree ocean surface currents')
+        elif parameter == u'dir':
+            self._DisplayName = _(u'direction of the OSCAR 5-day unfiltered 1/3 degree ocean surface currents')
+        elif parameter == u'mag':
+            self._DisplayName = _(u'magnitude of the OSCAR 5-day unfiltered 1/3 degree ocean surface currents')
+        else:
+            self._DisplayName = _(u'%(name)s component of the OSCAR 5-day unfiltered 1/3 degree ocean surface currents') % {u'name': parameter}
+
         # Initialize the base class.
 
-        super(OSCAR5DayThirdDegreeCurrents, self).__init__(queryableAttributes=(QueryableAttribute(u'VectorComponent', _(u'Vector component'), UnicodeStringTypeMetadata(allowedValues=[u'u', u'v', u'u_anom', u'v_anom'], makeLowercase=True)),),
-                                                           queryableAttributeValues={u'VectorComponent': vectorComponent},
+        super(OSCAR5DayThirdDegreeCurrents, self).__init__(queryableAttributes=(QueryableAttribute(u'Parameter', _(u'Geophysical parameter'), UnicodeStringTypeMetadata(allowedValues=[u'dir', u'dir_anom', u'eke', u'mag', u'mag_anom', u'u', u'v', u'u_anom', u'v_anom'], makeLowercase=True)),),
+                                                           queryableAttributeValues={u'Parameter': parameter},
                                                            lazyPropertyValues={'SpatialReference': Dataset.ConvertSpatialReference('proj4', '+proj=latlong +ellps=WGS84 +datum=WGS84 +no_defs', 'obj'),
                                                                                'Dimensions': u'tyx',
@@ -154 +169 @@
         if name in ['CornerCoords', 'Shape']:
             if self._Grid is None:
-                self._Grid = _OSCAR5DayThirdDegreeCurrents4D(self._VectorComponent, self._Timeout, self._MaxRetryTime, self._CacheDirectory)
+                self._Grid = cls._ConstructGridForParameter(self._Parameter, self._Timeout, self._MaxRetryTime, self._CacheDirectory)
 
             if name == 'CornerCoords':
@@ -174 +189 @@
 
         if self._Grid is None:
-            self._Grid = _OSCAR5DayThirdDegreeCurrents4D(self._VectorComponent, self._Timeout, self._MaxRetryTime, self._CacheDirectory)
+            self._Grid = cls._ConstructGridForParameter(self._Parameter, self._Timeout, self._MaxRetryTime, self._CacheDirectory)
         
         return self._Grid._GetCoords(coord, coordNum, slices, sliceDims, fixedIncrementOffset)
@@ -190 +205 @@
 
         if self._Grid is None:
-            self._Grid = _OSCAR5DayThirdDegreeCurrents4D(self._VectorComponent, self._Timeout, self._MaxRetryTime, self._CacheDirectory)
+            self._Grid = cls._ConstructGridForParameter(self._Parameter, self._Timeout, self._MaxRetryTime, self._CacheDirectory)
 
         sliceList = [sliceList[0], slice(0, 1), sliceList[1], sliceList[2]]
         data, noDataValue = self._Grid._ReadNumpyArray(sliceList)
         return data.reshape(data.shape[0], data.shape[2], data.shape[3]), noDataValue
+
+    @classmethod
+    def _ConstructGridForParameter(cls, parameter, timeout, maxRetryTime, cacheDirectory):
+
+        # If the caller just wants u, v, u_anom, or v_anom, construct
+        # and return a OSCAR5DayThirdDegreeCurrents instance.
+        
+        if parameter in [u'u', u'v', u'u_anom', u'v_anom']:
+            OSCAR5DayThirdDegreeCurrents(parameter, timeout, maxRetryTime, cacheDirectory)
+
+        # The caller wants something derived from both u and v. First
+        # create u and v component grids.
+
+        if parameter.endswith('_anom'):
+            uGrid = OSCAR5DayThirdDegreeCurrents(u'u_anom', timeout, maxRetryTime, cacheDirectory)
+            vGrid = OSCAR5DayThirdDegreeCurrents(u'v_anom', timeout, maxRetryTime, cacheDirectory)
+        else:
+            uGrid = OSCAR5DayThirdDegreeCurrents(u'u', timeout, maxRetryTime, cacheDirectory)
+            vGrid = OSCAR5DayThirdDegreeCurrents(u'v', timeout, maxRetryTime, cacheDirectory)
+
+        # Now construct and return the appropriate DerivedGrid
+        # instance.
+
+        qav = {}
+        for qa in uGrid.GetAllQueryableAttributes():
+            qav[qa.Name] = uGrid.GetQueryableAttributeValue(qa.Name)
+        qav[u'Parameter'] = parameter
+
+        from GeoEco.Datasets.Virtual import DerivedGrid
+
+        if parameter in [u'dir', u'dir_anom']:
+            return DerivedGrid([uGrid, vGrid],
+                               'numpy.arctan2(0 - self._Grids[0].Data.__getitem__(tuple(sliceList)), 0 - self._Grids[1].Data.__getitem__(tuple(sliceList))) / numpy.pi * 180 + 180',    # north = 0, east = 90, south = 180, west = 270
+                               _(u'OSCAR %(parameter)s') % {u'parameter': parameter},
+                               u'float32',
+                               noDataValue=uGrid.NoDataValue,
+                               queryableAttributes=tuple(uGrid.GetAllQueryableAttributes()),
+                               queryableAttributeValues=qav)
+
+        if parameter == u'eke':
+            return DerivedGrid([uGrid, vGrid],
+                               '0.5 * (self._Grids[0].Data.__getitem__(tuple(sliceList))**2 + self._Grids[1].Data.__getitem__(tuple(sliceList))**2)',
+                               _(u'OSCAR %(parameter)s') % {u'parameter': parameter},
+                               u'float32',
+                               noDataValue=uGrid.NoDataValue,
+                               queryableAttributes=tuple(uGrid.GetAllQueryableAttributes()),
+                               queryableAttributeValues=qav)
+
+        if parameter in [u'mag', u'mag_anom']:
+            return DerivedGrid([uGrid, vGrid],
+                               '(self._Grids[0].Data.__getitem__(tuple(sliceList))**2 + self._Grids[1].Data.__getitem__(tuple(sliceList))**2) ** 0.5',
+                               _(u'OSCAR %(parameter)s') % {u'parameter': parameter},
+                               u'float32',
+                               noDataValue=uGrid.NoDataValue,
+                               queryableAttributes=tuple(uGrid.GetAllQueryableAttributes()),
+                               queryableAttributeValues=qav)
+            
+        raise RuntimeError(_(u'Programming error in this tool: OSCAR5DayThirdDegreeCurrents._ConstructGridForParameter() does not recognize parameter "%(parameter)s". Please contact the author of this tool for assistance.') % {u'parameter': parameter})
 
     @classmethod
@@ -226 +299 @@
 
     @classmethod
-    def CreateArcGISRasters(cls, vectorComponent,
-                            outputWorkspace, mode=u'add', rasterNameExpressions=['%(VectorComponent)s', '%%Y', '%(VectorComponent)s_%%Y%%j.img'],
+    def CreateArcGISRasters(cls, parameter,
+                            outputWorkspace, mode=u'add', rasterNameExpressions=['%(Parameter)s', '%%Y', '%(Parameter)s_%%Y%%j.img'],
                             rotationOffset=None, spatialExtent=None, startDate=None, endDate=None,
                             timeout=60, maxRetryTime=120, cacheDirectory=None,
                             calculateStatistics=True, buildPyramids=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
-        grid = OSCAR5DayThirdDegreeCurrents(vectorComponent, timeout, maxRetryTime, cacheDirectory)
+        grid = OSCAR5DayThirdDegreeCurrents(parameter, timeout, maxRetryTime, cacheDirectory)
         try:
             from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISRaster
@@ -244 +317 @@
 
     @classmethod
-    def CreateClimatologicalArcGISRasters(cls, vectorComponent,
+    def CreateClimatologicalArcGISRasters(cls, parameter,
                                           statistic, binType,
-                                          outputWorkspace, mode=u'add', rasterNameExpressions=['%(VectorComponent)s', u'%(ClimatologyBinType)s_Climatology', u'%(VectorComponent)s_%(ClimatologyBinName)s_%(Statistic)s.img'],
+                                          outputWorkspace, mode=u'add', rasterNameExpressions=['%(Parameter)s', u'%(ClimatologyBinType)s_Climatology', u'%(Parameter)s_%(ClimatologyBinName)s_%(Statistic)s.img'],
                                           binDuration=1, startDayOfYear=1,
                                           rotationOffset=None, spatialExtent=None, startDate=None, endDate=None,
@@ -252 +325 @@
                                           calculateStatistics=True, buildPyramids=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
-        grid = OSCAR5DayThirdDegreeCurrents(vectorComponent, timeout, maxRetryTime, cacheDirectory)
+        grid = OSCAR5DayThirdDegreeCurrents(parameter, timeout, maxRetryTime, cacheDirectory)
         try:
             from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISRaster
@@ -320 +393 @@
 
     @classmethod
-    def InterpolateAtArcGISPoints(cls, vectorComponent,
+    def InterpolateAtArcGISPoints(cls, parameter,
                                    points, valueField, tField, method=u'Nearest', where=None, noDataValue=None,
                                    timeout=60, maxRetryTime=120, cacheDirectory=None,
                                    orderByFields=None, numBlocksToCacheInMemory=128, xBlockSize=16, yBlockSize=16, tBlockSize=3):
         cls.__doc__.Obj.ValidateMethodInvocation()
-        grid = OSCAR5DayThirdDegreeCurrents(vectorComponent, timeout, maxRetryTime, cacheDirectory)
+        grid = OSCAR5DayThirdDegreeCurrents(parameter, timeout, maxRetryTime, cacheDirectory)
         try:
             if orderByFields is not None:
@@ -429 +502 @@
     description=_(u'OSCAR5DayThirdDegreeCurrents instance.'))
 
-AddArgumentMetadata(OSCAR5DayThirdDegreeCurrents.__init__, u'vectorComponent',
-    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'u', u'v', u'u_anom', u'v_anom'], makeLowercase=True),
-    description=_(
-u"""OSCAR currents vector component, one of:
+AddArgumentMetadata(OSCAR5DayThirdDegreeCurrents.__init__, u'parameter',
+    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'dir', u'dir_anom', u'eke', u'mag', u'mag_anom', u'u', u'v', u'u_anom', u'v_anom'], makeLowercase=True),
+    description=_(
+u"""Geophysical parameter to use, one of:
+
+* dir - Direction of water flow, in degrees. Due north is 0, due east
+  is 90, due south is 180, due west is 270.
+
+* dir_anom - Direction of water flow (from u_anom and v_anom).
+
+* eke - Eddy kinetic energy, in cm^2/s^2, computed as 0.5*(u^2 + v^2).
+
+* mag - Absolute magnitude (or modulus) of the water velocity vector,
+  in cm/s.
+
+* mag_anom - Absolute magnitude of water velocity (from u_anom and
+  v_anom).
 
 * u - Eastward sea water velocity, in m/s.
@@ -451 +537 @@
 Please see the OSCAR documentation for more information about these
 variables."""),
-    arcGISDisplayName=_(u'Vector component'))
+    arcGISDisplayName=_(u'Geophysical parameter'))
 
 CopyArgumentMetadata(THREDDSCatalog.__init__, u'timeout', OSCAR5DayThirdDegreeCurrents.__init__, u'timeout')
@@ -477 +563 @@
     description=_(u'OSCAR5DayThirdDegreeCurrents class or instance.'))
 
-CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.__init__, u'vectorComponent', OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'vectorComponent')
+CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.__init__, u'parameter', OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'parameter')
 
 AddArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'outputWorkspace',
@@ -516 +602 @@
 The default expression assumes you are storing rasters in a file
 system directory and creates them in a tree structure with levels for
-the vector component and year. When storing rasters in a directory,
-the final expression specifies the file name of the raster and any
-preceding expressions specify subdirectories. The extension of the
-final expression determines the output raster format: .asc for ArcInfo
-ASCII Grid, .bmp for BMP, .gif for GIF, .img for an ERDAS IMAGINE
-file, .jpg for JPEG, .jp2 for JPEG 2000, .png for PNG, .tif for
-GeoTIFF, or no extension for ArcInfo Binary Grid. The default
+the geophysical parameter and year. When storing rasters in a
+directory, the final expression specifies the file name of the raster
+and any preceding expressions specify subdirectories. The extension of
+the final expression determines the output raster format: .asc for
+ArcInfo ASCII Grid, .bmp for BMP, .gif for GIF, .img for an ERDAS
+IMAGINE file, .jpg for JPEG, .jp2 for JPEG 2000, .png for PNG, .tif
+for GeoTIFF, or no extension for ArcInfo Binary Grid. The default
 expression uses .img.
 
@@ -533 +619 @@
 codes with appropriate values when creating each raster:
 
-* %(VectorComponent)s - Vector component represented by the the output
-  raster, either "u", "v", "u_anom", or "v_anom".
+* %(Parameter)s - Geophysical parameter represented by the the output
+  raster, either "dir", "dir_anom", "eke", "mag", "mag_anom", "u",
+  "v", "u_anom", or "v_anom".
 
 * %%Y - four-digit year of the raster.
@@ -645 +732 @@
 
 CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'cls', OSCAR5DayThirdDegreeCurrents.CreateClimatologicalArcGISRasters, u'cls')
-CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'vectorComponent', OSCAR5DayThirdDegreeCurrents.CreateClimatologicalArcGISRasters, u'vectorComponent')
+CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'parameter', OSCAR5DayThirdDegreeCurrents.CreateClimatologicalArcGISRasters, u'parameter')
 
 AddArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateClimatologicalArcGISRasters, u'statistic',
@@ -741 +828 @@
 The default expression assumes you are storing rasters in a file
 system directory and creates them in a tree structure with levels for
-the vector component and climatology type. When storing rasters in a
-directory, the final expression specifies the file name of the raster
-and any preceding expressions specify subdirectories. The extension of
-the final expression determines the output raster format: .asc for
-ArcInfo ASCII Grid, .bmp for BMP, .gif for GIF, .img for an ERDAS
-IMAGINE file, .jpg for JPEG, .jp2 for JPEG 2000, .png for PNG, .tif
-for GeoTIFF, or no extension for ArcInfo Binary Grid. The default
+the geophysical parameter and climatology type. When storing rasters
+in a directory, the final expression specifies the file name of the
+raster and any preceding expressions specify subdirectories. The
+extension of the final expression determines the output raster format:
+.asc for ArcInfo ASCII Grid, .bmp for BMP, .gif for GIF, .img for an
+ERDAS IMAGINE file, .jpg for JPEG, .jp2 for JPEG 2000, .png for PNG,
+.tif for GeoTIFF, or no extension for ArcInfo Binary Grid. The default
 expression uses .img.
 
@@ -758 +845 @@
 codes with appropriate values when creating each raster:
 
-* %(VectorComponent)s - Vector component represented by the the output
-  raster, either "u", "v", "u_anom", or "v_anom".
+* %(Parameter)s - Geophysical parameter represented by the the output
+  raster, either "dir", "dir_anom", "eke", "mag", "mag_anom", "u",
+  "v", "u_anom", or "v_anom".
 
 * %(ClimatologyBinType)s - type of the climatology bin, either "Daily"
@@ -1018 +1106 @@
 
 CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'cls', OSCAR5DayThirdDegreeCurrents.InterpolateAtArcGISPoints, u'cls')
-CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'vectorComponent', OSCAR5DayThirdDegreeCurrents.InterpolateAtArcGISPoints, u'vectorComponent')
+CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'parameter', OSCAR5DayThirdDegreeCurrents.InterpolateAtArcGISPoints, u'parameter')
 
 AddArgumentMetadata(OSCAR5DayThirdDegreeCurrents.InterpolateAtArcGISPoints, u'points',

MGET/Branches/Jason/PythonPackage/src/GeoEco/DataProducts/OSU/MesoscaleEddies.py

@@ -172 +172 @@
                 progressReporter = ProgressReporter(progressMessage1=_(u'Still copying points: %(elapsed)s elapsed, %(opsCompleted)i points copied, %(perOp)s per point, %(opsRemaining)i remaining, estimated completion time: %(etc)s.'),
                                                     completionMessage=_(u'Finished copying points: %(elapsed)s elapsed, %(opsCompleted)i points copied, %(perOp)s per point.'),
-                                                    abortedMessage=_(u'Insert operation stopped before all points were copied: %(elapsed)s elapsed, %(opsCompleted)i points copied, %(perOp)s per point, %(opsIncomplete)i points not copied.'))
+                                                    abortedMessage=_(u'Insert operation stopped before all points were copied: %(elapsed)s elapsed, %(opsCompleted)i points copied, %(perOp)s per point, %(opsIncomplete)i points not copied.'),
+                                                    arcGISProgressorLabel=_(u'Copying %(count)i points') % {u'count': len(track)})
                 progressReporter.Start(len(track))
             else:
@@ -212 +213 @@
             # desired).
 
+            indexes = ['track', 'obsdate', 'lon', 'lat']
+
             if reportProgress:
-                self._LogInfo(_(u'Creating indexes.'))
+                self._LogInfo(_(u'Creating %(count)i indexes.') % {u'count': len(indexes)})
+                progressReporter = ProgressReporter(progressMessage1=_(u'Still creating indexes: %(elapsed)s elapsed, %(opsCompleted)i indexes created, %(perOp)s per index, %(opsRemaining)i remaining, estimated completion time: %(etc)s.'),
+                                                    completionMessage=_(u'Finished creating indexes: %(elapsed)s elapsed, %(opsCompleted)i indexes created, %(perOp)s per index.'),
+                                                    abortedMessage=_(u'Stopped before all indexes were created: %(elapsed)s elapsed, %(opsCompleted)i indexes created, %(perOp)s per index, %(opsIncomplete)i indexes not created.'),
+                                                    arcGISProgressorLabel=_(u'Creating %(count)i indexes') % {u'count': len(indexes)})
+                progressReporter.Start(len(indexes))
             else:
-                self._LogDebug(_(u'Creating indexes.'))
-
-            table.CreateIndex(['track'], 'idx_%s_track' % tableName)
-            table.CreateIndex(['obsdate'], 'idx_%s_obsdate' % tableName)
-            table.CreateIndex(['lon'], 'idx_%s_lon' % tableName)
-            table.CreateIndex(['lat'], 'idx_%s_lat' % tableName)
-
-            if reportProgress:
-                self._LogInfo(_(u'Indexes created.'))
-            else:
+                self._LogDebug(_(u'Creating %(count)i indexes.') % {u'count': len(indexes)})
+
+            for indexName in indexes:
+                table.CreateIndex([indexName], 'idx_%s_%s' % (tableName, indexName))
+                if reportProgress:
+                    progressReporter.ReportProgress()
+
+            if not reportProgress:
                 self._LogDebug(_(u'Indexes created.'))
 
@@ -335 +341 @@
     def ExtractArcGISPointsFromSpatiaLite(cls, spatiaLiteDB, outputFeatureClass, tableName=u'EddyPoints', where=None, overwriteExisting=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
+
         from GeoEco.Datasets.SpatiaLite import SpatiaLiteDatabase
         from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISTable
+
         db = SpatiaLiteDatabase(spatiaLiteDB)
         try:
+            if where is not None:
+                cls._LogInfo(_(u'Querying for eddy centroids that match the expression: %(where)s') % {u'where': where})
+                selectCursor = db.Connection.execute('SELECT COUNT(*) FROM %s WHERE %s;' % (tableName, where))
+            else:
+                selectCursor = db.Connection.execute('SELECT COUNT(*) FROM %s;' % tableName)
+            try:
+                pointCount = selectCursor.fetchone()[0]
+            finally:
+                selectCursor.close()
+            
             table = db.QueryDatasets("TableName = '%s'" % tableName, False)[0]
             workspace = ArcGISWorkspace(os.path.dirname(outputFeatureClass), ArcGISTable, pathCreationExpressions=['%(TableName)s'], queryableAttributes=(QueryableAttribute('TableName', 'Table name', UnicodeStringTypeMetadata()),))
-            workspace.ImportTable(os.path.basename(outputFeatureClass), table, where=where)
+            workspace.ImportTable(os.path.basename(outputFeatureClass), table, where=where, rowCount=pointCount)
         finally:
             db.Close()
@@ -371 +389 @@
         table.AddField('meanU', 'float32')
 
-        # Open an insert cursor on the output feature class.
-
-        insertCursor = table.OpenInsertCursor()
+        # Open a SQLite cursor on the SpatiaLite database. We use
+        # a SQLite cursor rather than our own SelectCursor
+        # interface because if the caller specified a where
+        # clause, we want to extract complete tracks (all points)
+        # for eddies that have any points (even just one) that
+        # satisfy that expression. To do that, we have to join the
+        # eddy points table to itself, which is not possible using
+        # our SelectCursor interface.
+
+        from GeoEco.Datasets.SpatiaLite import SpatiaLiteDatabase
+
+        db = SpatiaLiteDatabase(spatiaLiteDB)
         try:
-
-            # Open a SQLite cursor on the SpatiaLite database. We use
-            # a SQLite cursor rather than our own SelectCursor
-            # interface because if the caller specified a where
-            # clause, we want to extract complete tracks (all points)
-            # for eddies that have any points (even just one) that
-            # satisfy that expression. To do that, we have to join the
-            # eddy points table to itself, which is not possible using
-            # our SelectCursor interface.
-
-            from GeoEco.Datasets.SpatiaLite import SpatiaLiteDatabase
-
-            db = SpatiaLiteDatabase(spatiaLiteDB)
+            if where is None:
+                selectCursor = db.Connection.execute('SELECT COUNT(DISTINCT track) FROM %s;' % tableName)
+                try:
+                    trackCount = selectCursor.fetchone()[0]
+                finally:
+                    selectCursor.close()
+
+                selectCursor = db.Connection.execute('SELECT * FROM %s ORDER BY track ASC, n ASC;' % tableName)
+
+            else:
+                db.Connection.execute('CREATE TABLE temp.MatchingEddies AS SELECT DISTINCT track FROM %s WHERE %s;' % (tableName, where))
+
+                selectCursor = db.Connection.execute('SELECT COUNT(DISTINCT track) FROM temp.MatchingEddies;')
+                try:
+                    trackCount = selectCursor.fetchone()[0]
+                finally:
+                    selectCursor.close()
+
+                selectCursor = db.Connection.execute('SELECT t1.* FROM %s AS t1 INNER JOIN temp.MatchingEddies ON t1.track = temp.MatchingEddies.track ORDER BY t1.track ASC, t1.n ASC;' % (tableName,))
+
             try:
-                if where is None:
-                    selectCursor = db.Connection.execute('SELECT * FROM %s ORDER BY track ASC, n ASC;' % tableName)
-                else:
-                    db.Connection.execute('CREATE TABLE temp.MatchingEddies AS SELECT DISTINCT track FROM %s WHERE %s;' % (tableName, where))
-                    selectCursor = db.Connection.execute('SELECT t1.* FROM %s AS t1 INNER JOIN temp.MatchingEddies ON t1.track = temp.MatchingEddies.track ORDER BY t1.track ASC, t1.n ASC;' % (tableName,))
-
+                # Open an insert cursor on the output feature class.
+
+                cls._LogInfo(_(u'Inserting %(count)i lines into %(fc)s.') % {u'count': trackCount, u'fc': outputFeatureClass})
+
+                insertCursor = table.OpenInsertCursor(trackCount)
                 try:
                     ogr = cls._ogr()
@@ -496 +529 @@
                         point = selectCursor.fetchone()
                 finally:
-                    selectCursor.close()
-                    del selectCursor
+                    del insertCursor
             finally:
-                db.Close()
+                selectCursor.close()
+                del selectCursor
         finally:
-            del insertCursor
+            db.Close()
 
 
@@ -524 +557 @@
 **References**
 
-Chelton, D.B., M.G. Schlax, and R.M. Samelson (2011) Global
+Chelton, D.B., M.G. Schlax, and R.M. Samelson (2011). Global
 observations of nonlinear mesoscale eddies. Progress in Oceanography
 91: 167-216.""")
@@ -581 +614 @@
 about how these parameters were calculated.
 
-This tool typically requires 5 to 10 minutes to complete on a reasonably
-fast computer.""") + _CheltonMesocaleEddies_References,
+This tool typically requires 10-15 minutes to complete on a reasonably
+fast computer. The SpatiaLite database typically requires about 650 MB
+of disk space.""") + _CheltonMesocaleEddies_References,
     isExposedToPythonCallers=True,
     isExposedByCOM=True,
@@ -684 +718 @@
 
 Because the database includes over 200,000 eddies with nearly 2.5
-million total centroids, we recommend that you use the Where Clause
+million centroids in total, we recommend that you use the Where Clause
 parameter to limit the extraction to the eddies that occured in your
 region and time period of interest. If you do not specify the Where
@@ -821 +855 @@
 eddies that occured in your region and time period of interest. If you
 do not specify the Where Clause, all 200,000 tracks will be extracted,
-which can take quite a long time and produce an output feature class
-that requires several hundred megabytes of disk space.""") +
-_CheltonMesocaleEddies_References,
+which may take 30-45 minutes on a relatively fast computer and
+produce an output feature class that requires 50-100 MB of disk
+space.""") + _CheltonMesocaleEddies_References,
     isExposedToPythonCallers=True,
     isExposedByCOM=True,

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/Collections.py

@@ -632 +632 @@
                                                     completionMessage=_(u'Finished checking: %(elapsed)s elapsed, %(opsCompleted)i datasets checked, %(perOp)s per dataset.'),
                                                     abortedMessage=_(u'Processing stopped before all datasets were checked: %(elapsed)s elapsed, %(opsCompleted)i datasets checked, %(perOp)s per dataset, %(opsIncomplete)i datasets not checked.'),
-                                                    loggingChannel=DatasetCollection._LoggingChannel)
+                                                    loggingChannel=DatasetCollection._LoggingChannel,
+                                                    arcGISProgressorLabel=_(u'Checking for existing datasets'))
                 progressReporter.Start(len(datasets))
             else:
@@ -673 +674 @@
                                                 completionMessage=_(u'Import complete: %(elapsed)s elapsed, %(opsCompleted)i datasets imported, %(perOp)s per dataset.'),
                                                 abortedMessage=_(u'Import stopped before all datasets were imported: %(elapsed)s elapsed, %(opsCompleted)i datasets imported, %(perOp)s per dataset, %(opsIncomplete)i datasets not imported.'),
-                                                loggingChannel=DatasetCollection._LoggingChannel)
+                                                loggingChannel=DatasetCollection._LoggingChannel,
+                                                arcGISProgressorLabel=_(u'Importing %(count)i datasets') % {u'count': datasetsToAdd})
             progressReporter.Start(datasetsToAdd)
         else:

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/Virtual.py

@@ -1355 +1355 @@
 
 
+class DerivedGrid(Grid):
+    __doc__ = DynamicDocString()
+
+    def __init__(self, grids, expression, displayName, dataType, noDataValue=None, queryableAttributes=None, queryableAttributeValues=None):
+        # TODO: self.__class__.__doc__.Obj.ValidateMethodInvocation()
+
+        # Initialize our properties.
+
+        self._Grids = grids
+        self._Expression = expression
+        self._DisplayName = displayName
+        self._ValidatedGrids = False
+
+        # Initialize the base class.
+        
+        super(DerivedGrid, self).__init__(queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues)
+
+        # Set lazy properties that override those of the contained
+        # grids.
+
+        self.SetLazyPropertyValue('UnscaledDataType', dataType)
+        self.SetLazyPropertyValue('ScaledDataType', None)
+        self.SetLazyPropertyValue('UnscaledNoDataValue', noDataValue)
+        self.SetLazyPropertyValue('ScaledNoDataValue', None)
+        self.SetLazyPropertyValue('ScalingFunction', None)
+        self.SetLazyPropertyValue('UnscalingFunction', None)
+
+    def _Close(self):
+        if hasattr(self, '_Grids') and self._Grids is not None:
+            for grid in self._Grids:
+                grid.Close()
+        super(DerivedGrid, self)._Close()
+
+    def _GetDisplayName(self):
+        return self._DisplayName
+
+    def _GetLazyPropertyPhysicalValue(self, name):
+
+        # If the requested property is PhysicalDimensions or
+        # PhysicalDimensionsFlipped, return values indicating the
+        # dimensions in the ideal order. The contained grids take care
+        # of reordering, if needed.
+
+        if name == 'PhysicalDimensions':
+            return self.Dimensions
+
+        if name == 'PhysicalDimensionsFlipped':
+            return tuple([False] * len(self.Dimensions))
+
+        # Otherwise just get the unaltered value from the first
+        # contained grid.
+
+        return self._Grids[0].GetLazyPropertyValue(name)
+
+    @classmethod
+    def _TestCapability(cls, capability):
+        if capability == 'SetSpatialReference':
+            return NotImplementedError(_(u'DerivedGrid does not support setting the spatial reference.'))
+        return cls._Grids[0]._TestCapability(capability)
+
+    def _GetCoords(self, coord, coordNum, slices, sliceDims, fixedIncrementOffset):
+        return self._Grids[0]._GetCoords(coord, coordNum, slices, sliceDims, fixedIncrementOffset)
+
+    def _ReadNumpyArray(self, sliceList):
+
+        # If we have not yet validated the grids, do so now.
+
+        if not self._ValidatedGrids:
+            if len(self._Grids) > 1:
+                for grid in self._Grids[1:]:
+                    if grid.Shape != self._Grids[0].Shape:
+                        raise ValueError(_(u'%(dn1)s does not have the same shape as %(dn2)s.') % {u'dn1': grid.DisplayName, u'dn1': self._Grids[0].DisplayName})
+                    
+                    # TODO: More validation?
+
+            self._ValidatedGrids = True
+
+        # Evaluate the expression.
+
+        import numpy
+
+        data = eval(self._Expression)
+
+        # If a no data value was provided, mask any cells that have no
+        # data in any of the grids.
+
+        if self.NoDataValue is not None:
+            for grid in self._Grids:
+                if grid.NoDataValue is not None:
+                    data[grid.Data.__getitem__(tuple(sliceList)) == grid.NoDataValue] = self.NoDataValue
+
+        # Return the data and no data value.
+
+        return data, self.NoDataValue
+
+
 class RotatedGlobalGrid(Grid):
     __doc__ = DynamicDocString()
@@ -3302 +3398 @@
 
 ###############################################################################
+# Metadata: DerivedGrid class
+###############################################################################
+
+AddClassMetadata(DerivedGrid,
+    shortDescription=_(u'TODO: Add description.'))
+
+# TODO: Add metadata
+
+###############################################################################
 # Metadata: RotatedGlobalGrid class
 ###############################################################################
@@ -3487 +3592 @@
            'ClippedGrid',
            'MaskedGrid',
+           'DerivedGrid',
            'RotatedGlobalGrid',
            'MemoryCachedGrid',

MGET/Branches/Jason/PythonPackage/src/GeoEco/Datasets/__init__.py

@@ -2135 +2135 @@
 
         if reportProgress:
+            if rowCount is not None:
+                arcGISProgressorLabel = _(u'Retrieving %(rowCount)i %(plural)s') % {u'rowCount': rowCount, u'plural': self._RowDescriptionPlural}
+            else:
+                arcGISProgressorLabel = None
+
             self._ProgressReporter = ProgressReporter(progressMessage1=_(u'Still retrieving %(plural)s: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s retrieved, %%(perOp)s per %(singular)s, %%(opsRemaining)i remaining, estimated completion time: %%(etc)s.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
                                                       progressMessage2=_(u'Still retrieving %(plural)s: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s retrieved, %%(perOp)s per %(singular)s.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
                                                       completionMessage=_(u'Finished retrieving %(plural)s: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s retrieved, %%(perOp)s per %(singular)s.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
-                                                      abortedMessage=_(u'Query operation stopped before all %(plural)s were retrieved: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s retrieved, %%(perOp)s per %(singular)s, %%(opsIncomplete)i %(plural)s not retrieved.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural})
+                                                      abortedMessage=_(u'Query operation stopped before all %(plural)s were retrieved: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s retrieved, %%(perOp)s per %(singular)s, %%(opsIncomplete)i %(plural)s not retrieved.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
+                                                      arcGISProgressorLabel=arcGISProgressorLabel)
             self._ProgressReporter.Start(rowCount)
         else:
@@ -2362 +2368 @@
 
         if reportProgress:
-            self._ProgressReporter = _UpdateCursorProgressReporter(self._RowDescriptionSingular, self._RowDescriptionPlural)
+            if rowCount is not None:
+                arcGISProgressorLabel = _(u'Updating %(rowCount)i %(plural)s') % {u'rowCount': rowCount, u'plural': self._RowDescriptionPlural}
+            else:
+                arcGISProgressorLabel = None
+
+            self._ProgressReporter = _UpdateCursorProgressReporter(self._RowDescriptionSingular, self._RowDescriptionPlural, arcGISProgressorLabel)
             self._ProgressReporter.Start(rowCount)
 
@@ -2392 +2403 @@
 class _UpdateCursorProgressReporter(ProgressReporter):
 
-    def __init__(self, rowDescriptionSingular, rowDescriptionPlural):
+    def __init__(self, rowDescriptionSingular, rowDescriptionPlural, arcGISProgressorLabel):
         self.RowsUpdated = 0
         self.RowsDeleted = 0
@@ -2399 +2410 @@
             progressMessage2=_(u'Update in progress: %%(elapsed)s elapsed, %%(updated)i %(plural)s updated, %%(deleted)i deleted, %%(unchanged)i unchanged, %%(perOp)s per %(singular)s.') % {u'singular': rowDescriptionSingular, u'plural': rowDescriptionPlural},
             completionMessage=_(u'Update complete: %%(elapsed)s elapsed, %%(updated)i %(plural)s updated, %%(deleted)i deleted, %%(unchanged)i unchanged, %%(perOp)s per %(singular)s.') % {u'singular': rowDescriptionSingular, u'plural': rowDescriptionPlural},
-            abortedMessage=_(u'Update stopped before all %(plural)s were processed: %%(elapsed)s elapsed, %%(updated)i %(plural)s updated, %%(deleted)i deleted, %%(unchanged)i unchanged, %%(perOp)s per %(singular)s, %%(opsIncomplete)i %(plural)s not processed.') % {u'singular': rowDescriptionSingular, u'plural': rowDescriptionPlural})
+            abortedMessage=_(u'Update stopped before all %(plural)s were processed: %%(elapsed)s elapsed, %%(updated)i %(plural)s updated, %%(deleted)i deleted, %%(unchanged)i unchanged, %%(perOp)s per %(singular)s, %%(opsIncomplete)i %(plural)s not processed.') % {u'singular': rowDescriptionSingular, u'plural': rowDescriptionPlural},
+            arcGISProgressorLabel=arcGISProgressorLabel)
 
     def _FormatProgressMessage1(self, timeElapsed, opsCompleted, timePerOp, opsRemaining, estimatedTimeOfCompletionString):
@@ -2501 +2513 @@
 
         if reportProgress:
+            if rowCount is not None:
+                arcGISProgressorLabel = _(u'Inserting %(rowCount)i %(plural)s') % {u'rowCount': rowCount, u'plural': self._RowDescriptionPlural}
+            else:
+                arcGISProgressorLabel = None
+                
             self._ProgressReporter = ProgressReporter(progressMessage1=_(u'Still inserting %(plural)s: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s inserted, %%(perOp)s per %(singular)s, %%(opsRemaining)i remaining, estimated completion time: %%(etc)s.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
                                                       progressMessage2=_(u'Still inserting %(plural)s: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s inserted, %%(perOp)s per %(singular)s.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
                                                       completionMessage=_(u'Finished inserting %(plural)s: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s inserted, %%(perOp)s per %(singular)s.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
-                                                      abortedMessage=_(u'Insert operation stopped before all %(plural)s were inserted: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s inserted, %%(perOp)s per %(singular)s, %%(opsIncomplete)i %(plural)s not inserted.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural})
+                                                      abortedMessage=_(u'Insert operation stopped before all %(plural)s were inserted: %%(elapsed)s elapsed, %%(opsCompleted)i %(plural)s inserted, %%(perOp)s per %(singular)s, %%(opsIncomplete)i %(plural)s not inserted.') % {u'singular': self._RowDescriptionSingular, u'plural': self._RowDescriptionPlural},
+                                                      arcGISProgressorLabel=arcGISProgressorLabel)
             self._ProgressReporter.Start(rowCount)
         else:

MGET/Branches/Jason/PythonPackage/src/GeoEco/Logging.py

@@ -22 +22 @@
 import logging
 import logging.config       # Do not remove this statement, even though it seems redundant after importing the logging module above. Removing it will break something.
+import math
 import os
 import sys
@@ -441 +442 @@
                  completionMessage=_(u'Processing complete: %(elapsed)s elapsed, %(opsCompleted)i operations completed, %(perOp)s per operation.'),
                  abortedMessage=_(u'Processing stopped before all operations were completed: %(elapsed)s elapsed, %(opsCompleted)i operations completed, %(perOp)s per operation, %(opsIncomplete)i operations not completed.'),
-                 loggingChannel=u'GeoEco'):
+                 loggingChannel=u'GeoEco',
+                 arcGISProgressorLabel=None):
 
         self.ProgressMessage1 = progressMessage1
@@ -448 +450 @@
         self.AbortedMessage = abortedMessage
         self.LoggingChannel = loggingChannel
+        self._ArcGISProgressorLabel = arcGISProgressorLabel
         self._TotalOperations = None
         self._OperationsCompleted = 0
@@ -492 +495 @@
     AbortedMessage = property(_GetAbortedMessage, _SetAbortedMessage, doc=DynamicDocString())
 
+    def _GetArcGISProgressorLabel(self):
+        return self._ArcGISProgressorLabel
+    
+    ArcGISProgressorLabel = property(_GetArcGISProgressorLabel, None, doc=DynamicDocString())
+
+    def _UseArcGISProgressor(self):
+        from GeoEco.ArcGIS import GeoprocessorManager
+        return self._TotalOperations is not None and self.ArcGISProgressorLabel is not None and GeoprocessorManager.GetGeoprocessor() is not None and (GeoprocessorManager.GetArcGISMajorVersion() > 9 or GeoprocessorManager.GetArcGISMajorVersion() == 9 and GeoprocessorManager.GetArcGISMinorVersion() >= 3) and not GeoprocessorManager.GetGeoprocessorIsCOMObject()
+
     def _GetLoggingChannel(self):
         return self._LoggingChannel
@@ -506 +518 @@
     def _SetTotalOperations(self, value):
         assert value is None or (isinstance(value, types.IntType) and value >= 0), u'totalOperations must be a non-negative integer, or None'
+        
         self._TotalOperations = value
+
+        if self._UseArcGISProgressor():
+            from GeoEco.ArcGIS import GeoprocessorManager
+            gp = GeoprocessorManager.GetWrappedGeoprocessor()
+            if self.HasStarted:
+                try:
+                    gp.ResetProgressor()
+                except:
+                    pass
+            try:
+                gp.SetProgressor('step', self.ArcGISProgressorLabel, 0, 1000, 1)
+                if self.HasStarted:
+                    gp.SetProgressorPosition(min(1000, int(math.floor(float(self._OperationsCompleted) / float(self._TotalOperations) * 1000.))))
+            except:
+                pass
+        
         if self._TotalOperations is not None and self.HasStarted and self._OperationsCompleted >= self._TotalOperations:
             self.Stop()
@@ -616 +645 @@
             else:
                 self._ClockNextReportTime = clockNow + 60.0
+
+        if self._UseArcGISProgressor() and int(math.floor(float(self._OperationsCompleted) / float(self._TotalOperations) * 1000.)) > int(math.floor(float(self._OperationsCompleted - 1) / float(self._TotalOperations) * 1000.)):
+            from GeoEco.ArcGIS import GeoprocessorManager
+            gp = GeoprocessorManager.GetWrappedGeoprocessor()
+            try:
+                gp.SetProgressorPosition(min(1000, int(math.floor(float(self._OperationsCompleted) / float(self._TotalOperations) * 1000.))))
+            except:
+                pass
 
     def Stop(self):
@@ -633 +670 @@
         elif self._AbortedMessage is not None:
             self._Log(self._FormatAbortedMessage(timeElapsed, self._OperationsCompleted, timePerOp, self._TotalOperations - self._OperationsCompleted))
+
+        if self._UseArcGISProgressor():
+            from GeoEco.ArcGIS import GeoprocessorManager
+            gp = GeoprocessorManager.GetWrappedGeoprocessor()
+            try:
+                gp.ResetProgressor()
+            except:
+                pass
 
     def _Log(self, message):
@@ -1264 +1309 @@
     isExposedToPythonCallers=True)
 
+AddPropertyMetadata(ProgressReporter.ArcGISProgressorLabel,
+    typeMetadata=UnicodeStringTypeMetadata(canBeNone=True),
+    shortDescription=_(u'Label to use for the ArcGIS geoprocessor progressor.'),
+    longDescription=_(
+u"""Starting in ArcGIS 9.3, the geoprocessor allows scripts to control
+the geoprocessing progress bar. If this property is not None and Start
+is called with a total number of operations, the value of this
+property will be used as the progressor label (the text that appears
+above the progress bar) and the ProgressReporter instance will
+automatically call the geoprocessor's SetProgressorPosition method
+when ProgressReporter.ReportProgress is called.
+
+If this property is None or Start is called without a total number of
+operations, the ProgressReporter instance will not manipulate the
+geoprocessor's progress bar."""),
+    isExposedToPythonCallers=True)
+
 AddPropertyMetadata(ProgressReporter.TotalOperations,
     typeMetadata=IntegerTypeMetadata(canBeNone=True),
@@ -1348 +1410 @@
     description=ProgressReporter.LoggingChannel.__doc__.Obj.ShortDescription + u'\n\n' + ProgressReporter.LoggingChannel.__doc__.Obj.LongDescription)
 
+AddArgumentMetadata(ProgressReporter.__init__, u'arcGISProgressorLabel',
+    typeMetadata=ProgressReporter.ArcGISProgressorLabel.__doc__.Obj.Type,
+    description=ProgressReporter.ArcGISProgressorLabel.__doc__.Obj.ShortDescription + u'\n\n' + ProgressReporter.ArcGISProgressorLabel.__doc__.Obj.LongDescription)
+
 AddResultMetadata(ProgressReporter.__init__, u'progressReporter',
     typeMetadata=ClassInstanceTypeMetadata(cls=ProgressReporter),

MGET/Branches/Jason/PythonPackage/src/GeoEco/SpatialAnalysis/Interpolation.py

@@ -364 +364 @@
                 
                 gridCoordIncrements.append(list(grids[i].CoordIncrements))
-                if grids[i].Dimensions[0] == u't':
+                if grids[i].Dimensions[0] == u't' and grids[i].CoordIncrements[0] is not None:
                     if grids[i].TSemiRegularity is not None:
                         gridCoordIncrements[i][0] = None