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