def main(): if not os.path.isdir(flag.output_dir): os.mkdir(flag.output_dir) if flag.mode == 'train': train_op = train.TrainModel(flag) train_op.train() elif flag.mode == 'predict_img': predict_image(flag) elif flag.mode == 'predict_imgDir': print ('not supported') else: print ('not supported')
def predict_image_handler(project=None, publishedName=None): try: """ imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] elif ('imageData' in request.form): imageData = request.form['imageData'] else: imageData = io.BytesIO(request.get_data()) """ imageStr= request.get_data(as_text=True) if imageStr.startswith('b\''): encoded_image = encoded_image[2:-1] else: encoded_image = imageStr decoded_img = base64.b64decode(encoded_image.encode('utf-8')) img_buffer = io.BytesIO(decoded_img) img = Image.open(io.BytesIO(decoded_img)) results = predict_image(img) return jsonify(results['predictions']) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def main(): current_dir = Path(__file__).resolve().parent cascade_path = Path(current_dir).joinpath( 'cascade', 'haarcascade_frontalface_default.xml') # 画像データがbase64形式で標準出力に来る upload_data = sys.stdin.readline() img = base64_to_ndarray(upload_data) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) face_cascade = cv2.CascadeClassifier(str(cascade_path)) faces = face_cascade.detectMultiScale(gray, 1.3, 3) images_dict = {} for i, (x, y, w, h) in enumerate(faces): images_dict[i] = {} face_ndarray = img[y:y + h, x:x + w] # リサイズしてbase64に変換 face_ndarray = cv2.resize(face_ndarray, (128, 128)) face_base64 = ndarray_to_base64(face_ndarray) images_dict[i]['data'] = face_base64 images_dict[i]['score'] = predict.predict_image(face_ndarray) img = cv2.rectangle(img, (x, y), (x + w, y + h), (147, 112, 216), 3) images_dict['original'] = ndarray_to_base64(img) print(json.dumps(images_dict))
def predict_image_handler(): try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] else: imageData = io.BytesIO(request.get_data()) img = Image.open(imageData) results = predict_image(img) prediction = MESSAGE_PARSER.highestProbabilityTagMeetingThreshold(results, THRESHOLD) file.write('\n------------\n') file.write('Got ' + prediction + '\n') file.write('------------\n') try: predictJson = json.loads(json.dumps(results)) for item in predictJson: print(predictJson) file.write(item['Tag'] + ': ' + str(item['Probability']) + '\n') except Exception as e: print('!!! EXCEPTION:', str(e)) file.flush() return json.dumps(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def predict_single_image(img_number): #dataset_path = '../data/lausanne' #dataset_path = '/scratch1/xkv467/lausanne' dataset_path = '/scratch1/xkv467/lausanne_unregistered' #dataset_path = '../data/test_dataset' results_path = '../results' batch_size = 128 #img_class_map = [[0, 3, 4, 5, 6, 7, 8], [1,2]] img_class_map = [[0, 7], [1], [2], [3, 4, 8], [6], [5]] #img_class_map = [[0, 1, 2, 5, 6, 7], [3, 4, 8]] # other, vesicles #img_class_map = [[0, 7], [1, 2, 3, 4, 8, 6, 5]] # cytosol, rest output_size = len(img_class_map) norm_params = (126.04022903600975, 29.063149797089494) model_manager = ModelsManager(results_path) saved_model = model_manager.get_model('conv_2_layer_07_1_2_348_6_5_more_reg') model = saved_model.load_model('best') epoch, train, test = saved_model.session_stats() input_shape = saved_model.input_shape dataset = PatchDataset(dataset_path, batch_size, input_shape, img_class_map, predict_only=True ) # consistency test: # Does model produce the same test acc as expected two times in a row? #test_acc = test_model(dataset, model) #print('test_acc:', test_acc) image = get_image_stack(img_number, input_shape[0]) output = predict_image(dataset, model, image) #print(output.shape) #plt.imshow(image[image.shape[0]//2,:,:], cmap='gray') #segments = np.argmax(output, axis=2) #colors = ['red', 'blue', 'g', 'purple', 'cyan', 'gold'] #for class_idx in range(6): # if class_idx == 1: # pass #plt.contour((segments==class_idx).astype(int), levels=[0.5], colors = [colors[class_idx]], linewidths=1) #plt.show() return output
def predict_image_base64(encoded_image): if encoded_image.startswith('b\''): encoded_image = encoded_image[2:-1] decoded_img = base64.b64decode(encoded_image.encode('utf-8')) img_buffer = io.BytesIO(decoded_img) image = Image.open(io.BytesIO(decoded_img)) return predict_image(image)
def predict_image_handler(role): try: imageData = io.BytesIO(request.get_data()) result = predict_image(imageData, role) return json.dumps(result) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def home(): if request.method == 'POST': image=request.files['image'] image_string = base64.b64encode(image.read());print(image_string); binary = base64.b64decode(image_string) img = np.asarray(bytearray(binary), dtype="uint8") img = cv2.imdecode(img, 1) img = cv2.resize( img, (32,32), interpolation=cv2.INTER_AREA );pred = predict_image(img.reshape(1,32,32,3)); return render_template('index.html', data={ 'status':True, 'img': str(image_string)[2:-1], 'pred': pred, 'accuracy':accuracy()}) else: return render_template('index.html', data={ 'status':False, 'accuracy':accuracy() })
def main(): if "train" not in os.listdir(): os.mkdir("./train") files = glob.glob('./train/*.jpg') numOfFiles = len(files) rd = random.randint(0, numOfFiles) tf.app.flags.DEFINE_string('output_path', './output/images/img_{}.jpg'.format(str(rd)), 'path to save image') tf.app.flags.DEFINE_string('input_path', files[rd], 'image to be predicted') if "output/images" not in os.listdir(): os.mkdir("./output/images") # run prediction on random image in the images folder if no image path is specified if FLAGS.input_path == 'random': FLAGS.input_path = files[rd] img = cv2.imread(FLAGS.input_path) img = cv2.resize(img, (512, 512)) results = predict_image(img) for i in range(len(results['predictions'])): name = results['predictions'][i]['tagName'] prob = results['predictions'][i]['probability'] x = np.int(results['predictions'][i]['boundingBox']['left'] * img.shape[0]) y = np.int(results['predictions'][i]['boundingBox']['top'] * img.shape[1]) w = x + np.int( results['predictions'][i]['boundingBox']['width'] * img.shape[0]) h = y + np.int( results['predictions'][i]['boundingBox']['height'] * img.shape[1]) img = cv2.rectangle(img, (x, y), (w, h), color=(0, 255, 0), thickness=2) img = cv2.putText(img, name, (x, y - 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.5, color=(0, 0, 255), thickness=2) img = cv2.putText(img, str(prob), (x, y - 35), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=0.5, color=(0, 0, 255), thickness=2) cv2.imshow('sh', img) cv2.imwrite(FLAGS.output_path, img) cv2.waitKey(0)
def upload_image(): if request.method == "POST": image_file = request.files['image'] if image_file: image_location = os.path.join(config.UPLOAD_FOLDER, image_file.filename) image_file.save(image_location) pred = predict_image(image_path=image_location) print(pred) return render_template("index.html", prediction=pred, image_loc=image_file.filename) return render_template("index.html", prediction=0, image_loc=None)
def predict_image_handler(): try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] else: imageData = io.BytesIO(request.get_data()) #img = scipy.misc.imread(imageData) img = Image.open(imageData) results = predict_image(img) return json.dumps(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def upload(): if request.method == 'POST' and 'photo' in request.files: # filename = photos.save(request.files['photo']) img = Image.open(request.files['photo'].stream) # os.rename('./'+filename,'./'+'output.png') print("debug") #read the image into memory # img = Image.open('./output.png') results = predict_image(img) print(results) # return render_template("index2.html",s1 = s1, s2 = s2, s3 = s3,s4 = s4,s5 = s5,s6 = s6) return render_template("index2.html", results=results)
def predict_image_handler(project=None): try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] elif ('imageData' in request.form): imageData = request.form['imageData'] else: imageData = io.BytesIO(request.get_data()) img = Image.open(imageData) results = predict_image(img) return jsonify(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def predict_image_handler(project=None, publishedName=None): try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] elif ('imageData' in request.form): imageData = request.form['imageData'] else: imageData = io.BytesIO(request.get_data()) img = Image.open(imageData) results = predict_image(img) return jsonify(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def process_single_file(filename, blob, dirname=""): print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") with open( '{dirname}/{filename}'.format(filename=filename, dirname=dirname), 'rb') as image: # record = {"filename": filename, # "blob": blob, # "date": datetime.datetime.utcnow()} # records = mydb.records # record_id = records.insert_one(record).inserted_id r = predict_image(image) #RPC CALL PREDICTION USING DB URL tagName = r["predictions"][0]["tagName"] # tagName = "cow" if tagName == "cow": print(f'{dirname}/{filename}') push_start = time.time() container_id = int(filename.split(".")[0]) % 5 + 1 print(f'test{container_id}') block_blob_service.create_blob_from_path( f'test{container_id}', f'{filename}', f'{dirname}/{filename}', content_settings=ContentSettings(content_type='image/jpeg')) # block_blob_service.create_blob_from_bytes(f'test{container_id}', # f'{filename}', # blob, # content_settings=ContentSettings(content_type='image/jpeg')) push_end = time.time() print("push blob time: {} sec".format(push_end - push_start)) put_start = time.time() queue.put_message( "imagequeue", f"https://cowimagestorage.blob.core.windows.net/test{container_id}/" + filename) put_end = time.time() print("put message: {}".format(put_end - put_start)) else: pass print( "------------------------------------------------------------------" )
def upload(): pic = request.files['pic'] if not pic: return 'No picture uploaded!', 400 filename = secure_filename(pic.filename) if not filename: return 'Bad upload!', 400 picture = pic.read() food = predict_image(picture) result = Storage(int(randint(0, 999999)), food) db.session.add(result) db.session.commit() return food
def upload_file(): file = request.files['image'] # Read image image = cv2.imdecode(np.fromstring(file.read(), np.uint8), cv2.IMREAD_UNCHANGED) filename = 'dataset/predict/' + file.filename #image.save(filename) cv2.imwrite(filename, image) path = 'dataset/predict/' + file.filename image_result, name = predict.predict_image(path) image_content = cv2.imencode('.jpg', image_result)[1].tostring() encoded_image = base64.encodestring(image_content) to_send = 'data:image/jpg;base64, ' + str(encoded_image, 'utf-8') return render_template('index.html', faceDetected=1, num_faces=1, image_to_show=to_send, init=True, name=name)
def predict_image_handler(project=None, publishedName=None): try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] elif ('imageData' in request.form): imageData = request.form['imageData'] else: imageData = io.BytesIO(request.get_data()) img = Image.open(imageData) results = predict_image(img) # get the most likely prediction highest_prediction = get_highest_prediction(results['predictions']) # replace list of all predictions with the highest one results['predictions'] = highest_prediction return jsonify(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def predict_image_handler(project=None): print("Image processing start") try: imageData = None if ('imageData' in request.files): print("ImageData as file found") imageData = request.files['imageData'] elif ('imageData' in request.form): print("ImageData as form found") imageData = request.form['imageData'] else: print("ImageData not present, continue with RAW data") imageData = io.BytesIO(request.get_data()) img = Image.open(imageData) results = predict_image(img) return jsonify(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def predict_image_handler(): global count try: print('data received') imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] else: imageData = io.BytesIO(request.get_data()) #img = scipy.misc.imread(imageData) img = Image.open(imageData) count = count + 1 # img.save('/images/image' + str(count) + '.jpg', "JPEG") results = predict_image(img) return json.dumps(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def classify(net, image, image_name): image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # height, width, channels = image.shape file_root_test = 'VOCdevkit_2007/VOC2007test/JPEGImages/' result = predict_image(net, image, root_img_directory=file_root_test) _labels = [] for left_up, right_bottom, class_name, _, prob in result: _labels.append(class_name) color = COLORS[VOC_CLASSES.index(class_name)] cv2.rectangle(image, left_up, right_bottom, color, 2) label = class_name + str(round(prob, 2)) text_size, baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1) p1 = (left_up[0], left_up[1] - text_size[1]) cv2.rectangle(image, (p1[0] - 2 // 2, p1[1] - 2 - baseline), (p1[0] + text_size[0], p1[1] + text_size[1]), color, -1) cv2.putText(image, label, (p1[0], p1[1] + baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1, 8) cv2.resize(image, (15, 15)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) cv2.imwrite(insert_dash(image_name), image) return _labels
def predictButtonPressed(self): if not os.path.exists(self.imagePath.get()): return if not os.path.exists(self.modelPath.get()): return self.startLoading() # Load first image, preprocess second self.Image1Data = cv2.imread(self.imagePath.get()) self.Image1Data = cv2.cvtColor(self.Image1Data, cv2.COLOR_BGR2RGB) self.showImage1() self.preprocessImage() self.showImage2() # Make Prediction (and Heatmaps if checked) if not hasattr(self, 'altMode') or not self.altMode: self.heatmaps = None buildHeatmaps = 'last' if self.buildHeatmapsChecked.get( ) == 1 else False self.predictions, self.prediction, _, self.heatmaps = predict.predict_image( self.modelPath.get(), 3, self.Image2Data, 250, buildHeatmaps) self.showPrediction() self.stopLoading()
def predict_image_handler(): try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] else: imageData = io.BytesIO(request.get_data()) #img = scipy.misc.imread(imageData) img = Image.open(imageData) results = predict_image(img) # local model highestProb = highestProbabilityTagMeetingThreshold(results, 0.3) # cloud model if highestProb < 0.6: results = analyze_image_external(img) print(results) return json.dumps(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
def predict_image_handler(project=None, publishedName=None): global blob_service_client try: imageData = None if ('imageData' in request.files): imageData = request.files['imageData'] elif ('imageData' in request.form): imageData = request.form['imageData'] else: imageData = io.BytesIO(request.get_data()) if blob_service_client == None: print("create blob_service_client") storage_name = request.args.get('storagename') storage_key = request.args.get('storagekey') url = "https://{}.blob.core.windows.net".format(storage_name) blob_service_client = BlobServiceClient(account_url=url, credential=storage_key) img = Image.open(imageData) results = predict_image(img, blob_service_client) return jsonify(results) except Exception as e: print('EXCEPTION:', str(e)) return 'Error processing image', 500
async def recv(self): global d1 global d2 global d3 global d4 global d5 global frameCount frame = await self.track.recv() if self.transform == "cartoon": img = frame.to_ndarray(format="bgr24") # prepare color img_color = cv2.pyrDown(cv2.pyrDown(img)) for _ in range(6): img_color = cv2.bilateralFilter(img_color, 9, 9, 7) img_color = cv2.pyrUp(cv2.pyrUp(img_color)) # prepare edges img_edges = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) img_edges = cv2.adaptiveThreshold( cv2.medianBlur(img_edges, 7), 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 2, ) img_edges = cv2.cvtColor(img_edges, cv2.COLOR_GRAY2RGB) # combine color and edges img = cv2.bitwise_and(img_color, img_edges) # rebuild a VideoFrame, preserving timing information new_frame = VideoFrame.from_ndarray(img, format="bgr24") new_frame.pts = frame.pts new_frame.time_base = frame.time_base return new_frame elif self.transform == "edges": # perform edge detection img = frame.to_ndarray(format="bgr24") img = cv2.cvtColor(cv2.Canny(img, 100, 200), cv2.COLOR_GRAY2BGR) # rebuild a VideoFrame, preserving timing information new_frame = VideoFrame.from_ndarray(img, format="bgr24") new_frame.pts = frame.pts new_frame.time_base = frame.time_base return new_frame elif self.transform == "rotate": # rotate image img = frame.to_ndarray(format="bgr24") rows, cols, _ = img.shape M = cv2.getRotationMatrix2D((cols / 2, rows / 2), frame.time * 45, 1) img = cv2.warpAffine(img, M, (cols, rows)) # rebuild a VideoFrame, preserving timing information new_frame = VideoFrame.from_ndarray(img, format="bgr24") new_frame.pts = frame.pts new_frame.time_base = frame.time_base return new_frame else: t1 = time.time() img = frame.to_ndarray(format="bgr24") rows, cols, _ = img.shape t2 = time.time() dec = Image.fromarray(frame.to_ndarray(format="rgb24"), mode="RGB") t3 = time.time() result = predict_image(dec) t4 = time.time() # for prediction in result['predictions']: if len(result['predictions']) > 0: prediction = sorted(result['predictions'], key=lambda i: i['probability'])[0] x = int(cols * prediction['boundingBox']['left']) y = int(rows * prediction['boundingBox']['top']) w = int(cols * prediction['boundingBox']['width']) h = int(rows * prediction['boundingBox']['height']) cv2.rectangle(img, (x, y), (x + w, y + h), (36, 255, 12), 1) cv2.putText( img, "{} ({}%)".format(prediction['tagName'], prediction['probability'] * 100), (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (36, 255, 12), 2) t5 = time.time() new_frame = VideoFrame.from_ndarray(img, format="bgr24") t6 = time.time() new_frame.pts = frame.pts new_frame.time_base = frame.time_base d1 = d1 + (t2 - t1) d2 = d2 + (t3 - t2) d3 = d3 + (t4 - t3) d4 = d4 + (t5 - t4) d5 = d5 + (t6 - t5) frameCount = frameCount + 1 if frameCount > 9: print("*****") print("*****") print("***** Average decode1 {}ms".format(d1 * 100)) print("***** Average decode2 {}ms".format(d1 * 100)) print("***** Average predict {}ms".format(d3 * 100)) print("***** Average draw {}ms".format(d4 * 100)) print("***** Average encode {}ms".format(d5 * 100)) print("*****") print("*****") d1 = 0 d2 = 0 d3 = 0 d4 = 0 d5 = 0 frameCount = 0 return new_frame
torch.save(net.state_dict(), 'best_detector.pth') torch.save(net.state_dict(), 'detector.pth') #View an example output net.eval() net.load_state_dict(torch.load('best_detector.pth')) # select random image from train set image_name = random.choice(train_dataset.fnames) image = cv2.imread(os.path.join(file_root_train, image_name)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) threshold = 0.1 print('predicting...') print(image.shape) result = predict_image(net, image_name, root_img_directory=file_root_train, threshold=threshold) for left_up, right_bottom, class_name, _, prob in result: color = COLORS[VOC_CLASSES.index(class_name)] cv2.rectangle(image, left_up, right_bottom, color, 2) label = class_name + str(round(prob, 2)) text_size, baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1) p1 = (left_up[0], left_up[1] - text_size[1]) cv2.rectangle(image, (p1[0] - 2 // 2, p1[1] - 2 - baseline), (p1[0] + text_size[0], p1[1] + text_size[1]), color, -1) cv2.putText(image, label, (p1[0], p1[1] + baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1, 8) plt.figure(figsize=(15, 15)) plt.imshow(image)
if n == "q": break start = time.time() camera.start_preview(alpha=200) camera.resolution = (1980, 1080) camera.framerate = 15 #sleep(5) #sleep(1) camera.capture('image.jpg') camera.stop_preview() image = Image.open("image.jpg") result = predict_image(image) #print("Results from Custom Vision Model: ") #print(result) #print("Results from Custom Vision Model: Predictions ") #print(result['predictions']) print() i = 0 for tag in result['predictions']: print("ID: " + str(tag['tagId']) + " Object detected : " + tag['tagName'] + " Confidence: " + '{0:f}'.format(tag['probability'])) print()
import predict import getopt import os import sys from pathlib import Path if __name__ == '__main__': options, args = getopt.getopt(sys.argv[1:], 'i:', ["lang="]) for o, a in options: if o == '-i': dir = a elif o == "--lang": if a == 'en': source = 'en' target = 'ko' elif a == 'ko': source = 'ko' target = 'en' else: exit(-1) if dir == None: exit(-1) predict.predict_image(dir) new_dir = Path(dir).parent os.system( f"python ocr_refactored.py -i {new_dir}/tmp_text.png -m {new_dir}/tmp_masked.png -s {source} -t {target}" ) os.system(f"rm {new_dir}/tmp*")
import predict predict.predict_image('slider.png')
if best_test_loss > test_loss: best_test_loss = test_loss print('Updating best test loss: %.5f' % best_test_loss) torch.save(net.state_dict(), '/results/best_detector.pth') torch.save(net.state_dict(), '/results/detector.pth') net.eval() # select random image from test set image_name = random.choice(test_dataset.fnames) image = cv2.imread(os.path.join(file_root_test, image_name)) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) print('predicting...') result = predict_image(net, image_name, root_img_directory=file_root_test) for left_up, right_bottom, class_name, _, prob in result: color = COLORS[VOC_CLASSES.index(class_name)] cv2.rectangle(image, left_up, right_bottom, color, 2) label = class_name + str(round(prob, 2)) text_size, baseline = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.4, 1) p1 = (left_up[0], left_up[1] - text_size[1]) cv2.rectangle(image, (p1[0] - 2 // 2, p1[1] - 2 - baseline), (p1[0] + text_size[0], p1[1] + text_size[1]), color, -1) cv2.putText(image, label, (p1[0], p1[1] + baseline), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1, 8) plt.figure(figsize=(15, 15)) plt.imshow(image)
def save_class_activation_map_evolutions(model_path, model_type, num_classes, image_path, image, image_size=250, output_dir="./results/cam/"): # Generate Prediction & CAM-Evolutions # NOTE: Ironically I use the function of another module which then calls `class_activation_map_evolutions`. # But that's how it is... :D predictions, prediction, predicted_class, all_map_evolutions = predict.predict_image( model_path, model_type, image, image_size, 'all') # Superimpose weighted & labeled heatmaps on image all_map_evolutions_superimposed = [] for num_class in range(0, num_classes): class_prediction = predictions[num_class] map_evolutions_superimposed = [label_image(image, "0 - Input")] weighted_map_evolutions_superimposed = [ label_image(image, "0 - Input") ] for idx, heatmap in enumerate(all_map_evolutions[num_class]): superimposed_heatmap = superimpose_heatmap_on_image(image, heatmap) superimposed_heatmap = label_image(superimposed_heatmap, f"{idx+1} - Conv2D") map_evolutions_superimposed.append(superimposed_heatmap) superimposed_weighted_heatmap = superimpose_heatmap_on_image( image, heatmap * class_prediction) superimposed_weighted_heatmap = label_image( superimposed_weighted_heatmap, f"{idx+1} - Conv2D (Weighted)") weighted_map_evolutions_superimposed.append( superimposed_weighted_heatmap) all_map_evolutions_superimposed.append([ map_evolutions_superimposed, weighted_map_evolutions_superimposed ]) # Create Unique Output Directory output_dir = io.next_path(output_dir, create_dirs=True) # Generate & Save Weighted Heatmap # last_heatmaps = [all_map_evolutions[0][-1], all_map_evolutions[1][-1]] # superimposed_weighted_heatmap = superimpose_weighted_heatmap_on_image(image, last_heatmaps, predictions) # output_path = os.path.join(output_dir, f'CAM_weighted.png') # cv2.imwrite(output_path, cv2.cvtColor(superimposed_weighted_heatmap, cv2.COLOR_RGB2BGR)) print(f"Save Animated GIF & Seperate PNGs..") for num_class in range(0, num_classes): output_dir_frames = os.path.join(output_dir, f"CAM_class_{num_class}_frames/") if not os.path.exists(output_dir_frames): os.makedirs(output_dir_frames) heatmaps_seq = all_map_evolutions_superimposed[num_class][0] weighted_heatmaps_seq = all_map_evolutions_superimposed[num_class][1] # Seperate PNGs for idx in range(len(heatmaps_seq)): heatmap = heatmaps_seq[idx] output_path = os.path.join( output_dir_frames, f'CAM_class_{num_class}_frame_{idx}.png') # cv2.imwrite(output_path, heatmap) cv2.imwrite(output_path, cv2.cvtColor(heatmap, cv2.COLOR_RGB2BGR)) weighted_heatmap = weighted_heatmaps_seq[idx] weighted_output_path = os.path.join( output_dir_frames, f'CAM_class_{num_class}_weighted_frame_{idx}.png') # cv2.imwrite(weighted_output_path, weighted_heatmap) cv2.imwrite(weighted_output_path, cv2.cvtColor(weighted_heatmap, cv2.COLOR_RGB2BGR)) # Animated GIF output_path = os.path.join(output_dir, f'CAM_class_{num_class}_animated.gif') imageio.mimsave(output_path, heatmaps_seq, duration=0.5) output_path = os.path.join( output_dir, f'CAM_class_{num_class}_weighted_animated.gif') imageio.mimsave(output_path, weighted_heatmaps_seq, duration=0.5) # Write Info-File info_path = os.path.join(output_dir, "_INFO.txt") predicted_class_name = "Benign" if predicted_class == 0 else "Malignant" with open(info_path, "w") as text_file: print(f"Image-Path: {image_path}", file=text_file) print(f"Model-Path: {model_path}", file=text_file) print(f"Model-Type: {model_type}", file=text_file) print(f"Predicted Class: {predicted_class} ({predicted_class_name})", file=text_file) print(f"Exact Predictions (Weight Factors): {predictions}", file=text_file) print(f"Single Value Prediction: {prediction}", file=text_file) print(f"\nCommand:", file=text_file) print( f'python cam.py --model_path "{model_path}" --model_type {model_type} --image_path "{image_path}"', file=text_file) return output_dir