Changeset 906

Timestamp:

02/04/12 21:41:25 (16 months ago)

Author:

jjr8

Message:

* Added uniformLength parameter to Create Vectors tools.
* Added Create Vectors tools for HYCOM.

Location:

MGET/Branches/Jason/PythonPackage/src/GeoEco

Files:

• DataProducts/Aviso.py (modified) (4 diffs)
• DataProducts/HYCOM.py (modified) (13 diffs)
• DataProducts/NOAA/OSCAR.py (modified) (3 diffs)
• SpatialAnalysis/Lines.py (modified) (12 diffs)

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

@@ -540 +540 @@
     def CreateVectorsAsArcGISFeatureClasses(cls, username, password, productName, temporalResolution,
                                             outputWorkspace, mode=u'add', featureClassNameExpressions=['%(Region)s', '%(DataSeries)s', '%(Satellites)s', '%(TemporalResolution)s', '%(Variable)s_uv_vectors', '%%Y', '%(DataSeries)s_%(Satellites)s_uv_vectors_%%Y%%j.shp'],
-                                            scaleFactor=500.,
+                                            scaleFactor=500., uniformLength=False,
                                             rotationOffset=None, spatialExtent=None, linearUnit=u'Degrees', startDate=None, endDate=None,
                                             timeout=60, maxRetryTime=120, cacheDirectory=None):
@@ -575 +575 @@
                     queryableAttributeValues[u'Variable'] = queryableAttributeValues[u'Variable'].split('_')[0]
 
-                    vectorShapefiles.append(ShapefileFromVectorComponentGrids(uSlices[i], vSlices[i], scaleFactor, queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues))
+                    vectorShapefiles.append(ShapefileFromVectorComponentGrids(uSlices[i], vSlices[i], scaleFactor, uniformLength, queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues))
 
                 # Import the ShapefileFromVectorComponentGrids into
@@ -2107 +2107 @@
 u"""Factor for scaling lines lengths.
 
-Use this parameter to scale the lines output by this tool to lengths
-that are visually appealing. If the lines are too short, they will
-resemble a grid of dots and you will not be able to discern the flow
-of the vector field. If the lines are too long, they will overlap each
-other and resemble a plate of spaghetti.
+The length of each line is calculated by multiplying the magnitude of
+the vector by this parameter. Use this parameter to scale the lines
+output by this tool to lengths that are visually appealing. If the
+lines are too short, they will resemble a grid of dots and you will
+not be able to discern the flow of the vector field. If the lines are
+too long, they will overlap each other and resemble a plate of
+spaghetti.
 
 If the vectors all have about the same magnitude, then a good approach
@@ -2126 +2128 @@
 """),
     arcGISDisplayName=_(u'Scale factor'),
+    arcGISCategory=_(u'Vector options'))
+
+AddArgumentMetadata(AvisoGriddedGeostrophicCurrents.CreateVectorsAsArcGISFeatureClasses, u'uniformLength',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If False (the default) then the lengths of the lines are
+determined by multiplying the magnitude of the vector by the Scale
+Factor parameter.
+
+If True, all lines will have the same length, which will be determined
+by multiplying the cell size of the Aviso grids (e.g. 37,000 meters)
+by the the Scale Factor. Use this option when you want to the lines'
+colors to indicate the magnitude of the vector, rather than the lines'
+lengths. Start with a Scale Factor of 1 and increase it or decrease it
+slightly to achieve the desired visual effect."""),
+    arcGISDisplayName=_(u'Create all lines with the same length'),
     arcGISCategory=_(u'Vector options'))
 

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

@@ -720 +720 @@
 
     @classmethod
+    def CreateCurrentVectorsAsArcGISFeatureClasses(cls, outputWorkspace, mode=u'add', featureClassNameExpressions=['uv_vectors', '%%Y', 'Depth_%(Depth)04.0fm', 'uv_vectors_%%%Y%%j_%(Depth)04.0fm.shp'],
+                                                   scaleFactor=4500, uniformLength=False,
+                                                   spatialExtent=None, linearUnit=u'Degrees', minDepth=None, maxDepth=None, startDate=None, endDate=None,
+                                                   timeout=600, maxRetryTime=None, cacheDirectory=None):
+        cls.__doc__.Obj.ValidateMethodInvocation()
+
+        # Create u and v component grids.
+
+        if startDate is not None:
+            startYear = startDate.year
+        else:
+            startYear = None
+        if endDate is not None:
+            endYear = endDate.year
+        else:
+            endYear = None
+        
+        uGrid = HYCOMGOMl0044D(u'u', startYear=startYear, endYear=endYear, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
+        try:
+            vGrid = HYCOMGOMl0044D(u'v', startYear=startYear, endYear=endYear, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
+            try:
+                cls._LogWarning(_(u'The HYCOM OPeNDAP server often requires five to ten minutes to return the data required to create the first feature class. Please be patient. After the first one is created, the rest will go much faster. Because the first raster takes so long, the first status report may estimate an absurdly long time to completion. Please wait for the second status report, issued five minutes after the first one, for a better estimate. This tool cannot be cancelled until the first raster is created. If this tool fails with to a timeout error, increase the timeout value and try again.'))
+                
+                # If the caller requested a minimum depth that is
+                # within the range of the HYCOM layers, instantiate
+                # those grids.
+
+                from GeoEco.Datasets.Virtual import GridSliceCollection, SeafloorGrid
+
+                uSlices = []
+                vSlices = []
+
+                if minDepth is None or minDepth <= 5500.:
+                    clippedUGrid = cls._Clip(uGrid, spatialExtent, linearUnit, minDepth, maxDepth, startDate, endDate)
+                    uSlices.extend(GridSliceCollection(clippedUGrid, tQACoordType=u'center', zQACoordType=u'center').QueryDatasets())
+
+                    clippedVGrid = cls._Clip(vGrid, spatialExtent, linearUnit, minDepth, maxDepth, startDate, endDate)
+                    vSlices.extend(GridSliceCollection(clippedVGrid, tQACoordType=u'center', zQACoordType=u'center').QueryDatasets())
+
+                # If the caller requested a maximum depth that is
+                # greater than or equal to 20000., instantiate grids
+                # representing the values at the seafloor.
+
+                if minDepth == 20000. or maxDepth >= 20000.:
+                    clippedUGrid = cls._Clip(uGrid, spatialExtent, linearUnit, None, None, startDate, endDate)
+                    seafloorUGrid = SeafloorGrid(clippedUGrid, (QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata()),), {u'Depth': 20000.})
+                    uSlices.extend(GridSliceCollection(seafloorUGrid, tQACoordType=u'center').QueryDatasets())
+
+                    clippedVGrid = cls._Clip(vGrid, spatialExtent, linearUnit, None, None, startDate, endDate)
+                    seafloorVGrid = SeafloorGrid(clippedVGrid, (QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata()),), {u'Depth': 20000.})
+                    vSlices.extend(GridSliceCollection(seafloorVGrid, tQACoordType=u'center').QueryDatasets())
+
+                # Construct a list of
+                # ShapefileFromVectorComponentGrids from the slices.
+
+                from GeoEco.SpatialAnalysis.Lines import ShapefileFromVectorComponentGrids
+
+                queryableAttributes = tuple(uGrid.GetAllQueryableAttributes() + [QueryableAttribute(u'DateTime', _(u'Date'), DateTimeTypeMetadata()), QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata())])
+                vectorShapefiles = []
+
+                for i in range(len(uSlices)):
+                    queryableAttributeValues = {}
+                    for qa in queryableAttributes:
+                        queryableAttributeValues[qa.Name] = uSlices[i].GetQueryableAttributeValue(qa.Name)
+
+                    vectorShapefiles.append(ShapefileFromVectorComponentGrids(uSlices[i], vSlices[i], scaleFactor, uniformLength, queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues))
+
+                # Import the ShapefileFromVectorComponentGrids into
+                # the output workspace.
+
+                from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISTable
+
+                workspace = ArcGISWorkspace(outputWorkspace, ArcGISTable, pathCreationExpressions=featureClassNameExpressions, cacheTree=True, queryableAttributes=queryableAttributes)
+                workspace.ImportDatasets(vectorShapefiles, mode)
+
+                # Return successfully.
+                
+                return outputWorkspace
+
+            finally:
+                vGrid.Close()
+        finally:
+            uGrid.Close()
+
+    @classmethod
     def InterpolateAtArcGISPoints(cls, variableNames,
                                   points, valueFields, tField, zField=None, zValue=None, method=u'Nearest', where=None, noDataValue=None,
@@ -1655 +1740 @@
 
     @classmethod
+    def CreateCurrentVectorsAsArcGISFeatureClasses(cls, outputWorkspace, mode=u'add', featureClassNameExpressions=['uv_vectors', '%%Y', 'Depth_%(Depth)04.0fm', 'uv_vectors_%%%Y%%j_%(Depth)04.0fm.shp'],
+                                                   scaleFactor=8900, uniformLength=False,
+                                                   rotationOffset=None, extendYExtent=False, spatialExtent=None, linearUnit=u'Degrees', minDepth=None, maxDepth=None, startDate=None, endDate=None,
+                                                   timeout=60, maxRetryTime=120, cacheDirectory=None):
+        cls.__doc__.Obj.ValidateMethodInvocation()
+
+        # Create u and v component grids.
+        
+        uGrid = HYCOMGLBa008Equatorial4D(u'u', extendYExtent=extendYExtent, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
+        try:
+            vGrid = HYCOMGLBa008Equatorial4D(u'v', extendYExtent=extendYExtent, timeout=timeout, maxRetryTime=maxRetryTime, cacheDirectory=cacheDirectory)
+            try:
+                
+                # If the caller requested a minimum depth that is
+                # within the range of the HYCOM layers, instantiate
+                # those grids.
+
+                from GeoEco.Datasets.Virtual import GridSliceCollection, SeafloorGrid
+
+                uSlices = []
+                vSlices = []
+
+                if minDepth is None or minDepth <= 5500.:
+                    clippedUGrid = cls._RotateAndClip(uGrid, rotationOffset, spatialExtent, linearUnit, minDepth, maxDepth, startDate, endDate)
+                    uSlices.extend(GridSliceCollection(clippedUGrid, tQACoordType=u'center', zQACoordType=u'center').QueryDatasets())
+
+                    clippedVGrid = cls._RotateAndClip(vGrid, rotationOffset, spatialExtent, linearUnit, minDepth, maxDepth, startDate, endDate)
+                    vSlices.extend(GridSliceCollection(clippedVGrid, tQACoordType=u'center', zQACoordType=u'center').QueryDatasets())
+
+                # If the caller requested a maximum depth that is
+                # greater than or equal to 20000., instantiate grids
+                # representing the values at the seafloor.
+
+                if minDepth == 20000. or maxDepth >= 20000.:
+                    clippedUGrid = cls._RotateAndClip(uGrid, rotationOffset, spatialExtent, linearUnit, None, None, startDate, endDate)
+                    seafloorUGrid = SeafloorGrid(clippedUGrid, (QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata()),), {u'Depth': 20000.})
+                    uSlices.extend(GridSliceCollection(seafloorUGrid, tQACoordType=u'center').QueryDatasets())
+
+                    clippedVGrid = cls._RotateAndClip(vGrid, rotationOffset, spatialExtent, linearUnit, None, None, startDate, endDate)
+                    seafloorVGrid = SeafloorGrid(clippedVGrid, (QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata()),), {u'Depth': 20000.})
+                    vSlices.extend(GridSliceCollection(seafloorVGrid, tQACoordType=u'center').QueryDatasets())
+
+                # Construct a list of
+                # ShapefileFromVectorComponentGrids from the slices.
+
+                from GeoEco.SpatialAnalysis.Lines import ShapefileFromVectorComponentGrids
+
+                queryableAttributes = tuple(uGrid.GetAllQueryableAttributes() + [QueryableAttribute(u'DateTime', _(u'Date'), DateTimeTypeMetadata()), QueryableAttribute(u'Depth', _(u'Depth'), FloatTypeMetadata())])
+                vectorShapefiles = []
+
+                for i in range(len(uSlices)):
+                    queryableAttributeValues = {}
+                    for qa in queryableAttributes:
+                        queryableAttributeValues[qa.Name] = uSlices[i].GetQueryableAttributeValue(qa.Name)
+
+                    vectorShapefiles.append(ShapefileFromVectorComponentGrids(uSlices[i], vSlices[i], scaleFactor, uniformLength, queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues))
+
+                # Import the ShapefileFromVectorComponentGrids into
+                # the output workspace.
+
+                from GeoEco.Datasets.ArcGIS import ArcGISWorkspace, ArcGISTable
+
+                workspace = ArcGISWorkspace(outputWorkspace, ArcGISTable, pathCreationExpressions=featureClassNameExpressions, cacheTree=True, queryableAttributes=queryableAttributes)
+                workspace.ImportDatasets(vectorShapefiles, mode)
+
+                # Return successfully.
+                
+                return outputWorkspace
+
+            finally:
+                vGrid.Close()
+        finally:
+            uGrid.Close()
+
+    @classmethod
     def InterpolateAtArcGISPoints(cls, variableNames,
                                   points, valueFields, tField, zField=None, zValue=None, method=u'Nearest', extendYExtent=False, where=None, noDataValue=None,
@@ -2069 +2229 @@
     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.
 
 If you do not specify a spatial extent, it will default to
-approximately 18 to 32 N, 98 to 76 W. The rasters can only be clipped
+approximately 18 to 32 N, 98 to 76 W. The outputs can only be clipped
 in whole grid cells. The values you provide will be rounded off to the
 closest cell."""),
@@ -2094 +2254 @@
     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. The HYCOM GOMl0.04 dataset
 provides a five-day forecast; its temporal extent ranges from 1
@@ -2109 +2269 @@
     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. The HYCOM GOMl0.04 dataset
 provides a five-day forecast; its temporal extent ranges from 1
@@ -2745 +2905 @@
     typeMetadata=FloatTypeMetadata(minValue=0.0, maxValue=20000.0, canBeNone=True),
     description=_(
-u"""Minimum depth, in meters, for the rasters to create.
-
-The value must be between 0 and 20000, inclusive. Rasters will be
+u"""Minimum depth, in meters, for the outputs to create.
+
+The value must be between 0 and 20000, inclusive. Outputs will be
 created for images with depths that are greater than or equal to the
 minimum depth and less than or equal to the maximum depth. If you do
@@ -2755 +2915 @@
 seafloor. Use this value if you need an estimate of "bottom
 temperature" or the value of another variable at the seafloor. If this
-value is requested, an output raster will be created with a fake depth
-of 20000 meters. The cells of this raster will be assigned by stacking
+value is requested, an output will be created with a fake depth of
+20000 meters. The cells of this output will be assigned by stacking
 all of the HYCOM depth layers and selecting the deepest cells that
 have data. Because HYCOM depth layers are spaced farther apart at
@@ -2762 +2922 @@
 location might be substantially shallower than the actual seafloor
 depth. Bear this in mind when considering the likely accuracy of the
-output raster."""),
+output."""),
     arcGISDisplayName=_(u'Minimum depth'),
     arcGISCategory=_(u'Spatiotemporal extent'))
@@ -2769 +2929 @@
     typeMetadata=FloatTypeMetadata(minValue=0.0, maxValue=20000.0, canBeNone=True),
     description=_(
-u"""Maximum depth, in meters, for the rasters to create.
-
-The value must be between 0 and 20000, inclusive. Rasters will be
+u"""Maximum depth, in meters, for the outputs to create.
+
+The value must be between 0 and 20000, inclusive. Outputs will be
 created for images with depths that are greater than or equal to the
 minimum depth and less than or equal to the maximum depth. If you do
@@ -2915 +3075 @@
 
 CopyResultMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'updatedOutputWorkspace', HYCOMGOMl0044D.CreateClimatologicalArcGISRasters, u'updatedOutputWorkspace')
+
+# Public method: HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses
+
+AddMethodMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses,
+    shortDescription=_(u'Creates line feature classes representing the vectors of HYCOM GOMl0.04 currents.'),
+    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 speed 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.
+
+""") + _HYCOMGOMl004_LongDescription % {u'name': 'tool'} + _('\n\n**References**\n\n') + _HYCOMGOMl004_References,
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Create Current Vectors for HYCOM GOMl0.04'),
+    arcGISToolCategory=_(u'Data Products\\HYCOM Consortium\\HYCOM + NCODA Gulf of Mexico 1/25 Degree Analysis (GLMl0.04)\\4D Variables'),
+    dependencies=[ArcGISDependency(9, 1), PythonAggregatedModuleDependency('numpy')])
+
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'cls', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'cls')
+
+AddArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, 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(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, 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(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, 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 year and
+depth.
+
+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:
+
+* %(Depth)f - depth of the output feature class. The f may be preceded
+  by Python's string formatting codes. Please see the Python
+  documentation for more information.
+
+* %%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'))
+
+AddArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'scaleFactor',
+    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0.0),
+    description=_(
+u"""Factor for scaling lines lengths.
+
+The length of each line is calculated by multiplying the magnitude of
+the vector by this parameter. Use this parameter to scale the lines
+output by this tool to lengths that are visually appealing. If the
+lines are too short, they will resemble a grid of dots and you will
+not be able to discern the flow of the vector field. If the lines are
+too long, they will overlap each other and resemble a plate of
+spaghetti.
+
+If the vectors all have about the same magnitude, then a good approach
+is to scale the lines so that the longest one is about as long as the
+raster cell size. But if there are a few very long vectors, then you
+may prefer to scale the lines so that the average-length vector is as
+long as the raster cell size.
+
+For HYCOM GOMl0.04 currents, the grid cell size is about 4500 m and
+currents are given in m/s. So, if the maximum (or mean) velocity in
+your region of interest is about 0.75 m/s:
+
+    scale factor = 4500 / 0.75 = 6000
+"""),
+    arcGISDisplayName=_(u'Scale factor'),
+    arcGISCategory=_(u'Vector options'))
+
+AddArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'uniformLength',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If False (the default) then the lengths of the lines are
+determined by multiplying the magnitude of the vector by the Scale
+Factor parameter.
+
+If True, all lines will have the same length, which will be determined
+by multiplying the cell size of the HYCOM grids by the the Scale
+Factor. Use this option when you want to the lines' colors to indicate
+the magnitude of the vector, rather than the lines' lengths. Start
+with a Scale Factor of 1 and increase it or decrease it slightly to
+achieve the desired visual effect."""),
+    arcGISDisplayName=_(u'Create all lines with the same length'),
+    arcGISCategory=_(u'Vector options'))
+
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'spatialExtent', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'spatialExtent')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'linearUnit', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'linearUnit')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'minDepth', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'minDepth')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'maxDepth', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'maxDepth')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'startDate', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'startDate')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'endDate', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'endDate')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'timeout', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'timeout')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'maxRetryTime', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'maxRetryTime')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'cacheDirectory', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'cacheDirectory')
+
+CopyResultMetadata(HYCOMGOMl0044D.CreateArcGISRasters, u'updatedOutputWorkspace', HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'updatedOutputWorkspace')
 
 # Public method: HYCOMGOMl0044D.InterpolateAtArcGISPoints
@@ -3616 +3916 @@
     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. The HYCOM GOMa0.08 dataset
 provides a five-day forecast; its temporal extent ranges from 11
@@ -3631 +3931 @@
     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. The HYCOM GLBa0.08 dataset
 provides a five-day forecast; its temporal extent ranges from 11
@@ -3908 +4208 @@
 CopyResultMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'updatedOutputWorkspace', HYCOMGLBa008Equatorial4D.CreateClimatologicalArcGISRasters, u'updatedOutputWorkspace')
 
+# Public method: HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses
+
+AddMethodMetadata(HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses,
+    shortDescription=_(u'Creates line feature classes representing the current vectors for the equatorial (Mercator) region of the HYCOM GLBa0.08 dataset.'),
+    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 speed 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.
+
+""") + _HYCOMGLBa008Equatorial_LongDescription % {u'name': 'tool'} + _('\n\n**References**\n\n') + _HYCOMGLBa008Equatorial_References,
+    isExposedToPythonCallers=True,
+    isExposedByCOM=True,
+    isExposedAsArcGISTool=True,
+    arcGISDisplayName=_(u'Create Current Vectors for HYCOM GLBa0.08 Equatorial Region'),
+    arcGISToolCategory=_(u'Data Products\\HYCOM Consortium\\HYCOM + NCODA Global 1/12 Degree Analysis (GLBa0.08)\\Equatorial Region (47 N to 66 S)\\4D Variables'),
+    dependencies=[ArcGISDependency(9, 1), PythonAggregatedModuleDependency('numpy')])
+
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'cls', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'cls')
+
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'outputWorkspace', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'outputWorkspace')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'mode', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'mode')
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'featureClassNameExpressions', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'featureClassNameExpressions')
+
+AddArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'scaleFactor',
+    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0.0),
+    description=_(
+u"""Factor for scaling lines lengths.
+
+The length of each line is calculated by multiplying the magnitude of
+the vector by this parameter. Use this parameter to scale the lines
+output by this tool to lengths that are visually appealing. If the
+lines are too short, they will resemble a grid of dots and you will
+not be able to discern the flow of the vector field. If the lines are
+too long, they will overlap each other and resemble a plate of
+spaghetti.
+
+If the vectors all have about the same magnitude, then a good approach
+is to scale the lines so that the longest one is about as long as the
+raster cell size. But if there are a few very long vectors, then you
+may prefer to scale the lines so that the average-length vector is as
+long as the raster cell size.
+
+For HYCOM GLBa0.08 currents, the grid cell size is about 8900 m and
+currents are given in m/s. So, if the maximum (or mean) velocity in
+your region of interest is about 0.75 m/s:
+
+    scale factor = 8900 / 0.75 = 11866.666666
+"""),
+    arcGISDisplayName=_(u'Scale factor'),
+    arcGISCategory=_(u'Vector options'))
+
+CopyArgumentMetadata(HYCOMGOMl0044D.CreateCurrentVectorsAsArcGISFeatureClasses, u'uniformLength', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'uniformLength')
+
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'rotationOffset', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'rotationOffset')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'extendYExtent', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'extendYExtent')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'spatialExtent', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'spatialExtent')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'linearUnit', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'linearUnit')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'minDepth', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'minDepth')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'maxDepth', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'maxDepth')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'startDate', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'startDate')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'endDate', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'endDate')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'timeout', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'timeout')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'maxRetryTime', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'maxRetryTime')
+CopyArgumentMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'cacheDirectory', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'cacheDirectory')
+
+CopyResultMetadata(HYCOMGLBa008Equatorial4D.CreateArcGISRasters, u'updatedOutputWorkspace', HYCOMGLBa008Equatorial4D.CreateCurrentVectorsAsArcGISFeatureClasses, u'updatedOutputWorkspace')
+
 # Public method: HYCOMGLBa008Equatorial4D.InterpolateAtArcGISPoints
 

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

@@ -266 +266 @@
     @classmethod
     def CreateVectorsAsArcGISFeatureClasses(cls, outputWorkspace, mode=u'add', featureClassNameExpressions=['uv_vectors', '%%Y', 'uv_vectors_%%Y%%j.shp'],
-                                            scaleFactor=0.444,
+                                            scaleFactor=0.444, uniformLength=False,
                                             rotationOffset=None, spatialExtent=None, startDate=None, endDate=None,
                                             timeout=60, maxRetryTime=120, cacheDirectory=None):
@@ -300 +300 @@
                         queryableAttributeValues[qa.Name] = uSlices[i].GetQueryableAttributeValue(qa.Name)
 
-                    vectorShapefiles.append(ShapefileFromVectorComponentGrids(uSlices[i], vSlices[i], scaleFactor, queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues))
+                    vectorShapefiles.append(ShapefileFromVectorComponentGrids(uSlices[i], vSlices[i], scaleFactor, uniformLength, queryableAttributes=queryableAttributes, queryableAttributeValues=queryableAttributeValues))
 
                 # Import the ShapefileFromVectorComponentGrids into
@@ -973 +973 @@
     arcGISCategory=_(u'Vector options'))
 
+AddArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateVectorsAsArcGISFeatureClasses, u'uniformLength',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If False (the default) then the lengths of the lines are
+determined by multiplying the magnitude of the vector by the Scale
+Factor parameter.
+
+If True, all lines will have the same length, which will be determined
+by multiplying the cell size of the OSCAR grids (i.e. 1/3 degree) by
+the the Scale Factor. Use this option when you want to the lines'
+colors to indicate the magnitude of the vector, rather than the lines'
+lengths. Start with a Scale Factor of 1 and increase it or decrease it
+slightly to achieve the desired visual effect."""),
+    arcGISDisplayName=_(u'Create all lines with the same length'),
+    arcGISCategory=_(u'Vector options'))
+
 CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'rotationOffset', OSCAR5DayThirdDegreeCurrents.CreateVectorsAsArcGISFeatureClasses, u'rotationOffset')
 CopyArgumentMetadata(OSCAR5DayThirdDegreeCurrents.CreateArcGISRasters, u'spatialExtent', OSCAR5DayThirdDegreeCurrents.CreateVectorsAsArcGISFeatureClasses, u'spatialExtent')

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

@@ -32 +32 @@
 
     @classmethod
-    def ShapefileFromVectorComponentGrids(cls, xGrid, yGrid, shapefile, scaleFactor, overwriteExisting=False):
+    def ShapefileFromVectorComponentGrids(cls, xGrid, yGrid, shapefile, scaleFactor, uniformLength, overwriteExisting=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
 
@@ -112 +112 @@
                 '-s', repr(scaleFactor)]
 
+        if uniformLength:
+            args.append('-u')
+
         oldLogInfoAsDebug = Logger.GetLogInfoAsDebug()
         Logger.SetLogInfoAsDebug(True)
@@ -139 +142 @@
 
     @classmethod
-    def FromVectorComponentRasters(cls, xRaster, yRaster, lines, scaleFactor, overwriteExisting=False):
+    def FromVectorComponentRasters(cls, xRaster, yRaster, lines, scaleFactor, uniformLength=False, overwriteExisting=False):
         cls.__doc__.Obj.ValidateMethodInvocation()
         try:
@@ -153 +156 @@
 
             if os.path.splitext(lines)[1].lower() == '.shp':
-                Lines.ShapefileFromVectorComponentGrids(xGrid, yGrid, lines, scaleFactor, overwriteExisting=overwriteExisting)
+                Lines.ShapefileFromVectorComponentGrids(xGrid, yGrid, lines, scaleFactor, uniformLength, overwriteExisting=overwriteExisting)
 
             # Otherwise, create a shapefile in a temporary directory and
@@ -163 +166 @@
 
                 shapefile = os.path.join(tempDir.Path, 'vectors.shp')
-                Lines.ShapefileFromVectorComponentGrids(xGrid, yGrid, shapefile, scaleFactor)
+                Lines.ShapefileFromVectorComponentGrids(xGrid, yGrid, shapefile, scaleFactor, uniformLength)
 
                 gp = GeoprocessorManager.GetWrappedGeoprocessor()
@@ -190 +193 @@
     __doc__ = DynamicDocString()
 
-    def __init__(self, xGrid, yGrid, scaleFactor, parentCollection=None, queryableAttributes=None, queryableAttributeValues=None):
+    def __init__(self, xGrid, yGrid, scaleFactor, uniformLength=False, parentCollection=None, queryableAttributes=None, queryableAttributeValues=None):
 
         # Initialize our properties.
@@ -197 +200 @@
         self._YGrid = yGrid
         self._ScaleFactor = scaleFactor
+        self._UniformLength = uniformLength
         self._TempDir = None
         self._DisplayName = _(u'vectors for x components = %(dnx)s, y components = %(dny)s') % {u'dnx': xGrid, u'dny': yGrid}
@@ -229 +233 @@
             try:
                 self._TempDir = self._CreateTempDirectory()
-                Lines.ShapefileFromVectorComponentGrids(self._XGrid, self._YGrid, os.path.join(self._TempDir, 'Vectors.shp'), self._ScaleFactor)
+                Lines.ShapefileFromVectorComponentGrids(self._XGrid, self._YGrid, os.path.join(self._TempDir, 'Vectors.shp'), self._ScaleFactor, self._UniformLength)
             except:
                 self._Close()
@@ -319 +323 @@
 u"""Factor for scaling lines lengths.
 
-Use this parameter to scale the lines output by this tool to lengths
-that are visually appealing. If the lines are too short, they will
-resemble a grid of dots and you will not be able to discern the flow
-of the vector field. If the lines are too long, they will overlap each
-other and resemble a plate of spaghetti.
+The length of each line is calculated by multiplying the magnitude of
+the vector by this parameter. Use this parameter to scale the lines
+output by this tool to lengths that are visually appealing. If the
+lines are too short, they will resemble a grid of dots and you will
+not be able to discern the flow of the vector field. If the lines are
+too long, they will overlap each other and resemble a plate of
+spaghetti.
 
 If the vectors all have about the same magnitude, then a good approach
@@ -345 +351 @@
 Use a scale factor of 1 to indicate that the lines should not be
 scaled."""))
+
+AddArgumentMetadata(Lines.ShapefileFromVectorComponentGrids, u'uniformLength',
+    typeMetadata=BooleanTypeMetadata(),
+    description=_(
+u"""If False (the default) then the lengths of the lines are
+determined by multiplying the magnitude of the vector by the Scale
+Factor parameter.
+
+If True, all lines will have the same length, which will be determined
+by multiplying the cell size of the input grids by the the Scale
+Factor. Use this option when you want to the lines' colors to indicate
+the magnitude of the vector, rather than the lines' lengths. Start
+with a Scale Factor of 1 and increase it or decrease it slightly to
+achieve the desired visual effect."""))
 
 AddArgumentMetadata(Lines.ShapefileFromVectorComponentGrids, u'overwriteExisting',
@@ -430 +450 @@
     arcGISDisplayName=_(u'Scale factor'))
 
+AddArgumentMetadata(ArcGISLines.FromVectorComponentRasters, u'uniformLength',
+    typeMetadata=FloatTypeMetadata(mustBeGreaterThan=0.0),
+    description=Lines.ShapefileFromVectorComponentGrids.__doc__.Obj.Arguments[5].Description,
+    arcGISDisplayName=_(u'Create all lines with the same length'))
+
 AddArgumentMetadata(ArcGISLines.FromVectorComponentRasters, u'overwriteExisting',
     typeMetadata=BooleanTypeMetadata(),
@@ -610 +635 @@
   right, 90 is up, -90 is down, and 180 is left.
 """)],
-    constantParamNames=[u'scaleFactor'],
+    constantParamNames=[u'scaleFactor', u'uniformLength'],
     processListMethodName=u'FromVectorComponentRastersInList',
     processListMethodShortDescription=_(u'Given lists of rasters representing the x and y components of vector fields, such as the u and v rasters for ocean currents, this tool creates feature classes of lines representing the vectors, similar to a "quiver plot".'),