Merge branch 'ngageoint:staging' into staging

Author: petersontex

sarpy/processing/sidd/sidd_product_creation.py

@@ -167,7 +167,7 @@ def create_detected_image_sidd(
     ortho_bounds = ortho_iterator.ortho_bounds
     sidd_structure = create_sidd_structure(
         ortho_helper, ortho_bounds,
-        product_class='Detected Image', pixel_type='MONO{}I'.format(remap_function.bit_depth), remap_function=remap_function, version=version) 
+        product_class='Detected Image', pixel_type='MONO{}I'.format(remap_function.bit_depth), version=version, remap_function=remap_function) 
     # set suggested name
     sidd_structure.NITF['SUGGESTED_NAME'] = ortho_helper.sicd.get_suggested_name(ortho_helper.index)+'_IMG'
 
@@ -256,7 +256,7 @@ def create_csi_sidd(
     ortho_bounds = ortho_iterator.ortho_bounds
     sidd_structure = create_sidd_structure(
         ortho_helper, ortho_bounds,
-        product_class='Color Subaperture Image', pixel_type='RGB24I', version=version)
+        product_class='Color Subaperture Image', pixel_type='RGB24I', version=version, remap_function=remap_function)
     # set suggested name
     sidd_structure.NITF['SUGGESTED_NAME'] = csi_calculator.sicd.get_suggested_name(csi_calculator.index)+'_CSI'
 
@@ -352,7 +352,7 @@ def create_dynamic_image_sidd(
     ortho_bounds = ortho_iterator.ortho_bounds
     sidd_structure = create_sidd_structure(
         ortho_helper, ortho_bounds,
-        product_class='Dynamic Image', pixel_type='MONO{}I'.format(remap_function.bit_depth), version=version)
+        product_class='Dynamic Image', pixel_type='MONO{}I'.format(remap_function.bit_depth), version=version, remap_function=remap_function)
     # set suggested name
     sidd_structure.NITF['SUGGESTED_NAME'] = subap_calculator.sicd.get_suggested_name(subap_calculator.index)+'__DI'
     the_sidds = []

sarpy/processing/sidd/sidd_structure_creation.py

@@ -521,7 +521,7 @@ def _create_exploitation_v1():
 ##########################
 # Switchable version SIDD structure
 
-def create_sidd_structure(ortho_helper, bounds, product_class, pixel_type,  remap_function=None, version=3):
+def create_sidd_structure(ortho_helper, bounds, product_class, pixel_type, version=3, remap_function=None):
     """
     Create a SIDD structure, with version specified, based on the orthorectification
     helper and pixel bounds.

sarpy/visualization/remap.py

@@ -33,7 +33,6 @@ class based solution which allows state variables associated with the remap
 
 _DEFAULTS_REGISTERED = False
 _REMAP_DICT = OrderedDict()  # type: Dict[str, RemapFunction]
-newRegMap   = OrderedDict() 
 
 ###########
 # helper functions
@@ -1828,12 +1827,17 @@ def register_remap(
     """
 
     if isinstance(remap_function, type) and issubclass(remap_function, RemapFunction):
-        remap_function = remap_function()
+        remap_function = remap_function( bit_depth=bit_depth)
     if not isinstance(remap_function, RemapFunction):
         raise TypeError('remap_function must be an instance of RemapFunction.')
 
-    remap_name = remap_function.name
+    
+    if remap_function.bit_depth == 16:
+        remap_name = remap_function.name + '_' + str( remap_function.bit_depth )
+    else:
+        remap_name = remap_function.name 
 
+            
     if remap_name not in _REMAP_DICT:
         _REMAP_DICT[remap_name] = remap_function
     elif overwrite:
@@ -1848,15 +1852,25 @@ def _register_defaults():
     if _DEFAULTS_REGISTERED:
         return
 
-    # register class as opposed to instance of class that it was
-    register_remap(NRL,             overwrite=False )
-    register_remap(Linear,          overwrite=False )
-    register_remap(Density,         overwrite=False )
-    register_remap(High_Contrast,   overwrite=False )
-    register_remap(Brighter,        overwrite=False )
-    register_remap(Darker,          overwrite=False )
-    register_remap(Logarithmic,     overwrite=False )
-    register_remap(PEDF,            overwrite=False )
+    # register instance of class 
+    register_remap(NRL(             bit_depth=8), overwrite=False)
+    register_remap(Density(         bit_depth=8), overwrite=False)
+    register_remap(High_Contrast(   bit_depth=8), overwrite=False)
+    register_remap(Brighter(        bit_depth=8), overwrite=False)
+    register_remap(Darker(          bit_depth=8), overwrite=False)
+    register_remap(Linear(          bit_depth=8), overwrite=False)
+    register_remap(Logarithmic(     bit_depth=8), overwrite=False)
+    register_remap(PEDF(            bit_depth=8), overwrite=False)
+
+    register_remap(NRL(             bit_depth=16), overwrite=False)
+    register_remap(Density(         bit_depth=16), overwrite=False)
+    register_remap(High_Contrast(   bit_depth=16), overwrite=False)
+    register_remap(Brighter(        bit_depth=16), overwrite=False)
+    register_remap(Darker(          bit_depth=16), overwrite=False)
+    register_remap(Linear(          bit_depth=16), overwrite=False)
+    register_remap(Logarithmic(     bit_depth=16), overwrite=False)
+    register_remap(PEDF(            bit_depth=16), overwrite=False)
+
 
     if plt is not None:
         try:
@@ -1875,32 +1889,6 @@ def _register_defaults():
             register_remap(LUT8bit(NRL(bit_depth=8), 'bone', use_alpha=False), overwrite=False)
         except KeyError:
             pass
-    # joz
-    newRegMap[ 'nrl'           ] = NRL
-    newRegMap[ 'linear'        ] = Linear
-    newRegMap[ 'density'       ] = Density
-    newRegMap[ 'high_contrast' ] = High_Contrast
-    newRegMap[ 'brighter'      ] = Brighter
-    newRegMap[ 'darker'        ] = Darker
-    newRegMap[ 'log'           ] = Logarithmic
-    newRegMap[ 'pedf'          ] = PEDF
-    if plt is not None:
-        try:
-            newRegMap[ 'viridis' ] = LUT8bit(NRL(bit_depth=8), 'viridis', use_alpha=False)
-        except KeyError:
-            pass
-        try:
-            newRegMap[ 'magma' ]   = LUT8bit(NRL(bit_depth=8), 'magma', use_alpha=False)
-        except KeyError:
-            pass
-        try:
-            newRegMap[ 'rainbow' ] = LUT8bit(NRL(bit_depth=8), 'rainbow', use_alpha=False)
-        except KeyError:
-            pass
-        try:
-            newRegMap[ 'bone' ]    = LUT8bit(NRL(bit_depth=8), 'bone', use_alpha=False)
-        except KeyError:
-            pass
 
     _DEFAULTS_REGISTERED = True
 
@@ -1916,7 +1904,7 @@ def get_remap_names() -> List[str]:
 
     if not _DEFAULTS_REGISTERED:
         _register_defaults()
-    return list(newRegMap.keys())
+    return list( _REMAP_DICT.keys())
 
 
 def get_remap_list() -> List[Tuple[str, RemapFunction]]:
@@ -1940,10 +1928,10 @@ def get_remap_list() -> List[Tuple[str, RemapFunction]]:
 
 def get_registered_remap(
         remap_name: str,
-        bit_depth=8,
-        default: Optional[RemapFunction] = None) -> RemapFunction:
+        default: Optional[RemapFunction] = None,
+        bit_depth=8)             -> RemapFunction:
     """
-    Gets a remap Class/constructor/init from it's registered name.
+    Gets a remap instance via its registered name.
     # add 16 bit ability by newRegMap is dict of class/constructors
 
 
@@ -1963,15 +1951,18 @@ def get_registered_remap(
 
     if not _DEFAULTS_REGISTERED:
         _register_defaults()
+
+    if int( bit_depth ) not in [ 8, 16 ]:
+        raise KeyError('Unregistered remap name `{}` with bit_depth `{}`'.format( remap_name, bit_depth ))
+        
+    if int( bit_depth ) == 16:
+        rm_name = remap_name + '_' + str( bit_depth )
+    else:
+        rm_name = remap_name 
+        
+    if rm_name in _REMAP_DICT:
+        return _REMAP_DICT[ rm_name ]
 
-    if remap_name in newRegMap:
-        # Try new regerst map return  class/Constructor
-        myFunc   = newRegMap[ remap_name ]
-        newRemap = myFunc( remap_name, bit_depth)
-        return newRemap
-
-    if remap_name in _REMAP_DICT:
-        return _REMAP_DICT[remap_name]
     if default is not None:
         return default
     raise KeyError('Unregistered remap name `{}`'.format(remap_name))

tests/visualization/test_remap.py

@@ -329,8 +329,31 @@ def test_remap_names(self):
     def test_get_registered_remap(self):
         with self.assertRaises(KeyError):
             remap.get_registered_remap("__fake__")
-        self.assertEqual(remap.get_registered_remap("__fake__", "default"), "default")
+        self.assertEqual(remap.get_registered_remap("__fake__", "default", 8 ), "default")
+
+    def test_get_registered_remap_required_param_only(self):
+        self.assertEqual(remap.get_registered_remap("linear" ).name, "linear")
+     
+    def test_get_registered_remap_required_param_default(self):
+        self.assertEqual(remap.get_registered_remap("linear", "default" ).name, "linear")
+ 
+    def test_get_registered_remap_required_param_default_bit_depth(self):
+        self.assertEqual(remap.get_registered_remap("linear" ).name, "linear")
+        self.assertEqual(remap.get_registered_remap("linear" ).bit_depth, 8)
+
+
+    def test_get_registered_remap_bitdepth_param(self):
+        self.assertEqual(remap.get_registered_remap("linear", bit_depth= 16 ).name, "linear")
+        self.assertEqual(remap.get_registered_remap("linear", bit_depth= 16 ).bit_depth, 16)
+ 
+    def test_get_registered_remap_falure_bitdepth_param(self):
+        with self.assertRaises(KeyError):
+            remap.get_registered_remap("linear", bit_depth= 32 )
 
+    def test_get_registered_remap_falure_not_registered(self):
+        with self.assertRaises(KeyError):
+            remap.get_registered_remap("steve" )
+    
     def test_get_remap_list(self):
         remap_list = remap.get_remap_list()
         self.assertSetEqual(set(item[0] for item in remap_list), set(remap.get_remap_names()))