Example #1
8
def show_progress(x, net, title=None, handle=False, dname='', CLC=True, IF_SAVE=False):
    '''
    Helper function to show intermediate results during the gradient descent.

    :param x: vectorised image on which the gradient descent is performed
    :param net: caffe.Classifier object defining the network
    :param title: optional title of figuer
    :param handle: obtional return of figure handle
    :return: figure handle (optional)
    '''
    global index
    disp_image = (x.reshape(*net.blobs['data'].data.shape)[0].transpose(1,2,0)[:,:,::-1]-x.min())/(x.max()-x.min())
    if CLC:
    	clear_output()
    if disp_image.shape[2] == 1:
        plt.imshow(disp_image[:,:,0], cmap='gray')
        if IF_SAVE:
	        pimg.imsave(dname+str(index)+'.png',disp_image[:,:,0], cmap='gray')
	        index += 1
    else:
        plt.imshow(disp_image)
    if title != None:
        ax = plt.gca()
        ax.set_title(title)
    f = plt.gcf()
    display()
    plt.show()    
    if handle:
        return f
Example #2
0
def match_score2prim(score,primlist,stafflist,barlist,myimg):
	notelist = score.getElementsByClass('Part')[0].getElementsByClass('Measure')[0].getElementsByClass('Note')
	#read all stem primitives
	stemlist = []
	for i in primlist:
		if i.name == "stem":
			stemlist.append(i)
	stemlist.sort(key=lambda x:x.locbegin[0],reverse=False)
	#for i in stemlist:
	#	print i.locbegin[0]
	note_range = []
	cols = range(barlist[1]-barlist[0])#10 pixels per column, overlap by 5
	column_labels = [0 for i in range(len(cols))]
	for i in range(len(notelist)):
		dur_label = int(4*notelist[i].duration.quarterLength)
		pitch_label = notelist[i].pitch
		left,right = get_stem_box(stemlist[i])
		#note_range.append([x,x2])
		up = stafflist[0]-20
		down = stafflist[4]+20
		#print dur_label,left,right
		cur = myimg[up:down,int(left):int(right)]
		debugdir = "./debug/"
		if not os.path.exists(debugdir):
			os.makedirs(debugdir)
		pngname = "./debug/"+str(dur_label)+"_"+str(int(left))+".png"
		mpimg.imsave(pngname,cur)
		for j in range(int(left)-barlist[0],int(right)-barlist[0]):
			column_labels[j] = dur_label
	reply = ""
	for i in column_labels:
		reply += str(i) + " "
	reply += "\n"
	return reply
def main():
  # parse command line arguments
  parser = argparse.ArgumentParser(description='Colorize pictures')
  parser.add_argument('greyImage', help='png image to be coloured')
  parser.add_argument('markedImage', help='png image with colour hints')
  parser.add_argument('output', help='png output file')
  parser.add_argument('-v', '--view', help='display image', action='store_true')
  args = parser.parse_args()

  # Note: when reading .png, division by 255. is not required
  # Note: when reading .bmp, division by 255. is required
  # TODO: make this more universal, i.e., support various image formats
  # read images
  greyImage = mpimg.imread(args.greyImage, format='png')
  markedImage = mpimg.imread(args.markedImage, format='png')
  
  # colorize
  colouredImage = colorize(greyImage, markedImage)
    
  # save output
  mpimg.imsave(args.output,colouredImage, format='png')
  
  # display output, if requested
  if args.view:
    plt.imshow(colouredImage)
    plt.show()
    def save_image(self, filename, mode='rgb', antialiased=False):
        """Save view from all panels to disk

        Parameters
        ----------
        filename: string
            Path to new image file.
        mode : string
            Either 'rgb' (default) to render solid background, or 'rgba' to
            include alpha channel for transparent background.
        antialiased : bool
            Antialias the image (see :func:`mayavi.mlab.screenshot`
            for details; default False).

            .. warning::
               Antialiasing can interfere with ``rgba`` mode, leading to opaque
               background.

        Notes
        -----
        Due to limitations in TraitsUI, if multiple views or hemi='split'
        is used, there is no guarantee painting of the windows will
        complete before control is returned to the command line. Thus
        we strongly recommend using only one figure window (which uses
        a Mayavi figure to plot instead of TraitsUI) if you intend to
        script plotting commands.
        """
        im = self.screenshot(mode, antialiased)
        imsave(filename, im)
def saveVideo(I, IDims, filename, FrameRate = 30, YCbCr = False, Normalize = False):
    #Overwrite by default
    if os.path.exists(filename):
        os.remove(filename)
    N = I.shape[0]
    if YCbCr:
        for i in range(N):
            frame = np.reshape(I[i, :], IDims)
            I[i, :] = ntsc2rgb(frame).flatten()
    if Normalize:
        I = I-np.min(I)
        I = I/np.max(I)
    for i in range(N):
        frame = np.reshape(I[i, :], IDims)
        frame[frame < 0] = 0
        frame[frame > 1] = 1
        mpimage.imsave("%s%i.png"%(TEMP_STR, i+1), frame)
    if os.path.exists(filename):
        os.remove(filename)
    #Convert to video using avconv
    command = [AVCONV_BIN,
                '-r', "%i"%FrameRate,
                '-i', TEMP_STR + '%d.png', 
                '-r', "%i"%FrameRate,
                '-b', '30000k', 
                filename]
    subprocess.call(command)
    #Clean up
    for i in range(N):
        os.remove("%s%i.png"%(TEMP_STR, i+1))
Example #6
0
def main():

    # Check and parse arguments
    if len(sys.argv) < 2:
        print("Not enough arguments given. Need full path for the image file.")
        sys.exit()
    source = sys.argv[1]

    im_colors = { 'r':0, 'g':1, 'b':2}

    for filename in os.listdir(source):
        filepath = source + filename
        if os.path.splitext(filepath)[1] == '.jpg':

            # Load image
            im       = mpim.imread(filepath)
            im_color = im_colors[filename[-5]]

            # Switch color channel
            rows, cols               = im.shape
            im_colored               = np.zeros((rows, cols, 3))
            im_colored[:,:,im_color] = im / 255.

            # Save colored image
            mpim.imsave(os.path.splitext(filepath)[0] + '.png', im_colored,
                                                                format='PNG')
def _fetch_captchas_to_dir(directory, num=1):
    plt.ion()
    plt.show()
    for i in range(num):
        img = _captcha_provider.fetch()
        plt.clf()
        plt.axis('off')
        plt.imshow(img)
        # http://stackoverflow.com/questions/12670101/matplotlib-ion-function
        # -fails-to-be-interactive
        # https://github.com/matplotlib/matplotlib/issues/1646/
        plt.show()
        plt.pause(1e-2)

        while True:
            seq = input('[{}] Enter the char sequence: '.format(i + 1))
            # To skip a CAPTCHA.
            # Warning: skipping may reduce the quality of the training set.
            if seq == _SEQ_SKIP:
                break
            seq = _captcha_provider.canonicalize_seq(seq)
            if not _captcha_provider.is_valid_seq(seq):
                print('Invalid sequence!')
            else:
                break
        if seq == _SEQ_SKIP:
            print('Skipped manually')
            continue
        path = os.path.join(directory, _add_suffix(seq))
        if os.path.isfile(path):
            print('Warning: char sequence already exists in dataset! Skipping')
        else:
            mpimg.imsave(path, img)
    plt.ioff()
Example #8
0
def display_image(image):
    import io
    from matplotlib.image import imsave
    from IPython import display
    buf = io.BytesIO()
    imsave(buf, image)
    return display.display_png(display.Image(buf.getvalue()))
def generate_label(num):
	for i in range(num):
		pagenum = i
		print "Label page num",pagenum
		infile = "./meas/"+"poly_44_"+str(pagenum)
		#read svg file and assemble
		svg_file = infile + ".svg"
		primlist,stafflist,barlist= svg2primlist(svg_file)
		primitive_assemble(primlist)
		#read xml file
		xml_file = infile + ".xml"
		score = converter.parse(xml_file)
		#score.show('text')
		#cut out png, and write out label for each column
		myimg = mpimg.imread(infile+'.png')
		extraspace = 30
		cur = myimg[stafflist[0]-extraspace:stafflist[4]+extraspace,barlist[0]:barlist[1]]
		pngname = infile+"_s"+".png"
		mpimg.imsave(pngname,cur)
		column_labels,range_labels = match_score2prim(score,primlist,stafflist,barlist,myimg,extraspace)
		labelfile = infile+"_col.txt"
		f = open(labelfile,"w")
		f.write(column_labels)
		f.close()
		rangefile = infile+"_s.txt"
		f2 = open(rangefile,"w")
		f2.write(range_labels)
		f2.close()
Example #10
0
def averager(imgpaths, width=500, height=600, alpha=False,
             blur_edges=False, out_filename='result.png', plot=False):
  size = (height, width)

  images = []
  point_set = []
  for path in imgpaths:
    img, points = load_image_points(path, size)
    if img is not None:
      images.append(img)
      point_set.append(points)

  ave_points = locator.average_points(point_set)
  num_images = len(images)
  result_images = np.zeros(images[0].shape, np.float32)
  for i in xrange(num_images):
    result_images += warper.warp_image(images[i], point_set[i],
                                       ave_points, size, np.float32)

  result_image = np.uint8(result_images / num_images)

  mask = blender.mask_from_points(size, ave_points)
  if blur_edges:
    blur_radius = 10
    mask = cv2.blur(mask, (blur_radius, blur_radius))
  if alpha:
    result_image = np.dstack((result_image, mask))
  mpimg.imsave(out_filename, result_image)

  if plot:
    plt.axis('off')
    plt.imshow(result_image)
    plt.show()
Example #11
0
def warp_report(in_file):
    """Plot the registration summary using nipy contours"""
    mni_file = op.join(os.environ["FSL_DIR"],
                       "data/standard/MNI152_T1_1mm_brain.nii.gz")
    mni_img = nib.load(mni_file)
    mni_data, mni_aff = mni_img.get_data(), mni_img.get_affine()
    sub_img = nib.load(in_file)
    sub_data, sub_aff = sub_img.get_data(), sub_img.get_affine()
    sub_data[sub_data < 1] = 0

    kwargs = dict(draw_cross=False, annotate=False)
    cut_coords = dict(x=(-45, -12, 12, 45),
                      y=(-55, -25, 5, 45),
                      z=(-30, -5, 20, 40))

    colors = sns.color_palette("bright")
    im_data = dict()
    for axis in ["x", "y", "z"]:
        f = plt.figure(figsize=(10, 2.5))
        coords = cut_coords[axis]
        slicer = viz.plot_anat(sub_data, sub_aff, slicer=axis,
                               cut_coords=coords, figure=f, **kwargs)
        slicer.contour_map(mni_data, mni_aff, colors=colors)
        fname = "slices_%s.png" % axis
        f.savefig(fname, facecolor="k", edgecolor="k")
        im_data[axis] = mplimg.imread(fname)

    concat_data = [im_data[axis] for axis in ["x", "y", "z"]]
    concat_data = np.concatenate(concat_data, axis=0)
    mplimg.imsave("warp_report.png", concat_data)
    return op.abspath("warp_report.png")
Example #12
0
def imgHibrida():
    raiz = os.getcwd()
    filtro = gaussiana(9)
    alinear(Image.open(raiz + "\human.png"), Image.open(raiz + "\cat.png"))
    gato = mpimg.imread(raiz + "\cat.png")
    print gato.shape
    humano = mpimg.imread(raiz + "\humanAlign.png")

    gatoConv = lowFilter(gato, filtro)
    humanoConv = lowFilter(humano, filtro)
    gatoHighConv = highFilter(gato, gatoConv)

    plt.show()
    plt.imshow(gatoHighConv)
    plt.colorbar()
    plt.title("Gat(Convolution with hp)")

    plt.show()
    plt.imshow(humanoConv)
    plt.colorbar()
    plt.title("Human(Convolution with lp)")

    finalImage = gatoHighConv + humanoConv
    normalizar(finalImage)
    plt.show()
    plt.imshow(finalImage)
    plt.colorbar()
    plt.title("Hybrid Image")
    mpimg.imsave("HybridImage1.png", finalImage)
Example #13
0
	def post_process(self, sequence):
		# postprocess a sequence in some way

		sequence = np.array(sequence[self.params['n_steps']:])

		save_generated_example('generated.wav',np.array(sequence))
		mpimg.imsave('sequence.png',sequence)
Example #14
0
def custom_imsave(path, image):
    imsave(path, image, cmap=cm.Greys_r)
    return

    ret = image.copy()
    ret = ret / (ret.max() / 255.0)
    imsave(path, ret.astype(int))
Example #15
0
def generate_tweet():
    """Generate a tweet and jpg.

    Returns
    -------
    (status, jpg) : (str, str)
    """
    imageid, fitsurl = select_random_image()
    log.info('Opening {0}'.format(fitsurl))
    fts = fits.open(fitsurl)
    # Create the status message
    imgtime = fts[0].header['IMG-TIME']
    instrument = fts[0].header['INSTRUME'][8:]
    exptime = fts[0].header['EXPTIME']
    timestr = Time(imgtime).datetime.strftime('%d %b %Y, %H:%M UT').lstrip("0")
    url = 'http://imagearchives.esac.esa.int/picture.php?/{0}'.format(imageid)
    status = ('A new #Rosetta image was recently released!\n'
              '⌚ {}.\n'
              '📷 #{}.\n'
              '⌛ {:.2f}s.\n'
              '🔗 {}'.format(timestr, instrument, exptime, url))
    # Create the cropped and scaled image
    image_cropped = entropy_crop(fts[0].data, width=600, height=300)
    image_scaled = scale_image(image_cropped, scale='linear',
                               min_percent=0.05, max_percent=99.95)
    # Save the result as an image
    image_fn = '/tmp/rosettabot.png'
    log.info('Writing {0}'.format(image_fn))
    imsave(image_fn, image_scaled, cmap=cm.gray)
    return (status, image_fn)
Example #16
0
def savePic2(fname, matrix, mode='normal'):
    if mode == 'normal':
        pimg.imsave(fname, matrix)
    elif mode == 'gray':
        pimg.imsave(fname, matrix, cmap=mlib.cm.gray)
    else:
        pass
Example #17
0
	def getImagePath(self, img_obj):
		buffer = io.BytesIO()
		mpimg.imsave(buffer,img_obj)
		try:
			mpimg.imsave(buffer,img_obj)
		except:
			print("Error: getImage method must return an image object")
		return(buffer)
Example #18
0
def _save_cm(output_cmap, cmap, format='png', n_colors=256):
    """ Save the colormap of an image as an image file.
    """

    # save the colormap
    data = np.arange(0., n_colors) / (n_colors - 1.)
    data = data.reshape([1, n_colors])
    imsave(output_cmap, data, cmap=cmap, format=format)
Example #19
0
def extract_hue(infile):
	"""
		Returns a hue greyscale image from an rgb image.
	"""
	rgb_image = imread(infile)
	hsv_image = rgb_to_hsv(rgb_image)
	hue_image = -hsv_image[:,:,0]
	imsave(fname='%s-hue.png' %(infile.split('.')[0]),arr=hue_image,cmap='gray')
Example #20
0
def render_offroad_tile(tile):
    mask = vecttile_mask(tile)
    heatmap = heatmap_array(tile_path(os.path.join(tiledir, 'strava'), tile, 'png'))
    mod = adjust_alpha(heatmap.copy(), mask)
    path = tile_path(os.path.join(tiledir, 'offroad'), tile, 'png')
    prep_dirs(path)
    image.imsave(path, mod)
    return path
Example #21
0
def preview(shape, solutions):
    import os
    remove("preview", "*.png")
    for i, solution in enumerate(solutions):
        image = matrix_to_image(shape, solution)
        imsave(os.path.join("preview", "%d.png" % i), image)
    if is_windows:
        os.system("preview\\0.png")
def compare_image_lists(new_result, old_result, decimals):
    fns = ['old.png', 'new.png']
    num_images = len(old_result)
    assert(num_images > 0)
    for i in range(num_images):
        mpimg.imsave(fns[0], np.loads(zlib.decompress(old_result[i])))
        mpimg.imsave(fns[1], np.loads(zlib.decompress(new_result[i])))
        assert compare_images(fns[0], fns[1], 10**(-decimals)) == None
        for fn in fns: os.remove(fn)
def convert(image_file, outfile):
  original_image = img.imread(image_file)
  image = rgb_to_grayscale(original_image)
  height, width = image.shape
  print "Converting image ({0}x{1}) to graph...".format(width, height)
  img.imsave("tmp/grayscale.png", image, cmap="gray")
  
  graph = {} # graph has structure vertex_id -> edges
  counter = 0
  for i in xrange(height):
    for j in xrange(width):
      my_id = str(i * width + j)
      edges = []
      
      # create edge between adjaceny pixels
      top_left = get_edge(i, j, i-1, j-1, height, width, image)
      top = get_edge(i, j, i-1, j, height, width, image)
      top_right = get_edge(i, j, i-1, j+1, height, width, image)
      left = get_edge(i, j, i, j-1, height, width, image)
      right = get_edge(i, j, i, j+1, height, width, image)
      bottom_left = get_edge(i, j, i+1, j-1, height, width, image)
      bottom = get_edge(i, j, i+1, j, height, width, image)
      bottom_right = get_edge(i, j, i+1, j+1, height, width, image)
      
      edges.append(top_left)
      edges.append(top)
      edges.append(top_right)
      edges.append(left)
      edges.append(right)
      edges.append(bottom_left)
      edges.append(bottom)
      edges.append(bottom_right)
      
      # remove out of range edges
      lst = range(len(edges))
      lst.reverse()
      for k in lst:
        if edges[k] == None:
          edges.pop(k)
      
      graph[my_id] = edges
      counter +=1
  
  # super source and super sink
  source_edges = []
  for i in xrange(height):
    for j in xrange(width):
      v_id = str(i * width + j)
      source_edges.append([v_id, source_weight(i, j, image)])
      graph[v_id].append(["t", sink_weight(i, j, image)])
  graph["s"] = source_edges
  graph["t"] = []
  
  # write the outfile
  outfile = open(outfile, "w")
  for u, edges in graph.iteritems():
    outfile.write(json.dumps(u) + "\t" + json.dumps(edges) + "\n")
Example #24
0
	def write_image(arr, name, suffix='.png', mode=None):
		from ..base.plots import colormap_for_mode
		if mode==None:
			cmap = colormap_for_mode(res['mode'])
		else:
			cmap = colormap_for_mode(mode)
		from ..base import make_filename
		imagefile = make_filename(args_file, name, suffix, work_dir)
		import matplotlib.image as pltimg
		pltimg.imsave(imagefile, arr, dpi=144, cmap=cmap)
Example #25
0
  def inner(self, *args, **kwargs):
    if not self.do_plot or self.filepath is None:
      pass

    if len(args) > 1 and args[1] is 'save' and self.filepath is not None:
      filename = self.filepath.format(self.counter - 1)
      mpimg.imsave(filename, args[0])
      print(filename)
    if self.do_plot:
      func(self, *args, **kwargs)
    self.counter += 1
Example #26
0
	def post_process(self, sequence):
		# postprocess a sequence in some way

		sequence = np.array(sequence[self.params['n_steps']:])
		mpimg.imsave('sequence.png', sequence, cmap=plt.cm.gray)

		# ex. convert each vec to binary and print
		fig = plt.figure(figsize=(10,10))
		sub = fig.add_subplot(111)
		sub.matshow(sequence,  cmap=plt.cm.gray)

		plt.show()
Example #27
0
def save_w_as_image(
	X, 
	in_w, 
	in_h, 
	out_w, 
	out_h, 
	outfile,
	mode,
	dpi=288,
	verbose=True,
	lms=False,
	):
	assert len(X.shape) == 2, 'imagetiles: size error'
	if mode=='rgb': 					vis_ch = 3
	elif mode=='rg' or mode=='rg_vs_b': vis_ch = 2
	else: 								vis_ch = 1
	x = out_h
	y = out_w
	_h = in_h
	_w = in_w
	xy, hw = X.shape
	assert (xy == x*y) and (hw == _h*_w*vis_ch), 'imagetiles: size error'
	if mode=='rgb': 					X = stack_matrix(X, _w, y)
	elif mode=='rg' or mode=='rg_vs_b':	X = stack_matrix(X, _w, y, mode=mode)
	frame = 1	
	if mode=='lum':	Y = N.ones((frame+x*(_h+frame), frame+y*(_w+frame))) * .05
	else:			Y = N.ones((frame+x*(_h+frame), frame+y*(_w+frame), 3)) * .05
	image_id = 0
	for xx in range(x):
		for yy in range(y):
			if image_id >= xy: break
			beginH, beginW = frame+xx*(_h+frame), frame+yy*(_w+frame)
			if mode=='rgb':
				tile = N.array([N.reshape(X[image_id].T[0], (_h, _w)), 
								N.reshape(X[image_id].T[1], (_h, _w)), 
								N.reshape(X[image_id].T[2], (_h, _w))]).T
			elif mode=='rg':
				tile = N.array([N.reshape(X[image_id].T[0], (_h, _w)), 
								N.reshape(X[image_id].T[1], (_h, _w)), 
								N.zeros((_h, _w))]).T
			elif mode=='rg_vs_b':
				tile = N.array([N.reshape(X[image_id].T[0], (_h, _w)), 
								N.reshape(X[image_id].T[0], (_h, _w)), 
								N.reshape(X[image_id].T[1], (_h, _w))]).T
			else:
				tile = N.reshape(X[image_id], (_h, _w))
			Y[beginH : beginH+_h, beginW : beginW+_w] = tile
			image_id += 1
	cmap = colormap_for_mode(mode)
	Y = normalize_color(Y)
	pltimg.imsave(outfile, Y, dpi=dpi, cmap=cmap)
	if (verbose):
		print 'file:', outfile, 'written.'
Example #28
0
    def write(self, imagearr,  file_name=None):

        if file_name != None:
            self.file_name = file_name
        elif self.file_name != None:
            pass
        else:
            raise Exception(" %s , Undefined file name: " %
                            sys._getframe().f_code.co_name)

        imagearr.un_normalize()
        imsave(self.file_name, imagearr.get_uint_array(tdepth=8))
Example #29
0
    def slice_save(self, outputFile):
        '''
        Processes/saves a single slice.

        ARGS

        o outputFile
        The output filename to save the slice to.

        '''
        if self._verbose:
            self._log('Output file: %s\n' % outputFile)
        image.imsave(outputFile, self._2Dslice, cmap = cm.Greys_r)
Example #30
0
def save_masks_to_dir(dataset, all_masks):
    os.mkdir("output/%s" % dataset.name)
    for t in range(len(dataset.time)):
        os.mkdir("output/%s/time%02d" % (dataset.name, t))
        for s in range(len(dataset.slices)):
            mask = all_masks[t][s]
            image.imsave("output/%s/time%02d/slice%02d_mask.png" % (dataset.name, t, s), mask)
            eroded = binary_erosion(mask)
            hollow_mask = np.where(eroded, 0, mask)
            colorimg = cv2.cvtColor(dataset.images[s][t], cv2.COLOR_GRAY2RGB)
            colorimg = colorimg.astype(np.uint8)
            colorimg[hollow_mask != 0] = [255, 0, 255]
            image.imsave("output/%s/time%02d/slice%02d_color.png" % (dataset.name, t, s), colorimg)
Example #31
0
def process_image(img):
    global counter
    mplimg.imsave(
        os.path.join(output_dir, "output_{:05d}.jpg".format(counter)), img)
    counter += 1
    return img
Example #32
0
            keypoint_coord3d_v = sess.run(keypoint_coord3d_tf,
                                          feed_dict={image_tf: image_v})

        # Classifying based on Geometry
        if args.solve_by == 0:
            score_label = predict_by_geometry(keypoint_coord3d_v,
                                              known_finger_poses,
                                              args.threshold)
        # Classifying based on Neural networks
        elif args.solve_by == 1:
            score_label = predict_by_neural_network(keypoint_coord3d_v,
                                                    known_finger_poses,
                                                    args.pb_file,
                                                    args.threshold)
        # Classifying based on SVM
        elif args.solve_by == 2:
            score_label = predict_by_svm(keypoint_coord3d_v,
                                         known_finger_poses, args.svc_file)

        font = cv2.FONT_HERSHEY_SIMPLEX
        cv2.putText(image_raw, score_label, (10, 200), font, 1.0, (255, 0, 0),
                    2, cv2.LINE_AA)

        file_name = os.path.basename(img_name)
        file_name_comp = file_name.split('.')
        file_save_path = os.path.join(output_path,
                                      "{}_out.png".format(file_name_comp[0]))
        mpimg.imsave(file_save_path, image_raw)

        print('{} -->  {}\n\n'.format(file_name, score_label))
Example #33
0
    def execute_image_pipeline(self, visualize=False):
        images = glob.glob(self.output_images_path + 'undist_*.jpg')

        for idx, fname in enumerate(images):
            image_fname = ntpath.basename(fname)

            print("Processing", fname)

            output_image = os.path.join(self.output_images_path, image_fname)
            image = mpimg.imread(output_image)

            self.image_shape = image.shape

            thresholded_binary, warped, out_img, ploty, left_fitx, right_fitx = \
                self.pipeline(
                    image,
                    sobel_kernel_size=self.sobel_kernel_size,
                    sx_thresh=self.sx_thresh,
                    sy_thresh=self.sy_thresh,
                    s_thresh=self.s_thresh,
                    mag_thresh=self.mag_thresh,
                    dir_thresh=self.dir_thresh,
                    test_image_pipeline=True,
                    visualize=True)

            result, newwarp = self.project_back(image, thresholded_binary, warped, ploty, left_fitx, right_fitx)

            result = self.plot_dashboard(result, ploty, left_fitx, right_fitx, newwarp)

            output_image_thres = os.path.join(self.output_images_path, 'thres_' + image_fname)
            mpimg.imsave(output_image_thres, thresholded_binary, cmap=cm.gray)

            output_image_warp = os.path.join(self.output_images_path, 'warp_' + 'thres_' + image_fname)
            mpimg.imsave(output_image_warp, warped, cmap=cm.gray)

            output_image_out = os.path.join(self.output_images_path, 'out_' + 'warp_' + 'thres_' + image_fname)
            mpimg.imsave(output_image_out, out_img)

            output_image_result = os.path.join(self.output_images_path, 'result_' + 'out_' + 'warp_' + 'thres_' + image_fname)
            mpimg.imsave(output_image_result, result)

            if visualize:
                # Plot the result
                f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))
                f.tight_layout()

                ax1.imshow(image)
                ax1.set_title('Undistorted Image', fontsize=30)

                ax2.imshow(thresholded_binary, cmap='gray')
                ax2.set_title('Thresholded Result', fontsize=30)
                plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)

                ax2.imshow(warped, cmap='gray')
                ax2.set_title('Warped Result', fontsize=30)
                plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)

                ax2.imshow(out_img, cmap='gray')
                ax2.set_title('Line fit', fontsize=30)
                ax2.plot(left_fitx, ploty, color='yellow')
                ax2.plot(right_fitx, ploty, color='yellow')

                plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)

                ax1.imshow(result)
                ax1.set_title('Output Image', fontsize=30)
Example #34
0
def find_lines_sliding_window(binary_warped, window_search, display):

    histogram = np.sum(binary_warped[int(binary_warped.shape[0] / 2):, :],
                       axis=0)

    out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255

    # we need max for each half of the histogram. the example above shows how
    # things could be complicated if didn't split the image in half
    # before taking the top 2 maxes
    midpoint = np.int(histogram.shape[0] / 2)
    leftx_base = np.argmax(histogram[:midpoint])
    rightx_base = np.argmax(histogram[midpoint:]) + midpoint

    # Choose the number of sliding windows
    # this will throw an error in the height if it doesn't evenly divide the img height
    nwindows = 9
    # Set height of windows
    window_height = np.int(binary_warped.shape[0] / nwindows)

    # Identify the x and y positions of all nonzero pixels in the image
    nonzero = binary_warped.nonzero()
    nonzeroy = np.array(nonzero[0])
    nonzerox = np.array(nonzero[1])

    # Current positions to be updated for each window
    leftx_current = leftx_base
    rightx_current = rightx_base

    # Set the width of the windows +/- margin
    margin = 100
    # Set minimum number of pixels found to recenter window
    minpix = 50
    # Create empty lists to receive left and right lane pixel indices
    left_lane_inds = []
    right_lane_inds = []

    # Step through the windows one by one
    for window in range(nwindows):
        # Identify window boundaries in x and y (and right and left)
        win_y_low = int(binary_warped.shape[0] - (window + 1) * window_height)
        win_y_high = int(binary_warped.shape[0] - window * window_height)
        win_xleft_low = leftx_current - margin
        win_xleft_high = leftx_current + margin
        win_xright_low = rightx_current - margin
        win_xright_high = rightx_current + margin

        # Draw the windows on the visualization image
        cv2.rectangle(out_img, (win_xleft_low, win_y_low),
                      (win_xleft_high, win_y_high), (0, 255, 0), 3)
        cv2.rectangle(out_img, (win_xright_low, win_y_low),
                      (win_xright_high, win_y_high), (0, 255, 0), 3)

        # Identify the nonzero pixels in x and y within the window
        good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
                          (nonzerox >= win_xleft_low) &
                          (nonzerox < win_xleft_high)).nonzero()[0]
        good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
                           (nonzerox >= win_xright_low) &
                           (nonzerox < win_xright_high)).nonzero()[0]
        # Append these indices to the lists
        left_lane_inds.append(good_left_inds)
        right_lane_inds.append(good_right_inds)
        # If you found > minpix pixels, recenter next window on their mean position
        if len(good_left_inds) > minpix:
            leftx_current = np.int(np.mean(nonzerox[good_left_inds]))
        if len(good_right_inds) > minpix:
            rightx_current = np.int(np.mean(nonzerox[good_right_inds]))

    # Concatenate the arrays of indices
    left_lane_inds = np.concatenate(left_lane_inds)
    right_lane_inds = np.concatenate(right_lane_inds)

    # Extract left and right line pixel positions
    leftx = nonzerox[left_lane_inds]
    lefty = nonzeroy[left_lane_inds]
    rightx = nonzerox[right_lane_inds]
    righty = nonzeroy[right_lane_inds]

    # Fit a second order polynomial to each
    left_fit = np.polyfit(lefty, leftx, 2)
    right_fit = np.polyfit(righty, rightx, 2)

    # Generate x and y values for plotting
    ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])
    left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2]
    right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2]

    nonzero = binary_warped.nonzero()
    nonzeroy = np.array(nonzero[0])
    nonzerox = np.array(nonzero[1])
    margin = 100
    left_lane_inds = (
        (nonzerox >
         (left_fit[0] *
          (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] - margin)) &
        (nonzerox <
         (left_fit[0] *
          (nonzeroy**2) + left_fit[1] * nonzeroy + left_fit[2] + margin)))
    right_lane_inds = (
        (nonzerox >
         (right_fit[0] *
          (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] - margin)) &
        (nonzerox <
         (right_fit[0] *
          (nonzeroy**2) + right_fit[1] * nonzeroy + right_fit[2] + margin)))

    # Again, extract left and right line pixel positions
    leftx = nonzerox[left_lane_inds]
    lefty = nonzeroy[left_lane_inds]
    rightx = nonzerox[right_lane_inds]
    righty = nonzeroy[right_lane_inds]
    # Fit a second order polynomial to each
    left_fit = np.polyfit(lefty, leftx, 2)
    right_fit = np.polyfit(righty, rightx, 2)

    if display:
        out_img[lefty, leftx] = [255, 0, 0]
        out_img[righty, rightx] = [0, 0, 255]
        # Plots the left and right polynomials on the lane lines
        plt.plot(left_fitx, ploty, color='yellow')
        plt.plot(right_fitx, ploty, color='yellow')
        plt.imshow(out_img)
        mpimg.imsave('./output_images/10-window_search.jpg', out_img)

    return left_fit, right_fit, leftx, lefty, rightx, righty, window_search
Example #35
0
                figure.append(temp)
            print("figure:", figure)

            # print(img.shape)
            counter = img[position[1]:position[1] + position[3] + 1,
                          position[0]:position[0] + position[2] + 1]
            counter = rgb2gray(counter)
            #plt.imshow(counter, cmap='gray', vmin=0, vmax=255)
            # plt.show()

            for i in range(5):
                img_figure = img[figure[i][1]:figure[i][1] + figure[i][3] + 1,
                                 figure[i][0]:figure[i][0] + figure[i][2] + 1]
                img_figure = rgb2gray(img_figure)
                mpimg.imsave(output_path + str(figure_reading[i]) + '/' +
                             str(index) + '.jpg',
                             img_figure,
                             cmap='gray')
                index += 1
                #plt.imshow(img_figure, cmap='gray', vmin=0, vmax=255)
                # plt.show()
"""
subprocess.call("rm -rf " + data_folder + output_all, shell=True)
f = open(data_folder + output_all,'w')

    for path,dir_list,file_list in g:
        for file_name in file_list:
                f.write(os.path.join(path, file_name))
                f.write('\n')

image_path = "../Linux/data/11_3.jpg"
img = rgb2gray(mpimg.imread(image_path))
def uploader():
    def load(fname):
        import numpy as np
        from PIL import Image
        import matplotlib.pyplot as plt
        import matplotlib.image as img
        import math as m
        import copy
        dic={}
        M = img.imread(fname)
        img.imsave('C:/Users/aditya/Desktop/cs300/static/'+fname, M)

        dic['M']=M
        W, H = M.shape[:2]
        dic['W']=W
        dic['H']=H
        NEW =  np.random.rand(W,H)
        dic['NEW']=NEW
        IMAG=  np.random.rand(W,H)
        dic['IMAG']=IMAG
        FB=(1.0/273)*np.array([ [1,4,7,4,1],
                        [4,16,26,16,4],
                        [7,26,41,26,7],
                        [4,16,26,16,4],
                        [1,4,7,4,1]
                        ])
        FS=(1.0)*np.array([
                        [0,-1,0],
                        [-1,5,-1],
                        [0,-1,0],

                        ])
        dic['FB']=FB
        dic['FS']=FS
        return dic
    def convertGray(fname):
        import copy
        import numpy as np
        d=load(fname)
        new=copy.deepcopy(d['NEW'])
        w=copy.deepcopy(d['W'])
        h=copy.deepcopy(d['H'])
        m=copy.deepcopy(d['M'])
        for i in range(w):
            for j in range(h):
                avg =float((m[i][j][0]*0.299)+(m[i][j][1]*0.587)+(m[i][j][2]*0.114))
                #avg =(m[i][j][0]+m[i][j][1]+m[i][j][2])/3
                new[i][j] = avg
        return copy.deepcopy(new)
    def blur(fname):
        import numpy as np
        import copy
        d=load(fname)
        m=copy.deepcopy(d['M'])
        Xw=Xw=m.shape[1]
        Xh=m.shape[0]

        newss=np.zeros((Xh,Xw,3))
        F=copy.deepcopy(d['FB'])



        g=sum(sum(F))
        Fh=F.shape[0]
        Fw=F.shape[1]
        H=(Fh-1)//2
        W=(Fw-1)//2

        for i in range(H,Xh-H):
            for j in range(W,Xw-W):
                s1=0
                s2=0
                s3=0
                for k in range(-H,H+1):
                    for l in range(-W,W+1):
                        a1=m[i+k,j+l,0]
                        a2=m[i+k,j+l,1]
                        a3=m[i+k,j+l,2]
                        p1=F[H+k,W+l]
                        p2=F[H+k,W+l]
                        p3=F[H+k,W+l]
                        s1+=(p1*a1)
                        s2+=(p2*a2)
                        s3+=(p3*a3)
                newss[i,j,0]=s1
                newss[i,j,1]=s2
                newss[i,j,2]=s3
        return copy.deepcopy(newss/255)
    def sharpen(fname):
        import numpy as np
        import copy
        d=load(fname)
        m=copy.deepcopy(d['M'])
        Xw=Xw=m.shape[1]
        Xh=m.shape[0]

        newsss=np.zeros((Xh,Xw,3))
        F=copy.deepcopy(d['FS'])

        g=sum(sum(F))
        Fh=F.shape[0]
        Fw=F.shape[1]
        H=(Fh-1)//2
        W=(Fw-1)//2

        for i in range(H,Xh-H):
            for j in range(W,Xw-W):
                s1=0
                s2=0
                s3=0
                for k in range(-H,H+1):
                    for l in range(-W,W+1):
                        a1=m[i+k,j+l,0]
                        a2=m[i+k,j+l,1]
                        a3=m[i+k,j+l,2]
                        p1=F[H+k,W+l]
                        p2=F[H+k,W+l]
                        p3=F[H+k,W+l]
                        s1+=(p1*a1)
                        s2+=(p2*a2)
                        s3+=(p3*a3)
                newsss[i,j,0]=s1
                newsss[i,j,1]=s2
                newsss[i,j,2]=s3
        return copy.deepcopy(newsss)
    def histogramequalisation(fname):
        import copy
        import numpy as np

        new=convertGray(fname)
        pmf={}
        cmf={}
        d=load(fname)
        w=copy.deepcopy(d['W'])
        h=copy.deepcopy(d['H'])
        for i in range(w):
            for j in range(h):
                if new[i][j] in pmf:
                    pmf[new[i][j]]+=1
                else:
                    pmf[new[i][j]]=1

        for i in pmf:
            pmf[i]=pmf[i]/(w*h)
        s=0
        for i in pmf:
            if s==0:
                s+=pmf[i]
                cmf[i]=pmf[i]
            else:
                s+=pmf[i]
                cmf[i]=s
        for i in cmf:
            cmf[i]=int(cmf[i]*255)
        newpmf={}
        for i in pmf:
            newpmf[cmf[i]]=pmf[i]*(w*h)

        pix={}
        for i in pmf:
            pix[i]=cmf[i]
        chan = np.random.rand(w,h)
        for i in range(w):
            for j in range(h):
                chan[i][j]=pix[new[i][j]]
        return copy.deepcopy(chan)
    def negative(fname):
        import numpy as np
        import copy
        from copy import deepcopy
        d=load(fname)
        w=copy.deepcopy(d['W'])
        h=copy.deepcopy(d['H'])
        neg=np.zeros((w,h))
        new=convertGray(fname)
        for i in range(w):
            for j in range(h):
                neg[i][j]=255-new[i][j]
        return deepcopy(neg)
    def logtransform(fname):
        import numpy as np
        from copy import deepcopy
        import math as m
        import copy

        d=load(fname)
        w=copy.deepcopy(d['W'])
        h=copy.deepcopy(d['H'])
        log=np.zeros((w,h))

        new=convertGray(fname)
        for i in range(w):
            for j in range(h):
                log[i][j]=0.004*m.log(new[i][j]+1)
        return deepcopy(log)
    def gamma(fname):
        import numpy as np
        import copy
        from copy import deepcopy
        d=load(fname)
        w=copy.deepcopy(d['W'])
        h=copy.deepcopy(d['H'])
        gama=np.zeros((w,h))
        new=convertGray(fname)

        for i in range(w):
            for j in range(h):
                gama[i][j]=new[i][j]**1.5
        return deepcopy(gama)
    def linear(fname):
        import numpy as np
        import copy

        from copy import deepcopy
        d=load(fname)
        w=copy.deepcopy(d['W'])
        h=copy.deepcopy(d['H'])
        lin=np.zeros((w,h))
        new=convertGray(fname)
        for i in range(w):
            for j in range(h):
                lin[i][j]=new[i][j]*25+1
        return deepcopy(lin)
    def MedianFilter(image, filter_size):
        import numpy
        result = numpy.zeros((len(image),len(image[0])))
        filter_range = filter_size // 2
        garbage = []
        for i in range(len(image)):

            for j in range(len(image[0])):

                for z in range(filter_size):
                    if i + z - filter_range < 0 or i + z +filter_range > len(image) - 1:
                        for c in range(filter_size):
                            garbage.append(0)
                    else:
                        if j + z - filter_range < 0 or j + filter_range > len(image[0]) - 1:
                            garbage.append(0)
                        else:
                            for k in range(filter_size):
                                garbage.append(image[i + z - filter_range][j + k - filter_range])

                garbage.sort()
                result[i][j] = garbage[len(garbage) // 2]
                garbage = []
        return result
    def Mean(image, filter_size):
        import numpy
        result = numpy.zeros((len(image),len(image[0])))
        filter_range = filter_size // 2
        garbage = []
        for i in range(len(image)):

            for j in range(len(image[0])):

                for z in range(filter_size):
                    if i + z - filter_range < 0 or i + z +filter_range > len(image) - 1:
                        for c in range(filter_size):
                            garbage.append(0)
                    else:
                        if j + z - filter_range < 0 or j + filter_range > len(image[0]) - 1:
                            garbage.append(0)
                        else:
                            for k in range(filter_size):
                                garbage.append(image[i + z - filter_range][j + k - filter_range])

                m=sum(garbage)//(len(garbage))
                result[i][j] = m
                garbage = []
        return result

    def rgb2gray(rgb):
        return np.dot(rgb[...,:3], [0.2989, 0.5870, 0.1140])
    def BandB(new):
        s=0
        w, h = new.shape[:2]
        for i in range(w):
            for j in range(h):
                s+=new[i][j]
        threshold=s//(new.shape[0]*new.shape[1])
        for i in range(w):
            for j in range(h):
                if new[i][j]>=threshold:
                    new[i][j]=1
                else:
                    new[i][j]=0
        return new


    if request.method == 'POST':
        import copy
        import numpy as np
        from PIL import Image
        import matplotlib.pyplot as plt
        import matplotlib.image as img
        import math as m
        import copy
        import cv2 as cv
        import io


        f = request.files['file']
        f.save(secure_filename(f.filename))
        if request.form['submit_button'] == 'Gray':
            new=convertGray(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'Gray'+str(f.filename), new,cmap='gray')
            full_filename='Gray'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Blur':
            new=blur(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'Blur'+str(f.filename), new)
            full_filename='Blur'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Sharpen Kernel':
            new=sharpen(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'S'+str(f.filename), new)
            full_filename='S'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Histogram Equalisation':
            new=histogramequalisation(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'Histo'+str(f.filename), new,cmap='gray')
            full_filename='Histo'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Linear Transformation':
            new=linear(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'linear'+str(f.filename), new,cmap='gray')
            full_filename='linear'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Gamma Transformation':
            new=gamma(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'gamma'+str(f.filename), new,cmap='gray')
            full_filename='gamma'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Negative Transformation':
            new=negative(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'negative'+str(f.filename), new,cmap='gray')
            full_filename='negative'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Log Transformation':
            new=logtransform(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'log'+str(f.filename), new,cmap='gray')
            full_filename='log'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Median Filtering':
            import numpy
            imgi = img.imread(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+str(f.filename), imgi)
            gray = rgb2gray(imgi)
            arr = numpy.array(gray)
            imgi = MedianFilter(arr, 3)
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'Med'+str(f.filename), imgi,cmap='gray')
            full_filename='Med'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Mean Filtering':
            import numpy
            imgi = img.imread(str(f.filename))
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+str(f.filename), imgi)
            gray = rgb2gray(imgi)
            arr = numpy.array(gray)
            imgi = Mean(arr, 3)
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'Mean'+str(f.filename), imgi,cmap='gray')
            full_filename='Mean'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))
        elif request.form['submit_button'] == 'Black & White':
            new=convertGray(str(f.filename))
            new=BandB(new)
            img.imsave('C:/Users/aditya/Desktop/cs300/static/'+'B&W'+str(f.filename), new,cmap='gray')
            full_filename='B&W'+str(f.filename)
            return render_template('image.html',name=full_filename,input=str(f.filename))


        return 'file uploaded successfully'
    sxbinary = np.zeros_like(scaled_sobel)
    sxbinary[(scaled_sobel >= thresh_min) & (scaled_sobel <= thresh_max)] = 1

    # Threshold color channel
    s_thresh_min = 170
    s_thresh_max = 255
    s_binary = np.zeros_like(S)
    s_binary[(S >= s_thresh_min) & (S <= s_thresh_max)] = 1

    combined_binary = np.zeros_like(sxbinary)
    combined_binary[(s_binary == 1) | (sxbinary == 1)] = 1

    plt.figure(c)
    plt.imshow(combined_binary, cmap='gray')
    mpimg.imsave("output_images/" + fname + "_combBin.jpg",
                 combined_binary,
                 cmap='gray')

    #trap = np.array([[[240,686],[1055,675],[690,450],[587,450]]], np.int32)
    #wwww = np.array([[[100,img.shape[1]],[1100,img.shape[1]],[1100,0],[100,0]]], np.int32)
    trap = np.array([[[568, 468], [715, 468], [1040, 680], [270, 680]]],
                    np.int32)
    wwww = np.array([[[200, 0], [1000, 0], [1000, 680], [200, 680]]], np.int32)
    src = np.float32(trap)
    dst = np.float32(wwww)
    M = cv2.getPerspectiveTransform(src, dst)
    warped = cv2.warpPerspective(
        combined_binary,
        M, (combined_binary.shape[1], combined_binary.shape[0]),
        flags=cv2.INTER_LINEAR)
Example #38
0
    for epoch in range(total_epochs):
        for batch in range(total_batchs):
            batch_x = train_x[batch * batch_size:(batch + 1) * batch_size]
            noise = random_noise(batch_size)

            sess.run(g_train, feed_dict={Z: noise})
            sess.run(d_train, feed_dict={X: batch_x, Z: noise})

            gl, dl = sess.run([g_loss, d_loss],
                              feed_dict={
                                  X: batch_x,
                                  Z: noise
                              })

        if epoch % 2 == 0:
            print("======= Epoch : ", epoch, " =======")
            print("generator: ", -gl)
            print("discriminator: ", -dl)

        samples = 20
        if epoch % 2 == 0:
            sample_noise = random_noise(samples)
            gen = sess.run(fake_x, feed_dict={Z: sample_noise})

            for i in range(samples):
                img = gen[i].reshape([256, 256, 3])
                mpimg.imsave('./epoch/epoch' + str(epoch) + '_' + str(i) +
                             '.png',
                             img,
                             format='png')
% Remove the low frequencies from image2. The easiest way to do this is to
% subtract a blurred version of image2 from the original version of image2.
% This will give you an image centered at zero with negative values.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
"""

lf2 = my_imfilter(image2, filter)
lf2 = my_imfilter(lf2, filter_transpose)
high_frequencies = image2 - lf2
"""
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Combine the high frequencies and low frequencies
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
"""
hybrid_image = low_frequencies + high_frequencies

#%% Visualize and save outputs

plt.figure(1)
plt.imshow(low_frequencies)
plt.figure(2)
plt.imshow(high_frequencies + 0.5)
vis = vis_hybrid_image(hybrid_image)  #see function script vis_hybrid_image.py
plt.figure(3)
plt.imshow(vis)
mpimg.imsave('Results/low_frequencies.jpg', np.clip(low_frequencies, 0, 1))
mpimg.imsave('Results/high_frequencies.jpg',
             np.clip(high_frequencies + 0.5, 0, 1.0))
mpimg.imsave('Results/em_hybrid_image.jpg', np.clip(hybrid_image, 0, 1))
mpimg.imsave('Results/em_hybrid_image_scales.jpg', np.clip(vis, 0, 1))
cv2.fillPoly(mask, vertices, ignore_mask_color)
masked_edges = cv2.bitwise_and(edges, mask)

# Define the Hough transform parameters
# Make a blank the same size as our image to draw on
rho = 2  # distance resolution in pixels of the Hough grid
theta = np.pi / 180  # angular resolution in radians of the Hough grid
threshold = 15  # minimum number of votes (intersections in Hough grid cell)
min_line_length = 40  #minimum number of pixels making up a line
max_line_gap = 20  # maximum gap in pixels between connectable line segments
line_image = np.copy(image) * 0  # creating a blank to draw lines on

# Run Hough on edge detected image
# Output "lines" is an array containing endpoints of detected line segments
lines = cv2.HoughLinesP(masked_edges, rho, theta, threshold, np.array([]),
                        min_line_length, max_line_gap)

# Iterate over the output "lines" and draw lines on a blank image
for line in lines:
    for x1, y1, x2, y2 in line:
        cv2.line(line_image, (x1, y1), (x2, y2), (255, 0, 0), 10)

# Create a "color" binary image to combine with line image
color_edges = np.dstack((edges, edges, edges))

# Draw the lines on the edge image
lines_edges = cv2.addWeighted(color_edges, 0.8, line_image, 1, 0)
mpimg.imsave('output.jpg', line_image)
plt.imshow(lines_edges)
plt.show()
Example #41
0
import numpy as np
import matplotlib.image as img
import statistics as stits
a = img.imread("Sample.png")
h, w = a.shape[:2]
k = np.zeros([h, w, 3])
for i in range(0, h):
    for j in range(0, w):
        n = [a[i][j][0], a[i][j][1], a[i][j][2]]
        m = int(stits.mean(n))
        k[i][j][0] = int(m)
        k[i][j][1] = int(m)
        k[i][j][2] = int(m)
img.imsave('test.png', k)
Example #42
0
    signal = np.clip(signal, -500, 500)
    # Calculate activation signal
    return expit(signal)


def ReLU_function(signal):
    # Return the activation signal
    return np.maximum(0, signal)


################################################################################
# Load Input Image
################################################################################
img = Image.open(os.path.join(PATH_TO_TEST_IMAGES_DIR, PATH_TO_TEST_IMAGE))
# Save original image to the visualization folder
image.imsave(os.path.join(PATH_TO_INPUT_IMAGE, '{}.png'.format(0)), img)
input_image = np.array(img.getdata(), dtype=np.uint8)
input_image = np.resize(input_image, (img.size[1], img.size[0], 4))
input_image = input_image[:, :, 1]

################################################################################
# Convolution 1
################################################################################
conv1_output = np.empty((20, 20, 256))
for i in range(conv1_weights.shape[3]):
    # Get the 9x9 kernel
    extracted_filter = conv1_weights[:, :, :, i]
    extracted_filter = np.squeeze(extracted_filter)

    # Save image of the kernel
    image.imsave(os.path.join(PATH_TO_CONV1_KERNEL, '{}.png'.format(i)),
Example #43
0
if __name__ == "__main__":
    labels = defaultdict(list)
    with open('training_data/object-detection-crowdai/labels.csv',
              'r') as csvfile:
        label_data = csv.DictReader(csvfile)
        for row in label_data:
            if row['Label'] == 'Car':
                x0, x1, y0, y1 = int(row['xmin']), int(row['ymin']), int(
                    row['xmax']), int(row['ymax'])
                value = (min(x0, x1), max(x0, x1), min(y0, y1), max(y0, y1))
                labels[row['Frame']].append(value)

    filenames = glob.glob('training_data/object-detection-crowdai/*.jpg')
    # out_path = 'training_data/udacity/cars/'  #to void triggering by mistake and blowing away folder!!
    if os.path.exists(out_path):
        shutil.rmtree(out_path)
    os.makedirs(out_path)
    i = 0
    for fname in filenames:
        frame_name = os.path.basename(fname)
        frame_labels = labels.get(frame_name)
        if frame_labels is not None:
            image = mpimg.imread(fname)
            for label in frame_labels:
                sub_image = image[label[2]:label[3], label[0]:label[1], :]
                if sub_image.any():
                    outname = "{}/{}.png".format(out_path, i)
                    mpimg.imsave(outname, sub_image)
                    i += 1
Example #44
0
#gray scale
import matplotlib.image as img
a=img.imread("sample.jpg")
w,h=a.shape[:2]
import numpy as np
b=np.zeros([w,h,3])
import statistics as stits
for i in range(0,w):
 for j in range(0,h):
  n=[a[i][j][0],a[i][j][1],a[i][j][2]]
  k=int(stits.mean(n))
  b[i][j][0]=int(k)
  b[i][j][1]=int(k)
  b[i][j][2]=int(k)
img.imsave('shine1.jpg',b)



    img = mpimg.imread(img_path)
    img = np.array(img)

    mask = mpimg.imread(mask_path)
    mask = np.array(mask)

    #converting to grayscale

    mask_gray = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY)
    img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)

    block_sizes = [5, 10, 15, 20, 25, 30]
    SD_THs = [None, 1, 2, 3, 4]
    pms = []
    counter = 1
    for size in block_sizes:
        for SD_TH in SD_THs:

            print("size :", size, " SD_TH:", SD_TH)

            pm = CPF(img_gray, mask_gray, size, mean_threshold, SD_threshold,
                     min_pixel_distance, check_offset, SD_TH)

            output = str(img_no) + "_" + str(counter) + ".png"

            mpimg.imsave(output, pm, cmap="gray")

            counter += 1

plt.show()
Example #46
0
# -*- coding: utf-8 -*-
"""
Generates templates with dots for each domino
"""

import numpy as np
import matplotlib as mpl
from matplotlib.image import imsave
import cv2 as cv
import os

folder = "domino_templ"
base_images = []
final_images = []
for i in range(0, 7):
    img = cv.imread(os.path.join(folder, "base/%i.png" % i))
    if img is not None:
        img = img[:, :, 1]
        base_images.append(img)
        #imsave(folder + '/0%i.png' %i, img)

for i in range(7):
    for j in range(i + 1):
        upper_half = base_images[i][:, :]
        lower_half = base_images[j][::-1, ::-1]
        img = np.vstack((upper_half[:100, :], lower_half[100:, :]))
        imsave(folder + '/%i%i.png' % (j, i), 255 - img, cmap='binary')
Example #47
0
def simulateByteErrors(I, IDims, fracbyte, doPlot=False):
    """
    Create a version of the video which would occur from bit errors
    :param I: NFrames x NPixels video array
    :param IDims: Tuple of the dimensions of the pixels
    :param fracbyte: The fraction of the bytes that are randomly changed
    """
    TEMPAVI = "temp.avi"
    LFAC = 400  #How many bytes to corrupt in a row
    FLIPPROB = 0.5
    FrameRate = 30
    N = I.shape[0]
    #Step 1: Output video as temporary files and convert to AVI
    for i in range(N):
        frame = np.reshape(I[i, :], IDims)
        mpimage.imsave("%s%i.png" % (TEMP_STR, i + 1), frame)
    #Convert to video using avconv
    if os.path.exists(TEMPAVI):
        os.remove(TEMPAVI)
    command = [
        AVCONV_BIN, '-r',
        "%i" % FrameRate, '-i', TEMP_STR + '%d.png', '-r',
        "%i" % FrameRate, '-b', '30000k', TEMPAVI
    ]
    subprocess.call(command)

    #Step 2: Read in AVI file as a binary file and corrupt it
    fin = open(TEMPAVI, "rb")
    b = fin.read()
    fin.close()
    #Cleanup leftover files
    for i in range(N):
        os.remove("%s%i.png" % (TEMP_STR, i + 1))
    os.remove(TEMPAVI)
    b = bytearray(b)
    i = 15000  #Make sure the header is skipped
    lam = LFAC / fracbyte
    ilocs = []
    while i < len(b):
        i += int(np.random.exponential(lam))
        ilocs.append(i)
    NumFlipped = 0
    for i in ilocs:
        for k in range(i, min(i + LFAC, len(b))):
            if np.random.rand() < FLIPPROB:
                b[k] = np.random.randint(255)
                NumFlipped += 1
    if doPlot:
        #For debugging
        plt.stem(np.array(ilocs), np.ones(len(ilocs)))
        plt.title("fracbyte = %g, %g flipped" %
                  (fracbyte, float(NumFlipped) / len(b)))
        plt.show()
    fout = open(TEMPAVI, "wb")
    fout.write(b)
    fout.close()

    #Step 3: Use avconv to extract the corrupted frames
    command = [AVCONV_BIN, '-i', TEMPAVI, '-f', 'image2', TEMP_STR + '%d.png']
    subprocess.call(command)
    os.remove(TEMPAVI)
    i = 1
    frames = []
    IDimsRet = IDims
    while os.path.exists("%s%d.png" % (TEMP_STR, i)):
        filename = "%s%d.png" % (TEMP_STR, i)
        F = scipy.misc.imread(filename)
        IDimsRet = F.shape
        #os.remove(filename)
        frames.append(F.flatten())
        i += 1
    ret = np.array(frames) / 255.0
    return (ret, IDimsRet)
Example #48
0
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
@author: Wenxuan Liu 805152602
"""

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np

if __name__ == "__main__":
    img1 = mpimg.imread('g.jpg').copy()
    img2 = mpimg.imread('h.jpg').copy()
    img1 = img1 / 255.0
    img2 = img2 / 255.0
    a, b, c = img1.shape
    img3 = np.empty([a, b, c])
    for i in range(a):
        for j in range(b):
            for k in range(c):
                img3[i, j, k] = abs(img2[i, j, k]-img1[i, j, k])    #find the difference
    plt.axis('off')
    plt.imshow(img3)
    mpimg.imsave('i.jpg', img3)
    plt.show()
for idx, fname in enumerate(images):
    test_img = mpimg.imread(fname)
    # Find_cars on test images
    box_list, find_cars_img = find_cars(test_img,
                                        ystart=ystart,
                                        ystop=ystop,
                                        color_space=color_space,
                                        scale=scale,
                                        svc=svc,
                                        X_scaler=X_scaler,
                                        orient=orient,
                                        pix_per_cell=pix_per_cell,
                                        cell_per_block=cell_per_block,
                                        spatial_size=spatial_size,
                                        hist_bins=hist_bins)
    mpimg.imsave('./output_images/find_cars_' + str(idx) + '.jpg',
                 find_cars_img)
    # Add heat to each box in box list
    heat = np.zeros_like(test_img[:, :, 0]).astype(np.float)
    heat = add_heat(heat, box_list)
    # Visualize the heatmap when saving
    heatmap = np.clip(heat, 0, 255)
    mpimg.imsave('./output_images/add_heat_' + str(idx) + '.jpg',
                 heatmap,
                 cmap='hot')
    # Apply threshold to help remove false positives
    heat = apply_threshold(heat, threshold=threshold)
    # Visualize the heatmap when saving
    heatmap = np.clip(heat, 0, 255)
    mpimg.imsave('./output_images/apply_threshold_' + str(idx) + '.jpg',
                 heatmap,
                 cmap='hot')
Example #50
0
    """
    The image "img" will be repeated n times in 
    vertical and m times in horizontal direction.
    """
    if n == 1:
        tiled_img = img
    else:
        lst_imgs = []
        for i in range(n):
            lst_imgs.append(img)
        tiled_img = np.concatenate(lst_imgs, axis=1)
    if m > 1:
        lst_imgs = []
        for i in range(m):
            lst_imgs.append(tiled_img)
        tiled_img = np.concatenate(lst_imgs, axis=0)

    return tiled_img


basic_pattern = mpimg.imread('imag_tile_explanation.png')
decorators_img = imag_tile(basic_pattern, 3, 3)
print decorators_img
plt.axis("off")
plt.imshow(decorators_img)
cropped = basic_pattern[90:150, 50:120]
# print(at_img.shape)
mpimg.imsave('/home/halk/Pictures/decorators_with_at.png', cropped)

mpimg.imsave('/home/halk/Pictures/decorators_with_at1.png', decorators_img)
Example #51
0
        if i < 2:
            continue
        fname = x.split(' ')[0]
        landmarks = x.split(' ')[1:]
        landmarks = [int(a) for a in landmarks if len(a) > 0]

        if len(landmarks) == 10:
            nose_to_left_eye = landmarks[0] - landmarks[4]
            eye_distance = landmarks[0] - landmarks[2]
            rotation = nose_to_left_eye / float(eye_distance)
            # print('%s %.04f' % (fname, rotation))

            if (rotation > 0.35) and (rotation < 0.65):
                eye_height = (landmarks[1] + landmarks[3]) // 2
                mouth_height = (landmarks[7] + landmarks[9]) // 2
                nose_height = landmarks[5]
                # origin is top left
                thirds_height = mouth_height - eye_height
                top = eye_height - thirds_height
                bottom = nose_height + thirds_height

                left = landmarks[4] - thirds_height
                right = landmarks[4] + thirds_height

                # nose_to_right_eye = landmarks[2] - landmarks[4]

                img = imread('%s/%s' % (src_folder, fname))
                crop = img[top:bottom, left:right]
                imsave('%s/%s' % (dst_folder, fname), crop)
                # img.close()
Example #52
0
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Sun Sep 15 15:07:42 2019

@author: nguyent
"""

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpg

largeur = 600
longueur = int(largeur * 2 / 3)

c = int(largeur * 1 / 3)

im = np.zeros((longueur, largeur, 3), dtype=np.uint8)

im[:, 0:c:1] = [5, 20, 64]
im[:, c:2 * c:1] = [255, 255, 255]
im[:, 2 * c:3 * c:1] = [236, 25, 32]

plt.imshow(im)
mpg.imsave('Flag/DrapeauFrancais.png', im)
            x0 = start.real - (radius / 2) + (j * radius / nb_pxls)
            y0 = start.imag - (radius / 2) + (i * radius / nb_pxls)
            z0 = complex(x0, y0)
            # gray = (MAX - how_long_within(z0, MAX))/MAX
            # color = (gray, gray, gray)
            index = MAX - how_long_within(z0, MAX)
            color = COLORS[index]
            mtrx[i, j] = color
    return mtrx

    # mtrx[i,j] =


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Draw mandelbrot set')
    parser.add_argument('nb_pixels',
                        type=int,
                        help='size in pixels of the square image')
    parser.add_argument('xc', type=float, help='real part of the start')
    parser.add_argument('yc', type=float, help='imaginary part of the start')
    parser.add_argument('radius',
                        type=float,
                        help='enter smaller numbers to zoom near')
    args = parser.parse_args()
    nb_pixels = args.nb_pixels
    xc = args.xc
    yc = args.yc
    radius = args.radius
    res = mandelbrot_image_matrix(nb_pixels, complex(xc, yc), radius)
    mpimg.imsave('tes.png', res)
Example #54
0
def save_images(model_dict,
                data_dict,
                X_test,
                adv_x,
                dev_list,
                mean,
                rd=None,
                dr_alg=None):
    """Save <no_of_img> samples as image files in visual_data folder"""

    from lib.utils.dr_utils import invert_dr

    no_of_img = 1
    indices = range(no_of_img)
    X_curr = X_test[indices]
    channels = data_dict['channels']
    atk = model_dict['attack']
    dataset = model_dict['dataset']
    DR = model_dict['dim_red']
    rev = model_dict['rev']
    abs_path_v = resolve_path_v(model_dict)

    if (rd is not None) and (rev is None):
        X_curr = invert_dr(X_curr, dr_alg, DR)
        features_per_c = X_curr.shape[-1]
        height = int(np.sqrt(features_per_c))
        width = height
        X_curr_rev = X_curr.reshape((no_of_img, channels, height, width))
    elif (rd is None) or ((rd is not None) and (rev is not None)):
        height = data_dict['height']
        width = data_dict['width']

    if channels == 1:
        dev_count = 0
        for dev_mag in dev_list:
            adv_curr = adv_x[indices, :, dev_count]
            if (rd is not None) and (rev is None):
                adv_x_rev = invert_dr(adv_curr, dr_alg, DR)
                adv_x_rev = adv_x_rev.reshape(
                    (no_of_img, channels, height, width))
                for i in indices:
                    adv = adv_x_rev[i].reshape((height, width))
                    orig = X_curr_rev[i].reshape((height, width))
                    adv += mean
                    orig += mean
                    img.imsave(
                        abs_path_v +
                        '{}_{}_{}_{}_mag{}.png'.format(atk, i, DR, d, dev_mag),
                        adv * 255,
                        vmin=0,
                        vmax=255,
                        cmap='gray')
                    img.imsave(abs_path_v +
                               '{}_{}_{}_orig.png'.format(i, DR, rd),
                               orig * 255,
                               vmin=0,
                               vmax=255,
                               cmap='gray')

            elif (rd is None) or (rev is not None):
                adv_x_curr = adv_x[indices, :, dev_count]
                for i in indices:
                    adv = adv_x_curr[i].reshape((height, width))
                    orig = (X_curr[i] + mean[0]).reshape((height, width))
                    mean_arr = mean[0].reshape((height, width))
                    adv += mean[0]
                    if rd is not None:
                        fname = abs_path_v + ' {}_{}_{}_rev_{}'.format(
                            atk, i, DR, rd)
                    elif rd is None:
                        fname = abs_path_v + '{}_{}'.format(atk, i)
                    img.imsave(fname + '_mag{}.png'.format(dev_mag),
                               adv * 255,
                               vmin=0,
                               vmax=255,
                               cmap='gray')
                    img.imsave(fname + '_orig.png',
                               orig * 255,
                               vmin=0,
                               vmax=255,
                               cmap='gray')
            dev_count += 1
Example #55
0
def main(data_set,
         model_type,
         latent_dim,
         shortcut='True',
         num_epoch=100,
         log_gamma_decay=0.0,
         beta_policy_type='constant'):
    data_dir = data_folder(data_set)
    if data_dir == '':
        print('No such data set named {0}.'.format(data_set))
        return
    x = load_img_from_folder(data_dir, num_img=50)

    if model_type == 'VAE':
        variational = True
    elif model_type == 'AE':
        variational = False
    else:
        print('No such model type named {0}.'.format(model_type))
        return

    if shortcut == 'True':
        resnet = True
    elif shortcut == 'False':
        resnet = False
    else:
        print('Shortcut setting unclear: {0}.'.format(shortcut))
        return

    if beta_policy_type == 'constant':
        beta_policy = constant_beta
    elif beta_policy_type == 'linear':
        beta_policy = linear_beta
    else:
        print('No beta policy named {0}.'.format(beta_policy_type))
        return


#    model = VaeNet(variational, latent_dim=latent_dim, shortcut=resnet, init_log_gamma=-4.0, log_gamma_decay=log_gamma_decay)

#    if not os.path.exists('model'):
#        os.mkdir('model')
#    with tf.Session() as sess:
#        sess.run(tf.global_variables_initializer())
#        saver = tf.train.Saver()
#        writer = tf.summary.FileWriter('graph', sess.graph)

#        train_model(model, sess, writer, x, num_epoch, 0.002, 32, beta_policy)
#        saver.save(sess, 'model/model.ckpt')

#    tf.reset_default_graph()
    model = VaeNet(variational,
                   latent_dim=latent_dim,
                   shortcut=resnet,
                   is_train=False)
    with tf.Session() as sess:
        saver = tf.train.Saver()
        saver.restore(
            sess,
            './experiment/HYPER_GammaDecay_Policy/Flower_000_constant/model/model.ckpt'
        )
        samples = generate_sample(model, sess, 500)
        if not os.path.exists('samples'):
            os.mkdir('samples')
        for i in range(500):
            mpimg.imsave('samples/' + str(i) + '.jpg', samples[i, :, :, :],
                         0.0, 1.0)
Example #56
0
        raw_imgs = draw_boxes(raw_imgs, boxes)

        # save found boxes
        for box in boxes:
            box_list.append(box)
            # print(box_list)

    # Add heat to each box in box list
    heat = add_heat(heat, box_list)
    # filter out multiple detections and false positives
    tresh_heat = np.copy(heat)
    tresh_heat = apply_threshold(tresh_heat, 3)

    # visualize the heatmap when displaying
    heatmap = np.clip(tresh_heat, 0, 255)

    # process labels
    labels = label(heatmap)
    draw_img = draw_labeled_bboxes(np.copy(img), labels)
    print(labels[1], 'cars found in file', fname)

    # plot images
    mpimg.imsave('./output_images/' + fname[-9:-4] + '_cars_found.jpg',
                 raw_imgs)
    mpimg.imsave('./output_images/' + fname[-9:-4] + '_heat.jpg', heat)
    mpimg.imsave('./output_images/' + fname[-9:-4] + '_tresh_heat.jpg',
                 tresh_heat)
    mpimg.imsave('./output_images/' + fname[-9:-4] + '_processed.jpg',
                 draw_img)
    # mpimg.imsave('./output_images/'+fname[-9:-4]+'_windows.jpg', window_img)
Example #57
0
def draw_lines(img,
               lines,
               color=[255, 0, 0],
               thickness=6,
               output_path="test_images/annotated/"):
    """workflow:
    1) examine each individual line returned by hough & determine if it's in left or right lane by its slope
    because we are working "upside down" with the array, the left lane will have a negative slope and right positive
    2) track extrema
    3) compute averages
    4) solve for b intercept 
    5) use extrema to solve for points
    6) smooth frames and cache
    """
    y_global_min = img.shape[
        0]  #min will be the "highest" y value, or point down the road away from car
    y_max = img.shape[0]
    l_slope, r_slope = [], []
    l_lane, r_lane = [], []
    det_slope = 0.4
    hough_lines_img = copy.deepcopy(img)

    print "Found {0} lines in the image.".format(len(lines))
    for line in lines:
        #1
        for x1, y1, x2, y2 in line:
            cv2.line(hough_lines_img, (x1, y1), (x2, y2), color, thickness)
            slope = get_slope(x1, y1, x2, y2)
            if slope > det_slope:
                r_slope.append(slope)
                r_lane.append(line)
            elif slope < -det_slope:
                l_slope.append(slope)
                l_lane.append(line)
        #2
        y_global_min = min(y1, y2, y_global_min)

    mpimg.imsave(output_path + "6a-hough_lines.jpg", hough_lines_img)

    # to prevent errors in challenge video from dividing by zero
    if ((len(l_lane) == 0) or (len(r_lane) == 0)):
        print('no lane detected')
        return 1

    #3
    l_slope_mean = np.mean(l_slope, axis=0)
    r_slope_mean = np.mean(r_slope, axis=0)
    l_mean = np.mean(np.array(l_lane), axis=0)
    r_mean = np.mean(np.array(r_lane), axis=0)

    if ((r_slope_mean == 0) or (l_slope_mean == 0)):
        print('dividing by zero')
        return 1

    #4, y=mx+b -> b = y -mx
    l_b = l_mean[0][1] - (l_slope_mean * l_mean[0][0])
    r_b = r_mean[0][1] - (r_slope_mean * r_mean[0][0])

    #5, using y-extrema (#2), b intercept (#4), and slope (#3) solve for x using y=mx+b
    # x = (y-b)/m
    # these 4 points are our two lines that we will pass to the draw function
    l_x1 = int((y_global_min - l_b) / l_slope_mean)
    l_x2 = int((y_max - l_b) / l_slope_mean)
    r_x1 = int((y_global_min - r_b) / r_slope_mean)
    r_x2 = int((y_max - r_b) / r_slope_mean)

    #6
    if l_x1 > r_x1:
        l_x1 = int((l_x1 + r_x1) / 2)
        r_x1 = l_x1
        l_y1 = int((l_slope_mean * l_x1) + l_b)
        r_y1 = int((r_slope_mean * r_x1) + r_b)
        l_y2 = int((l_slope_mean * l_x2) + l_b)
        r_y2 = int((r_slope_mean * r_x2) + r_b)
    else:
        l_y1 = y_global_min
        l_y2 = y_max
        r_y1 = y_global_min
        r_y2 = y_max

    vertices = np.array([l_x1, l_y1, l_x2, l_y2, r_x1, r_y1, r_x2, r_y2],
                        dtype=np.int32)
    cv2.line(img, (vertices[0], vertices[1]), (vertices[2], vertices[3]),
             color, thickness)
    cv2.line(img, (vertices[4], vertices[5]), (vertices[6], vertices[7]),
             color, thickness)
Example #58
0
def process_frame(image, output_path="test_images/annotated/"):

    imshape = image.shape
    print "imshape =", imshape

    # KITCHEN
    # lower_left = [0, imshape[0]]
    # lower_right = [imshape[1]*9/10, imshape[0]]
    # top_left = [0, imshape[0]/4]
    # top_right = [imshape[1]*7/8, imshape[0]/4]

    # HIGHWAY
    # lower_left = [0, imshape[0]]
    # lower_right = [imshape[1]*7/9, imshape[0]]
    # top_left = [imshape[1]*3/8, imshape[0]*4/10]
    # top_right = [imshape[1]*6/9, imshape[0]*4/10]

    # BALCANI
    # lower_left = [imshape[1]/8, imshape[0]]
    # lower_right = [imshape[1]*7/8, imshape[0]]
    # top_left = [imshape[1]*3/7, imshape[0]*5/8]
    # top_right = [imshape[1]*4/7, imshape[0]*5/8]

    # DEFAULT
    lower_left = [imshape[1] / 9, imshape[0]]
    lower_right = [imshape[1] * 8 / 9, imshape[0]]
    top_left = [imshape[1] * 3 / 8, imshape[0] * 6 / 10]
    top_right = [imshape[1] * 5 / 8, imshape[0] * 6 / 10]

    roi_lines_image = copy.deepcopy(image)
    color = [0, 255, 0]
    thickness = 3
    cv2.line(roi_lines_image, (lower_left[0], lower_left[1]),
             (top_left[0], top_left[1]), color, thickness)
    cv2.line(roi_lines_image, (top_left[0], top_left[1]),
             (top_right[0], top_right[1]), color, thickness)
    cv2.line(roi_lines_image, (top_right[0], top_right[1]),
             (lower_right[0], lower_right[1]), color, thickness)
    cv2.line(roi_lines_image, (lower_right[0], lower_right[1]),
             (lower_left[0], lower_left[1]), color, thickness)
    mpimg.imsave(output_path + "1a-roi_lines_image.jpg", roi_lines_image)

    vertices = [
        np.array([lower_left, top_left, top_right, lower_right],
                 dtype=np.int32)
    ]
    roi_image = region_of_interest(image, vertices)
    mpimg.imsave(output_path + "1b-roi_image.jpg", roi_image)

    gray_image = grayscale(roi_image)
    mpimg.imsave(output_path + "1-grayscale.jpg", gray_image)

    img_hsv = cv2.cvtColor(roi_image, cv2.COLOR_RGB2HSV)
    mpimg.imsave(output_path + "2-hsv.jpg", img_hsv)
    #hsv = [hue, saturation, value]
    #more accurate range for yellow since it is not strictly black, white, r, g, or b

    lower_yellow = np.array([20, 100, 100], dtype="uint8")
    upper_yellow = np.array([30, 255, 255], dtype="uint8")

    mask_yellow = cv2.inRange(img_hsv, lower_yellow, upper_yellow)
    mpimg.imsave(output_path + "3a-mask_yelow.jpg", mask_yellow)

    mask_white = cv2.inRange(gray_image, 180, 255)
    mpimg.imsave(output_path + "3b-mask_white.jpg", mask_white)

    mask_yw = cv2.bitwise_or(mask_white, mask_yellow)
    mask_yw_image = cv2.bitwise_and(gray_image, mask_yw)
    mpimg.imsave(output_path + "3c-mask_yellow_white.jpg", mask_yw_image)

    kernel_size = 5
    gauss_gray = gaussian_blur(mask_yw_image, kernel_size)
    mpimg.imsave(output_path + "4-gauss_gray.jpg", gauss_gray)

    #same as quiz values
    low_threshold = 50
    high_threshold = 150
    canny_edges = canny(gauss_gray, low_threshold, high_threshold)
    mpimg.imsave(output_path + "5-canny_edges.jpg", canny_edges)

    #rho and theta are the distance and angular resolution of the grid in Hough space
    #same values as quiz
    rho = 2
    theta = np.pi / 180
    #threshold is minimum number of intersections in a grid for candidate line to go to output
    threshold = 30
    min_line_len = 50
    max_line_gap = 100

    line_image = hough_lines(canny_edges,
                             rho,
                             theta,
                             threshold,
                             min_line_len,
                             max_line_gap,
                             output_path=output_path)
    mpimg.imsave(output_path + "6b-hough_lines.jpg", line_image)

    result = weighted_img(line_image, image, alpha=0.8, beta=1., gamma=0.)
    return result
Example #59
0
        return samples


if __name__ == "__main__":
    dbTrain = MyDatabase("database/train", "database/train/data_train.csv")
    print("Train db length: ", len(dbTrain))
    edge = Edge()

    dbTest = MyDatabase("database/test", "database/test/data_test.csv")
    print("Test db length: ", len(dbTest))

    # check shape
    assert edge_kernels.shape == (5, 2, 2)

    # evaluate database
    APs, res = myevaluate(dbTrain,
                          dbTest,
                          edge.make_samples,
                          depth=depth,
                          d_type="d1")

    # add pictures in prediction folder under the predicted class folder
    path = "/Users/johanncarfantan/Documents/ENSSAT/IMR3/AnalyseDimages/Partie 1/predictions/"
    for i in range(len(dbTest)):
        saveName = path + res[i] + "/" + dbTest.data.img[i].split('/')[-1]
        bid = imageio.imread(dbTest.data.img[i])
        if not os.path.exists(path + res[i]):
            os.makedirs(path + res[i])
        mpimg.imsave(saveName, bid / 255.)
Example #60
0
im = mplimg.imread(imgPath)

# Do rectification in two stages
imA, HA = rectifyAffineF(im, nLinePairs)
plt.close('all')
imM, HM = rectifyMetricF(imA, nLinePairs)

# Translate and scale HM * HA to the image
H = translateAndScaleHToImage(np.dot(HM, HA), imA.shape)

# Apply translated and scaled version of HM * HA
imM = myApplyH(im, H)  # Chain the two transforms
plt.close('all')

# Show result
imshow(np.concatenate((im, imA, imM), axis=1))
axis('off')
plt.suptitle(
    'Original (left), Affine rectified (middle), Metric rectification (right)')
margin = 0.05
plt.subplots_adjust(left=margin,
                    right=1.0 - margin,
                    top=1.0 - margin,
                    bottom=margin)
show()

# Save output
imgPathRect = fileparts[0] + "_rect" + fileparts[1]
print("Saving output to %s..." % imgPathRect)
mplimg.imsave(imgPathRect, cropOuterRegion(imM))