Changeset 773

Timestamp:

03/19/11 19:02:59 (2 years ago)

Author:

jjr8

Message:

Started work on AvisoGriddedGeostrophicCurrents?.CreateVectorsAsArcGISFeatureClasses()

Location:

MGET/Branches/Jason/PythonPackage/src/GeoEco

Files:

• DataProducts/Aviso.py (modified) (6 diffs)
• Datasets/ArcGIS.py (modified) (3 diffs)
• SpatialAnalysis/Lines.py (modified) (4 diffs)

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

@@ -495 +495 @@
 
     @classmethod
+    def CreateVectorsAsArcGISFeatureClasses(cls, username, password, productName,
+                                            outputWorkspace, mode=u'add', featureClassNameExpressions=['%(Region)s', '%(DataSeries)s', '%(Satellites)s', '%(Variable)s_uv_vectors', '%%Y', '%(DataSeries)s_%(Satellites)s_uv_vectors_%%Y%%j.shp'],
+                                            rotationOffset=None, spatialExtent=None, linearUnit=u'Degrees', startDate=None, endDate=None,
+                                            timeout=60, maxRetryTime=120, cacheDirectory=None):
+        cls.__doc__.Obj.ValidateMethodInvocation()
+        grid = AvisoGriddedGeostrophicCurrents(productName, vectorComponent, 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,
                                    points, valueField, tField, method=u'Nearest', where=None, noDataValue=None,
@@ -903 +913 @@
     typeMetadata=FloatTypeMetadata(canBeNone=True),
     description=_(
-u"""Distance to rotate the output rasters about the polar axis, in the
-units specified by the Linear Units parameter. If not provided, the
-output rasters will be centered on the 180th meridian (the Pacific
-ocean).
-
-Use this parameter to shift the center longitude of the rasters to a
+u"""Distance to rotate the outputs about the polar axis, in the units
+specified by the Linear Units parameter. If not provided, the outputs
+will be centered on the 180th meridian (the Pacific ocean).
+
+Use this parameter to shift the center longitude of the outputs to a
 different location. Positive values shift it to the east, negative
-values to the west. For example, to center the output rasters on the
-Prime Meridian, provide -180 for this parameter and set the Linear
-Units parameter to Degrees. 
-
-The rasters can only be rotated in whole grid cells. The value you
-provide will be rounded off to the closest cell."""),
-    arcGISDisplayName=_(u'Rotate raster by'),
+values to the west. For example, to center the outputs on the Prime
+Meridian, provide -180 for this parameter and set the Linear Units
+parameter to Degrees.
+
+The outputs can only be rotated in whole cells of the Aviso grids. The
+value you provide will be rounded off to the closest cell."""),
+    arcGISDisplayName=_(u'Rotate by'),
     arcGISCategory=_(u'Spatiotemporal extent'))
 
@@ -922 +931 @@
     typeMetadata=EnvelopeTypeMetadata(canBeNone=True),
     description=_(
-u"""Spatial extent of the output rasters, in the units specified by
-the Linear Units parameter.
+u"""Spatial extent of the outputs, in the units specified by the
+Linear Units parameter.
 
 This parameter is applied after the rotation parameter and uses
 coordinates that result after rotation. 
 
-The rasters can only be clipped in whole grid cells. The values you
+The outputs can only be clipped in whole grid cells. The values you
 provide will be rounded off to the closest cell."""),
     arcGISDisplayName=_(u'Spatial extent'),
@@ -950 +959 @@
     typeMetadata=DateTimeTypeMetadata(canBeNone=True),
     description=_(
-u"""Start date for the rasters to create.
-
-Rasters will be created for images that occur on or after the start
+u"""Start date for the outputs to create.
+
+Outputs will be created for images that occur on or after the start
 date and on or before the end date. If you do not provide a start
 date, the date of the first available image will be used. For Delayed
@@ -966 +975 @@
     typeMetadata=DateTimeTypeMetadata(canBeNone=True),
     description=_(
-u"""End date for the rasters to create.
-
-Rasters will be created for images that occur on or after the start
+u"""End date for the outputs to create.
+
+Outputs will be created for images that occur on or after the start
 date and on or before the end date. If you do not specify an end date,
 the date of the most recent image will be used. For Delayed Time (DT)
@@ -1841 +1850 @@
 CopyResultMetadata(AvisoGriddedSSH.CreateClimatologicalArcGISRasters, u'updatedOutputWorkspace', AvisoGriddedGeostrophicCurrents.CreateClimatologicalArcGISRasters, u'updatedOutputWorkspace')
 
+# Public method: AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses
+
+AddMethodMetadata(AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses,
+    shortDescription=_(u'Creates line feature classes representing the current vectors of an Aviso gridded geostrophic currents product.'),
+    longDescription=_(
+u"""The lines output by this tool are similar to those in a "quiver
+plot". When displayed on a map, they can help visualize the direction
+and velocity of ocean currents. In ArcMap, select the "Arrow at End"
+symbology. You may also want to reduce the line decoration (the arrow)
+to a small size, such as 2.0.
+
+""") + _AvisoGriddedProduct_LongDescription % {u'name': 'tool'},
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Create Vectors for Aviso Geostrophic Currents Product'),
+    arcGISToolCategory=_(u'Data Products\\Aviso\\Geostrophic Currents Products'),
+    dependencies=[ArcGISDependency(9, 1), PythonAggregatedModuleDependency('numpy')])
+
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'cls', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'cls')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'username', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'username')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'password', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'password')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.__init__, u'productName', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'productName')
+
+AddArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'outputWorkspace',
+    typeMetadata=ArcGISWorkspaceTypeMetadata(createParentDirectories=True),
+    description=_(
+u"""Directory or geodatabase to receive the feature classes.
+
+Unless you have a specific reason to store the feature classes in a
+geodatabase, we recommend you store them in a directory because it
+will be faster and allows them to be organized as a tree (of
+shapefiles). If you do store the feature classes in a geodatabase, you
+must change the Feature Class Name Expressions parameter; see below
+for more information."""),
+    arcGISDisplayName=_(u'Output workspace'))
+
+AddArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'mode',
+    typeMetadata=UnicodeStringTypeMetadata(allowedValues=[u'Add', u'Replace'], makeLowercase=True),
+    description=_(
+u"""Overwrite mode, one of:
+
+* Add - create feature classes that do not exist and skip those that
+  already exist. This is the default.
+
+* Replace - create feature classes that do not exist and overwrite
+  those that already exist.
+
+The ArcGIS Overwrite Outputs geoprocessing setting has no effect on
+this tool. If 'Replace' is selected the feature classes will be
+overwritten, regardless of the ArcGIS Overwrite Outputs setting."""),
+    arcGISDisplayName=_(u'Overwrite mode'))
+
+AddArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'featureClassNameExpressions',
+    typeMetadata=ListTypeMetadata(elementType=UnicodeStringTypeMetadata(), minLength=1),
+    description=_(
+u"""List of expressions specifying how the output feature classes
+should be named.
+
+The default expression assumes the output workspace is a directory and
+creates shapefiles in a tree structure with levels for the region,
+data series, satellite, variable, and year.
+
+If the output workspace is a geodatabase, you should provide only one
+or two expressions. If you provide one expression, it specifies the
+feature class name. If you provide two, the first one specifies the
+feature dataset name and the second specifies the feature class name.
+
+Each expression may contain any sequence of characters permitted by
+the output workspace. Each expression may optionally contain one or
+more of the following case-sensitive codes. The tool replaces the
+codes with appropriate values when creating each feature class:
+
+* %(Region)s - Region of the output feature class, either "global",
+  "medsea", or "blacksea".
+
+* %(DataSeries)s - Aviso data series of the output feature class,
+  either "dt_ref", "dt_upd", or "nrt".
+
+* %(Satellites)s - Satellites used to produce the feature class. At
+  this time, only one such value exists, "merged", which means that
+  multiple satellites were used. Please see the Aviso documentation
+  for more information on how Aviso products are created.
+
+* %(Variable)s - Aviso variable represented in the output feature
+  class, either "madt_uv_vectors" for Mean Absolute Dynamic Topography
+  (MADT) vectors or "msla_uv_vectors" for Mean Sea Level Anomaly
+  (MSLA) vectors.
+
+* %%Y - four-digit year of the output feature class.
+
+* %%m - two-digit month of the output feature class.
+
+* %%d - two-digit day of the month of the output feature class.
+
+* %%j - three-digit day of the year of the output feature class.
+"""),
+    arcGISDisplayName=_(u'Feature class name expressions'))
+
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'rotationOffset', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'rotationOffset')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'spatialExtent', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'spatialExtent')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'linearUnit', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'linearUnit')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'startDate', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'startDate')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'endDate', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'endDate')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'timeout', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'timeout')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'maxRetryTime', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'maxRetryTime')
+CopyArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'cacheDirectory', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'cacheDirectory')
+
+CopyResultMetadata(AvisoGriddedGeostrophicCurrents.CreateArcGISRasters, u'updatedOutputWorkspace', AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'updatedOutputWorkspace')
+
 # Public method: AvisoGriddedGeostrophicCurrents.InterpolateAtArcGISPoints
 

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

@@ -595 +595 @@
     def _ImportDatasetsToPath(self, pathComponents, sourceDatasets, mode, progressReporter, options):
         self.DatasetType._ImportDatasetsToPath(os.path.join(self.Path, *pathComponents), sourceDatasets, mode, progressReporter, options)
-
+    
 
 class ArcGISRaster(DatasetCollection):
@@ -1515 +1515 @@
 
         raise ValueError(_(u'Cannot open "%(path)s" as an ArcGIS raster band, raster dataset, or raster layer. ArcGIS reports that it is a "%(dataType)".') % {u'path': path, u'dataType': d.DataType})
+
+
+class ArcGISCopyableTable(object):
+    __doc__ = DynamicDocString()
+
+    def GetArcGISCopyablePath(self):
+        raise NotImplementedError(_(u'The GetArcGISCopyablePath method of class %s has not been implemented.') % self.__class__.__name__)
 
 
@@ -1822 +1829 @@
     def _OpenInsertCursor(self, rowCount, reportProgress, rowDescriptionSingular, rowDescriptionPlural):
         return ArcGISInsertCursor(self, rowCount, reportProgress, rowDescriptionSingular, rowDescriptionPlural)
+
+    @classmethod
+    def _ImportDatasetsToPath(cls, path, sourceDatasets, mode, progressReporter, options):
+
+        # Validate that there is only one source dataset. We do not
+        # currently support importing multiple source datasets into a
+        # single destination dataset. (This could theoretically be
+        # supported in the future by appending multiple datasets into
+        # the same destination.)
+
+        if len(sourceDatasets) > 1:
+            raise ValueError(_(u'Cannot import %(count)i datasets into ArcGIS table or feature class "%(path)s". Importing of multiple datasets into a single table or feature class is not currently supported. If you are receiving this error from a tool that has a parameter that is a list of expressions that define the output dataset namen, you may have made a mistake in your expressions that caused the same output dataset name to be generated for multiple input datasets. If that is the problem, you can fix it by modifying the expressions to generate a unique output dataset name for each input dataset.') % {u'count': len(sourceDatasets), u'path': path})
+
+        # Validate that the source dataset is importable.
+        #
+        # TODO: Implement support for Table instances that are not
+        # ArcGISCopyableTable instances. (That is a lot of work
+        # because we have to create the destination table and its
+        # fields and then copy each row one at a time.)
+        
+        if not isinstance(sourceDatasets[0], ArcGISCopyableTable):
+            raise TypeError(_(u'Cannot import %(dn)s into ArcGIS table or feature class "%(path)s" because it is a %(type)s, which is not an ArcGISCopyableTable. At this time, only ArcGISCopyableTable can be imported.') % {u'dn': sourceDatasets[0].DisplayName, u'path': path, u'type': dataset.__class__.__name__})
+
+        # If the mode is 'replace' and the destination dataset exists,
+        # delete it.
+
+        gp = GeoprocessorManager.GetWrappedGeoprocessor()
+
+        if mode == u'replace' and gp.Exists(path):
+            cls._LogDebug(_(u'%(class)s: Deleting existing ArcGIS dataset "%(path)s".'), {u'class': cls.__name__, u'path': path})
+            try:
+                gp.Delete_management(path)
+            except Exception, e:
+                raise RuntimeError(_(u'Failed to delete the existing ArcGIS dataset "%(path)s" due to %(e)s: %(msg)s') % {u'path': path, u'e': e.__class__.__name__, u'msg': cls._Unicode(e)})
+
+        # Otherwise, make sure all the parent levels in the
+        # destination path exist (directories, geodatabase, feature
+        # dataset), creating them if necessary. Use ArcGIS tools such
+        # as CreateFolder_management to create them, so the ArcGIS
+        # catalog is aware of them.
+
+        elif not gp.Exists(os.path.dirname(path)):
+
+            # If the destination path is in the file system, figure
+            # out whether it contains levels for a geodatabase and a
+            # feature dataset. If neither, it must be a shapefile, DBF
+            # table, or something similar.
+
+            if path[0] in ['/', '\\'] or hasattr(os.path, 'splitdrive') and os.path.splitdrive(path)[0] != '' or hasattr(os.path, 'splitunc') and os.path.splitunc(path)[0] != '':
+                if os.path.splitext(os.path.dirname(path))[1].lower() in ['.mdb', '.gdb']:
+                    featureDataset = None
+                    geodatabase = os.path.dirname(path)
+                    directory = os.path.dirname(geodatabase)
+                elif os.path.splitext(os.path.dirname(os.path.dirname(path)))[1].lower() in ['.mdb', '.gdb']:
+                    featureDataset = os.path.dirname(path)
+                    geodatabase = os.path.dirname(featureDataset)
+                    directory = os.path.dirname(geodatabase)
+                else:
+                    featureDataset = None
+                    geodatabase = None
+                    directory = os.path.dirname(path)
+
+                # Create the directory if it does not exist.
+
+                if not os.path.exists(directory):
+                    cls._LogDebug(_(u'%(class)s: Creating directory "%(path)s".'), {u'class': cls.__name__, u'path': directory})
+
+                    if hasattr(os.path, 'splitdrive') and os.path.splitdrive(directory)[0] != '':
+                        root, subdirs = os.path.splitdrive(directory)
+                        root = root + '\\'
+                    elif hasattr(os.path, 'splitunc') and os.path.splitunc(directory)[0] != '':
+                        root, subdirs = os.path.splitunc(directory)
+                    else:
+                        root, subdirs = directory[0], directory[1:]
+
+                    subdirsList = []
+                    while len(subdirs) > 1:
+                        subdirsList.insert(0, os.path.basename(subdirs))
+                        subdirs = os.path.dirname(subdirs)
+
+                    dirToCheck = root
+                    for subdir in subdirsList:
+                        if not os.path.isdir(os.path.join(dirToCheck, subdir)):
+                            try:
+                                gp.CreateFolder_management(dirToCheck, subdir)
+                            except Exception, e:
+                                raise RuntimeError(_(u'Failed to create the directory "%(path)s" due to %(e)s: %(msg)s') % {u'path': os.path.join(dirToCheck, subdir), u'e': e.__class__.__name__, u'msg': cls._Unicode(e)})
+                        dirToCheck = os.path.join(dirToCheck, subdir)
+
+                # If the path includes a geodatabase and it does not
+                # exist, create it.
+
+                if geodatabase is not None and not gp.Exists(geodatabase):
+                    if os.path.splitext(geodatabase).lower() == '.mdb':
+                        gp.CreatePersonalGDB_management(directory, os.path.basename(geodatabase))
+                    else:
+                        gp.CreateFileGDB_management(directory, os.path.basename(geodatabase))
+
+                # If the path includes a feature dataset and it does not
+                # exist, create it.
+
+                if featureDataset is not None and not gp.Exists(featureDataset):
+                    gp.CreateFeatureDataset_management(geodatabase, os.path.basename(featureDataset))
+                    
+            # TODO: Otherwise (the desination path is not in the file
+            # system), make sure the destination exists and create the
+            # feature dataset. I'm not willing to code this without
+            # having an ArcSDE geodatabase to test it with.
+
+            else:
+                raise NotImplementedError(_(u'Cannot import %(dn)s into destination ArcGIS table or feature class "%(path)s" because that destination is not a folder, personal geodatabase, or file geodatabase. Other destinations (e.g. ArcSDE geodatabases) are not fully supported. Please contact the author of this tool for assistance.') % {u'dn': sourceDatasets[0].DisplayName, u'path': path})
+
+        # Import the dataset.
+
+        if isinstance(sourceDatasets[0], ArcGISCopyableTable):
+            arcGISCopyablePath = sourceDatasets[0].GetArcGISCopyablePath()
+            try:
+                cls._LogDebug(_(u'%(class)s: Copying "%(src)s" to ArcGIS dataset "%(path)s".'), {u'class': cls.__name__, u'src': arcGISCopyablePath, u'path': path})
+                gp.Copy_management(arcGISCopyablePath, path)
+            finally:
+                sourceDatasets[0].Close()       # This will make sure it deletes temporary files, if it had to create any in order to make itself ArcGIS-copyable.
+            
+            if progressReporter is not None:
+                progressReporter.ReportProgress()
+
+        else:
+            raise TypeError(_(u'Cannot import %(dn)s into ArcGIS table or feature class "%(path)s" because it is a %(type)s, which is not an ArcGISCopyableTable. At this time, only ArcGISCopyableTable can be imported.') % {u'dn': sourceDatasets[0].DisplayName, u'path': path, u'type': dataset.__class__.__name__})
 
 

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

@@ -21 +21 @@
 
 from GeoEco.ArcGIS import GeoprocessorManager, ArcGISDependency
+from GeoEco.Datasets import Table
+from GeoEco.Datasets.ArcGIS import ArcGISCopyableTable
 from GeoEco.DynamicDocString import DynamicDocString
 from GeoEco.Internationalization import _
@@ -185 +187 @@
 
 
+class ShapefileFromVectorComponentGrids(Table, ArcGISCopyableTable):
+    __doc__ = DynamicDocString()
+
+    def __init__(self, xGrid, yGrid, scaleFactor, parentCollection=None, queryableAttributes=None, queryableAttributeValues=None):
+
+        # Initialize our properties.
+
+        self._XGrid = xGrid
+        self._YGrid = yGrid
+        self._ScaleFactor = scaleFactor
+        self._TempDir = None
+        self._DisplayName = _(u'vectors for x components = %(dnx)s, y components = %(dny)s') % {u'dnx': xGrid, u'dny': yGrid}
+
+        # Initialize the base class.
+        
+        super(ShapefileFromVectorComponentGrids, self).__init__(parentCollection=parentCollection, queryableAttributes=None, queryableAttributeValues=queryableAttributeValues)
+
+    def _GetDisplayName(self):
+        return self._DisplayName
+
+    def _GetLazyPropertyPhysicalValue(self, name):
+        return None
+
+    def _Close(self):
+        self._TempDir = None
+        super(ShapefileFromVectorComponentGrids, self)._Close()
+
+    @classmethod
+    def _TestCapability(cls, capability):
+        if isinstance(cls, ShapefileFromVectorComponentGrids):
+            return RuntimeError(_(u'The %(cls)s class does not support the "%(cap)s" capability.') % {u'cls': cls.__class__.__name__, u'cap': capability})
+        return RuntimeError(_(u'The %(cls)s class does not support the "%(cap)s" capability.') % {u'cls': cls.__name__, u'cap': capability})
+
+    def GetArcGISCopyablePath():
+
+        # If we have not created the shapefile in a temporary
+        # directory, do it now. If we catch an exception, call
+        # _Close() to delete the temporary directory.
+
+        if self._TempDir is None:
+            try:
+                self._TempDir = self._CreateTempDirectory()
+                Lines.ShapefileFromVectorComponentGrids(self._XGrid, self._YGrid, os.path.join(self._TempDir, 'Vectors.shp'), self._ScaleFactor)
+            except:
+                self._Close()
+                raise
+
+        # Return the path to the shapefile in the temporary directory.
+
+        return os.path.join(self._TempDir, 'Vectors.shp')
+
+
 ###############################################################################
 # Metadata: module
@@ -500 +554 @@
 
 CopyArgumentMetadata(ArcGISLines.FromVectorComponentRasters, u'overwriteExisting', ArcGISLines.ConnectSequentialPoints, u'overwriteExisting')
+
+###############################################################################
+# Metadata: ShapefileFromVectorComponentGrids class
+###############################################################################
+
+AddClassMetadata(ShapefileFromVectorComponentGrids,
+    shortDescription=_(u'An ArcGIS-copyable Table representing the vectors of x and y component rasters, similar to a "quiver plot".'))
+
+# TODO: Add metadata.
 
 ###############################################################################
@@ -561 +624 @@
 ###############################################################################
 
-__all__ = ['Lines', 'ArcGISLines']
+__all__ = ['Lines', 'ArcGISLines', 'ShapefileFromVectorComponentGrids']