def liveview():
search = ControlPoint()
cameras = search.discover(5)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
quit()
mode = camera.getAvailableApiList()
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(2)
#sizes = camera.getLiveviewSize()
#print('Supported liveview size:', sizes)
url = camera.liveview()
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
print('LiveviewStreamThread startedr.')
t_end=time.time() + 60*1
i=0
# while time.time()<t_end:
#print("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
print lst.get_latest_view()
#print(type(lst.get_latest_view))
# i+=1
print(i)
def find_camera(self, duration=3):
"""
Uses the discover protocol and sets communication with one camera.
"""
# get available camera
search = ControlPoint()
self.cameras = search.discover(duration)
# use first found camera
if len(self.cameras):
self.cam = SonyAPI(self.cameras[0])
else:
self.cam = None
rospy.logerr("No camera found")
return
self.mode = self.cam.getAvailableApiList()
# some cameras need startRecMode call
# no needed in QX1
if 'starRecMode' in (self.mode['result'])[0]:
self.cam.startRecMode()
time.sleep(5)
else:
rospy.loginfo("No startRecMode available")
# re-read capabilities
self.mode = self.cam.getAvailableApiList()
rospy.loginfo("Found camera")
return
def take_pictures(self, save_directory, photos):
wait_between_photos = 1.2
photo_urls = deque()
thread.start_new_thread(
self.download_pictures_from_deque,
(photo_urls, save_directory, photos, wait_between_photos))
while 1:
try:
#pixhawk = dronekit.connect(ip = "127.0.0.1:8081", baud = 57600)
#print(pixhawk.location.global_frame)
# Take pictures forever.
camera = SonyAPI()
camera.QX_ADDR = "http://192.168.122.1:8080"
while 1:
url = camera.actTakePicture()['result'][0][0]
url = url.replace("\/", "/")
#url = url.replace("Scn", "Origin") # original
url = url.replace("Origin", "Scn") # preview
photo_urls.append(url)
time.sleep(wait_between_photos)
pixhawk.close()
except:
print("Error accessing camera.")
time.sleep(1)
def liveview():
# Connect and set-up camera
search = ControlPoint()
cameras = search.discover(5)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
quit()
mode = camera.getAvailableApiList()
# some cameras need `startRecMode` before we can use liveview
# For those camera which doesn't require this, just comment out the following 2 lines
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(2)
sizes = camera.getLiveviewSize()
print('Supported liveview size:', sizes)
# url = camera.liveview("M")
url = camera.liveview()
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
print('[i] LiveviewStreamThread started.')
return lst.get_latest_view
def liveview_and_save(timer=5):
camera = SonyAPI()
try:
live = camera.startLiveview()
liveview_url = live['result'][0]
f = urllib2.urlopen(liveview_url)
except:
print live
raise
if not os.path.exists("./static"):
os.makedirs("./static")
if not os.path.exists("./static/saved"):
os.makedirs("./static/saved")
t = timer
while 1:
data = f.read(8)
data = f.read(128)
payload = payload_header(data)
live = open('./static/live.jpg', 'w')
live.write(f.read(payload['jpeg_data_size']))
live.close()
if t == 0:
save = shutil.copy(
'./static/live.jpg',
'./static/saved/' + str(int(time.time())) + '.jpg')
t = timer
f.read(payload['padding_size'])
time.sleep(1)
t = t - 1
def liveview():
camera = SonyAPI()
# [TODO]
# replace liveview function to camera.liveview function.
# liveview function will do everything in this liveview function not just a file.
f = camera.liveview()
#st = os.stat(f.name())
if not os.path.exists("./static"):
os.makedirs("./static")
pos = 0
while True:
# read f size and control.
#if st.st_size - pos < 136:
# continue
#else:
# pos += 136
data = f.read(8)
data = f.read(128)
payload = payload_header(data)
# [TODO] when debug mode, print payload for debug
if False: #app.config('DEBUG'):
print(payload)
try:
data_size = f.read(payload['jpeg_data_size'])
test = open('./static/test.jpg', 'wb')
# wait until get pyload jpeg data size.
test.write(data_size)
test.close()
f.read(payload['padding_size'])
except Exception as e:
print("[ERROR]" + str(e))
def liveview(filename=None):
camera = SonyAPI()
f = camera.liveview()
with open(filename, 'wb') as backup:
while True:
data = f.read(100)
backup.write(data)
def getImage():
search = ControlPoint()
cameras = search.discover(5)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
quit()
mode = camera.getAvailableApiList()
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(2)
import socket
s = socket.socket()
print "Socket successfully created"
port = 52347
s.bind(('', port))
print "socket binded to %s" % (port)
s.listen(5)
print "socket is listening"
while True:
c, addr = s.accept()
print 'Got connection from', addr
toSend = camera.actTakePicture()
pic_url = toSend['result'][0][0]
img = urllib2.urlopen(pic_url).read()
c.send(str(img))
c.close()
def __init__(self, picture_size, preview_size, zoom=30, ssid="DIRECT-LKE0:ILCE-6000", pw="UeyxbxAG",
iface="wlp2s0"):
Camera.__init__(self, picture_size, preview_size, zoom, type='sony_wifi')
self.live_stream = None
if not sony_enabled:
raise CameraException("pysony module not installed")
self.previous_wifi = \
subprocess.check_output(["nmcli", "--fields", "NAME", "c", "show", "--active"]).decode("utf-8").split("\n")[
1].strip()
self.sony_api_version = "1.0"
if self.previous_wifi == ssid:
self.previous_wifi = ""
else:
try:
wifi_list = subprocess.check_output(["nmcli", "--fields", "SSID", "device", "wifi"]).decode(
"utf-8").split("\n")
wifi_list = [wifi_list[i].strip() for i in range(len(wifi_list))]
if ssid in wifi_list:
subprocess.check_call(["nmcli", "con", "up", "id", ssid])
else:
raise CameraException("Sony Wifi not found")
except subprocess.CalledProcessError:
raise CameraException("Cannot connect to wifi")
search = ControlPoint()
cameras = search.discover()
self.last_preview_frame = Image.new('RGB', preview_size, (0, 0, 0))
if len(cameras):
self.camera = SonyAPI(QX_ADDR=cameras[0])
else:
raise CameraException("No camera found")
options = self.camera.getAvailableApiList()['result'][0]
logging.info(str(options))
def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print("using LiveView grabber")
self.active = False
self.photomode = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
# Search for available camera
if options.debug:
print("searching for camera")
search = ControlPoint()
cameras = search.discover(1)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
return
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print("No camera found, aborting")
display.terminate_clicked()
self.event_terminated.set()
return
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if options.debug:
print("Versions: %s" % camera.getVersions())
print("API List: %s" % mode)
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len((camera.getAvailableLiveviewSize()['result'])[0]) > 1:
url = camera.liveview(["L"])
else:
url = camera.liveview()
else:
url = camera.liveview()
incoming_image = None
frame_info = None
# Ensure that we're in correct mode (movie by default)
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if options.still:
if (mode['result'])[0] != 'still':
if 'still' in (mode['result'])[1]:
camera.setShootMode(["still"])
self.photomode = True
else:
self.photomode = True
else:
if (mode['result'])[0] != 'movie':
if 'movie' in (mode['result'])[1]:
camera.setShootMode(["movie"])
else:
self.photomode = True
lst = SonyAPI.LiveviewStreamThread(url)
lst.start()
while not self.event_terminate.isSet():
# Handle events from the camera (record start/stop)
if self.frame_count % 50 == 0:
mode = camera.getEvent(["false"])
else:
mode = None
if mode and type(mode) == dict:
status = mode['result'][1]
if self.active == False and status['cameraStatus'] == 'MovieRecording':
self.frame_count = 0
self.start_time = datetime.datetime.now()
self.active = True
if options.debug:
print("started capture %s" % self.start_time)
elif self.active == True and status['cameraStatus'] == 'IDLE':
self.active = False
self.end_time = datetime.datetime.now()
if options.debug:
elapsed = self.end_time - self.start_time
'''
print("Stopped capture: frames = ", self.frame_count, \
", delta = ", elapsed.seconds + (float(elapsed.microseconds) / 1000000), \
", fps = ", self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000)))
'''
print("Stopped capture: frames = %d, delta = %d, fps = %d" % \
(self.frame_count, elapsed.seconds + (float(elapsed.microseconds) / 1000000), \
self.frame_count / (elapsed.seconds + (float(elapsed.microseconds) / 1000000))))
# read header, confirms image is also ready to read
header = lst.get_header()
if header:
image_file = io.BytesIO(lst.get_latest_view())
incoming_image = Image.open(image_file)
frame_info = lst.get_frameinfo()
if options.gui == True :
# Correct display size if changed
if incoming_image and ((incoming_image.size)[0] != display.width):
if options.debug:
print("adjusted width from %d to %d" % (display.width, (incoming_image.size)[0]))
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
display.width, display.height)
if incoming_image and ((incoming_image.size)[1] != display.height):
if options.debug:
print("adjusted height from %d to %d" % (display.height, (incoming_image.size)[1]))
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
display.width, display.height)
# copy image to the display
if incoming_image:
image_copy = incoming_image.convert("RGB")
# draw frame info to image
if frame_info:
for x in range(len(frame_info)):
left = frame_info[x]['left'] * display.width / 10000
top = frame_info[x]['top'] * display.height / 10000
right = frame_info[x]['right'] * display.width / 10000
bottom = frame_info[x]['bottom'] * display.height / 10000
dr = ImageDraw.Draw(image_copy)
dr.line((left, top, left, bottom), fill="white", width=3)
dr.line((right, top, right, bottom), fill="white", width=3)
dr.line((left, top, right, top), fill="white", width=3)
dr.line((left, bottom, right, bottom), fill="white", width=3)
display.copy_to_offscreen(image_copy)
if options.debug and header:
common = common_header(header)
print("Frame: %d, %d, %s" % (common['sequence_number'], common['time_stamp'], datetime.datetime.now()))
# count frames
self.frame_count = self.frame_count + 1
# handle events
if self.event_start_stream.isSet():
if self.photomode == True:
camera.actTakePicture()
else:
camera.startMovieRec()
self.event_start_stream.clear()
if self.event_stop_stream.isSet():
camera.stopMovieRec()
self.event_stop_stream.clear()
# give OS a breather
#time.sleep(0.01)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
dest="zoom",
help="Zoom image to fill screen")
parser.add_argument("-s",
"--skip",
action="store_true",
dest="skip",
help="Skip frames if computer too slow")
options = parser.parse_args()
# Connect and set-up camera
search = ControlPoint()
cameras = search.discover()
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print("No camera found, aborting")
quit()
mode = camera.getAvailableApiList()
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print "using LiveView grabber"
self.active = False
self.photomode = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
# Search for available camera
if options.debug:
print "searching for camera"
search = ControlPoint()
cameras = search.discover(1)
if len(cameras):
camera = SonyAPI(QX_ADDR=cameras[0])
else:
print "No camera found, aborting"
return
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print "No camera found, aborting"
display.terminate_clicked()
self.event_terminated.set()
return
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
time.sleep(5)
# and re-read capabilities
mode = camera.getAvailableApiList()
if options.debug:
print "Versions:", camera.getVersions()
print "API List:", mode
if 'setLiveviewFrameInfo' in (mode['result'])[0]:
if options.info:
camera.setLiveviewFrameInfo([{"frameInfo": True}])
else:
camera.setLiveviewFrameInfo([{"frameInfo": False}])
if 'getAvailableLiveviewSize' in (mode['result'])[0]:
if options.large and len(
(camera.getAvailableLiveviewSize()['result'])[0]) > 1:
incoming = camera.liveview(["L"])
else:
incoming = camera.liveview()
else:
incoming = camera.liveview()
incoming_image = None
frame_sequence = None
frame_info = None
frame_data = None
# Ensure that we're in correct mode (movie by default)
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if options.still:
if (mode['result'])[0] != 'still':
if 'still' in (mode['result'])[1]:
camera.setShootMode(["still"])
self.photomode = True
else:
self.photomode = True
else:
if (mode['result'])[0] != 'movie':
if 'movie' in (mode['result'])[1]:
camera.setShootMode(["movie"])
else:
self.photomode = True
while not self.event_terminate.isSet():
# Handle events from the camera (record start/stop)
if self.frame_count % 50 == 0:
mode = camera.getEvent(["false"])
else:
mode = None
if mode and type(mode) == dict:
status = mode['result'][1]
if self.active == False and status[
'cameraStatus'] == 'MovieRecording':
self.frame_count = 0
self.start_time = datetime.datetime.now()
self.active = True
if options.debug:
print "started capture", self.start_time
elif self.active == True and status['cameraStatus'] == 'IDLE':
self.active = False
self.end_time = datetime.datetime.now()
if options.debug:
elapsed = self.end_time - self.start_time
print "Stopped capture: frames = ", self.frame_count,
print ", delta = ", elapsed.seconds + (
float(elapsed.microseconds) / 1000000),
print ", fps = ", self.frame_count / (
elapsed.seconds +
(float(elapsed.microseconds) / 1000000))
# read next image
data = incoming.read(8)
common = common_header(data)
data = incoming.read(128)
if common['payload_type'] == 1:
payload = payload_header(data)
image_file = io.BytesIO(
incoming.read(payload['jpeg_data_size']))
incoming_image = Image.open(image_file)
incoming.read(payload['padding_size'])
elif common['payload_type'] == 2:
frame_info = payload_header(data, 2)
if frame_info['jpeg_data_size']:
frame_sequence = common['sequence_number']
frame_data = incoming.read(frame_info['jpeg_data_size'])
incoming.read(frame_info['padding_size'])
if options.gui == True:
# Correct display size if changed
if incoming_image and (
(incoming_image.size)[0] != display.width):
if options.debug:
print "adjusted width from", display.width, "to", (
incoming_image.size)[0]
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
if incoming_image and (
(incoming_image.size)[1] != display.height):
if options.debug:
print "adjusted height from", display.height, "to", (
incoming_image.size)[1]
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
# copy image to the display
if incoming_image:
image_copy = incoming_image.convert("RGB")
# only recent frame info to image
if frame_info and frame_sequence >= common['sequence_number']-1 \
and frame_info['jpeg_data_size']:
for x in range(frame_info['frame_count']):
x = x * frame_info['frame_size']
(left, top, right,
bottom) = struct.unpack(">HHHH",
frame_data[x:x + 8])
left = left * display.width / 10000
top = top * display.height / 10000
right = right * display.width / 10000
bottom = bottom * display.height / 10000
dr = ImageDraw.Draw(image_copy)
dr.line((left, top, left, bottom),
fill="white",
width=3)
dr.line((right, top, right, bottom),
fill="white",
width=3)
dr.line((left, top, right, top),
fill="white",
width=3)
dr.line((left, bottom, right, bottom),
fill="white",
width=3)
display.copy_to_offscreen(image_copy)
if options.debug:
print "Frame:", common['sequence_number'], common[
'time_stemp'], datetime.datetime.now()
# count frames
self.frame_count = self.frame_count + 1
# handle events
if self.event_start_stream.isSet():
if self.photomode == True:
camera.actTakePicture()
else:
camera.startMovieRec()
self.event_start_stream.clear()
if self.event_stop_stream.isSet():
camera.stopMovieRec()
self.event_stop_stream.clear()
# give OS a breather
#time.sleep(0.01)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
def run(self):
global options, grabber, decoder, display, image_copy
if options.debug:
print "using LiveView grabber"
self.active = False
# grabber control signals
self.event_start_stream = threading.Event()
self.event_stop_stream = threading.Event()
self.event_stopped_stream = threading.Event()
self.event_terminate = threading.Event()
self.event_terminated = threading.Event()
# decoder control signals
self.event_decoding = threading.Event()
self.event_decoder_terminated = threading.Event()
# display control signals
self.lock_offscreen = threading.Semaphore()
# export to other threads
self.frame_count = 0
grabber = self
camera = SonyAPI()
# Check if we need to do 'startRecMode'
mode = camera.getAvailableApiList()
# Need a better method to check for the presence of a camera
if type(mode) != dict:
print "No camera found, aborting"
display.terminate_clicked()
self.event_terminated.set()
return
if options.debug:
print "Versions:", camera.getVersions()
print "API List:", mode
# For those cameras which need it
if 'startRecMode' in (mode['result'])[0]:
camera.startRecMode()
# Ensure that we're in 'Movie' mode
mode = camera.getAvailableShootMode()
if type(mode) == dict:
if (mode['result'])[0] != 'movie':
if 'movie' in (mode['result'])[1]:
camera.setShootMode(["movie"])
else:
print "'movie' mode not supported"
# Wait for camera to be ready and check whether we're recoding
mode = camera.getEvent(["true"])
if options.debug:
print "Event:", mode
if type(mode) == dict:
status = mode['result'][1]
if status['cameraStatus'] == 'MovieRecording':
self.active = True
self.start_time = datetime.datetime.now()
incoming = camera.liveview()
while not self.event_terminate.isSet():
if options.gui == True:
# read next image
data = incoming.read(8)
data = incoming.read(128)
payload = payload_header(data)
image_file = io.BytesIO(
incoming.read(payload['jpeg_data_size']))
incoming_image = Image.open(image_file)
incoming.read(payload['padding_size'])
# set initial width/height
if display.offscreen == None:
display.width = (incoming_image.size)[0]
display.height = (incoming_image.size)[1]
if options.debug:
print "Display set to", (
incoming_image.size)[0], "x", (
incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
# Correct display size if changed
if ((incoming_image.size)[0] != display.width):
if options.debug:
print "adjusted width from", display.width, "to", (
incoming_image.size)[0]
display.width = (incoming_image.size)[0]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
if ((incoming_image.size)[1] != display.height):
if options.debug:
print "adjusted height from", display.height, "to", (
incoming_image.size)[1]
display.height = (incoming_image.size)[1]
display.offscreen = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,
False, 8, display.width,
display.height)
# copy image to the display
image_copy = incoming_image.convert("RGB")
display.copy_to_offscreen(image_copy)
if self.event_start_stream.isSet():
camera.startMovieRec()
self.frame_count = 0
# and we're ready to go..
self.start_time = datetime.datetime.now()
self.event_start_stream.clear()
# loop until request to stop
if self.active == True:
while not self.event_stop_stream.isSet():
if options.gui == True:
# read next image
data = incoming.read(8)
data = incoming.read(128)
payload = payload_header(data)
image_file = io.BytesIO(
incoming.read(payload['jpeg_data_size']))
incoming_image = Image.open(image_file)
incoming.read(payload['padding_size'])
image_copy = incoming_image.convert("RGB")
display.copy_to_offscreen(image_copy)
# copy image to the display
display.offscreen = gtk.gdk.Pixbuf(
gtk.gdk.COLORSPACE_RGB, False, 8, display.width,
display.height * 2)
display.copy_to_offscreen(image_copy)
self.frame_count = self.frame_count + 1
if self.event_terminate.isSet():
break
if self.event_stop_stream.isSet():
# clean up
camera.stopMovieRec()
self.end_time = datetime.datetime.now()
self.event_stop_stream.clear()
self.active = False
time.sleep(0.1)
# declare that we're done...
self.event_terminated.set()
self.event_terminate.clear()
import sys
import pprint
from pysony import SonyAPI
method = None
param = []
if len(sys.argv) > 1:
method = sys.argv[1]
if len(sys.argv) > 2:
param = list(sys.argv[2:])
sony = SonyAPI()
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(sony._cmd(method, param=None))
from pysony import SonyAPI, payload_header
import urllib2
camera = SonyAPI()
camera.QX_ADDR = "http://192.168.122.1:8080"
# print(camera.getAvailableApiList())
live = camera.startLiveview()
liveview_url = live['result'][0]
f = urllib2.urlopen("http://192.168.122.1:8080/liveview/liveviewstream")
while 1:
data = f.read(8)
data = f.read(128)
payload = payload_header(data)
live = open('./static/live.jpg', 'w')
live.write(f.read(payload['jpeg_data_size']))
live.close()
# if t == 0:
# save = shutil.copy('./static/live.jpg', './static/saved/' + str(int(time.time()))+'.jpg')
# t = timer
f.read(payload['padding_size'])
# time.sleep(1)
