def media_profile_configuration():
'''
A media profile consists of configuration entities such as video/audio
source configuration, video/audio encoder configuration,
or PTZ configuration. This use case describes how to change one
configuration entity which has been already added to the media profile.
'''
# Create the media service
# mycam = ONVIFCamera('192.168.0.112', 80, 'admin', '12345')
mycam = ONVIFCamera('10.9.6.49', 80, 'admin', '12345', 'C:\onvif\wsdl\\')
media_service = mycam.create_media_service()
profiles = media_service.GetProfiles()
# Use the first profile and Profiles have at least one
token = profiles[0]._token
# Get all video encoder configurations
configurations_list = media_service.GetVideoEncoderConfigurations()
# Use the first profile and Profiles have at least one
video_encoder_configuration = configurations_list[0]
# Get video encoder configuration options
options = media_service.GetVideoEncoderConfigurationOptions({'ProfileToken':token})
# Setup stream configuration
video_encoder_configuration.Encoding = 'H264'
# Setup Resolution
video_encoder_configuration.Resolution.Width = \
options.H264.ResolutionsAvailable[0].Width
video_encoder_configuration.Resolution.Height = \
options.H264.ResolutionsAvailable[0].Height
# Setup Quality
video_encoder_configuration.Quality = options.QualityRange.Max
# Setup FramRate
video_encoder_configuration.RateControl.FrameRateLimit = \
options.H264.FrameRateRange.Max
# Setup EncodingInterval
video_encoder_configuration.RateControl.EncodingInterval = \
options.H264.EncodingIntervalRange.Max
# Setup Bitrate
video_encoder_configuration.RateControl.BitrateLimit = \
options.Extension.H264[0].BitrateRange[0].Min[0]
# Create request type instance
request = media_service.create_type('SetVideoEncoderConfiguration')
request.Configuration = video_encoder_configuration
# ForcePersistence is obsolete and should always be assumed to be True
request.ForcePersistence = True
# Set the video encoder configuration
media_service.SetVideoEncoderConfiguration(request)
def rotate_image_180():
''' Rotate the image '''
# Create the media service
mycam = ONVIFCamera('192.168.0.112', 80, 'admin', '12345')
media_service = mycam.create_media_service()
profiles = media_service.GetProfiles()
# Use the first profile and Profiles have at least one
token = profiles[0]._token
# Get all video source configurations
configurations_list = media_service.GetVideoSourceConfigurations()
# Use the first profile and Profiles have at least one
video_source_configuration = configurations_list[0]
# Enable rotate
video_source_configuration.Extension[0].Rotate[0].Mode[0] = 'OFF'
# Create request type instance
request = media_service.create_type('SetVideoSourceConfiguration')
request.Configuration = video_source_configuration
# ForcePersistence is obsolete and should always be assumed to be True
request.ForcePersistence = True
# Set the video source configuration
media_service.SetVideoSourceConfiguration(request)
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 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
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 __deviceProc(self):
res = url.urlparse(self.__xaddr)
print(res)
tmp = res[1].split(':')
ip = tmp[0]
if len(tmp) > 1:
port = tmp[1]
else:
port = 80
num, matrix = read_anno_config('./Elec_Solution2/config/anno0.json')
# get camera instance
cam = ONVIFCamera(ip, port, '', '')
# create media service
media_service = cam.create_media_service()
token = '000'
# set video configuration
configurations_list = media_service.GetVideoEncoderConfigurations()
video_encoder_configuration = configurations_list[0]
options = media_service.GetVideoEncoderConfigurationOptions({'ProfileToken':token})
video_encoder_configuration.Encoding = 'H264'
video_encoder_configuration.Resolution = options.H264.ResolutionsAvailable[0]
request = media_service.create_type('SetVideoEncoderConfiguration')
request.Configuration = video_encoder_configuration
request.ForcePersistence = True
media_service.SetVideoEncoderConfiguration(request)
# get video stream
streamSetup = {
'StreamSetup': {
'Stream': 'RTP-Unicast',
'Transport': {
'Protocol': 'TCP'
}
},
'ProfileToken': token
}
res = media_service.GetStreamUri(streamSetup)
self.__rtsp = cv2.VideoCapture(res.Uri)
reporter = context.getContext().reporter
# capture and detect
while self.__rtsp.isOpened():
print('%s capture start...' % ip)
start = time.time()
print('start: %d' % start)
ret, frame = self.__rtsp.read()
print('capture: %d' % time.time())
# img = cv2.cvtColor(numpy.asarray(frame),cv2.COLOR_RGB2BGR)
print('convert: %d' % time.time())
tmp = self.__urn.split('-')
name = tmp[-1] + '.jpg'
cv2.imwrite(name, frame)
detect_result = entry_detect(frame, num, matrix)
print(detect_result)
print('%s capture end %d. duration:%d' % (ip, time.time(), time.time() - start))
reporter.publish('hm_test', detect_result)
time.sleep(10)
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():
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 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 __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)
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 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)
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 photo():
# Set up the camera object using the ONVIF port.
mycam = ONVIFCamera(
'192.168.1.108', 80, 'admin', '10iLtxyh',
'/home/coovi/pCloudDrive/Projects/Jane/Amigos/III/amigos/amigos/onvif/wsdl'
)
media = mycam.create_media_service()
allProfiles = media.GetProfiles()
mainProfile = media.GetProfile({'ProfileToken': allProfiles[0]._token})
snapshot = media.GetSnapshotUri({'ProfileToken': mainProfile._token})
# print (dir(media))
# snapShot_url = snapshot.Uri
# url = snapshot.Uri #making the url downloadable
# To get the current datetime use:
dt = str(datetime.datetime.now())
username = '******' # The cameras user name
password = '******' # the cameras password
# bypass the username and password authentication
response = requests.get(snapshot.Uri,
auth=HTTPDigestAuth(username, password))
f = open('pic.jpg', 'wb') # opening
newname = 'file_' + dt + '.jpg' # Write the file to the time stamp
os.rename('pic.jpg', newname)
f.write(response.content)
f.close()
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)
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 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 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 camera_start(self):
"""Start module.
"""
mycam = ONVIFCamera(self.cam_ip, 80, self.cam_user, self.cam_password, no_cache = True)
media = mycam.create_media_service()
media_profile = media.GetProfiles()[0]
self.mycam = mycam
self.camera_media = media
self.camera_media_profile = media_profile
def media_profile_configuration():
'''
A media profile consists of configuration entities such as video/audio
source configuration, video/audio encoder configuration,
or PTZ configuration. This use case describes how to change one
configuration entity which has been already added to the media profile.
'''
# Create the media service
# mycam = ONVIFCamera('192.168.0.112', 80, 'admin', '12345')
mycam = ONVIFCamera('10.9.6.49', 80, 'admin', '12345', 'C:\onvif\wsdl\\')
media_service = mycam.create_media_service()
profiles = media_service.GetProfiles()
# Use the first profile and Profiles have at least one
token = profiles[0]._token
# Get all video encoder configurations
configurations_list = media_service.GetVideoEncoderConfigurations()
# Use the first profile and Profiles have at least one
video_encoder_configuration = configurations_list[0]
# Get video encoder configuration options
options = media_service.GetVideoEncoderConfigurationOptions(
{'ProfileToken': token})
# Setup stream configuration
video_encoder_configuration.Encoding = 'H264'
# Setup Resolution
video_encoder_configuration.Resolution.Width = \
options.H264.ResolutionsAvailable[0].Width
video_encoder_configuration.Resolution.Height = \
options.H264.ResolutionsAvailable[0].Height
# Setup Quality
video_encoder_configuration.Quality = options.QualityRange.Max
# Setup FramRate
video_encoder_configuration.RateControl.FrameRateLimit = \
options.H264.FrameRateRange.Max
# Setup EncodingInterval
video_encoder_configuration.RateControl.EncodingInterval = \
options.H264.EncodingIntervalRange.Max
# Setup Bitrate
video_encoder_configuration.RateControl.BitrateLimit = \
options.Extension.H264[0].BitrateRange[0].Min[0]
# Create request type instance
request = media_service.create_type('SetVideoEncoderConfiguration')
request.Configuration = video_encoder_configuration
# ForcePersistence is obsolete and should always be assumed to be True
request.ForcePersistence = True
# Set the video encoder configuration
media_service.SetVideoEncoderConfiguration(request)
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 main():
# __init()
print("start...")
global discovery
discovery = discover.Discover('test')
devInfos = discovery.discover()
for info in devInfos:
res = url.urlparse(info.xaddr)
print(res)
tmp = res[1].split(':')
ip = tmp[0]
if len(tmp) > 1:
port = tmp[1]
else:
port = 80
# get camera instance
cam = ONVIFCamera(ip, port, '', '')
# create media service
media_service = cam.create_media_service()
token = '000'
# set video configuration
configurations_list = media_service.GetVideoEncoderConfigurations()
video_encoder_configuration = configurations_list[0]
options = media_service.GetVideoEncoderConfigurationOptions(
{'ProfileToken': token})
video_encoder_configuration.Encoding = 'H264'
video_encoder_configuration.Resolution = options.H264.ResolutionsAvailable[
0]
request = media_service.create_type('SetVideoEncoderConfiguration')
request.Configuration = video_encoder_configuration
request.ForcePersistence = True
media_service.SetVideoEncoderConfiguration(request)
# get video stream
streamSetup = {
'StreamSetup': {
'Stream': 'RTP-Unicast',
'Transport': {
'Protocol': 'TCP'
}
},
'ProfileToken': '000'
}
res = media_service.GetStreamUri(streamSetup)
rtspclt = rtsp.Client(rtsp_server_uri=res.Uri)
content = rtspclt.read()
img = cv2.cvtColor(numpy.asarray(content), cv2.COLOR_RGB2BGR)
tmp = info.urn.split('-')
name = tmp[-1] + '.jpg'
cv2.imwrite(name, img)
def focus(x, s):
# Connecting to Camera
mycam = ONVIFCamera('192.168.15.43', 80, 'admin', 'Supervisor',
'C:\Users\komar\Documents\python-onvif-master\wsdl')
# Creation of Media Service
media = mycam.create_media_service()
# Getting of Media Profile
media_profile = media.GetProfiles()[0]
# Creation of Imaging Service
img = mycam.create_imaging_service()
# Creation of Request for supported Focus Move modes with Video Source Token
request = img.create_type('GetMoveOptions')
request.VideoSourceToken = media_profile.VideoSourceConfiguration.SourceToken
# Getting Focus Move options
move_options = img.GetMoveOptions(request)
print move_options
# Getting Current Focus Status
# status = img.GetStatus({'VideoSourceToken': media_profile.VideoSourceConfiguration.SourceToken})
# print status
# Creation of Request for Focus Move with Video Source Token
request = img.create_type('Move')
request.VideoSourceToken = media_profile.VideoSourceConfiguration.SourceToken
# Setting Focus Move Params
# Absolute Move
# request.Focus.Absolute.Position = x
# request.Focus.Absolute.Speed = s
# Continuous Move
request.Focus.Continuous.Speed = s
# Relative Move
# request.Focus.Relative.Distance = x
# request.Focus.Relative.Speed = s
# Calling Move Method of Imaging Service with request as a param
img.Move(request)
# Stopping any movement after 5 seconds delay
sleep(5)
img.Stop({
'VideoSourceToken':
media_profile.VideoSourceConfiguration.SourceToken
})
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 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
class Camera:
def __init__(self, address, user, password):
self.dvrip = DVRIPCam(address, user, password)
loginok = self.dvrip.login()
if not loginok:
raise ValueError('Login failed')
self.onvif = ONVIFCamera(address, 8899, user, password,
'../venv/lib/python3.7/site-packages/wsdl/')
self.onvif_media = self.onvif.create_media_service()
def step(self, direction, sleep=0.1):
assert direction in ('DirectionUp', 'DirectionDown', 'DirectionLeft',
'DirectionRight')
self.dvrip.ptz(direction, preset=65535) # move
time.sleep(sleep)
self.dvrip.ptz(direction, preset=-1) # Stop
def get_snapshot_uri(self):
for profile in ('000', '001', '002'):
snapshot_uri = self.onvif.media.GetSnapshotUri('000').Uri
logging.info("Snapshot uri is: %s for profile %s", snapshot_uri,
profile)
return snapshot_uri
def acquire(self, filename=None):
if filename is None:
filename = datetime.datetime.now().isoformat() + '.jpg'
logging.info('Saving file to %s', filename)
hdr = {'Accept': '*/*'}
with open(filename, 'wb') as fout:
'''
r = requests.get(self.get_snapshot_uri(), stream=True, headers=hdr)
if r.status_code == 200:
with open(path, 'wb') as f:
r.raw.decode_content = True
shutil.copyfileobj(r.raw, fout)
'''
response = urlopen(self.get_snapshot_uri())
data = response.read()
fout.write(data)
def close(self):
self.dvrip.close()
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 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)
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)
class onvif_host:
'''
onvif device class info
'''
def __init__(self, ip, port, username, password):
self.ip = ip
self.port = port
self.username = username
self.password = password
if sys.platform == 'win32':
wsdl_path = os.path.join(os.path.dirname(onvif.__file__), os.path.pardir, "wsdl")
self.camera = ONVIFCamera(ip, port, username, password, wsdl_path)
else:
self.camera = ONVIFCamera(ip, port, username, password)
def __check_user_exist__(self, username, users = None):
user_lists = self.camera.devicemgmt.GetUsers()
if users is None:
users = dict()
users.clear()
user_name_lists = list()
for user_item in user_lists:
user_name_lists.append(user_item.Username)
if not users.has_key(user_item.Username) and user_item.Username == username:
if hasattr(user_item, 'Username'):
users['Username'] = user_item.Username
if hasattr(user_item, 'Password'):
users['Password'] = user_item.Password
if hasattr(user_item, 'UserLevel'):
users['UserLevel'] = user_item.UserLevel
if username not in user_name_lists:
return False
else:
return True
def get_stream_url(self, out_data=None):
media_capability_name ='Meda'
media_info = self.camera.devicemgmt.GetCapabilities({'Categroy':media_capability_name})
if out_data is None:
out_data = list()
if media_info.Media.StreamingCapabilities.RTP_RTSP_TCP or media_info.Media.StreamingCapabilities.RTP_TCP:
media_service = self.camera.create_media_service()
profiles = media_service.GetProfiles()
url_nodes = ET.Element('stream_url_lists')
for item in profiles:
stream = {'StreamSetup':{'StreamType':'RTP_unicast','Transport':'RTSP'}, 'ProfileToken':item._token}
stream_url = media_service.GetStreamUri(stream)
url_node = ET.SubElement(url_nodes,'stream_url')
url_node.text = stream_url.Uri
if type(out_data) == list:
out_data.append(ET.tostring(url_nodes))
elif type(out_data) == str:
out_data.join(ET.tostring(url_nodes))
def get_device_status(self, out_data, out_data_type):
"""get device current status"""
return 0
def add_user(self, out_data, username, password, level=None):
"""add a user to device"""
logger.debug(locals())
if level is None:
level = 'Operator'
user = {'User':{'Username':username, 'Password':password, 'UserLevel':level}}
user_lists_node = ET.Element('user_lists')
user_content = ET.SubElement(user_lists_node, 'user')
user_content.set('name', username)
if self.__check_user_exist__(username):
user_content.text = 'False'
user_content.set('error_message', 'user exist')
else:
try:
out_response = self.camera.devicemgmt.CreateUsers(user)
user_content.text = 'True'
except:
user_content.text = 'False'
out_data.append(ET.tostring(user_lists_node))
def del_user(self, out_data, username):
""" delete a device user."""
logger.debug(locals())
user = {'Username':username}
user_lists_node = ET.Element('user_lists')
user_content = ET.SubElement(user_lists_node, 'user')
user_content.set('name', username)
if self.__check_user_exist__(username):
out_response = self.camera.devicemgmt.DeleteUsers(user)
user_content.text = 'True'
else:
user_content.text = 'False'
user_content.set('error_message', 'user not exist')
if type(out_data) == types.ListType:
out_data.append(ET.tostring(user_lists_node))
def alter_user(self, out_data, username, level, password=None):
"""alter device user info"""
logger.debug(locals())
users = dict()
user_lists_node = ET.Element('user_lists')
user_content = ET.SubElement(user_lists_node, 'user')
user_content.set('name', username)
if self.__check_user_exist__(username, users):
if password is None:
user = {'User':{'Username':username, 'UserLevel':level}}
self.camera.devicemgmt.SetUser(user)
else:
user = {'User':{'Username':username, 'UserLevel':level, 'Password':password}}
self.camera.devicemgmt.SetUser(user)
user_content.text = 'True'
else:
logger.warning("user %s not exitst", username)
user_content.text = 'False'
out_data.append(ET.tostring(user_lists_node))
def reboot_device(self, out_data):
"""device reboot"""
logger.debug(locals())
response = self.camera.devicemgmt.SystemReboot()
logger.debug(response)
# -*- coding: utf-8 -*-
"""
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()
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
