apps/CameraITS/tests/scene2_a/test_exposure_keys_consistent.py

# Copyright 2025 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Validate that exposure values agree when AE is either on or off."""

import logging
import os.path
import camera_properties_utils
import capture_request_utils
import image_processing_utils
import its_base_test
import its_session_utils
import matplotlib.pyplot as plt
from mobly import test_runner
import numpy as np
from scipy.ndimage import gaussian_filter

_NAME = os.path.splitext(os.path.basename(__file__))[0]
_SAD_THRESHOLD = 0.04  # Images should not be >= 4% different
_JPG_FORMAT = 'jpg'


def calc_avg_exposure_sad(cap_no_ae, cap_ae, name_with_log_path):
  """Calculate the avg SAD of the AE capture and the non-AE capture.

  Calculates the sum of absolute difference (SAD) for the two images averaged
  by the number of pixels.

  Args:
    cap_no_ae: Camera capture object without auto exposure.
    cap_ae: Camera capture object with auto exposure.
    name_with_log_path: File name with path to write image.

  Returns:
    The average sum of absolute differences for the two images.
  """
  suffix = f'_fmt={_JPG_FORMAT}.{_JPG_FORMAT}'
  img_no_ae = image_processing_utils.decompress_jpeg_to_yuv_image(cap_no_ae)
  image_processing_utils.write_image(
      img_no_ae, f'{name_with_log_path}_no_ae{suffix}', is_yuv=True
  )

  img_ae = image_processing_utils.decompress_jpeg_to_yuv_image(cap_ae)
  image_processing_utils.write_image(
      img_ae, f'{name_with_log_path}{suffix}', is_yuv=True
  )

  luma_no_ae = img_no_ae[:, :, 0:1]
  image_processing_utils.write_image(
      luma_no_ae, f'{name_with_log_path}_luma_no_ae{suffix}'
  )

  luma_ae = img_ae[:, :, 0:1]
  image_processing_utils.write_image(
      luma_ae, f'{name_with_log_path}_luma{suffix}'
  )

  # Blur the captures to remove noise
  luma_no_ae_blur = gaussian_filter(luma_no_ae, sigma=3)
  image_processing_utils.write_image(
      luma_no_ae_blur, f'{name_with_log_path}_luma_no_ae_blur{suffix}'
  )

  luma_ae_blur = gaussian_filter(luma_ae, sigma=3)
  image_processing_utils.write_image(
      luma_ae_blur, f'{name_with_log_path}_luma_blur{suffix}'
  )

  luma_sad = np.abs(np.subtract(luma_no_ae_blur, luma_ae_blur))
  fig, ax = plt.subplots()
  im = ax.imshow(luma_sad, cmap='Reds')
  cbar = fig.colorbar(im, ax=ax)
  cbar.set_label('SAD')
  plt.savefig(f'{name_with_log_path}_sad.png', dpi=300, bbox_inches='tight')

  # Calculate the sum of absolute difference, take the average per pixel.
  avg_sad = np.sum(
      np.abs(np.subtract(luma_ae_blur, luma_no_ae_blur))
  ) / (img_ae.shape[0] * img_ae.shape[1])

  return avg_sad


class ExposureKeysConsistentTest(its_base_test.ItsBaseTest):
  """Test for inconsistencies in exposure metadata and the resulting image.

  Uses JPEG captures as the output format.

  Steps:
  - Takes one capture with auto exposure on.
  - Using values the above CaptureResult, applies the following keys to a
  capture
    request with auto exposure off:
        - Sensor sensitivity
        - Post raw sensitivity boost
        - Exposure time
        - Frame duration
  - Validates that the two images are roughly the same via SAD.
  """

  def test_exposure_keys_consistent(self):
    logging.debug('Starting %s', _NAME)

    with its_session_utils.ItsSession(
        device_id=self.dut.serial,
        camera_id=self.camera_id,
        hidden_physical_id=self.hidden_physical_id,
    ) as cam:
      props = cam.get_camera_properties()
      props = cam.override_with_hidden_physical_camera_props(props)
      log_path = self.log_path
      name_with_log_path = os.path.join(log_path, _NAME)

      # Load chart for scene
      its_session_utils.load_scene(
          cam, props, self.scene, self.tablet, self.chart_distance
      )

      # Capture for each available reprocess format
      sizes = capture_request_utils.get_available_output_sizes(
          _JPG_FORMAT, props
      )
      size = sizes[0]

      camera_properties_utils.skip_unless(
          size is not None and
          camera_properties_utils.manual_sensor(props)
      )

      logging.info('capture width: %d', size[0])
      logging.info('capture height: %d', size[1])
      out_surface = {'width': size[0], 'height': size[1], 'format': _JPG_FORMAT}

      # Create req, do caps and determine SAD
      req = capture_request_utils.auto_capture_request()
      req['android.control.aeMode'] = 1  # ON
      cam.do_3a()
      cap_ae = cam.do_capture([req], out_surface, reuse_session=True)[0]
      cr = cap_ae['metadata']
      sensor_sensitivity = cr['android.sensor.sensitivity']
      exposure_time = cr['android.sensor.exposureTime']
      post_raw_sensitivity_boost = cr['android.control.postRawSensitivityBoost']
      frame_duration = cr['android.sensor.frameDuration']

      camera_properties_utils.skip_unless(
          post_raw_sensitivity_boost is not None
      )

      logging.info('sensor_sensitivity: %s', sensor_sensitivity)
      logging.info('exposure_time: %s', exposure_time)
      logging.info('post_raw_sensitivity_boost: %s', post_raw_sensitivity_boost)
      logging.info('frame_duration: %s', frame_duration)

      req['android.control.aeMode'] = 0  # OFF
      req['android.sensor.sensitivity'] = sensor_sensitivity
      req['android.sensor.exposureTime'] = exposure_time
      req['android.control.postRawSensitivityBoost'] = (
          post_raw_sensitivity_boost
      )
      req['android.sensor.frameDuration'] = frame_duration
      cap_no_ae = cam.do_capture([req], out_surface, reuse_session=True)[0]

      cr_no_ae = cap_no_ae['metadata']
      post_raw_sensitivity_boost_no_ae = cr_no_ae[
          'android.control.postRawSensitivityBoost'
      ]
      logging.info(
          '(no ae) post_raw_sensitivity_boost: %s',
          post_raw_sensitivity_boost_no_ae
      )
      camera_properties_utils.skip_unless(
          post_raw_sensitivity_boost_no_ae is not None
          and post_raw_sensitivity_boost == post_raw_sensitivity_boost_no_ae
      )

      sad = calc_avg_exposure_sad(
          cap_no_ae['data'], cap_ae['data'], name_with_log_path
      )

      logging.info('Avg SAD: %s (threshold: %s)', sad, _SAD_THRESHOLD)
      if sad > _SAD_THRESHOLD:
        raise AssertionError(
            f'Avg SAD greater than threshold: {sad} / {_SAD_THRESHOLD}'
        )


if __name__ == '__main__':
  test_runner.main()