Source code for colour.quality.cqs

"""
Colour Quality Scale
====================

Define the *Colour Quality Scale* (CQS) computation objects.

-   :class:`colour.quality.ColourRendering_Specification_CQS`
-   :func:`colour.colour_quality_scale`

References
----------
-   :cite:`Davis2010a` : Davis, W., & Ohno, Y. (2010). Color quality scale.
    Optical Engineering, 49(3), 033602. doi:10.1117/1.3360335
-   :cite:`Ohno2008a` : Ohno, Yoshiro, & Davis, W. (2008). NIST CQS simulation
    (Version 7.4) [Computer software].
    https://drive.google.com/file/d/1PsuU6QjUJjCX6tQyCud6ul2Tbs8rYWW9/view?\
usp=sharing
-   :cite:`Ohno2013` : Ohno, Yoshiro, & Davis, W. (2008). NIST CQS simulation
    (Version 7.4) [Computer software].
    https://drive.google.com/file/d/1PsuU6QjUJjCX6tQyCud6ul2Tbs8rYWW9/view?\
usp=sharing
"""

from __future__ import annotations

import typing
from dataclasses import dataclass

from colour.adaptation import chromatic_adaptation_VonKries
from colour.algebra import euclidean_distance, sdiv, sdiv_mode
from colour.colorimetry import (
    CCS_ILLUMINANTS,
    MSDS_CMFS,
    SPECTRAL_SHAPE_DEFAULT,
    CIE_illuminant_D_series,
    MultiSpectralDistributions,
    SpectralDistribution,
    msds_to_XYZ,
    planck_law,
    reshape_msds,
    reshape_sd,
    sd_to_XYZ,
)

if typing.TYPE_CHECKING:
    from colour.hints import (
        ArrayLike,
        Dict,
        Literal,
        NDArrayFloat,
        Tuple,
    )

from colour.models import Lab_to_LCHab  # pyright: ignore
from colour.models import UCS_to_uv, XYZ_to_Lab, XYZ_to_UCS, XYZ_to_xy, xy_to_XYZ
from colour.quality.datasets.vs import INDEXES_TO_NAMES_VS, SDS_VS
from colour.temperature import CCT_to_xy_CIE_D, uv_to_CCT_Ohno2013
from colour.utilities import (
    array_namespace,
    as_float_array,
    as_float_scalar,
    domain_range_scale,
    suppress_warnings,
    tsplit,
    validate_method,
    xp_as_float_array,
    xp_average,
    xp_matrix_transpose,
)
from colour.utilities.documentation import DocstringTuple, is_documentation_building

__author__ = "Colour Developers"
__copyright__ = "Copyright 2013 Colour Developers"
__license__ = "BSD-3-Clause - https://opensource.org/licenses/BSD-3-Clause"
__maintainer__ = "Colour Developers"
__email__ = "colour-developers@colour-science.org"
__status__ = "Production"

__all__ = [
    "GAMUT_AREA_D65",
    "DataColorimetry_VS",
    "DataColourQualityScale_VS",
    "ColourRendering_Specification_CQS",
    "COLOUR_QUALITY_SCALE_METHODS",
    "colour_quality_scale",
    "gamut_area",
    "vs_colorimetry_data",
    "CCT_factor",
    "scale_conversion",
    "delta_E_RMS",
    "colour_quality_scales",
]

GAMUT_AREA_D65: int = 8210
"""Gamut area for *CIE Illuminant D Series D65*."""


@dataclass
class DataColorimetry_VS:
    """
    Store colorimetry data for *VS test colour samples*.

    This dataclass encapsulates the colorimetric measurements and derived
    values for Visual Spectrum (VS) test colour samples used in colour
    quality evaluation.

    Attributes
    ----------
    name
        Sample identifier or designation.
    XYZ
        Tristimulus values under the test illuminant.
    Lab
        *CIE L\\*a\\*b\\** colour space coordinates.
    C
        Chroma values calculated from the *CIE L\\*a\\*b\\** coordinates.
    """

    name: str
    XYZ: NDArrayFloat
    Lab: NDArrayFloat
    C: NDArrayFloat


@dataclass
class DataColourQualityScale_VS:
    """
    Store colour quality scale data for *VS test colour samples*.

    This dataclass encapsulates the colour quality metrics computed for VS
    (Visual Samples) test colour samples, including quality assessment and
    colour difference measurements used in colour rendering evaluations.

    Attributes
    ----------
    name
        Identifier or descriptor for the test colour sample.
    Q_a
        Colour quality scale value for the sample.
    D_C_ab
        Chroma difference in *CIE L\\*a\\*b\\** colourspace.
    D_E_ab
        Total colour difference in *CIE L\\*a\\*b\\** colourspace.
    """

    name: str
    Q_a: float
    D_C_ab: float
    D_E_ab: float
    D_Ep_ab: float


[docs] @dataclass class ColourRendering_Specification_CQS: """ Define the *Colour Quality Scale* (CQS) colour rendering (quality) specification. Parameters ---------- name Name of the test spectral distribution. Q_a Colour quality scale :math:`Q_a`. Q_f Colour fidelity scale :math:`Q_f` intended to evaluate the fidelity of object colour appearances (compared to the reference illuminant of the same correlated colour temperature and illuminance). Q_p Colour preference scale :math:`Q_p` similar to colour quality scale :math:`Q_a` but placing additional weight on preference of object colour appearance, set to *None* in *NIST CQS 9.0* method. This metric is based on the notion that increases in chroma are generally preferred and should be rewarded. Q_g Gamut area scale :math:`Q_g` representing the relative gamut formed by the (:math:`a^*`, :math:`b^*`) coordinates of the 15 samples illuminated by the test light source in the *CIE L\\*a\\*b\\** object colourspace. Q_d Relative gamut area scale :math:`Q_d`, set to *None* in *NIST CQS 9.0* method. Q_as Individual *Colour Quality Scale* (CQS) data for each sample. colorimetry_data Colorimetry data for the test and reference computations. References ---------- :cite:`Davis2010a`, :cite:`Ohno2008a`, :cite:`Ohno2013` """ name: str Q_a: float Q_f: float Q_p: float | None Q_g: float Q_d: float | None Q_as: Dict[int, DataColourQualityScale_VS] colorimetry_data: Tuple[ Tuple[DataColorimetry_VS, ...], Tuple[DataColorimetry_VS, ...] ]
COLOUR_QUALITY_SCALE_METHODS: tuple = ("NIST CQS 7.4", "NIST CQS 9.0") if is_documentation_building(): # pragma: no cover COLOUR_QUALITY_SCALE_METHODS = DocstringTuple(COLOUR_QUALITY_SCALE_METHODS) COLOUR_QUALITY_SCALE_METHODS.__doc__ = """ Supported *Colour Quality Scale* (CQS) computation methods. References ---------- :cite:`Davis2010a`, :cite:`Ohno2008a`, :cite:`Ohno2013` """ @typing.overload def colour_quality_scale( sd_test: SpectralDistribution, additional_data: Literal[False] = False, method: Literal["NIST CQS 7.4", "NIST CQS 9.0"] | str = ..., ) -> float: ... @typing.overload def colour_quality_scale( sd_test: SpectralDistribution, additional_data: Literal[True], method: Literal["NIST CQS 7.4", "NIST CQS 9.0"] | str = ..., ) -> ColourRendering_Specification_CQS: ... @typing.overload def colour_quality_scale( sd_test: MultiSpectralDistributions, additional_data: Literal[False] = False, method: Literal["NIST CQS 7.4", "NIST CQS 9.0"] | str = ..., ) -> NDArrayFloat: ...
[docs] def colour_quality_scale( sd_test: SpectralDistribution | MultiSpectralDistributions, additional_data: bool = False, method: Literal["NIST CQS 7.4", "NIST CQS 9.0"] | str = "NIST CQS 9.0", ) -> float | NDArrayFloat | ColourRendering_Specification_CQS: """ Compute the *Colour Quality Scale* (CQS) of the specified spectral distribution using the specified method. Parameters ---------- sd_test Test spectral distribution. A :class:`colour.MultiSpectralDistributions` of ``N`` test illuminants is also accepted, in which case ``additional_data`` must be ``False`` and the return value is a :class:`numpy.ndarray` of ``N`` :math:`Q_a` values. additional_data Whether to output additional data. method Computation method. Returns ------- :class:`float`, :class:`numpy.ndarray` or \ :class:`colour.quality.ColourRendering_Specification_CQS` *Colour Quality Scale* (CQS). Notes ----- - The score is piecewise differentiable with respect to the test spectral values while the reference-illuminant branch remains unchanged. Its derivative is undefined where that selection changes. References ---------- :cite:`Davis2010a`, :cite:`Ohno2008a`, :cite:`Ohno2013` Examples -------- >>> from colour import SDS_ILLUMINANTS >>> sd = SDS_ILLUMINANTS["FL2"] >>> colour_quality_scale(sd) # doctest: +ELLIPSIS np.float64(64.1118220...) """ method = validate_method(method, tuple(COLOUR_QUALITY_SCALE_METHODS)) cmfs = reshape_msds( MSDS_CMFS["CIE 1931 2 Degree Standard Observer"], SPECTRAL_SHAPE_DEFAULT, copy=False, ) shape = cmfs.shape vs_sds = { sd.name: reshape_sd(sd, shape, copy=False) for sd in SDS_VS[method].values() } is_msds = isinstance(sd_test, MultiSpectralDistributions) if is_msds and additional_data: error = ( '"additional_data=True" is not supported when "sd_test" is a ' '"MultiSpectralDistributions" instance.' ) raise NotImplementedError(error) if is_msds: sd_test = reshape_msds(sd_test, shape, copy=False) sd_test_values = sd_test.values xp = array_namespace(sd_test_values) test_values = xp_matrix_transpose( xp_as_float_array(sd_test_values, xp=xp), xp=xp ) else: sd_test = reshape_sd(sd_test, shape, copy=False) sd_test_values = sd_test.values xp = array_namespace(sd_test_values) test_values = xp_as_float_array(sd_test_values, xp=xp)[None, :] with domain_range_scale("1"): XYZ = ( msds_to_XYZ(test_values, cmfs, method="Integration", shape=shape) if is_msds else sd_to_XYZ(sd_test, cmfs)[None, :] ) uv = UCS_to_uv(XYZ_to_UCS(XYZ)) CCT = uv_to_CCT_Ohno2013(uv)[..., 0] # ``planck_law`` squeezes its output, so a single-CCT batch collapses # to 1-D; the sample axis is reinstated below. planckian = planck_law(shape.wavelengths * 1e-9, CCT) * 1e-9 planckian_values = ( planckian[None, :] if planckian.ndim == 1 else xp_matrix_transpose(planckian, xp=xp) ) # See :mod:`colour.quality.cri` for the warning-suppression rationale. with suppress_warnings(colour_usage_warnings=True): daylight = CIE_illuminant_D_series(CCT_to_xy_CIE_D(CCT), shape=shape) daylight_values = ( daylight[None, :] if daylight.ndim == 1 else xp_matrix_transpose(daylight, xp=xp) ) ref_values = xp.where(CCT[..., None] < 5000, planckian_values, daylight_values) test_names, test_XYZ, test_Lab, test_C = _vs_colorimetry_data( test_values, ref_values, vs_sds, cmfs, chromatic_adaptation=True ) ref_names, ref_XYZ, ref_Lab, ref_C = _vs_colorimetry_data( ref_values, ref_values, vs_sds, cmfs ) D_C_ab = test_C - ref_C D_E_ab = euclidean_distance(test_Lab, ref_Lab) # ``D_E_ab ** 2 >= D_C_ab ** 2`` by Pythagoras; the inner ``xp.where`` # guards ``xp.sqrt`` against floating-point cancellation, not a colour # data clamp. D_Ep_squared = D_E_ab**2 - D_C_ab**2 D_Ep_ab = xp.where( D_C_ab > 0, xp.sqrt(xp.where(D_Ep_squared > 0, D_Ep_squared, xp.zeros_like(D_Ep_squared))), D_E_ab, ) if method == "nist cqs 9.0": CCT_f = xp.ones_like(D_C_ab[..., 0]) scaling_f = 3.2 else: ref_XYZ_white = msds_to_XYZ( ref_values, cmfs, method="Integration", shape=cmfs.shape ) with sdiv_mode(): ref_XYZ_white_n = sdiv(ref_XYZ_white, ref_XYZ_white[..., 1:2]) CCT_f = _CCT_factor(ref_XYZ, ref_XYZ_white_n) scaling_f = 3.104 D_E_RMS = xp.sqrt(xp_average(D_E_ab**2, axis=-1, xp=xp)) D_Ep_RMS = xp.sqrt(xp_average(D_Ep_ab**2, axis=-1, xp=xp)) Q_a = scale_conversion(D_Ep_RMS, CCT_f, scaling_f) scaling_f_Q_f = 2.93 * 1.0343 if method == "nist cqs 9.0" else 2.928 Q_f = scale_conversion(D_E_RMS, CCT_f, scaling_f_Q_f) G_t = gamut_area(test_Lab) G_r = gamut_area(ref_Lab) Q_g = G_t / GAMUT_AREA_D65 * 100 Q_p: NDArrayFloat | None Q_d: NDArrayFloat | None if method == "nist cqs 9.0": Q_p = None Q_d = None else: p_delta_C = xp_average( xp.where(D_C_ab > 0, D_C_ab, xp.zeros_like(D_C_ab)), axis=-1, xp=xp, ) Q_p = 100 - 3.6 * (D_Ep_RMS - p_delta_C) Q_d = G_t / G_r * CCT_f * 100 if is_msds: return Q_a Q_a_scalar = as_float_scalar(Q_a[0]) if additional_data: Q_f_scalar = as_float_scalar(Q_f[0]) Q_p_scalar = as_float_scalar(Q_p[0]) if Q_p is not None else None Q_g_scalar = as_float_scalar(Q_g[0]) Q_d_scalar = as_float_scalar(Q_d[0]) if Q_d is not None else None CCT_f_scalar = as_float_scalar(CCT_f[0]) Q_as: Dict[int, DataColourQualityScale_VS] = {} for i, name in enumerate(test_names): D_C_i = as_float_scalar(D_C_ab[0, i]) D_E_i = as_float_scalar(D_E_ab[0, i]) D_Ep_i = as_float_scalar(D_Ep_ab[0, i]) Q_a_i = float(scale_conversion(D_Ep_i, CCT_f_scalar, scaling_f)) Q_as[i + 1] = DataColourQualityScale_VS(name, Q_a_i, D_C_i, D_E_i, D_Ep_i) test_data = tuple( DataColorimetry_VS(name, test_XYZ[0, i], test_Lab[0, i], test_C[0, i]) for i, name in enumerate(test_names) ) ref_data = tuple( DataColorimetry_VS(name, ref_XYZ[0, i], ref_Lab[0, i], ref_C[0, i]) for i, name in enumerate(ref_names) ) return ColourRendering_Specification_CQS( sd_test.name, Q_a_scalar, Q_f_scalar, Q_p_scalar, Q_g_scalar, Q_d_scalar, Q_as, (test_data, ref_data), ) return Q_a_scalar
def gamut_area(Lab: ArrayLike) -> NDArrayFloat: """ Compute the gamut area :math:`G` covered by the specified *CIE L\\*a\\*b\\** colourspace matrices. Parameters ---------- Lab *CIE L\\*a\\*b\\** colourspace matrices. Returns ------- :class:`float` Gamut area :math:`G`. Examples -------- >>> import numpy as np >>> Lab = [ ... np.array([39.94996006, 34.59018231, -19.86046321]), ... np.array([38.88395498, 21.44348519, -34.87805301]), ... np.array([36.60576301, 7.06742454, -43.21461177]), ... np.array([46.60142558, -15.90481586, -34.64616865]), ... np.array([56.50196523, -29.54655550, -20.50177194]), ... np.array([55.73912101, -43.39520959, -5.08956953]), ... np.array([56.20776870, -53.68997662, 20.21134410]), ... np.array([66.16683122, -38.64600327, 42.77396631]), ... np.array([76.72952110, -23.92148210, 61.04740432]), ... np.array([82.85370708, -3.98679065, 75.43320144]), ... np.array([69.26458861, 13.11066359, 68.83858372]), ... np.array([69.63154351, 28.24532497, 59.45609803]), ... np.array([61.26281449, 40.87950839, 44.97606172]), ... np.array([41.62567821, 57.34129516, 27.46718170]), ... np.array([40.52565174, 48.87449192, 3.45121680]), ... ] >>> gamut_area(Lab) # doctest: +ELLIPSIS np.float64(8335.9482018...) """ Lab = as_float_array(Lab) xp = array_namespace(Lab) Lab_s = xp.roll(Lab, shift=-1, axis=-2) A = xp.linalg.vector_norm(Lab[..., 1:3], axis=-1) B = xp.linalg.vector_norm(Lab_s[..., 1:3], axis=-1) C = xp.linalg.vector_norm(Lab_s[..., 1:3] - Lab[..., 1:3], axis=-1) t = (A + B + C) / 2 S = xp.sqrt(t * (t - A) * (t - B) * (t - C)) return xp.sum(S, axis=-1) def _vs_colorimetry_data( t_values: NDArrayFloat, r_values: NDArrayFloat, sds_vs: Dict[str, SpectralDistribution], cmfs: MultiSpectralDistributions, chromatic_adaptation: bool = False, ) -> Tuple[list[str], NDArrayFloat, NDArrayFloat, NDArrayFloat]: """ Compute the *VS test colour samples* colorimetry arrays in a single vectorised pass over an arbitrary leading shape of test/reference irradiance pairs. Parameters ---------- t_values, r_values Test and reference irradiance values of shape ``(..., n_wavelengths)``. Returns ------- :class:`tuple` ``(names, XYZ_vs, Lab_vs, C_vs)`` with leading shape ``(..., n_test_colour_samples)``. """ XYZ_t = msds_to_XYZ(t_values, cmfs, method="Integration", shape=cmfs.shape) with sdiv_mode(): XYZ_t_n = sdiv(XYZ_t, XYZ_t[..., 1:2]) XYZ_r = msds_to_XYZ(r_values, cmfs, method="Integration", shape=cmfs.shape) with sdiv_mode(): XYZ_r_n = sdiv(XYZ_r, XYZ_r[..., 1:2]) xy_r = XYZ_to_xy(XYZ_r_n) names: list[str] = [] vs_values_list = [] for _key, value in sorted(INDEXES_TO_NAMES_VS.items()): if value not in sds_vs: continue names.append(sds_vs[value].name) vs_values_list.append(sds_vs[value].values) xp = array_namespace(XYZ_t, t_values) vs_values = xp.stack( [xp_as_float_array(values, xp=xp, like=XYZ_t) for values in vs_values_list] ) # Vectorised :math:`XYZ_{vs}` across the VS test colour samples; the # ``1 / Y_t`` factor recovers the ``domain_range_scale("1")`` # reflectance-under-illuminant scale. sds_vs_t = vs_values * t_values[..., None, :] XYZ_vs = ( msds_to_XYZ( sds_vs_t, cmfs, method="Integration", shape=cmfs.shape, ) / XYZ_t[..., 1:2, None] ) if chromatic_adaptation: XYZ_vs = chromatic_adaptation_VonKries( XYZ_vs, XYZ_t_n[..., None, :], XYZ_r_n[..., None, :], transform="CMCCAT2000", ) Lab_vs = XYZ_to_Lab(XYZ_vs, illuminant=xy_r[..., None, :]) _L_vs, C_vs, _Hab = tsplit(Lab_to_LCHab(Lab_vs)) return names, XYZ_vs, Lab_vs, C_vs def vs_colorimetry_data( sd_test: SpectralDistribution, sd_reference: SpectralDistribution, sds_vs: Dict[str, SpectralDistribution], cmfs: MultiSpectralDistributions, chromatic_adaptation: bool = False, ) -> Tuple[DataColorimetry_VS, ...]: """ Compute the *VS test colour samples* colorimetry data. Parameters ---------- sd_test Test spectral distribution. sd_reference Reference spectral distribution. sds_vs *VS test colour samples* spectral reflectance distributions. cmfs Standard observer colour matching functions. chromatic_adaptation Whether to perform chromatic adaptation. Returns ------- :class:`tuple` *VS test colour samples* colorimetry data. """ xp = array_namespace(sd_test.values) names, XYZ_vs, Lab_vs, C_vs = _vs_colorimetry_data( xp_as_float_array(sd_test.values, xp=xp), xp_as_float_array(sd_reference.values, xp=xp), sds_vs, cmfs, chromatic_adaptation, ) return tuple( DataColorimetry_VS(name, XYZ_vs[i], Lab_vs[i], C_vs[i]) for i, name in enumerate(names) ) def CCT_factor( reference_data: Tuple[DataColorimetry_VS, ...], XYZ_r: ArrayLike ) -> float: """ Compute the correlated colour temperature factor that penalizes lamps with extremely low correlated colour temperatures. Parameters ---------- reference_data Reference colorimetry data. XYZ_r *CIE XYZ* tristimulus values for reference. Returns ------- :class:`float` Correlated colour temperature factor. """ XYZ_vs = as_float_array( [colorimetry_data.XYZ for colorimetry_data in reference_data] ) return as_float_scalar(_CCT_factor(XYZ_vs, as_float_array(XYZ_r))) def _CCT_factor(XYZ_vs: NDArrayFloat, XYZ_r: NDArrayFloat) -> NDArrayFloat: """ Compute the correlated colour temperature factor for arbitrary leading batch shape. Parameters ---------- XYZ_vs Reference VS sample tristimulus values of shape ``(..., n_test_colour_samples, 3)``. XYZ_r Reference white tristimulus values of shape ``(..., 3)``. """ xy_w = CCS_ILLUMINANTS["CIE 1931 2 Degree Standard Observer"]["D65"] XYZ_w = xy_to_XYZ(xy_w) Lab = XYZ_to_Lab( chromatic_adaptation_VonKries( XYZ_vs, XYZ_r[..., None, :], XYZ_w, transform="CMCCAT2000", ), illuminant=xy_w, ) G_r = gamut_area(Lab) / GAMUT_AREA_D65 xp = array_namespace(G_r) return xp.minimum(G_r, xp.ones_like(G_r)) def scale_conversion( D_E_ab: ArrayLike, CCT_f: ArrayLike, scaling_f: float ) -> NDArrayFloat: """ Compute the *Colour Quality Scale* (CQS) for the specified :math:`\\Delta E_{ab}` value and correlated colour temperature penalizing factor. Parameters ---------- D_E_ab :math:`\\Delta E_{ab}` value. CCT_f Correlated colour temperature penalizing factor. scaling_f Scaling factor constant. Returns ------- :class:`numpy.ndarray` *Colour Quality Scale* (CQS). """ D_E_ab = as_float_array(D_E_ab) xp = array_namespace(D_E_ab) return as_float_array( 10 * xp.log1p(xp.exp((100 - scaling_f * D_E_ab) / 10)) * CCT_f ) def delta_E_RMS( CQS_data: Dict[int, DataColourQualityScale_VS], attribute: str ) -> float: """ Compute the root-mean-square average for the specified *Colour Quality Scale* (CQS) data using the specified colorimetry attribute. Parameters ---------- CQS_data *Colour Quality Scale* (CQS) data. attribute Colorimetry data attribute to use for computing the root-mean-square average. Returns ------- :class:`float` Root-mean-square average. """ values = as_float_array( [getattr(sample_data, attribute) ** 2 for sample_data in CQS_data.values()] ) xp = array_namespace(values) return as_float_scalar(xp.sqrt(1 / len(CQS_data) * xp.sum(values))) def colour_quality_scales( test_data: Tuple[DataColorimetry_VS, ...], reference_data: Tuple[DataColorimetry_VS, ...], scaling_f: float, CCT_f: float, ) -> Dict[int, DataColourQualityScale_VS]: """ Compute the *VS test colour samples* rendering scales. Parameters ---------- test_data Test data for the VS colour samples. reference_data Reference data for the VS colour samples. scaling_f Scaling factor constant for normalizing the colour rendering scales. CCT_f Factor penalizing light sources with extremely low correlated colour temperatures. Returns ------- :class:`dict` *VS test colour samples* colour rendering scales. """ Q_as = {} xp = array_namespace(test_data[0].Lab) for i in range(len(test_data)): D_C_ab = as_float_scalar(test_data[i].C - reference_data[i].C) D_E_ab = as_float_scalar( euclidean_distance(test_data[i].Lab, reference_data[i].Lab) ) D_Ep_ab_arr = as_float_array(D_E_ab**2 - D_C_ab**2) D_Ep_ab = as_float_scalar(xp.sqrt(D_Ep_ab_arr) if D_C_ab > 0 else D_E_ab) Q_a = float(scale_conversion(D_Ep_ab, CCT_f, scaling_f)) Q_as[i + 1] = DataColourQualityScale_VS( test_data[i].name, Q_a, D_C_ab, D_E_ab, D_Ep_ab ) return Q_as