def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) open_cv_image = numpy.array(input_img) open_cv_image = open_cv_image[:, :, ::-1].copy() output_img_cv = self.makeup_artist.apply_makeup(open_cv_image) img = cv2.cvtColor(output_img_cv, cv2.COLOR_BGR2RGB) output_img = Image.fromarray(img) ################## where the hard work is done ############ # # output_img is an PIL image # output_img = self.makeup_artist.apply_makeup(input_img) # output_str is a base64 string in ascii output_str = pil_image_to_base64(output_img) # convert eh base64 string in ascii to base64 string in _bytes_ self.to_output.append(binascii.a2b_base64(output_str))
def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) # output_img is an PIL image output_img = input_img # output_str is a base64 string in ascii output_str = pil_image_to_base64(output_img) # convert the base64 string in ascii to base64 string in _bytes_ self.to_output.append(binascii.a2b_base64(output_str))
def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) ################## where the hard work is done ############ data = self.vp.process(input_img, self.id) # output_str is a base64 string in ascii #output_str = pil_image_to_base64(output_img) # convert eh base64 string in ascii to base64 string in _bytes_ self.to_output.append(data)
def answer(videoStrings): sampleLength = 10 firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels+1)[levels] sample = np.zeros((sampleLength, firstGauss.shape[0], firstGauss.shape[1], videoChannels)) idx = 0 respRate = [] #pipeline = PipeLine(videoFrameRate) for i in range(len(videoStrings)): input_img = base64_to_pil_image(videoStrings[i]) input_img = input_img.resize((320,240)) frame = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) detectionFrame = frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):int(realWidth-int(videoWidth/2)), :] sample[idx] = buildGauss(detectionFrame, levels+1)[levels] freqs, signals = applyFFT(sample, videoFrameRate) signals = bandPass(freqs, signals, (0.2, 0.8)) respiratoryRate = searchFreq(freqs, signals, sample, videoFrameRate) #frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):(realWidth-int(videoWidth/2)), :] = outFrame idx = (idx + 1) % 10 respRate.append(respiratoryRate) l = [] a = max(respRate) b = mean(respRate) if b < 0: b = 5 l.append(a) l.append(b) return mean(l)
def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) ################## where the hard work is done ############ # output_img is an PIL image output_img = self.makeup_artist.apply_makeup(input_img) # output_str is a base64 string in ascii output_str = pil_image_to_base64(output_img) # convert eh base64 string in ascii to base64 string in _bytes_ self.to_output.append(binascii.a2b_base64(output_str))
def process_one(self): if not self.to_process or not self.volume: print("empty list") return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) v = self.volume.pop(0) ################## where the hard work is done ############ # output_img is an PIL image output_img, self.ikon = self.makeup_artist.apply_makeup( input_img, self.ikon, v) # output_str is a base64 string in ascii output_str = pil_image_to_base64(output_img) # convert eh base64 string in ascii to base64 string in _bytes_ self.to_output.append(binascii.a2b_base64(output_str)) print("to output list: {}".format(len(self.to_output)))
def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) # frame = np.array(input_img) print("Type of input image", input_img) data1 = np.ndarray(shape=(1, 224, 224, 3), dtype=np.float32) size = (224, 224) image = ImageOps.fit(input_img, size, Image.ANTIALIAS) image_array = np.asarray(image) normalized_image_array = (image_array.astype(np.float32) / 127.0) - 1 data1[0] = normalized_image_array ################## where the hard work is done ############ # output_img is an PIL image #image_array = cv2.resize(image_array,(300,150)) #cv2.imshow("frame",image_array) # ret, jpeg = cv2.imencode('.jpg', image_array) # image_array = cv2.resize(jpeg, (300, 150)) PIL_image = Image.fromarray( np.uint8(image_array)).convert('RGB').resize(size=(300, 150)) b = BytesIO() PIL_image.save(b, format="jpeg") PIL_image = Image.open(b) #Image.open(BytesIO(base64.b64decode(base64_img)) #output_img = self.makeup_artist.apply_makeup(jpeg) # output_str is a base64 string in ascii output_str = pil_image_to_base64(PIL_image) # convert eh base64 string in ascii to base64 string in _bytes_ self.to_output.append(binascii.a2b_base64(output_str))
def upload(): # dict = request.form # for key in dict: # print('form key ' + dict[key]) target = os.path.join(APP_ROOT, "ids/") if not os.path.isdir(target): os.mkdir(target) user_id = str(request.form['username']) model = os.path.join(target, user_id + "/") if not os.path.isdir(model): os.mkdir(model) images_data = request.form['canvasImage'] json_data = json.loads(images_data) # print(image_data) # for i in range(len(image_data)): # print(i) for i in range(0, 4): name = "image_" + str(i) print("Image Name : " + name) image_data = json_data[name] if image_data: content = image_data.split(';')[1] image_encoded = content.split(',')[1] input_img = base64_to_pil_image(image_encoded) basename = user_id + name suffix = datetime.now().strftime("%y%m%d_%H%M%S.jpg") filename = "_".join([basename, suffix]) print("Saving to: " + model + filename) input_img.save(model + filename) return render_template("task.html")
def get(self, user_index): # frame_text = str(frame_text) #print # if user_index == '1': # frame_text = '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8QEBD/2wBDAQMDAwQDBAgEBAgQCwkLEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBD/wAARCACWASwDASIAAhEBAxEB/8QAHQAAAQUBAQEBAAAAAAAAAAAAAAMEBQYHAggBCf/EAEIQAAEEAQIDBgMFBgMGBwAAAAEAAgMRBAUhBhIxB0FRYXGBEyKRFCMyobEIFTNSYsEkctEXQlOS4fFDRIKissLw/8QAGwEAAgMBAQEAAAAAAAAAAAAAAgMAAQQFBgf/xAAoEQACAgEFAAICAgIDAAAAAAAAAQIRAwQSITFBE1EUYSJCBTIjUqH/2gAMAwEAAhEDEQA/AM04A4o/c2oRyyP/AMNNUUw6AC9ne36Wt2hma9jXtdbSLBvqvL+OJIHDka4B/X1Ww9mXE41DBOjZbwcjFFxk7c0Wwr2O3oR5rzX+OzJP42z0Ovw7lvRpMTyT1TuJwJBLq9VFQyUaH0T2KUfzWSu/FnEkTOPM2gA7opKCagC49dlX4ZCPKu9SEWRtV2nKQqXJP477IAqj4qQge0uDeb81B4UxNKVx3AuukaYsmsY0aFetKWxroUbUHiydB3qVx5RQItMiAyewjyuF9+3ip/CokEqtYZHy7qwYDxYF7HxTooTIsunsaSASPorLhMa4UD+aq+nv6U6uitGmuDwOYEV+aenSM8icxYwAKAT4CgmuLtunXcufkds06ZcWCEISzWCEIUICEIUICEIUICEIUICEIUICEIUICEIUICEIUICEIUICEIUIfh3NlAbx/UnYJXRtbn03UIs/GcfiQuBIs05veD5KKLea2O39Cu4cdzdxI4DzK8LhkoNSvk9nOKao9I6BrMGqafDm47xyStsd9eIPobCmWZJ6gg+aw3s54mfpmeNFyZQYMl1xOJ6P8Pf9a8VrceYT0cPYr1Glz/NFNHndTgeKdLosceRvun2PP/Uq5jZJd8rv1Uljz0Nh9FuTMcolnxskNHW7UrjTDqqtjZJ28QpbFyh0s/omJiHZacWYEDfdSuNkNFWqxi5Wwt2ylcbJLqNpkWA2WrDyO6/qp3AyP6gqhhzEUp/BnNi3A2nxdiZIu2mzmwC4+itWmSt23VE0+cfLvXurRpuSbHzUfVPg/DNMvOHIC0EHZPO5ROnShzR81qVaQRsQseaNMfpZWqZ9QhCSbQQhChAQvhIHUgJOTKxYRcuTEz/M8BWk30U5JdsVQmL9e0OMkP1nBaRubyGf6prNxjwtBfxNfwtjXyyh36Iljm+kwXlgu2iYQq1J2kcFRGn67H1raN5/RqZ5HaxwdAaZlzzDxjir/wCRCJYMr/qwPyMX/ZFxQs/yO2jhqMfcYuXIfAhrf7lMJe2/CG0OjOJ/qn/6Ivxsv0V+Ti+zT0LIJ+2/NN/Z9MxWD+tzj/cJlN2zcQSk/CGND/ljv9bRrSTfqAergvGbYhYQ/tS4qyNv3lyjp8rGt/MBfDxjxHkC36xkkHahIUS0b9kinq14jeCQOqQkz8GL+LmwM/zSALCZNV1GexNmTP7jb7SLpJ5NviO+tolpI+y/8Aesl5E3CbibQYP4mq4/s6/0TDI4/wCGcfrml/8AkasYcyQn5QfzST8eWr3TFpcS+wHqpvqkaxldq/D0A+5imlPpQUY/tkxA4hunkD/MSsoyopWn5vG7TRwfzdD7FX8ONf1Is2R+n5wPuI7RFw/m8E1yZgfmLwAOvik8nVzRbGbvvtQ+VqDnWJXO33a1fL4wVn0VyfhJR5jmytexxBaeZpGxvyW38EcTt13So5JX1kQ1HO3+ruPoR+djuXnL7RI94DQa9KU9w3xZPw9qkeSXn4Un3cwB2LfH1HX/ALrp6TI8U6+zHqcPyx65R6cx52gj5gD5KShzGDq4CvNZph8QyTRtfFLzNcAQ5psEHon8eq5Dt2v2XfjK+ThSjRpMOoQN3D6/VSEGr4zSC6VoWWt1HINffEgdd0s3UJ3H+MT7pykhLjZrkHEOI2iZApKDizTmCjKB7rF482S/4xF+aXblyf8AEN926YsiQlwNxg4506KrlHuncfaXgw/heFhUecdgX37p3HmOPQlGsoqWNm7w9rkUQAYfonjO2uRgAjYeqweLKdYDeb23KfwzTu/DG8+oTFmYt416bpB276rEfunHyF0nLO3ziXcRvoeaxPHZmOqsd+/kpTGwdSf+HHdaYs7YDxI1yPt04wk6ZQaTt6JcdsXGkw21Qt9FmmDouqyV9z9VZ9M4U1WeqjAPomrLYl40iyf7S+MpRvreQ2+4PKTk434qnaWya5mUev3p3SuD2eaxLRLavyU3j9lGqTii53/KjU2A1FdlQk4g1WV3NNqMzq/mkJTeTVskm35DzXi4q+u7HtQH4pH+VBcHsflAJe6TzTFkl9gPYjPTqsgPzSk+6Rk1iiR8Xb1WgO7J4IyfiNkOxuykh2Y6aPxxE+qpyl6y4uBnztbbyn7yvO1w7XWEfK+1pUfZzo7P/Li/MJzHwJpDK/w7NvJL3MYtplP75e7ZnM7w2SkedlS7Nx5T58pWuRcJaSwcogZuO4dQlY9H0SIiO4GluxbYtVufhLSMojGpyDbDmo+SeQafrUw2wn+61mPT9IiZ8R7og0D8TiAB7p/h4enyt54XRyAd7SCPcqJtkckjKsPQNekcP8PQ9VcNI4E1zKjaeQUeuyv+Fp+KacWN8LAVr0/HiiiAY0VSuc/jVsGP/JLajN8Ps01I/wAWRoKlIezOTb4mWB6BaB0QkflT8RrWkj6ykM7NscfjySV2zs4wRduu/Eq6IQ/lZAvxMZQ8rszxHttlEjoo1/ZrE11CAfVachEtXNdlPSx8Z+AjJCBRN30o9VzHG97rLj1TkYriRysG/encTIIgejiNt+i8HFJI95T9G7cSQNBvlb1PiU2mxTO4RwRucXEABu+6sGmaPqOtZTcXChc7xJvlb6lapwvwDi6Oxs0kYkySPmkIuj5eC2YNPKfLMufOsRCcD6NquLpkcGpuLXDeNhG7WdwKuePpjq3cbUti6WyMl1We8mlJY+E296XXxxcVRxss97shI9ILiN7HqncWhl1c1kDzU/DiCunXyT6HGYGixuOiZRnbRAwcPMfuW3XcpDH4fgHWJvpSm4sdlWGgJ/BA0dB1TEhTlZD4/D0AoiJvnspXF4dgsD4d+ykIIgpGANb1q0aVgNjPF4fxhX3bfoprE0GAEVE2/S0riNisBz22e5TmHDz0GAnyTVFCZSEMTRYNvuwPZTeFosII+QfRSOmaLn5RDYMW9+9wF/VXLSOzziTI5ScKOJp/33TMI/Ik/kmxj9iJTd0iv6dozHEDl7+4K98M8PxmVvxI9vRP8Ds6zsd7ftGTi8o6lrnE/oFbNO0aHTwKcHkd/LScpQir9FSxZcjpIUxNJxsdgAjA9E8bFGzo0L7zFHMVncpS7Zuhp4Q6R9LWnq0fRcOghd1YN/Jdh3ivqFWvRrxxfaIPWtPa2F0rG7AXdLDeO+2zhjhF+RiNjnzs+B5jfBG3lDXDrzOOw9rW+8Q6vHoWi5mqvAcceJzmNPRz6+UH1NLwP2hCfUdXzc/J/i5Uz5300NBc5xc6gOm5XS0mN5Yty6RyNZHHinUeyR4m/av4sJLdF0DTcNu4Jm55n+xBaB7grM+KP2hu1LiGMwScTT4MRN1gf4ck/wCdlO9rpQGtYrgXHlpVHOYQTv06rU4xj0hUXY4l4m1aXJflSallOnl2fIZnFzr62SbK5gznE/NXMohzg127vdOMaQBwFIHJjlFfRZsPLkNEvVs0HUMvGnZlYuTLDKKqSN5a4ehG4VJ09wcarvVv0VtlruUbb9UcZNi5xpG48D9q3aHpgZFFxJk5EYNlmXU9+XM8FwHkHBeley7tJyuKLwdaxYIcjl5o5IbDH+RBJo+9Hy7/ACJwuN224EGtivQPZW1zdQxTE0WHgGlpnpoZsct30YvmlgmpRPQfmhfG7tF+C+rzB6aLtWCEIULBCEKEPwVlyG/DpoA323T3h3SW6zn/AGfKyGxRM+Zxr5qvuCg3Nawin9/cLVr4K4U1jU9Ri1BkJhxoyfvH/wC/Xc0f36detUvIabHumuD1+eW2Lp8mraBBoOi4wx8KB9DcuoWfclTkesYrdhFIa8aUZiaA9rA1xdt5qSi0NpHTceK70Ft8OBNtu2Ls1uMfMMc34WlRr4BJbA0b9C61zHoTCAC205boELgA6hfmmqhLEW8UvDquIH3/ANUuziPMkb8rmj0aErBw1isqmN3UhDoMBFcooeCJfoB0Mma9mPpplcPQBLRaxmEkGaY9+xKk4dDhaBUd/wB09g0aBoosrwRqxTaIlmq5IcGuDyOpsqSxtQeaPK415KQi0aDb7oV5qRxtKgab+GPojQt8HOnankWLiNLQOFnfbmiSTNixqNESGiq1h4EbapgVhwII28u6dFiZu1wanoDdMgcx03EOORe4aHH+y0/Rdf0RkTcePUhIR38p/wBFgensiBbRqlbdKyvgkFrj9E9JSVGJuUJbrNsjminHNE8OC66bKlaJq2ZbWRAvvuJVmhhz5shmXLJHGGt5eTl5jR673t3fRVLFXNmnFq5S/i42/wBD9CEJRvQWvoK+L6OqhfBSO1HLazTBjP3aQXV5+P8A+8V5C49IM0hDfmsr0v2yao/GyDjSS8oEYLR6jr+v0K8xcY5jHmQ89r0enSx6WP75PK53LLqpt/ZkevCQ8/KQFSM/GkLj951V416QOc/5h7qn5TzzH81ky5HZuwYURDMMl1HoncGEAbG3uvomafl5q9E6ilYzci1kllaOlHDGiT03GaAAVcdHx2ktHKB6qm4mSGmxQVh0zUi2gXV6FFHJ+xc8KXhqvDsMbXN+bfxC3Ls11IabmQZLZPwHpfUd4/NebNF1inNId0HutL4W4gex7Ke5dLT51W183wcvUaa+UezsHNgzsdk8LrDxacLGODeOn4ZY2WUujJALT/Za9p2oY2p4rMvFkDmO/I+C5Os0ctNK1zF+m7R6v5VsnxIcoQhYToAhCFCH4l8HdlmRmSsz9eaWQkBzMa6cT/X4Dy6+lUdfwdJgxYWxRMY0NFNAFADwHknMGM1jQA3ZO42VuR9AuRhwxxrg7GbNKb5ZxHjNbyih6pyyEXsLXTG0QQPqEu1oJ2b060tK/Zkk7PkUW4JbScsiHghjD15U4Y0HarRqrEyZ9jZuPH0pPIWDvq+5JRQi+h+icsZR8a8UYpirWUe70S8YFVvsuGs7/ffdLsbRGyJAMWibv4eyeQ/is9yassH5u/zTqI2fGvJNSFNkjBI4VRv3UpjSHY0VEQuAI7lJwS9N0SFvksOBO8AG/alZ9KyHh45q7lTMPJjbXM9TeDqUMdOMhFeJTIOhEomscNZzIXtJI81fcfJjnYC1w6LENL4gx4yCXu28FbdO4whjDfmO3W1ocVNciYTnhluiaQhVzE4xwXtHOSApaDWcCdocJavokvFJeG+GsxS/2dD1JZeVDg478vIeGxs6k/RdsyIHi2yBV3tK5ncCay+GQB8OMZxv3RkPP5NKqEbmlIbLNHY3BqzEu3niGDUnNzoHtuBvw3cp6ts1+d/VeYOIdbLy8Nku1eOKeJhmQyxyTEh1g2Vi2uahyTPYXWAfFdieaMEoR6RxMeJye59kfqmol7yCSQq9kzF7jQ+pRqerxMceQBxHmq5m6tkucRGSAemyxTbl0dPHGMETQJB/EnUUgFNJ+h6KkSatqTSfnO3cVzHxHqMVAsB9Qs8oN+mhZYrw0SGZvNRdt3UpXDyA1wIdsO4rOcPiouI+M3lIUtFxJHykiUA+CFQkug98ZGq4GrNioAgHuV44f4ngg5S97QfArzvFxFkSO5Y5CPNTOn65k7femvMrTiUq7M2WmeqdI42jD2hmQz05qXoLsN4myNWl1DAle57GRRyss7Dcg/Xb6L8/9I13IDm/fUf869Ffs8cW8Vwapmt0nWtExIhhufJJqwe6JoDm97XNLdyNya6+K1OMsmNwsxNwxyU66PaKFiOX2/ajoHLDqY4X1yQbSP0TPlLGnqN3xlvf3Odv1Wm8HcXN4r4dw9el09+CctrnCF0nPQDiAQ6hYIAINdCFzJ6fJBW1wblqsXrosKEh9tx/+ID6L79sg/nStkvoP5sf2fmIyNuxrfxpLMYaBooY2zt3+SXYzlNOGywo6bdHyNn8zR5Gks0AfKPdfA0AUNko0XsBuoBYowb7j806iAAFBIxt8CE4YwN3FefiohcjtnuNvBOI9qJBSH4gB9ErGKO/1TU3QppD2MXv39Uq11lNY5QNrH1SrXm7tWmC0PoyK+YX7JxEN9gUwjlLW0T+adRTgfNe/qmKxbSJCMnawnsb22AG9OqimSkCubZKtm2q90aFtE1FKAQK6FPoMoA7tHuVXY5nVs40fFO4pwDRJRJi2i0QZoaQeWgpPG1QmgKVRinIO5KeRzlu4d6bpsZC3AuuPrD2uZ0G6sWJrdChI2vNZhHlyhwc2Wq7lJ4uquad/wAimxmKlis1TE4iljoNkZ9FQe0n9oGHgvUxw9laD+845sYPlccjkYWvLhylvIeYUN7rrSbM1rlr5iAvPP7ReoTw8UY2c4kQ5GG1sb+4ua93MPUW0+hCrJl2q0O0mkjmybJFY4p4n05+p5Z0/ClZiyTPdAJJLcI7PKD3bClQOJJ/tTfj20bdG7BMdU1iR127Zu4UZk6iJouUu6hLeqtdG16B45NWIZD4gwGNl7datRUoMzy0yFlC9wvv25schx53bE/I66HokcgtcSDzEHr3qvnvkFadrgY5GI4nm+07dbA6hRszoY5agc8gfzCv0UvL8MjkDDXdaZSMhiJe9pAHedgPdR6hURaed8sbvmDYyX2O4bKa0nThmxNklmIJG1Doq1PkjLmZjw24B3zuqxSt+i/dNa0PsCu9KnqmlwacelUn/LlHDS7S8l2LMOaxzMN1YT2DMnJ5mn5fCzsneZpsWqMYWyiPIi+aN3W/IjvCjxkHHeY8rHkjeDuWNL2nz2sj3TMWquPPYGbR7Xa6LRpmdLTQ2Qg+Ztbb2G69p8fEuHp+tYUGXi5HMx0c0bXsLuU8uzgR1ruu6Xn7C1KBhH42jzieL/JXbhLiXF0/LizPjzNdjubI0MhfbiDYANVe3eQtWPO0zJk0txPY3Hk/Cuj8EaxmYHD+nYcjsX4Qkgx443Dmc0VbQDVkfRaFwBrzNO4L0PByHFssGn47JAeocI22PqsHficQceDDh1nAbpWgxStyJIJJmS5GcWgFocGFzGR2TfzFxroNiNIg1FsbQ3p5J3ybYu32YpYlKv0aiOKccEU/v7yuJOKIi7+M76f9VnB1QDpXlZSZ1VwNF49igeQtYTy+1jW1uduqXBYaoJIVVir9F1zgCq3vqvPKz0bX2KbF1bX6LoBoIDfmSTa/EUtGQ5wNeiNADuNgLQT18F3zVsO9ccx5dh/ZfWkEb/REmLaFWEXularcbJuCeg2Hiu2nfc/mrVi2hwym+vkUsx212m7HMb1d+SXYWGvE9ESAY4aQfBdscAd+7ySHM1o/Fuu2SC9nBFdFD5jiGhKijvaZtlBqj7WlGPPQHpurUgHEfMeALKcCVt2AFHNfRrpfkuzO1leXemJgbCUZk+O/unTMuhXMN/NQYyW9eYpduQwgUevirsqiaZlOFHmH1TqHMBO71ARzVfK60uzJo7lEmwaRPDNA2L7HqqP2ycNHi7gzI+x45kzsA/asblFudQ+dg7zzNuh3uDVPfaQN+YH0XbMxhG5CvcXF7JbkeH8/Km+FXNzNPiP7qJdqFgN5qXqDjHsD0biXWJtY0rW36Wcp7pZ4fs/xoy89S0czS2zZIsjfahssU7buyZnZz+7c/S8qfKwsthillk2Lchu56dA4GwP6XdeqVKF8o6MdRGdL0ocszZGcrwCPPokHRY7R92HM8mPc39Coo5oBovCUizGEi32R0vdYpuUGaI1Lhkg6Nrmcvxckt7wZ30fzTDJhxWgmOFlkdTuV1k57Y4rD9x13UPNqgfbmjp3lLWSQz4ojk54xoCyEMbL/AFdCnOka5qsUnNkQtDSdiw9ygpct0reZz2NC7xZ42Nv49PP4RRATITX9i3BLo0WLXZhCTAG85GwJpKMy8qVjZcg0/vI2tUrFzGx7yTG+tgFTONrLAADMyT3ohOpPoXy2XDCywQATt0JIU7gSgPZyna+9UfB1ZkjwW0K81ZtIndmZMOLCeeSV4jaALsk0PzVwT3JICdKLbPaHCuRO7hvSnvILnYUBJ67mMWpgTv73V7KuafOMTCgxWcwZFG1jQNhQFBOftl95F+a6Ep8nGUUTRyD0LyfZcid47/yUOMs728o+2OGwc+kO9el1RjzabTu7w819oP3o7FJgmrb1/RKtb4CvFchOjtSVn1ja2o9Uq2gbrYd9r4GV1O/kjpsBSNOxdC7ZgRZK7bIQaHgm4J6NC6Yd991dgVwOA9x3Psuuau4AjqkmV1Bo1SUDb67eKsW0dtlBBCXZKaoApqW13UPFdtId37ok/sGhx8Qk7+yUbNVnv6dU1DiD/ZdFx69PVXaYFDxkoI67BLRTUdhfqo3mobpVkgHW0SZVEo3IB6rozAt5SbCYska4dd/NDuYdHbq9xW0d/H5T3eFrr7U4dD+aZte8GiW0uy5tbV57K97Jt/Q5blHwvdLszZAbr3JCjg/wd08Eo+YtiMkhDWDq9+wHurUmVtX0TAyi+jytQcg9Byj0UC3VtPFNGo4oPUXkNG31UTqvaLwdokJn1LiXDijBNvEvOCR1aC27Pl1V7ybLLqMqhQcbHkqz2jcNR8e8IZ3Dkjo45pWh+NI7pHO3djvIXsf6XOVG1L9ojs5woftWPk6jqGOBbpcfEc1jfImXks+lrKdd/aW4r1/Ui7h1sOi6NA4uc6RrZMido/3bIIBd/SPl/mPfTm2mNhhdqjGNSdLp+ZNh5LSySF7mSMI6OBoj6pm3Umh4PMNvM/3SfE2onPz59QLyXTSOkdtZJJslQP7wAPQ34lYskkzqKFFmnzxPGRz13UoznmfzNjPKPH/umTc5rgQHV4Arr7Q4AHmpJumNST7F4oJPiEZGRIXDw6KTxcPHcQBnTt2s2QP7KIbIJjYcPcdUq2ASHmbkOFdd0aySGKCjzVlghxcZrgH5k7j0HzD+wTqXTtNm5fhumbJ13cq6zFbHTxO9wPWyQpPGJjc0NlddUEazOJT2tf6k/hudA8NBsDxO613sUwH6xxbiSujuLB/xMhvYFv4f/dX0KxTTxNJmsxmtfJLI4Na1jSS4k0AAOpXrvsn4Nfwbw81uTFWoZdS5Lv5evKz/ANIP1J7qWvBJy/n4jm6tqMdq7ZqDc5/Q8pNei+jOk6AWoLJ1bC0/kOo5mPi85phlkbHzHwFkWoh/afwPj5P2HI4lxIprDSHuLd78SKTN9dnPWKVWkXYZcrepG/da+jKlIsBv1Vci4x4UkDXxcTaS4Hpy5sZ/+ydDibQ3C/3xp58xkM/1RbkRRfiKa0ADy2S4BA5j39EIXOXR0bYo2MkWSuQ07WbQhTtgNnVHvAK6aKBsD2QhGkVbFg0AX/Zdctjba0IRC7Poogiz4IG9gbEIQi8J2fQPyShIrrVeSEIUUz6ARuKXXM4fiNhCEaFnQdXTvTHUtdx9IZz5TZnCifuwD09SEIRJWRclE1vt107TZZIcXh/JmEYsySTNZW38oBv/AJgs+139qDiXnMOjaLhYt/8AiygyO9Q26HvaEKM0bUimar20dpOrE5OVxdm4ke9jBAh28KZygqqzcTYOUXZOW/UsqfqHZEgeCfGrBH1KEI4pIl2hfH4w1VzaicyOBnzNga0Bl+Y7/e13kajqGsSjVNZyn5T27RtcbaweAHQDyGyEJWeTNGKEfojeJM6XL0mNpLmcstGnbEeigpcp0UYa26aBtaELM2/jTGwitzGGVkmaMg3Tt1DyNcAS00EIS0aavsbsynsAZ3k15J5FkPa7wA613oQo+wUlYvDnOlsjmHcOicwZk0Zq9iPEoQqpWX4KjPl+KGEnpflScw6i6raDXWvNCE1RQCbbJHRtY/eOdNjmMh0MRcCao13ELYW9pvFul6Dh42p6/qGW8FjWyNmczliAHK2mkAkbbu5j5oQtGFtRaRl1HM0ipal2harhR58WPJN9qyn8jsp8hMjWd7WnqL7/ACFLrhVmEzEl1zWGS5bWuEbIgatxv8R8PRCEWJtpyfaFTSjBJfZc+HeOYoRJKdLjaxp+SOMBrQPbqVOHtpy8cmGPS4WtaaADGoQieWfVgrFByfB//9k=' # # frame_text = '/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8QEBD/2wBDAQMDAwQDBAgEBAgQCwkLEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBD/wAARCACWASwDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAn/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFAEBAAAAAAAAAAAAAAAAAAAAAP/EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAMAwEAAhEDEQA/AJVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//9k=' # elif user_index == '0': # frame_text = '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' credentials_json = open("credentials.json", "rb") config = pickle.load(credentials_json) credentials_json.close() firebase = pyrebase.initialize_app(config) db = firebase.database() #print(db) #print(res['spbase64']) #print(res['rr']) count = 0 i = 0 A = 100 B = 5 bo = 0.0 nm = db.child("Appointments").child(user_index).get() res = nm.val() video_frames = res['spbase64'] video_strings = video_frames.split(';') video_strings = video_strings[1:] #print(video_strings[0]==video_strings[4]) #video_strings = video_strings*2 spresult = 0 # convert it to a pil image spcount = 0 result = 0 length = len(video_strings) print("The no of video_strings: " + str(length)) for w in range(len(video_strings)): input_img = base64_to_pil_image(video_strings[w]) input_img = input_img.resize((640, 480)) img = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) avg = 0 count = 0 sumres = 0 c1 = 0 res = 0 rows, cols = gray.shape for i in range(rows): for j in range(cols): l = gray[i, j] avg = avg + l c1 += 1 for i in range(285, 386): for j in range(177, 351): k = gray[i, j] # if i >= 285 and j >= 180 and i<=385 and j<=350: count += 1 sumres = sumres + k avg = avg / c1 sumres = sumres / count avg = round(avg, 0) sumres = round(sumres, 0) print("photo avg: " + str(avg)) print("Fin avg:" + str(sumres)) diff = avg - sumres diff = abs(diff) #print(diff) # if diff >= 5: if avg >= 140: if sumres >= 140 and sumres <= 200: #print("Hand detected") res = 1 elif avg >= 120 and avg <= 139: if sumres >= 130 and sumres <= 200: #print("Hand detected") res = 1 else: #print("no hand") res = 0 elif avg >= 90 and avg <= 119: if sumres >= 90 and sumres <= 180: #print("hand detected") res = 1 else: #print("no hand") res = 0 else: #print("no hand") res = 0 # else: # print("No hand") # res=0 print("res", str(res)) #res = 1 if res == 1: #Red channel operations red_channel = img[:, :, 2] mean_red = np.mean(red_channel) #print("RED MEAN", mean_red) std_red = np.std(red_channel) #print("RED STD", std_red) red_final = std_red / mean_red #print("RED FINAL",red_final) #Blue channel operations blue_channel = img[:, :, 0] mean_blue = np.mean(blue_channel) #print("BLUE MEAN", mean_blue) std_blue = np.std(red_channel) #print("BLUE STD", std_blue) blue_final = std_blue / mean_blue #print("BLUE FINAL",blue_final) sp = A - (B * (red_final / blue_final)) sp = round(sp, 2) spresult = spresult + sp spcount += 1 else: sp = "No hand" result = result + res result = result / length print("final res value: " + str(result)) print("positive hand counts: " + str(spcount)) if result > 0.25: spresult = spresult / spcount spresult = round(spresult, 2) else: spresult = "Finger not recognised" db.child("Appointments").child(user_index).update({"spo2": spresult}) db.child("Consultation").child(user_index).update({"fspo2": spresult}) return (1)
def get(self, user_index): config = { "apiKey": "AIzaSyDlmyLHYxZYCdmlI-pzKwkudQ85jdydBJ4", "authDomain": "televital-hack.firebaseapp.com", "databaseURL": "https://televital-hack.firebaseio.com", "projectId": "televital-hack", "storageBucket": "televital-hack.appspot.com", "messagingSenderId": "209026679607", "appId": "1:209026679607:web:68ae56edcb1abae7f290b2", "measurementId": "G-07L3WDKM0H" } firebase = pyrebase.initialize_app(config) db = firebase.database() count = 0 i=0 A=100 B=5 bo = 0.0 nm = db.child(user_index).get() res= nm.val() frame_text = res['spbase64'] # convert it to a pil image input_img = base64_to_pil_image(frame_text) input_img = input_img.resize((320,240)) img = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) #Red channel operations red_channel = img[:,:,2] mean_red = np.mean(red_channel) #print("RED MEAN", mean_red) std_red = np.std(red_channel) #print("RED STD", std_red) red_final = std_red/mean_red #print("RED FINAL",red_final) #Blue channel operations blue_channel = img[:,:,0] mean_blue = np.mean(blue_channel) #print("BLUE MEAN", mean_blue) std_blue = np.std(red_channel) #print("BLUE STD", std_blue) blue_final = std_blue/mean_blue #print("BLUE FINAL",blue_final) sp = A-(B*(red_final/blue_final)) #print("SP_VALUE",sp) bo = bo + sp #this is the value to be returned on the result screen bo = bo/100.0 db.child(user_index).update({"sp":sp}) return (1)
def get(self, user_index): credentials_json = open("credentials.json","rb") config = pickle.load(credentials_json) credentials_json.close() firebase = pyrebase.initialize_app(config) db = firebase.database() nm = db.child("Appointments").child(user_index).get() res= nm.val() video_frames = res['hrbase64'] video_strings = video_frames.split(';') #print(video_strings) video_strings = video_strings[1:] print(len(video_strings)) video_strings = video_strings*10 face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml') def buildGauss(frame, levels): pyramid = [frame] for level in range(levels): frame = cv2.pyrDown(frame) pyramid.append(frame) return pyramid def reconstructFrame(pyramid, index, levels): filteredFrame = pyramid[index] for level in range(levels): filteredFrame = cv2.pyrUp(filteredFrame) filteredFrame = filteredFrame[:videoHeight, :videoWidth] return filteredFrame def applyFFT(frames, fps): n = frames.shape[0] t = np.linspace(0,float(n)/fps, n) disp = frames.mean(axis = 0) y = frames - disp k = np.arange(n) T = n/fps frq = k/T # two sides frequency range freqs = frq[range(n//2)] # one side frequency range Y = np.fft.fft(y, axis=0)/n # fft computing and normalization signals = Y[range(n//2), :,:] return freqs, signals def bandPass(freqs, signals, freqRange): signals[freqs < freqRange[0]] *= 0 signals[freqs > freqRange[1]] *= 0 return signals def find(condition): res, = np.nonzero(np.ravel(condition)) return res def freq_from_crossings(sig, fs): """Estimate frequency by counting zero crossings """ #print(sig) # Find all indices right before a rising-edge zero crossing indices = find((sig[1:] >= 0) & (sig[:-1] < 0)) x = sig[1:] x = mean(x) return x def searchFreq(freqs, signals, frames, fs): curMax = 0 freMax = 0 Mi = 0 Mj = 0 for i in range(10, signals.shape[1]): for j in range(signals.shape[2]): idxMax = abs(signals[:,i,j]) idxMax = np.argmax(idxMax) freqMax = freqs[idxMax] ampMax = signals[idxMax,i,j] c, a = abs(curMax), abs(ampMax) if (c < a).any(): curMax = ampMax freMax = freqMax Mi = i Mj = j # print "(%d,%d) -> Freq:%f Amp:%f"%(i,j,freqMax*60, abs(ampMax)) y = frames[:,Mi, Mj] y = y - y.mean() fq = freq_from_crossings(y, fs) rate_fft = freMax*60 rate_count = round(20+(fq*10)) if np.isnan(rate_count): rate = rate_fft elif abs(rate_fft - rate_count) > 20: rate = rate_fft else: rate = rate_count return rate def answer(videoStrings): sampleLen = 10 firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels+1)[levels] sample = np.zeros((sampleLen, firstGauss.shape[0], firstGauss.shape[1], videoChannels)) idx = 0 respRate = [] #pipeline = PipeLine(videoFrameRate) face_flag = 0 for i in range(len(videoStrings)): input_img = base64_to_pil_image(videoStrings[i]) input_img = input_img.resize((320,240)) gray = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) #print(faces) #faces = [1,2,3] #print(len(faces)) if len(faces) > 0: #print("FACE FOUND _ RR") face_flag = 1 frame = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) detectionFrame = frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):int(realWidth-int(videoWidth/2)), :] sample[idx] = buildGauss(detectionFrame, levels+1)[levels] freqs, signals = applyFFT(sample, videoFrameRate) signals = bandPass(freqs, signals, (0.2, 0.8)) respiratoryRate = searchFreq(freqs, signals, sample, videoFrameRate) #frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):(realWidth-int(videoWidth/2)), :] = outputFrame idx = (idx + 1) % 10 respRate.append(respiratoryRate) else: print("Face not found") if face_flag == 1: l = [] a = max(respRate) b = mean(respRate) if b < 0: b = 5 l.append(a) l.append(b) rr = mean(l) rr = round(rr,2) else: rr = "Face not recognised!" return(rr) # Webcam Parameters realWidth = 320 realHeight = 240 videoWidth = 160 videoHeight = 120 videoChannels = 3 videoFrameRate = 15 # Color Magnification Parameters levels = 3 alpha = 170 minFrequency = 1.0 maxFrequency = 2.0 bufferSize = 150 bufferIndex = 0 # Output Display Parameters font = cv2.FONT_HERSHEY_SIMPLEX loadingTextLocation = (20, 30) bpmTextLocation = (videoWidth//2 + 5, 30) fontScale = 1 fontColor = (0,0,0) lineType = 2 boxColor = (0, 255, 0) boxWeight = 3 # Initialize Gaussian Pyramid firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels+1)[levels] videoGauss = np.zeros((bufferSize, firstGauss.shape[0], firstGauss.shape[1], videoChannels)) fourierTransformAvg = np.zeros((bufferSize)) # Bandpass Filter for Specified Frequencies frequencies = (1.0*videoFrameRate) * np.arange(bufferSize) / (1.0*bufferSize) mask = (frequencies >= minFrequency) & (frequencies <= maxFrequency) # Heart Rate Calculation Variables bpmCalculationFrequency = 15 bpmBufferIndex = 0 bpmBufferSize = 10 bpmBuffer = np.zeros((bpmBufferSize)) i = 0 bpm_values = [] face_flag = 0 for j in range(len(video_strings)): # convert it to a pil image input_img = base64_to_pil_image(video_strings[j]) input_img = input_img.resize((320,240)) img = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) gray = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) #faces = [1,2,3] if len(faces) > 0: face_flag = 1 #print("FACE FOUND") detectionFrame = img[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):int(realWidth-int(videoWidth/2)), :] # Construct Gaussian Pyramid videoGauss[bufferIndex] = buildGauss(detectionFrame, levels+1)[levels] fourierTransform = np.fft.fft(videoGauss, axis=0) # Bandpass Filter fourierTransform[mask == False] = 0 # Grab a Pulse if bufferIndex % bpmCalculationFrequency == 0: i = i + 1 for buf in range(bufferSize): fourierTransformAvg[buf] = np.real(fourierTransform[buf]).mean() hz = frequencies[np.argmax(fourierTransformAvg)] bpm = 60.0 * hz bpmBuffer[bpmBufferIndex] = bpm # print("BPM Buffer List: ", bpmBuffer) bpmBufferIndex = (bpmBufferIndex + 1) % bpmBufferSize # Amplify filtered = np.real(np.fft.ifft(fourierTransform, axis=0)) filtered = filtered * alpha # Reconstruct Resulting Frame filteredFrame = reconstructFrame(filtered, bufferIndex, levels) outputFrame = detectionFrame + filteredFrame outputFrame = cv2.convertScaleAbs(outputFrame) bufferIndex = (bufferIndex + 1) % bufferSize if i > bpmBufferSize: bpm_values.append(bpmBuffer.mean()) #print(bpm_values) else: print("Face not found") if face_flag == 1: hr = max(bpm_values) hr = round(hr) else: hr = 'Face not found' print(hr) rr = answer(video_strings) print(rr) db.child("Appointments").child(user_index).update({"hr":hr,'rr':rr}) db.child("Consultation").child(user_index).update({"fhr":hr,'frr':rr}) return (1)
def answer(videoStrings): sampleLen = 10 firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels+1)[levels] sample = np.zeros((sampleLen, firstGauss.shape[0], firstGauss.shape[1], videoChannels)) idx = 0 respRate = [] #pipeline = PipeLine(videoFrameRate) face_flag = 0 for i in range(len(videoStrings)): input_img = base64_to_pil_image(videoStrings[i]) input_img = input_img.resize((320,240)) gray = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) #print(faces) #faces = [1,2,3] #print(len(faces)) if len(faces) > 0: #print("FACE FOUND _ RR") face_flag = 1 frame = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) detectionFrame = frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):int(realWidth-int(videoWidth/2)), :] sample[idx] = buildGauss(detectionFrame, levels+1)[levels] freqs, signals = applyFFT(sample, videoFrameRate) signals = bandPass(freqs, signals, (0.2, 0.8)) respiratoryRate = searchFreq(freqs, signals, sample, videoFrameRate) #frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):(realWidth-int(videoWidth/2)), :] = outputFrame idx = (idx + 1) % 10 respRate.append(respiratoryRate) else: print("Face not found") if face_flag == 1: l = [] a = max(respRate) b = mean(respRate) if b < 0: b = 5 l.append(a) l.append(b) rr = mean(l) rr = round(rr,2) else: rr = "Face not recognised!" return(rr)
def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) ################## where the hard work is done ############ # output_img is an PIL image output_img = self.makeup_artist.apply_makeup(input_img) frame = cv2.cvtColor(np.array(output_img), cv2.COLOR_RGB2BGR) cv2.resize(frame, (400, 560), interpolation=cv2.INTER_AREA) im = cv2.imread("newmask.png") # cv2.rectangle(image, (400, 300), (700, 500), (178, 190, 181), 5) # frame = cv2.flip(opencvImage, 2) gaze.refresh(frame) frame, x, y = gaze.annotated_frame() text = "" # cv2.putText(frame, text, (90, 60), cv2.FONT_HERSHEY_DUPLEX, 1.6, (147, 58, 31), 2) left_pupil = gaze.pupil_left_coords() right_pupil = gaze.pupil_right_coords() print(right_pupil, left_pupil) points_cnt = (x, y) # print(points_cnt) if left_pupil and right_pupil != None: a = left_pupil b = right_pupil c = points_cnt # dist = [(a - c) ** 2 for a, c in zip(a, c)] # dist = math.sqrt(sum(dist)) # print("new method",dist) dst_left = distance.euclidean(a, c) mm = 0.26458333 dist_left_mm = (dst_left * mm) + 20 # print(dist_left_mm) print("left:::", dist_left_mm) dst_right = distance.euclidean(b, c) # print(dst_right) # print(dst_left) dist_right_mm = (dst_right * mm) + 20 total_pd = dist_right_mm + dist_left_mm print("total::", total_pd) print("right::", dist_right_mm) cv2.putText(frame, "Left PD: " + str(dist_left_mm) + 'mm', (80, 135), cv2.FONT_HERSHEY_DUPLEX, 0.9, (0, 0, 255), 1) cv2.putText(frame, "Right PD: " + str(dist_right_mm) + 'mm', (85, 175), cv2.FONT_HERSHEY_DUPLEX, 0.9, (0, 0, 255), 1) # cv2.putText(frame, "Total PD: " + str(total_pd) + 'mm', (85, 200), cv2.FONT_HERSHEY_DUPLEX, 0.9, # (0, 0, 255), 1) # print(frame.shape[1::-1]) im = cv2.resize(im, frame.shape[1::-1], interpolation=cv2.INTER_AREA) dst = cv2.addWeighted(frame, 0.5, im, 0.5, 0) # cv2.imshow("Frame",dst) # cv2.waitKey(1) ##Convert opencv output to pillow image img = cv2.cvtColor(dst, cv2.COLOR_BGR2RGB) im_pil = Image.fromarray(img) # output_str is a base64 string in ascii output_str = pil_image_to_base64(im_pil) # convert eh base64 string in ascii to base64 string in _bytes_ self.to_output.append(binascii.a2b_base64(output_str))
def process_frame(input): img = base64_to_pil_image(input) name, score = search(img,simNet.model,db='index.json') message = {'Name':name,'Score':score} print(message) socketio.emit(MESSAGE_TO_CLIENT,message,namespace=NAME_SPACE)
def get(self, user_index): config = { "apiKey": "AIzaSyDlmyLHYxZYCdmlI-pzKwkudQ85jdydBJ4", "authDomain": "televital-hack.firebaseapp.com", "databaseURL": "https://televital-hack.firebaseio.com", "projectId": "televital-hack", "storageBucket": "televital-hack.appspot.com", "messagingSenderId": "209026679607", "appId": "1:209026679607:web:68ae56edcb1abae7f290b2", "measurementId": "G-07L3WDKM0H" } firebase = pyrebase.initialize_app(config) db = firebase.database() nm = db.child(user_index).get() res= nm.val() video_frames = res['hrbase64'] video_strings = video_frames.split(';') video_strings = video_strings[3:] def buildGauss(frame, levels): pyramid = [frame] for level in range(levels): frame = cv2.pyrDown(frame) pyramid.append(frame) return pyramid def reconstructFrame(pyramid, index, levels): fiFrame = pyramid[index] for level in range(levels): fiFrame = cv2.pyrUp(fiFrame) fiFrame = fiFrame[:videoHeight, :videoWidth] return fiFrame def applyFFT(frames, fps): n = frames.shape[0] t = np.linspace(0,float(n)/fps, n) disp = frames.mean(axis = 0) y = frames - disp k = np.arange(n) T = n/fps frq = k/T # two sides frequency range freqs = frq[range(n//2)] # one side frequency range Y = np.fft.fft(y, axis=0)/n # fft computing and normalization signals = Y[range(n//2), :,:] return freqs, signals def bandPass(freqs, signals, freqRange): signals[freqs < freqRange[0]] *= 0 signals[freqs > freqRange[1]] *= 0 return signals def find(condition): res, = np.nonzero(np.ravel(condition)) return res def freq_from_crossings(sig, fs): """Estimate frequency by counting zero crossings """ #print(sig) # Find all indices right before a rising-edge zero crossing indices = find((sig[1:] >= 0) & (sig[:-1] < 0)) x = sig[1:] x = mean(x) return x def searchFreq(freqs, signals, frames, fs): curMaximumval = 0 freMax = 0 Mi = 0 Mj = 0 for i in range(10, signals.shape[1]): for j in range(signals.shape[2]): idxMaximumval = abs(signals[:,i,j]) idxMaximumval = np.argmax(idxMaximumval) freqMaximumval = freqs[idxMaximumval] ampMaximumval = signals[idxMaximumval,i,j] c, a = abs(curMaximumval), abs(ampMaximumval) if (c < a).any(): curMaximumval = ampMaximumval freMax = freqMaximumval Mi = i Mj = j # print "(%d,%d) -> Freq:%f Amp:%f"%(i,j,freqMaximumval*60, abs(ampMaximumval)) y = frames[:,Mi, Mj] y = y - y.mean() fq = freq_from_crossings(y, fs) rate_fft = freMax*60 rate_count = round(20+(fq*10)) if np.isnan(rate_count): rate = rate_fft elif abs(rate_fft - rate_count) > 20: rate = rate_fft else: rate = rate_count return rate def answer(videoStrings): sampleLength = 10 firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels+1)[levels] sample = np.zeros((sampleLength, firstGauss.shape[0], firstGauss.shape[1], videoChannels)) idx = 0 respRate = [] #pipeline = PipeLine(videoFrameRate) for i in range(len(videoStrings)): input_img = base64_to_pil_image(videoStrings[i]) input_img = input_img.resize((320,240)) frame = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) detectionFrame = frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):int(realWidth-int(videoWidth/2)), :] sample[idx] = buildGauss(detectionFrame, levels+1)[levels] freqs, signals = applyFFT(sample, videoFrameRate) signals = bandPass(freqs, signals, (0.2, 0.8)) respiratoryRate = searchFreq(freqs, signals, sample, videoFrameRate) #frame[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):(realWidth-int(videoWidth/2)), :] = outFrame idx = (idx + 1) % 10 respRate.append(respiratoryRate) l = [] a = max(respRate) b = mean(respRate) if b < 0: b = 5 l.append(a) l.append(b) return mean(l) # Webcam Parameters realWidth = 320 realHeight = 240 videoWidth = 160 videoHeight = 120 videoChannels = 3 videoFrameRate = 15 # Color Magnification Parameters levels = 3 alpha = 170 minFrequency = 1.0 maxFrequency = 2.0 bufferSize = 150 bufferIndex = 0 # Output Display Parameters font = cv2.FONT_HERSHEY_SIMPLEX loadingTextLocation = (20, 30) bpmTextLocation = (videoWidth//2 + 5, 30) fontScale = 1 fontColor = (0,0,0) lineType = 2 boxColor = (0, 255, 0) boxWeight = 3 # Initialize Gaussian Pyramid firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels+1)[levels] videoGauss = np.zeros((bufferSize, firstGauss.shape[0], firstGauss.shape[1], videoChannels)) fourierTransformAvg = np.zeros((bufferSize)) # Bandpass Filter for Specified Frequencies frequencies = (1.0*videoFrameRate) * np.arange(bufferSize) / (1.0*bufferSize) mask = (frequencies >= minFrequency) & (frequencies <= maxFrequency) # Heart Rate Calculation Variables bpmCalculationFrequency = 15 bpmBufferIndex = 0 bpmBufferSize = 10 bpmBuffer = np.zeros((bpmBufferSize)) i = 0 bpm_values = [] for j in range(len(video_strings)): # convert it to a pil image input_img = base64_to_pil_image(video_strings[j]) input_img = input_img.resize((320,240)) img = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) detectionFrame = img[int(videoHeight/2):int(realHeight-videoHeight/2), int(videoWidth/2):int(realWidth-int(videoWidth/2)), :] # Construct Gaussian Pyramid videoGauss[bufferIndex] = buildGauss(detectionFrame, levels+1)[levels] fourierTransform = np.fft.fft(videoGauss, axis=0) # Bandpass Filter fourierTransform[mask == False] = 0 # Grab a Pulse if bufferIndex % bpmCalculationFrequency == 0: i = i + 1 for buf in range(bufferSize): fourierTransformAvg[buf] = np.real(fourierTransform[buf]).mean() hz = frequencies[np.argmax(fourierTransformAvg)] bpm = 60.0 * hz bpmBuffer[bpmBufferIndex] = bpm # print("BPM Buffer List: ", bpmBuffer) bpmBufferIndex = (bpmBufferIndex + 1) % bpmBufferSize # Amplify filtered = np.real(np.fft.ifft(fourierTransform, axis=0)) filtered = filtered * alpha # Reconstruct Resulting Frame fiFrame = reconstructFrame(filtered, bufferIndex, levels) outFrame = detectionFrame + fiFrame outFrame = cv2.convertScaleAbs(outFrame) bufferIndex = (bufferIndex + 1) % bufferSize if i > bpmBufferSize: bpm_values.append(bpmBuffer.mean()) # take the maximum val of the calculated heart rates hr = max(bpm_values) print(hr) # call the function to calculate respiratory rate rr = answer(video_strings) print(rr) # push the data to database db.child(user_index).update({"hr":hr,'rr':rr}) return (1)
def hr(): json_data = request.json video_frames = itemgetter("frames")(json_data) video_strings = video_frames.split(";") video_strings2 = video_strings[1:] print(len(video_strings)) video_strings = video_strings2 * 20 face_found_flag = 0 for index, i in enumerate(video_strings2): imgdata = base64.b64decode(i) filename = str(index) + "some_image.jpg" with open(filename, "wb") as f: f.write(imgdata) face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml") img = cv2.imread(filename) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.1, 4) if len(faces) > 0: face_found_flag = 1 break face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml") def buildGauss(frame, levels): pyramid = [frame] for level in range(levels): frame = cv2.pyrDown(frame) pyramid.append(frame) return pyramid def reconstructFrame(pyramid, index, levels): filteredFrame = pyramid[index] for level in range(levels): filteredFrame = cv2.pyrUp(filteredFrame) filteredFrame = filteredFrame[:videoHeight, :videoWidth] return filteredFrame def applyFFT(frames, fps): n = frames.shape[0] t = np.linspace(0, float(n) / fps, n) disp = frames.mean(axis=0) y = frames - disp k = np.arange(n) T = n / fps frq = k / T freqs = frq[range(n // 2)] Y = np.fft.fft(y, axis=0) / n signals = Y[range(n // 2), :, :] return freqs, signals def bandPass(freqs, signals, freqRange): signals[freqs < freqRange[0]] *= 0 signals[freqs > freqRange[1]] *= 0 return signals def find(condition): (res,) = np.nonzero(np.ravel(condition)) return res def freq_from_crossings(sig, fs): indices = find((sig[1:] >= 0) & (sig[:-1] < 0)) x = sig[1:] x = mean(x) return x def searchFreq(freqs, signals, frames, fs): curMax = 0 freMax = 0 Mi = 0 Mj = 0 for i in range(10, signals.shape[1]): for j in range(signals.shape[2]): idxMax = abs(signals[:, i, j]) idxMax = np.argmax(idxMax) freqMax = freqs[idxMax] ampMax = signals[idxMax, i, j] c, a = abs(curMax), abs(ampMax) if (c < a).any(): curMax = ampMax freMax = freqMax Mi = i Mj = j y = frames[:, Mi, Mj] y = y - y.mean() fq = freq_from_crossings(y, fs) rate_fft = freMax * 60 rate_count = round(20 + (fq * 10)) if np.isnan(rate_count): rate = rate_fft elif abs(rate_fft - rate_count) > 20: rate = rate_fft else: rate = rate_count return rate def answer(videoStrings): sampleLen = 10 firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels + 1)[levels] sample = np.zeros( (sampleLen, firstGauss.shape[0], firstGauss.shape[1], videoChannels) ) idx = 0 respRate = [] face_flag = 0 for i in range(len(videoStrings)): input_img = base64_to_pil_image(videoStrings[i]) input_img = input_img.resize((320, 240)) if face_found_flag == 1: # print("FACE FOUND _ RR") face_flag = 1 frame = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) detectionFrame = frame[ int(videoHeight / 2) : int(realHeight - videoHeight / 2), int(videoWidth / 2) : int(realWidth - int(videoWidth / 2)), :, ] sample[idx] = buildGauss(detectionFrame, levels + 1)[levels] freqs, signals = applyFFT(sample, videoFrameRate) signals = bandPass(freqs, signals, (0.2, 0.8)) respiratoryRate = searchFreq(freqs, signals, sample, videoFrameRate) idx = (idx + 1) % 10 respRate.append(respiratoryRate) else: print("Face not found") if face_flag == 1: l = [] a = max(respRate) b = mean(respRate) if b < 0: b = 5 l.append(a) l.append(b) rr = mean(l) rr = round(rr, 2) else: rr = "Face not recognised!" return rr # Webcam Parameters realWidth = 320 realHeight = 240 videoWidth = 160 videoHeight = 120 videoChannels = 3 videoFrameRate = 15 # Color Magnification Parameters levels = 3 alpha = 170 minFrequency = 1.0 maxFrequency = 2.0 bufferSize = 150 bufferIndex = 0 # Initialize Gaussian Pyramid firstFrame = np.zeros((videoHeight, videoWidth, videoChannels)) firstGauss = buildGauss(firstFrame, levels + 1)[levels] videoGauss = np.zeros( (bufferSize, firstGauss.shape[0], firstGauss.shape[1], videoChannels) ) fourierTransformAvg = np.zeros((bufferSize)) # Bandpass Filter for Specified Frequencies frequencies = (1.0 * videoFrameRate) * np.arange(bufferSize) / (1.0 * bufferSize) mask = (frequencies >= minFrequency) & (frequencies <= maxFrequency) # Heart Rate Calculation Variables bpmCalculationFrequency = 15 bpmBufferIndex = 0 bpmBufferSize = 10 bpmBuffer = np.zeros((bpmBufferSize)) i = 0 bpm_values = [] face_flag = 0 for j in range(len(video_strings)): # convert it to a pil image input_img = base64_to_pil_image(video_strings[j]) input_img = input_img.resize((320, 240)) img = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) if face_found_flag == 1: face_flag = 1 # print("FACE FOUND") detectionFrame = img[ int(videoHeight / 2) : int(realHeight - videoHeight / 2), int(videoWidth / 2) : int(realWidth - int(videoWidth / 2)), :, ] # Construct Gaussian Pyramid videoGauss[bufferIndex] = buildGauss(detectionFrame, levels + 1)[levels] fourierTransform = np.fft.fft(videoGauss, axis=0) # Bandpass Filter fourierTransform[mask == False] = 0 # Grab a Pulse if bufferIndex % bpmCalculationFrequency == 0: i = i + 1 for buf in range(bufferSize): fourierTransformAvg[buf] = np.real(fourierTransform[buf]).mean() hz = frequencies[np.argmax(fourierTransformAvg)] bpm = 60.0 * hz bpmBuffer[bpmBufferIndex] = bpm bpmBufferIndex = (bpmBufferIndex + 1) % bpmBufferSize # Amplify filtered = np.real(np.fft.ifft(fourierTransform, axis=0)) filtered = filtered * alpha # Reconstruct Resulting Frame filteredFrame = reconstructFrame(filtered, bufferIndex, levels) outputFrame = detectionFrame + filteredFrame outputFrame = cv2.convertScaleAbs(outputFrame) bufferIndex = (bufferIndex + 1) % bufferSize print(f"IIIIIIII is equal to {i} and bpmBufferSize is {bpmBufferSize}") if i < bpmBufferSize: bpm_values.append(bpmBuffer.mean()) print("bpm_values: ") print(bpm_values) else: print("Face not found") if face_flag == 1: hr = max(bpm_values) hr = round(hr) else: hr = "Face not found" print(hr) rr = answer(video_strings) print(rr) answer = str(hr) + " " + str(rr) return answer
def spo(): count = 0 i = 0 A = 100 B = 5 json_data = request.json video_frames = itemgetter("frames")(json_data) video_strings = video_frames.split(";") video_strings = video_strings[0:] spresult = 0 spcount = 0 result = 0 length = len(video_strings) print("The no of video_strings: " + str(length)) for w in range(len(video_strings)): input_img = base64_to_pil_image(video_strings[w]) input_img = input_img.resize((640, 480)) img = cv2.cvtColor(np.array(input_img), cv2.COLOR_BGR2RGB) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) avg = 0 count = 0 sumres = 0 c1 = 0 res = 0 rows, cols = gray.shape for i in range(rows): for j in range(cols): temp = gray[i, j] avg = avg + temp c1 += 1 for i in range(285, 386): for j in range(177, 351): k = gray[i, j] count += 1 sumres = sumres + k avg = avg / c1 sumres = sumres / count avg = round(avg, 0) sumres = round(sumres, 0) print("photo avg: " + str(avg)) print("Fin avg:" + str(sumres)) diff = avg - sumres diff = abs(diff) if avg >= 140: if sumres >= 140 and sumres <= 200: # print("Hand detected") res = 1 elif avg >= 120 and avg <= 139: if sumres >= 130 and sumres <= 200: res = 1 else: res = 0 elif avg >= 90 and avg <= 119: if sumres >= 90 and sumres <= 180: res = 1 else: res = 0 else: res = 0 print("res", str(res)) # res = 1 if res == 1: # Red channel operations red_channel = img[:, :, 2] mean_red = np.mean(red_channel) std_red = np.std(red_channel) red_final = std_red / mean_red # Blue channel operations blue_channel = img[:, :, 0] mean_blue = np.mean(blue_channel) std_blue = np.std(red_channel) blue_final = std_blue / mean_blue sp = A - (B * (red_final / blue_final)) sp = round(sp, 2) spresult = spresult + sp spcount += 1 else: sp = "Finger not found" result = result + res result = result / length if result > 0.25: spresult = spresult / spcount spresult = round(spresult, 2) else: spresult = "Finger not recognised" return spresult
def process_one(self): if not self.to_process: return # input is an ascii string. input_str = self.to_process.pop(0) # convert it to a pil image input_img = base64_to_pil_image(input_str) ################## where the hard work is done ############ # output_img is an PIL image # output_img = input_img #self.makeup_artist.apply_makeup(input_img) # output_str is a base64 string in ascii # output_str = pil_image_to_base64(output_img) # convert eh base64 string in ascii to base64 string in _bytes_ # self.to_output.append(binascii.a2b_base64(output_str)) open_cv_image = np.array(input_img) # Convert RGB to BGR open_cv_image = open_cv_image[:, :, ::-1].copy() print("Processing frame...") face_patches, padded_bounding_boxes, landmarks = detect_and_align.align_image( open_cv_image, self.pnet, self.rnet, self.onet) matching_id = "Unknown" if len(face_patches) > 0: face_patches = np.stack(face_patches) feed_dict = { self.images_placeholder: face_patches, self.phase_train_placeholder: False } embs = self.sess.run(self.embeddings, feed_dict=feed_dict) print('Matches in frame:') for i in range(len(embs)): bb = padded_bounding_boxes[i] matching_id, dist = self.find_matching_id(embs[i, :]) if matching_id: print('Hi %s! Distance: %1.4f' % (matching_id, dist)) else: matching_id = 'Unknown' print('Unknown! Couldn\'t fint match.') font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(open_cv_image, matching_id, (bb[0], bb[3]), font, 1, (255, 255, 255), 1, cv2.LINE_AA) cv2.rectangle(open_cv_image, (bb[0], bb[1]), (bb[2], bb[3]), (255, 0, 0), 2) else: print("No face patches") match_dict = {} match_dict[matching_id] = open_cv_image # adding matching_name=>frame to array self.to_output.append(match_dict)