def test_extrapolate(self): """ Tests :func:`colour.colorimetry.spectrum.\ MultiSpectralDistribution.extrapolate` method. """ data = dict(zip(range(25, 35), tstack([[0] * 5 + [1] * 5] * 3))) multi_sd = MultiSpectralDistribution(data) multi_sd.extrapolate(SpectralShape(10, 50)) np.testing.assert_almost_equal(multi_sd[10], np.array([0.0, 0.0, 0.0]), decimal=7) np.testing.assert_almost_equal(multi_sd[50], np.array([1.0, 1.0, 1.0]), decimal=7) multi_sd = MultiSpectralDistribution( tstack([np.linspace(0, 1, 10)] * 3), np.linspace(25, 35, 10)) multi_sd.extrapolate(SpectralShape(10, 50), extrapolator_args={ 'method': 'Linear', 'left': None, 'right': None }) np.testing.assert_almost_equal(multi_sd[10], np.array([-1.5, -1.5, -1.5]), decimal=7) np.testing.assert_almost_equal(multi_sd[50], np.array([2.5, 2.5, 2.5]), decimal=7)
def make_srgb_2015_color_checker(): # get color checker spectrum cc_spectrum, cc_shape = load_colorchecker_spectrum() cc_shape = SpectralShape(390, 730, 1) cc_spectrum.trim(cc_shape) cc_spectrum = cc_spectrum.interpolate(SpectralShape(interval=1), interpolator=LinearInterpolator) # get d65 spd, cie1931 cmfs d65_spd = load_d65_spd_1nmdata().trim(cc_shape) cmfs_cie2015 =\ STANDARD_OBSERVERS_CMFS['CIE 2012 2 Degree Standard Observer'].copy() cmfs_cie2015.trim(cc_shape) d65_spd_1nm = d65_spd.values[:, 1] cmfs_cie2015_1nm = cmfs_cie2015.values # get large xyz data from spectrum large_xyz = colorchecker_spectrum_to_large_xyz_2015( d_light=d65_spd_1nm, cc_spectrum=cc_spectrum, cmfs=cmfs_cie2015_1nm, temperature=6500) # convert from XYZ to sRGB rgb = color_checker_large_xyz_to_rgb(large_xyz) rgb[rgb < 0] = 0 # rgb[rgb > 1] = 1 rgb = np.uint8(np.round(oetf_sRGB(rgb) * 255)) # plot tpg.plot_color_checker_image(rgb) return rgb
def test_extrapolate(self): """ Tests :func:`colour.colorimetry.spectrum.\ SpectralPowerDistribution.extrapolate` method. """ data = dict(zip(range(25, 35), [0] * 5 + [1] * 5)) spd = SpectralPowerDistribution(data) spd.extrapolate(SpectralShape(10, 50)) self.assertAlmostEqual(spd[10], 0, places=7) self.assertAlmostEqual(spd[50], 1, places=7) spd = SpectralPowerDistribution( np.linspace(0, 1, 10), np.linspace(25, 35, 10)) spd.extrapolate( SpectralShape(10, 50), extrapolator_args={ 'method': 'Linear', 'left': None, 'right': None }) self.assertAlmostEqual(spd[10], -1.5000000000000004, places=7) self.assertAlmostEqual(spd[50], 2.4999999999999964, places=7)
def test__eq__(self): """ Tests :func:`colour.colorimetry.spectrum.SpectralShape.__eq__` method. """ self.assertEqual(SpectralShape(0, 10, 0.1), SpectralShape(0, 10, 0.1))
def test_interpolate(self): """ Tests :func:`colour.colorimetry.spectrum.\ MultiSpectralDistribution.interpolate` method. """ multi_sd = self._sample_multi_sd.copy() multi_sd.interpolate(SpectralShape(interval=1)) for signal in multi_sd.signals.values(): np.testing.assert_almost_equal(signal.values, INTERPOLATED_SAMPLE_SD_DATA, decimal=7) # TODO: Remove statement whenever we make "Scipy" 0.19.0 the minimum # version. # Skipping tests because of "Scipy" 0.19.0 interpolation code changes. if LooseVersion(scipy.__version__) < LooseVersion('0.19.0'): return multi_sd = self._non_uniform_sample_multi_sd.copy() multi_sd.interpolate(SpectralShape(interval=1)) for signal in multi_sd.signals.values(): np.testing.assert_allclose(signal.values, INTERPOLATED_NON_UNIFORM_SAMPLE_SD_DATA, rtol=0.0000001, atol=0.0000001)
def test_end(self): """ Tests :attr:`colour.colorimetry.spectrum.SpectralShape.end` attribute. """ self.assertEqual(SpectralShape(360, 830, 1).end, 830) self.assertRaises(AssertionError, lambda: SpectralShape(830, 830, 1)) self.assertRaises(AssertionError, lambda: SpectralShape(830, 0, 1))
def test_trim(self): """ Tests :func:`colour.colorimetry.spectrum.\ SpectralDistribution.trim` method. """ shape = SpectralShape(400, 700, 20) self.assertEqual(self._sd.copy().trim(shape).shape, shape) shape = SpectralShape(200, 900, 1) self.assertEqual(self._sd.copy().trim(shape).shape, self._sd.shape)
def test_align(self): """ Tests :func:`colour.colorimetry.spectrum.\ SpectralDistribution.align` method. """ shape = SpectralShape(100, 900, 5) self.assertEqual(self._sd.copy().align(shape).shape, shape) shape = SpectralShape(600, 650, 1) self.assertEqual(self._sd.copy().align(shape).shape, shape)
def test_boundaries(self): """ Tests :attr:`colour.colorimetry.spectrum.SpectralShape.boundaries` attribute. """ shape = SpectralShape() shape.boundaries = (360, 830) self.assertEqual(shape.start, 360) self.assertEqual(shape.end, 830)
def test_align(self): """ Tests :func:`colour.colorimetry.spectrum.\ MultiSpectralPowerDistribution.align` method. """ multi_spd = self._sample_multi_spd.copy() shape = SpectralShape(100, 900, 5) self.assertEqual(multi_spd.align(shape).shape, shape) shape = SpectralShape(600, 650, 1) self.assertEqual(multi_spd.align(shape).shape, shape)
def test__contains__(self): """ Tests :func:`colour.colorimetry.spectrum.SpectralShape.__contains__` method. """ self.assertIn(360.1, SpectralShape(360, 830, 0.1)) self.assertNotIn(360.11, SpectralShape(360, 830, 0.1)) self.assertIn(np.array([0.5, 0.6]), SpectralShape(0, 10, 0.1)) self.assertNotIn(np.array([0.5, 0.61]), SpectralShape(0, 10, 0.1))
def test_raise_exception_range(self): """ Tests :func:`colour.colorimetry.spectrum.SpectralShape.range` method raised exception. """ self.assertRaises(RuntimeError, SpectralShape().range)
def test_interval(self): """ Tests :attr:`colour.colorimetry.spectrum.SpectralShape.interval` attribute. """ self.assertEqual(SpectralShape(360, 830, 1).interval, 1)
def interpolate_5nm_cmfs_data(spd, interplation="linear"): interpolator = get_interpolater(interplation) temp = spd.copy() temp.interpolate(SpectralShape(interval=1), interpolator=interpolator) return temp
def get_normalize_large_y_param_cie1931_5nm(temperature=6500): """ XYZ算出用の正規化係数を算出する """ d_light = make_day_light_by_calculation(temperature=temperature, interpolater=LinearInterpolator, interval=5) # d_light.values = fit_significant_figures(d_light.values, 6) d_light.trim(SpectralShape(380, 780)) cmfs_cie1931 = load_cie1931_1nm_data().trim(SpectralShape(380, 780)) d_light_5nm = d_light.values cmfs_cie1931_5nm = cmfs_cie1931.values[::5] large_y = np.sum(d_light_5nm * cmfs_cie1931_5nm[:, 1]) normalize_coef = 100 / large_y return normalize_coef
def test_shape(self): """ Tests :attr:`colour.colorimetry.spectrum.\ SpectralDistribution.shape` attribute. """ self.assertEqual(self._sd.shape, SpectralShape(340, 820, 20))
def get_nomalize_large_y_cie2015(temperature=6500): """ XYZ算出用の正規化係数を算出する """ shape = SpectralShape(390, 830, 1) if temperature == 6500: d_light = load_d65_spd_1nmdata() else: d_light = make_day_light_by_calculation( temperature=temperature, interpolater=LinearInterpolator, interval=1) d_light.trim(shape) if temperature == 6500: d_light_1nm = d_light.values[:, 1] else: d_light_1nm = d_light.values cmfs =\ STANDARD_OBSERVERS_CMFS['CIE 2012 2 Degree Standard Observer'].copy() cmfs_cie2015_1nm = cmfs.values large_y = np.sum(d_light_1nm * cmfs_cie2015_1nm[:, 1]) normalize_coef = 100 / large_y return normalize_coef
def test_shape(self): """ Tests :attr:`colour.colorimetry.spectrum.\ MultiSpectralDistribution.shape` attribute. """ self.assertEqual(self._multi_sd.shape, SpectralShape(380, 780, 5))
def test_range(self): """ Tests :func:`colour.colorimetry.spectrum.SpectralShape.range` method. """ np.testing.assert_almost_equal( [wavelength for wavelength in SpectralShape(0, 10, 0.1)], np.arange(0, 10 + 0.1, 0.1))
def load_cie1931_1nm_data(): """ CIE S 014-1 に記載の2°視野の等色関数を得る """ cie_file = "./src_data/CMFs_CIE_S_014-1.csv" cms_1931_2 = np.loadtxt(cie_file, delimiter=',') m_data = make_multispectral_format_data(cms_1931_2[:, 0], cms_1931_2[:, 1:], "CIE1931_1nm_data") cmfs_1nm = MultiSpectralDistribution(m_data) cmfs_1nm.trim(SpectralShape(380, 780, 5)) # print(cmfs_1nm.wavelengths[::5]) return cmfs_1nm
def make_day_light_by_calculation(temperature=6500, interpolater=LinearInterpolator, interval=1): """ 計算でD光源を作る。 interpolater: SpragueInterpolator or LinearInterpolator """ xy = make_xy_value_from_temperature(temperature) spd = sd_CIE_illuminant_D_series(xy) spd = spd.interpolate(SpectralShape(interval=interval), interpolator=interpolater) spd.values = fit_significant_figures(spd.values, 6) return spd
def calc_d65_white_xy(): """ とりあえず D65 White の XYZ および xy を求めてみる。 """ # temperature = 6500 # d65_spd = make_day_light_by_calculation(temperature=temperature, # interpolater=LinearInterpolator, # interval=5) # d65_spd.values = fit_significant_figures(d65_spd.values, 6) d65_spd = load_d65_spd_1nmdata().trim(SpectralShape(380, 780)) cmfs_cie1931 = load_cie1931_1nm_data().trim(SpectralShape(380, 780)) d65_spd_5nm = d65_spd.values[::5] cmfs_cie1931_5nm = cmfs_cie1931.values[::5] large_x = np.sum(d65_spd_5nm[:, 1] * cmfs_cie1931_5nm[:, 0]) large_y = np.sum(d65_spd_5nm[:, 1] * cmfs_cie1931_5nm[:, 1]) large_z = np.sum(d65_spd_5nm[:, 1] * cmfs_cie1931_5nm[:, 2]) normalize_coef = 100 / large_y large_xyz = [ large_x * normalize_coef, large_y * normalize_coef, large_z * normalize_coef ] print(large_xyz) print(XYZ_to_xy(large_xyz))
def load_colorchecker_spectrum(): """ Babel Average 2012 のデータをロード。 """ csv = "./src_data/babel_spectrum_2012.csv" data = np.loadtxt(csv, delimiter=',', skiprows=0) wavelength = data[0, :] values = tstack([data[x, :] for x in range(1, 25)]) m_data = make_multispectral_format_data(wavelength, values, "Babel Average Spectrum") color_checker_spd = MultiSpectralDistribution(m_data) color_checker_spd.interpolate(SpectralShape(interval=5), interpolator=LinearInterpolator) return color_checker_spd, color_checker_spd.shape
def make_day_light_by_calculation(temperature=6500, interpolater=None, interval=1): """ 計算でD光源を作る。 interpolater: SpragueInterpolator or LinearInterpolator """ xy = make_xy_value_from_temperature(temperature) spd = sd_CIE_illuminant_D_series(xy) spd = spd.interpolate(SpectralShape(interval=interval), interpolator=interpolater) spd.values = fit_significant_figures(spd.values, 6) # ret_value = np.dstack([spd.wavelengths, spd.values]) # return ret_value.reshape((len(spd.values), 2)).T return spd
def get_normalize_large_y_param_cie1931_5nm_test(): temperature = 5000 shape = SpectralShape(380, 780) coef = get_normalize_large_y_param_cie1931_5nm(temperature) d_light = make_day_light_by_calculation(temperature=temperature, interpolater=LinearInterpolator, interval=5) d_light.trim(shape) cmfs_cie1931 = load_cie1931_1nm_data().trim(shape) cmfs_cie1931_5nm = cmfs_cie1931.values[::5] large_x = np.sum(d_light.values * cmfs_cie1931_5nm[:, 0]) large_y = np.sum(d_light.values * cmfs_cie1931_5nm[:, 1]) large_z = np.sum(d_light.values * cmfs_cie1931_5nm[:, 2]) large_xyz = [large_x * coef, large_y * coef, large_z * coef] print(large_xyz) print(XYZ_to_xy(large_xyz))
def calc_cie2015_d65_white_xy(): shape = SpectralShape(390, 830, 1) cmfs = STANDARD_OBSERVERS_CMFS['CIE 2012 2 Degree Standard Observer'] d65_spd = load_d65_spd_1nmdata().trim(shape) d65_1nm = d65_spd.values[:, 1] cmfs_1nm = cmfs.values large_x = np.sum(d65_1nm * cmfs_1nm[:, 0]) large_y = np.sum(d65_1nm * cmfs_1nm[:, 1]) large_z = np.sum(d65_1nm * cmfs_1nm[:, 2]) normalize_coef = 100 / large_y large_xyz = [ large_x * normalize_coef, large_y * normalize_coef, large_z * normalize_coef ] print(large_xyz) print(XYZ_to_xy(large_xyz))
def load_colorchecker_spectrum(interpolator=SpragueInterpolator): """ Babel Average 2012 のデータをロード。 """ base_dir = os.path.dirname(os.path.abspath(__file__)) csv = base_dir + "/data/babel_spectrum_2012.csv" data = np.loadtxt(csv, delimiter=',', skiprows=0) wavelength = data[0, :] values = tstack([data[x, :] for x in range(1, 25)]) m_data = _make_multispectral_format_data(wavelength, values) color_checker_spd = MultiSpectralDistribution(m_data) if interpolator is not None: color_checker_spd.interpolate(SpectralShape(interval=1), interpolator=interpolator) return color_checker_spd
def calc_appropriate_shape(spd1, spd2): """ 等色関数と測定対象の波長範囲が一致しない場合に 適切な Shape を設定する。 例: ``` a.shape = SpectralShape(390, 830, 1) b.shape = SpectralShape(360, 780, 5) calc_appropriate_shape(a, b) >>> SpectralShape(360, 780, 5) ``` """ start = np.max(np.array([spd1.shape.start, spd2.shape.start])) end = np.min(np.array([spd1.shape.end, spd2.shape.end])) interval = np.max(np.array([spd1.shape.interval, spd2.shape.interval])) return SpectralShape(start, end, interval)