def setup_move():
mycam = ONVIFCamera(IP, PORT, USER, PASS)
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
global ptz
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration.token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
global moverequest
moverequest = ptz.create_type('ContinuousMove')
moverequest.ProfileToken = media_profile.token
if moverequest.Velocity is None:
moverequest.Velocity = ptz.GetStatus({'ProfileToken': media_profile.token}).Position
moverequest.Velocity.PanTilt.space = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].URI
moverequest.Velocity.Zoom.space = ptz_configuration_options.Spaces.ContinuousZoomVelocitySpace[0].URI
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Min
move_left(ptz, moverequest)
move_right(ptz, moverequest)
def __init__(self, hass, config):
"""Initialize a ONVIF camera."""
from onvif import ONVIFCamera, exceptions
super().__init__()
self._name = config.get(CONF_NAME)
self._ffmpeg_arguments = config.get(CONF_EXTRA_ARGUMENTS)
self._input = None
camera = None
try:
_LOGGER.debug("Connecting with ONVIF Camera: %s on port %s",
config.get(CONF_HOST), config.get(CONF_PORT))
camera = ONVIFCamera(
config.get(CONF_HOST), config.get(CONF_PORT),
config.get(CONF_USERNAME), config.get(CONF_PASSWORD)
)
media_service = camera.create_media_service()
stream_uri = media_service.GetStreamUri(
{'StreamSetup': {'Stream': 'RTP-Unicast', 'Transport': 'RTSP'}}
)
self._input = stream_uri.Uri.replace(
'rtsp://', 'rtsp://{}:{}@'.format(
config.get(CONF_USERNAME),
config.get(CONF_PASSWORD)), 1)
_LOGGER.debug(
"ONVIF Camera Using the following URL for %s: %s",
self._name, self._input)
except Exception as err:
_LOGGER.error("Unable to communicate with ONVIF Camera: %s", err)
raise
try:
self._ptz = camera.create_ptz_service()
except exceptions.ONVIFError as err:
self._ptz = None
_LOGGER.warning("Unable to setup PTZ for ONVIF Camera: %s", err)
class PtzCam():
def __init__(self,host,port,user,password,wsdl):
self.mycam = ONVIFCamera(host, port, user, password, wsdl)
self.media = self.mycam.create_media_service()
self.media_profile = self.media.GetProfiles()[0]
self.ptz = self.mycam.create_ptz_service()
self.requests = self.ptz.create_type('Stop')
self.requests.ProfileToken = self.media_profile._token
self.requestc = self.ptz.create_type('ContinuousMove')
self.requestc.ProfileToken = self.media_profile._token
self.requestg = self.ptz.create_type('GotoPreset')
self.requestg.ProfileToken = self.media_profile._token
self.stop()
def stop(self):
self.requests.PanTilt = True
self.requests.Zoom = True
self.ptz.Stop(self.requests)
def get_presets(self):
self.ptzPresetsList = self.ptz.GetPresets(self.requestc)
return self.ptzPresetsList
def goto_preset(self, preset_token):
self.requestg.PresetToken = preset_token
self.ptz.GotoPreset(self.requestg)
def getPresets():
#mycam = ONVIFCamera('192.168.0.139',1018,'admin','8146dpr','/home/visionstudio/Desktop/wsdl')
global mycam, media, ptz, media_profile, request, ptz_configuration_options
mycam = ONVIFCamera(ip, port, user, password, wsdl_dir)
media = mycam.create_media_service()
media_profile = media.GetProfiles()[0]
ptz = mycam.create_ptz_service()
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
#ver presets
ptzPresetsList = ptz.GetPresets(request)
print len(ptzPresetsList)
for preset in ptzPresetsList:
print preset._token
if preset.Name == '':
print '-'
else:
print preset.Name
def continuous_move():
mycam = ONVIFCamera('10.11.12.175', 80, 'admin', 'admin')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Min
# Move up
move_up(ptz, request)
def movimiento_continuo():
ip = '192.168.1.109'
port = 80
user = '******'
passwd = 'ufro_ufro_ufro'
cam = ONVIFCamera(ip, port, user, passwd, '/home/victor/collarvacas/camara/python-onvif/wsdl')
media = cam.create_media_service()
ptz = cam.create_ptz_service()
media_profile = media.GetProfiles()[0] # profile
peticion = ptz.create_type('GetConfigurationOptions')
peticion.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_config = ptz.GetConfigurationOptions(peticion)
peticion = ptz.create_type('ContinuousMove')
peticion.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
# rangos de la camara
XMAX = ptz_config.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Max
XMIN = ptz_config.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Min
YMAX = ptz_config.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Max
YMIN = ptz_config.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Min
mov_arriba(ptz, YMAX, peticion, 1)
def continuous_move():
global x1
global x2
global y2
global y1
mycam = ONVIFCamera('192.168.0.4', 5000, 'admin', '')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
# print (media_profile)
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
while True:
print 1
move_up(ptz=ptz, request=request)
time.sleep(1)
move_right(ptz=ptz, request=request)
time.sleep(1)
move_left(ptz=ptz, request=request)
time.sleep(1)
move_down(ptz=ptz, request=request)
time.sleep(1)
def continuous_move():
mycam = ONVIFCamera('192.168.13.12', 80, 'admin', 'Supervisor')
media = mycam.create_media_service()
ptz = mycam.create_ptz_service()
media_profile = media.GetProfiles()[0]
def continuous_move():
ip = '192.168.1.108'
port = 80
user = '******'
passwd = 'ufro_ufro_ufro'
cam = ONVIFCamera(ip, port, user, passwd,
'/home/victor/collarvacas/camara/python-onvif/wsdl')
media = cam.create_media_service()
ptz = cam.create_ptz_service()
media_profile = media.GetProfiles()[0]
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Min
return [ptz, request]
def get_presets(self):
mycam = ONVIFCamera(IP, PORT, USER, PASS, '../wsdl/')
# Create media service object
media = mycam.create_media_service()
print("setup_move {} {}", mycam, media)
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
profileToken = media_profile.token
# Get presets
print("Get Presets...")
gp = ptz.create_type('GetPresets')
gp.ProfileToken = profileToken
self.presets = ptz.GetPresets(gp)
for preset in self.presets:
if (hasattr(preset, "Name")):
name = preset.Name
else:
name = ""
position = preset['PTZPosition']
print("preset {} => ({}, {}, {})".format(name, position.PanTilt.x,
position.PanTilt.y,
position.Zoom.x))
return self.presets
def get_current_preset(self):
mycam = ONVIFCamera(CAMERA_IP, CAMERA_CONTROL_PORT, CAMERA_USER_NAME,
CAMERA_PASSWORD, '/etc/onvif/wsdl/')
# Create media service object
media = mycam.create_media_service()
print("setup_move {} {}", mycam, media)
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
profileToken = media_profile.token
# GetStatus
print("GetStatus")
self.status = ptz.GetStatus({'ProfileToken': profileToken})
print('status {} {} {} ? => {}'.format(
self.status.Position.PanTilt.x, self.status.Position.PanTilt.y,
self.status.Position.Zoom.x, self.status.MoveStatus.PanTilt))
min_dist = 100
current_prest = None
for preset in self.presets:
position = preset['PTZPosition']
dist = pow(
(self.status.Position.PanTilt.x - position.PanTilt.x),
2) + pow(
(self.status.Position.PanTilt.y - position.PanTilt.y), 2)
if dist < min_dist:
min_dist = dist
current_prest = preset
# snapshot = media.GetSnapshotUri({'ProfileToken': profileToken})
# print('snapshot uri {}'.format(snapshot))
return current_prest, self.status.MoveStatus.PanTilt
def connect(self, ip, port, username, password):
global ptz, img
# Connect to ONVIF camera
logger.info('IP camera initialization...')
if os.path.exists(SYSPATH):
path = SYSPATH
else:
path = HOMEPATH
mycam = ONVIFCamera(ip, port, username, password, path)
host = mycam.devicemgmt.GetHostname()
logger.info(' Connected to ONVIF camera ' + str(host.Name))
# Create media service object
logger.info(' Creating media service...')
media = mycam.create_media_service()
logger.info(' Creating media service... Done.')
# Get media profile (first element if we don't have multiple profiles)
media_profiles = media.GetProfiles()
media_profile_h264 = media_profiles[0]
# media_profile_jpg = media_profiles[1]
# Get video sources
# video_source = media.GetVideoSources()[0]
# We need the profile token
token = media_profile_h264._token
# PTZ
# Create ptz service object
logger.info(' Creating PTZ service...')
ptz = mycam.create_ptz_service()
logger.info(' Creating PTZ service... Done.')
# Next we want to automatically define all functions, in requesting those from the ptz-service
self.define_requests(token)
def continuous_move():
mycam = ONVIFCamera('192.168.13.12', 80, 'admin', 'Supervisor')
media = mycam.create_media_service()
ptz = mycam.create_ptz_service()
media_profile = media.GetProfiles()[0]
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
for i in range(1, 50):
move(ptz, request, 0.01 * i, 0.01 * i, 0.1 * i / 20, 0.15)
print i
for i in range(1, 50):
move(ptz, request, 0.50 - 0.01 * i, -(0.50 - 0.01 * i),
0.25 - 0.1 * i / 20, 0.15)
print i
for i in range(1, 50):
move(ptz, request, -0.01 * i, -0.01 * i, 0.50 - 0.01 * i, 0.15)
for i in range(1, 50):
move(ptz, request, -(0.50 - 0.01 * i), 0.50 - 0.01 * i, 0.1 * i / 20,
0.15)
print i
stop(ptz, request)
class MegapixelDomeCamera:
def __init__(self, host, port=8999, user="******", password="******"):
self.__camera = ONVIFCamera(host, port, user, password, "wsdl/")
self.__mediaService = self.__camera.create_media_service()
self.__ptzService = self.__camera.create_ptz_service()
self.__mediaProfileToken = self.__mediaService.GetProfiles()[0].token
self.__ptzNodeToken = self.__ptzService.GetNodes()[0].token
def getSnapshot(self):
response = self.__mediaService.GetSnapshotUri(self.__mediaProfileToken)
return response.Uri
def getRotationStatus(self):
return self.__ptzService.GetStatus(self.__mediaProfileToken)
# def move(self):
# vector = 10
# speed = 5
# return self.__ptzService.RelativeMove(self.__mediaProfileToken, vector)
def getPositionPresets(self):
return self.__ptzService.GetPresets(self.__mediaProfileToken)
def moveToPositionPreset(self, presetToken):
p = self.__ptzService.create_type("GotoPreset")
p.ProfileToken = self.__mediaProfileToken
p.PresetToken = presetToken
self.__ptzService.GotoPreset(p)
def continuous_move():
mycam = ONVIFCamera('192.168.15.42', 80, 'admin', 'Supervisor',
'C:\Users\komar\Documents\python-onvif-master\wsdl')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
print media_profile
# Get PTZ configuration options for getting continuous move range of Pan and Tilt
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
# Get range of Pan and Tilt
# X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Min
# Creating continuous move request with media_profile token
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
# Stops all other movement
ptz.Stop({'ProfileToken': media_profile._token})
# custom move
custom_move(ptz, request, -0.1, -0.2, -0.05, 2, 1, 0.5)
sleep(3)
# custom move
custom_move(ptz, request, 0.1, 0.2, 0.05, 2, 3, 2)
sleep(3)
# move right
move_right(ptz, request, 1)
sleep(2)
# move left
move_left(ptz, request, 1)
sleep(2)
# Move up
move_up(ptz, request, 1)
sleep(2)
# move down
move_down(ptz, request, 1)
sleep(2)
def is_ptz_supported(camera):
mycam = ONVIFCamera(camera['hostname'], camera['port'], camera['username'],
camera['password'])
try:
ptz = mycam.create_ptz_service()
return True
except onvif.exceptions.ONVIFError:
logger.debug("Camera does not support PTZ Services")
return False
def setup_move():
mycam = ONVIFCamera(IP, PORT, USER, PASS)
# Create media service object
media = mycam.create_media_service()
print("setup_move {} {}", mycam, media)
# Create ptz service object
global ptz
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
profileToken = media_profile.token
# Get presets
print("Get Presets...")
gp = ptz.create_type('GetPresets')
gp.ProfileToken = profileToken
presets = ptz.GetPresets(gp)
for preset in presets:
if (hasattr(preset, "Name")):
name = preset.Name
else:
name = ""
position = preset['PTZPosition']
print("preset {} => ({}, {}, {})".format(name, position.PanTilt.x,
position.PanTilt.y,
position.Zoom.x))
# GetStatus
print("GetStatus")
status = ptz.GetStatus({'ProfileToken': profileToken})
print('status {} {} {} ? => {}'.format(status.Position.PanTilt.x,
status.Position.PanTilt.y,
status.Position.Zoom.x,
status.MoveStatus.PanTilt))
# abMove = ptz.create_type('AbsoluteMove')
# abMove.ProfileToken = profileToken
# print('status {} {} {} {}'.format(status.Position.PanTilt.x, status.Position.PanTilt.y,
# status.Velocity.PanTilt.x, status.Velocity.PanTilt.y))
return
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration.token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
global moverequest
moverequest = ptz.create_type('ContinuousMove')
moverequest.ProfileToken = media_profile.token
if moverequest.Velocity is None:
moverequest.Velocity = ptz.GetStatus({
'ProfileToken':
media_profile.token
}).Position
def continuous_move():
mycam = ONVIFCamera('192.168.18.251', 80, 'admin', '182333')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
media_profile = media.GetProfiles()[0]
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration.token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile.token
ptz.Stop({'ProfileToken': media_profile.token})
if request.Velocity is None:
request.Velocity = ptz.GetStatus({
'ProfileToken': media_profile.token
}).Position
request.Velocity = ptz.GetStatus({
'ProfileToken': media_profile.token
}).Position
request.Velocity.PanTilt.space = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].URI
request.Velocity.Zoom.space = ptz_configuration_options.Spaces.ContinuousZoomVelocitySpace[
0].URI
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Min
# move right
move_right(ptz, request)
# move left
move_left(ptz, request)
# Move up
move_up(ptz, request)
# move down
move_down(ptz, request)
def getStatus():
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
mycam = ONVIFCamera("192.168.8.237", 80, "admin", "xxl123456")
media = mycam.create_media_service()
ptz = mycam.create_ptz_service()
params = ptz.create_type('GetStatus')
media_profile = media.GetProfiles()[0] # 获取配置信息
print(media_profile.token)
params.ProfileToken = media_profile.token
res = ptz.GetStatus(params)
print(res)
def continuous_move():
global x1
global x2
global y2
global y1
mycam = ONVIFCamera('192.168.1.45', 5000, 'admin', '')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
# print (media_profile)
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
while 1:
try: # used try so that if user pressed other than the given key error will not be shown
if keyboard.is_pressed('d'):
Movement.move_right(ptz, request)
elif keyboard.is_pressed('a'):
Movement.move_left(ptz, request)
elif keyboard.is_pressed('w'):
Movement.move_up(ptz, request)
elif keyboard.is_pressed('s'):
Movement.move_down(ptz, request)
elif keyboard.is_pressed('e'):
Movement.move_upright(ptz, request)
elif keyboard.is_pressed('c'):
Movement.move_downright(ptz, request)
elif keyboard.is_pressed('z'):
Movement.move_downleft(ptz, request)
elif keyboard.is_pressed('q'):
Movement.move_upleft(ptz, request)
except Exception as e:
print(e)
break # if user pressed a key other than the given key the loop will break
def initialize(self, ip, port, username, password):
global ptz
print 'IP Camera initialization...'
mycam = ONVIFCamera(ip, port, username, password)
print 'Connected to ONVIF Camera ' + ip
print 'Creating Media service...'
media = mycam.create_media_service()
print 'Creating Media service... Done.'
token = media.GetProfiles()[0]._token
print 'Creating PTZ service...'
ptz = mycam.create_ptz_service()
print 'Creating PTZ service... Done.'
self.define_requests(token)
def continuous_move():
print "1"
mycam = ONVIFCamera(
'192.168.43.161', 29444, 'admin', '88888888',
'/usr/local/lib/python2.7/dist-packages/onvif_zeep-0.2.12-py2.7.egg/wsdl'
)
print "2"
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
print "a"
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
print "b"
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
print "c"
ptz.Stop({'ProfileToken': media_profile._token})
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Min
print "D"
# move right
move_right(ptz, request)
# move left
move_left(ptz, request)
# Move up
move_up(ptz, request)
# move down
move_down(ptz, request)
print "e"
def OV_Move_to_preset(preset, plano):
falcon_logger.info("Move to Preset %s - %s " % (preset, plano))
try:
mycam = ONVIFCamera(config.CAMARA.HOST, config.CAMARA.PORT,
config.CAMARA.USER, config.CAMARA.PASSWORD)
ptz = mycam.create_ptz_service()
ptz.GotoPreset({"ProfileToken": "MainStream", "PresetToken": preset})
rc = 0
msg = "Ok - Camara movida a %s %s " % (preset, plano)
except Exception as e:
rc = 9
msg = "Error al conectar con camara %s " % str(e)
falcon_logger.info("RC: %s - %s " % (rc, msg))
return rc, msg
def absolute_move(pan=0, pan_speed=1, tilt=0, tilt_speed=1):
# pan = 0
# pan_speed = 1
# tilt = 0
# tilt_speed = 1
zoom = 1
zoom_speed = 0.1
mycam = ONVIFCamera('192.168.1.108', 80, 'admin', 'admin123')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
media_profile = media.GetProfiles()[0]
# Get PTZ configuration options for getting absolute move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration.token
# ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('AbsoluteMove')
request.ProfileToken = media_profile.token
ptz.Stop({'ProfileToken': media_profile.token})
if request.Position is None:
request.Position = ptz.GetStatus({
'ProfileToken': media_profile.token
}).Position
if request.Speed is None:
request.Speed = ptz.GetStatus({
'ProfileToken': media_profile.token
}).Position
request.Position.PanTilt.x = pan
request.Speed.PanTilt.x = pan_speed
request.Position.PanTilt.y = tilt
request.Speed.PanTilt.y = tilt_speed
request.Position.Zoom = zoom
request.Speed.Zoom = zoom_speed
ptz.AbsoluteMove(request)
# print(request)
print('finish')
def get_ptz():
mycam = ONVIFCamera('192.168.1.66', 80, 'admin', 'abcd1234')
media = mycam.create_media_service()
ptz = mycam.create_ptz_service()
request = ptz.create_type('GetStatus')
media_profile = media.GetProfiles()[0]
request.ProfileToken = media_profile._token
while 1:
try:
res = ptz.GetStatus(request)
#print(res)
rospy.loginfo(res.Position)
# print(res.Position)
# print(res.Position[0]._y)
sleep(0.1)
except Exception:
pass
def setup_move():
mycam = ONVIFCamera(IP, PORT, USER, PASS)
# Create media service object
media = mycam.create_media_service()
print(mycam.devicemgmt.GetDNS())
# Create ptz service object
if mycam.devicemgmt.GetCapabilities()['PTZ'] is None:
print("PTZ Not Support")
return False
else:
global ptz
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0]
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
confi = ptz.create_type('GetConfiguration')
request.ConfigurationToken = media_profile.PTZConfiguration.token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
#print(ptz_configuration_options)
global moverequest
moverequest = ptz.create_type('ContinuousMove')
moverequest.ProfileToken = media_profile.token
if moverequest.Velocity is None:
moverequest.Velocity = ptz.GetStatus({
'ProfileToken':
media_profile.token
}).Position
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[
0].YRange.Min
print("setup done")
return True
def continuous_move():
print 0
#mycam = ONVIFCamera('192.168.0.139',1018,'admin','8146dpr','/home/visionstudio/Desktop/wsdl')
global mycam,media,ptz,media_profile,request,ptz_configuration_options,tourlist
mycam = ONVIFCamera(ip,port,user,password,wsdl_dir)
# Create media service object
media = mycam.create_media_service()
# Get target profile
media_profile = media.GetProfiles()[0]
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
"""
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Min
"""
client = mqtt.Client("", True, None, mqtt.MQTTv31)
client.on_connect = on_connect
client.on_message = on_message
client.connect(mqtt_ip, 1883)
while (stop_flag == False):
client.loop()
def continuous_move():
mycam = ONVIFCamera('rtsp://192.168.1.101:554/onvif1', 5000, 'admin', '123','/usr/local/lib/python2.7/dist-packages/onvif-0.2.0-py2.7.egg/wsdl/')
# Create media service object
resp = mycam.devicemgmt.GetHostname()
print 'My camera`s hostname: ' + str(resp.Name)
media = mycam.create_media_service()
print "tao doi tuong..."
# Create ptz service object
ptz = mycam.create_ptz_service()
print "tao doi project..."
# Get target profile
media_profile = media.GetProfiles()[0];
print "tao profile.."
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
print "tao conf.."
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Min
# move right
print "right"
move_right(ptz, request)
print "left"
# move left
move_left(ptz, request)
# Move up
move_up(ptz, request)
# move down
move_down(ptz, request)
def __init__(self):
# @todo: config parsing
# dont touch this
zeep.xsd.simple.AnySimpleType.pythonvalue = self.zeep_pythonvalue
# hardcoded ip-port-log-pass
ip = '192.168.11.43'
port = 80
login = '******'
password = '******'
# @todo: code properly
self.width = None
self.height = None
self.UseRightThird = False
mycam = ONVIFCamera(ip, port, login, password)
media = mycam.create_media_service()
self.profile = media.GetProfiles()[0]
self.token = self.profile.token
self.ptz = mycam.create_ptz_service()
request = self.ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = self.profile.PTZConfiguration.token
ptz_configuration_options = self.ptz.GetConfigurationOptions(request)
request = self.ptz.create_type('ContinuousMove')
request.ProfileToken = self.profile.token
self.request2 = request
# gets url in a struct
streamURIStruct = media.GetStreamUri({
'StreamSetup': {
'Stream': 'RTP-Unicast',
'Transport': 'UDP'
},
'ProfileToken': self.token
})
# the url itself
self.streamURL = streamURIStruct.Uri
def __init__(self, hass, config):
"""Initialize a ONVIF camera."""
from onvif import ONVIFCamera, exceptions
super().__init__()
self._name = config.get(CONF_NAME)
self._ffmpeg_arguments = config.get(CONF_EXTRA_ARGUMENTS)
self._input = None
camera = None
try:
_LOGGER.debug("Connecting with ONVIF Camera: %s on port %s",
config.get(CONF_HOST), config.get(CONF_PORT))
camera = ONVIFCamera(
config.get(CONF_HOST), config.get(CONF_PORT),
config.get(CONF_USERNAME), config.get(CONF_PASSWORD)
)
media_service = camera.create_media_service()
self._profiles = media_service.GetProfiles()
self._profile_index = config.get(CONF_PROFILE)
if self._profile_index >= len(self._profiles):
_LOGGER.warning("ONVIF Camera '%s' doesn't provide profile %d."
" Using the last profile.",
self._name, self._profile_index)
self._profile_index = -1
req = media_service.create_type('GetStreamUri')
# pylint: disable=protected-access
req.ProfileToken = self._profiles[self._profile_index]._token
self._input = media_service.GetStreamUri(req).Uri.replace(
'rtsp://', 'rtsp://{}:{}@'.format(
config.get(CONF_USERNAME),
config.get(CONF_PASSWORD)), 1)
_LOGGER.debug(
"ONVIF Camera Using the following URL for %s: %s",
self._name, self._input)
except Exception as err:
_LOGGER.error("Unable to communicate with ONVIF Camera: %s", err)
raise
try:
self._ptz = camera.create_ptz_service()
except exceptions.ONVIFError as err:
self._ptz = None
_LOGGER.warning("Unable to setup PTZ for ONVIF Camera: %s", err)
def connect(camera):
# connects to camera after pressing the connect button
import settings
global token, ptz
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
ip = settings.net + '.' + str(camera)
cameraList = settings.cameras
for i in range(len(cameraList)):
if camera == cameraList[i]:
index = i
portList = settings.ports
port = portList[index]
login = '******'
password = '******'
cam = ONVIFCamera(ip, port, login, password)
media = cam.create_media_service()
profile = media.GetProfiles()[0]
token = profile.token
ptz = cam.create_ptz_service()
print('connected')
def connect(camera):
# connects to camera after pressing the connect button
import settings
global token, ptz
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
ip = settings.net + '.' + str(camera)
cameraList = settings.cameras
for i in range(len(cameraList)):
if camera == cameraList[i]:
index = i
portList = settings.ports
port = portList[index]
login = '******'
password = '******'
cam = ONVIFCamera(ip, port, login, password)
media = cam.create_media_service()
profile = media.GetProfiles()[0]
token = profile.token
ptz = cam.create_ptz_service()
print('connected')
def __init__(self, hass, config):
"""Initialize a ONVIF camera."""
from onvif import ONVIFCamera, exceptions
super().__init__()
self._name = config.get(CONF_NAME)
self._ffmpeg_arguments = config.get(CONF_EXTRA_ARGUMENTS)
self._input = None
camera = None
try:
_LOGGER.debug("Connecting with ONVIF Camera: %s on port %s",
config.get(CONF_HOST), config.get(CONF_PORT))
camera = ONVIFCamera(config.get(CONF_HOST), config.get(CONF_PORT),
config.get(CONF_USERNAME),
config.get(CONF_PASSWORD))
media_service = camera.create_media_service()
self._profiles = media_service.GetProfiles()
self._profile_index = config.get(CONF_PROFILE)
if self._profile_index >= len(self._profiles):
_LOGGER.warning(
"ONVIF Camera '%s' doesn't provide profile %d."
" Using the last profile.", self._name,
self._profile_index)
self._profile_index = -1
req = media_service.create_type('GetStreamUri')
# pylint: disable=protected-access
req.ProfileToken = self._profiles[self._profile_index]._token
self._input = media_service.GetStreamUri(req).Uri.replace(
'rtsp://', 'rtsp://{}:{}@'.format(config.get(CONF_USERNAME),
config.get(CONF_PASSWORD)),
1)
_LOGGER.debug("ONVIF Camera Using the following URL for %s: %s",
self._name, self._input)
except Exception as err:
_LOGGER.error("Unable to communicate with ONVIF Camera: %s", err)
raise
try:
self._ptz = camera.create_ptz_service()
except exceptions.ONVIFError as err:
self._ptz = None
_LOGGER.warning("Unable to setup PTZ for ONVIF Camera: %s", err)
def continuous_move():
mycam = ONVIFCamera('192.168.0.112', 80, 'admin', '12345')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0];
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = media_profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = media_profile._token
ptz.Stop({'ProfileToken': media_profile._token})
# Get range of pan and tilt
# NOTE: X and Y are velocity vector
global XMAX, XMIN, YMAX, YMIN
XMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Max
XMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].XRange.Min
YMAX = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Max
YMIN = ptz_configuration_options.Spaces.ContinuousPanTiltVelocitySpace[0].YRange.Min
# move right
move_right(ptz, request)
# move left
move_left(ptz, request)
# Move up
move_up(ptz, request)
# move down
move_down(ptz, request)
class ONVIFHassCamera(Camera):
"""An implementation of an ONVIF camera."""
def __init__(self, hass, config):
"""Initialize an ONVIF camera."""
super().__init__()
_LOGGER.debug("Importing dependencies")
import onvif
from onvif import ONVIFCamera
_LOGGER.debug("Setting up the ONVIF camera component")
self._username = config.get(CONF_USERNAME)
self._password = config.get(CONF_PASSWORD)
self._host = config.get(CONF_HOST)
self._port = config.get(CONF_PORT)
self._name = config.get(CONF_NAME)
self._ffmpeg_arguments = config.get(CONF_EXTRA_ARGUMENTS)
self._profile_index = config.get(CONF_PROFILE)
self._ptz_service = None
self._input = None
_LOGGER.debug("Setting up the ONVIF camera device @ '%s:%s'",
self._host,
self._port)
self._camera = ONVIFCamera(self._host,
self._port,
self._username,
self._password,
'{}/wsdl/'
.format(os.path.dirname(onvif.__file__)))
async def async_initialize(self):
"""
Initialize the camera.
Initializes the camera by obtaining the input uri and connecting to
the camera. Also retrieves the ONVIF profiles.
"""
from aiohttp.client_exceptions import ClientConnectorError
from homeassistant.exceptions import PlatformNotReady
from zeep.exceptions import Fault
import homeassistant.util.dt as dt_util
try:
_LOGGER.debug("Updating service addresses")
await self._camera.update_xaddrs()
_LOGGER.debug("Setting up the ONVIF device management service")
devicemgmt = self._camera.create_devicemgmt_service()
_LOGGER.debug("Retrieving current camera date/time")
system_date = dt_util.utcnow()
device_time = await devicemgmt.GetSystemDateAndTime()
if device_time:
cdate = device_time.UTCDateTime
cam_date = dt.datetime(cdate.Date.Year, cdate.Date.Month,
cdate.Date.Day, cdate.Time.Hour,
cdate.Time.Minute, cdate.Time.Second,
0, dt_util.UTC)
_LOGGER.debug("Camera date/time: %s",
cam_date)
_LOGGER.debug("System date/time: %s",
system_date)
dt_diff = cam_date - system_date
dt_diff_seconds = dt_diff.total_seconds()
if dt_diff_seconds > 5:
_LOGGER.warning("The date/time on the camera is '%s', "
"which is different from the system '%s', "
"this could lead to authentication issues",
cam_date,
system_date)
_LOGGER.debug("Obtaining input uri")
await self.async_obtain_input_uri()
_LOGGER.debug("Setting up the ONVIF PTZ service")
if self._camera.get_service('ptz', create=False) is None:
_LOGGER.warning("PTZ is not available on this camera")
else:
self._ptz_service = self._camera.create_ptz_service()
_LOGGER.debug("Completed set up of the ONVIF camera component")
except ClientConnectorError as err:
_LOGGER.warning("Couldn't connect to camera '%s', but will "
"retry later. Error: %s",
self._name, err)
raise PlatformNotReady
except Fault as err:
_LOGGER.error("Couldn't connect to camera '%s', please verify "
"that the credentials are correct. Error: %s",
self._name, err)
return
async def async_obtain_input_uri(self):
"""Set the input uri for the camera."""
from onvif import exceptions
_LOGGER.debug("Connecting with ONVIF Camera: %s on port %s",
self._host, self._port)
try:
_LOGGER.debug("Retrieving profiles")
media_service = self._camera.create_media_service()
profiles = await media_service.GetProfiles()
_LOGGER.debug("Retrieved '%d' profiles",
len(profiles))
if self._profile_index >= len(profiles):
_LOGGER.warning("ONVIF Camera '%s' doesn't provide profile %d."
" Using the last profile.",
self._name, self._profile_index)
self._profile_index = -1
_LOGGER.debug("Using profile index '%d'",
self._profile_index)
_LOGGER.debug("Retrieving stream uri")
req = media_service.create_type('GetStreamUri')
req.ProfileToken = profiles[self._profile_index].token
req.StreamSetup = {'Stream': 'RTP-Unicast',
'Transport': {'Protocol': 'RTSP'}}
stream_uri = await media_service.GetStreamUri(req)
uri_no_auth = stream_uri.Uri
uri_for_log = uri_no_auth.replace(
'rtsp://', 'rtsp://<user>:<password>@', 1)
self._input = uri_no_auth.replace(
'rtsp://', 'rtsp://{}:{}@'.format(self._username,
self._password), 1)
_LOGGER.debug(
"ONVIF Camera Using the following URL for %s: %s",
self._name, uri_for_log)
except exceptions.ONVIFError as err:
_LOGGER.error("Couldn't setup camera '%s'. Error: %s",
self._name, err)
return
async def async_perform_ptz(self, pan, tilt, zoom):
"""Perform a PTZ action on the camera."""
from onvif import exceptions
if self._ptz_service is None:
_LOGGER.warning("PTZ actions are not supported on camera '%s'",
self._name)
return
if self._ptz_service:
pan_val = 1 if pan == DIR_RIGHT else -1 if pan == DIR_LEFT else 0
tilt_val = 1 if tilt == DIR_UP else -1 if tilt == DIR_DOWN else 0
zoom_val = 1 if zoom == ZOOM_IN else -1 if zoom == ZOOM_OUT else 0
req = {"Velocity": {
"PanTilt": {"_x": pan_val, "_y": tilt_val},
"Zoom": {"_x": zoom_val}}}
try:
_LOGGER.debug(
"Calling PTZ | Pan = %d | Tilt = %d | Zoom = %d",
pan_val, tilt_val, zoom_val)
await self._ptz_service.ContinuousMove(req)
except exceptions.ONVIFError as err:
if "Bad Request" in err.reason:
self._ptz_service = None
_LOGGER.debug("Camera '%s' doesn't support PTZ.",
self._name)
else:
_LOGGER.debug("Camera '%s' doesn't support PTZ.", self._name)
async def async_added_to_hass(self):
"""Handle entity addition to hass."""
_LOGGER.debug("Camera '%s' added to hass", self._name)
if ONVIF_DATA not in self.hass.data:
self.hass.data[ONVIF_DATA] = {}
self.hass.data[ONVIF_DATA][ENTITIES] = []
self.hass.data[ONVIF_DATA][ENTITIES].append(self)
async def async_camera_image(self):
"""Return a still image response from the camera."""
from haffmpeg.tools import ImageFrame, IMAGE_JPEG
_LOGGER.debug("Retrieving image from camera '%s'", self._name)
ffmpeg = ImageFrame(
self.hass.data[DATA_FFMPEG].binary, loop=self.hass.loop)
image = await asyncio.shield(ffmpeg.get_image(
self._input, output_format=IMAGE_JPEG,
extra_cmd=self._ffmpeg_arguments), loop=self.hass.loop)
return image
async def handle_async_mjpeg_stream(self, request):
"""Generate an HTTP MJPEG stream from the camera."""
from haffmpeg.camera import CameraMjpeg
_LOGGER.debug("Handling mjpeg stream from camera '%s'", self._name)
ffmpeg_manager = self.hass.data[DATA_FFMPEG]
stream = CameraMjpeg(ffmpeg_manager.binary,
loop=self.hass.loop)
await stream.open_camera(
self._input, extra_cmd=self._ffmpeg_arguments)
try:
stream_reader = await stream.get_reader()
return await async_aiohttp_proxy_stream(
self.hass, request, stream_reader,
ffmpeg_manager.ffmpeg_stream_content_type)
finally:
await stream.close()
@property
def supported_features(self):
"""Return supported features."""
if self._input:
return SUPPORT_STREAM
return 0
@property
def stream_source(self):
"""Return the stream source."""
return self._input
@property
def name(self):
"""Return the name of this camera."""
return self._name
def __init__(self):
# reading config
path = os.getcwd() + '/engine/utils/config.py'
try:
d = open(path, 'r')
print('opening config successful')
except IOError:
print('error while opening config, loading default config')
d = open(os.getcwd() + '/engine/utils/defaultConfig.py', 'r')
dconfig = d.read()
config = literal_eval(dconfig)
# dont touch this
zeep.xsd.simple.AnySimpleType.pythonvalue = self.zeep_pythonvalue
# getting ip-port-log-pass-orientation-zoom from config
ip = config.get('IP')
port = config.get('port')
login = config.get('login')
password = config.get('password')
self.UseRightThird = config.get('right')
#zoom = config.get('zoom')
""" if code above doesnt work this the hardcoded version
ip = '192.168.11.43'
port = 80
login = '******'
password = '******'
self.UseRightThird = False
"""
mycam = ONVIFCamera(ip, port, login, password)
media = mycam.create_media_service()
profiles = media.GetProfiles()
createP = True
profileNo = None
for i in range(len(profiles)):
profile = profiles[i]
if profile.Name == 'trackingProfile':
createP = False
profileNo = i
print('Profile already exists')
if createP:
print('Profile not found, creating new profile')
media.CreateProfile('trackingProfile')
self.profile = media.GetProfiles()[len(media.GetProfiles())-1]
#adding video source configuration to the profile
vidsrc = media.GetVideoSourceConfigurations()[0]
addVidSrc = media.create_type('AddVideoSourceConfiguration')
addVidSrc.ProfileToken = self.profile.token
addVidSrc.ConfigurationToken = vidsrc.token
media.AddVideoSourceConfiguration(addVidSrc)
print('Video source config set')
#adding video analytics configuration to the profile
try:
vidan = media.GetVideoAnalyticsConfigurations()[0]
addVidAn = media.create_type('AddVideoAnalyticsConfiguration')
addVidAn.ProfileToken = self.profile.token
addVidAn.ConfigurationToken = vidan.token
media.AddVideoAnalyticsConfiguration(addVidAn)
print('Video analytics config set')
except:
print('Couldnt set video analytics')
#adding PTZ configuration to the profile
self.ptz = mycam.create_ptz_service()
ptzc = self.ptz.GetConfigurations()[0]
addPTZ = media.create_type('AddPTZConfiguration')
addPTZ.ProfileToken = self.profile.token
addPTZ.ConfigurationToken = ptzc.token
media.AddPTZConfiguration(addPTZ)
print('PTZ config set')
#adding video encoder configuration to the profile
vEncoderConfig = media.GetVideoEncoderConfigurations()[len(media.GetVideoEncoderConfigurations())-1]
options = media.GetVideoEncoderConfigurationOptions()
try:
if options.JPEG:
print('JPEG encoding exists')
vEncoderConfig.Encoding = 'JPEG'
opIndex = None
for count in range(len(options.JPEG.ResolutionsAvailable)):
if options.JPEG.ResolutionsAvailable[count].Width == 1280 and options.JPEG.ResolutionsAvailable[count].Height == 720:
opIndex = count
if opIndex == None:
for count in range(len(options.JPEG.ResolutionsAvailable)):
if options.JPEG.ResolutionsAvailable[count].Width > 700 and options.JPEG.ResolutionsAvailable[count].Width <1281:
opIndex = count
break
if opIndex == None:
opIndex = len(options.JPEG.ResolutionsAvailable)-1
vEncoderConfig.Resolution.Width = options.JPEG.ResolutionsAvailable[opIndex].Width
vEncoderConfig.Resolution.Height = options.JPEG.ResolutionsAvailable[opIndex].Height
print('Width = ', vEncoderConfig.Resolution.Width, '; Height = ', vEncoderConfig.Resolution.Height)
vEncoderConfig.RateControl.FrameRateLimit = 4
vEncoderConfig.Quality = options.QualityRange.Max
print('after quality setting')
except:
print('JPEG encoding doesnt exist')
vEncoderConfig.Resolution.Width = 1280
vEncoderConfig.Resolution.Height = 720
vEncoderConfig.RateControl.FrameRateLimit = 4
vEncoderConfig.Quality = options.QualityRange.Max
setVideoEncode = media.create_type('SetVideoEncoderConfiguration')
print('type created')
setVideoEncode.ForcePersistence = True
setVideoEncode.Configuration = vEncoderConfig
print('setvideoencode ready for setting')
#media.SetVideoEncoderConfiguration(setVideoEncode)
print('setvideoencoder success')
addVideoEncode = media.create_type('AddVideoEncoderConfiguration')
addVideoEncode.ProfileToken = self.profile.token
addVideoEncode.ConfigurationToken = vEncoderConfig.token
# not setting the video encoder because of broken onvif python3 implementation
#media.AddVideoEncoderConfiguration(addVideoEncode)
print('Video encoder set')
else:
self.profile = media.GetProfiles()[profileNo]
print('Profile selected')
print(self.profile.Name)
# get height - width of the frame to use in move module
self.width = self.profile.VideoEncoderConfiguration.Resolution.Width
print('Got width = ', self.width)
self.height = self.profile.VideoEncoderConfiguration.Resolution.Height
print('Codec = ', self.profile.VideoEncoderConfiguration.Encoding)
print('FPS = ', self.profile.VideoEncoderConfiguration.RateControl.FrameRateLimit)
self.token = self.profile.token
self.ptz = mycam.create_ptz_service()
# getting current absolute pantilt coordinates
#currentStatus = self.ptz.GetStatus(self.token)
#absX = currentStatus.Position.PanTilt.x
#absY = currentStatus.Position.PanTilt.y
# setting the specified zoom
#zoomRequest = {'Position': {'Zoom': {'space': '', 'x': zoom}, 'PanTilt': {'space': '', 'y': absY, 'x': absX}}, 'ProfileToken': self.token}
#self.ptz.AbsoluteMove(zoomRequest)
# gets url in a struct
streamURIStruct = media.GetStreamUri({'StreamSetup': {'Stream': 'RTP-Unicast', 'Transport': 'UDP'}, 'ProfileToken': self.token})
# the url itself
self.streamURL = 'rtsp://' + ip + ':554' + '/Streaming/Channels/2'
print(self.streamURL)
Created on Sat Oct 24 14:49:21 2015
@author: Lily
"""
from onvif import ONVIFCamera
#import time
mycam = ONVIFCamera('10.2.1.49', 80, 'admin', '12345', 'C:\onvif\wsdl\\')
#mycam = ONVIFCamera('10.2.1.49', 80, 'admin', '12345', 'C:\onvif\wsdl\\')
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# Get target profile
media_profile = media.GetProfiles()[0];
#media = mycam.create_media_service()
#device = mycam.create_devicemgmt_service()
# Get target profile
#print mycam.devicemgmt.GetServices({'IncludeCapability': False })
#print media.GetStreamUri()
# Get PTZ configuration options for getting continuous move range
request = ptz.create_type('GetConfigurationOptions')
