Esempio n. 1
0
def test_color_RGB_to_xy_brightness():
    """Test color_RGB_to_xy_brightness."""
    assert color_util.color_RGB_to_xy_brightness(0, 0, 0) == (0, 0, 0)
    assert color_util.color_RGB_to_xy_brightness(255, 255,
                                                 255) == (0.323, 0.329, 255)

    assert color_util.color_RGB_to_xy_brightness(0, 0,
                                                 255) == (0.136, 0.04, 12)

    assert color_util.color_RGB_to_xy_brightness(0, 255,
                                                 0) == (0.172, 0.747, 170)

    assert color_util.color_RGB_to_xy_brightness(255, 0,
                                                 0) == (0.701, 0.299, 72)

    assert color_util.color_RGB_to_xy_brightness(128, 0,
                                                 0) == (0.701, 0.299, 16)

    assert color_util.color_RGB_to_xy_brightness(255, 0, 0,
                                                 GAMUT) == (0.7, 0.299, 72)

    assert color_util.color_RGB_to_xy_brightness(0, 255, 0, GAMUT) == (
        0.215,
        0.711,
        170,
    )

    assert color_util.color_RGB_to_xy_brightness(0, 0, 255,
                                                 GAMUT) == (0.138, 0.08, 12)
Esempio n. 2
0
    def test_color_RGB_to_xy_brightness(self):
        """Test color_RGB_to_xy_brightness."""
        self.assertEqual((0, 0, 0),
                         color_util.color_RGB_to_xy_brightness(0, 0, 0))
        self.assertEqual((0.323, 0.329, 255),
                         color_util.color_RGB_to_xy_brightness(255, 255, 255))

        self.assertEqual((0.136, 0.04, 12),
                         color_util.color_RGB_to_xy_brightness(0, 0, 255))

        self.assertEqual((0.172, 0.747, 170),
                         color_util.color_RGB_to_xy_brightness(0, 255, 0))

        self.assertEqual((0.701, 0.299, 72),
                         color_util.color_RGB_to_xy_brightness(255, 0, 0))

        self.assertEqual((0.701, 0.299, 16),
                         color_util.color_RGB_to_xy_brightness(128, 0, 0))
Esempio n. 3
0
    def test_color_RGB_to_xy_brightness(self):
        """Test color_RGB_to_xy_brightness."""
        self.assertEqual((0, 0, 0),
                         color_util.color_RGB_to_xy_brightness(0, 0, 0))
        self.assertEqual((0.32, 0.336, 255),
                         color_util.color_RGB_to_xy_brightness(255, 255, 255))

        self.assertEqual((0.136, 0.04, 12),
                         color_util.color_RGB_to_xy_brightness(0, 0, 255))

        self.assertEqual((0.172, 0.747, 170),
                         color_util.color_RGB_to_xy_brightness(0, 255, 0))

        self.assertEqual((0.679, 0.321, 80),
                         color_util.color_RGB_to_xy_brightness(255, 0, 0))

        self.assertEqual((0.679, 0.321, 17),
                         color_util.color_RGB_to_xy_brightness(128, 0, 0))
    def test_color_RGB_to_xy_brightness(self):
        """Test color_RGB_to_xy_brightness."""
        self.assertEqual((0, 0, 0),
                         color_util.color_RGB_to_xy_brightness(0, 0, 0))
        self.assertEqual((0.32, 0.336, 255),
                         color_util.color_RGB_to_xy_brightness(255, 255, 255))

        self.assertEqual((0.136, 0.04, 12),
                         color_util.color_RGB_to_xy_brightness(0, 0, 255))

        self.assertEqual((0.172, 0.747, 170),
                         color_util.color_RGB_to_xy_brightness(0, 255, 0))

        self.assertEqual((0.679, 0.321, 80),
                         color_util.color_RGB_to_xy_brightness(255, 0, 0))

        self.assertEqual((0.679, 0.321, 17),
                         color_util.color_RGB_to_xy_brightness(128, 0, 0))
Esempio n. 5
0
    def test_color_RGB_to_xy_brightness(self):
        """Test color_RGB_to_xy_brightness."""
        assert (0, 0, 0) == \
            color_util.color_RGB_to_xy_brightness(0, 0, 0)
        assert (0.323, 0.329, 255) == \
            color_util.color_RGB_to_xy_brightness(255, 255, 255)

        assert (0.136, 0.04, 12) == \
            color_util.color_RGB_to_xy_brightness(0, 0, 255)

        assert (0.172, 0.747, 170) == \
            color_util.color_RGB_to_xy_brightness(0, 255, 0)

        assert (0.701, 0.299, 72) == \
            color_util.color_RGB_to_xy_brightness(255, 0, 0)

        assert (0.701, 0.299, 16) == \
            color_util.color_RGB_to_xy_brightness(128, 0, 0)
Esempio n. 6
0
    async def async_flux_update(self, utcnow=None):
        """Update all the lights using flux."""
        if utcnow is None:
            utcnow = dt_utcnow()

        now = as_local(utcnow)

        sunset = get_astral_event_date(self.hass, SUN_EVENT_SUNSET, now.date())
        start_time = self.find_start_time(now)
        stop_time = self.find_stop_time(now)

        if stop_time <= start_time:
            # stop_time does not happen in the same day as start_time
            if start_time < now:
                # stop time is tomorrow
                stop_time += datetime.timedelta(days=1)
        elif now < start_time:
            # stop_time was yesterday since the new start_time is not reached
            stop_time -= datetime.timedelta(days=1)

        if start_time < now < sunset:
            # Daytime
            time_state = "day"
            temp_range = abs(self._start_colortemp - self._sunset_colortemp)
            day_length = int(sunset.timestamp() - start_time.timestamp())
            seconds_from_start = int(now.timestamp() - start_time.timestamp())
            percentage_complete = seconds_from_start / day_length
            temp_offset = temp_range * percentage_complete
            if self._start_colortemp > self._sunset_colortemp:
                temp = self._start_colortemp - temp_offset
            else:
                temp = self._start_colortemp + temp_offset
        else:
            # Night time
            time_state = "night"

            if now < stop_time:
                if stop_time < start_time and stop_time.day == sunset.day:
                    # we need to use yesterday's sunset time
                    sunset_time = sunset - datetime.timedelta(days=1)
                else:
                    sunset_time = sunset

                night_length = int(stop_time.timestamp() -
                                   sunset_time.timestamp())
                seconds_from_sunset = int(now.timestamp() -
                                          sunset_time.timestamp())
                percentage_complete = seconds_from_sunset / night_length
            else:
                percentage_complete = 1

            temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
            temp_offset = temp_range * percentage_complete
            if self._sunset_colortemp > self._stop_colortemp:
                temp = self._sunset_colortemp - temp_offset
            else:
                temp = self._sunset_colortemp + temp_offset
        rgb = color_temperature_to_rgb(temp)
        x_val, y_val, b_val = color_RGB_to_xy_brightness(*rgb)
        brightness = self._brightness if self._brightness else b_val
        if self._disable_brightness_adjust:
            brightness = None
        if self._mode == MODE_XY:
            await async_set_lights_xy(self.hass, self._lights, x_val, y_val,
                                      brightness, self._transition)
            _LOGGER.debug(
                "Lights updated to x:%s y:%s brightness:%s, %s%% "
                "of %s cycle complete at %s",
                x_val,
                y_val,
                brightness,
                round(percentage_complete * 100),
                time_state,
                now,
            )
        elif self._mode == MODE_RGB:
            await async_set_lights_rgb(self.hass, self._lights, rgb,
                                       self._transition)
            _LOGGER.debug(
                "Lights updated to rgb:%s, %s%% of %s cycle complete at %s",
                rgb,
                round(percentage_complete * 100),
                time_state,
                now,
            )
        else:
            # Convert to mired and clamp to allowed values
            mired = color_temperature_kelvin_to_mired(temp)
            await async_set_lights_temp(self.hass, self._lights, mired,
                                        brightness, self._transition)
            _LOGGER.debug(
                "Lights updated to mired:%s brightness:%s, %s%% "
                "of %s cycle complete at %s",
                mired,
                brightness,
                round(percentage_complete * 100),
                time_state,
                now,
            )
Esempio n. 7
0
    def flux_update(self, now=None):
        """Update all the lights using flux."""
        if now is None:
            now = dt_now()

        sunset = get_astral_event_date(self.hass, 'sunset', now.date())
        start_time = self.find_start_time(now)
        stop_time = self.find_stop_time(now)

        if stop_time <= start_time:
            # stop_time does not happen in the same day as start_time
            if start_time < now:
                # stop time is tomorrow
                stop_time += datetime.timedelta(days=1)
        elif now < start_time:
            # stop_time was yesterday since the new start_time is not reached
            stop_time -= datetime.timedelta(days=1)

        if start_time < now < sunset:
            # Daytime
            time_state = 'day'
            temp_range = abs(self._start_colortemp - self._sunset_colortemp)
            day_length = int(sunset.timestamp() - start_time.timestamp())
            seconds_from_start = int(now.timestamp() - start_time.timestamp())
            percentage_complete = seconds_from_start / day_length
            temp_offset = temp_range * percentage_complete
            if self._start_colortemp > self._sunset_colortemp:
                temp = self._start_colortemp - temp_offset
            else:
                temp = self._start_colortemp + temp_offset
        else:
            # Night time
            time_state = 'night'

            if now < stop_time:
                if stop_time < start_time and stop_time.day == sunset.day:
                    # we need to use yesterday's sunset time
                    sunset_time = sunset - datetime.timedelta(days=1)
                else:
                    sunset_time = sunset

                # pylint: disable=no-member
                night_length = int(stop_time.timestamp() -
                                   sunset_time.timestamp())
                seconds_from_sunset = int(now.timestamp() -
                                          sunset_time.timestamp())
                percentage_complete = seconds_from_sunset / night_length
            else:
                percentage_complete = 1

            temp_range = abs(self._sunset_colortemp - self._stop_colortemp)
            temp_offset = temp_range * percentage_complete
            if self._sunset_colortemp > self._stop_colortemp:
                temp = self._sunset_colortemp - temp_offset
            else:
                temp = self._sunset_colortemp + temp_offset
        rgb = color_temperature_to_rgb(temp)
        x_val, y_val, b_val = color_RGB_to_xy_brightness(*rgb)
        brightness = self._brightness if self._brightness else b_val
        if self._disable_brightness_adjust:
            brightness = None
        if self._mode == MODE_XY:
            set_lights_xy(self.hass, self._lights, x_val,
                          y_val, brightness, self._transition)
            _LOGGER.info("Lights updated to x:%s y:%s brightness:%s, %s%% "
                         "of %s cycle complete at %s", x_val, y_val,
                         brightness, round(
                             percentage_complete * 100), time_state, now)
        elif self._mode == MODE_RGB:
            set_lights_rgb(self.hass, self._lights, rgb, self._transition)
            _LOGGER.info("Lights updated to rgb:%s, %s%% "
                         "of %s cycle complete at %s", rgb,
                         round(percentage_complete * 100), time_state, now)
        else:
            # Convert to mired and clamp to allowed values
            mired = color_temperature_kelvin_to_mired(temp)
            set_lights_temp(self.hass, self._lights, mired, brightness,
                            self._transition)
            _LOGGER.info("Lights updated to mired:%s brightness:%s, %s%% "
                         "of %s cycle complete at %s", mired, brightness,
                         round(percentage_complete * 100), time_state, now)