def tile(img, sz=256, N=16): shape = img.shape pad0, pad1 = (sz - shape[0] % sz) % sz, (sz - shape[1] % sz) % sz img = np.pad( img, [[pad0 // 2, pad0 - pad0 // 2], [pad1 // 2, pad1 - pad1 // 2], [0, 0]], constant_values=255) img = img.reshape(img.shape[0] // sz, sz, img.shape[1] // sz, sz, 3) img = img.transpose(0, 2, 1, 3, 4).reshape(-1, sz, sz, 3) if len(img) < N: img = np.pad(img, [[0, N - len(img)], [0, 0], [0, 0], [0, 0]], constant_values=255) idxs = np.argsort(img.reshape(img.shape[0], -1).sum(-1))[:N] img = img[idxs] return img
def main(request): if request.method == 'POST': form = form_canvas(request.POST) tim = request.POST.get('im') if form.is_valid(): data = base64.b64decode(tim) print(type(data)) print( '***************************************************************' ) img0 = "ml_app/test.bmp" with open(img0, 'wb') as f: f.write(data) f.close o = count(name=img0) o.save() print(type(img0)) print('+++++++++++++++++++++++++++++++++++') # to save image in different files ''' img1 = Image.open(img0) idi = o.id a = "C:/Users/Yzat/Downloads/ML_Django/Credit_Approval/Credit_project/media/" adr = a + str(idi) + '.bmp' img1.save(adr) ''' #################### ML Model ################################## new_model = tf.keras.models.load_model('ml_app/yzat.h5') img = cv2.imread('ml_app/test.bmp', -1) b, g, r, alpha = cv2.split(img) img_BGR = cv2.merge((r, g, alpha)) image = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY) image = cv2.resize(image, (28, 28)) image = image.astype('float32') image = image.reshape(1, 28, 28, 1) image /= 255 predictions = new_model.predict(image) yzat_predictions = np.argmax(predictions) print('******************', yzat_predictions, '**********************') messages.success(request, '{}'.format(yzat_predictions)) #################### ML Model End #################################### return HttpResponseRedirect('/canvas') else: return HttpResponseRedirect('/canvas') else: return render(request, 'canvas.html')
def process_images(fp): imgs = [] for f in fp: img = load_img(f) img = img.resize((w, h), Image.ANTIALIAS) img = img_to_array(img) / 255 img = img.reshape(3, w, h) imgs.append(img) return np.array(imgs)
def prepare_img_for_predection(): for dirpath, dirnames, filenames in walk("croped"): image = color.rgb2gray(io.imread("croped/"+filenames)) #plt.imshow(255-img4, cmap='gray') # plt.show() image = resize(image, (28, 28),anti_aliasing=True) image = np.asarray(image) #print(img4.shape) image = image.reshape(1,784) #print(img4.shape) predict_new_img(image)
def restore_channels(image, n_channels): """ Convert 1-channel image to n-channel image. :param image: an image in ndarray format :param n_channels: target number of channels :return: ndarray with image's pixels' intensities """ width, height, m = image.shape[0], image.shape[1], 1 arr = image.reshape(width, height) return np.repeat(arr, m * n_channels).reshape(width, height, n_channels)
def __call__(self, sample): image, keypoints = sample['image'], sample['keypoints'] # If image has no grayscale channel, add it if len(image.shape) == 2: image = image.reshape(image.shape[0], image.shape[1], 1) # Reshape color dimensions to torch Tensor: [channel, height, width] image = image.transpose((2, 0, 1)) return { 'image': torch.from_numpy(image), 'keypoints': torch.from_numpy(keypoints) }
def feed_net_mnist(sess): x = int(input('input index:')) digit = mnist.test.images[x] img = np.array(digit) pixels = img.reshape((28, 28)) plt.imshow(pixels, cmap='gray') plt.show() # with tf.Session() as sess: result = tf.argmax(prediction, 1) print(sess.run(result, feed_dict={ x_: [digit], y_: [mnist.test.labels[x]] }))
def mouth_cluster(image_path,files_path): global gmm # GMM分群 pic_path = glob.glob(image_path + '/*') opic = [] pic = [] for file in pic_path: image = io.imread(file + '/filled_mouth_cu_center.jpg') opic.append(image) image = image[:,:,0] images = image.reshape((image.shape[0]*image.shape[1])) pic.append(images) if not 'gmm' in globals(): gmm = joblib.load(files_path + '/mouth_10.pkl') return gmm.predict(pic)[0]
def __call__(self, sample: Sample) -> Sample: """ Apply transformation on provided sample. :param sample: :return: transformed sample """ image, key_pts = sample['image'], sample['keypoints'] # If image has no grayscale color channel, add one if len(image.shape) == 2: # Add that third color dim image = image.reshape(image.shape[0], image.shape[1], 1) # Swap color axis because # Numpy image: H x W x C # Torch image: C X H X W image = image.transpose((2, 0, 1)) return { 'image': torch.from_numpy(image), 'keypoints': torch.from_numpy(key_pts) }
def gen(batch_size=1, flag='train'): if flag == 'train': start = 1 end = 3 else: start = 3 end = 4 x_train = np.zeros((batch_size, 256 * 256), dtype='float32') y_train = np.zeros((batch_size, 1), dtype='float32') while True: for i in range(start, end): for j in range(batch_size): with open("scores.csv", "rb") as f: reader = csv.reader(f) y_train[j, :] = float(list(reader)[j][0]) path = "codes_GRBM/codes_GRBM/target_images/" + str(j) + ".jpg" img = image.load_img(path, grayscale=True) img = image.img_to_array(img) img = preprocess_input(img, mode='tf') x_train[j, :] = img.reshape(256 * 256) yield x_train, y_train
def callback(image): #print "Cur loglik: ", image_prior_nll(image), "mean loglik:", image_prior_nll(all_mean) matplotlib.image.imsave("../figures/optimizing", image.reshape((28,28)))
:param: width of the image :param: BGR pixel values of the color :return: tuple of bar, rgb values """ bar = np.zeros((height, width, 3), np.uint8) bar[:] = color red, green, blue = int(color[2]), int(color[1]), int(color[0]) return bar, (red, green, blue) # Load image img = cv2.imread('YOUR_NDVI_IMAGE') height, width, _ = np.shape(img) # Reshape the image to be a list of RGB pixels image = img.reshape((height * width, 3)) #convert from BGR to RGB for kmeans img_kmeans = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # define a cluster num_clusters = 1 clusters = KMeans(n_clusters=num_clusters) clusters.fit(image) # count the dominant colors and sort them into groups histogram = make_histogram(clusters) # sort the groups, most-common first combined = zip(histogram, clusters.cluster_centers_) combined = sorted(combined, key=lambda x: x[0], reverse=True)
#Save the picture in the current directory #OverWrite it. Temporary solution. cv2.imwrite("NewPicture.jpg", frame) #Add delay for temp solution time.sleep(0.5) image = cv2.imread('NewPicture.jpg') #Take image in numpy array data = np.array(image) a2D = data.reshape(-1, data.shape[-1]) #R G and B values of the image captured r = a2D[:, 0] g = a2D[:, 1] b = a2D[:, 2] #print(a2D) pixels = np.float32(image.reshape(-1, 3)) #Use Kmeans to find the dominant colors in the picture n_colors = 5 criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 200, .1) flags = cv2.KMEANS_RANDOM_CENTERS _, labels, palette = cv2.kmeans(pixels, n_colors, None, criteria, 10, flags) _, counts = np.unique(labels, return_counts=True) #Pick the RGB color with the highest count (the dominant) dominant = palette[np.argmax(counts)] print(dominant)
test_input_folder = "/content/sample_data/Rain-Haze/Haze" test_output_folder = "/content/sample_data/dehazed_test_images2/" if not os.path.exists(test_output_folder): os.mkdir(test_output_folder) file_types = ['jpeg','jpg','png'] with tf.Session() as sess: #saver.restore(sess,'models/model_checkpoint_9.ckpt') saver.restore(sess,'/content/sample_data/TESTING_TAR/MY_WEIGHTS_USING_EEC206_DATASET/model_checkpoint_9.ckpt') test_image_paths = [] for file_type in file_types: test_image_paths.extend(glob.glob(test_input_folder+"/*."+file_type)) for path in test_image_paths: image_label = path.split(test_input_folder)[-1][1:] image = Image.open(path) image = image.resize((640, 480)) image = np.asarray(image) / 255.0 image = image.reshape((1,) + image.shape) dehazed_image = sess.run(dehazed_X,feed_dict={X:image,Y:image}) fig, axes = plt.subplots(nrows=1, ncols=2,figsize=(10,10)) axes[0].imshow(image[0]) axes[1].imshow(dehazed_image[0]) fig.tight_layout() dehazed_image = np.asarray(dehazed_image[0] * 255,dtype=np.uint8) mpl.image.imsave(test_output_folder + "/" + 'dehazed_' + image_label, dehazed_image)
import numpy as np import tensorflow as tf from matplotlib import image import matplotlib.pyplot as plt # shape=(256,256), dtype=float image = image.imread('cameraman.png').min(2) x = np.zeros((256 * 256, 2)) for i in range(256 * 256): x[i][0] = (i // 256) / 255 x[i][1] = (i % 256) / 255 y = image.reshape((256 * 256, 1)) activation = tf.math.sin model = tf.keras.Sequential([ tf.keras.layers.Dense(16, input_dim=2), tf.keras.layers.Activation(activation), tf.keras.layers.Dense(16, input_dim=2), tf.keras.layers.Activation(activation), tf.keras.layers.Dense(16, input_dim=2), tf.keras.layers.Activation(activation), tf.keras.layers.Dense(16, input_dim=2), tf.keras.layers.Activation(activation), tf.keras.layers.Dense(1) ]) model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.03, momentum=0.9),
def vis(img): if os.path.isfile('model_{}_.h5'.format(model_version)): print 'loading model...' cnn = load_cnn_model() cnn.load_weights('model_{}_.h5'.format(model_version)) # list all layers in loaded model. layer_name = "output_layer" layer_idx = [ idx for idx, layer in enumerate(cnn.layers) if layer.name == layer_name ][0] # selected layers to visualise. layers = [ 'conv_layer_1', 'conv_layer_2', 'conv_layer_3', 'output_layer' ] # visualise convnet visualisation for each layer, place them in a subplot. for layer_name in layers: print "Generating visualisation of {}".format(layer_name) layer_idx = [ idx for idx, layer in enumerate(cnn.layers) if layer.name == layer_name ][0] if 'conv' not in layer_name: plt.figure() for idx, e in enumerate(emotions): plt.subplot(6, 6, idx + 1) plt.text(1, 7, '{}'.format(e)) img = visualize_activation(cnn, layer_idx, filter_indices=idx, max_iter=750) img = array_to_img(img.reshape(3, w, h)) plt.axis('off') plt.imshow(img) plt.suptitle('Visualisation of the Output Layer') plt.savefig('{}.png'.format(layer_name), bbox_inches='tight') plt.show() break filters = np.arange(get_num_filters(cnn.layers[layer_idx])) images = [] for idx in filters: img = visualize_activation(cnn, layer_idx, tv_weight=0, verbose=False, filter_indices=idx, max_iter=750) img = array_to_img(img.reshape(3, w, h)) images.append(img) plt.figure() for idx, i in enumerate(images): plt.subplots_adjust(wspace=0, hspace=0) plt.subplot(6, 6, idx + 1) plt.text(0, 15, 'Filter {}'.format(idx)) plt.axis('off') plt.imshow(i) plt.suptitle('Visualisation of Convolution Layer {}'.format( layer_name[len(layer_name) - 1])) plt.savefig('{}.png'.format(layer_name), bbox_inches='tight') plt.show() else: print 'model does not exist, train the network first.'
import numpy as np from math import pi, sin, cos, sqrt, hypot from matplotlib import image import matplotlib.pyplot as plt import scipy.sparse.linalg # shape=(256,256), dtype=float image = image.imread('cameraman.png').min(2) x = np.zeros((256*256,2)) for i in range(256*256): x[i][0] = (i//256)/255 x[i][1] = (i%256)/255 y = image.reshape(256*256) def fit_cosine(x, y, deg): dim = deg*deg def generate_u(x): ui = np.array([cos(pi*i*x[0]) for i in range(deg)]) uj = np.array([cos(pi*j*x[1]) for j in range(deg)]) return np.tensordot(ui, uj, axes=0).reshape((deg*deg)) cov = np.zeros((dim, dim)) vec = np.zeros((dim)) for i in range(len(x)): ui = generate_u(x[i])