def is_ok(path): if not OpenEXR.isOpenExrFile(path): return False img = OpenEXR.InputFile(path) if not img.isComplete(): return False return True
def load(self, path = ""): if type(path) is not str: raise TypeError("Path must be string") if path == "": path = self._path if path == "": raise ValueError("Path must be set") if not OpenEXR.isOpenExrFile(path): raise FileNotFoundError(path) img = OpenEXR.InputFile(path) if not img.isComplete(): raise IOError("File is corrupted") dw = img.header()['displayWindow'] size = (dw.max.y - dw.min.y + 1, dw.max.x - dw.min.x + 1) # compression type self._compression = compress.str_to_obj(img.header()["compression"]) # load data for channel_name, channel_type in img.header()["channels"].items(): # data data = img.channel(channel_name) # pixel data type pix_type = np.float32 if channel_type == Imath.Channel( Imath.PixelType( Imath.PixelType.HALF ) ): pix_type = np.float16 elif channel_type == Imath.Channel( Imath.PixelType( Imath.PixelType.UINT ) ): pix_type = np.np.uint64 # create numpy channel in dictionary if channel_name not in self or self._preserve_channels: self[channel_name] = np.fromstring(data, dtype = pix_type).reshape(size) self._shape = size print("HEADER: ", img.header() )
def load_depth(filePath): ''' Loads an depth OpenEXR image.''' if oe.isOpenExrFile(filePath) is not True: raise Exception("File ", filePath, " does not exist!") try: ifi = oe.InputFile(filePath) # Compute size header = ifi.header() dw = header["dataWindow"] w, h = dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1 # Read the three channels ifiType = header["channels"]["Z"].type.v if ifiType is not im.PixelType.FLOAT: raise Exception("Only float32 supported! (file is type ", ifiType) Z = ifi.channel("Z", im.PixelType(ifiType)) ifi.close() image = np.zeros((h, w), dtype = np.float32) # order = "C" image[:, :] = np.core.multiarray.fromstring(Z, dtype = np.float32).reshape(h, w) except: raise return image
def load_depth(filePath): ''' Loads an depth OpenEXR image.''' if oe.isOpenExrFile(filePath) is not True: raise Exception("File ", filePath, " does not exist!") try: ifi = oe.InputFile(filePath) # Compute size header = ifi.header() dw = header["dataWindow"] w, h = dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1 # Read the three channels ifiType = header["channels"]["Z"].type.v if ifiType is not im.PixelType.FLOAT: raise Exception("Only float32 supported! (file is type ", ifiType) Z = ifi.channel("Z", im.PixelType(ifiType)) ifi.close() image = np.zeros((h, w), dtype=np.float32) # order = "C" image[:, :] = np.core.multiarray.fromstring(Z, dtype=np.float32).reshape( h, w) except: raise return image
def is_valid_exr(self, exr_handle=None): """ Check if exr is valid and complete (all data present) :param exr_handle: optional - an exr InputFile handle. If not provided one is created :return: The error if not readable or missing pixels, None otherwise """ # check if a file handle was given if not exr_handle: # no handle provided so open the exr and get one exr_handle = self._open_exr_file_handle(self.path) # check for errors if not isinstance(exr_handle, OpenEXR.InputFile): return exr_handle # check of the exr is readable if not OpenEXR.isOpenExrFile(self.path): error = "The following exr does not exist or is not readable: {0}".format( self.path) logging.exception(error) exr_handle.close() return error # check if the exr has complete pixel information if not exr_handle.isComplete(): error = "The following exr has missing pixels: {0}".format( self.path) logging.exception(error) exr_handle.close() return error return None
def _open_inputfile(filename): if not OpenEXR.isOpenExrFile(filename): print( "Failed reading image. File can't be opened or is not an OpenEXR image." ) raise SystemExit(1) exr_file = OpenEXR.InputFile(filename) if not exr_file.isComplete(): print( "WARNING: File seems incomplete (corrupted or still being written)." ) return exr_file
def matte_pass_channel_cleanup(in_path, out_path): """ @params: in_path: Path to exr file. out_path: Path to write out the new exr file. """ if os.path.exists(in_path) and OpenEXR.isOpenExrFile(in_path): channels_to_merge = defaultdict(list) base_channels = [] # Read the file and header handle = OpenEXR.InputFile(in_path) header = handle.header() # Get the channels channels = header['channels'] header['channels'] = {} new_channels = {} for channel_name, channel_data in channels.iteritems(): match = CHANNEL_MATCH.match(channel_name) if match: layer, channel = match.groups() channels_to_merge[layer].append(channel) elif not ALPHA_MATCH.match(channel_name): base_channels.append(channel_name) for layer in base_channels: all_pixels = array.array( 'f', handle.channel(layer, Imath.PixelType(Imath.PixelType.HALF))).tolist() new_channels[layer] = array.array('f', all_pixels).tostring() for layer, data in channels_to_merge.iteritems(): new_pixels = [] try: new_layer_name = layer.split('_')[1] except: new_layer_name = layer # new pixels new_pixels = array.array('f', handle.channel('{0}.{1}'.format(layer, data[0]))) new_channels['matte.{0}'.format(new_layer_name)] = array.array('f', new_pixels).tostring() # write out new exr header['channels'] = dict([(c, HALF) for c in new_channels.keys()]) out = OpenEXR.OutputFile(out_path, header) out.writePixels(new_channels)
def __init__(self, image): super(AniImage, self).__init__() self.image = image # allow user to pass a AnImage object, or a string path self.__path = getattr(image, 'path', None) if self.__path is None: self.__path = str(image) # image parts self.__dirname, self.__filename = os.path.split(self.__path) # all numeric parts image name self.__digits = util.DIGITS_RE.findall(self.name) # get all non numeric parts of image name self.__parts = util.DIGITS_RE.split(self.name) self.__size = (0, 0) # get image size using OpenExr for exrs and PIL for other image formats. Lighter weight than using cv2 which # causes standalone executable to be 30 megs bigger if OpenEXR.isOpenExrFile(self.path): try: exr_image = OpenEXR.InputFile(self.path) dw = exr_image.header()['dataWindow'] self.__size = (dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1) exr_image.close() except (IOError, OSError, ValueError) as e: raise AniImageError('Image: {0} is not a valid exr.'.format(self.path)) else: try: with Image.open(self.path) as img: self.__size = img.size except (IOError, OSError, ValueError) as e: raise AniImageError('Image: {0} does not exist on disk or is invalid.'.format(self.path)) try: # get the frame as a pyani.core. AniFrame object self.__frame = AniFrame(self.path) except IndexError: # image must not have a frame self.__frame = None # the start_and end are at the . in file name, or whatever separates frame number from extension and image name # subtract one from start to get image name no '.' and add one to get extension no '.' if self.frame: self.__base_name = self.name[:self.frame.start - 1] self.__ext = self.name[self.frame.end+1:] else: # no frame in image name, split at extension split_name = self.name.split(".") self.__base_name = ".".join(split_name[:-1]) self.__ext = split_name[-1]
def read_texture(filename): image_data = 0 is_hdr = False size = () if OpenEXR.isOpenExrFile(filename): is_hdr = True img = OpenEXR.InputFile(filename) FLOAT = Imath.PixelType(Imath.PixelType.FLOAT) (r, g, b) = ( img.channel(chan, FLOAT) for chan in ('R', 'G', 'B')) dw = img.header()['dataWindow'] size = (dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1) r_data = np.fromstring(r, dtype=np.float32) g_data = np.fromstring(g, dtype=np.float32) b_data = np.fromstring(b, dtype=np.float32) image_data = np.dstack((r_data, g_data, b_data)) img.close() else: try: image = Image.open(filename) except IOError as ex: print('IOError: failed to open texture file %s' % filename) return -1 print('opened file: size=', image.size, 'format=', image.format) image_data = np.array(list(image.getdata()), np.uint8) size = image.size image.close() texture_id= glGenTextures(1) glPixelStorei(GL_UNPACK_ALIGNMENT, 4) glBindTexture(GL_TEXTURE_2D, texture_id) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) if is_hdr: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, size[0], size[1], 0, GL_RGB, GL_FLOAT, image_data) else: glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size[0], size[1], 0, GL_RGB, GL_UNSIGNED_BYTE, image_data) return texture_id
def inspect_file(in_path): """ TODO: add docstring. Args: in_path (str): File to read Raises: NoExrFileException """ print 'Started inspect of {in_path}.'.format(in_path=in_path) # start time time_start = time.time() if not OpenEXR.isOpenExrFile(in_path): raise NoExrFileException(in_path) # open exr file in_exr_file = OpenEXR.InputFile(in_path) # get open exr header in_exr_header = in_exr_file.header() # printable_exr_header = {key: value for key, filter_jsonable(value) in in_exr_header.iteritems()} def catch_value(value): """ Catch non-jsonable values. Args: value (mixed): Value Returns: mixed """ # if isinstance(value, Imath.Box2i): return repr(value) print json.dumps(filter_jsonable(in_exr_header, catch_value), indent=4) # stop time time_stop = time.time() # duration duration = round(time_stop - time_start) print 'Finished inspect for {in_path} ({duration}s).'.format( in_path=in_path, duration=duration)
def load_hdr_as_tensor(img_path): """Converts OpenEXR image to torch float tensor.""" # Read OpenEXR file if not OpenEXR.isOpenExrFile(img_path): raise ValueError(f'Image {img_path} is not a valid OpenEXR file') src = OpenEXR.InputFile(img_path) pixel_type = Imath.PixelType(Imath.PixelType.FLOAT) dw = src.header()['dataWindow'] size = (dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1) # Read into tensor tensor = torch.zeros((3, size[1], size[0])) for i, c in enumerate('RGB'): rgb32f = np.fromstring(src.channel(c, pixel_type), dtype=np.float32) tensor[i, :, :] = torch.from_numpy(rgb32f.reshape(size[1], size[0])) return tensor
def load_exr_as_tensor(filename): import OpenEXR import Imath if not OpenEXR.isOpenExrFile(filename): raise Exception(f"File {filename} is not an EXR file.") exr_data = OpenEXR.InputFile(filename) exr_header = exr_data.header() dw = exr_header['dataWindow'] width = dw.max.x - dw.min.x + 1 height = dw.max.y - dw.min.y + 1 red_channel = np.frombuffer(exr_data.channels('R')[0], dtype=np.float32).reshape(height, width) green_channel = np.frombuffer(exr_data.channels('G')[0], dtype=np.float32).reshape(height, width) blue_channel = np.frombuffer(exr_data.channels('B')[0], dtype=np.float32).reshape(height, width) image_tensor = np.stack((red_channel, green_channel, blue_channel), axis=0) return torch.Tensor(image_tensor)
def read_exr_header(fullpath): # type: (Union[str, Path]) -> dict ''' Reads an OpenEXR image file header. Args: fullpath (str or Path): Image file path. Raises: IOError: If given filepath is not an EXR file. Returns: dict: EXR header. ''' fullpath = Path(fullpath).absolute().as_posix() if not openexr.isOpenExrFile(fullpath): msg = f'{fullpath} is not an EXR file.' raise IOError(msg) img = openexr.InputFile(fullpath) return img.header()
def load_exr(filename, datatype=np.float16): import OpenEXR import Imath HALF = Imath.PixelType(Imath.PixelType.HALF) if not OpenEXR.isOpenExrFile(filename): raise Exception("File '%s' is not an EXR file." % filename) infile = OpenEXR.InputFile(filename) header = infile.header() dw = header['dataWindow'] width = dw.max.x - dw.min.x + 1 height = dw.max.y - dw.min.y + 1 return_matrix_ch_B = np.fromstring(infile.channels('B')[0], dtype=datatype).reshape(height, width) return_matrix_ch_G = np.fromstring(infile.channels('G')[0], dtype=datatype).reshape(height, width) return_matrix_ch_R = np.fromstring(infile.channels('R')[0], dtype=datatype).reshape(height, width) matrix_new = np.stack( (return_matrix_ch_R, return_matrix_ch_G, return_matrix_ch_B), axis=-1) return matrix_new
def load_rgb(filePath): ''' Loads an rgb OpenEXR image.''' if oe.isOpenExrFile(filePath) is not True: raise Exception("File ", filePath, " does not exist!") try: ifi = oe.InputFile(filePath) # Compute size header = ifi.header() dw = header["dataWindow"] w, h = dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1 # Read the three channels ifiType = header["channels"]["R"].type.v if ifiType is not im.PixelType.UINT: raise Exception("Only uint32 supported! (file is type ", ifiType) R = ifi.channel("R", im.PixelType(ifiType)) G = ifi.channel("G", im.PixelType(ifiType)) B = ifi.channel("B", im.PixelType(ifiType)) ifi.close() image = np.zeros((h, w, 3), dtype=np.uint32) # order = "C" image[:, :, 0] = np.core.multiarray.fromstring(R, dtype=np.uint32).reshape( h, w) image[:, :, 1] = np.core.multiarray.fromstring(G, dtype=np.uint32).reshape( h, w) image[:, :, 2] = np.core.multiarray.fromstring(B, dtype=np.uint32).reshape( h, w) except: raise return image
def read_openexr_image(filename): """Read image in OpenEXR file format into numpy array.""" filename = check_file_ext(filename, ".exr") if not OpenEXR.isOpenExrFile(str(filename)): return None image = OpenEXR.InputFile(str(filename)) if not image.isComplete(): return None header = image.header() size = header["displayWindow"] resolution = (size.max.x - size.min.x + 1, size.max.y - size.min.y + 1) ch_info = header["channels"] if "R" in ch_info and "G" in ch_info and "B" in ch_info: if "A" in ch_info: channels = 4 else: channels = 3 else: return None image_o = np.zeros((resolution[1],resolution[0],channels), np.float32) ch = ["R", "G", "B", "A"] pt = Imath.PixelType(Imath.PixelType.FLOAT) for c in range(0, channels): image_channel = np.fromstring(image.channel(ch[c], pt), np.float32) image_o[:, :, c] = image_channel.reshape(resolution[1], resolution[0]) image.close() return image_o
def read_openexr_image(filename): """Read image in OpenEXR file format into numpy array.""" if not OpenEXR.isOpenExrFile(str(filename)): return None img = OpenEXR.InputFile(str(filename)) if not img.isComplete(): return None header = img.header() size = header["displayWindow"] resolution = (size.max.x - size.min.x + 1, size.max.y - size.min.y + 1) ch_info = header["channels"] if "R" in ch_info and "G" in ch_info and "B" in ch_info: if "A" in ch_info: channels = 4 else: channels = 3 else: return None image_o = np.zeros((resolution[1], resolution[0], channels), np.float32) chn = ["R", "G", "B", "A"] pix_t = Imath.PixelType(Imath.PixelType.FLOAT) for channel in range(0, channels): img_chn = np.frombuffer(img.channel(chn[channel], pix_t), np.float32) image_o[:, :, channel] = img_chn.reshape(resolution[1], resolution[0]) img.close() return image_o
def exrHeaderInfo(imagePath): ''' check if the EXR is valid, read the header and return a key, value dict of its values ''' if not 'OpenEXR' in sys.modules.keys(): print "No openEXR module" return #check it is a valid EXR if OpenEXR.isOpenExrFile(imagePath): infile = OpenEXR.InputFile(imagePath) if not infile.isComplete(): print "Invalid EXR: %s" %imagePath #return True here as we still want the directory scan to continue return True EXRheader = infile.header() rDict = {} for k,v in EXRheader.iteritems(): rDict[k]=v #print k,v return rDict
def open(filename): # Check if the file is an EXR file if not OpenEXR.isOpenExrFile(filename): raise Exception("File '%s' is not an EXR file." % filename) # Return an `InputFile` return InputFile(OpenEXR.InputFile(filename), filename)
def check_exr(path): if not OpenEXR.isOpenExrFile(path): logging.warning("EXR_ERROR %s : OpenEXR could not read file", path) return {'valid': False, 'message': 'OpenEXR could not read file'} return {'valid': True, 'message': 'ok'}
def preview_file(in_path, out_path, layer=None): """ Create preview of exr files by normalizing the color range to 8bit. Args: in_path (str): File to read out_path (str): File to write Raises: NoExrFileException """ console.info('Started preview of {in_path}.'.format( in_path=os.path.basename(in_path))) if in_path == out_path: raise SameFileException(out_path) # start time time_start = time.time() if not OpenEXR.isOpenExrFile(in_path): raise NoExrFileException(in_path) # open exr file in_exr_file = OpenEXR.InputFile(in_path) # get open exr header in_exr_header = in_exr_file.header() pixel_type = Imath.PixelType(Imath.PixelType.FLOAT) data_window = in_exr_header['dataWindow'] size = (data_window.max.x - data_window.min.x + 1, data_window.max.y - data_window.min.y + 1) # default channels channels = 'RGB' if layer: selected_channels = [] for layer_name, value in in_exr_header['channels'].iteritems(): if re.search(r'{}'.format(layer), layer_name, flags=re.IGNORECASE): if not layer_name in selected_channels: selected_channels.append(layer_name) selected_channels = sort_rgba(selected_channels) if selected_channels: if len(selected_channels) < 3: # create greyscale image from first channel channels = [ selected_channels[0], selected_channels[0], selected_channels[0] ] elif len(selected_channels) > 3: # maximum of 3 channels channels = selected_channels[:3] else: channels = selected_channels console.debug(channels) rgbf = [ Image.fromstring("F", size, in_exr_file.channel(c, pixel_type)) for c in channels ] extrema = [im.getextrema() for im in rgbf] darkest = min([lo for (lo, hi) in extrema]) lighest = max([hi for (lo, hi) in extrema]) scale = 255 / (lighest - darkest) def normalize_0_255(value): """ Normalize value. Args: value (float): Value to normalize """ return (value * scale) + darkest rgb8 = [im.point(normalize_0_255).convert("L") for im in rgbf] Image.merge("RGB", rgb8).save(out_path) # stop time time_stop = time.time() # duration duration = round(time_stop - time_start) console.info('Finished preview for {out_path} ({duration}s).'.format( out_path=os.path.basename(out_path), duration=duration))
def supported(path): return OpenEXR.isOpenExrFile(path)
def rechannel_file(in_path, out_path, layer_map=None): """ Rechannel layers of exr file at in_path by replacing layer names via regular expression provided by layer_map and storing a new exr file at out_path. Args: in_path (str): File to read out_path (str): File to write layer_map (dict): Regular expression / replacement name pairs Raises: NoExrFileException """ console.info('Started rechannel of {in_path}.'.format( in_path=os.path.basename(in_path))) if in_path == out_path: raise SameFileException(out_path) # start time time_start = time.time() if not layer_map: layer_map = {} if not OpenEXR.isOpenExrFile(in_path): raise NoExrFileException(in_path) # open exr file in_exr_file = OpenEXR.InputFile(in_path) # get open exr header in_exr_header = in_exr_file.header() # create new copy from header out_exr_header = copy.deepcopy(in_exr_header) # reset channels out_exr_header['channels'] = {} # empty dict for matched layers matched_layers = {} for layer_name, value in in_exr_header['channels'].iteritems(): for pattern, replacement_name in layer_map.iteritems(): matches = re.search(r'{}'.format(pattern), layer_name, flags=re.IGNORECASE) if matches: match_data = matches.groupdict() if 'channel' in match_data.keys(): out_channel_name = replacement_name + '.' + match_data[ 'channel'] else: out_channel_name = replacement_name # insert rechanneld channel into header with old channel value out_exr_header['channels'].update({out_channel_name: value}) # store rechanneld layer with data matched_layers[out_channel_name] = in_exr_file.channel( layer_name) out_exr_file = OpenEXR.OutputFile(out_path, out_exr_header) # copy matched layers if matched_layers: out_exr_file.writePixels(matched_layers) out_exr_file.close() # stop time time_stop = time.time() # duration duration = round(time_stop - time_start) console.info('Finished rechannel of of {out_path} ({duration}s).'.format( out_path=os.path.basename(out_path), duration=duration))
def readOpenEXR(filename): """ Simple read function for an OpenEXR file Use of this function requires that the OpenEXR package be installed. :param filename: The name of the OpenEXR file :return channel_names: List of image channel names found in the OpenEXR file :return im_dict: All image data in a dictionary keyed by channel names or channel groups. Channels are grouped into RGB triplets if the channel names have the form prefix.R, prefix.G and prefix.B. All image data is returned as numpy arrays. :return header: OpenEXR header as a dictionary. """ import OpenEXR import Imath if not OpenEXR.isOpenExrFile(filename): raise IOError('OpenEXR file was not found, or file is not OpenEXR.') exr_file = OpenEXR.InputFile(filename) header = exr_file.header() # Returns a dict channel_names = header['channels'].keys() data_window = header['dataWindow'] size = (data_window.max.x - data_window.min.x + 1, data_window.max.y - data_window.min.y + 1) # Read all channels im_FLOAT = np.array([], dtype=np.float32) im_HALF = np.array([], dtype=np.float16) im_UINT = np.array([], dtype=np.uint32) im_dict = {} triplets = {} for i_chan, chan_name in enumerate(channel_names): pixel_type = str(header['channels'][chan_name]).split()[0] if pixel_type == 'FLOAT': imath_type = Imath.PixelType(Imath.PixelType.FLOAT) elif pixel_type == 'HALF': imath_type = Imath.PixelType(Imath.PixelType.HALF) elif pixel_type == 'UINT': imath_type = Imath.PixelType(Imath.PixelType.UINT) chan_data_str = exr_file.channel(chan_name, imath_type) if pixel_type == 'FLOAT': chan_data = np.fromstring(chan_data_str, dtype=np.float32).reshape((size[1], size[0])) if im_FLOAT.size == 0: im_FLOAT = chan_data else: im_FLOAT= np.dstack((im_FLOAT, chan_data)) elif pixel_type == 'HALF': chan_data = np.fromstring(chan_data_str, dtype=np.float16).reshape((size[1], size[0])) if im_HALF.size == 0: im_HALF = chan_data else: im_HALF = np.dstack((im_HALF, chan_data)) elif pixel_type == 'UINT': chan_data = np.fromstring(chan_data_str, dtype=np.uint32).reshape((size[1], size[0])) if im_UINT.size == 0: im_UINT = chan_data else: im_UINT = np.dstack((im_UINT, chan_data)) else: raise ValueError('Unknown image pixel type in OpenEXR file.') im_dict[chan_name] = chan_data rgbya = chan_name[-1] # red, green, blue, luminance, transparency prefix = chan_name.split('.')[0] if prefix == rgbya: prefix = 'rgb' if rgbya in 'RGB': if (prefix in triplets): triplets[prefix][rgbya] = chan_name else: triplets[prefix] = {rgbya: chan_name} for triplet in triplets: im_dict[triplet] = np.dstack((im_dict[triplets[triplet]['R']], im_dict[triplets[triplet]['G']], im_dict[triplets[triplet]['B']])) return channel_names, im_dict, header
def load_rgb(filePath): ''' Loads an rgb OpenEXR image.''' if oe.isOpenExrFile(filePath) is not True: raise Exception("File ", filePath, " does not exist!") try: ifi = oe.InputFile(filePath) # Compute size header = ifi.header() dw = header["dataWindow"] w, h = dw.max.x - dw.min.x + 1, dw.max.y - dw.min.y + 1 # Read the three channels ifiType = header["channels"]["R"].type.v if ifiType is not im.PixelType.UINT: raise Exception("Only uint32 supported! (file is type ", ifiType) R = ifi.channel("R", im.PixelType(ifiType)) G = ifi.channel("G", im.PixelType(ifiType)) B = ifi.channel("B", im.PixelType(ifiType)) ifi.close() image = np.zeros((h, w, 3), dtype = np.uint32) # order = "C" image[:, :, 0] = np.core.multiarray.fromstring(R, dtype = np.uint32).reshape(h, w) image[:, :, 1] = np.core.multiarray.fromstring(G, dtype = np.uint32).reshape(h, w) image[:, :, 2] = np.core.multiarray.fromstring(B, dtype = np.uint32).reshape(h, w) except: raise return image