Changeset 955

Timestamp:

04/05/12 17:49:51 (14 months ago)

Author:

jjr8

Message:

* Finished implementation of #537: Add support for GHRSST Level 4 datasets
* Cleaned up some documentation of for the front detection tools.

Location:

MGET/Branches/Jason/PythonPackage/src/GeoEco

Files:

• DataProducts/HYCOM.py (modified) (4 diffs)
• DataProducts/NASA/PODAAC.py (modified) (9 diffs)
• DataProducts/NOAA/CoastWatchAVHRR.py (modified) (14 diffs)
• DataProducts/NOAA/NODC.py (modified) (5 diffs)
• OceanographicAnalysis/Fronts.py (modified) (42 diffs)

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

@@ -3414 +3414 @@
 
 This tool efficiently downloads 2D time/depth slices of a specified 4D
-HYCOM variable, executes the Cayula-Cornillon SIED algorithm to
+HYCOM variable, executes the Cayula and Cornillon SIED algorithm to
 identify fronts in each 2D slice, and creates rasters showing the
 locations of the fronts.
@@ -3481 +3481 @@
 * temperature - Sea water potential temperature, in degrees C.
 
-The Cayula-Cornillon SIED algorithm has traditionally been applied to
+The Cayula and Cornillon SIED algorithm has traditionally been applied to
 surface temperature, but in principle, it can be applied to salinity
 as well."""),
@@ -3526 +3526 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -3670 +3670 @@
 in a histogram window that had a sufficiently large number of
 non-masked pixels to proceed with the histogramming step of the
-Cayula-Cornillon algorithm. If the histogram window stride is less
+Cayula and Cornillon algorithm. If the histogram window stride is less
 than the window size, successive histogram windows will overlap, and
 many pixels will have candidate counts greater than 1. Masked pixels

MGET/Branches/Jason/PythonPackage/src/GeoEco/DataProducts/NASA/PODAAC.py

@@ -20 +20 @@
 
 import datetime
+import os
 
 from GeoEco.Datasets import Dataset, QueryableAttribute, Grid
@@ -526 +527 @@
                                                                            'TCornerCoordType': 'min',
                                                                            'CoordDependencies': (None, None, None),
-                                                                           'PhysicalDimensions': u'tyx',
-                                                                           'PhysicalDimensionsFlipped': (False, False, False)})
+                                                                           'PhysicalDimensions': u'tyx'})
 
     def _GetLazyPropertyPhysicalValue(self, name):
@@ -537 +537 @@
         self.ParentCollection._Open()
 
-        if name in ['CoordIncrements', 'CornerCoords']:
+        if name in ['CoordIncrements', 'CornerCoords', 'PhysicalDimensionsFlipped']:
             lon = self.ParentCollection._PydapDataset['lon']
             lat = self.ParentCollection._PydapDataset['lat']
 
-            if lon[0] > lon[-1]:
-                self.SetLazyPropertyValue('CoordIncrements', (1., (lat[-1] - lat[0]) / (lat.shape[0] - 1), (lon[-1] + 360. - lon[0]) / (lon.shape[0] - 1)))     # For datasets such as ABOM-L4HRfnd-AUS-RAMSSA_09km that cross the 180th meridian, use a 0-to-360 coordinate system
+            yIncrement = abs((lat[-1] - lat[0]) / (lat.shape[0] - 1))
+
+            if os.path.basename(self.ParentCollection.URL).find('-GLOB-') >= 0:      # If it is a global dataset, assume 360 degrees longitude and calculate the x increment at full precision.
+                xIncrement = 360. / self.Shape[-1]
+            elif lon[0] > lon[-1]:
+                xIncrement = abs((lon[-1] + 360. - lon[0]) / (lon.shape[0] - 1))     # For datasets such as ABOM-L4HRfnd-AUS-RAMSSA_09km that cross the 180th meridian, use a 0-to-360 coordinate system
             else:
-                self.SetLazyPropertyValue('CoordIncrements', (1., (lat[-1] - lat[0]) / (lat.shape[0] - 1), (lon[-1] - lon[0]) / (lon.shape[0] - 1)))
-
-            self.SetLazyPropertyValue('CornerCoords', (datetime.datetime(1980, 1, 1), lat[0], lon[0]))      # Use fake time coordinate; the true time coordinates are parsed from the file name. 
+                xIncrement = abs((lon[-1] - lon[0]) / (lon.shape[0] - 1))
+                    
+            if abs(yIncrement - xIncrement) < 0.000001:     # If x and y increments are almost exactly the same, force them to be exactly the same so that the cells are perfectly square
+                yIncrement = xIncrement
+
+            self.SetLazyPropertyValue('CoordIncrements', (1., yIncrement, xIncrement))
+
+            if lat[-1] > lat[0]:
+                self.SetLazyPropertyValue('CornerCoords', (datetime.datetime(1980, 1, 1), lat[0], lon[0]))      # Use fake time coordinate; the true time coordinates are parsed from the file name.
+                self.SetLazyPropertyValue('PhysicalDimensionsFlipped', (False, False, False))
+            else:
+                self.SetLazyPropertyValue('CornerCoords', (datetime.datetime(1980, 1, 1), lat[-1], lon[0]))      # Use fake time coordinate; the true time coordinates are parsed from the file name.
+                self.SetLazyPropertyValue('PhysicalDimensionsFlipped', (False, True, False))
 
             return self.GetLazyPropertyValue(name)
@@ -1943 +1957 @@
 Given a satellite name, temporal resolution, spatial resolution, and
 desired SST product, this tool efficiently downloads the corresponding
-time series of MODIS Level 3 SST images, executes the Cayula-Cornillon
+time series of MODIS Level 3 SST images, executes the Cayula and Cornillon
 SIED algorithm to identify fronts, and creates rasters showing the
 locations of the fronts.
@@ -2001 +2015 @@
 
 The choice of an appropriate temporal resolution is critical to the
-successful operation of the Cayula-Cornillon algorithm. The algorithm
+successful operation of the Cayula and Cornillon algorithm. The algorithm
 is designed to operate on instantaneous images of SST, not averages.
 Therefore, for best results, choose daily temporal resolution.
@@ -2023 +2037 @@
 u"""
 
-The default Cayula-Cornillon algorithm parameters are intended to be
+The default Cayula and Cornillon algorithm parameters are intended to be
 used with the 4km MODIS products. If you use the 9km products, you
 might achieve better results by adjusting the parameter values,
@@ -2074 +2088 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -2212 +2226 @@
 in a histogram window that had a sufficiently large number of
 non-masked pixels to proceed with the histogramming step of the
-Cayula-Cornillon algorithm. If the histogram window stride is less
+Cayula and Cornillon algorithm. If the histogram window stride is less
 than the window size, successive histogram windows will overlap, and
 many pixels will have candidate counts greater than 1. Masked pixels
@@ -2853 +2867 @@
 AddMethodMetadata(GHRSSTLevel4.CreateCayulaCornillonFrontsAsArcGISRasters,
     shortDescription=_(u'Creates rasters indicating the positions of fronts in GHRSST L4 SST images hosted by NASA JPL PO.DAAC, using the Cayula and Cornillon (1992) single image edge detection (SIED) algorithm.'),
-    longDescription=_MODISL3SSTTimeSeries_LongDescription + _(
+    longDescription=_GHRSSTLevel4_LongDescription + _(
 u"""
 
 Given a desired GHRSST L4 product, this tool efficiently downloads the
-a time series of SST images, executes the Cayula-Cornillon SIED
+a time series of SST images, executes the Cayula and Cornillon SIED
 algorithm to identify fronts, and creates rasters showing the
 locations of the fronts.

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

@@ -3085 +3085 @@
         # integers that are multiplied by 0.01 to obtain the
         # actual SST value as a 32-bit float. The
-        # Cayula-Cornillon algorithm operates on integers,
+        # Cayula and Cornillon algorithm operates on integers,
         # however, so when we export the variable to a binary
         # file, we must do it as integers, not floats.
@@ -3100 +3100 @@
 
         else:
-            Logger.RaiseException(ValueError(_(u'Cannot find fronts in the variable %(var)s of CoastWatch file %(file)s because the data type of the variable is %(type)s. The Cayula-Cornillon edge detection algorithm can only operate on integer data. In CoastWatch files, only variables with the data types "ubyte" or "short" may be used.') % {u'var': variable, u'file': imageFileTemp, u'type': metadata[u'Type']}))
+            Logger.RaiseException(ValueError(_(u'Cannot find fronts in the variable %(var)s of CoastWatch file %(file)s because the data type of the variable is %(type)s. The Cayula and Cornillon edge detection algorithm can only operate on integer data. In CoastWatch files, only variables with the data types "ubyte" or "short" may be used.') % {u'var': variable, u'file': imageFileTemp, u'type': metadata[u'Type']}))
 
         # Execute cwexport to create a binary file.
@@ -6528 +6528 @@
 
 AddMethodMetadata(CoastWatchAVHRR.FindFrontsAsBinaryRaster,
-    shortDescription=_(u'Finds fronts in a CoastWatch POES AVHRR image using the Cayula-Cornillon (1992) single-image edge detection algorithm and outputs them to a binary raster.'),
+    shortDescription=_(u'Finds fronts in a CoastWatch POES AVHRR image using the Cayula and Cornillon (1992) single-image edge detection algorithm and outputs them to a binary raster.'),
     isExposedToPythonCallers=True,
     isExposedByCOM=True,
@@ -6648 +6648 @@
 
 AddMethodMetadata(CoastWatchAVHRR.FindFrontsAsArcGISRaster,
-    shortDescription=_(u'Finds fronts in a CoastWatch POES AVHRR image using the Cayula-Cornillon (1992) single-image edge detection algorithm and outputs them to an ArcGIS raster.'),
+    shortDescription=_(u'Finds fronts in a CoastWatch POES AVHRR image using the Cayula and Cornillon (1992) single-image edge detection algorithm and outputs them to an ArcGIS raster.'),
     isExposedToPythonCallers=True,
     isExposedByCOM=True,
@@ -6673 +6673 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -6723 +6723 @@
     description=_(
 u"""Output raster that shows the pixels of the input image that were
-masked prior to executing the Cayula-Cornillon algorithm.
+masked prior to executing the Cayula and Cornillon algorithm.
 
 The raster will contain 8-bit integers and have the same dimensions as
@@ -6753 +6753 @@
 the number of times it appeared in a histogram window that had a
 sufficiently large number of non-masked pixels to proceed with the
-histogramming step of the Cayula-Cornillon algorithm.
+histogramming step of the Cayula and Cornillon algorithm.
 
 The raster will contain 16-bit signed integers and have the same
@@ -7424 +7424 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -7438 +7438 @@
 
 _(u"""%s output rasters to create that show the pixels of the input
-images that were masked prior to executing the Cayula-Cornillon
+images that were masked prior to executing the Cayula and Cornillon
 algorithm.
 
@@ -7459 +7459 @@
 containing fronts, i.e. the number of times the pixels appeared in
 histogram windows that had a sufficiently large number of non-masked
-pixels to proceed with the histogramming step of the Cayula-Cornillon
+pixels to proceed with the histogramming step of the Cayula and Cornillon
 algorithm.
 
@@ -7509 +7509 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -7556 +7556 @@
 _(u"""Python expression used to calculate the absolute path of the
 output raster that shows the pixels of the input image that were
-masked prior to executing the Cayula-Cornillon algorithm. If an
+masked prior to executing the Cayula and Cornillon algorithm. If an
 expression is not provided, this raster will not be created.
 
@@ -7592 +7592 @@
 number of times the pixels appeared in histogram windows that had a
 sufficiently large number of non-masked pixels to proceed with the
-histogramming step of the Cayula-Cornillon algorithm. If an expression
+histogramming step of the Cayula and Cornillon algorithm. If an expression
 is not provided, this raster will not be created.
 
@@ -7654 +7654 @@
     constantParamNames=[u'minPopMeanDifference', u'cloudVariable', u'sunZenithVariable', u'useDayCloudTest1', u'useDayCloudTest2', u'useDayCloudTest3', u'useDayCloudTest4', u'useDayCloudTest5', u'useDayCloudTest6', u'useDayCloudTest7', u'maskWhenDayCloudMaskExceeds', u'useNightCloudTest1', u'useNightCloudTest2', u'useNightCloudTest3', u'useNightCloudTest4', u'useNightCloudTest5', u'useNightCloudTest6', u'useNightCloudTest7', u'maskWhenNightCloudMaskExceeds', u'minCloudyNeighbors', u'medianFilterWindowSize', u'histogramWindowSize', u'histogramWindowStride', u'minPropNonMaskedCells', u'minPopProp', u'minTheta', u'minSinglePopCohesion', u'minGlobalPopCohesion', u'threads', u'projectedCoordinateSystem', u'geographicTransformation', u'resamplingTechnique', u'projectedCellSize', u'registrationPoint', u'clippingRectangle', u'buildPyramids'],
     processListMethodName=u'FindFrontsAsArcGISRastersList',
-    processListMethodShortDescription=_(u'Finds fronts in a list of CoastWatch POES AVHRR images using the Cayula-Cornillon (1992) single-image edge detection algorithm and outputs them as ArcGIS rasters.'),
+    processListMethodShortDescription=_(u'Finds fronts in a list of CoastWatch POES AVHRR images using the Cayula and Cornillon (1992) single-image edge detection algorithm and outputs them as ArcGIS rasters.'),
     processTableMethodName=u'FindFrontsAsArcGISRastersTable',
-    processTableMethodShortDescription=_(u'Finds fronts in CoastWatch POES AVHRR images listed in a table using the Cayula-Cornillon (1992) single-image edge detection algorithm and outputs them as ArcGIS rasters.'),
+    processTableMethodShortDescription=_(u'Finds fronts in CoastWatch POES AVHRR images listed in a table using the Cayula and Cornillon (1992) single-image edge detection algorithm and outputs them as ArcGIS rasters.'),
     processArcGISTableMethodName=u'FindFrontsAsArcGISRastersArcGISTable',
     processArcGISTableMethodArcGISDisplayName=_(u'Cayula-Cornillon Fronts in CoastWatch Images Listed in Table as ArcGIS Rasters'),
     findAndProcessMethodName=u'FindCoastWatchFilesAndFindFrontsAsArcGISRasters',
     findAndProcessMethodArcGISDisplayName=u'Find CoastWatch Images and Find Cayula-Cornillon Fronts as ArcGIS Rasters',
-    findAndProcessMethodShortDescription=_(u'Uses the Cayula-Cornillon (1992) single-image edge detection algorithm to find fronts in the CoastWatch POES AVHRR images found in a directory, and outputs the fronts as ArcGIS rasters.'),
+    findAndProcessMethodShortDescription=_(u'Uses the Cayula and Cornillon (1992) single-image edge detection algorithm to find fronts in the CoastWatch POES AVHRR images found in a directory, and outputs the fronts as ArcGIS rasters.'),
     findMethod=CoastWatchAVHRR.FindImagesInFilesAndCreateTable,
     findOutputFieldParams=[u'fileField', u'variableField'],

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

@@ -1025 +1025 @@
                     definiteClouds[reclaimedClouds] = False
 
-            # The Cayula-Cornillon algorithm median-filters the SST
+            # The Cayula and Cornillon algorithm median-filters the SST
             # image before running the edge detection step. Because of
             # that, we can ignore clouds that would just get filled in
@@ -2982 +2982 @@
 Given a temporal resolution and observation time, this tool
 efficiently downloads a time series of Pathfinder SST images, executes
-the Cayula-Cornillon SIED algorithm to identify fronts, and creates
+the Cayula and Cornillon SIED algorithm to identify fronts, and creates
 rasters showing the locations of the fronts.
 
@@ -3054 +3054 @@
 
 The choice of an appropriate temporal resolution is critical to the
-successful operation of the Cayula-Cornillon algorithm. The algorithm
+successful operation of the Cayula and Cornillon algorithm. The algorithm
 is designed to operate on instantaneous images of SST, not averages.
 Therefore, for best results, choose daily temporal resolution.
@@ -3122 +3122 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -3366 +3366 @@
 in a histogram window that had a sufficiently large number of
 non-masked pixels to proceed with the histogramming step of the
-Cayula-Cornillon algorithm. If the histogram window stride is less
+Cayula and Cornillon algorithm. If the histogram window stride is less
 than the window size, successive histogram windows will overlap, and
 many pixels will have candidate counts greater than 1. Masked pixels

MGET/Branches/Jason/PythonPackage/src/GeoEco/OceanographicAnalysis/Fronts.py

@@ -164 +164 @@
             bufferedImage[bufferSize:bufferSize+image.shape[0], -bufferSize:] = bufferedImage[bufferSize:bufferSize+image.shape[0], bufferSize:bufferSize*2]
 
-        # Run the Cayula-Cornillon (1992) single-image edge detection
+        # Run the Cayula and Cornillon (1992) single-image edge detection
         # algorithm. This function performs the histogram and cohesion
         # steps, but does not perform contour following, thinning or
@@ -607 +607 @@
             pixelType = gp.Describe(inputRaster).PixelType
             if pixelType.lower() not in ['s1', 'u1', 's2', 'u2', 's4', 'u4', 's8', 'u8', 's16', 'u16', 's32', 'u32']:
-                Logger.RaiseException(ValueError(_(u'The input raster must contain integers in order to be processed by the Cayula-Cornillon algorithm. Please provide a raster that meets this requirement. Alternatively, you can use the Map Algebra Expression parameter to convert your data.')))
+                Logger.RaiseException(ValueError(_(u'The input raster must contain integers in order to be processed by the Cayula and Cornillon algorithm. Please provide a raster that meets this requirement. Alternatively, you can use the Map Algebra Expression parameter to convert your data.')))
 
         # Detect the fronts.
@@ -653 +653 @@
                     pixelType = gp.Describe(inputRasterToProcess).PixelType
                     if pixelType.lower() not in ['s1', 'u1', 's2', 'u2', 's4', 'u4', 's8', 'u8', 's16', 'u16', 's32', 'u32']:
-                        Logger.RaiseException(ValueError(_(u'The map algebra expression you provided did not yield a raster that contains integers. The Cayula-Cornillon algorithm can only process integers. Please provide a map algebra expression that yields integers.')))
+                        Logger.RaiseException(ValueError(_(u'The map algebra expression you provided did not yield a raster that contains integers. The Cayula and Cornillon algorithm can only process integers. Please provide a map algebra expression that yields integers.')))
 
                 # Read the raster into a numpy array.
@@ -751 +751 @@
 
         if grid.UnscaledDataType.startswith('f') and unscalingFunction is None:
-            raise ValueError(_(u'The grid has a floating point data type but an unscaling function was not supplied. An unscaling function is required to convert the floating point numbers to integers so that the Cayula-Cornillon algorithm can be applied to them. If you do not know what unscaling function to use, try: lambda a: numpy.cast[\'int16\'](a * 10)'))
+            raise ValueError(_(u'The grid has a floating point data type but an unscaling function was not supplied. An unscaling function is required to convert the floating point numbers to integers so that the Cayula and Cornillon algorithm can be applied to them. If you do not know what unscaling function to use, try: lambda a: numpy.cast[\'int16\'](a * 10)'))
 
         # Initialize our properties.
@@ -783 +783 @@
 
         if tQAName is not None and zQAName is not None:
-            displayName = _(u'Cayula-Cornillon SIED fronts in the %(tdn)s and %(zdn)s slices of %(dn)s') % {u'tdn': tQADisplayName.lower(), u'zdn': zQADisplayName.lower(), u'dn': self._Grid.DisplayName}
+            displayName = _(u'Cayula and Cornillon SIED fronts in the %(tdn)s and %(zdn)s slices of %(dn)s') % {u'tdn': tQADisplayName.lower(), u'zdn': zQADisplayName.lower(), u'dn': self._Grid.DisplayName}
         elif tQAName is not None:
-            displayName = _(u'Cayula-Cornillon SIED fronts in the %(tdn)s slices of %(dn)s') % {u'tdn': tQADisplayName.lower(), u'dn': self._Grid.DisplayName}
+            displayName = _(u'Cayula and Cornillon SIED fronts in the %(tdn)s slices of %(dn)s') % {u'tdn': tQADisplayName.lower(), u'dn': self._Grid.DisplayName}
         else:
-            displayName = _(u'Cayula-Cornillon SIED fronts in the %(zdn)s slices of %(dn)s') % {u'zdn': zQADisplayName.lower(), u'dn': self._Grid.DisplayName}
-
-        super(CayulaCornillonFrontsInGrid, self).__init__(grid, tQAName, tQADisplayName, tQACoordType, zQAName, zQADisplayName, zQACoordType, displayName, [QueryableAttribute(u'ImageType', u'Cayula-Cornillon image type', UnicodeStringTypeMetadata(allowedValues=[u'ccnt', u'fcnt', u'floc', u'wsco', u'wsvl'], makeLowercase=True))])
+            displayName = _(u'Cayula and Cornillon SIED fronts in the %(zdn)s slices of %(dn)s') % {u'zdn': zQADisplayName.lower(), u'dn': self._Grid.DisplayName}
+
+        super(CayulaCornillonFrontsInGrid, self).__init__(grid, tQAName, tQADisplayName, tQACoordType, zQAName, zQADisplayName, zQACoordType, displayName, [QueryableAttribute(u'ImageType', u'Cayula and Cornillon image type', UnicodeStringTypeMetadata(allowedValues=[u'ccnt', u'fcnt', u'floc', u'wsco', u'wsvl'], makeLowercase=True))])
 
     def _EvaluateExpressionForSlice(self, parsedExpression, attrValues, t, z, tCoord, zCoord, progressReporter):
@@ -849 +849 @@
                 noDataValue = self._Grid.UnscaledNoDataValue
                 if self._Grid.DataType != self._Grid.UnscaledDataType:
-                    minPopMeanDifference = float(self._Grid.GetLazyPropertyValue('UnscalingFunction')(self._MinPopMeanDifference))      # Convert self._MinPopMeanDifference from degrees C to unscaled integer counts
+                    minPopMeanDifference = float(self._Grid.GetLazyPropertyValue('UnscalingFunction')(self._MinPopMeanDifference)) - float(self._Grid.GetLazyPropertyValue('UnscalingFunction')(0.))      # Convert self._MinPopMeanDifference from degrees C to unscaled integer counts
                 else:
                     minPopMeanDifference = self._MinPopMeanDifference
             
             if self._TQAName is not None and self._ZQAName is not None:
-                Logger.Debug(_(u'Finding Cayula-Cornillon SIED fronts in %(tdn)s, %(zdn)s slice %(t)i, %(z)i of %(dn)s') % {u'tdn': self._TQADisplayName.lower(), u'zdn': self._ZQADisplayName.lower(), u't': key[0], u'z': key[1], u'dn': self._Grid.DisplayName})
+                Logger.Debug(_(u'Finding Cayula and Cornillon SIED fronts in %(tdn)s, %(zdn)s slice %(t)i, %(z)i of %(dn)s') % {u'tdn': self._TQADisplayName.lower(), u'zdn': self._ZQADisplayName.lower(), u't': key[0], u'z': key[1], u'dn': self._Grid.DisplayName})
             elif self._TQAName is not None:
-                Logger.Debug(_(u'Finding Cayula-Cornillon SIED fronts in %(tdn)s slice %(t)i of %(dn)s') % {u'tdn': self._TQADisplayName.lower(), u't': key[0], u'dn': self._Grid.DisplayName})
+                Logger.Debug(_(u'Finding Cayula and Cornillon SIED fronts in %(tdn)s slice %(t)i of %(dn)s') % {u'tdn': self._TQADisplayName.lower(), u't': key[0], u'dn': self._Grid.DisplayName})
             else:
-                Logger.Debug(_(u'Finding Cayula-Cornillon SIED fronts in %(zdn)s slice %(z)i of %(dn)s') % {u'zdn': self._ZQADisplayName.lower(), u'z': key[0], u'dn': self._Grid.DisplayName})
+                Logger.Debug(_(u'Finding Cayula and Cornillon SIED fronts in %(zdn)s slice %(z)i of %(dn)s') % {u'zdn': self._ZQADisplayName.lower(), u'z': key[0], u'dn': self._Grid.DisplayName})
 
             if noDataValue is not None:
@@ -897 +897 @@
 
         if self._InstantiatingCollection._TQAName is not None and self._InstantiatingCollection._ZQAName is not None:
-            displayName = _(u'Cayula-Cornillon SIED fronts in the %(tdn)s and %(zdn)s slices of %(dn)s') % {u'tdn': self._InstantiatingCollection._TQADisplayName.lower(), u'zdn': self._InstantiatingCollection._ZQADisplayName.lower(), u'dn': self._InstantiatingCollection._Grid.DisplayName}
+            displayName = _(u'Cayula and Cornillon SIED fronts in the %(tdn)s and %(zdn)s slices of %(dn)s') % {u'tdn': self._InstantiatingCollection._TQADisplayName.lower(), u'zdn': self._InstantiatingCollection._ZQADisplayName.lower(), u'dn': self._InstantiatingCollection._Grid.DisplayName}
         elif self._InstantiatingCollection._TQAName is not None:
-            displayName = _(u'Cayula-Cornillon SIED fronts in the %(tdn)s slices of %(dn)s') % {u'tdn': self._InstantiatingCollection._TQADisplayName.lower(), u'dn': self._InstantiatingCollection._Grid.DisplayName}
+            displayName = _(u'Cayula and Cornillon SIED fronts in the %(tdn)s slices of %(dn)s') % {u'tdn': self._InstantiatingCollection._TQADisplayName.lower(), u'dn': self._InstantiatingCollection._Grid.DisplayName}
         else:
-            displayName = _(u'Cayula-Cornillon SIED fronts in the %(zdn)s slices of %(dn)s') % {u'zdn': self._InstantiatingCollection._ZQADisplayName.lower(), u'dn': self._InstantiatingCollection._Grid.DisplayName}
+            displayName = _(u'Cayula and Cornillon SIED fronts in the %(zdn)s slices of %(dn)s') % {u'zdn': self._InstantiatingCollection._ZQADisplayName.lower(), u'dn': self._InstantiatingCollection._Grid.DisplayName}
 
         super(_CayulaCornillonFrontsImageForGridSlice, self).__init__(self._InstantiatingCollection._Grid,
@@ -1035 +1035 @@
 
 In 2005, I obtained a Rational Fortran (Ratfor) version of the
-Cayula-Cornillon algorithm from Dave Ullman. Although it had been
+Cayula and Cornillon algorithm from Dave Ullman. Although it had been
 modified extensively from the 1992 version, mainly to incorporate the
 multi-image edge detection (MIED) algorithm (Cayula and Cornillon
@@ -1118 +1118 @@
 u"""The image in which edges should be detected.
 
-The image pixels must be integers. The Cayula-Cornillon algorithm is
+The image pixels must be integers. The Cayula and Cornillon algorithm is
 designed to operate on the original unscaled integer data provided by
 the original data provider. For example, the NOAA NODC 4km AVHRR
@@ -1133 +1133 @@
     description=_(
 u"""If True, the input image is assumed to be a cylinder, with the
-east and west edges connected. The Cayula-Cornillon algorithm will
+east and west edges connected. The Cayula and Cornillon algorithm will
 "wrap around" to the other side of the image when needed. If False,
 the east and west edges are assumed to not be connected, and the
@@ -1149 +1149 @@
 u"""Minimum allowed value for pixels of the input image. If a value is
 provided, pixels less than this value will be masked prior to running
-the Cayula-Cornillon algorithm."""),
+the Cayula and Cornillon algorithm."""),
     arcGISDisplayName=_(u'Minimum allowed image value'),
     arcGISCategory=_(u'Mask options'))
@@ -1158 +1158 @@
 u"""Maximum allowed value for pixels of the input image. If a value is
 provided, pixels greater than this value will be masked prior to
-running the Cayula-Cornillon algorithm."""),
+running the Cayula and Cornillon algorithm."""),
     arcGISDisplayName=_(u'Maximum allowed image value'),
     arcGISCategory=_(u'Mask options'))
@@ -1166 +1166 @@
     description=_(
 u"""List of masks to apply to the input image before running the
-Cayula-Cornillon algorithm on it. Each item in the list corresponds to
+Cayula and Cornillon algorithm on it. Each item in the list corresponds to
 parallel entries in the lists of mask tests and values.
 
@@ -1231 +1231 @@
 u"""Window size, in pixels, of the median filter to apply to the input
 image prior to running the histogram analysis step of the
-Cayula-Cornillon algorithm. If not provided, median filtering will not
+Cayula and Cornillon algorithm. If not provided, median filtering will not
 be performed.
 
@@ -1241 +1241 @@
 
 Median filtering is a traditional first step for certain classes of
-edge detection algorithms. The original Cayula-Cornillon paper used a
+edge detection algorithms. The original Cayula and Cornillon paper used a
 window size of 3."""),
     arcGISDisplayName=_(u'Median filter window size'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'histogramWindowSize',
     typeMetadata=IntegerTypeMetadata(minValue=8, maxValue=128),
     description=_(
-u"""Size of the histogram window to use for the Cayula-Cornillon
+u"""Size of the histogram window to use for the Cayula and Cornillon
 algorithm.
 
@@ -1259 +1259 @@
 sizes."""),
     arcGISDisplayName=_(u'Histogram window size'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'histogramWindowStride',
@@ -1265 +1265 @@
     description=_(
 u"""Number of pixels to move the histogram window after each iteration
-of the Cayula-Cornillon algorithm.
+of the Cayula and Cornillon algorithm.
 
 The original paper used a 32x32 window and a stride of 16, to minimize
@@ -1280 +1280 @@
 Options) to thin the fronts back to one pixel wide."""),
     arcGISDisplayName=_(u'Histogram window stride'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'minPropNonMaskedCells',
@@ -1298 +1298 @@
 0.65."""),
     arcGISDisplayName=_(u'Minimum proportion of non-masked pixels'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'minPopProp',
@@ -1317 +1317 @@
 understand the statistical analysis presented in the 1992 paper."""),
     arcGISDisplayName=_(u'Minimum proportion of smaller population'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'minPopMeanDifference',
@@ -1353 +1353 @@
 less than 1 degree, set this parameter to 1 / 0.075 = 13.333333."""),
     arcGISDisplayName=_(u'Minimum population mean difference'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'minTheta',
@@ -1378 +1378 @@
 understand the statistics presented in the original paper."""),
     arcGISDisplayName=_(u'Minimum value for criterion function'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'minSinglePopCohesion',
@@ -1405 +1405 @@
 For a 16x16 window, the equation evaluates to 0.8675."""),
     arcGISDisplayName=_(u'Minimum single-population cohesion'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'minGlobalPopCohesion',
@@ -1422 +1422 @@
 For a 16x16 window, the equation evaluates to 0.8875."""),
     arcGISDisplayName=_(u'Minimum global-population cohesion'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'threads',
@@ -1437 +1437 @@
 reduce performance."""),
     arcGISDisplayName=_(u'Processing threads'),
-    arcGISCategory=_(u'Cayula-Cornillon algorithm parameters'))
+    arcGISCategory=_(u'Cayula and Cornillon algorithm parameters'))
 
 AddArgumentMetadata(CayulaCornillonEdgeDetection.DetectEdgesInSingleImage, u'fillHoles',
@@ -1541 +1541 @@
 it appeared in a histogram window that had a sufficiently large number
 of non-masked pixels to proceed with the histogramming step of the
-Cayula-Cornillon algorithm. If the histogram window stride is less
+Cayula and Cornillon algorithm. If the histogram window stride is less
 than the window size, successive histogram windows will overlap, and
 many pixels will have candidate counts greater than 1. Masked pixels
@@ -1572 +1572 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -1741 +1741 @@
 * uint16 - 16-bit unsigned integer, range 0 to 65535
 
-The Cayula-Cornillon algorithm is designed to operate on the original
+The Cayula and Cornillon algorithm is designed to operate on the original
 unscaled integer data provided by the original data provider. For
 example, the NOAA NODC 4km AVHRR Pathfinder version 5.0 dataset
@@ -1814 +1814 @@
   any histogram windows that had sufficiently large numbers of
   non-masked pixels to proceed with the histogramming step of the
-  Cayula-Cornillon algorithm.
+  Cayula and Cornillon algorithm.
 
 * 0 - The pixel was a candidate for containing a front -- it was not
@@ -1855 +1855 @@
     description=_(
 u"""Binary rasters to apply as masks to the input image before running
-the Cayula-Cornillon algorithm on it. Each item in this list
+the Cayula and Cornillon algorithm on it. Each item in this list
 corresponds to parallel entries in the lists of mask data types,
 tests, and values.
@@ -1958 +1958 @@
     description=_(
 u"""Output binary raster that shows the pixels of the input image that
-were masked prior to executing the Cayula-Cornillon algorithm.
+were masked prior to executing the Cayula and Cornillon algorithm.
 
 The file will have the same dimensions as the input image and contain
@@ -2091 +2091 @@
 one of the acceptable ranges.
 
-The Cayula-Cornillon algorithm cannot operate on floating-point data.
+The Cayula and Cornillon algorithm cannot operate on floating-point data.
 If your input raster contains floating-point numbers, use the Map
 Algebra Expression option to instruct this tool to convert the raster
@@ -2165 +2165 @@
   it did not appear in any histogram windows that had sufficiently
   large numbers of pixels that were not NoData in the input image to
-  proceed with the histogramming step of the Cayula-Cornillon
+  proceed with the histogramming step of the Cayula and Cornillon
   algorithm.
 
@@ -2192 +2192 @@
     description=_(
 u"""Map algebra expression to execute on the input raster before
-running the Cayula-Cornillon algorithm.
+running the Cayula and Cornillon algorithm.
 
 **WARNING:** The ArcGIS Geoprocessing Model Builder may randomly and
@@ -2254 +2254 @@
 u"""Window size, in pixels, of the median filter to apply to the input
 image prior to running the histogram analysis step of the
-Cayula-Cornillon algorithm. If not provided, median filtering will not
+Cayula and Cornillon algorithm. If not provided, median filtering will not
 be performed.
 
@@ -2334 +2334 @@
 the number of times it appeared in a histogram window that had a
 sufficiently large number of pixels to proceed with the histogramming
-step of the Cayula-Cornillon algorithm.
+step of the Cayula and Cornillon algorithm.
 
 The raster will contain 16-bit signed integers and have the same
@@ -2442 +2442 @@
 
 Each raster must contain 8-bit or 16-bit integers (signed or
-unsigned). The Cayula-Cornillon algorithm cannot operate on
+unsigned). The Cayula and Cornillon algorithm cannot operate on
 floating-point data. If your input rasters contain floating-point
 numbers, use the Map Algebra Expression option to instruct this tool
@@ -2465 +2465 @@
   it did not appear in any histogram windows that had sufficiently
   large numbers of pixels that were not NoData in the input image to
-  proceed with the histogramming step of the Cayula-Cornillon
+  proceed with the histogramming step of the Cayula and Cornillon
   algorithm.
 
@@ -2493 +2493 @@
 containing fronts, i.e. the number of times the pixels appeared in
 histogram windows that had a sufficiently large number of non-masked
-pixels to proceed with the histogramming step of the Cayula-Cornillon
+pixels to proceed with the histogramming step of the Cayula and Cornillon
 algorithm.
 
@@ -2544 +2544 @@
   it did not appear in any histogram windows that had sufficiently
   large numbers of pixels that were not NoData in the input image to
-  proceed with the histogramming step of the Cayula-Cornillon
+  proceed with the histogramming step of the Cayula and Cornillon
   algorithm.
 
@@ -2602 +2602 @@
 number of times the pixels appeared in histogram windows that had a
 sufficiently large number of pixels to proceed with the histogramming
-step of the Cayula-Cornillon algorithm. If an expression is not
+step of the Cayula and Cornillon algorithm. If an expression is not
 provided, this raster will not be created.
 
@@ -2664 +2664 @@
     constantParamNames=[u'minPopMeanDifference', u'wrapEdges', u'mapAlgebraExpression', u'medianFilterWindowSize', u'histogramWindowSize', u'histogramWindowStride', u'minPropNonMaskedCells', u'minPopProp', u'minTheta', u'minSinglePopCohesion', u'minGlobalPopCohesion', u'threads', u'fillHoles', u'thin', u'minSize'],
     processListMethodName=u'DetectEdgesInArcGISRastersList',
-    processListMethodShortDescription=_(u'Finds fronts in a list of ArcGIS rasters using the Cayula-Cornillon (1992) single-image edge detection algorithm.'),
+    processListMethodShortDescription=_(u'Finds fronts in a list of ArcGIS rasters using the Cayula and Cornillon (1992) single-image edge detection algorithm.'),
     processTableMethodName=u'DetectEdgesInArcGISRastersTable',
-    processTableMethodShortDescription=_(u'Finds fronts in ArcGIS rasters listed in a table using the Cayula-Cornillon (1992) single-image edge detection algorithm.'),
+    processTableMethodShortDescription=_(u'Finds fronts in ArcGIS rasters listed in a table using the Cayula and Cornillon (1992) single-image edge detection algorithm.'),
     processArcGISTableMethodName=u'DetectEdgesInArcGISRastersArcGISTable',
     processArcGISTableMethodArcGISDisplayName=_(u'Cayula-Cornillon Fronts in ArcGIS Rasters Listed in Table'),
     findAndProcessMethodName=u'FindArcGISRastersAndDetectEdges',
     findAndProcessMethodArcGISDisplayName=u'Find ArcGIS Rasters and Find Cayula-Cornillon Fronts',
-    findAndProcessMethodShortDescription=_(u'Finds ArcGIS rasters in a workspace and finds fronts within them using the Cayula-Cornillon (1992) single-image edge detection algorithm.'),
+    findAndProcessMethodShortDescription=_(u'Finds ArcGIS rasters in a workspace and finds fronts within them using the Cayula and Cornillon (1992) single-image edge detection algorithm.'),
     findMethod=ArcGISRaster.FindAndCreateTable,
     findOutputFieldParams=[u'rasterField'],