continue
seen_services.append(service.getXAddrs()[0])
parsed = urllib.parse.urlparse(service.getXAddrs()[0])
parts = parsed.netloc.split(':')
ip = parts[0]
if len(parts) > 1:
port = parts[1]
else:
port = 80
for authinfo in try_auth:
try:
print("Trying ONVIFCamera({ip}, {port}, {user}, {passwd})".format(
ip=ip, port=port, user=authinfo[0], passwd=authinfo[1]))
mycam = ONVIFCamera(ip, port, authinfo[0], authinfo[1])
except ONVIFError as e:
print("Got error {}".format(e))
continue
print("=> Scopes:")
scopes = service.getScopes()
for scope in scopes:
print(" {}({})".format(type(scope),repr(scope)))
print("=> Streams:")
media_service = mycam.create_media_service()
profiles = media_service.GetProfiles()
for profile in profiles:
try:
params = media_service.create_type('GetStreamUri')
# option 2
# else:
# angle_calib_y = (angle_calib_y - (-0.348))*2/1.133 - 1
# print('angle_calib_y: ', angle_calib_y)
ptz_object.move_abs(angle_calib, angle_calib_y, 0.2)
if __name__ == '__main__':
import sys
# get the config params
config = yaml.safe_load(open("config.yml"))
config_user = yaml.safe_load(open("config_user.yml"))
# Define the onvif device
onvif_device = ONVIFCamera(config_user['ip'], 80, config_user['login'],
config_user['password'],
'python-onvif-zeep/wsdl/')
# create the ptz class
ptz_object = PTZ(onvif_device)
app = QtWidgets.QApplication(sys.argv)
window = Window()
window.setGeometry(200, 200, 900, 700)
window.show()
sys.exit(app.exec_())
import cv2
import numpy
from time import sleep
from matplotlib import pyplot as plt
#Удаление данной ошибки pythonvalue() not implemented
import zeep
from onvif import ONVIFCamera, ONVIFService
def zeep_pythonvalue(self, xmlvalue):
return xmlvalue
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
#Подключение к камере
from onvif import ONVIFCamera
mycam = ONVIFCamera('192.168.15.43', 80, 'admin', 'Supervisor')
#Получаем поток
str=cv2.VideoCapture('rtsp://192.168.15.43:554/2')
#Создаём гистограмму
fig=plt.figure(figsize=(2, 2))
color = ('b','g','r')
ret,frame=str.read()
cv2.imshow('qwerty',frame)
hsv = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)
hist = cv2.calcHist([hsv], [0,1], None, [180, 256], [0, 180, 0, 256]) #Оттенок 180 Насыщенность 256
fig.add_subplot(2, 2, 1)
plt.imshow(hist,interpolation = 'nearest')
fig.add_subplot(2, 2, 2)
from time import sleep
import zeep
from onvif import ONVIFCamera, ONVIFService
def zeep_pythonvalue(self, xmlvalue):
return xmlvalue
zeep.xsd.simple.AnySimpleType.pythonvalue = zeep_pythonvalue
# ------------------------------ABSOLUTE MOVE------------------------------
# Initialize camera 42
cam = ONVIFCamera(
'192.168.15.42', 80, 'agney1919', 'hDzmk0leTN0W',
'/home/agney/anaconda3/lib/python3.7/site-packages/onvif_zeep-0.2.12-py3.7.egg/onvif/wsdl'
)
# Create media service
media_service = cam.create_media_service()
# Get profiles
profiles = media_service.GetProfiles()
media_profile = profiles[0]
# Create PTZ service
ptz = cam.create_ptz_service()
# Get ptz absolute move option
request_absolute_move = ptz.create_type("AbsoluteMove")
request_absolute_move.ProfileToken = media_profile.token
# Get Ptz Position
def get_ptz_position():
print('stop move!')
request.Velocity.PanTilt.x = 0
request.Velocity.PanTilt.y = 0
perform_move(ptz, request, timeout)
def callback_position(msg):
global max_T, min_T
print("receive mgs:" + str(msg.data))
min_T = msg.data[0]
max_T = msg.data[1]
#云台控制初始化
# def continuous_move():
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 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')
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')
# 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 = streamURIStruct.Uri
print(self.streamURL)
def continuous_move():
# import pdb
# pdb.set_trace()
# IP Address, port, username, password
mycam = ONVIFCamera('192.168.1.108', 80, 'admin',
'10iLtxyh', '/home/coovi/pCloudDrive/Projects/Jane/Amigos/III/amigos/amigos/onvif/wsdl', no_cache=True)
# Create media service object
media = mycam.create_media_service()
# Create ptz service object
ptz = mycam.create_ptz_service()
# print (dir(ptz))
# Get target profile
media_profile = media.GetProfiles()[0]
# print(media_profile[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)
# print(ptz_configuration_options)
# print('above line 70')
request = ptz.create_type('ContinuousMove')
# print(type(request))
request.ProfileToken = media_profile._token
# print('Profil_Token:', request.ProfileToken)
ptz.Stop({'ProfileToken': media_profile._token})
# NOTE: X and Y are velocity vector; get range of pan and tilt
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
# pdb.set_trace()
# move down initialize as the first starting movement
move_down(ptz, request, 5)
sleep(1) # after moving the camera waits 1 second
# photo() #taking a photo at the location
# move right till in next initial position (should be facing tower)
move_right(ptz, request, 5)
# move up 45 degrees
move_up(ptz, request, .5)
sleep(2)
# photo()
# move up
move_up(ptz, request, .6)
sleep(2)
# photo()
# move left
move_left(ptz, request, .80)
sleep(2)
# photo()
# move left
move_left(ptz, request, .70)
sleep(2)
# photo()
# move left
move_left(ptz, request, .75)
sleep(2)
from onvif import ONVIFCamera
import sys
login = str(sys.argv[1])
password = str(sys.argv[2])
port = str(sys.argv[3])
old_ip = str(sys.argv[4])
new_ip = str(sys.argv[5])
print(old_ip, new_ip)
mycam = ONVIFCamera(old_ip, port, login, password, '/scr/scripts/cameras/wsdl')
mycam.devicemgmt.SetNetworkInterfaces(dict(InterfaceToken='eth0', NetworkInterface=dict(
IPv4=dict(Enabled=True, Manual=[dict(Address=new_ip, PrefixLength=24)], DHCP=False))))
def __init__(self, ip):
from onvif import ONVIFCamera
from time import sleep
print 'IP camera initialization'
#Several cameras that have been tried -------------------------------------/home/pi/collarVacas/camara/python-onvif/wsdl
#Netcat camera (on my local network) Port 8899
self.mycam = ONVIFCamera(
ip, 80, 'admin', 'ufro_ufro_ufro',
'/home/pi/collarVacas/camara/python-onvif/wsdl')
#self.mycam = ONVIFCamera(ip, 80, 'admin', 'vacas123', '/home/grace/collarVacas/camara/python-onvif/wsdl')
#This is a demo camera that anyone can use for testing
#Toshiba IKS-WP816R
#self.mycam = ONVIFCamera('67.137.21.190', 80, 'toshiba', 'security', '/etc/onvif/wsdl/')
print 'Connected to ONVIF camera'
# Create media service object
self.media = self.mycam.create_media_service()
print 'Created media service object'
print
# Get target profile
self.media_profile = self.media.GetProfiles()[0]
# Use the first profile and Profiles have at least one
token = self.media_profile._token
#PTZ controls -------------------------------------------------------------
print
# Create ptz service object
print 'Creating PTZ object'
self.ptz = self.mycam.create_ptz_service()
print 'Created PTZ service object'
print
#Get available PTZ services
request = self.ptz.create_type('GetServiceCapabilities')
Service_Capabilities = self.ptz.GetServiceCapabilities(request)
#Get PTZ status
self.status = self.ptz.GetStatus({'ProfileToken': token})
#requestst =self.ptz.create_type('GetStatus')
#self.requestst.ProfileToken =self.media_profile.token
# Get PTZ configuration options for getting option ranges
request = self.ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = self.media_profile.PTZConfiguration._token
ptz_configuration_options = self.ptz.GetConfigurationOptions(request)
# print 'PTZ configuration options:'
# print ptz_configuration_options
# print
self.requestc = self.ptz.create_type('ContinuousMove')
self.requestc.ProfileToken = self.media_profile._token
self.requesta = self.ptz.create_type('AbsoluteMove')
self.requesta.ProfileToken = self.media_profile._token
# print 'Absolute move options'
# print self.requesta
# print
self.requestr = self.ptz.create_type('RelativeMove')
self.requestr.ProfileToken = self.media_profile._token
# print 'Relative move options'
# print self.requestr
# print
self.requests = self.ptz.create_type('Stop')
self.requests.ProfileToken = self.media_profile._token
self.requestp = self.ptz.create_type('SetPreset')
self.requestp.ProfileToken = self.media_profile._token
self.requestg = self.ptz.create_type('GotoPreset')
self.requestg.ProfileToken = self.media_profile._token
print 'Initial PTZ stop'
print
self.stop()
vec_y = (len_y/(vec/100.0))/100.0
print str(vec_x)+" : "+str(vec_y)
request.Velocity.PanTilt._x = vec_x*speed_kof
request.Velocity.PanTilt._y = vec_y*speed_kof
ptz.ContinuousMove(request)
sleep(timeout)
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt.xml')
head_cascade = cv2.CascadeClassifier('cascadeH5.xml')
profile_cascade = cv2.CascadeClassifier('haarcascade_profileface.xml')
upperbody_cascade = cv2.CascadeClassifier('haarcascade_mcs_upperbody.xml')
print 'conection with camera...'
mycam = ONVIFCamera('192.168.1.102', 80, 'admin', 'Supervisor', '/etc/onvif/wsdl/')
#mycam = ONVIFCamera('172.16.83.102:554', 80, 'admin', 'Supervisor')
#mycam = ONVIFCamera('192.168.13.12', 80, 'admin', 'Supervisor')
media = mycam.create_media_service()
profile = media.GetProfiles()[0]
ptz = mycam.create_ptz_service()
request = ptz.create_type('GetConfigurationOptions')
request.ConfigurationToken = profile.PTZConfiguration._token
ptz_configuration_options = ptz.GetConfigurationOptions(request)
request = ptz.create_type('ContinuousMove')
request.ProfileToken = profile._token
print 'sucsess conection.'
print("starting video stream...")
vs = VideoStream(src='rtsp://192.168.1.102:554/Streaming/Channels/101').start()
#vs = VideoStream(src='rtsp://192.168.13.12:554/Streaming/Channels/101?transportmode=unicast&profile=Profile_1').start()
def GetSystemDateAndTime(ip, user='******', password='******'):
try:
cam = ONVIFCamera(ip, 80, user, password, '/etc/onvif/wsdl')
return cam.devicemgmt.GetSystemDateAndTime()
except ONVIFError as e:
return None
def GetNetworkInterfaces(ip, user='******', password='******'):
try:
cam = ONVIFCamera(ip, 80, user, password, '/etc/onvif/wsdl')
return cam.devicemgmt.GetNetworkInterfaces()
except ONVIFError as e:
return None
def GetHostname(ip, user='******', password='******'):
try:
cam = ONVIFCamera(ip, 80, user, password, '/etc/onvif/wsdl/')
return cam.devicemgmt.GetHostname().Name
except ONVIFError as e:
return None
import datetime
from onvif import ONVIFCamera
TZ = "CET+1CEST"
mycam = ONVIFCamera('192.168.86.219', 8899, 'admin', 'admin', '/home/pi/wsdl/')
# Get system date and time
date_now = datetime.datetime.utcnow()
dt = mycam.devicemgmt.GetSystemDateAndTime()
tz = dt.TimeZone
year = str(dt.UTCDateTime.Date.Year)
month = str(dt.UTCDateTime.Date.Month)
day = str(dt.UTCDateTime.Date.Day)
hour = str(dt.UTCDateTime.Time.Hour)
minute = str(dt.UTCDateTime.Time.Minute)
second = str(dt.UTCDateTime.Time.Second)
# Create datetime object from string
date_str = year+"-"+month+"-"+day+" "+hour+":"+minute+":"+second
date_time_obj = datetime.datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S')
# Calculate time difference in seconds and set system time if > 10 seconds
time_diff = int((date_time_obj-date_now).total_seconds())
if time_diff > 10 or time_diff < -10:
print "time diff("+str(time_diff)+") too big, let's sync"
time_params = mycam.devicemgmt.create_type('SetSystemDateAndTime')
time_params.DateTimeType = 'Manual'
time_params.DaylightSavings = True
time_params.TimeZone.TZ = TZ
time_params.UTCDateTime.Date.Year = date_now.year
