def sum_array(self,array_1,array_2):
if len(array_1) != len(array_2):
raise Exception.message('both input arrays should be of the same size')
result = []
for i in range(0,len(array_1)):
result.append(array_1[i] + array_2[i])
return result
def evaluate(cpfcnpj, birthday, apikey=None):
if validate_cpf(cpfcnpj):
if birthday is None:
raise Exception(
"É necessário a data de nascimento para consultar um CPF.")
elif validate_cnpj(cpfcnpj):
pass
else:
raise Exception(
"O documento informado não é um CPF ou CNPJ válido.")
ws = WebService(apikey)
return ws.post("SELECT FROM 'BIPBOPJS'.'CPFCNPJ'", {
'documento': cpfcnpj,
'nascimento': birthday
}).find("./body/nome").text
def get_list_amount_activities_RescueTime_interval_with_mindwave(
self, session_id, statistic_type):
result_x = []
result_y = []
datetime_from_session, datetime_to_session = self.dasession.get_dates_session(
session_id)
list_dates = self.rescuetimeDataProcessing.get_dates_list(
datetime_from_session, datetime_to_session)
mindwave_data_list = Mindwave_data_processing.get_mindwave_data_filtered_smoothed(
datetime_from_session, datetime_to_session, 10)
for interval in list_dates:
rescueTime_data = self.darescuetime.get_data_specific_period(
interval[0], interval[1])
result_x.append(len(rescueTime_data))
sublist = Mindwave_data_processing.get_sublist(
mindwave_data_list, datetime_from_session, datetime_to_session)
if statistic_type == Calculate_statistics_enumeration.AVG:
attention, meditation = Mindwave_data_processing.calculate_avg_attention_meditation(
sublist)
elif statistic_type == Calculate_statistics_enumeration.STD:
attention, meditation = Mindwave_data_processing.calculate_std_attention_meditation(
sublist)
else:
raise Exception.UnknownID("The statistic_type is unknown")
result_y.append(attention)
print "rescuetime amount"
print "result_x"
print result_x
print "result_y"
print result_y
return result_x, result_y
def sum_array(self, array_1, array_2):
if len(array_1) != len(array_2):
raise Exception.message(
'both input arrays should be of the same size')
result = []
for i in range(0, len(array_1)):
result.append(array_1[i] + array_2[i])
return result
def Advise(self, pUnk): # Creates a connection to the client. Simply allocate a new cookie, # find the clients interface, and store it in a dictionary. try: interface = pUnk.QueryInterface(self._connect_interfaces_[0],pythoncom.IID_IDispatch) except pythoncom.com_error: raise Exception(scode=olectl.CONNECT_E_NOCONNECTION) self.cookieNo = self.cookieNo + 1 self.connections[self.cookieNo] = interface return self.cookieNo
def get_average_userfeedback_specific_period(start_datetime_activity_detail,
end_datetime_activity_detail):
gemiddelde_concentratie = 0.0
totaal = 0.0
userfeedback = DAUserFeedback_SQLite.get_data_specific_period(
start_datetime_activity_detail, end_datetime_activity_detail)
# gemiddelde berekenen van de userfeedback gegevens voor de periodes van activity_detail
total_user_feedback_time = 0.0
for item in userfeedback:
try:
datetime_from_userfeedback = datetime.datetime.strptime(
item[1], "%Y-%m-%d %H:%M:%S.%f")
except:
datetime_from_userfeedback = datetime.datetime.strptime(
item[1], "%Y-%m-%d %H:%M:%S")
datetime_to_userfeedback = datetime_from_userfeedback + datetime.timedelta(
seconds=item[4])
if (datetime_from_userfeedback < end_datetime_activity_detail) and (
datetime_to_userfeedback > start_datetime_activity_detail):
if datetime_from_userfeedback < start_datetime_activity_detail:
datetime_from_userfeedback = start_datetime_activity_detail
if datetime_to_userfeedback > end_datetime_activity_detail:
datetime_to_userfeedback = end_datetime_activity_detail
difference = datetime_to_userfeedback - datetime_from_userfeedback
total_user_feedback_time += difference.seconds
if total_user_feedback_time <= 0:
raise Exception.ListEmpty('Geen user_feedback gegevens gevonden')
for item in userfeedback:
try:
datetime_from_userfeedback = datetime.datetime.strptime(
item[1], "%Y-%m-%d %H:%M:%S.%f")
except:
datetime_from_userfeedback = datetime.datetime.strptime(
item[1], "%Y-%m-%d %H:%M:%S")
datetime_to_userfeedback = datetime_from_userfeedback + datetime.timedelta(
seconds=item[4])
if datetime_from_userfeedback < end_datetime_activity_detail:
if datetime_from_userfeedback < start_datetime_activity_detail:
datetime_from_userfeedback = start_datetime_activity_detail
if datetime_to_userfeedback > end_datetime_activity_detail:
datetime_to_userfeedback = end_datetime_activity_detail
difference = datetime_to_userfeedback - datetime_from_userfeedback
gemiddelde_concentratie += float(
item[2] *
(float(difference.seconds) / float(total_user_feedback_time)))
return gemiddelde_concentratie
def checking_data(space, location):
exception = Exception()
if (not space):
exception.no_data()
if (not location):
exception.no_data()
def checking_data(name, surname):
exception = Exception()
if(not name):
exception.no_data()
if(not surname):
exception.no_data()
def checking_data(name, location):
exception = Exception()
if(not name):
exception.no_data()
if(not location):
exception.no_data()
def get_sublist(mindwave_data, datetime_from, datetime_to):
index_from = -1
index_to = -1
for i in range(0, len(mindwave_data)):
if mindwave_data[i][0] >= datetime_from and index_from == -1:
index_from = i
else:
if mindwave_data[i][1] <= datetime_to and index_from != -1:
index_to = i
if datetime_from == -1 or datetime_to == -1:
raise Exception.ListEmpty(
"datetime_from or datetime_to is outside the range of the mindwave data"
)
return mindwave_data[index_from:index_to + 1]
def get_average_sample_interval(list_mindwave_data, start_index, start_date,
end_date):
sublist, end_index = get_list_interval_mindwave_data(
list_mindwave_data, start_index, start_date, end_date)
total = 0.0
attention_acc = 0.0
meditation_acc = 0.0
for index_sublist in range(0, len(sublist)):
attention_acc += sublist[index_sublist][3]
meditation_acc += sublist[index_sublist][4]
total += 1.0
if total > 0:
attention_avg = attention_acc / total
meditation_avg = meditation_acc / total
else:
raise Exception.ListEmpty("no mindwave data for this interval")
datetime_start_mindwave = sublist[0][1]
datetime_end_mindwave = sublist[len(sublist) - 1][1]
return attention_avg, meditation_avg, end_index, datetime_start_mindwave, datetime_end_mindwave
def EnumConnectionPoints(self):
raise Exception(winerror.E_NOTIMPL)
def Unadvise(self, cookie):
# Destroy a connection - simply delete interface from the map.
try:
del self.connections[cookie]
except KeyError:
raise Exception(scode=winerror.E_UNEXPECTED)
def GetConnectionInterface(self):
raise Exception(winerror.E_NOTIMPL)
def detect_eye_boundaries(eye_frame_gray, x_position, y_position,
set_brightness, set_contrast):
"""
#total_ipf_normal = 68.8214334285
#total_ipf_normal = 60.94624643
#total_ipf_normal = 61.1061384532
total_ipf_normal = 123.47399829497017
total_vpf_normal = 29.299850501006954
#brightness_initial = 100.0
#contrast_initial = 90.0
brightness_initial = 40.0
contrast_initial = 60.0
"""
fig_y = None
fig_x = None
fig_x_iris = None
subplot = 111
"""
# plot
fig_y = plt.figure()
fig_x = plt.figure()
fig_x_iris = plt.figure()
subplot = 111
"""
#treshold = 0.305
#treshold_y = 9
#treshold_x = 11
"""
#eye_frame_gray = cv2.cvtColor(eye_frame, cv2.COLOR_BGR2GRAY)
total_ipf_vpf_gray = calculate_total_ipf_vpf(eye_frame_gray)
print str("total_ipf_vpf: " + str(total_ipf_vpf_gray))
print str("total_ipf test: " + str(calculate_total_ipf_check(eye_frame_gray)))
#brightness = brightness_initial / total_ipf_vpf_gray[0] * total_ipf_normal * 0.2
#brightness /= (abs(brightness - brightness_initial) / brightness)
#contrast = contrast_initial / total_ipf_vpf_gray[0] * total_ipf_normal * 0.2
#contrast *= (abs(contrast - contrast_initial)/ contrast)
#brightness = 45
#contrast = 50
"""
brightness = 0
contrast = 0
#brightness = set_brightness
#contrast = set_contrast
treshold_x = 2
treshold_y1 = 3
treshold_y2 = 2
alpha = 0.6
"""
newGray = image_operations.update_brightcont(eye_frame_gray, brightness, contrast)
print str("brightness: " + str(brightness) + "\t contrast: " + str(contrast))
"""
#newGray = change_contrast(eye_frame_gray,10.0,2.0,255.0)
#newGray = change_contrast_3de_poging(eye_frame_gray)
#eye_frame_gray = newGray
gray_original = eye_frame_gray
"""
y = 0
result = ''
while y < len(eye_frame_gray):
x = 0
result += "\n" + "\n" + "y = " + str(y) + "\n" + "\t"
while x < len(eye_frame_gray[0]):
result += str(eye_frame_gray[y][x]) + "\t"
x += 1
y += 1
print result
cv2.imshow('original',eye_frame_gray)
"""
# Dit stond er oorspronkelijk, als puur ipf en vpf gebruikt worden
"""
x1_initial = 2.0
x2_initial = float(len(eye_frame_gray[0]) - 1)
y1_initial = math.floor(len(eye_frame_gray) * (1.0 / 5.0))
y2_initial = math.floor(len(eye_frame_gray) * (3.0 / 4.0))
"""
x1_initial = 0.0
x2_initial = float(len(eye_frame_gray[0]) - 1)
y1_initial = 0.0
y2_initial = math.floor(len(eye_frame_gray) - 1)
y1 = calculate_horizontal_line(alpha, gray_original, x1_initial,
x2_initial, y1_initial, y2_initial, fig_y,
subplot, treshold_y1)
y2 = calculate_horizontal_line(alpha, gray_original, x1_initial,
x2_initial, y2_initial, y1, fig_y, subplot,
treshold_y2)
x1 = calculate_vertical_lines(alpha, gray_original, y1, y2, treshold_x,
x1_initial, x2_initial, fig_x, subplot)
x2 = calculate_vertical_lines(alpha, gray_original, y1, y2, treshold_x,
x2_initial, x1, fig_x, subplot)
if (y2 - y1) + (x2 - x1) == 0:
raise Exception.NoEyesDetected('Unable to detect the eye')
"""
print '-----------------------------------------'
# Mark
mark_horizontal_line(eye_frame_gray,y1,x1_initial,x2_initial,0.5)
mark_horizontal_line(eye_frame_gray,y2,x1_initial,x2_initial,0.5)
mark_vertical_line(eye_frame_gray,x1,y1,y2,0)
mark_vertical_line(eye_frame_gray,x2,y1,y2,0)
cv2.imshow('test',eye_frame_gray)
plt.show()
"""
return [[x1, y1], [x2, y2]]
