def readStream(self):
gpCam = GoProCamera.GoPro()
cap = cv2.VideoCapture("udp://127.0.0.1:10000")
while True:
ret, frame = cap.read()
if ret == True:
self.frame = frame
def main():
wireless = Wireless()
print("Switching to GoPro SSID={}...".format(Config.GoPro.SSID))
wireless.connect(ssid=Config.GoPro.SSID, password=Config.GoPro.SSID_PASS)
print("Connected to GoPro SSID")
sleep(2) # sleep since it takes time for network connection to establish
print("Connecting to GoPro...")
gopro = GoProCamera.GoPro()
print("GoPro connected")
print("Downloading media...")
media = gopro.downloadAll(media_type=Config.MEDIA_TYPE,
dest_folder=Config.MEDIA_DEST_FOLDER)
print("Download complete")
if (Config.GoPro.is_power_off_when_done):
print("Powering off GoPro...")
gopro.power_off()
print("GoPro powered off")
print("Switching to Home SSID={}...".format(Config.HomeNetwork.SSID))
wireless.connect(ssid=Config.HomeNetwork.SSID,
password=Config.HomeNetwork.SSID_PASS)
print("Connected to Home SSID")
sleep(2)
print("Starting upload to Google Photos...")
googlephotos.upload_folder(os.path.abspath(Config.MEDIA_DEST_FOLDER),
album=Config.GooglePhotos.DEST_ALBUM,
auth_file=Config.GooglePhotos.CREDENTIALS_PATH)
print("Upload to Google Photos complete")
def test_has_sd_card(self):
print("Needs an SD card")
time.sleep(SLEEP_SEC)
self.gopro = GoProCamera.GoPro()
self.assertFalse(
self.gopro.getStatus(constants.Status.Status,
constants.Status.STATUS.RemainingSpace) == 0)
def set(self, attempt=1):
if (attempt > 5):
return None
try:
print('%s: Connection attempt #%d ' %
(self.GoProWifiSSID, attempt))
GoProNetworkSetup = "/usr/sbin/networksetup -setairportnetwork en0 '%s' '%s'" % (
self.GoProWifiSSID, self.GoProWifiPassword)
GoProNetworkSetupOutput = subprocess.run(GoProNetworkSetup,
stdout=subprocess.PIPE,
shell=True)
# Settle to allow WIFI to connect to GoPro
time.sleep(10)
GoProNetworkGetSSID = "/usr/sbin/networksetup -listallhardwareports | /usr/bin/awk '/Wi-Fi/{getline; print $2}' | /usr/bin/xargs /usr/sbin/networksetup -getairportnetwork | /usr/bin/awk -F\"Network: \" '/Network:/{print $2}'"
GoProNetworkGetSSIDOutput = subprocess.run(GoProNetworkGetSSID,
stdout=subprocess.PIPE,
shell=True)
if (GoProNetworkGetSSIDOutput.stdout.strip().decode("utf-8") !=
self.GoProWifiSSID):
raise Exception("Incorrect WIFI")
# Connect to GoPro
self.GoProCameraInstance = GoProCamera.GoPro()
return self.GoProCameraInstance
except Exception as e:
return self.set((attempt + 1))
def main():
while True:
try:
print("Connect to GoPro")
gpCam = GoProCamera.GoPro()
print(gpCam)
if gpCam is None:
continue
print("Downloading all the files...")
media = gpCam.downloadAll()
print("Deleting all files")
gpCam.delete(len(media))
print("Copying files to Yandex.Disk")
files = os.listdir()
cwd = os.getcwd()
videos = list(filter(lambda x: x.endswith('MP4'), files))
local_videos = list(map(lambda x: os.path.join(cwd, x), videos))
yandex_videos = list(
map(lambda x: os.path.join(YANDEX_DISK_FOLDER, x), videos))
paths = zip(local_videos, yandex_videos)
for from_path, to_path in paths:
print("Copying {} to {}".format(from_path, to_path))
os.rename(from_path, to_path)
except:
print("Can't connect to GoPro")
sleep(5)
continue
def create_gopro(mock_image_paths):
if mock_image_paths is None or len(mock_image_paths) == 0:
gopro = GoProCamera.GoPro()
gopro.mode(constants.Mode.PhotoMode)
return RealGoPro(gopro)
else:
return MockGoPro(mock_image_paths)
def main_gopro(loopControl: threading.Event):
# get GoPro
logger.info("Connecting to GoPro ...")
cam = GoProCamera.GoPro()
if cam.getStatusRaw():
# set GoPro to video mode
setCamVideoMode(cam)
# listen to gamecontroller
logger.info("Listen to GameController")
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.bind(('', 3838))
s.settimeout(5) # in sec
# status monitor and cam keep alive thread
status = CamStatus(cam, 1)
status.start()
# start main loop
main_loop(cam, status, s, loopControl)
# stop status listener
status.stop()
# close socket
s.close()
def __init__(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
gopro = GoProCamera.GoPro(ip_address=GoProCamera.GoPro.getWebcamIP("usb" + str(args[1])), camera=constants.gpcontrol, webcam_device="usb" + str(args[1]))
gopro.webcamFOV(constants.Webcam.FOV.Narrow)
gopro.startWebcam(resolution="720")
self.cap = cv2.VideoCapture("udp://172.21.173.54:8554?overrun_nonfatal=1&fifo_size=50000000", cv2.CAP_FFMPEG)
self.pub = rospy.Publisher('gopro_image', Image, queue_size=10)
def __init__(self):
self.gpCam = GoProCamera.GoPro()
self.gpCam.video_settings("1080p", "60")
self.CameraInfo = self.gpCam.infoCamera()
self.CameraName = self.CameraInfo['serial_number']
self.BarCodeScan = None
self.Clip = None
def connect_goPro(self):
self.goproCamera = GoProCamera.GoPro()
self.videosLeft.setText(
self.get_status("video_left",
constants.Status.STATUS.RemVideoTime))
self.currentMode.setText(
self.get_status("mode", constants.Status.STATUS.Mode))
self.currentResolution.setText(
self.get_status("video_res", constants.Video.RESOLUTION))
self.currentFramerate.setText(
self.get_status("video_fr", constants.Video.FRAME_RATE))
self.currentSubmode.setText(
self.get_status("sub_mode", constants.Status.STATUS.SubMode))
self.battery.setText(
self.get_status("battery", constants.Status.STATUS.BatteryLevel))
self.connection.setText("Connected")
self.ip_to_stream_to.setText(self.get_ip_address())
self.streamWorker = MainApp.StreamingWorker(
self.goproCamera, self.ip_to_stream_to.text(),
self.stream_quality.currentText().lower())
self.streamWorker.moveToThread(self.thread)
self.thread.started.connect(self.streamWorker.run)
self.streamWorker.finished.connect(self.thread.quit)
self.streamWorker.finished.connect(self.streamWorker.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
def test_photo_mode(self):
print("PHOTO MODE")
time.sleep(SLEEP_SEC)
self.gopro = GoProCamera.GoPro()
self.assertEqual(
self.gopro.mode(constants.Mode.PhotoMode,
constants.Mode.SubMode.Photo.Single_H5), RESP_OK)
def __init__(self):
threading.Thread.__init__(self)
self.cam = GoProCamera.GoPro()
self.runningTime = 0
def init():
global tests
tests = pd.DataFrame(list(itertools.product(*list(settings.values()))),
columns=list(settings.keys()))
print(tests.columns, tests.shape)
gpCam = GoProCamera.GoPro()
print(gpCam.getStatusRaw())
return gpCam
def test_init_pair(self):
def fakepair(self):
self.paired = True
with self.monkeypatch.context() as m:
m.setattr(GoProCamera.GoPro, 'pair', fakepair)
self.goprocam = GoProCamera.GoPro(camera='startpair')
assert self.goprocam.paired
def get_files_from_gopro():
gpCam = GoProCamera.GoPro()
try:
gpCam.downloadAll()
except:
print("Looks like an error")
get_files_from_gopro()
def startRecording(cameraNumber):
connectToCamera(cameraNumber)
gp1 = GoProCamera.GoPro()
gp1.overview()
if recordCmd == 'y':
gp1.shutter(constants.start)
if gp1.IsRecording() == 1:
print('First camera IsRecording confirmation: YES, RECORDING NOW')
def takeVideo(time):
signal(SIGINT, handler)
gopro = GoProCamera.GoPro(ip_address=GoProCamera.GoPro.getWebcamIP())
gopro.video_settings("480p", fps='30')
gopro.shoot_video(time)
gopro.downloadLowRes(custom_filename=(location + "plaintext/" +
numFiles() + ".mp4"))
gopro.delete("last")
def test_shutter(self):
print("SHUTTER START")
time.sleep(SLEEP_SEC)
self.gopro = GoProCamera.GoPro()
self.assertEqual(self.gopro.shutter(constants.start), RESP_OK)
time.sleep(4)
self.assertEqual(self.gopro.hilight(), RESP_OK)
time.sleep(2)
self.assertEqual(self.gopro.shutter(constants.stop), RESP_OK)
def take_a_photo(self):
gpCam = GoProCamera.GoPro(constants.auth)
gpCam.take_photo(1)
time.sleep(2)
save_path = self.visual_save_path
filename = save_path + str(round(time.time())) + ".jpg"
gpCam.downloadLastMedia(custom_filename=filename)
time.sleep(1)
gpCam.delete("all")
def take_photo(interface):
gopro = GoProCamera.GoPro(
ip_address=GoProCamera.GoPro.getWebcamIP(interface),
camera=constants.gpcontrol,
webcam_device=interface)
while True:
gopro.take_photo()
time.sleep(2)
print("Photo taken")
def ensureCamAlive(cameraNumber):
connectToCamera(cameraNumber)
gp1 = GoProCamera.GoPro()
try:
print('Attempting to send KeepAlive command...')
gp1.KeepAlive()
print('Keep Alive Sent')
except:
print('GoPro Definitely Dead or KeepAlive command DOES NOT WORK')
def setup_gopro():
global goproCamera
#initiating object for go pro camera
goproCamera = GoProCamera.GoPro()
#camera settings adjusted
goproCamera.gpControlSet(constants.Photo.RESOLUTION,
constants.Photo.Resolution.R12W)
goproCamera.locate(constants.Locate.Start)
return
def connect_camera():
""" Connect the camera, will return the object, it can be NoneType """
from goprocam import GoProCamera, constants
connect_wifi('GOPRO')
time.sleep(20)
gp = GoProCamera.GoPro(mac_address=_.DEFAULT_MAC)
gp.mode('0')
gp.mode('1')
return gp
def __init__(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
gopro = GoProCamera.GoPro(
ip_address=GoProCamera.GoPro.getWebcamIP("usb1"),
camera=constants.gpcontrol,
webcam_device="usb1") #getWebCamIPにはGoProのネットワークインターフェース名を入力
gopro.webcamFOV(constants.Webcam.FOV.Narrow)
gopro.startWebcam(resolution="720")
self.cap = cv2.VideoCapture(
"udp://172.21.173.54:8554?overrun_nonfatal=1&fifo_size=50000000",
cv2.CAP_FFMPEG)
def connectGoProCamera(self):
self.gopro = GoProCamera.GoPro()
if self.gopro:
self.connectionStatusLabel.setStyleSheet("QLabel {color: green}")
self.connectionStatusLabel.setText("CONNECTED")
self.gopro.mode(constants.Mode.PhotoMode)
self.setWorkingDirectoryButton.setEnabled(True)
self.getGoProImageButton.setEnabled(True)
self.tagImageButton.setEnabled(True)
self.saveImageButton.setEnabled(True)
self.setGoProOffButton.setEnabled(True)
self.setGoProOnButton.setEnabled(False)
def start_timelapse(interface):
gopro = GoProCamera.GoPro(ip_address=GoProCamera.GoPro.getWebcamIP(
interface), camera=constants.gpcontrol, webcam_device=interface)
logging.info(
"Started goprocam instance with interface {}".format(interface))
gopro.gpControlSet(constants.Setup.VOICE_CONTROL,
constants.Setup.VoiceControl.OFF)
gopro.gpControlSet(constants.Setup.AUTO_OFF, constants.Setup.AutoOff.Never)
logging.info("All config set")
gopro.mode(constants.Mode.MultiShotMode,
constants.Mode.SubMode.MultiShot.NightLapse)
gopro.shutter(constants.start)
logging.info("Started timelapse")
def __init__(self, starting_led_index, total_leds, background_interval):
self.leds = []
self.starting_led_index = starting_led_index
self.background_interval = background_interval
self.total_leds = total_leds
self.cam = GoProCamera.GoPro()
self.ser = serial.Serial(port=SERIAL_PORT,
baudrate=9600,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=1)
self.clear_leds()
def processStream(q, a):
gpCam = GoProCamera.GoPro()
cap = cv2.VideoCapture("udp://127.0.0.1:10000")
img = np.zeros((480,640,3))
x = 280
y = 280
while True:
for i in range(4):
ret, frame = cap.read()
if ret == True:
pos = detect_spheres(frame)
'''
# Hack
x += 1
pos = (x, y)
'''
if (pos == (None, None)):
continue
x_b = int(pos[0] - a[0] * 1.4)
y_b = int(pos[1])
x_l = int(pos[0])
y_l = int(pos[1] - a[1] * 1.4)
x_r = int(pos[0])
y_r = int(pos[1] + a[2] * 1.4)
x_fl = int(pos[0] + a[3] * 1.4)
y_fl = int(pos[1])
x_fr = int(pos[0] + a[4] * 1.4)
y_fr = int(pos[1])
cv2.circle(img, (x_b, y_b), 3, (0, 255, 0), thickness=-1)
cv2.circle(img, (x_l, y_l), 3, (0, 255, 0), thickness=-1)
cv2.circle(img, (x_r, y_r), 3, (0, 255, 0), thickness=-1)
cv2.circle(img, (x_fl, y_fl), 3, (0, 255, 0), thickness=-1)
cv2.circle(img, (x_fr, y_fr), 3, (0, 255, 0), thickness=-1)
q.put(img)
# (480, 640, 3) -> ~138 pixels per meter
# Or 1.4 pixels per cm
cap.release()
cv2.destroyAllWindows()
def capture(self):
#camera = self.ids['camera']
takax = ObjectProperty(None)
takan = ObjectProperty(None)
gpc = GoProCamera.GoPro(constants.auth)
gpc.mode(constants.Hero3Commands.Mode.PhotoMode)
gpc.delete(option="all")
gpc.downloadLastMedia(gpc.take_photo(), custom_filename="x.jpg")
print("we took an image")
file = "x.jpg"
wimg = Image(source=file, width=480, allow_stretch=True)
self.inside.add_widget(wimg)
def main():
gopro = GoProCamera.GoPro()
def gopro_thread():
gopro.stream("udp://127.0.0.1:10000", quality="low")
pass
t1 = FuncThread(gopro_thread)
t1.daemon = True
t1.start()
camera = Camera()
port = int(os.environ.get("PORT", 8000))
app = create_app(camera, gopro)
app.run(host="0.0.0.0", port=port)