You've already forked MicroPythonOS
mirror of
https://github.com/m5stack/MicroPythonOS.git
synced 2026-05-20 11:51:27 -07:00
Thomas Farstrike
550 lines
23 KiB
Python
550 lines
23 KiB
Python
import lvgl as lv
|
|
import time
|
|
|
|
try:
|
|
import webcam
|
|
except Exception as e:
|
|
print(f"Info: could not import webcam module: {e}")
|
|
|
|
import mpos.time
|
|
from mpos.apps import Activity
|
|
from mpos.content.intent import Intent
|
|
|
|
from camera_settings import CameraSettingsActivity
|
|
|
|
class CameraApp(Activity):
|
|
|
|
DEFAULT_WIDTH = 320 # 240 would be better but webcam doesn't support this (yet)
|
|
DEFAULT_HEIGHT = 240
|
|
PACKAGE = "com.micropythonos.camera"
|
|
CONFIGFILE = "config.json"
|
|
SCANQR_CONFIG = "config_scanqr_mode.json"
|
|
|
|
button_width = 60
|
|
button_height = 45
|
|
colormode = False
|
|
|
|
status_label_text = "No camera found."
|
|
status_label_text_searching = "Searching QR codes...\n\nHold still and try varying scan distance (10-25cm) and make the QR code big (4-12cm). Ensure proper lighting."
|
|
status_label_text_found = "Found QR, trying to decode... hold still..."
|
|
|
|
cam = None
|
|
current_cam_buffer = None # Holds the current memoryview to prevent garba
|
|
width = None
|
|
height = None
|
|
|
|
image = None
|
|
image_dsc = None
|
|
scanqr_mode = None
|
|
use_webcam = False
|
|
keepliveqrdecoding = False
|
|
|
|
capture_timer = None
|
|
|
|
# Widgets:
|
|
main_screen = None
|
|
qr_label = None
|
|
qr_button = None
|
|
snap_button = None
|
|
status_label = None
|
|
status_label_cont = None
|
|
|
|
def onCreate(self):
|
|
self.scanqr_mode = self.getIntent().extras.get("scanqr_mode")
|
|
from mpos.config import SharedPreferences
|
|
self.prefs = SharedPreferences(self.PACKAGE, filename=self.SCANQR_CONFIG if self.scanqr_mode else self.CONFIGFILE)
|
|
|
|
self.main_screen = lv.obj()
|
|
self.main_screen.set_style_pad_all(1, 0)
|
|
self.main_screen.set_style_border_width(0, 0)
|
|
self.main_screen.set_size(lv.pct(100), lv.pct(100))
|
|
self.main_screen.set_scrollbar_mode(lv.SCROLLBAR_MODE.OFF)
|
|
# Initialize LVGL image widget
|
|
self.image = lv.image(self.main_screen)
|
|
self.image.align(lv.ALIGN.LEFT_MID, 0, 0)
|
|
close_button = lv.button(self.main_screen)
|
|
close_button.set_size(self.button_width, self.button_height)
|
|
close_button.align(lv.ALIGN.TOP_RIGHT, 0, 0)
|
|
close_label = lv.label(close_button)
|
|
close_label.set_text(lv.SYMBOL.CLOSE)
|
|
close_label.center()
|
|
close_button.add_event_cb(lambda e: self.finish(),lv.EVENT.CLICKED,None)
|
|
# Settings button
|
|
settings_button = lv.button(self.main_screen)
|
|
settings_button.set_size(self.button_width, self.button_height)
|
|
settings_button.align(lv.ALIGN.TOP_RIGHT, 0, self.button_height + 5)
|
|
settings_label = lv.label(settings_button)
|
|
settings_label.set_text(lv.SYMBOL.SETTINGS)
|
|
settings_label.center()
|
|
settings_button.add_event_cb(lambda e: self.open_settings(),lv.EVENT.CLICKED,None)
|
|
self.snap_button = lv.button(self.main_screen)
|
|
self.snap_button.set_size(self.button_width, self.button_height)
|
|
self.snap_button.align(lv.ALIGN.RIGHT_MID, 0, 0)
|
|
self.snap_button.add_flag(lv.obj.FLAG.HIDDEN)
|
|
self.snap_button.add_event_cb(self.snap_button_click,lv.EVENT.CLICKED,None)
|
|
snap_label = lv.label(self.snap_button)
|
|
snap_label.set_text(lv.SYMBOL.OK)
|
|
snap_label.center()
|
|
self.zoom_button = lv.button(self.main_screen)
|
|
self.zoom_button.set_size(self.button_width, self.button_height)
|
|
self.zoom_button.align(lv.ALIGN.RIGHT_MID, 0, self.button_height + 5)
|
|
self.zoom_button.add_event_cb(self.zoom_button_click,lv.EVENT.CLICKED,None)
|
|
zoom_label = lv.label(self.zoom_button)
|
|
zoom_label.set_text("Z")
|
|
zoom_label.center()
|
|
self.qr_button = lv.button(self.main_screen)
|
|
self.qr_button.set_size(self.button_width, self.button_height)
|
|
self.qr_button.add_flag(lv.obj.FLAG.HIDDEN)
|
|
self.qr_button.align(lv.ALIGN.BOTTOM_RIGHT, 0, 0)
|
|
self.qr_button.add_event_cb(self.qr_button_click,lv.EVENT.CLICKED,None)
|
|
self.qr_label = lv.label(self.qr_button)
|
|
self.qr_label.set_text(lv.SYMBOL.EYE_OPEN)
|
|
self.qr_label.center()
|
|
self.status_label_cont = lv.obj(self.main_screen)
|
|
width = mpos.ui.pct_of_display_width(70)
|
|
height = mpos.ui.pct_of_display_width(60)
|
|
self.status_label_cont.set_size(width,height)
|
|
center_w = round((mpos.ui.pct_of_display_width(100) - self.button_width - 5 - width)/2)
|
|
center_h = round((mpos.ui.pct_of_display_height(100) - height)/2)
|
|
self.status_label_cont.set_pos(center_w,center_h)
|
|
self.status_label_cont.set_style_bg_color(lv.color_white(), 0)
|
|
self.status_label_cont.set_style_bg_opa(66, 0)
|
|
self.status_label_cont.set_style_border_width(0, 0)
|
|
self.status_label = lv.label(self.status_label_cont)
|
|
self.status_label.set_text("No camera found.")
|
|
self.status_label.set_long_mode(lv.label.LONG_MODE.WRAP)
|
|
self.status_label.set_width(lv.pct(100))
|
|
self.status_label.center()
|
|
self.setContentView(self.main_screen)
|
|
|
|
def onResume(self, screen):
|
|
self.parse_camera_init_preferences()
|
|
# Init camera:
|
|
self.cam = self.init_internal_cam(self.width, self.height)
|
|
if self.cam:
|
|
self.image.set_rotation(900) # internal camera is rotated 90 degrees
|
|
# Apply saved camera settings, only for internal camera for now:
|
|
self.apply_camera_settings(self.cam, self.use_webcam) # needs to be done AFTER the camera is initialized
|
|
else:
|
|
print("camera app: no internal camera found, trying webcam on /dev/video0")
|
|
try:
|
|
# Initialize webcam with desired resolution directly
|
|
print(f"Initializing webcam at {self.width}x{self.height}")
|
|
self.cam = webcam.init("/dev/video0", width=self.width, height=self.height)
|
|
self.use_webcam = True
|
|
except Exception as e:
|
|
print(f"camera app: webcam exception: {e}")
|
|
# Start refreshing:
|
|
if self.cam:
|
|
print("Camera app initialized, continuing...")
|
|
self.update_preview_image()
|
|
self.capture_timer = lv.timer_create(self.try_capture, 100, None)
|
|
self.status_label_cont.add_flag(lv.obj.FLAG.HIDDEN)
|
|
if self.scanqr_mode or self.keepliveqrdecoding:
|
|
self.start_qr_decoding()
|
|
else:
|
|
self.qr_button.remove_flag(lv.obj.FLAG.HIDDEN)
|
|
self.snap_button.remove_flag(lv.obj.FLAG.HIDDEN)
|
|
else:
|
|
print("No camera found, stopping camera app")
|
|
if self.scanqr_mode:
|
|
self.finish()
|
|
|
|
def onPause(self, screen):
|
|
print("camera app backgrounded, cleaning up...")
|
|
if self.capture_timer:
|
|
self.capture_timer.delete()
|
|
if self.use_webcam:
|
|
webcam.deinit(self.cam)
|
|
elif self.cam:
|
|
self.cam.deinit()
|
|
# Power off, otherwise it keeps using a lot of current
|
|
try:
|
|
from machine import Pin, I2C
|
|
i2c = I2C(1, scl=Pin(16), sda=Pin(21)) # Adjust pins and frequency
|
|
#devices = i2c.scan()
|
|
#print([hex(addr) for addr in devices]) # finds it on 60 = 0x3C after init
|
|
camera_addr = 0x3C # for OV5640
|
|
reg_addr = 0x3008
|
|
reg_high = (reg_addr >> 8) & 0xFF # 0x30
|
|
reg_low = reg_addr & 0xFF # 0x08
|
|
power_off_command = 0x42 # Power off command
|
|
i2c.writeto(camera_addr, bytes([reg_high, reg_low, power_off_command]))
|
|
except Exception as e:
|
|
print(f"Warning: powering off camera got exception: {e}")
|
|
print("camera app cleanup done.")
|
|
|
|
def parse_camera_init_preferences(self):
|
|
resolution_str = self.prefs.get_string("resolution", f"{self.DEFAULT_WIDTH}x{self.DEFAULT_HEIGHT}")
|
|
self.colormode = self.prefs.get_bool("colormode", False)
|
|
try:
|
|
width_str, height_str = resolution_str.split('x')
|
|
self.width = int(width_str)
|
|
self.height = int(height_str)
|
|
print(f"Camera resolution loaded: {self.width}x{self.height}")
|
|
except Exception as e:
|
|
print(f"Error parsing resolution '{resolution_str}': {e}, using default 320x240")
|
|
self.width = self.DEFAULT_WIDTH
|
|
self.height = self.DEFAULT_HEIGHT
|
|
|
|
def update_preview_image(self):
|
|
self.image_dsc = lv.image_dsc_t({
|
|
"header": {
|
|
"magic": lv.IMAGE_HEADER_MAGIC,
|
|
"w": self.width,
|
|
"h": self.height,
|
|
"stride": self.width * (2 if self.colormode else 1),
|
|
"cf": lv.COLOR_FORMAT.RGB565 if self.colormode else lv.COLOR_FORMAT.L8
|
|
},
|
|
'data_size': self.width * self.height * (2 if self.colormode else 1),
|
|
'data': None # Will be updated per frame
|
|
})
|
|
self.image.set_src(self.image_dsc)
|
|
disp = lv.display_get_default()
|
|
target_h = disp.get_vertical_resolution()
|
|
#target_w = disp.get_horizontal_resolution() - self.button_width - 5 # leave 5px for border
|
|
target_w = target_h # square
|
|
print(f"scaling to size: {target_w}x{target_h}")
|
|
scale_factor_w = round(target_w * 256 / self.width)
|
|
scale_factor_h = round(target_h * 256 / self.height)
|
|
print(f"scale_factors: {scale_factor_w},{scale_factor_h}")
|
|
self.image.set_size(target_w, target_h)
|
|
#self.image.set_scale(max(scale_factor_w,scale_factor_h)) # fills the entire screen but cuts off borders
|
|
self.image.set_scale(min(scale_factor_w,scale_factor_h))
|
|
|
|
def qrdecode_one(self):
|
|
try:
|
|
import qrdecode
|
|
import utime
|
|
before = time.ticks_ms()
|
|
if self.colormode:
|
|
result = qrdecode.qrdecode_rgb565(self.current_cam_buffer, self.width, self.height)
|
|
else:
|
|
result = qrdecode.qrdecode(self.current_cam_buffer, self.width, self.height)
|
|
after = time.ticks_ms()
|
|
#result = bytearray("INSERT_TEST_QR_DATA_HERE", "utf-8")
|
|
if not result:
|
|
self.status_label.set_text(self.status_label_text_searching)
|
|
else:
|
|
print(f"SUCCESSFUL QR DECODE TOOK: {after-before}ms")
|
|
result = self.remove_bom(result)
|
|
result = self.print_qr_buffer(result)
|
|
print(f"QR decoding found: {result}")
|
|
if self.scanqr_mode:
|
|
self.setResult(True, result)
|
|
self.finish()
|
|
else:
|
|
self.status_label.set_text(result) # in the future, the status_label text should be copy-paste-able
|
|
self.stop_qr_decoding()
|
|
except ValueError as e:
|
|
print("QR ValueError: ", e)
|
|
self.status_label.set_text(self.status_label_text_searching)
|
|
except TypeError as e:
|
|
print("QR TypeError: ", e)
|
|
self.status_label.set_text(self.status_label_text_found)
|
|
except Exception as e:
|
|
print("QR got other error: ", e)
|
|
|
|
def snap_button_click(self, e):
|
|
print("Picture taken!")
|
|
import os
|
|
try:
|
|
os.mkdir("data")
|
|
except OSError:
|
|
pass
|
|
try:
|
|
os.mkdir("data/images")
|
|
except OSError:
|
|
pass
|
|
if self.current_cam_buffer is None:
|
|
print("snap_button_click: won't save empty image")
|
|
return
|
|
colorname = "RGB565" if self.colormode else "GRAY"
|
|
filename=f"data/images/camera_capture_{mpos.time.epoch_seconds()}_{self.width}x{self.height}_{colorname}.raw"
|
|
try:
|
|
with open(filename, 'wb') as f:
|
|
f.write(self.current_cam_buffer)
|
|
print(f"Successfully wrote image to {filename}")
|
|
except OSError as e:
|
|
print(f"Error writing to file: {e}")
|
|
|
|
def start_qr_decoding(self):
|
|
print("Activating live QR decoding...")
|
|
self.keepliveqrdecoding = True
|
|
self.qr_label.set_text(lv.SYMBOL.EYE_CLOSE)
|
|
self.status_label_cont.remove_flag(lv.obj.FLAG.HIDDEN)
|
|
self.status_label.set_text(self.status_label_text_searching)
|
|
|
|
def stop_qr_decoding(self):
|
|
print("Deactivating live QR decoding...")
|
|
self.keepliveqrdecoding = False
|
|
self.qr_label.set_text(lv.SYMBOL.EYE_OPEN)
|
|
self.status_label_text = self.status_label.get_text()
|
|
if self.status_label_text in (self.status_label_text_searching or self.status_label_text_found): # if it found a QR code, leave it
|
|
self.status_label_cont.add_flag(lv.obj.FLAG.HIDDEN)
|
|
|
|
def qr_button_click(self, e):
|
|
if not self.keepliveqrdecoding:
|
|
self.start_qr_decoding()
|
|
else:
|
|
self.stop_qr_decoding()
|
|
|
|
def zoom_button_click(self, e):
|
|
print("zooming...")
|
|
if self.use_webcam:
|
|
print("zoom_button_click is not supported for webcam")
|
|
return
|
|
if self.cam:
|
|
startX = self.prefs.get_int("startX", CameraSettingsActivity.startX_default)
|
|
startY = self.prefs.get_int("startX", CameraSettingsActivity.startY_default)
|
|
endX = self.prefs.get_int("startX", CameraSettingsActivity.endX_default)
|
|
endY = self.prefs.get_int("startX", CameraSettingsActivity.endY_default)
|
|
offsetX = self.prefs.get_int("startX", CameraSettingsActivity.offsetX_default)
|
|
offsetY = self.prefs.get_int("startX", CameraSettingsActivity.offsetY_default)
|
|
totalX = self.prefs.get_int("startX", CameraSettingsActivity.totalX_default)
|
|
totalY = self.prefs.get_int("startX", CameraSettingsActivity.totalY_default)
|
|
outputX = self.prefs.get_int("startX", CameraSettingsActivity.outputX_default)
|
|
outputY = self.prefs.get_int("startX", CameraSettingsActivity.outputY_default)
|
|
scale = self.prefs.get_bool("scale", CameraSettingsActivity.scale_default)
|
|
binning = self.prefs.get_bool("binning", CameraSettingsActivity.binning_default)
|
|
result = self.cam.set_res_raw(startX,startY,endX,endY,offsetX,offsetY,totalX,totalY,outputX,outputY,scale,binning)
|
|
print(f"self.cam.set_res_raw returned {result}")
|
|
|
|
def open_settings(self):
|
|
intent = Intent(activity_class=CameraSettingsActivity, extras={"prefs": self.prefs, "use_webcam": self.use_webcam, "scanqr_mode": self.scanqr_mode})
|
|
self.startActivity(intent)
|
|
|
|
def try_capture(self, event):
|
|
#print("capturing camera frame")
|
|
try:
|
|
if self.use_webcam:
|
|
self.current_cam_buffer = webcam.capture_frame(self.cam, "rgb565" if self.colormode else "grayscale")
|
|
elif self.cam.frame_available():
|
|
self.current_cam_buffer = self.cam.capture()
|
|
except Exception as e:
|
|
print(f"Camera capture exception: {e}")
|
|
return
|
|
# Display the image:
|
|
self.image_dsc.data = self.current_cam_buffer
|
|
#self.image.invalidate() # does not work so do this:
|
|
self.image.set_src(self.image_dsc)
|
|
if not self.use_webcam:
|
|
self.cam.free_buffer() # Free the old buffer, otherwise the camera doesn't provide a new one
|
|
try:
|
|
if self.keepliveqrdecoding:
|
|
self.qrdecode_one()
|
|
except Exception as qre:
|
|
print(f"try_capture: qrdecode_one got exception: {qre}")
|
|
|
|
def init_internal_cam(self, width, height):
|
|
"""Initialize internal camera with specified resolution.
|
|
|
|
Automatically retries once if initialization fails (to handle I2C poweroff issue).
|
|
"""
|
|
try:
|
|
from camera import Camera, GrabMode, PixelFormat, FrameSize, GainCeiling
|
|
|
|
# Map resolution to FrameSize enum
|
|
# Format: (width, height): FrameSize
|
|
resolution_map = {
|
|
(96, 96): FrameSize.R96X96,
|
|
(160, 120): FrameSize.QQVGA,
|
|
(128, 128): FrameSize.R128X128,
|
|
(176, 144): FrameSize.QCIF,
|
|
(240, 176): FrameSize.HQVGA,
|
|
(240, 240): FrameSize.R240X240,
|
|
(320, 240): FrameSize.QVGA,
|
|
(320, 320): FrameSize.R320X320,
|
|
(400, 296): FrameSize.CIF,
|
|
(480, 320): FrameSize.HVGA,
|
|
(480, 480): FrameSize.R480X480,
|
|
(640, 480): FrameSize.VGA,
|
|
(640, 640): FrameSize.R640X640,
|
|
(720, 720): FrameSize.R720X720,
|
|
(800, 600): FrameSize.SVGA,
|
|
(800, 800): FrameSize.R800X800,
|
|
(960, 960): FrameSize.R960X960,
|
|
(1024, 768): FrameSize.XGA,
|
|
(1024,1024): FrameSize.R1024X1024,
|
|
(1280, 720): FrameSize.HD,
|
|
(1280, 1024): FrameSize.SXGA,
|
|
(1280, 1280): FrameSize.R1280X1280,
|
|
(1600, 1200): FrameSize.UXGA,
|
|
(1920, 1080): FrameSize.FHD,
|
|
}
|
|
|
|
frame_size = resolution_map.get((width, height), FrameSize.QVGA)
|
|
print(f"init_internal_cam: Using FrameSize for {width}x{height}")
|
|
|
|
# Try to initialize, with one retry for I2C poweroff issue
|
|
max_attempts = 3
|
|
for attempt in range(max_attempts):
|
|
try:
|
|
cam = Camera(
|
|
data_pins=[12,13,15,11,14,10,7,2],
|
|
vsync_pin=6,
|
|
href_pin=4,
|
|
sda_pin=21,
|
|
scl_pin=16,
|
|
pclk_pin=9,
|
|
xclk_pin=8,
|
|
xclk_freq=20000000,
|
|
powerdown_pin=-1,
|
|
reset_pin=-1,
|
|
pixel_format=PixelFormat.RGB565 if self.colormode else PixelFormat.GRAYSCALE,
|
|
frame_size=frame_size,
|
|
#grab_mode=GrabMode.WHEN_EMPTY,
|
|
grab_mode=GrabMode.LATEST,
|
|
fb_count=1
|
|
)
|
|
cam.set_vflip(True)
|
|
return cam
|
|
except Exception as e:
|
|
if attempt < max_attempts-1:
|
|
print(f"init_cam attempt {attempt} failed: {e}, retrying...")
|
|
else:
|
|
print(f"init_cam final exception: {e}")
|
|
return None
|
|
except Exception as e:
|
|
print(f"init_cam exception: {e}")
|
|
return None
|
|
|
|
def print_qr_buffer(self, buffer):
|
|
try:
|
|
# Try to decode buffer as a UTF-8 string
|
|
result = buffer.decode('utf-8')
|
|
# Check if the string is printable (ASCII printable characters)
|
|
if all(32 <= ord(c) <= 126 for c in result):
|
|
return result
|
|
except Exception as e:
|
|
pass
|
|
# If not a valid string or not printable, convert to hex
|
|
hex_str = ' '.join([f'{b:02x}' for b in buffer])
|
|
return hex_str.lower()
|
|
|
|
# Byte-Order-Mark is added sometimes
|
|
def remove_bom(self, buffer):
|
|
bom = b'\xEF\xBB\xBF'
|
|
if buffer.startswith(bom):
|
|
return buffer[3:]
|
|
return buffer
|
|
|
|
|
|
def apply_camera_settings(self, cam, use_webcam):
|
|
"""Apply all saved camera settings to the camera.
|
|
|
|
Only applies settings when use_webcam is False (ESP32 camera).
|
|
Settings are applied in dependency order (master switches before dependent values).
|
|
|
|
Args:
|
|
cam: Camera object
|
|
use_webcam: Boolean indicating if using webcam
|
|
"""
|
|
if not cam or use_webcam:
|
|
print("apply_camera_settings: Skipping (no camera or webcam mode)")
|
|
return
|
|
|
|
try:
|
|
# Basic image adjustments
|
|
brightness = self.prefs.get_int("brightness", 0)
|
|
cam.set_brightness(brightness)
|
|
|
|
contrast = self.prefs.get_int("contrast", 0)
|
|
cam.set_contrast(contrast)
|
|
|
|
saturation = self.prefs.get_int("saturation", 0)
|
|
cam.set_saturation(saturation)
|
|
|
|
# Orientation
|
|
hmirror = self.prefs.get_bool("hmirror", False)
|
|
cam.set_hmirror(hmirror)
|
|
|
|
vflip = self.prefs.get_bool("vflip", True)
|
|
cam.set_vflip(vflip)
|
|
|
|
# Special effect
|
|
special_effect = self.prefs.get_int("special_effect", 0)
|
|
cam.set_special_effect(special_effect)
|
|
|
|
# Exposure control (apply master switch first, then manual value)
|
|
exposure_ctrl = self.prefs.get_bool("exposure_ctrl", True)
|
|
cam.set_exposure_ctrl(exposure_ctrl)
|
|
|
|
if not exposure_ctrl:
|
|
aec_value = self.prefs.get_int("aec_value", 300)
|
|
cam.set_aec_value(aec_value)
|
|
|
|
ae_level = self.prefs.get_int("ae_level", 0)
|
|
cam.set_ae_level(ae_level)
|
|
|
|
aec2 = self.prefs.get_bool("aec2", False)
|
|
cam.set_aec2(aec2)
|
|
|
|
# Gain control (apply master switch first, then manual value)
|
|
gain_ctrl = self.prefs.get_bool("gain_ctrl", True)
|
|
cam.set_gain_ctrl(gain_ctrl)
|
|
|
|
if not gain_ctrl:
|
|
agc_gain = self.prefs.get_int("agc_gain", 0)
|
|
cam.set_agc_gain(agc_gain)
|
|
|
|
gainceiling = self.prefs.get_int("gainceiling", 0)
|
|
cam.set_gainceiling(gainceiling)
|
|
|
|
# White balance (apply master switch first, then mode)
|
|
whitebal = self.prefs.get_bool("whitebal", True)
|
|
cam.set_whitebal(whitebal)
|
|
|
|
if not whitebal:
|
|
wb_mode = self.prefs.get_int("wb_mode", 0)
|
|
cam.set_wb_mode(wb_mode)
|
|
|
|
awb_gain = self.prefs.get_bool("awb_gain", True)
|
|
cam.set_awb_gain(awb_gain)
|
|
|
|
# Sensor-specific settings (try/except for unsupported sensors)
|
|
try:
|
|
sharpness = self.prefs.get_int("sharpness", 0)
|
|
cam.set_sharpness(sharpness)
|
|
except:
|
|
pass # Not supported on OV2640
|
|
|
|
try:
|
|
denoise = self.prefs.get_int("denoise", 0)
|
|
cam.set_denoise(denoise)
|
|
except:
|
|
pass # Not supported on OV2640
|
|
|
|
# Advanced corrections
|
|
colorbar = self.prefs.get_bool("colorbar", False)
|
|
cam.set_colorbar(colorbar)
|
|
|
|
dcw = self.prefs.get_bool("dcw", True)
|
|
cam.set_dcw(dcw)
|
|
|
|
bpc = self.prefs.get_bool("bpc", False)
|
|
cam.set_bpc(bpc)
|
|
|
|
wpc = self.prefs.get_bool("wpc", True)
|
|
cam.set_wpc(wpc)
|
|
|
|
raw_gma = self.prefs.get_bool("raw_gma", True)
|
|
print(f"applying raw_gma: {raw_gma}")
|
|
cam.set_raw_gma(raw_gma)
|
|
|
|
lenc = self.prefs.get_bool("lenc", True)
|
|
cam.set_lenc(lenc)
|
|
|
|
# JPEG quality (only relevant for JPEG format)
|
|
try:
|
|
quality = self.prefs.get_int("quality", 85)
|
|
cam.set_quality(quality)
|
|
except:
|
|
pass # Not in JPEG mode
|
|
|
|
print("Camera settings applied successfully")
|
|
|
|
except Exception as e:
|
|
print(f"Error applying camera settings: {e}")
|
|
|