def main(pixCount, srcDir, destDir): srcNames = os.listdir(srcDir) nr = 0 for srcName in srcNames: nr += 1 countLog = str(nr) + '/' + str(len(srcNames)) + ' >' srcPath = os.path.join(srcDir, srcName) destName = srcName.split('.')[0] + '_slice' + str(pixCount) + '.tif' destPath = os.path.join(destDir, destName) if os.path.isfile(destPath): #print(countLog, destName, 'already processed') continue srcExt = srcName.split('.')[-1] if srcExt.lower() in ['png', 'jpg']: img = Image.open(srcPath) rgb = numpy.asarray(img) sliver(pixCount, rgb, destPath) print(countLog, srcName, 'slivered') elif srcExt.lower() in ['tif', 'tiff']: rgb = tifffile.imread(srcPath) sliver(pixCount, rgb, destPath) print(countLog, srcName, 'slivered') elif srcExt.lower() in ['nef', 'cr2', 'dng']: try: raw = rawpy.imread(srcPath) except: raw = None if raw: rawpyPars = rawpy.Params(output_bps=16) rgb = raw.postprocess(params=rawpyPars) sliver(pixCount, rgb, destPath) print(countLog, srcName, 'slivered') else: corruptDir = os.path.join(srcDir, '../' + os.path.basename(srcDir) + '__corrupt') if not os.path.isdir(corruptDir): os.makedirs(corruptDir) corruptPath = os.path.join(corruptDir, srcName) if not os.path.exists(corruptPath): copyfile(srcPath, corruptPath) print(countLog, srcName, 'rawpy import faild, copied to "corrupt" dir') else: convertedName = srcName.split('.')[0] + '.dng' convertedPath = os.path.join(corruptDir, convertedName) if not os.path.exists(convertedPath): print(countLog, srcName, 'is corrupt, convert to .dng, leave in "corrupt" dir') else: try: raw = rawpy.imread(convertedPath) except: raw = None if raw: print(countLog, convertedName) sliver(pixCount, rawConverted, destPath) else: print(countLog, convertedName, 'found converted .dng, rawpy import faild, you`re screwed') print('finished!')
def testBayerPattern(): expected_desc = b'RGBG' # libraw hard-codes this and varies the color indices only for path in [rawTestPath, raw2TestPath]: raw = rawpy.imread(path) assert_equal(raw.color_desc, expected_desc) assert_array_equal(raw.raw_pattern, [[0,1],[3,2]]) raw = rawpy.imread(raw3TestPath) assert_equal(raw.color_desc, expected_desc) assert_array_equal(raw.raw_pattern, [[3,2],[0,1]])
def take_picture_thread(self, stop): self.go_button.setEnabled(False) self.stop_button.setEnabled(True) if self.get_parameter('shutterspeed')[1] != 'bulb': self.text_line.setText('Capturing...') error, self.file_path = gphoto2.gp_camera_capture(self.camera, gphoto2.GP_CAPTURE_IMAGE, self.context) camera_file = gphoto2.check_result(gphoto2.gp_camera_file_get(self.camera, self.file_path.folder, self.file_path.name, gphoto2.GP_FILE_TYPE_NORMAL, self.context)) error = gphoto2.gp_file_save(camera_file, self.file_path.name) img_num = 1 while os.path.isfile(self.current_picture): self.current_picture = 'IMG_'+str(img_num).zfill(4)+'.CR2' img_num = img_num + 1 if hasattr(self, 'file_path'): os.rename(self.file_path.name, self.current_picture) raw = rawpy.imread(self.current_picture) image = raw.postprocess(user_flip=False, output_bps=8) image = cv2.resize(image,(768, 512)) self.myImage = QtGui.QImage(image.astype(numpy.uint8), 768, 512, QtGui.QImage.Format_RGB888) self.text_line.setText('Done') self.image_event = 1 self.update() else: secs = int(self.bulb_time.text()) i = 0 while i < int(self.bulb_pics.text()) and not stop.isSet(): self.file_path = self.get_bulb_picture(secs, stop) img_num = 1 while os.path.isfile(self.current_picture): self.current_picture = 'IMG_'+str(img_num).zfill(4)+'.CR2' img_num = img_num + 1 if hasattr(self, 'file_path'): os.rename(self.file_path.name, self.current_picture) raw = rawpy.imread(self.current_picture) image = raw.postprocess(user_flip=False, output_bps=8) image = cv2.resize(image,(768, 512)) self.myImage = QtGui.QImage(image.astype(numpy.uint8), 768, 512, QtGui.QImage.Format_RGB888) self.text_line.setText('Image '+str(i+1)+" of "+self.bulb_pics.text()+' done') self.image_event = 1 self.update() i = i + 1 if stop.isSet(): self.text_line.setText('Interruped by user!') stop.clear() if hasattr(self, 'file_path'): self.solve_button.setEnabled(True) self.solve_scale.setEnabled(True) self.go_button.setEnabled(True) self.stop_button.setEnabled(False)
def testFileOpenAndPostProcess(): raw = rawpy.imread(rawTestPath) assert_array_equal(raw.raw_image.shape, [2844, 4288]) rgb = raw.postprocess(no_auto_bright=True, user_wb=raw.daylight_whitebalance) assert_array_equal(rgb.shape, [2844, 4284, 3]) print_stats(rgb) save('test_8daylight.tiff', rgb) print('daylight white balance multipliers:', raw.daylight_whitebalance) rgb = raw.postprocess(no_auto_bright=True, user_wb=raw.daylight_whitebalance) print_stats(rgb) save('test_8daylight2.tiff', rgb) rgb = raw.postprocess(no_auto_bright=True, user_wb=raw.daylight_whitebalance, output_bps=16) print_stats(rgb) save('test_16daylight.tiff', rgb) # linear images are more useful for science (=no gamma correction) # see http://www.mit.edu/~kimo/blog/linear.html rgb = raw.postprocess(no_auto_bright=True, user_wb=raw.daylight_whitebalance, gamma=(1,1), output_bps=16) print_stats(rgb) save('test_16daylight_linear.tiff', rgb)
def testBufferOpen(): with open(rawTestPath, 'rb') as rawfile: with rawpy.imread(rawfile) as raw: assert_array_equal(raw.raw_image.shape, [2844, 4288]) rgb = raw.postprocess() print_stats(rgb) save('test_buffer.tiff', rgb)
def _open(self): try: img = rawpy.imread(self.fp) self.mode = "RGB" self.size = (img.sizes.width, img.sizes.height) except: raise (SyntaxError, "Cannot process file.")
def _create_proxy_rawpy(self, source, dest, mode): # maybe Pillow supports this file type directly? if not self.image: try: self.image = Image.open(source) except IOError: pass except Exception as e: logging.error('cannot read {}: {}'.format(source, e.args[0])) raise e # obviously not, try decoding as Raw if not self.image: try: raw = rawpy.imread(source) rgb = raw.postprocess(use_camera_wb=True, no_auto_bright=True) self.image = Image.fromarray(rgb) except Exception as e: logging.error('cannot read {}: {}'.format(source, e.args[0])) raise e image = self.image.copy() if mode == self.PROXY_FULLSIZE: pass elif mode == self.PROXY_THUMBNAIL: image.thumbnail(settings.THUMBNAILSIZE) elif mode == self.PROXY_WEBSIZED: image.thumbnail(settings.WEBSIZE) try: image.save(dest) except Exception as e: logging.error('cannot write {}: {}'.format(dest, e.args[0]))
def convertRawFileToArray(filename, batchSideLength): with rawpy.imread(filename) as raw: rgb = raw.postprocess() arr = rgb.astype(float) batchedArr = batchAndDifferentiate(arr, [(batchSideLength, False), \ (batchSideLength, False), (1, False)]) return batchedArr
def publishCR2(self, file): print "publishCR2", file raw = rawpy.imread(file) #rgb = raw.postprocess(gamma=(1,1), no_auto_bright=True, output_bps=16) rgb = raw.postprocess() imageio.imsave(file+'.tiff', rgb) print "save" bayer = raw.raw_image print "bayer" self.pub_image.publish(self.bridge.cv2_to_imgmsg(cv2.fromarray(bayer), "bgr8"))
def testNikonD4Size(): if rawpy.libraw_version < (0,15): # older libraw/dcraw versions don't support D4 fully return raw = rawpy.imread(raw2TestPath) s = raw.sizes assert_equal(s.width, 4940) assert_equal(s.height, 3292) assert_equal(s.top_margin, 0) assert_equal(s.left_margin, 2)
def __init__(self, path): """ Convert RAW images to 3-color array (ndarray) """ # Load the RAW file self._file = rawpy.imread(path) # Save the size of the image raw_height, raw_width, height, width, top_margin, left_margin, iheight, iwidth, pixel_aspect, flip= (self._file).sizes size = (height,width) # Postprocess this file to obtain a numpy ndarray of shape (h,w,c) : 16 bits => la palette de couleur peut contenir 2^16 = 65536 couleurs ndarray = self._file.postprocess(output_bps=16, output_color=ColorSpace.raw, demosaic_algorithm=DemosaicAlgorithm.VNG, use_camera_wb=True, no_auto_bright=True) # SuperClass Constructor super(ImageRaw,self).__init__(path,ndarray,size)
def testWindowsFileLockRelease(): # see https://github.com/neothemachine/rawpy/issues/10 # we make a copy of the raw file which we will later remove copyPath = rawTestPath + '-copy' shutil.copyfile(rawTestPath, copyPath) with rawpy.imread(copyPath) as raw: rgb = raw.postprocess() assert_array_equal(rgb.shape, [2844, 4284, 3]) print_stats(rgb) # if the following does not throw an exception on Windows, # then the file is not locked anymore, which is how it should be os.remove(copyPath) # we test the same using .close() instead of a context manager shutil.copyfile(rawTestPath, copyPath) raw = rawpy.imread(copyPath) rgb = raw.postprocess() raw.close() os.remove(copyPath) assert_array_equal(rgb.shape, [2844, 4284, 3])
def testVisibleSize(): for path in [rawTestPath, raw2TestPath]: print('testing', path) raw = rawpy.imread(path) s = raw.sizes print(s) h,w = raw.raw_image_visible.shape assert_equal(h, s.height) assert_equal(w, s.width) h,w = raw.raw_colors_visible.shape assert_equal(h, s.height) assert_equal(w, s.width)
def load_image(path): if(path[-3:] == 'dng'): import rawpy with rawpy.imread(path) as raw: img = raw.postprocess() # img = plt.imread(path) elif(path[-3:]=='bmp' or path[-3:]=='jpg' or path[-3:]=='png'): import cv2 return cv2.imread(path)[:,:,::-1] else: img = (255*plt.imread(path)[:,:,:3]).astype('uint8') return img
def testProperties(): raw = rawpy.imread(rawTestPath) print('black_level_per_channel:', raw.black_level_per_channel) print('color_matrix:', raw.color_matrix) print('rgb_xyz_matrix:', raw.rgb_xyz_matrix) print('tone_curve:', raw.tone_curve) assert_array_equal(raw.black_level_per_channel, [0,0,0,0]) # older versions have zeros at the end, was probably a bug if rawpy.libraw_version >= (0,16): assert_array_equal(raw.tone_curve, np.arange(65536))
def scandirs(path): for currentFile in glob.glob( os.path.join(path, '*') ): if os.path.isdir(currentFile): print 'got a directory: ' + currentFile scandirs(currentFile) filename, file_extension = os.path.splitext(currentFile) file_extension = file_extension.lower() if file_extension in rawextens: print "processing file: " + currentFile imageFilename = "{0}.jpg".format(filename) raw = rawpy.imread(currentFile) rgb = raw.postprocess() imageio.imsave(imageFilename, rgb)
def proxify(file_path, out_path, orientation): # create proxies and output to hashdir. try: os.makedirs(os.path.dirname(out_path)) except: print logger('error creating dir - exists') try: ext = os.path.splitext(file_path)[-1].lower() # create image object for raw files through rawpy module if ext in RAW_EXTENSIONS: print logger( 'processing raw image') raw = rawpy.imread(file_path) rgb = raw.postprocess() im = Image.fromarray(rgb) filetype = 'raw' elif ext in MOVIE_EXTENSIONS: print logger('found a movie!') ffmpeg(file_path, out_path) print logger('not making a proxy!') filetype = 'mov' return filetype else: # otherwise every other image type (not raw) filetype = 'img' im = Image.open(file_path) # rotate image as necessary 90, 180, 270 from metadata. if orientation in ROTATEMAP: print logger( 'ROTATING! ' + orientation) im = im.rotate(ROTATEMAP[orientation], expand=True) for s in THUMB_SIZE: im2 = im.copy() # create copy to allow for different resolution images to be created from full res. Just trust me... im2.thumbnail(s, Image.ANTIALIAS) im2.save(out_path + '_' + str(THUMB_SIZE.index(s)) + OUTEXT, "JPEG") im2.close() im.close() return filetype except: print logger( str(traceback.print_exc())) print logger( 'error creating image: ' + file_path ) IM_ERRORS.append(file_path) return filetype
def _processedImage(self, key): if key in self.processedImagePaths: return self.processedImagePaths[key] assert self.useRaw rawPath = self.rawImagePaths[key] raw = rawpy.imread(rawPath) rawpy.enhance.repair_bad_pixels(raw, self.badPixels) if self.raw_white_balance: if not (raw.color_desc == 'RGBG' and raw.num_colors == 3): raise NotImplementedError wb = [self.raw_white_balance[0], self.raw_white_balance[1], self.raw_white_balance[2], self.raw_white_balance[1]] else: wb = self.apiData['raw_white_balance'] rgb = raw.postprocess(user_wb=wb, output_bps=self.raw_bps, no_auto_bright=self.raw_no_auto_bright, gamma=self.raw_gamma, user_flip=False) if self.apiData['raw_is_upside_down']: # rotate 180deg rgb = rgb[::-1,::-1] # correct lens distortion dist_corr = self.apiData['distortion_correction'] if dist_corr: # TODO undistCoords could be cached to avoid recomputing them each time mod = getLensfunModifierFromParams(dist_corr['model'], dist_corr['params'], rgb.shape[1], rgb.shape[0]) undistCoords = mod.apply_geometry_distortion() rgb = lensfunpy.util.remap(rgb, undistCoords) # WCS solutions from the ISS dataset are based on cropped images, # therefore we crop here as well to make it match. rgb = croppedImage(rgb, divisible_by=16) if self.noRawPostprocessCaching: return rgb else: processedImagePath = os.path.join(self.cacheFolder, key + '.tiff') saveImage(processedImagePath, rgb) self.processedImagePaths[key] = processedImagePath return processedImagePath
def read_raw(path, tmp=None): import rawpy tmp_ = tmp or tempfile.mkdtemp(suffix='tmp', prefix='crayimage') _, filename = osp.split(path) tmppath = osp.join(tmp_, filename) with gzip.open(path, "r") as gf, open(tmppath, 'w') as f: shutil.copyfileobj(gf, f, length=128 * 1024) with rawpy.imread(tmppath) as img_f: img = img_f.raw_image.copy() os.remove(tmppath) if tmp is None: shutil.rmtree(tmp_) img = img.reshape((1, ) + img.shape) return img
def generate_thumbnail(source, outname, box, skip, fit=False, options=None): """Create a thumbnail image.""" logger = logging.getLogger(__name__) extension = os.path.splitext(source)[1] if extension in ('.cr2'): raw = rawpy.imread(source) img = PILImage.fromarray(raw.postprocess()) original_format = "JPEG" else: img = PILImage.open(source) original_format = img.format if fit: img = ImageOps.fit(img, box, PILImage.ANTIALIAS) else: img.thumbnail(box, PILImage.ANTIALIAS) outformat = img.format or original_format or 'JPEG' logger.debug(u'Save thumnail image: {0} ({1})'.format(outname, outformat)) save_image(img, outname, outformat, options=options, autoconvert=True)
def testBadPixelRepair(): def getColorNeighbors(raw, y, x): # 5x5 area around coordinate masked by color of coordinate raw_colors = raw.raw_colors_visible raw_color = raw_colors[y, x] masked = ma.masked_array(raw.raw_image_visible, raw_colors!=raw_color) return masked[y-2:y+3,x-2:x+3].copy() bad_pixels = np.loadtxt(badPixelsTestPath, int) i = 60 y, x = bad_pixels[i,0], bad_pixels[i,1] for useOpenCV in [False,True]: if useOpenCV: if rawpy.enhance.cv2 is None: print('OpenCV not available, skipping subtest') continue print('testing with OpenCV') else: print('testing without OpenCV') oldCv = rawpy.enhance.cv2 rawpy.enhance.cv2 = None for repair in [_repair_bad_pixels_generic, _repair_bad_pixels_bayer2x2]: print('testing ' + repair.__name__) raw = rawpy.imread(rawTestPath) before = getColorNeighbors(raw, y, x) repair(raw, bad_pixels, method='median') after = getColorNeighbors(raw, y, x) print(before) print(after) # check that the repaired value is the median of the 5x5 neighbors assert_equal(int(ma.median(before)), raw.raw_image_visible[y,x], 'median wrong for ' + repair.__name__) if not useOpenCV: rawpy.enhance.cv2 = oldCv
train_id = train_ids[ind] in_files = glob.glob(input_dir + '%05d_00*.ARW' % train_id) in_path = in_files[np.random.random_integers(0, len(in_files) - 1)] _, in_fn = os.path.split(in_path) gt_files = glob.glob(gt_dir + '%05d_00*.hdr' % train_id) gt_path = gt_files[0] _, gt_fn = os.path.split(gt_path) in_exposure = float(in_fn[9:-5]) gt_exposure = float(gt_fn[9:-5]) ratio = min(gt_exposure / in_exposure, 300) #calculate exposure ratio st = time.time() cnt += 1 if input_images[str(ratio)[0:2]][ind] is None: raw = rawpy.imread(in_path) input_images[str(ratio)[0:2]][ind] = np.expand_dims(pack_raw(raw), axis=0) * ratio print(gt_path) ''' # method 1: read raw hdr file in rgbe format gt_file = open(gt_path, 'rb') header = gt_file.read(78) gt_bytes = gt_file.read() gt_file.close() gt_images[ind] = np.expand_dims(np.float32(pack_hdr(gt_bytes)/255.0),axis = 0)# 8-bit, 4 channels ''' # method 2: use Reinhard tonemapped image as gt hdr = cv2.imread(gt_path, -1) tonemapReinhard = cv2.createTonemapReinhard(3.0, -2.5, 0, 0)
import tifffile as tiff import math paths = [ ] tk = [] for k in range(1,17): paths.append('exposure%d.nef' % k ) tk.append(2**(k-12)) print(k) print(paths) print(tk) i = 0; ########## section 3.a <processing raw images and resizing the images >####################### for path in paths: i= i +1 with rawpy.imread(path) as raw: rgb = raw.postprocess(gamma=(1,1), no_auto_bright=True, output_bps=16) xnew,ynew=rgb.shape[1]/10,rgb.shape[0]/10 xnew = int(xnew) ynew = int(ynew) #print (xnew) rgb=cv2.resize(rgb,(xnew,ynew)) imageio.imsave('processed_exposure%d.tiff' % i,rgb) #################################### ########## section 3.b <calculating hdr image using the formula >####################### Ihdr=np.zeros((400,600,3)) Ihdr0=0 Ihdr1=0
def main(args): setproctitle.setproctitle('hdrnet_run') inputs = get_input_list(args.input) # -------- Load params ---------------------------------------------------- config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as sess: checkpoint_path = tf.train.latest_checkpoint(args.checkpoint_dir) if checkpoint_path is None: log.error('Could not find a checkpoint in {}'.format(args.checkpoint_dir)) return metapath = ".".join([checkpoint_path, "meta"]) log.info('Loading graph from {}'.format(metapath)) tf.train.import_meta_graph(metapath) model_params = utils.get_model_params(sess) # -------- Setup graph ---------------------------------------------------- if not hasattr(models, model_params['model_name']): log.error("Model {} does not exist".format(params.model_name)) return mdl = getattr(models, model_params['model_name']) tf.reset_default_graph() net_shape = model_params['net_input_size'] t_fullres_input = tf.placeholder(tf.float32, (1, None, None, 3)) t_lowres_input = tf.placeholder(tf.float32, (1, net_shape, net_shape, 3)) with tf.variable_scope('inference'): prediction = mdl.inference( t_lowres_input, t_fullres_input, model_params, is_training=False) output = tf.cast(255.0*tf.squeeze(tf.clip_by_value(prediction, 0, 1)), tf.uint8) saver = tf.train.Saver() if args.debug: coeffs = tf.get_collection('bilateral_coefficients')[0] if len(coeffs.get_shape().as_list()) == 6: bs, gh, gw, gd, no, ni = coeffs.get_shape().as_list() coeffs = tf.transpose(coeffs, [0, 3, 1, 4, 5, 2]) coeffs = tf.reshape(coeffs, [bs, gh*gd, gw*ni*no, 1]) coeffs = tf.squeeze(coeffs) m = tf.reduce_max(tf.abs(coeffs)) coeffs = tf.clip_by_value((coeffs+m)/(2*m), 0, 1) ms = tf.get_collection('multiscale') if len(ms) > 0: for i, m in enumerate(ms): maxi = tf.reduce_max(tf.abs(m)) m = tf.clip_by_value((m+maxi)/(2*maxi), 0, 1) sz = tf.shape(m) m = tf.transpose(m, [0, 1, 3, 2]) m = tf.reshape(m, [sz[0], sz[1], sz[2]*sz[3]]) ms[i] = tf.squeeze(m) fr = tf.get_collection('fullres_features') if len(fr) > 0: for i, m in enumerate(fr): maxi = tf.reduce_max(tf.abs(m)) m = tf.clip_by_value((m+maxi)/(2*maxi), 0, 1) sz = tf.shape(m) m = tf.transpose(m, [0, 1, 3, 2]) m = tf.reshape(m, [sz[0], sz[1], sz[2]*sz[3]]) fr[i] = tf.squeeze(m) guide = tf.get_collection('guide') if len(guide) > 0: for i, g in enumerate(guide): maxi = tf.reduce_max(tf.abs(g)) g = tf.clip_by_value((g+maxi)/(2*maxi), 0, 1) guide[i] = tf.squeeze(g) with tf.Session(config=config) as sess: log.info('Restoring weights from {}'.format(checkpoint_path)) saver.restore(sess, checkpoint_path) for idx, input_path in enumerate(inputs): if args.limit is not None and idx >= args.limit: log.info("Stopping at limit {}".format(args.limit)) break log.info("Processing {}".format(input_path)) im_ext = os.path.splitext(input_path)[1].lower() if im_ext == '.cr2' or im_ext == '.nef': raw = rawpy.imread(input_path) im_input = raw.postprocess() else: raw = cv2.imread(input_path) # opencv reads into a BGR format im_input = cv2.cvtColor(raw, cv2.COLOR_BGR2RGB) if im_input.shape[2] == 4: log.info("Input {} has 4 channels, dropping alpha".format(input_path)) im_input = im_input[:, :, :3] log.info("Max level: {}".format(np.amax(im_input[:, :, 0]))) log.info("Max level: {}".format(np.amax(im_input[:, :, 1]))) log.info("Max level: {}".format(np.amax(im_input[:, :, 2]))) # HACK for HDR+. if im_input.dtype == np.uint16 and args.hdrp: log.info("Using HDR+ hack for uint16 input. Assuming input white level is 32767.") # im_input = im_input / 32767.0 # im_input = im_input / 32767.0 /2 # im_input = im_input / (1.0*2**16) im_input = skimage.img_as_float(im_input) else: im_input = skimage.img_as_float(im_input) # Make or Load lowres image if args.lowres_input is None: lowres_input = skimage.transform.resize( im_input, [net_shape, net_shape], order = 0) else: raise NotImplemented fname = os.path.splitext(os.path.basename(input_path))[0] output_path = os.path.join(args.output, fname+".png") basedir = os.path.dirname(output_path) im_input = im_input[np.newaxis, :, :, :] lowres_input = lowres_input[np.newaxis, :, :, :] feed_dict = { t_fullres_input: im_input, t_lowres_input: lowres_input } out_ = sess.run(output, feed_dict=feed_dict) if not os.path.exists(basedir): os.makedirs(basedir) Image.fromarray(out_, mode='RGB').save(output_path) if args.debug: output_path = os.path.join(args.output, fname+"_input.png") Image.fromarray(np.squeeze(im_input), mode='RGB').save(output_path) coeffs_ = sess.run(coeffs, feed_dict=feed_dict) output_path = os.path.join(args.output, fname+"_coeffs.png") Image.fromarray(coeffs_, mode='RGB').save(output_path) if len(ms) > 0: ms_ = sess.run(ms, feed_dict=feed_dict) for i, m in enumerate(ms_): output_path = os.path.join(args.output, fname+"_ms_{}.png".format(i)) Image.fromarray(m, mode='RGB').save(output_path) if len(fr) > 0: fr_ = sess.run(fr, feed_dict=feed_dict) for i, m in enumerate(fr_): output_path = os.path.join(args.output, fname+"_fr_{}.png".format(i)) Image.fromarray(m, mode='RGB').save(output_path) if len(guide) > 0: guide_ = sess.run(guide, feed_dict=feed_dict) for i, g in enumerate(guide_): output_path = os.path.join(args.output, fname+"_guide_{}.png".format(i)) Image.fromarray(g, mode='RGB').save(output_path)
PARAMS_CONVERSION = { 'demosaic_algorithm': rawpy.DemosaicAlgorithm(3), 'no_auto_bright': True, 'output_bps': 16, 'gamma': (1, 1), 'output_color': rawpy.ColorSpace(0), 'user_wb': [1, 1, 1, 1], 'four_color_rgb': True, # 'median_filter_passes': 3 } # Processing for loop i = 0 for path_red, path_green, path_blue in zip(filenames[0::3], filenames[1::3], filenames[2::3]): with rawpy.imread(path_red) as raw: red = raw.postprocess(**PARAMS_CONVERSION) with rawpy.imread(path_green) as raw: green = raw.postprocess(**PARAMS_CONVERSION) with rawpy.imread(path_blue) as raw: blue = raw.postprocess(**PARAMS_CONVERSION) merged_frames = np.zeros(red.shape) merged_frames[:, :, 0] = red[:, :, 0] merged_frames[:, :, 1] = green[:, :, 1] merged_frames[:, :, 2] = blue[:, :, 2] i += 1 print(i)
os.makedirs('/home/stephan/Images/.memories/thumbnails') for picture in pictures: try: im = Image.open('/home/stephan/Images/%s' % picture.get('filename')) im.thumbnail((640, 480)) if not os.path.exists(os.path.dirname('/home/stephan/Images/.memories/thumbnails/%s' % picture.get('filename'))): os.makedirs(os.path.dirname('/home/stephan/Images/.memories/thumbnails/%s' % picture.get('filename'))) try: filename = picture.get('filename') im.save('/home/stephan/Images/.memories/thumbnails/%s' % filename) except KeyError as nef: print 'raw file %s' % picture.get('filename') raw = rawpy.imread('/home/stephan/Images/%s' % picture.get('filename')) rbg = raw.postprocess() img = Image.fromarray(rbg) filename = '%s.jpg' % os.path.splitext(picture.get('filename'))[0] img.save('%s.jpg' % (os.path.splitext('/home/stephan/Images/.memories/thumbnails/%s' % picture.get('filename'))[0])) print filename db.pictures.update_one({'_id': picture['_id']}, {"$set": {'thumbnail': filename}}) except IOError as e: print e print picture.get('filename') print '---------------------' print '---------------------' print '---------------------' print '---------------------'
''' @ author Bean, Fangte, Yike, ''' import cv2 import numpy as np from matplotlib import pyplot as plt import rawpy from patchmatch import * from tau import * from hdr_fusion import * # Read raw images. Here we use 1_320 as the reference image. Typically, an image under moderate # exposure time has the most well exposued pixels. raw = rawpy.imread('1_320.NEF') imgR = raw.postprocess() imgR = cv2.cvtColor(imgR, cv2.COLOR_RGB2BGR) imgR = cv2.resize(imgR, None, fx=0.1, fy=0.1) cv2.imwrite('imgR.png', imgR) # Read two other images as source images raw1 = rawpy.imread('2_800.NEF') imgS1 = raw1.postprocess() imgS1 = cv2.cvtColor(imgS1, cv2.COLOR_RGB2BGR) imgS1 = cv2.resize(imgS1, None, fx=0.1, fy=0.1) cv2.imwrite('imgS1.png', imgS1) raw2 = rawpy.imread('3_160.NEF') imgS2 = raw2.postprocess() imgS2 = cv2.cvtColor(imgS2, cv2.COLOR_RGB2BGR) imgS2 = cv2.resize(imgS2, None, fx=0.1, fy=0.1) cv2.imwrite('imgS2.png', imgS2)
def testHalfSizeParameter(): raw = rawpy.imread(rawTestPath) s = raw.sizes rgb = raw.postprocess(half_size=True) assert_equal(rgb.shape[0], s.height // 2) assert_equal(rgb.shape[1], s.width // 2)
def testThumbExtractBitmap(): with rawpy.imread(raw4TestPath) as raw: thumb = raw.extract_thumb() assert thumb.format == rawpy.ThumbFormat.BITMAP assert_array_equal(thumb.data.shape, [378, 567, 3])
def testThumbExtractJPEG(): with rawpy.imread(rawTestPath) as raw: thumb = raw.extract_thumb() assert thumb.format == rawpy.ThumbFormat.JPEG img = imageio.imread(thumb.data) assert_array_equal(img.shape, [2832, 4256, 3])
def raw2fits(inputfile, crop="", dark="", flat='', inverseGrayscale=False): """ Create FITS object from raw file (doesn't write) parameters: - inputfile: input raw file path - crop: use this option if you want to crop the image. string like "x0,y0,size_x,size_y" - dark: path to pgm file containing frame to subtract - inverseGrayscale returns: - pyfits object """ logger = logging.getLogger() # Read RAW meta try: # Getting the EXIF of raw file with dcraw p = subprocess.Popen(["dcraw", "-i", "-v", inputfile], stdout=subprocess.PIPE) dcraw_exif = p.communicate()[0].decode('utf-8') # Catching the Shutter Speed m = re.search('(?<=Shutter:).*(?=sec)', dcraw_exif) shutterstr = m.group(0).strip() if "/" in shutterstr: shutterplit = m.group(0).strip().split('/') shutter = float(shutterplit[0]) / float(shutterplit[1]) else: shutter = float(shutterstr) m = re.search('(?<=Aperture: f/).*', dcraw_exif) aperture = m.group(0).strip() m = re.search('(?<=ISO speed:).*', dcraw_exif) iso = m.group(0).strip() m = re.search('(?<=Filename:).*', dcraw_exif) original_file = m.group(0).strip() m = re.search('(?<=Focal length: ).*(?=mm)', dcraw_exif) focal = m.group(0).strip() m = re.search('(?<=Camera:).*', dcraw_exif) camera = m.group(0).strip() m = re.search('(?<=Filter pattern:).*', dcraw_exif) filter_pattern = m.group(0).strip() # Catching the true Image Size # Image size: 7362 x 4920 m = re.search('(?<=Image size: ).*', dcraw_exif) dim_list = m.group(0).strip().split('x') NAXIS1 = int(dim_list[0]) NAXIS2 = int(dim_list[1]) # Catching the Timestamp m = re.search('(?<=Timestamp:).*', dcraw_exif) date1 = m.group(0).split() months = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6, 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12} date = datetime.datetime(int(date1[4]), months[date1[1]], int(date1[2]), int(date1[3].split(':')[0]), int(date1[3].split(':')[1]), int(date1[3].split(':')[2])) # To use for timestamp/timezone correction FIXME #print('WARNING WARNING WARNING WARNING WARNING WARNING WARNING') #logger.critical('This is a very special mode for timing correction, do not use in PRODUCTION') #logger.critical("DATETIME: " + str(date)) #from datetime import timedelta #utc_delta = timedelta(days=0,hours=11,minutes=0, seconds=6) #logger.critical(utc_delta) #logger.critical(date - utc_delta) #date = date - utc_delta #logger.critical("DATETIME: " + str(date)) # formating date date = '{0:%Y-%m-%d %H:%M:%S}'.format(date) exposure_recorded_time = Time(date) try: # to to match the timestamp to actual trigger time + trigger delay try: # D810 56ms interval_log_file = dfn_utils.find_log_file(os.path.dirname(inputfile), suffix='_log_interval', extension='txt') logger.debug('Found interval log file: {}'.format(interval_log_file)) fw_string = dfn_utils.search_dfn_operation_log(interval_log_file, key='leostick_version', module='interval_control_lin') ### core_1_temperature_list = re.findall('(?:^Core 1:\s+)([\+-]\d+\.\d+)', sensors, re.MULTILINE) # 2017-08-23 18:17:51,447, INFO, interval_control_lin, leostick_version, built:Jun 7 2017 10:12:58 note:kit, small and ext compatible, bulb and non-bulb, pulse frequency and pulse width encoding, ext heating and cooling, single exposure and video camera triggering, exposure:5.0/15s, element period:1000ms, short 0 dash length:200ms, long 1 dash length:600ms, target:unifi^Ad #print(re.findall('(?:exposure:\d+\.\d+/)(\d+)', fw_string)) cadence = int(re.findall('(?:exposure:\d+\.\d+/)(\d+)', fw_string)[0]) logger.info('Found cadence {} in interval log {}'.format(cadence, os.path.basename(interval_log_file))) except Exception as e: logger.error(e) # default to 5 seconds (avoid messing up data too much) cadence = 5 exposure_triggered_time = dfn_utils.round_to_nearest_n_seconds(exposure_recorded_time, cadence) logger.info('Image timestamp has been rounded off from {} to {}'.format(exposure_recorded_time.isot, exposure_triggered_time.isot)) try: trigger_delay = TimeDelta(DSLR_TRIGGER_DELAY_CATALOG[camera], format='sec') except Exception as e: logger.error(e) trigger_delay = TimeDelta(0.0, format='sec') exposure_corrected_time = exposure_triggered_time + trigger_delay logger.info('Image timestamp has been offset from {} to {}'.format(exposure_triggered_time.isot, exposure_corrected_time.isot)) except Exception as e: logger.error(e) exposure_corrected_time = exposure_recorded_time except: logger.error('Failed during DCRAW meta read attempt') raise # Dark subtraction if needed if dark != "": dark_com = ["-K ", dark] else: dark_com = [] # Cropping if needed if crop == "": needsCropping = False cropprofile = "None" crop_command = [] else: needsCropping = True # regex for finding 4 numbers separated by commas match = re.search("[0-9]+(,[0-9]+){3}", crop) # Crop centered presets if 'centered_' in crop and crop.split('_')[1].isnumeric(): crop_size = int(crop.split('_')[1]) # top left pixel must have even coordinates, otherwise bayer pattern will be shifted x0 = int((NAXIS1 - crop_size) / 2) y0 = int((NAXIS2 - crop_size) / 2) y_size = crop_size x_size = crop_size cropprofile = crop elif match: cropstr = match.group().split(',') x0 = int(cropstr[0]) y0 = int(cropstr[1]) x_size = int(cropstr[2]) y_size = int(cropstr[3]) cropprofile = "Custom" else: needsCropping = False cropprofile = "None" logger.error('Crop input is not valid. Crop aborted') raise KeyError('Invalid crop parameters') # top left pixel must have even coordinates, otherwise bayer pattern will be shifted if x0 % 2 == 1: x0 += 1 if y0 % 2 == 1: y0 += 1 # check the requested crop falls into the picture bounds if (x0 >= NAXIS1) or (y0 >= NAXIS2) or ((x0 + x_size) >= NAXIS1) or ((y0 + y_size) >= NAXIS2) or (x0 < 0) or (y0 < 0): needsCropping = False cropprofile = "None" OOB_msg = 'Crop input does NOT fall into picture bounds. Crop aborted' logger.error(OOB_msg) raise IndexError(OOB_msg) # use netpbm's pamcut to crop crop_command = ['pamcut', '-left', str(x0), '-top', str(y0), '-width', str(x_size), '-height', str(y_size)] if RAW_HANDLING_LIB == 'RAWPY': logger.info("Using RAWPY for decoding") # .raw_image contains 32 extra columns (on Sony) filled with nonsense raw_data = rawpy.imread(inputfile).raw_image_visible if dark != "": dark_data = pyfits.open(dark)[0].data raw_data = (raw_data - dark_data).astype(np.uint16) if flat != "": flat_data = pyfits.open(flat)[0].data raw_data = (raw_data / flat_data * np.mean(flat_data)).astype(np.uint16) if needsCropping: im_ppm = raw_data[y0:y0+y_size, x0:x0+x_size] else: im_ppm = raw_data elif RAW_HANDLING_LIB == 'DCRAW': logger.info("Using DCRAW for decoding") # DCRAW extract command # -c option send dcraw output to stdout base_command = ["dcraw", "-D", "-4", "-t", "0", "-c"] # Prepare command for converting the RAW to PPM the_command = base_command # dark subtraction option the_command += dark_com # target raw file the_command += [inputfile] # Read RAW data try: conv = subprocess.Popen(the_command, stdout=subprocess.PIPE) # optional pipe to cropping command if len(crop_command) >= 1: crop = subprocess.Popen(crop_command, stdin=conv.stdout, stdout=subprocess.PIPE) end_of_pipe = crop.stdout else: end_of_pipe = conv.stdout # pipe output into netPbm object im_ppm = netPbm.NetpbmFile(end_of_pipe).asarray() except Exception as e: logger.critical('Failed during DCRAW data read attempt. Can be dcraw, pamcut, netPbm... :') logger.error(e) raise e else: logger.critical('shit went wrong') raise NotImplementedError('shit went wrong') try: if inverseGrayscale: maxBitPix = np.ndarray.max(im_ppm) im_ppm = maxBitPix * np.ones_like(im_ppm) - im_ppm # Create the FITS object hdu = pyfits.PrimaryHDU(im_ppm) # set basic header values hdu.header.set('OBSTIME', exposure_corrected_time.iso, 'ISO timestamp of start of exposure') # comment next line to bypass shutter fraction problem hdu.header.set('EXPTIME', float(shutter), 'Exposure time in s') hdu.header.set('APERTUR', float(aperture), 'Lens aperture, as in f/APERTUR') hdu.header.set('ISO', int(iso), 'ISO speed') hdu.header.set('FOCAL', float(focal), 'Focal length in mm') hdu.header.set('FILT_PAT', filter_pattern, 'Shape of the Color array (usually Bayer)') hdu.header.set('ORIGIN', original_file) hdu.header.set('CAMERA', camera, 'Camera model') hdu.header.add_comment('FITS File Created with ' + __pipeline_task__) if needsCropping: hdu.header.set('CROPPED', "TRUE", 'If picture has been cropped from original') hdu.header.set('CROP', cropprofile, 'Crop preset (for further use)') hdu.header.set('CROPX0', x0, 'LEFT boundary of the crop') hdu.header.set('CROPX1', x0 + x_size, 'RIGHT boundary of the crop') hdu.header.set('CROPY0', y0, 'BOTTOM boundary of the crop') hdu.header.set('CROPY1', y0 + y_size, 'TOP boundary of the crop') hdu.header.set('ONAXIS1', NAXIS1, 'Original NAXIS1 before cropping') hdu.header.set('ONAXIS2', NAXIS2, 'Original NAXIS2 before cropping') else: hdu.header.set('CROPPED', "FALSE", 'If picture has been cropped from original') except: logger.error('Something went wrong while creating the FITS object') raise logger.info("RAW extraction into FITS successful") return hdu
def testManualClose(): raw = rawpy.imread(rawTestPath) assert_array_equal(raw.raw_image.shape, [2844, 4288]) raw.close()
import rawpy, matplotlib.pyplot as plt, numpy as np path='tree.exif.dng' raw=rawpy.imread(path) print 'Sizes of the image:',raw.sizes print 'Bayer pattern:\n',raw.raw_pattern print 'Indices 0,1,2,3 in above are, in order: ',raw.color_desc print 'camera_whitebalance',raw.camera_whitebalance print 'daylight_whitebalance',raw.daylight_whitebalance ##note the two following methods are (y,x) - annoying! print 'Colour of bayer pixel at 101,100:',raw.raw_color(101,100) print 'Value of bayer pixel at 101,100:',raw.raw_value(101,100) nx=raw.raw_image.shape[1] ny=raw.raw_image.shape[0] ris=raw.raw_image.astype(float) rismax=ris.max() #Make an rgb bayer image rgb=np.zeros((ny,nx,3), 'float') rgb[1::2,0::2,0]=ris[1::2,0::2]/rismax rgb[0::2,0::2,1]=ris[0::2,0::2]/rismax rgb[1::2,1::2,1]=ris[1::2,1::2]/rismax rgb[0::2,1::2,2]=ris[0::2,1::2]/rismax plt.imshow(rgb, interpolation='none') plt.show() #Perform a half-resolution demosaic rgbi=np.zeros((ny/2,nx/2,3), 'float') rgbi[::,::,0]=ris[1::2,0::2]/rismax
def _inference_image(self, model, transform, filename): ''' Loads the image with given filename from disk, splits it up into regular patches, performs inference and then re-splits the image into patches that fit the predicted boxes tightly ('WindowCropping' strategy), if there are any boxes. Commits the resulting patch names to the database and returns the identified bounding boxes under the patch names as a dict. ''' device = self.get_device() # load image filePath = os.path.join(self.baseFolder_unlabeled, filename) _, fileExt = os.path.splitext(filePath) if fileExt.lower() in ['.nef', '.cr2']: img = Image.fromarray(rawpy.imread(filePath).postprocess()) else: img = Image.open(filePath).convert('RGB') # transform tensor = transform(img).to(device) # evaluate in a grid fashion gridX, gridY = tensorSharding.createSplitLocations_auto( img.size, [self.patchSize[1], self.patchSize[0]], stride=self.stride, tight=True) tensors = tensorSharding.splitTensor( tensor, [self.patchSize[1], self.patchSize[0]], gridY, gridX) gridX, gridY = gridX.view(-1).float(), gridY.view(-1).float() bboxes = torch.empty(size=( 0, 4, ), dtype=torch.float32) labels = torch.empty(size=(0, ), dtype=torch.long) confs = torch.empty(size=( 0, model.numClasses, ), dtype=torch.float32) scores = torch.empty(size=(0, ), dtype=torch.float32) numPatches = tensors.size(0) numBatches = int(np.ceil(numPatches / float(self.batchSize))) for t in range(numBatches): startIdx = t * self.batchSize endIdx = min((t + 1) * self.batchSize, numPatches) batch = tensors[startIdx:endIdx, :, :, :] if len(batch.size()) == 3: batch = batch.unsqueeze(0) with torch.no_grad(): bboxes_pred_img, labels_pred_img = model(batch) bboxes_pred_img, labels_pred_img, confs_pred_img = self.encoder.decode( bboxes_pred_img.squeeze(0).cpu(), labels_pred_img.squeeze(0).cpu(), self.patchSize, cls_thresh=0.1, nms_thresh=0, #TODO return_conf=True) # incorporate patch offsets and append to list of predictions for b in range(len(bboxes_pred_img)): if len(bboxes_pred_img[b]): bboxes_pred_img[b][:, 0] += gridX[startIdx + b] bboxes_pred_img[b][:, 1] += gridY[startIdx + b] bboxes_pred_img[b][:, 2] += gridX[startIdx + b] bboxes_pred_img[b][:, 3] += gridY[startIdx + b] scores_pred, _ = torch.max(confs_pred_img[b], 1) bboxes = torch.cat((bboxes, bboxes_pred_img[b]), dim=0) labels = torch.cat((labels, labels_pred_img[b]), dim=0) confs = torch.cat((confs, confs_pred_img[b]), dim=0) scores = torch.cat((scores, scores_pred), dim=0) # do NMS on entire set keep = box_nms(bboxes, scores, threshold=0.1) #TODO bboxes = bboxes[keep, :] labels = labels[keep] confs = confs[keep, :] scores = scores[keep] # re-split into patches (WindowCropping) patchData = self.windowCropper.splitImageIntoPatches( img, bboxes, labels, confs) # #TODO # import matplotlib.pyplot as plt # from matplotlib.patches import Rectangle # plt.figure(1) # plt.clf() # plt.imshow(img) # ax = plt.gca() # for b in range(bboxes.size(0)): # ax.add_patch(Rectangle( # (bboxes[b,0], bboxes[b,1]), # (bboxes[b,2] - bboxes[b,0]), (bboxes[b,3] - bboxes[b,1]), # fill=False, # ec='r' # )) # plt.draw() # plt.waitforbuttonpress() # iterate over patches result = {} for key in patchData.keys(): if not self.options['contrib']['export_empty_patches'] and not len( patchData[key]['predictions']): continue # patch name patchName = re.sub('\..*$', '', filename) + '_' + key + '.JPG' patchDir = os.path.join( self.config.getProperty('FileServer', 'staticfiles_dir'), patchName) parentFolder, _ = os.path.split(patchDir) os.makedirs(parentFolder, exist_ok=True) # save patch patchData[key]['patch'].save(patchDir) # append metadata result[patchName] = {'predictions': patchData[key]['predictions']} # #TODO # plt.figure(2) # plt.clf() # plt.imshow(patchData[key]['patch']) # psz = patchData[key]['patch'].size # ax = plt.gca() # for b in range(len(patchData[key]['predictions'])): # bbox = patchData[key]['predictions'][b] # ax.add_patch(Rectangle( # (psz[0] * (bbox['x']-bbox['width']/2), psz[1] * (bbox['y']-bbox['height']/2),), # psz[0]*bbox['width'], psz[0]*bbox['height'], # fill=False, # ec='r' # )) # plt.draw() # plt.waitforbuttonpress() # return metadata return result
def predict_Ltsitd (filename) : if request.method == 'POST': file_path1 = os.path.join(APP_ROOT, 'static/hasilfitur1') if not os.path.isdir(file_path1): os.mkdir(file_path1) input_dir = './static/RAW/' checkpoint_dir = './checkpoint/Sony/' DEBUG = 0 if DEBUG == 1: save_freq = 2 test_ids = test_ids[0:5] def lrelu(x): return tf.maximum(x * 0.2, x) def upsample_and_concat(x1, x2, output_channels, in_channels): pool_size = 2 deconv_filter = tf.Variable(tf.truncated_normal([pool_size, pool_size, output_channels, in_channels], stddev=0.02)) deconv = tf.nn.conv2d_transpose(x1, deconv_filter, tf.shape(x2), strides=[1, pool_size, pool_size, 1]) deconv_output = tf.concat([deconv, x2], 3) deconv_output.set_shape([None, None, None, output_channels * 2]) return deconv_output def network(input): conv1 = slim.conv2d(input, 32, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv1_1') conv1 = slim.conv2d(conv1, 32, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv1_2') pool1 = slim.max_pool2d(conv1, [2, 2], padding='SAME') conv2 = slim.conv2d(pool1, 64, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv2_1') conv2 = slim.conv2d(conv2, 64, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv2_2') pool2 = slim.max_pool2d(conv2, [2, 2], padding='SAME') conv3 = slim.conv2d(pool2, 128, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv3_1') conv3 = slim.conv2d(conv3, 128, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv3_2') pool3 = slim.max_pool2d(conv3, [2, 2], padding='SAME') conv4 = slim.conv2d(pool3, 256, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv4_1') conv4 = slim.conv2d(conv4, 256, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv4_2') pool4 = slim.max_pool2d(conv4, [2, 2], padding='SAME') conv5 = slim.conv2d(pool4, 512, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv5_1') conv5 = slim.conv2d(conv5, 512, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv5_2') up6 = upsample_and_concat(conv5, conv4, 256, 512) conv6 = slim.conv2d(up6, 256, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv6_1') conv6 = slim.conv2d(conv6, 256, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv6_2') up7 = upsample_and_concat(conv6, conv3, 128, 256) conv7 = slim.conv2d(up7, 128, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv7_1') conv7 = slim.conv2d(conv7, 128, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv7_2') up8 = upsample_and_concat(conv7, conv2, 64, 128) conv8 = slim.conv2d(up8, 64, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv8_1') conv8 = slim.conv2d(conv8, 64, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv8_2') up9 = upsample_and_concat(conv8, conv1, 32, 64) conv9 = slim.conv2d(up9, 32, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv9_1') conv9 = slim.conv2d(conv9, 32, [3, 3], rate=1, activation_fn=lrelu, scope='g_conv9_2') conv10 = slim.conv2d(conv9, 12, [1, 1], rate=1, activation_fn=None, scope='g_conv10') out = tf.depth_to_space(conv10, 2) return out def pack_raw(raw): # read image black level bl = raw.black_level_per_channel[0] # pack Bayer image to 4 channels im = raw.raw_image_visible.astype(np.float32) im = np.maximum(im - bl, 0) / (16383 - bl) # subtract the black level im = np.expand_dims(im, axis=2) img_shape = im.shape H = img_shape[0] W = img_shape[1] out = np.concatenate((im[0:H:2, 0:W:2, :], im[0:H:2, 1:W:2, :], im[1:H:2, 1:W:2, :], im[1:H:2, 0:W:2, :]), axis=2) return out #manggil model sess = tf.Session() in_image = tf.placeholder(tf.float32, [None, None, None, 4]) gt_image = tf.placeholder(tf.float32, [None, None, None, 3]) out_image = network(in_image) saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) ckpt = tf.train.get_checkpoint_state(checkpoint_dir) if ckpt: print('loaded ' + ckpt.model_checkpoint_path) saver.restore(sess, ckpt.model_checkpoint_path) #proses gambar input in_files = glob.glob(input_dir + filename) in_path = in_files[0] #in_fn = os.path.basename(in_path) #print(in_fn) ratio = 200 raw = rawpy.imread(in_path) input_full = np.expand_dims(pack_raw(raw), axis=0) * ratio im = raw.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16) # scale_full = np.expand_dims(np.float32(im/65535.0),axis = 0)*ratio scale_full = np.expand_dims(np.float32(im / 65535.0), axis=0) input_full = np.minimum(input_full, 1.0) output = sess.run(out_image, feed_dict={in_image: input_full}) output = np.minimum(np.maximum(output, 0), 1) output = output[0, :, :, :] origin_full = scale_full[0, :, :, :] #save image fileoutput = os.path.splitext(filename)[0] + '.png' #fileoutput = namafile + '.png' fileinput = os.path.splitext(filename)[0] + '.png' namainput = fileinput scipy.misc.toimage(output * 255, high=255, low=0, cmin=0, cmax=255).save(file_path1 + '/' + fileoutput) #scipy.misc.toimage(origin_full * 255, high=255, low=0, cmin=0, cmax=255).save(input_dir + '/' + fileoutput) #out = scipy.misc.toimage(output * 255, high=255, low=0, cmin=0, cmax=255) # out.save(os.path.join(file_path1, 'out.png')) keluar = Image.open(os.path.join(file_path1, fileoutput)) return render_template("resultem.html", keluar=fileoutput, namainput=fileinput) #belom tau bisa gini apa engga wkwkw
def testHighlightModeParameter(): raw = rawpy.imread(rawTestPath) raw.postprocess(highlight_mode=1) raw.postprocess(highlight_mode=rawpy.HighlightMode.Blend) raw.postprocess(highlight_mode=rawpy.HighlightMode.Reconstruct(3))
def __getitem__(self, idx): raw = rawpy.imread(self.gt_files[idx]) img_gt = raw.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16).copy() img_gtt = np.float32(img_gt / 65535.0) raw.close() raw = rawpy.imread(self.train_files[idx]) img = raw.raw_image_visible.astype(np.float32).copy() raw.close() img_loww = (np.maximum(img - 512, 0) / (16383 - 512)) H, W = img_loww.shape ############################################################################## r_low = [] g1_low = [] g2_low = [] b_low = [] gt = [] for_amplifier = [] for gener in range(4): if random.randint(0, 100) > 50: flip_flag = True else: flip_flag = False if random.randint(0, 100) < 20: v_flag = True else: v_flag = False # print(H) i = random.randint(0, (H - self.opt['patch'] - 2) // 2) * 2 j = random.randint(0, (W - self.opt['patch'] - 2) // 2) * 2 img_low = img_loww[i:i + self.opt['patch'], j:j + self.opt['patch']] img_gt = img_gtt[i:i + self.opt['patch'], j:j + self.opt['patch'], :] if flip_flag: img_gt = np.flip(img_gt, 0).copy() img_low = np.flip(img_low, 0).copy() if v_flag: img_gt = np.flip(img_gt, 1).copy() img_low = np.flip(img_low, 1).copy() values, edges = np.histogram(img_low, bins=self.a, range=(0, 1), normed=None, weights=None, density=None) values = values / (img_low.shape[0] * img_low.shape[1]) img_low_r = img_low[0:self.opt['patch']:2, 0:self.opt['patch']:2] img_low_g1 = img_low[0:self.opt['patch']:2, 1:self.opt['patch']:2] img_low_g2 = img_low[1:self.opt['patch']:2, 0:self.opt['patch']:2] img_low_b = img_low[1:self.opt['patch']:2, 1:self.opt['patch']:2] for_amplifier.append(torch.from_numpy(values).float()) img_gt_avg = np.zeros((opt['patch'] // 8, opt['patch'] // 8, int(64 * 3))).astype(np.float32) r_avg = np.zeros((opt['patch'] // 16, opt['patch'] // 16, 64)).astype(np.float32) g1_avg = np.zeros((opt['patch'] // 16, opt['patch'] // 16, 64)).astype(np.float32) g2_avg = np.zeros((opt['patch'] // 16, opt['patch'] // 16, 64)).astype(np.float32) b_avg = np.zeros((opt['patch'] // 16, opt['patch'] // 16, 64)).astype(np.float32) count_gt = 0 # We now begin the Pack 8x operation count_raw = 0 for ii in range(8): for jj in range(8): img_gt_avg[:, :, count_gt:count_gt + 3] = img_gt[ii:opt['patch']:8, jj:opt['patch']:8, :] count_gt = count_gt + 3 # print(count_gt) r_avg[:, :, count_raw] = img_low_r[ii:opt['patch'] // 2:8, jj:opt['patch'] // 2:8] g1_avg[:, :, count_raw] = img_low_g1[ii:opt['patch'] // 2:8, jj:opt['patch'] // 2:8] g2_avg[:, :, count_raw] = img_low_g2[ii:opt['patch'] // 2:8, jj:opt['patch'] // 2:8] b_avg[:, :, count_raw] = img_low_b[ii:opt['patch'] // 2:8, jj:opt['patch'] // 2:8] count_raw = count_raw + 1 # print('{},{},{}'.format(count_raw,ii,jj)) gt.append( torch.from_numpy((np.transpose(img_gt_avg, [2, 0, 1]))).float()) r_low.append( torch.from_numpy((np.transpose(r_avg, [2, 0, 1]))).float()) g1_low.append( torch.from_numpy((np.transpose(g1_avg, [2, 0, 1]))).float()) g2_low.append( torch.from_numpy((np.transpose(g2_avg, [2, 0, 1]))).float()) b_low.append( torch.from_numpy((np.transpose(b_avg, [2, 0, 1]))).float()) return gt, r_low, g1_low, g2_low, b_low, for_amplifier
def testSegfaultBug(): # https://github.com/neothemachine/rawpy/issues/7 im = rawpy.imread(rawTestPath).raw_image assert_array_equal(im.shape, [2844, 4288]) print(im)
def testLibRawFileUnsupportedError(): rawpy.imread(os.path.join(thisDir, 'README.txt'))
def read_raw_image(filename): with rawpy.imread(filename) as raw: rgb = raw.postprocess() # Changing to BGR rgb[:, :, 0], rgb[:, :, 2] = rgb[:, :, 2], rgb[:, :, 0] return rgb
def testContextManager(): with rawpy.imread(rawTestPath) as raw: assert_array_equal(raw.raw_image.shape, [2844, 4288])
srgb = np.clip(srgb, 0, 1) return (srgb*255).astype(np.uint8) def convertColor(img, ccm): out = np.zeros_like(img) out[:, :, 0] = ccm[0, 0] * img[:, :, 0] + ccm[0, 1] * img[:, :, 1] + ccm[0, 2] * img[:, :, 2] out[:, :, 1] = ccm[1, 0] * img[:, :, 0] + ccm[1, 1] * img[:, :, 1] + ccm[1, 2] * img[:, :, 2] out[:, :, 2] = ccm[2, 0] * img[:, :, 0] + ccm[2, 1] * img[:, :, 1] + ccm[2, 2] * img[:, :, 2] return out if __name__ == '__main__': raw = RAW() raw = raw.fromFile('00002_00_10s.ARW') srgb = raw.get_sRGB() Image.fromarray(srgb).show() raw = rawpy.imread('00002_00_10s.ARW') srgb = raw.postprocess( demosaic_algorithm=rawpy.DemosaicAlgorithm.AHD, half_size=False, use_camera_wb=True, output_color=rawpy.ColorSpace.sRGB, output_bps=8, no_auto_bright=False, no_auto_scale=True ) Image.fromarray(srgb).show() print('Over!')
def load(file, name=None): img = rawpy.imread(file) if not name: name = file return image(image=img, name=name)
def test_color(path_im, color_name, ppg_data, wb_roi, patch_roi, path_jpeg = None): #Full DNG detail # with exiftool.ExifTool() as et: # metadata = et.get_metadata(path_im) # for key in metadata.keys(): # print(key, ' ', metadata[key]) with rp.imread(path_im) as raw: h, w = np.shape(raw.raw_image) print(h, ' ', w) #print(raw.raw_colors) m_raw_rgb = np.array([0.0, 0.0, 0.0, 0.0]) m_raw_cnt = np.array([0, 0, 0, 0]) for i in range(wb_roi[1], wb_roi[3]): for j in range(wb_roi[0], wb_roi[2]): m_raw_rgb[raw.raw_color(i, j)] += raw.raw_value(i, j) m_raw_cnt[raw.raw_color(i, j)] += 1 m_raw_rgb /= m_raw_cnt # print(m_raw_rgb) wp = np.array([m_raw_rgb[0], m_raw_rgb[1], m_raw_rgb[2]]) wp /= wp[1] print('white point: ' + str(wp)) user_whitebalance = (1.0 / wp).tolist() + [0] print('user white balance: ' + str(user_whitebalance)) print('camera white balance: ' + str(raw.camera_whitebalance)) print('Custom processing:') custom_xyz = raw.postprocess(user_wb=user_whitebalance, output_bps=16, output_color=rp.ColorSpace.XYZ, gamma = (1, 1)).astype(float) / (2.0**16 - 1) sample = custom_xyz[patch_roi[1]:patch_roi[3], patch_roi[0]:patch_roi[2]] c_xyz = [np.mean(sample[:, :, x]) for x in range(0, 3)] c_rgb = cam2xyz.XYZ2sRGB(c_xyz) print('Default processing:') default_xyz = raw.postprocess(use_camera_wb=True, output_bps=16, output_color=rp.ColorSpace.XYZ, gamma = (1, 1)).astype(float) / (2.0**16 - 1) sample = default_xyz[patch_roi[1]:patch_roi[3], patch_roi[0]:patch_roi[2]] d_xyz = [np.mean(sample[:, :, x]) for x in range(0, 3)] d_rgb = cam2xyz.XYZ2sRGB(d_xyz) j_rgb = [0, 0, 0] if path_jpeg: jpeg_rgb = cv2.cvtColor(cv2.imread(path_jpeg), cv2.COLOR_BGR2RGB) sample = jpeg_rgb[patch_roi[1]:patch_roi[3], patch_roi[0]:patch_roi[2]] j_rgb = [np.mean(sample[:, :, x]) for x in range(0, 3)] c_lab = cam2xyz.XYZ2LAB(c_xyz) d_lab = cam2xyz.XYZ2LAB(d_xyz) if path_jpeg: j_lab = cam2xyz.RGB2LAB(j_rgb) print('RGB after eliminate illuminant: ' + str(c_rgb)) print('PPG RGB: ' + str(ppg_data[color_name]['RGB'])) print('Lab after eliminate illuminant: ' + str(c_lab)) print('PPG Lab: ' + str(ppg_data[color_name]['LAB'])) # dE_c = deltaE(c_lab, np.array(ppg_data[color_name]['LAB'])) # dE_d = deltaE(d_lab, np.array(ppg_data[color_name]['LAB'])) dE_c = colour.delta_E(c_lab, np.array(ppg_data[color_name]['LAB'])) dE_d = colour.delta_E(d_lab, np.array(ppg_data[color_name]['LAB'])) # print('Custom wb dE: ', deltaE(c_lab, np.array(ppg_data[color_name]['LAB']))) # print('Default wb dE: ', deltaE(d_lab, np.array(ppg_data[color_name]['LAB']))) print('Custom wb dE: ', dE_c) print('Default wb dE: ', dE_d) dE_j = -1.0 if path_jpeg: dE_j = colour.delta_E(j_lab, np.array(ppg_data[color_name]['LAB'])) print('JPEG dE: ', dE_j) # vis_s = np.tile(c_rgb, [300, 300, 1]) # vis_d = np.tile(d_rgb, [300, 300, 1]) # vis_ppg = np.tile(ppg_data[color_name]['RGB'], [300, 300, 1]) # if path_jpeg: # vis_j = np.tile(j_rgb, [300, 300, 1]) # if path_jpeg: # fig, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4) # ax1.imshow(vis_s) # ax1.set_title('Custom wb') # ax2.imshow(vis_ppg) # ax2.set_title('Gt') # ax3.imshow(vis_d) # ax3.set_title('Default wb') # ax4.imshow(vis_j) # ax4.set_title('jpeg') # plt.show() return dE_d, dE_c, dE_j, d_rgb, c_rgb, j_rgb, d_xyz, c_xyz
import rawpy import imageio for i in range(33): raw = rawpy.imread('HG/'+str(i)+'.CR2') rgb = raw.postprocess() imageio.imsave('HG/'+str(i)+'.tiff', rgb)
filedir = args.raw_image_folder if not os.path.exists(filedir+'/jpg'): os.makedirs(filedir+'/jpg') if not os.path.exists(filedir+'/jpg/cropped'): os.makedirs(filedir+'/jpg/cropped') jpgdir = filedir+'/jpg' croppeddir = jpgdir + '/cropped' # Convert raw images CR2 in png for full_path in glob.glob(filedir + "/*.CR2"): filename = os.path.basename(full_path) print(full_path) raw = rawpy.imread(full_path) image = raw.postprocess() imageio.imsave(jpgdir + "/" + filename.split(".")[0] + ".jpg", image) for full_path in glob.glob(jpgdir + "/*.jpg"): filename = os.path.basename(full_path) # Original image image = cv2.imread(full_path) print(full_path) # # Resize draw = np.zeros_like(image) # Convert to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Get black and white image
bad_pixels = np.asarray(bad_pixels) # Format is: pixel column, pixel row, UNIX time of death dc = np.zeros((len(bad_pixels),3), dtype=int) dc[:,0] = bad_pixels[:,1] dc[:,1] = bad_pixels[:,0] np.savetxt(path, dc, fmt='%1i') if __name__ == '__main__': prefix = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'test') testfiles = ['iss030e122639.NEF', 'iss030e122659.NEF', 'iss030e122679.NEF', 'iss030e122699.NEF', 'iss030e122719.NEF'][0:1] paths = [os.path.join(prefix, f) for f in testfiles] coords = find_bad_pixels(paths) import imageio raw = rawpy.imread(paths[0]) if not os.path.exists('test_original.png'): rgb = raw.postprocess() imageio.imsave('test_original.png', rgb) # A. use dcraw repair # Note that this method fails when two bad pixels are direct neighbors. # This is because it corrects each bad pixel separately and uses the # mean of the surrounding pixels. t0 = time.time() bad_pixels_path = os.path.abspath('bad_pixels.txt') save_dcraw_bad_pixels(bad_pixels_path, coords) rgb = raw.postprocess(bad_pixels_path=bad_pixels_path) print('badpixel dcraw repair+postprocessing:', time.time()-t0, 's') imageio.imsave('test_hotpixels_repaired_dcraw.png', rgb)
def load_frame(imgname, pbar): global args, master_dark, master_flat linearGamma = (1, 1) sRGBGamma = (2.4, 12.92) calibrate = master_dark is not None and master_flat is not None black = 0 if calibrate or args['--raw'] else None whitebalance = [0, 0, 0, 0] if calibrate or args['--raw'] else None params = rawpy.Params( gamma=linearGamma, no_auto_scale=False, no_auto_bright=True, output_bps=16, use_camera_wb=False, use_auto_wb=False, user_wb=whitebalance, output_color=rawpy.ColorSpace.sRGB, demosaic_algorithm=rawpy.DemosaicAlgorithm.AHD, fbdd_noise_reduction=rawpy.FBDDNoiseReductionMode.Off, dcb_enhance=False, dcb_iterations=0, half_size=False, median_filter_passes=0, user_black=black) try: pbar.set_postfix(step=f"loading") with rawpy.imread(imgname) as raw: if calibrate: if raw.raw_image.shape != master_dark.shape or raw.raw_image.shape != master_flat.shape: raise RuntimeError( "Flat and dark frames must be the same resolution as each stacked image" ) pbar.set_postfix(step=f"calibrating") dark_removed = (1.0 * raw.raw_image - master_dark) dark_removed[dark_removed < 0] = 0 corrected = dark_removed / master_flat corrected[corrected < 0] = 0 np.copyto(raw.raw_image, corrected.astype(np.uint16)) if args['--raw']: img = np.float32(raw.raw_image.astype(np.uint16) / 65535.0) else: pbar.set_postfix(step=f"demosaicing") img = np.float32( raw.postprocess(params).astype(np.uint16) / 65535.0) # crop margin if args['--visible']: s = raw.sizes img = img[s.top_margin * 2:s.raw_height - s.top_margin * 2, s.left_margin * 2:s.raw_width - s.left_margin * 2] return img except rawpy.LibRawError as inst: return None
def find_bad_pixels(paths, find_hot=True, find_dead=True, confirm_ratio=0.9): """ Find and return coordinates of hot/dead pixels in the given RAW images. The probability that a detected bad pixel is really a bad pixel gets higher the more input images are given. The images should be taken around the same time, that is, each image must contain the same bad pixels. Also, there should be movement between the images to avoid the false detection of bad pixels in non-moving high-contrast areas. :param paths: paths to RAW images shot with the same camera :type paths: iterable of str :param bool find_hot: whether to find hot pixels :param bool find_dead: whether to find dead pixels :param float confirm_ratio: ratio of how many out of all given images must contain a bad pixel to confirm it as such :return: coordinates of confirmed bad pixels :rtype: ndarray of shape (n,2) with y,x coordinates relative to visible RAW size """ assert find_hot or find_dead coords = [] width = None paths = list(paths) for path in paths: t0 = time.time() # TODO this is a bit slow, try RawSpeed raw = rawpy.imread(path) if width is None: if raw.raw_type != rawpy.RawType.Flat: raise NotImplementedError('Only Bayer-type images are currently supported') # we need the width later for counting width = raw.sizes.width print('imread:', time.time()-t0, 's') thresh = max(np.max(raw.raw_image_visible)//150, 20) print('threshold:', thresh) isCandidate = partial(_is_candidate, find_hot=find_hot, find_dead=find_dead, thresh=thresh) coords.extend(_find_bad_pixel_candidates(raw, isCandidate)) coords = np.vstack(coords) if len(paths) == 1: return coords # select candidates that appear on most input images # count how many times a coordinate appears # first we convert y,x to array offset such that we have an array of integers offset = coords[:,0]*width offset += coords[:,1] # now we count how many times each offset occurs t0 = time.time() counts = _groupcount(offset) print('groupcount:', time.time()-t0, 's') print('found', len(counts), 'bad pixel candidates, cross-checking images..') # we select the ones whose count is high is_bad = counts[:,1] >= confirm_ratio*len(paths) # and convert back to y,x bad_offsets = counts[is_bad,0] bad_coords = np.transpose([bad_offsets // width, bad_offsets % width]) print(len(bad_coords), 'bad pixels remaining after cross-checking images') return bad_coords
def render_raw(image, savename): im = rawpy.imread(image) rgb = im.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=8) imageio.imwrite(savename, rgb)
import urllib.request as urllib import pandas as pd import rawpy import cv2 df = pd.read_csv("RAISE_1k.csv") urls = df['NEF'].values num_images = 1 image_count = 1 for url in urls: image_str = 'raw/' + str(image_count) + '.nef' print(image_str) try: img = urllib.urlopen(url).read() except urllib.error.HTTPError: # add the os.environ code here img = urllib.urlopen(url).read() f = open(image_str, 'wb') f.write(img) f.close() rgb_img = rawpy.imread(image_str).postprocess(use_camera_wb=True, output_bps=8) rgb_img = cv2.cvtColor(rgb_img, cv2.COLOR_RGB2BGR) cv2.imwrite('rgb/' + str(image_count) + '.png', rgb_img) image_count += 1
def upload_pertama(): # create image directory if not found target = os.path.join(APP_ROOT, 'static/RAW/') if not os.path.isdir(target): os.mkdir(target) targetdua = os.path.join(APP_ROOT, 'static/PNG/') # create image directory if not found if not os.path.isdir(targetdua): os.mkdir(targetdua) # retrieve file from html file-picker upload = request.files.getlist("file")[0] print("File name: {}".format(upload.filename)) filename = upload.filename fileinput = os.path.splitext(filename)[0] + '.png' # save file destination = "/".join([target, filename]) print("File saved to to:", destination) upload.save(destination) # save file png #destination = "/".join([targetdua, filename]) #print("File saved to to:", destination) #upload.save(destination) input_dir = './static/RAW/' def pack_raw(raw): # read image black level bl = raw.black_level_per_channel[0] # pack Bayer image to 4 channels im = raw.raw_image_visible.astype(np.float32) im = np.maximum(im - bl, 0) / (16383 - bl) # subtract the black level im = np.expand_dims(im, axis=2) img_shape = im.shape H = img_shape[0] W = img_shape[1] out = np.concatenate((im[0:H:2, 0:W:2, :], im[0:H:2, 1:W:2, :], im[1:H:2, 1:W:2, :], im[1:H:2, 0:W:2, :]), axis=2) return out #proses gambar input in_files = glob.glob(input_dir + filename) in_path = in_files[0] raw = rawpy.imread(in_path) im = raw.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16) scale_full = np.expand_dims(np.float32(im / 65535.0), axis=0) origin_full = scale_full[0, :, :, :] fileinput = os.path.splitext(filename)[0] + '.png' namainput=fileinput scipy.misc.toimage(origin_full * 255, high=255, low=0, cmin=0, cmax=255).save('./static/PNG/' + fileinput) # forward to processing page return render_template("processing1.html", image_name=filename, namainput=fileinput)
#!/usr/bin/python # OpenCV tutorial import numpy as np import rawpy, imageio from skimage.exposure import rescale_intensity raw4 = rawpy.imread('/home/simba/Downloads/Kitchen4.CR2') raw3 = rawpy.imread('/home/simba/Downloads/Kitchen3.CR2') raw2 = rawpy.imread('/home/simba/Downloads/Kitchen2.CR2') raw1 = rawpy.imread('/home/simba/Downloads/Kitchen1.CR2') raw0 = rawpy.imread('/home/simba/Downloads/Kitchen0.CR2') rgb = raw.postprocess(no_auto_bright=True, use_auto_wb =False,gamma=None) imageio.imwrite('/home/simba/Downloads/example.jpg', rgb)
import matplotlib.pyplot as plt from matplotlib import colors from matplotlib import ticker from matplotlib.colors import LinearSegmentedColormap images=[] for infile in os.listdir("./"): print( "file : " + infile) if infile[-3:] == "tif" or infile[-3:] == "DNG" : # print "is tif or DNG (RAW)" outfile = infile[:-3] + "jpg" print( "new filename : " + outfile) dim=(640,360) raw = rawpy.imread(infile) # Postprocessing, i.e demosaicing here, will always #change the original pixel values. Typically what you want # is to get a linearly postprocessed image so that roughly #the number of photons are in linear relation to the pixel values. #You can do that with: rgb = raw.postprocess() # demosaicing #rgb = np.rot90(rgb, k=2) which could change RGGB pattern to BGGR, vice versa) rgb = cv2.resize(rgb,dim,interpolation = cv2.INTER_AREA) rgb = cv2.bitwise_not(~rgb) images.append(rgb) #Read the images from your directory
import numpy import rawpy import imageio import cv2 raw_image = rawpy.imread('IMG.CR2') img = raw_image.postprocess() rgb=cv2.cvtColor(img, cv2.COLOR_BGR2RGBA) print(rgb.shape) cv2.imwrite('1.jpg',rgb, [cv2.IMWRITE_PNG_COMPRESSION, 0])
for test_id in test_ids: # test the first image in each sequence in_files = glob.glob(input_dir + '%05d_00*.ARW' % test_id) for k in range(len(in_files)): in_path = in_files[k] in_fn = os.path.basename(in_path) print(in_fn) gt_files = glob.glob(gt_dir + '%05d_00*.ARW' % test_id) gt_path = gt_files[0] gt_fn = os.path.basename(gt_path) in_exposure = float(in_fn[9:-5]) gt_exposure = float(gt_fn[9:-5]) ratio = min(gt_exposure / in_exposure, 300) raw = rawpy.imread(in_path) input_full = np.expand_dims(pack_raw(raw), axis=0) * ratio im = raw.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16) # scale_full = np.expand_dims(np.float32(im/65535.0),axis = 0)*ratio scale_full = np.expand_dims(np.float32(im / 65535.0), axis=0) gt_raw = rawpy.imread(gt_path) im = gt_raw.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16) gt_full = np.expand_dims(np.float32(im / 65535.0), axis=0)
import numpy as np import rawpy from skimage import color, exposure from matplotlib import pyplot as plt file_path_long = r'E:\LSID\dataset\Sony\long\00100_00_30s.ARW' gt_image = rawpy.imread(file_path_long) gt_image = gt_image.postprocess(use_camera_wb=True, half_size=False, no_auto_bright=True, output_bps=16) # divide by 65535 after converting a uint16 intensity image to double target = np.float32( gt_image / 65535.0) # RGB image shape (2848, 4256, 3), channel order: RGB # Convert image to HSV color space img_hsv = color.rgb2hsv(target) # Histogram normalization on V channel img_v = img_hsv[:, :, 2].copy() img_hsv[:, :, 2] = exposure.equalize_hist(img_hsv[:, :, 2]) # Convert back to RGB space img_equalized = color.hsv2rgb(img_hsv.astype('float')) plt.figure() plt.subplot(2, 2, 1) plt.title('Unmodified') plt.imshow(target)
path_im = 'E:/UIUC/Data_11_07_18/iOS' im_name = 'RAW_2018_11_08_15_09_06_866_noflash.dng' with open('E:/UIUC/Data_11_07_18/IOSNoFlashLabel.json', 'r') as fp: labels = json.load(fp) test_key = [ 'HYDRANGEA FLORET', 'BLUE SHAMROCK', 'DARK GREEN VELVET', 'DOVER GRAY', 'OREGANO', 'GINGER', 'FERRIS WHEEL' ] fig, axs = plt.subplots(len(test_key), 5) cnt = 0 for key in test_key: im_name = labels[key][0]['im_name'] with rp.imread(path_im + '/' + im_name) as raw: patch_roi = labels[key][0]['patch_roi'] #Raw values raw_values = np.array(raw.raw_image) h, w = np.shape(raw_values) rgb = np.zeros([int(h / 2), int(w / 2), 3], dtype=np.float) cwb = raw.camera_whitebalance print(cwb) for i in range(0, np.shape(raw_values)[0], 2): for j in range(0, np.shape(raw_values)[1], 2): #print(raw.raw_color(i, j), ' ', raw.raw_color(i, j + 1), ' ', raw.raw_color(i + 1, j)) tmp = [ raw_values[i][j], raw_values[i][j + 1], raw_values[i + 1][j + 1] ]
def testThumbnail(): raw = rawpy.imread(rawTestPath) thumb = raw.get_thumbnail() assert_equal(thumb["type"], 'jpeg') with open('thumb_test.jpg', 'wb') as f: f.write(thumb["data"])