My-small-educational-projects/adaptive_brightnes14_oop.py at main · RMANOV/My-small-educational-projects · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
import cv2
import numpy as np
import screen_brightness_control as sbc
from datetime import datetime
import time
import pyautogui
from threading import Thread
from queue import Queue
import pickle
import queue


class BrightnessController:
    def __init__(self, camera_index=0, num_threads=4, frame_queue_size=100, brightness_queue_size=100,
                 batch_size=5, frame_interval=0.1, update_interval=1):
        self.camera_index = camera_index
        self.num_threads = num_threads
        self.frame_queue_size = frame_queue_size
        self.brightness_queue_size = brightness_queue_size
        self.batch_size = batch_size
        self.frame_interval = frame_interval
        self.update_interval = update_interval
        self.state = self.load_state()
        if self.state is None:
            self.prev_brightness = sbc.get_brightness()[0]
            self.smoothed_brightness = self.prev_brightness
            self.integral_term = 0
            self.prev_error = 0
            self.kp, self.ki, self.kd = 0.6, 0.15, 0.08
        else:
            self.prev_brightness, self.smoothed_brightness, self.integral_term, self.prev_error, self.kp, self.ki, self.kd = self.state

    def turn_on_keyboard_backlight(self):
        pass

    def turn_off_keyboard_backlight(self):
        pass

    def analyze_image(self, frame):
        brightness = cv2.meanStdDev(frame)[0][0][0] / 255 * 100
        return brightness

    def get_screenshot_brightness(self):
        try:
            screenshot = pyautogui.screenshot()
            screenshot = cv2.cvtColor(np.array(screenshot), cv2.COLOR_BGR2GRAY)
            brightness = cv2.meanStdDev(screenshot)[0][0][0] / 255 * 100
            return brightness
        except OSError:
            print("Error capturing screenshot. Returning default brightness.")
            return 50

    def get_screenshot_brightness_thread(self, screenshot_brightness_queue):
        while True:
            screenshot_brightness = self.get_screenshot_brightness()
            screenshot_brightness_queue.put(screenshot_brightness)
            time.sleep(0.1)

    def process_frames(self, frame_queue, brightness_queue):
        frames = []
        last_frame_time = time.time()
        while True:
            if time.time() - last_frame_time >= self.frame_interval:
                frame = frame_queue.get()
                if frame is None:
                    break
                frames.append(frame)
                if len(frames) == self.batch_size:
                    avg_frame = cv2.GaussianBlur(np.stack(frames), (1, 1), 0)
                    brightness = self.analyze_image(avg_frame)
                    brightness_queue.put(brightness)
                    frames = []
                last_frame_time = time.time()

    def adjust_screen_brightness(self):
        print(f'Initial brightness: {round(self.prev_brightness)}% at {
              datetime.now().strftime("%H:%M:%S")}')
        frame_queue = Queue(maxsize=self.frame_queue_size)
        brightness_queue = Queue(maxsize=self.brightness_queue_size)
        for _ in range(self.num_threads):
            t = Thread(target=self.process_frames,
                       args=(frame_queue, brightness_queue))
            t.start()
        screenshot_brightness_queue = Queue()
        screenshot_thread = Thread(target=self.get_screenshot_brightness_thread, args=(
            screenshot_brightness_queue,))
        screenshot_thread.start()
        last_update_time = time.time()
        last_brightness_change_time = time.time()
        try:
            cap = cv2.VideoCapture(self.camera_index)
            if not cap.isOpened():
                print("Cannot open camera. Exiting...")
                return
            prev_camera_brightness = None
            prev_screenshot_brightness = None
            while True:
                current_brightness = sbc.get_brightness()[0]
                if abs(current_brightness - self.prev_brightness) > 10:
                    print(f'Brightness changed to {current_brightness}%')
                    self.smoothed_brightness = current_brightness
                    self.integral_term = 0
                    self.prev_error = 0
                ret, frame = cap.read()
                if not ret:
                    print("Error reading frame from camera.")
                    camera_brightness = prev_camera_brightness if prev_camera_brightness is not None else 50
                else:
                    frame_queue.put(frame)
                    try:
                        camera_brightness = brightness_queue.get(
                            block=True, timeout=1)
                    except queue.Empty:
                        camera_brightness = prev_camera_brightness if prev_camera_brightness is not None else 50
                try:
                    screenshot_brightness = screenshot_brightness_queue.get(
                        block=False)
                except queue.Empty:
                    screenshot_brightness = prev_screenshot_brightness if prev_screenshot_brightness is not None else 50
                if prev_camera_brightness is None:
                    prev_camera_brightness = camera_brightness
                if prev_screenshot_brightness is None:
                    prev_screenshot_brightness = screenshot_brightness
                weight_camera = camera_brightness / 100
                weight_screenshot = 1/2 * \
                    (1 - weight_camera) * (1 - weight_camera)
                combined_brightness = weight_camera * camera_brightness + \
                    weight_screenshot * screenshot_brightness
                brightness_diff = abs(
                    combined_brightness - self.smoothed_brightness)
                if brightness_diff > 10:
                    setpoint = combined_brightness
                    self.integral_term = 0
                    self.prev_error = 0
                else:
                    setpoint = self.smoothed_brightness
                error = setpoint - self.smoothed_brightness
                self.integral_term = max(-50, min(50,
                                         self.integral_term + error * self.update_interval))
                derivative_term = (error - self.prev_error) / \
                    self.update_interval
                output = self.kp * error + self.ki * \
                    self.integral_term + self.kd * derivative_term
                output = max(-10, min(10, output))
                self.prev_error = error
                self.smoothed_brightness += output
                self.smoothed_brightness = max(
                    5, min(95, self.smoothed_brightness))
                try:
                    sbc.set_brightness(round(self.smoothed_brightness))
                    if abs(self.smoothed_brightness - self.prev_brightness) > 5:
                        print(f'New brightness: {round(self.smoothed_brightness)}% at {
                              datetime.now().strftime("%H:%M:%S")}')
                        self.prev_brightness = self.smoothed_brightness
                        last_brightness_change_time = time.time()
                    else:
                        print("-", end="")
                    if self.smoothed_brightness < 20:
                        self.turn_on_keyboard_backlight()
                    self.save_state((self.prev_brightness, self.smoothed_brightness,
                                    self.integral_term, self.prev_error, self.kp, self.ki, self.kd))
                except Exception as e:
                    print(f"Error setting brightness: {str(e)}")
                if time.time() - last_brightness_change_time > 5:
                    self.update_interval = min(self.update_interval * 1.5, 5)
                else:
                    self.update_interval = max(self.update_interval / 1.5, 1)
                prev_camera_brightness = camera_brightness
                prev_screenshot_brightness = screenshot_brightness
                time.sleep(self.update_interval)
        except KeyboardInterrupt:
            print("Keyboard interrupt received. Exiting...")
        finally:
            for _ in range(self.num_threads):
                frame_queue.put(None)
            if cap is not None:
                cap.release()
            cv2.destroyAllWindows()

    def load_state(self):
        try:
            with open('brightness_controller_state.pkl', 'rb') as f:
                state = pickle.load(f)
                prev_brightness, smoothed_brightness, integral_term, prev_error, kp, ki, kd = state
                return prev_brightness, smoothed_brightness, integral_term, prev_error, kp, ki, kd
        except (FileNotFoundError, ValueError):
            return None

    def save_state(self, state):
        with open('brightness_controller_state.pkl', 'wb') as f:
            pickle.dump(state, f)


if __name__ == '__main__':
    controller = BrightnessController()
    controller.adjust_screen_brightness()