def test_options_conversion_st_algorithm(self):
        opts = {
            'note': '',
            'etm7_collection': {
                'inputs': ['LE07_L1TP_029030_20171222_20180117_01_T2'],
                'products': ['st']
            },
            'resampling_method': 'nn',
            'format': 'gtiff'
        }
        opts_split_window = deepcopy(opts)
        opts_split_window['etm7_collection']['products'] = [
            'st', 'stalg_split_window'
        ]
        opts_single_chan = deepcopy(opts)
        opts_single_chan['etm7_collection']['products'] = [
            'st', 'stalg_single_channel'
        ]

        self.assertDictEqual(
            OptionsConversion._flatten(opts_split_window,
                                       OptionsConversion.keywords_map), {
                                           'include_st': True,
                                           'output_format': 'gtiff',
                                           'st_algorithm': 'split_window'
                                       })

        self.assertDictEqual(
            OptionsConversion._flatten(opts_single_chan,
                                       OptionsConversion.keywords_map), {
                                           'include_st': True,
                                           'output_format': 'gtiff',
                                           'st_algorithm': 'single_channel'
                                       })
    def test_options_reanalysis_source(self):
        opts = {
            'note': '',
            'etm7_collection': {
                'inputs': ['LE07_L1TP_029030_20171222_20180117_01_T2'],
                'products': ['st']
            },
            'resampling_method': 'nn',
            'format': 'gtiff'
        }

        opts_narr = deepcopy(opts)
        opts_narr['etm7_collection']['products'] = ['st', 'reanalsrc_narr']
        self.assertDictEqual(
            OptionsConversion._flatten(opts_narr,
                                       OptionsConversion.keywords_map), {
                                           'include_st': True,
                                           'output_format': 'gtiff',
                                           'reanalysis_source': 'narr'
                                       })

        opts_merra2 = deepcopy(opts)
        opts_merra2['etm7_collection']['products'] = ['st', 'reanalsrc_merra2']
        self.assertDictEqual(
            OptionsConversion._flatten(opts_merra2,
                                       OptionsConversion.keywords_map), {
                                           'include_st': True,
                                           'output_format': 'gtiff',
                                           'reanalysis_source': 'merra2'
                                       })

        opts_fp = deepcopy(opts)
        opts_fp['etm7_collection']['products'] = ['st', 'reanalsrc_fp']
        self.assertDictEqual(
            OptionsConversion._flatten(opts_fp,
                                       OptionsConversion.keywords_map), {
                                           'include_st': True,
                                           'output_format': 'gtiff',
                                           'reanalysis_source': 'fp'
                                       })

        opts_fpit = deepcopy(opts)
        opts_fpit['etm7_collection']['products'] = ['st', 'reanalsrc_fpit']
        self.assertDictEqual(
            OptionsConversion._flatten(opts_fpit,
                                       OptionsConversion.keywords_map), {
                                           'include_st': True,
                                           'output_format': 'gtiff',
                                           'reanalysis_source': 'fpit'
                                       })
Example #3
0
    def convert(self):
        current_orders = self._retrieve_orders()

        for co in current_orders:
            if not co['product_options']:
                co['product_options'] = '{"include_sr": true}'

            scenes = self._retrieve_scenes(co['id'])

            if not scenes:
                continue

            try:
                prod_opts = OptionsConversion.convert(old=json.loads(
                    co['product_options']),
                                                      scenes=scenes)
            except:
                raise

            self._update_product_opts(json.dumps(prod_opts), co['id'])

        try:
            self.db.commit()
        except:
            raise
    def test_options_conversion_orca_algorithm(self):
        opts = {
            'note': '',
            'olitirs8_collection': {
                'inputs': ['LC08_L1TP_025027_20160521_20170223_01_T1'],
                'products': ['orca']
            },
            'resampling_method': 'nn',
            'format': 'gtiff'
        }

        self.assertDictEqual(
            OptionsConversion._flatten(opts, OptionsConversion.keywords_map), {
                'include_orca': True,
                'output_format': 'gtiff'
            })
    def test_convert_product_options(self):
        """
        Test the conversion procedure to make sure that the new format for orders converts
        to the old format
        """
        scenes = [
            'LE07_L1TP_026027_20170912_20171008_01_T1',
            'LC08_L1TP_025027_20160521_20170223_01_T1',
            'LT05_L1TP_025027_20110913_20160830_01_T1'
        ]

        includes = ['include_sr', 'include_sr_toa', 'include_sr_thermal']

        new_format = {
            u'etm7_collection': {
                u'inputs': [u'LE07_L1TP_026027_20170912_20171008_01_T1'],
                u'products': [u'sr']
            },
            u'olitirs8_collection': {
                u'inputs': [u'LC08_L1TP_025027_20160521_20170223_01_T1'],
                u'products': [u'toa']
            },
            u'tm5_collection': {
                u'inputs': [u'LT05_L1TP_025027_20110913_20160830_01_T1'],
                u'products': [u'bt']
            },
            u'format': u'gtiff',
            u'image_extents': {
                u'east': -2265585.0,
                u'north': 3164805.0,
                u'south': 3014805.0,
                u'units': u'meters',
                u'west': -2415585.0
            },
            u'note': u'CONUS_h1v1',
            u'projection': {
                u'aea': {
                    u'central_meridian': -96,
                    u'datum': u'nad83',
                    u'false_easting': 0,
                    u'false_northing': 0,
                    u'latitude_of_origin': 23,
                    u'standard_parallel_1': 29.5,
                    u'standard_parallel_2': 45.5
                }
            },
            u'resampling_method': u'cc'
        }

        ruberic = {
            'central_meridian': -96,
            'datum': u'nad83',
            'false_easting': 0,
            'false_northing': 0,
            'image_extents': True,
            'image_extents_units': u'meters',
            'include_customized_source_data': False,
            'include_dswe': False,
            'include_st': False,
            'include_solr_index': False,
            'include_source_data': False,
            'include_source_metadata': False,
            'include_sr': False,
            'include_sr_browse': False,
            'include_sr_evi': False,
            'include_sr_msavi': False,
            'include_sr_nbr': False,
            'include_sr_nbr2': False,
            'include_sr_ndmi': False,
            'include_sr_ndvi': False,
            'include_sr_savi': False,
            'include_sr_thermal': False,
            'include_sr_toa': False,
            'include_statistics': False,
            'latitude_true_scale': None,
            'longitude_pole': None,
            'maxx': -2265585.0,
            'maxy': 3164805.0,
            'minx': -2415585.0,
            'miny': 3014805.0,
            'origin_lat': 23,
            'output_format': u'gtiff',
            'pixel_size': None,
            'pixel_size_units': None,
            'reproject': True,
            'resample_method': 'cubic',
            'resize': False,
            'std_parallel_1': 29.5,
            'std_parallel_2': 45.5,
            'target_projection': u'aea',
            'utm_north_south': None,
            'utm_zone': None
        }

        for scene, include in zip(scenes, includes):
            ruberic[include] = True
            old_format = OptionsConversion.convert(new=new_format,
                                                   scenes=[scene])

            self.assertDictEqual(ruberic, old_format)

            ruberic[include] = False
    def test_convert_product_options(self):
        """
        Test the conversion procedure to make sure that the new format for orders converts
        to the old format
        """
        scenes = ['LE70480272012076EDC00', 'LC80500272013196LGN00',
                  'LT40480271983028PAC00', 'LT50490262009162PAC03']

        includes = ['include_sr', 'include_sr_toa',
                    'include_cfmask', 'include_sr_thermal']

        new_format = {u'etm7': {u'inputs': [u'LE70480272012076EDC00'],
                                u'products': [u'sr']},
                      u'olitirs8': {u'inputs': [u'LC80500272013196LGN00'],
                                    u'products': [u'toa']},
                      u'tm4': {u'inputs': [u'LT40480271983028PAC00'],
                               u'products': [u'cloud']},
                      u'tm5': {u'inputs': [u'LT50490262009162PAC03'],
                               u'products': [u'bt']},
                      u'format': u'gtiff',
                      u'image_extents': {u'east': -2265585.0,
                                         u'north': 3164805.0,
                                         u'south': 3014805.0,
                                         u'units': u'meters',
                                         u'west': -2415585.0},
                      u'note': u'CONUS_h1v1',

                      u'projection': {u'aea': {u'central_meridian': -96,
                                               u'datum': u'nad83',
                                               u'false_easting': 0,
                                               u'false_northing': 0,
                                               u'latitude_of_origin': 23,
                                               u'standard_parallel_1': 29.5,
                                               u'standard_parallel_2': 45.5}},
                      u'resampling_method': u'cc'}

        ruberic = {'central_meridian': -96,
                   'datum': u'nad83',
                   'false_easting': 0,
                   'false_northing': 0,
                   'image_extents': True,
                   'image_extents_units': u'meters',
                   'include_cfmask': False,
                   'include_customized_source_data': False,
                   'include_dswe': False,
                   'include_lst': False,
                   'include_solr_index': False,
                   'include_source_data': False,
                   'include_source_metadata': False,
                   'include_sr': False,
                   'include_sr_browse': False,
                   'include_sr_evi': False,
                   'include_sr_msavi': False,
                   'include_sr_nbr': False,
                   'include_sr_nbr2': False,
                   'include_sr_ndmi': False,
                   'include_sr_ndvi': False,
                   'include_sr_savi': False,
                   'include_sr_thermal': False,
                   'include_sr_toa': False,
                   'include_statistics': False,
                   'latitude_true_scale': None,
                   'longitude_pole': None,
                   'maxx': -2265585.0,
                   'maxy': 3164805.0,
                   'minx': -2415585.0,
                   'miny': 3014805.0,
                   'origin_lat': 23,
                   'output_format': u'gtiff',
                   'pixel_size': None,
                   'pixel_size_units': None,
                   'reproject': True,
                   'resample_method': 'cubic',
                   'resize': False,
                   'std_parallel_1': 29.5,
                   'std_parallel_2': 45.5,
                   'target_projection': u'aea',
                   'utm_north_south': None,
                   'utm_zone': None}

        for scene, include in zip(scenes, includes):
            ruberic[include] = True
            old_format = OptionsConversion.convert(new=new_format, scenes=[scene])

            self.assertDictEqual(ruberic, old_format)

            ruberic[include] = False