示例#1
0
    def test_command_run_with_mocks(self):
        with RVConfig.get_tmp_dir() as tmp_dir:
            predict_package_uri = os.path.join(tmp_dir, 'predict_package.zip')

            task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build()

            backend_config = rv.BackendConfig.builder(mk.MOCK_BACKEND).build()
            scene = mk.create_mock_scene()
            analyzer_config = rv.AnalyzerConfig.builder(
                mk.MOCK_ANALYZER).build()

            cmd_conf = rv.command.rv.CommandConfig.builder(rv.BUNDLE) \
                                                  .with_task(task_config) \
                                                  .with_backend(backend_config) \
                                                  .with_scene(scene) \
                                                  .with_analyzers([analyzer_config]) \
                                                  .with_root_uri('.') \
                                                  .build()

            cmd_conf = rv.command.CommandConfig.from_proto(cmd_conf.to_proto())

            cmd_conf.task.predict_package_uri = predict_package_uri
            analyzer_config = cmd_conf.analyzers[0]

            cmd = cmd_conf.create_command()

            cmd.run()

            self.assertTrue(os.path.exists(predict_package_uri))
            self.assertTrue(analyzer_config.mock.save_bundle_files.called)
示例#2
0
    def test_with_aoi(self):
        aoi_uri = data_file_path('evaluator/cc-label-aoi.json')
        task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build()

        scene_config = mk.create_mock_scene()
        scene_config = scene_config.to_builder().with_aoi_uri(aoi_uri).build()
        scene = scene_config.create_scene(task_config, self.temp_dir.name)
        self.assertEqual(1, len(scene.aoi_polygons))
示例#3
0
 def test_with_aoi_back_compat(self):
     aoi_uri = data_file_path('evaluator/cc-label-aoi.json')
     task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build()
     scene_config = mk.create_mock_scene()
     scene_msg = scene_config.to_proto()
     # Use deprecated aoi_uri field.
     del scene_msg.aoi_uris[:]
     scene_msg.aoi_uri = aoi_uri
     scene_config = rv.SceneConfig.from_proto(scene_msg)
     scene = scene_config.create_scene(task_config, self.temp_dir.name)
     self.assertEqual(1, len(scene.aoi_polygons))
    def test_command_run_with_mocks(self):
        task = rv.TaskConfig.builder(mk.MOCK_TASK).build()
        scene = mk.create_mock_scene()
        analyzer_config = rv.AnalyzerConfig.builder(mk.MOCK_ANALYZER).build()
        analyzer = analyzer_config.create_analyzer()
        analyzer_config.mock.create_analyzer.return_value = analyzer
        cmd = rv.command.AnalyzeCommandConfig.builder() \
                                             .with_task(task) \
                                             .with_scenes([scene]) \
                                             .with_root_uri('.') \
                                             .with_analyzers([analyzer_config]) \
                                             .build() \
                                             .create_command()
        cmd.run()

        self.assertTrue(analyzer.mock.process.called)
    def test_command_run_with_mocks(self):
        task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build()
        scene = mk.create_mock_scene()
        evaluator_config = rv.EvaluatorConfig.builder(
            mk.MOCK_EVALUATOR).build()
        evaluator = evaluator_config.create_evaluator()
        evaluator_config.mock.create_evaluator.return_value = evaluator

        cmd = rv.command.EvalCommandConfig.builder() \
                                          .with_task(task_config) \
                                          .with_scenes([scene]) \
                                          .with_evaluators([evaluator_config]) \
                                          .with_root_uri('.') \
                                          .build() \
                                          .create_command()
        cmd.run()

        self.assertTrue(evaluator.mock.process.called)
示例#6
0
    def test_command_run_with_mocks(self):
        task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build()
        backend_config = rv.BackendConfig.builder(mk.MOCK_BACKEND).build()
        backend = backend_config.create_backend(task_config)
        task = task_config.create_task(backend)
        task_config.mock.create_task.return_value = task
        backend_config.mock.create_backend.return_value = backend
        scene = mk.create_mock_scene()
        cmd = rv.CommandConfig.builder(rv.CHIP) \
                              .with_task(task_config) \
                              .with_backend(backend_config) \
                              .with_train_scenes([scene]) \
                              .with_val_scenes([scene]) \
                              .with_root_uri('.') \
                              .build() \
                              .create_command()
        cmd.run()

        self.assertTrue(task.mock.get_train_windows.called)
        self.assertTrue(backend.mock.process_sceneset_results.called)
    def test_command_run_with_mocks(self):
        task_config = rv.TaskConfig.builder(mk.MOCK_TASK).build()
        backend_config = rv.BackendConfig.builder(mk.MOCK_BACKEND).build()
        backend = backend_config.create_backend(task_config)
        backend_config.mock.create_backend.return_value = backend
        task = task_config.create_task(backend)
        task_config.mock.create_task.return_value = task
        scene = mk.create_mock_scene()

        task.mock.get_predict_windows.return_value = [Box(0, 0, 1, 1)]

        cmd = rv.CommandConfig.builder(rv.PREDICT) \
                              .with_task(task_config) \
                              .with_backend(backend_config) \
                              .with_scenes([scene]) \
                              .with_root_uri('.') \
                              .build() \
                              .create_command()
        cmd.run()

        self.assertTrue(backend.mock.predict.called)