Changeset 909

Timestamp:

02/15/12 13:42:42 (15 months ago)

Author:

jjr8

Message:

Continued work on MesoscaleEddies?.py

Location:

MGET/Branches/Jason/PythonPackage/src/GeoEco

Files:

• ArcGIS.py (modified) (1 diff)
• DataProducts/OSU/MesoscaleEddies.py (modified) (12 diffs)
• Datasets/ArcGIS.py (modified) (1 diff)

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

@@ -1442 +1442 @@
                 return value.strftime('%Y-%m-%d %H:%M:%S')
 
+        elif isinstance(value, datetime.date):
+            if geoprocessorIsCOMObject:
+                import pywintypes
+                return pywintypes.Time((value.year, value.month, value.day, 0, 0, 0, 0, 0, 0))
+            else:
+                return value.strftime('%Y-%m-%d 00:00:00')
+
         # When the geoprocessor is obtained through arcgisscripting.create(), it
         # expects integers rather than booleans.

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

@@ -24 +24 @@
 import sys
 
-from GeoEco.Datasets import Dataset, Table, Field, SelectCursor
+from GeoEco.Datasets import Dataset, QueryableAttribute, Table, Field, SelectCursor
 from GeoEco.DynamicDocString import DynamicDocString
 from GeoEco.Internationalization import _
@@ -107 +107 @@
         return self._SpatiaLiteTable.OpenSelectCursor(fields, where, orderBy, rowCount, reportProgress, rowDescriptionSingular, rowDescriptionPlural)
 
-##    def _CopyNetCDFToSpatiaLiteDB(self, dbPath, tableName=u'EddyPoints', displayName=None, reportProgress=True):
-##
-##        # Read all of the netCDF variables into memory.
-##
-##        values = {}
-##        ds = self._OpenNetCDF()
-##        try:
-##            for field in self.Fields:
-##                if field.Name == u'obsdate':
-##                    values['j1'] = ds.variables['j1'][:]
-##                elif field.Name != u'Geometry':
-##                    values[field.Name] = ds.variables[field.Name][:]
-##        finally:
-##            ds.close()
-##
-##        # Create the SpatiaLite in-memory database,
-##        
-##        from GeoEco.Datasets.SpatiaLite import SpatiaLiteDatabase
-##        db = SpatiaLiteDatabase(dbPath, displayName=displayName)
-##        try:
-##            # Create the SpatiaLite table.
-##
-##            table = db.CreateTable(tableName, u'Point', self.GetSpatialReference('Obj'))
-##            
-##            for field in self.Fields:
-##                if field.Name != u'Geometry':
-##                    table.AddField(field.Name, field.DataType, isNullable=True)
-##
-##            # Copy the rows of the netCDF into the table.
-##
-##            if reportProgress:
-##                self._LogInfo(_(u'Copying %(rowCount)i eddy points from %(dn1)s into %(dn2)s.') % {u'rowCount': len(values['track']), u'dn1': self.DisplayName, u'dn2': db.DisplayName})
-##            else:
-##                self._LogDebug(_(u'Copying %(rowCount)i eddy points from %(dn1)s into %(dn2)s.') % {u'rowCount': len(values['track']), u'dn1': self.DisplayName, u'dn2': db.DisplayName})
-##
-##            db.Connection.execute('BEGIN EXCLUSIVE TRANSACTION;')
-##            try:
-##                ogr = self._ogr()
-##                insertCursor = table.OpenInsertCursor(len(values['track']), reportProgress)
-##                try:
-##                    for i in range(len(values['track'])):
-##
-##                        # The longitude domain in the netCDF file
-##                        # is 260 E to 650 E. See
-##                        # http://cioss.coas.oregonstate.edu/eddies/domain.html
-##                        # for more information. Adjust these
-##                        # coordinates to a 0 to 360 range before
-##                        # setting the geometry.
-##                        
-##                        lon = float(values['lon'][i])
-##                        if lon >= 360.:
-##                            lon -= 360.
-##                        lat = float(values['lat'][i])
-##                        
-##                        geometry = ogr.Geometry(ogr.wkbPoint)
-##                        geometry.AddPoint_2D(lon, lat)
-##                        
-##                        insertCursor.SetGeometry(geometry)
-##
-##                        # Copy the values of the fields.
-##                        
-##                        for field in self.Fields:
-##                            if field.Name == u'obsdate':
-##                                insertCursor.SetValue(field.Name, datetime.datetime(1992, 1, 1) + datetime.timedelta(int(values['j1'][i]) - 2448623))    # Convert from Julian date integer to datetime instance
-##                            elif field.Name == u'lon':
-##                                insertCursor.SetValue(field.Name, lon)
-##                            elif field.Name != u'Geometry':
-##                                value = values[field.Name][i]
-##                                if value.dtype.kind == 'i':
-##                                    value = int(value)
-##                                else:
-##                                    value = float(value)
-##                                insertCursor.SetValue(field.Name, value)
-##                            
-##                        insertCursor.InsertRow()
-##
-##                finally:
-##                    del insertCursor
-##            except:
-##                db.Connection.execute('ROLLBACK;')
-##                raise
-##            else:
-##                db.Connection.execute('COMMIT;')
-##
-##            # Create indexes on obsdate, lon, and lat. These indexes
-##            # are highly selective and likely to be used by the
-##            # caller. It is true that the lon and lat columns are
-##            # redundant with the geometry, but we maintain them so
-##            # that users can include them in simple where clauses
-##            # rather than specifying OGC-compliant syntax that works
-##            # with the geometry column (which they are free to do, if
-##            # desired).
-##
-##            if reportProgress:
-##                self._LogInfo(_(u'Creating indexes.'))
-##
-##            table.CreateIndex(['obsdate'], 'idx_%s_obsdate' % tableName)
-##            table.CreateIndex(['lon'], 'idx_%s_lon' % tableName)
-##            table.CreateIndex(['lat'], 'idx_%s_lat' % tableName)
-##
-##            self._LogInfo(_(u'Copy complete.'))
-##
-##        except:
-##            db.Close()
-##            raise
-##
-##        # Return successfully.
-##
-##        return db, table
-
     def _CopyNetCDFToSpatiaLiteDB(self, dbPath, tableName=u'EddyPoints', displayName=None, reportProgress=True):
 
@@ -237 +127 @@
 
             lon = ds.variables['lon'][:]
-            lon[lon >= 360.] = lon - 360.
+            lon[lon >= 360.] = lon[lon >= 360.] - 360.
             lon = lon.tolist()
 
@@ -327 +217 @@
                 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)
@@ -441 +332 @@
         table._CopyNetCDFToSpatiaLiteDB(spatiaLiteDB, tableName)
 
-##        from GeoEco.Datasets.SpatiaLite import SpatiaLiteDatabase
-##        table = CheltonMesocaleEddyPoints(netCDF)
-##        db = SpatiaLiteDatabase(spatiaLiteDB)
-##        db.ImportTable(tableName, table)
+    @classmethod
+    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:
+            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)
+        finally:
+            db.Close()
+
+    @classmethod
+    def ExtractArcGISLinesFromSpatiaLite(cls, spatiaLiteDB, outputFeatureClass, tableName=u'EddyPoints', where=None, overwriteExisting=False):
+        cls.__doc__.Obj.ValidateMethodInvocation()
+
+        # Create the output feature class.
+
+        from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISTable
+
+        workspace = ArcGISWorkspace(os.path.dirname(outputFeatureClass), ArcGISTable, pathCreationExpressions=['%(TableName)s'], queryableAttributes=(QueryableAttribute('TableName', 'Table name', UnicodeStringTypeMetadata()),))
+        table = workspace.CreateTable(os.path.basename(outputFeatureClass), geometryType='MultiLineString', spatialReference=Dataset.ConvertSpatialReference('proj4', '+proj=latlong +ellps=WGS84 +datum=WGS84 +no_defs', 'obj'))
+
+        table.AddField('track', 'int32')
+        table.AddField('duration', 'int32')
+        table.AddField('startdate', 'datetime')
+        table.AddField('enddate', 'datetime')
+        table.AddField('cyc', 'int32')
+        table.AddField('minA', 'float32')
+        table.AddField('maxA', 'float32')
+        table.AddField('meanA', 'float32')
+        table.AddField('minL', 'float32')
+        table.AddField('maxL', 'float32')
+        table.AddField('meanL', 'float32')
+        table.AddField('minU', 'float32')
+        table.AddField('maxU', 'float32')
+        table.AddField('meanU', 'float32')
+
+        # Open an insert cursor on the output feature class.
+
+        insertCursor = table.OpenInsertCursor()
+        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)
+            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,))
+
+                try:
+                    ogr = cls._ogr()
+                    line = None
+                    point = selectCursor.fetchone()
+                    while True:
+
+                        # If we have no more points or this point is
+                        # the start of a new line, insert the current
+                        # line into the output feature class.
+                        
+                        if line is not None and (point is None or point['track'] != line['track']):
+                            insertCursor.SetGeometry(ogr.CreateGeometryFromWkt('MULTILINESTRING(%s)' % ', '.join(['(' + ', '.join(['%r %r' % (coords[0], coords[1]) for coords in part]) + ')' for part in line['geometry']])))
+                            insertCursor.SetValue('track', line['track'])
+                            insertCursor.SetValue('duration', line['duration'])
+                            insertCursor.SetValue('startdate', line['startdate'])
+                            insertCursor.SetValue('enddate', line['enddate'])
+                            insertCursor.SetValue('cyc', line['cyc'])
+                            insertCursor.SetValue('minA', min(line['A']))
+                            insertCursor.SetValue('maxA', max(line['A']))
+                            insertCursor.SetValue('meanA', float(sum(line['A'])) / len(line['A']))
+                            insertCursor.SetValue('minL', min(line['L']))
+                            insertCursor.SetValue('maxL', max(line['L']))
+                            insertCursor.SetValue('meanL', float(sum(line['L'])) / len(line['L']))
+                            insertCursor.SetValue('minU', min(line['U']))
+                            insertCursor.SetValue('maxU', max(line['U']))
+                            insertCursor.SetValue('meanU', float(sum(line['U'])) / len(line['U']))
+
+                            insertCursor.InsertRow()
+                            
+                            line = None
+
+                        # If we have no more points, break out of the
+                        # loop.
+
+                        if point is None:
+                            break
+
+                        # If this point is the start of a new line,
+                        # initialize a new entry in our dictionary of
+                        # line attributes.
+
+                        if line is None:
+                            line = {}
+                            line['geometry'] = [[]]
+                            line['track'] = point['track']
+                            line['startdate'] = point['obsdate']
+                            line['cyc'] = point['cyc']
+                            line['A'] = []
+                            line['L'] = []
+                            line['U'] = []                    
+
+                        # Update the dictionary of line attributes
+                        # with values from this point.
+                            
+                        line['duration'] = point['n'] - 1
+                        line['enddate'] = point['obsdate']
+                        line['A'].append(point['A'])
+                        line['L'].append(point['L'])
+                        line['U'].append(point['U'])
+
+                        # Add this point to the line geometry. If this
+                        # the first point of the line or this point
+                        # did not cause the line to wrap around from
+                        # 360 to 0 or 0 to 360 (which is indicated by
+                        # a longitudinal difference of more than 100
+                        # degrees), then just append this point to the
+                        # existing line part.
+
+                        if len(line['geometry'][-1]) <= 0 or abs(point['lon'] - line['geometry'][-1][-1][-2]) < 100:
+                            line['geometry'][-1].append([point['lon'], point['lat']])
+
+                        else:
+                            previousLat = line['geometry'][-1][-1][-1]
+                            previousLon = line['geometry'][-1][-1][-2]
+
+                            # Otherwise, if this point caused the line
+                            # to wrap from 360 around to 0, terminate
+                            # the current line part at 360 longitude,
+                            # then start another line part at 0
+                            # longitude.
+                                
+                            if point['lon'] < line['geometry'][-1][-1][-2]:
+                                latAt360 = previousLat + (point['lat'] - previousLat) * ((360. - previousLon) / (360. + point['lon'] - previousLon))
+                                line['geometry'][-1].append([360., latAt360])
+                                line['geometry'].append([[0., latAt360], [point['lon'], point['lat']]])
+
+                            # Otherwise, if this point caused the line
+                            # to wrap from 0 around to 360, terminate
+                            # the current line part at 0 longitude,
+                            # then start another line part at 360
+                            # longitude.
+
+                            else:
+                                latAt0 = previousLat + (point['lat'] - previousLat) * (previousLon / (previousLon - (point['lon'] - 360.)))
+                                line['geometry'][-1].append([0., latAt0])
+                                line['geometry'].append([[360., latAt0], [point['lon'], point['lat']]])
+
+                        # Fetch the next point.
+
+                        point = selectCursor.fetchone()
+                finally:
+                    selectCursor.close()
+                    del selectCursor
+            finally:
+                db.Close()
+        finally:
+            del insertCursor
 
 
@@ -462 +519 @@
 ###############################################################################
 
-_CheltonMesocaleEddies_LongDescription = _(
-u"""TODO: Long description of this %(name)s.""")
+_CheltonMesocaleEddies_References = _(
+u"""
+
+**References**
+
+Chelton, D.B., M.G. Schlax, and R.M. Samelson (2011) Global
+observations of nonlinear mesoscale eddies. Progress in Oceanography
+91: 167-216.""")
 
 AddClassMetadata(CheltonMesocaleEddyPoints,
     shortDescription=_(u'A Table of points produced from the Chelton el al. (2011) mesoscale eddies netCDF file.'),
-    longDescription=_CheltonMesocaleEddies_LongDescription % {u'name': 'class'})
+    longDescription=_CheltonMesocaleEddies_References.strip())
 
 # Constructor
@@ -473 +536 @@
 AddMethodMetadata(CheltonMesocaleEddyPoints.__init__,
     shortDescription=_(u'Constructs a new CheltonMesocaleEddyPoints instance.'),
-    longDescription=_CheltonMesocaleEddies_LongDescription % {u'name': 'class'},
+    longDescription=_CheltonMesocaleEddies_References.strip(),
     isExposedToPythonCallers=True,
     dependencies=[PythonAggregatedModuleDependency('numpy')])
@@ -504 +567 @@
 AddMethodMetadata(CheltonMesocaleEddyPoints.ConvertToSpatiaLite,
     shortDescription=_(u'Converts the Chelton et al. (2011) mesoscale eddy database netCDF file to a SpatiaLite database.'),
-    longDescription=_CheltonMesocaleEddies_LongDescription % {u'name': 'tool'},
+    longDescription=_(
+u"""The other MGET tools that work with the mesoscale eddy database
+require a SpatiaLite database as input. Use this tool to create that
+database prior to using the other tools. You can also work with the
+SpatiaLite database directly from tools or programs that are
+compatible with that format.
+
+Each record represents the centroid of an eddy, with attributes such
+as the eddy identification number, longitude, latitude, date,
+polarity, amplitude, radius scale, and average speed around the SSH
+contour at the radius scale. Please see Chelton et al. (2011) and
+`<http://cioss.coas.oregonstate.edu/eddies/>`_ for more information
+about how these parameters were calculated.
+
+This tool typically requires 5 to 10 minutes to complete on a reasonably
+fast computer.""") + _CheltonMesocaleEddies_References,
     isExposedToPythonCallers=True,
     isExposedByCOM=True,
@@ -553 +631 @@
 * obsdate (date) - date of the point.
 
-* cyc (integer) - -1 for cyclonic eddies and +1 for anticyclonic eddies.
+* cyc (integer) - polarity of the eddy: -1 for cyclonic eddies and +1
+  for anticyclonic eddies.
 
 * lon, lat (float) - longitude and latitude of the centroid of the
@@ -571 +650 @@
   the eddy.
 
+Please see Chelton et al. (2011) and
+`<http://cioss.coas.oregonstate.edu/eddies/>`_ for more information
+about how these parameters were calculated.
+
 A spatial index will be created on Geometry and non-spatial indexes
-will be created on obsdate, lon, and lat."""),
+will be created on track, obsdate, lon, and lat."""),
     direction=u'Output',
-    arcGISDisplayName=_(u'SpatiaLite database file'))
+    arcGISDisplayName=_(u'Output SpatiaLite database'))
 
 AddArgumentMetadata(CheltonMesocaleEddyPoints.ConvertToSpatiaLite, u'tableName',
@@ -580 +663 @@
     description=_(
 u"""Name of the table to create in the SpatiaLite database."""),
-    arcGISDisplayName=_(u'Table name'))
+    arcGISDisplayName=_(u'SpatiaLite table name'))
 
 AddArgumentMetadata(CheltonMesocaleEddyPoints.ConvertToSpatiaLite, u'overwriteExisting',
@@ -589 +672 @@
     initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')
 
+# Public method: CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite
+
+AddMethodMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite,
+    shortDescription=_(u'Extracts eddy centroid points from the Chelton et al. (2011) mesoscale eddy database in SpatiaLite format.'),
+    longDescription=_(
+u"""In order to use this tool, you must first download the mesoscale
+eddy database netCDF file (usually available at
+`<http://cioss.coas.oregonstate.edu/eddies/>`_) and convert it to a
+SpatiaLite database using the Convert Mesoscale Eddies NetCDF to
+SpatiaLite Database tool.
+
+Because the database includes over 200,000 eddies with nearly 2.5
+million total centroids, 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
+Clause, all of the centroids 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,
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Extract Mesoscale Eddy Centroids From SpatiaLite Database'),
+    arcGISToolCategory=_(u'Data Products\\Oregon State University CIOSS\\Mesoscale Eddies in Altimeter Observations of SSH'),
+    dependencies=[PythonAggregatedModuleDependency('numpy')])
+
+CopyArgumentMetadata(CheltonMesocaleEddyPoints.ConvertToSpatiaLite, u'cls', CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'cls')
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'spatiaLiteDB',
+    typeMetadata=FileTypeMetadata(mayBeCompressed=True, mustExist=True),
+    description=_(
+u"""Mesoscale eddies SpatiaLite database to read.
+
+This database is produced from the mesoscale eddy database netCDF file
+(usually available at `<http://cioss.coas.oregonstate.edu/eddies/>`_)
+by the Convert Mesoscale Eddies NetCDF to SpatiaLite Database
+tool."""),
+    arcGISDisplayName=_(u'Mesoscale eddies SpatiaLite database'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'outputFeatureClass',
+    typeMetadata=ArcGISFeatureClassTypeMetadata(mustBeDifferentThanArguments=[u'spatiaLiteDB'], deleteIfParameterIsTrue=u'overwriteExisting', createParentDirectories=True),
+    description=_(
+u"""Point feature class to create.
+
+Each point represents the centroid of an eddy. Longitudes of the
+points will range from 0 to 360. The points will have the following
+attributes; data types are indicated in parentheses following the
+field name.
+
+* track (integer) - eddy identification number.
+
+* n (integer) - point number along the eddy track. Starts with 1. Points
+  are separated by intervals of 7 days, so at point 2 the eddy is 7
+  days old, at point 3 it is 14 days old, and so on.
+
+* obsdate (date) - date of the point.
+
+* cyc (integer) - polarity of the eddy: -1 for cyclonic eddies and +1
+  for anticyclonic eddies.
+
+* lon, lat (float) - longitude and latitude of the centroid of the
+  eddy. The longitudes are converted from the range used in the netCDF
+  (260 E - 650 E) to 0 E - 360 E.
+
+* A (float) - eddy amplitude (cm) defined to be the magnitude of the
+  height difference between the extremum of SSH within the eddy and
+  the SSH around the contour defining the perimeter of the eddy.
+
+* L (float) - eddy radius scale (km) defined to be the radius of a
+  circle with area equal to that enclosed by the contour of SSH within
+  the eddy around which the circum-average speed is maximum.
+
+* U (float) - average speed (cm/sec) around the SSH contour that
+  defines the scale L, i.e., the maximum circum-average speed within
+  the eddy.
+
+Please see Chelton et al. (2011) and
+`<http://cioss.coas.oregonstate.edu/eddies/>`_ for more information
+about how these parameters were calculated.
+
+A spatial index will be created on the output feature class."""),
+    direction=u'Output',
+    arcGISDisplayName=_(u'Output feature class'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'tableName',
+    typeMetadata=UnicodeStringTypeMetadata(),
+    description=_(
+u"""Name of the table to read from the SpatiaLite database."""),
+    arcGISDisplayName=_(u'SpatiaLite table name'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'where',
+    typeMetadata=UnicodeStringTypeMetadata(canBeNone=True),
+    description=_(
+u"""SQL WHERE clause expression that specifies the subset of points to
+extract. If this parameter is not provided, all of the points will be
+extracted.
+
+The expression is evaluated by the SQLite database engine that
+SpatiaLite is built upon. Please see the `SQLite documentation
+<http://www.sqlite.org/lang_expr.html>`_ for more information about
+the syntax of this expression.
+
+The following expression shows how to specify a geographic bounding
+box and time window to extract centroids that occurred in a region of
+the north Atlantic in the first three months of 2000. Note that
+longitude ranges from 0 to 360::
+
+    lat >= 25 and lat <= 50 and lon >= 280 and lon <= 340 and obsdate >= '2000-01-01' and obsdate <= '2000-03-31'
+
+This example shows how to extract the centroids from the southern
+hemisphere that were at least 16 weeks old and that had anticyclonic
+polarity::
+
+    lat < 0 and n >= 17 and cyc = 1
+
+You may use SpatiaLite's SQL functions in this expression to perform
+spatial comparisons. Please see the `SpatiaLite documentation
+<http://www.gaia-gis.it/gaia-sins/spatialite-sql-3.0.0.html>`_ for
+more information."""),
+    arcGISDisplayName=_(u'Where clause'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'overwriteExisting',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If True, the output feature class will be overwritten, if it
+exists. If False, a ValueError will be raised if the output feature
+class exists."""),
+    initializeToArcGISGeoprocessorVariable=u'OverwriteOutput')
+
+# Public method: CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite
+
+AddMethodMetadata(CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite,
+    shortDescription=_(u'Extracts eddy tracklines from the Chelton et al. (2011) mesoscale eddy database in SpatiaLite format.'),
+    longDescription=_(
+u"""In order to use this tool, you must first download the mesoscale
+eddy database netCDF file (usually available at
+`<http://cioss.coas.oregonstate.edu/eddies/>`_) and convert it to a
+SpatiaLite database using the Convert Mesoscale Eddies NetCDF to
+SpatiaLite Database tool.
+
+Each line represents the track of an eddy and includes attributes such
+as the start date, end date, duration, polarity, and various summary
+statistics. The track is constructed by connecting the eddy centroid
+points present in the database.
+
+Because the database includes over 200,000 eddies, 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 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,
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Extract Mesoscale Eddy Tracklines From SpatiaLite Database'),
+    arcGISToolCategory=_(u'Data Products\\Oregon State University CIOSS\\Mesoscale Eddies in Altimeter Observations of SSH'),
+    dependencies=[PythonAggregatedModuleDependency('numpy')])
+
+CopyArgumentMetadata(CheltonMesocaleEddyPoints.ConvertToSpatiaLite, u'cls', CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite, u'cls')
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite, u'spatiaLiteDB',
+    typeMetadata=FileTypeMetadata(mayBeCompressed=True, mustExist=True),
+    description=_(
+u"""Mesoscale eddies SpatiaLite database to read.
+
+This database is produced from the mesoscale eddy database netCDF file
+(usually available at `<http://cioss.coas.oregonstate.edu/eddies/>`_)
+by the Convert Mesoscale Eddies NetCDF to SpatiaLite Database
+tool."""),
+    arcGISDisplayName=_(u'Mesoscale eddies SpatiaLite database'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite, u'outputFeatureClass',
+    typeMetadata=ArcGISFeatureClassTypeMetadata(mustBeDifferentThanArguments=[u'spatiaLiteDB'], deleteIfParameterIsTrue=u'overwriteExisting', createParentDirectories=True),
+    description=_(
+u"""Line feature class to create.
+
+Each line represents an eddy track. Longitude coordinates will range
+from 0 to 360. Tracks that cross the Prime Meridian will be split into
+multi-part lines.
+
+The lines will have the following attributes; data types are indicated
+in parentheses following the field name.
+
+* track (integer) - eddy identification number.
+
+* duration (integer) - duration of the eddy, in weeks.
+
+* startdate (date) - date the eddy was first observed.
+
+* enddate (date) - date the eddy was last observed.
+
+* cyc (integer) - polarity of the eddy: -1 for cyclonic eddies and +1
+  for anticyclonic eddies.
+
+* minA, maxA, meanA (float) - minimum, maximum, and mean per-centroid
+  eddy amplitude (cm), defined to be the magnitude of the height
+  difference between the extremum of SSH within the eddy and the SSH
+  around the contour defining the perimeter of the eddy. These
+  statistics are calculated from the A parameter of the eddy centroids
+  that make up the track.
+
+* minL, maxL, meanL (float) - minimum, maximum, and mean per-centroid
+  eddy radius scale (km), defined to be the radius of a circle with
+  area equal to that enclosed by the contour of SSH within the eddy
+  around which the circum-average speed is maximum. These statistics
+  are calculated from the L parameter of the eddy centroids that make
+  up the track.
+
+* minU, maxU, meanU (float) - minimum, maximum, and mean per-centroid
+  average speed (cm/sec) around the SSH contour that defines the scale
+  L, i.e., the maximum circum-average speed within the eddy. These
+  statistics are calculated from the U parameter of the eddy centroids
+  that make up the track.
+
+Please see Chelton et al. (2011) and
+`<http://cioss.coas.oregonstate.edu/eddies/>`_ for more information
+about how these parameters were calculated.
+
+A spatial index will be created on the output feature class."""),
+    direction=u'Output',
+    arcGISDisplayName=_(u'Output feature class'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite, u'tableName',
+    typeMetadata=UnicodeStringTypeMetadata(),
+    description=_(
+u"""Name of the table to read from the SpatiaLite database."""),
+    arcGISDisplayName=_(u'SpatiaLite table name'))
+
+AddArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite, u'where',
+    typeMetadata=UnicodeStringTypeMetadata(canBeNone=True),
+    description=_(
+u"""SQL WHERE clause expression that specifies the eddy centroids that
+identify the eddy tracks to extract. If this parameter is not
+provided, all of the tracks will be extracted.
+
+The expression should reference the attributes of the centroids, not
+the tracks. Please see the documentation for the Convert Mesoscale
+Eddies NetCDF to SpatiaLite Database tool for a description of the
+centroid attributes.
+
+If this expression does not select all of the centroids that make up a
+track, the entire track will be extracted anyway. For example, if the
+expression specifies a geographic bounding box, complete tracks will
+be extracted for all eddies that had at least one centroid occur
+within the box.
+
+The expression is evaluated by the SQLite database engine that
+SpatiaLite is built upon. Please see the `SQLite documentation
+<http://www.sqlite.org/lang_expr.html>`_ for more information about
+the syntax of this expression.
+
+The following expression shows how to specify a geographic bounding
+box and time window to extract tracks that had at least one centroid
+occur in a region of the north Atlantic in the first three months of
+2000. Note that longitude ranges from 0 to 360::
+
+    lat >= 25 and lat <= 50 and lon >= 280 and lon <= 340 and obsdate >= '2000-01-01' and obsdate <= '2000-03-31'
+
+This example shows how to extract the tracks that had at least one
+centroid in the southern hemisphere, that had a duration of at least
+16 weeks, and that had anticyclonic polarity::
+
+    lat < 0 and n >= 17 and cyc = 1
+
+You may use SpatiaLite's SQL functions in this expression to perform
+spatial comparisons. Please see the `SpatiaLite documentation
+<http://www.gaia-gis.it/gaia-sins/spatialite-sql-3.0.0.html>`_ for
+more information."""),
+    arcGISDisplayName=_(u'Where clause'))
+
+CopyArgumentMetadata(CheltonMesocaleEddyPoints.ExtractArcGISPointsFromSpatiaLite, u'overwriteExisting', CheltonMesocaleEddyPoints.ExtractArcGISLinesFromSpatiaLite, u'overwriteExisting')
+
 ###############################################################################
 # Names exported by this module

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

@@ -445 +445 @@
             if capList[1] in ['point', 'point25d', 'linestring', 'linestring25d', 'polygon', 'polygon25d', 'multipoint', 'multipoint25d', 'multilinestring', 'multilinestring25d', 'multipolygon', 'multipolygon25d']:
                 return None
-            return RuntimeError(_(u'Cannot create table %(table)s with "%(geom)s" geometry in %(dn)s. ArcGIS does not support that geometry type.') % {u'tableName': capList[2], u'geom': capList[1], u'dn': cls._DisplayName})
+            return RuntimeError(_(u'Cannot create table %(table)s with "%(geom)s" geometry. ArcGIS does not support that geometry type.') % {u'table': capList[2], u'geom': capList[1]})
         
         if isinstance(cls, ArcGISWorkspace):