def init_gcam(self, index, name, addr):
self.camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
self.camera.set_port_info(port_info_list[idx])
self.camera.init()
def detectCamera():
print("Camera::detectCamera()")
try:
cams = list()
# Get the context of the camera.
context = gp.Context()
if hasattr(gp, 'gp_camera_autodetect'):
# gphoto2 version 2.5+
cameras = context.camera_autodetect()
else:
port_info_list = gp.PortInfoList()
port_info_list.load()
abilities_list = gp.CameraAbilitiesList()
abilities_list.load(context)
cameras = abilities_list.detect(port_info_list, context)
for name, port in cameras:
cams.append({"name" : name, "port" : port})
return(cams)
except Exception as e:
print("Error occured in Camera::detectCamera()")
print(str(e))
def __init__(self, index):
"""
Konstruktor der Klasse Camera.
Beendet alle laufenden gphoto2 Prozesse.
Nimmt einen Index entgegen und erstellt mit diesem aus der Liste der verfügbaren Kameras die ausgewählte Kamera.
Weist die Kamera zum Schluss an, die aufgenommen Bilder auf der SD-Karte zu speichern.
:param index: Index der ausgewählten Kamera.
:rtype: int
"""
self.index = index # Speichere den übergebenen Index
Camera.kill_gphoto_process() # Beende alle laufenden gphoto2 Prozesse
self.name, self.addr = Camera.available_cameras[index] # Entnehme den Namen und den Port der gewählten Kamera aus der Liste der verfügbaren Kameras
self.camera = gp.Camera() # Erstelle ein neues Objekt vom Typ "gp.Camera"
port_info_list = gp.PortInfoList() # Lese die verfügbaren Ports (Usb) aus
port_info_list.load() # Lade die Liste der Usb-Ports
idx = port_info_list.lookup_path(self.addr) # Lade den Pfad der Kamera aus der Liste
self.camera.set_port_info(port_info_list[idx]) # Setze den Port des erstellen Kamera-Objektes auf den geladenen Pfad
self.camera.init() # Initialisiere die Kamera
self.set_capture_target() # Weise die Kamera an, Bilder auf der SD KArte zu speichern
print("Kamera initialisiert")
def camera_find_by_serialnumber(self, serialnumber):
logging.info(
'camera_find_by_serialnumber: ++ sn = {}'.format(serialnumber))
found = False
ret = None
try:
cnt, cameras = gp.gp_camera_autodetect()
for i in range(cnt):
if len(cameras[i]) == 2:
addr = cameras[i][1]
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
c = gp.Camera()
c.set_port_info(port_info_list[idx])
c.init()
config = c.get_config()
OK, sn = gp.gp_widget_get_child_by_name(
config, 'serialnumber')
if OK >= gp.GP_OK:
sn_text = sn.get_value()
if serialnumber == sn_text[-len(serialnumber):]:
found = True
ret = c
if not found:
c.exit()
if found:
break
except:
pass
logging.info('camera_find_by_serialnumber: -- ret={}'.format(ret))
return ret
def get_camera(serial, serial_to_address=None):
if serial_to_address is None:
serial_to_address = list_camera_serial_numbers()
if len(serial_to_address) == 0:
raise ValueError('No cameras!')
if serial == '':
print('Using first attached camera!')
serial = serial_to_address.keys()[0]
print('')
print('===============')
print('Selected camera:')
print('===============')
print('Serial Number: ' + serial)
print('===============')
print('')
addr = serial_to_address[serial]
camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
return camera
def detect_all_cameras(self):
self.disconnect_all()
with self._gp_lock:
cameras_name_and_port = gp.check_result(gp.gp_camera_autodetect())
# Search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
for name, port in cameras_name_and_port:
gp_camera = gp.Camera()
idx = port_info_list.lookup_path(port)
port_info = port_info_list[idx]
gp_camera.set_port_info(port_info)
try:
camera = GpCamera(name=name,
port=port,
gp_camera=gp_camera,
lock=self.sync_lock)
with self._cameras_dict_lock:
self._cameras_dict[camera.id] = camera
except Exception as e:
print('Detect all: {0}'.format(e))
def start(self):
right = True
autodetected = gp.check_result(gp.gp_camera_autodetect())
for i, cam in enumerate(autodetected):
name, addr = cam
if i == 0:
right = get_bool(name + " connect in " + addr +
" is Right cam ? (show left page) ")
else:
right = not self.camera_list[i - 1]["right"]
# camera_list.append((name, addr))camera = gp.Camera()
# search ports for camera port name
camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
self.camera_list.append({
"gp": camera,
"name": name,
"right": right
})
if not self.camera_list:
print('No camera detected')
else:
canvas = np.zeros((512, 512, 3), np.uint8)
while self.scanning:
cv2.imshow('canvas', canvas)
self.key_event(cv2.waitKey(100))
def list_camera_serial_numbers():
camera_list = get_list_of_availale_cameras()
if len(camera_list) == 0:
return
addresses = [camera_info[1] for camera_info in camera_list]
camera_types = [camera_info[0] for camera_info in camera_list]
serial_numbers = []
serial_to_address = {}
for i, addr in enumerate(addresses):
camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
txt = str(camera.get_summary())
serial = txt.split('Serial Number: ')[1].split('\n')[0]
serial_numbers.append(serial)
serial_to_address[serial_numbers[i]] = addresses[i]
print('Attached Cameras:')
print('================')
for i in range(len(addresses)):
print('Camera ' + str(i + 1))
print(' Serial number: ' + serial_numbers[i])
print(' Make and Model: ' + camera_types[i])
print(' USB Address: ' + addresses[i])
return serial_to_address
def init_camera(addr):
camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
return camera
def connect(self, camera):
name, addr = camera
self.camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
self.camera.set_port_info(port_info_list[idx])
self.camera.init(self.context)
return self.camera
def camera_control_util(addr):
"""
A utility that summarizes the basic parts of a function
that you need in order to select and send to a Theta sending a command in Python-gPhoto2.
Parameters
----------
addr : char
ID for connected THETA
Returns
-------
camera : Camera object
parent_widget : camera widget object
--------
Japanese
--------
Python-gPhoto2において
コマンドを送信するThetaを選択して送信する必要がある関数の
基本部分をまるっとまとめたユーティリティ。
Parameters
----------
addr : char
接続されているThetaのID
Returns
-------
camera : Camera object
parent_widget : camera widget object
"""
camera = gp.Camera()
# Search for a port by camera port name (?)
# カメラのポート名でポートを検索(?)
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
try:
parent_widget = camera.get_config()
except gp.GPhoto2Error:
# Just in case, the process of making an exception remains the same. Not sure if it makes sense
# 念の為例外を立てる処理はそのまま。意味があるかは不明
raise RuntimeError("Unable to connect to Camera")
return camera, parent_widget
def connect_camera(self, port):
self.camera = gp.Camera()
# Search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(port)
self.camera.set_port_info(port_info_list[idx])
self.camera.init()
# Get camera configuration
self.config = self.camera.get_config()
def get_gp_camera_proxy(port=None):
"""Return camera proxy if a gPhoto2 compatible camera is found
else return None.
.. note:: try to kill any process using gPhoto2 as it may block camera access.
:param port: look on given port number
:type port: str
"""
if not gp:
return None # gPhoto2 is not installed
pkill('*gphoto2*')
if hasattr(gp, 'gp_camera_autodetect'):
# gPhoto2 version 2.5+
cameras = gp.check_result(gp.gp_camera_autodetect())
else:
port_info_list = gp.PortInfoList()
port_info_list.load()
abilities_list = gp.CameraAbilitiesList()
abilities_list.load()
cameras = abilities_list.detect(port_info_list)
if cameras:
LOGGER.debug("Found gPhoto2 cameras on ports: '%s'",
"' / '".join([p for _, p in cameras]))
# Initialize first camera proxy and return it
camera = gp.Camera()
if port is not None:
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(port)
camera.set_port_info(port_info_list[idx])
try:
camera.init()
return camera
except gp.GPhoto2Error as ex:
LOGGER.warning("Could not connect gPhoto2 camera: %s", ex)
return None
def camera_connected():
"""Return the list of connected camera compatible with gPhoto2.
"""
if hasattr(gp, 'gp_camera_autodetect'):
# gPhoto2 version 2.5+
cameras = gp.check_result(gp.gp_camera_autodetect())
else:
port_info_list = gp.PortInfoList()
port_info_list.load()
abilities_list = gp.CameraAbilitiesList()
abilities_list.load()
cameras = abilities_list.detect(port_info_list)
return cameras
def _get_available_cameras_raw():
"""
Use gphoto2 autodetect functionality to get list of available cameras
:return: list of cameras
:rtype: gphoto2.CameraList of values like "['Canon EOS 1000D', 'usb:002,007']"
"""
port_info_list = gp.PortInfoList()
port_info_list.load()
abilities_list = gp.CameraAbilitiesList()
abilities_list.load()
cameras = abilities_list.detect(port_info_list)
return cameras
def get_cameras(self):
if self.cameras is None:
self.cameras = {}
has_attached_cameras = False
for index, (name, addr) in enumerate(
gp.check_result(gp.gp_camera_autodetect())):
try:
has_attached_cameras = True
print('{:d}: {:s} {:s}'.format(index, addr, name))
context = gp.Context()
camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init(context)
config = camera.get_config(context)
serial = config.get_child_by_name('eosserialnumber')
self.cameras[serial.get_value()] = (camera, {
'port_index': idx
})
try:
output = config.get_child_by_name('output')
output.set_value(output.get_choice(0))
vf = config.get_child_by_name('viewfinder')
vf.set_value(0)
camera.set_config(config)
except Exception as e:
print(e)
except Exception as e:
print(e)
if has_attached_cameras == False:
print('No Cameras Detected')
Qtw.QMessageBox.critical(
None, 'Error Detecting Cameras',
'No cameras were detected. Confirm that 4 cameras are attached via USB. Go into config and "Refresh Camera List"'
)
else:
Qtw.QMessageBox.about(
None, 'Cameras Detected',
'{} camera(s) attached. If that is not correct confirm they are connected to USB then go into config and "Refresh Camera List"'
.format(len(self.cameras)))
return self.cameras
def select_camera(self, port_name):
# free any existing camera
if self.camera:
self.camera.exit(self.context)
self.camera = None
# initialise camera
self.camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(port_name)
self.camera.set_port_info(port_info_list[idx])
self.camera.init(self.context)
return CameraSource(self.camera, self.context)
def main():
logging.basicConfig(format='%(levelname)s: %(name)s: %(message)s',
level=logging.WARNING)
gp.check_result(gp.use_python_logging())
context = gp.Context()
# make a list of all available cameras
camera_list = []
for name, addr in context.camera_autodetect():
camera_list.append((name, addr))
if not camera_list:
print('No camera detected')
return 1
camera_list.sort(key=lambda x: x[0])
# ask user to choose one
for index, (name, addr) in enumerate(camera_list):
print('{:d}: {:s} {:s}'.format(index, addr, name))
if six.PY3:
choice = input('Please input number of chosen camera: ')
else:
choice = raw_input('Please input number of chosen camera: ')
try:
choice = int(choice)
except ValueError:
print('Integer values only!')
return 2
if choice < 0 or choice >= len(camera_list):
print('Number out of range')
return 3
# initialise chosen camera
name, addr = camera_list[choice]
camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init(context)
text = camera.get_summary(context)
print('Summary')
print('=======')
print(str(text))
try:
text = camera.get_manual(context)
print('Manual')
print('=======')
print(str(text))
except Exception as ex:
print(str(ex))
camera.exit(context)
return 0
def session(self):
# initialise camera
camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(self.port_name)
camera.set_port_info(port_info_list[idx])
camera.init()
# check camera is the right model
if camera.get_abilities().model != self.model:
raise RuntimeError('Camera model mismatch')
yield camera
camera.exit()
def _select_camera(self, model, port_name) -> None:
# Code from Jim Easterbrook's Photoini
# initialise camera
self.camera = gp.Camera()
# search abilities for camera model
abilities_list = gp.CameraAbilitiesList()
abilities_list.load(self.context)
idx = abilities_list.lookup_model(str(model))
self.camera.set_abilities(abilities_list[idx])
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(str(port_name))
self.camera.set_port_info(port_info_list[idx])
def _get_camera_object_by_addr(camera_addr):
"""
Get uninitialized Camera object, based on camera address.
:param camera_addr: Address of the camera from PortInfoList. E.g. "usb:002,041".
:type camera_addr: str
:return: gphoto2.Camera
"""
camera = ThreadsafeCameraObject()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(camera_addr)
camera.set_port_info(port_info_list[idx])
return camera
def init_gcam(self, index, name, addr):
self.camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
self.camera.set_port_info(port_info_list[idx])
try:
self.camera.init(
) # prints: WARNING: gphoto2: (b'gp_context_error') b'Could not detect any camera' if logging set up
self.hasCamInited = True
except Exception as ex:
self.hasCamInited = False
lastException = ex
logging.warning("No camera: {} {}; ".format(
type(lastException).__name__, lastException.args))
def __init__(self, model, port_name):
self.model = model
self.port_name = port_name
self.context = gp.Context()
# initialise camera
self.camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(self.port_name)
self.camera.set_port_info(port_info_list[idx])
self.camera.init(self.context)
# check camera is the right model
if self.camera.get_abilities().model != self.model:
raise RuntimeError('Camera model mismatch')
def __init__(self, root=None, addr=None, logger=logger):
super().__init__()
self._root = root # root folder where to store photos from this specific camera instance
self.src_fn = None # path to currently made photo (source) inside the camera
self.dst_fn = None # path to photo (destination) on drive
self.logger = logger
self.id = None # TODO: give a uniue ID to each camera (once CameraRig is defined, complete)
self.name = None # TODO: give a name to each camera (once CameraRig is defined, complete)
if addr is not None:
# access a specific camera if the address details are provided
# get all accessible ports
ports = gp.PortInfoList()
ports.load()
# find the port that's commensurate with the address of the camera
idx = ports.lookup_path(addr)
self.set_port_info(ports[idx])
def get_camera(self):
self.logger.info("Getting camera list")
camera_list = list(gp.Camera.autodetect())
self.camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
self.logger.debug("Excluding iPhones from the camera list")
non_iphone = [x for x in camera_list if 'Apple' not in x[0]]
if len(non_iphone) < 1:
raise ValueError("No cameras attached")
idx = port_info_list.lookup_path(non_iphone[0][1])
self.camera.set_port_info(port_info_list[idx])
self.logger.debug(f"Initializing camera {non_iphone[0]}")
self.camera.init()
self.logger.debug(f"Initialized camera {non_iphone[0]}")
def gp_camera_connected():
"""Return True if a camera compatible with gPhoto2 is found.
"""
if not gp:
return False # gPhoto2 is not installed
if hasattr(gp, 'gp_camera_autodetect'):
# gPhoto2 version 2.5+
cameras = gp.check_result(gp.gp_camera_autodetect())
else:
port_info_list = gp.PortInfoList()
port_info_list.load()
abilities_list = gp.CameraAbilitiesList()
abilities_list.load()
cameras = abilities_list.detect(port_info_list)
if cameras:
return True
return False
def set_datetime(self):
for index, (name, addr) in enumerate(self.camera_list):
camera = gp.Camera()
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
abilities = camera.get_abilities()
config = camera.get_config()
if self.gphoto_datetime(config, abilities.model, gp):
camera.set_config(config)
logging.debug("Synchronized datetime for : " +
'{:d}: {:s} {:s}'.format(index, addr, name))
else:
logging.warning('Could not set date & time for ' +
'{:d}: {:s} {:s}'.format(index, addr, name))
camera.exit()
def getCamera(cameraNumber=0):
logging.basicConfig(format='%(levelname)s: %(name)s: %(message)s',
level=logging.WARNING)
gp.check_result(gp.use_python_logging())
# make a list of all available cameras
camera_list = []
for name, addr in gp.check_result(gp.gp_camera_autodetect()):
camera_list.append((name, addr))
camera_list.sort(key=lambda x: x[0])
if len(camera_list) == 0:
print("No cameras found")
return None
if cameraNumber < 0 or cameraNumber >= len(camera_list):
print('Camera out of range')
return None
# initialise chosen camera
name, addr = camera_list[cameraNumber]
camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
config = gp.check_result(gp.gp_camera_get_config(camera))
# find the image format config item
OK, image_format = gp.gp_widget_get_child_by_name(config, 'imageformat')
if OK >= gp.GP_OK:
# get current setting
value = gp.check_result(gp.gp_widget_get_value(image_format))
OK, capture_size_class = gp.gp_widget_get_child_by_name(
config, 'capturesizeclass')
if OK >= gp.GP_OK:
# set value
value = gp.check_result(gp.gp_widget_get_choice(capture_size_class, 2))
gp.check_result(gp.gp_widget_set_value(capture_size_class, value))
# set config
gp.check_result(gp.gp_camera_set_config(camera, config))
return camera
def detect_cameras(self):
""" Detects the connected cameras and if the ownername matches
with `LEFTNAME` or `RIGHTNAME`, it will be stored under the variable
`cameras`
"""
_cameras = self.context.camera_autodetect()
msg = [(False, "None"), (False, "None")]
if len(_cameras) == 0:
raise Exception("Unable to find any camera")
# Stores the left and right camera
ports = gp.PortInfoList()
ports.load()
for index, (name, addr) in enumerate(_cameras):
logger.debug("Count: {}, Name: {}, Addr: {}".format(
index, name, addr))
# Get the ports and search for the camera
idx = ports.lookup_path(addr)
try:
camera = gp.Camera()
camera.set_port_info(ports[idx])
camera.init(self.context)
# Check if the ownername matches to given values
ownername = self._get_config("ownername", camera)
abilities = gp.check_result(gp.gp_camera_get_abilities(camera))
except gp.GPhoto2Error as error:
logger.error(str(error))
else:
if ownername == self.LEFTNAME:
camera._camera_name = self.LEFTNAME
camera._camera_id = CameraID.LEFT
self.cameras[CameraID.LEFT] = camera
msg[CameraID.LEFT] = True, str(abilities.model)
logger.info("Connected: " + str(abilities.model))
elif ownername == self.RIGHTNAME:
camera._camera_name = self.RIGHTNAME
camera._camera_id = CameraID.RIGHT
self.cameras[CameraID.RIGHT] = camera
msg[CameraID.RIGHT] = True, str(abilities.model)
logger.info("Connected: " + str(abilities.model))
return self.connected, msg
def clear_photos_from_camera(self):
cameraCounter = 1
camera_list = []
# Get list of all connected cameras
for name, addr in gp.check_result(gp.gp_camera_autodetect()):
camera_list.append((name, addr))
if not camera_list:
self.deletePhotosLabel.setText('No camera detected')
return 1
# Sort the camera list
camera_list.sort(key=lambda x: x[0])
for item in camera_list:
cameraPercentage = int((cameraCounter / len(camera_list)) * 100)
self.cameraProgressBarDelete.setValue(cameraPercentage)
self.deletePhotosLabel.setText('Deleting from camera %i of %i' %
(cameraCounter, len(camera_list)))
# initialise camera
name, addr = item
camera = gp.Camera()
# search ports for camera port name
port_info_list = gp.PortInfoList()
port_info_list.load()
idx = port_info_list.lookup_path(addr)
camera.set_port_info(port_info_list[idx])
camera.init()
# Get list of all files from the camera
camera_files = self.list_camera_files(camera)
if not camera_files:
self.deletePhotosLabel.setText('No files found')
# Deleting files
counter = 1
for path in camera_files:
filePercentage = int((counter / len(camera_files)) * 100)
self.fileProgressBarDelete.setValue(filePercentage)
# Get folder and name from path
folder, name = os.path.split(path)
# Delete image from camera
gp.check_result(gp.gp_camera_file_delete(camera, folder, name))
counter += 1
gp.check_result(gp.gp_camera_exit(camera))
cameraCounter += 1
self.deletePhotosLabel.setText('Deletion Completed')
