image_imageview - CSDN
  • python的Image模块

    2018-07-10 14:19:43
    Image 模块Image 模块提供了同名的类用来表示PIL的图像。Image模块还提供了许多工厂(factory)函数,包块从文件加载图像的函数,以及创建新图像的函数。 例子 下面的脚本加载了一个图像,并把它旋转了45度,然后...
    原文链接: https://www.cnblogs.com/DjangoBlog/p/3557744.html
    Image 模块
    Image 模块提供了同名的类用来表示PIL的图像。Image模块还提供了许多工厂(factory)函数,包块从文件加载图像的函数,以及创建新图像的函数。 
     
    例子 
    下面的脚本加载了一个图像,并把它旋转了45度,然后调用外部的查看器(通常在Unix下是xv,Windows下是paint)。 
     
    打开,旋转,和显示图像(使用默认的查看器) 
     
    from PIL import Image 
    im = Image.open("bride.jpg") 
    im.rotate(45).show() 
    下面的脚本为当前目录下所以的JPEG图像创建漂亮128x128的缩略图。 
     创建缩略图 
     
    from PIL import Image 
    import glob, os 
     
    size = 128, 128 
     
    for infile in glob.glob("*.jpg"): 
        file, ext = os.path.splitext(infile) 
        im = Image.open(infile) 
        im.thumbnail(size, Image.ANTIALIAS) 
        im.save(file + ".thumbnail", "JPEG") 

    函数  new 

    Image.new(mode, size) => image 

    Image.new(mode, size, color) => image 

     
    以指定的模式和大小创建一个新图像。大小以2元元组的形式给出。给colour赋单个值,表示要创建单波段图像,元组表示创建多波段图像(每个波段一个值)。如果忽略colour参数,图像将以黑色填充。如果colour设为None,图像不会被初始化。 
     

    open 

    Image.open(infile) => image 

    Image.open(infile, mode) => image 

    打开并识别给定图像文件。这是一个偷懒的操作;真正的图像数据只有到处理的时候才会被读入(调用load函数强制加载)。如果给出了模式(mode)参数,它必须设为“r”。 
     
    要打开图像,即可以使用字符串(表示文件名)也可以使用文件对象。对后一种情况,文件对象必须实现了read,seek,和 tell 方法,并以二进制模式打开。 

    blend 

    Image.blend(image1, image2, alpha) => image 

     通过使用alpha常量,在图像进行差值操作,创建新图像。两个图像必须具有相同的大小和模式。 
     out = image1 * (1.0 - alpha) + image2 * alpha 
    (注:没有成功) 
    如果设置alpha为0.0,将返回第一个图像的拷贝。如果设置alpha为1.0,将返回第二个图像的拷贝。对alpha的值没有限制。必要的话,结果会被剪裁,以适合允许的输出范围。 

     composite 

    Image.composite(image1, image2, mask) => image 

     使用遮罩(mask)作为alpha,通过在两个图像之间进行插值来创建一个新图像。遮罩图像的模式可以是“1”,“L”,或者“RGBA”。所有的图像的大小必须有相同。 

     eval 

    Image.eval_r(image, function) => image 

     把函数(function)(应该接收一个参数)应用到所给图像的每一个像素。如果图像有多个波段,相同的函数会应用到每一个波段。注意,该函数对每一个可能的像素值只计算一次,所有不能使用随机组件(components)或者其它发生器(generators)。 

     frombuffer 

    Image.frombuffer(mode, size, data) => image 

     (PIL1.1.4添加)。使用标准的“raw”解码器,把来自字符串或者缓冲区(buffer)对象的图像数据创建为一个图像内存(image memory)。对于某些模式,图像内存会和原来的缓冲区共享内存(这意味着对原始缓冲区对象的修改会影响图像)。不是所有的模式都能共享内存;支持共享内存的模式包括:“L”,“RGBX”,“RGBA”和“CMYK”。对其其它模式,这个函数的作用与fromstring函数类似。 
     
    注意:1.1.6版中,默认的方向与fromstring的不同。这些可能会在未来的版本中发生变化,所以为了最大的兼容性,建议在使用“raw”解码器的时候给出所有的参数。 
     
    im = Image.frombuffer(mode, size, data, "raw", mode, 0, 1)Image.frombuffer(mode, size, data, decoder, parameters) => image 
     
    与调用fromstring 相同。 

     fromstring 

    Image.fromstring(mode, size, data) => image 

     使用标准的“raw”解码器从来自字符串的像素数据创建一个图像内存。 
     
    Image.fromstring(mode, size, data, decoder, parameters) => image 
     
    也一样,但是允许你使用PIL支持的任何像素解码器。关于可用解码器的更多信息,参见Writing Your Own File Decoder节 
     
    注意,这个函数只对像素数据解码,而不是整个图像。如果字符串中包含了一个完整的图像文件,可以使用StringIO对象对它进行处理,并使用open函数加载图像。 

     merge 

    Image.merge(mode, bands) => image 

     从几个单波段图像创建一个新图像。bands参数是包含图像的元组或列表,一个图像对应模式中描述的一个波段。所有波段的图像必须有相同的大小。 
     
    方法 
    一个Image类的实例具有下列方法。除非另外指出,所有的方法都返回一个新的Image类的实例,包含处理过的图像数据。 

     convert 

    im.convert(mode) => image 

    返回图像转换后的副本 
     
    如果原始图像是调色板图像,这个函数通过调色板转换像素。忽略mode参数,会自动选择一个模式,以保证所有的图像信息和调色板信息在没有调色板的时候也能表示出来。 
     
    从彩色图像转换到黑白图像时,图像库使用ITU-R 601-2 luma转换: 
     
        L = R * 299/1000 + G * 587/1000 + B * 114/1000在把图像转换为二值图(bilevel image)(模式“1”)时,源图像首先被转换为黑白图。然后在结果中,值大于127的像素点被设置为白色,图像抖动(and the image is dithered)。使用point方法可以改变阈值。 
     
    im.convert(mode, matrix) => image 
     
    使用转换矩阵,把一个 "RGB" 图像转换为 "L" 或者 "RGB" 图像。其中矩阵是一个4元或16元元组。 
     
    下面的例子把一个RGB图像转换(根据ITU-R 709进行线性校正,using the D65 luminant)到CIE XYZ颜色空间: 
     
    Convert RGB to XYZ 
         rgb2xyz = ( 
            0.412453, 0.357580, 0.180423, 0, 
            0.212671, 0.715160, 0.072169, 0, 
            0.019334, 0.119193, 0.950227, 0 ) 
        out = im.convert("RGB", rgb2xyz)

    copy 

    im.copy() => image 

     Copies the image. Use this method if you wish to paste things into an image, but still retain the original.复制图像。如果你想往图像上粘贴东西,但是又保持源图像不变可以使用这个函数。  

    crop 

    im.crop(box) => image 

    返回当前图像的一个矩形区域。box参数是一个定义了左,上,右,下像素坐标的4元元组。 
     
    这是一个投篮操作。改变源图像可能会也可能不会影响剪裁的图像。要得到一个单独的拷贝,可以在剪裁的副本上应用load函数。 

     draft 

    im.draft(mode, size)  

    配置图像文件加载器,使它返回一个与给定模式和大小尽可能匹配的图像。比如,你可以在加载的时候,把一个彩色的JPEG图像转换为一个灰度图,或者从一个PCD文件中提取出一个128x192的版本。 
     
    注意这个方法在适当的时候修改图像对象。如果图像已经加载了,这个方法可能无效。 

     filter 

    im.filter(filter) => image 

    Returns a copy of an image filtered by the given filter. For a list of available filters, see the ImageFilter module. 
     

    fromstring 

    im.fromstring(data)  

    im.fromstring(data, decoder, parameters)  
    Same as the fromstring function, but loads data into the current image.  

    getbands 

    im.getbands() => tuple of strings  

    Returns a tuple containing the name of each band. For example, getbands on an RGB image returns ("R", "G", "B"). 

     getbbox 

    im.getbbox() => 4-tuple or None 
     
    Calculates the bounding box of the non-zero regions in the image. The bounding box is returned as a 4-tuple defining the left, upper, right, and lower pixel coordinate. If the image is completely empty, this method returns None. 

     getcolors 

    im.getcolors() => a list of (count, color) tuples or None 
    im.getcolors(maxcolors) => a list of (count, color) tuples or None 
     
    (New in 1.1.5) Returns an unsorted list of (count, color) tuples, where the count is the number of times the corresponding color occurs in the image. 
     
    If the maxcolors value is exceeded, the method stops counting and returns None. The default maxcolors value is 256. To make sure you get all colors in an image, you can pass in size[0]*size[1] (but make sure you have lots of memory before you do that on huge images). 

     getdata 

    im.getdata() => sequence 
     
    Returns the contents of an image as a sequence object containing pixel values. The sequence object is flattened, so that values for line one follow directly after the values of line zero, and so on. 
     
    Note that the sequence object returned by this method is an internal PIL data type, which only supports certain sequence operations, including iteration and basic sequence access. To convert it to an ordinary sequence (e.g. for printing), use list(im.getdata()).  

    getextrema 

    im.getextrema() => 2-tuple 
     
    Returns a 2-tuple containing the minimum and maximum values of the image. In the current version of PIL, this is only applicable to single-band images.  

    getpixel 

    im.getpixel(xy) => value or tuple 
     
    Returns the pixel at the given position. If the image is a multi-layer image, this method returns a tuple. 
     
    Note that this method is rather slow; if you need to process larger parts of an image from Python, you can either use pixel access objects (see load), or the getdata method.  

    histogram 

    im.histogram() => list 
     
    Returns a histogram for the image. The histogram is returned as a list of pixel counts, one for each pixel value in the source image. If the image has more than one band, the histograms for all bands are concatenated (for example, the histogram for an "RGB" image contains 768 values). 
     
    A bilevel image (mode "1") is treated as a greyscale ("L") image by this method. 
     
    im.histogram(mask) => list 
     
    Returns a histogram for those parts of the image where the mask image is non-zero. The mask image must have the same size as the image, and be either a bi-level image (mode "1") or a greyscale image ("L"). 

    load 

    im.load() 
     
    Allocates storage for the image and loads it from the file (or from the source, for lazy operations). In normal cases, you don't need to call this method, since the Image class automatically loads an opened image when it is accessed for the first time. 
     
    (New in 1.1.6) In 1.1.6 and later, load returns a pixel access object that can be used to read and modify pixels. The access object behaves like a 2-dimensional array, so you can do: 
     
    pix = im.load() 
    print pix[x, y] 
    pix[x, y] = value 
    Access via this object is a lot faster than getpixel and putpixel.  

    offset 

    im.offset(xoffset, yoffset) => image 
     
    (Deprecated) Returns a copy of the image where the data has been offset by the given distances. Data wraps around the edges. If yoffset is omitted, it is assumed to be equal to xoffset. 
     
    This method is deprecated. New code should use the offset function in the ImageChops module.  

    paste 

    im.paste(image, box) 
     
    Pastes another image into this image. The box argument is either a 2-tuple giving the upper left corner, a 4-tuple defining the left, upper, right, and lower pixel coordinate, or None (same as (0, 0)). If a 4-tuple is given, the size of the pasted image must match the size of the region. 
     
    If the modes don't match, the pasted image is converted to the mode of this image (see the convert method for details). 
     
    im.paste(colour, box) 
     
    Same as above, but fills the region with a single colour. The colour is given as a single numerical value for single-band images, and a tuple for multi-band images. 
     
    im.paste(image, box, mask) 
     
    Same as above, but updates only the regions indicated by the mask. You can use either "1", "L" or "RGBA" images (in the latter case, the alpha band is used as mask). Where the mask is 255, the given image is copied as is. Where the mask is 0, the current value is preserved. Intermediate values can be used for transparency effects. 
     
    Note that if you paste an "RGBA" image, the alpha band is ignored. You can work around this by using the same image as both source image and mask. 
     
    im.paste(colour, box, mask) 
     
    Same as above, but fills the region indicated by the mask with a single colour.  

    point 

    im.point(table) => image 
     
    im.point(function) => image 
     
    Returns a copy of the image where each pixel has been mapped through the given table. The table should contains 256 values per band in the image. If a function is used instead, it should take a single argument. The function is called once for each possible pixel value, and the resulting table is applied to all bands of the image. 
     
    If the image has mode "I" (integer) or "F" (floating point), you must use a function, and it must have the following format: 
     
        argument * scale + offsetExample: 
     
        out = im.point(lambda i: i * 1.2 + 10)You can leave out either the scale or the offset. 
     
    im.point(table, mode) => image 
     
    im.point(function, mode) => image 
     
    Map the image through table, and convert it on fly. This can be used to convert "L" and "P" images to "1" in one step, e.g. to threshold an image. 
     
    (New in 1.1.5) This form can also be used to convert "L" images to "I" or "F", and to convert "I" images with 16-bit data to "L". In the last case, you must use a 65536-item lookup table.  

    putalpha 

    im.putalpha(band) 
     
    Copies the given band to the alpha layer of the current image. 
     
    The image must be an "RGBA" image, and the band must be either "L" or "1". 
     
    (New in PIL 1.1.5) You can use putalpha on other modes as well; the image is converted in place, to a mode that matches the current mode but has an alpha layer (this usually means "LA" or "RGBA"). Also, the band argument can be either an image, or a colour value (an integer).  

    putdata 

    im.putdata(data) 
     
    im.putdata(data, scale, offset) 
     
    Copy pixel values from a sequence object into the image, starting at the upper left corner (0, 0). The scale and offset values are used to adjust the sequence values: 
     
        pixel = value * scale + offsetIf the scale is omitted, it defaults to 1.0. If the offset is omitted, it defaults to 0.0. 

    putpalette 

    im.putpalette(sequence) 
     
    Attach a palette to a "P" or "L" image. The palette sequence should contain 768 integer values, where each group of three values represent the red, green, and blue values for the corresponding pixel index. Instead of an integer sequence, you can use an 8-bit string. 

    putpixel 

    im.putpixel(xy, colour) 
     
    Modifies the pixel at the given position. The colour is given as a single numerical value for single-band images, and a tuple for multi-band images. 
     
    Note that this method is relatively slow. If you're using 1.1.6, pixel access objects (see load) provide a faster way to modify the image. If you want to generate an entire image, it can be more efficient to create a Python list and use putdata to copy it to the image. For more extensive changes, use paste or the ImageDraw module instead. 
     
    You can speed putpixel up a bit by "inlining" the call to the internal putpixel implementation method: 
     
        im.load() 
        putpixel = im.im.putpixel 
        for i in range(n): 
           ... 
           putpixel((x, y), value) 
    In 1.1.6, the above is better written as: 
     
        pix = im.load() 
        for i in range(n): 
            ... 
            pix[x, y] = value 
     
    resize 
    im.resize(size) => image 
     
    im.resize(size, filter) => image 
     
    Returns a resized copy of an image. The size argument gives the requested size in pixels, as a 2-tuple: (width, height). 
     
    The filter argument can be one of NEAREST (use nearest neighbour), BILINEAR (linear interpolation in a 2x2 environment), BICUBIC (cubic spline interpolation in a 4x4 environment), or ANTIALIAS (a high-quality downsampling filter). If omitted, or if the image has mode "1" or "P", it is set to NEAREST. 

     rotate 

    im.rotate(angle) => image 
     
    im.rotate(angle, filter=NEAREST, expand=0) => image 
     
    Returns a copy of an image rotated the given number of degrees counter clockwise around its centre. 
     
    The filter argument can be one of NEAREST (use nearest neighbour), BILINEAR (linear interpolation in a 2x2 environment), or BICUBIC (cubic spline interpolation in a 4x4 environment). If omitted, or if the image has mode "1" or "P", it is set to NEAREST. 
     
    The expand argument, if true, indicates that the output image should be made large enough to hold the rotated image. If omitted or false, the output image has the same size as the input image. 

     save 

    im.save(outfile, options...) 
     
    im.save(outfile, format, options...) 
     
    Saves the image under the given filename. If format is omitted, the format is determined from the filename extension, if possible. This method returns None. 
     
    Keyword options can be used to provide additional instructions to the writer. If a writer doesn't recognise an option, it is silently ignored. The available options are described later in this handbook. 
     
    You can use a file object instead of a filename. In this case, you must always specify the format. The file object must implement the seek, tell, and write methods, and be opened in binary mode. 
     
    If the save fails, for some reason, the method will raise an exception (usually an IOError exception). If this happens, the method may have created the file, and may have written data to it. It's up to your application to remove incomplete files, if necessary. 

     seek 

    im.seek(frame) 
     
    Seeks to the given frame in a sequence file. If you seek beyond the end of the sequence, the method raises an EOFError exception. When a sequence file is opened, the library automatically seeks to frame 0. 
     
    Note that in the current version of the library, most sequence formats only allows you to seek to the next frame. 

     show 

    im.show() 
     
    Displays an image. This method is mainly intended for debugging purposes. 
     
    On Unix platforms, this method saves the image to a temporary PPM file, and calls the xv utility. 
     
    On Windows, it saves the image to a temporary BMP file, and uses the standard BMP display utility to show it. 
     
    This method returns None.  

    split 

    im.split() => sequence 
     
    Returns a tuple of individual image bands from an image. For example, splitting an "RGB" image creates three new images each containing a copy of one of the original bands (red, green, blue). 

     tell 

    im.tell() => integer 
    Returns the current frame number.  

    thumbnail 

    im.thumbnail(size)  
    im.thumbnail(size, filter) 
     
    Modifies the image to contain a thumbnail version of itself, no larger than the given size. This method calculates an appropriate thumbnail size to preserve the aspect of the image, calls the draft method to configure the file reader (where applicable), and finally resizes the image. 
     
    The filter argument can be one of NEAREST, BILINEAR, BICUBIC, or ANTIALIAS (best quality). If omitted, it defaults to NEAREST. 
     
    Note that the bilinear and bicubic filters in the current version of PIL are not well-suited for thumbnail generation. You should use ANTIALIAS unless speed is much more important than quality. 
     
    Also note that this function modifies the Image object in place. If you need to use the full resolution image as well, apply this method to a copy of the original image. This method returns None.  

    tobitmap 

    im.tobitmap() => string 
     
    Returns the image converted to an X11 bitmap.  

    tostring 

    im.tostring() => string  
    Returns a string containing pixel data, using the standard "raw" encoder.  
    im.tostring(encoder, parameters) => string  
    Returns a string containing pixel data, using the given data encoding.  

    transform 

    im.transform(size, method, data) => image  
    im.transform(size, method, data, filter) => image 
     
    Creates a new image with the given size, and the same mode as the original, and copies data to the new image using the given transform. 
     
    In the current version of PIL, the method argument can be EXTENT (cut out a rectangular subregion), AFFINE (affine transform), QUAD (map a quadrilateral to a rectangle), or MESH (map a number of source quadrilaterals in one operation). The various methods are described below. 
     
    The filter argument defines how to filter pixels from the source image. In the current version, it can be NEAREST (use nearest neighbour), BILINEAR (linear interpolation in a 2x2 environment), or BICUBIC (cubic spline interpolation in a 4x4 environment). If omitted, or if the image has mode "1" or "P", it is set to NEAREST. 
     
    im.transform(size, EXTENT, data) => image 
     
    im.transform(size, EXTENT, data, filter) => image 
     
    Extracts a subregion from the image. 
     
    Data is a 4-tuple (x0, y0, x1, y1) which specifies two points in the input image's coordinate system. The resulting image will contain data sampled from between these two points, such that (x0, y0) in the input image will end up at (0,0) in the output image, and (x1, y1) at size. 
     
    This method can be used to crop, stretch, shrink, or mirror an arbitrary rectangle in the current image. It is slightly slower than crop, but about as fast as a corresponding resize operation. 
     
    im.transform(size, AFFINE, data) => image 
     
    im.transform(size, AFFINE, data, filter) => image 
     
    Applies an affine transform to the image, and places the result in a new image with the given size. 
     
    Data is a 6-tuple (a, b, c, d, e, f) which contain the first two rows from an affine transform matrix. For each pixel (x, y) in the output image, the new value is taken from a position (a x + b y + c, d x + e y + f) in the input image, rounded to nearest pixel. 
     
    This function can be used to scale, translate, rotate, and shear the original image. 
     
    im.transform(size, QUAD, data) => image 
     
    im.transform(size, QUAD, data, filter) => image 
     
    Maps a quadrilateral (a region defined by four corners) from the image to a rectangle with the given size. 
     
    Data is an 8-tuple (x0, y0, x1, y1, x2, y2, y3, y3) which contain the upper left, lower left, lower right, and upper right corner of the source quadrilateral. 
     
    im.transform(size, MESH, data) image => image 
     
    im.transform(size, MESH, data, filter) image => image 
     
    Similar to QUAD, but data is a list of target rectangles and corresponding source quadrilaterals. 

     transpose 

    im.transpose(method) => image 
     
    Returns a flipped or rotated copy of an image. 
     
    Method can be one of the following: FLIP_LEFT_RIGHT, FLIP_TOP_BOTTOM, ROTATE_90, ROTATE_180, or ROTATE_270.  

    verify 

    im.verify() 
     
    Attempts to determine if the file is broken, without actually decoding the image data. If this method finds any problems, it raises suitable exceptions. This method only works on a newly opened image; if the image has already been loaded, the result is undefined. Also, if you need to load the image after using this method, you must reopen the image file. 
     

    Attributes 

    Instances of the Image class have the following attributes:  

    format 

    im.format => string or None 
     
    The file format of the source file. For images created by the library, this attribute is set to None.  

    mode 

    im.mode => string 
     
    Image mode. This is a string specifying the pixel format used by the image. Typical values are "1", "L", "RGB", or "CMYK."  

    size 

    im.size => (width, height) 
     
    Image size, in pixels. The size is given as a 2-tuple (width, height).  

    palette 

    im.palette => palette 
    展开全文
  • image

    2019-03-12 13:14:36
  • 内核编译(make)之后会生成两个文件,一个Image,一个zImage,其中Image为内核映像文件,而zImage为内核的一种映像压缩文件,Image大约为4M,而zImage不到2M。 那么uImage又是什么的? 它是uboot专用的映像文件...

    内核编译(make)之后会生成两个文件,一个Image,一个zImage,其中Image为内核映像文件,而zImage为内核的一种映像压缩文件,Image大约为4M,而zImage不到2M。

    那么uImage又是什么的?
    它是uboot专用的映像文件,它是在zImage之前加上一个长度为64字节的“头”,说明这个内核的版本、加载位置、生成时间、大小等信息;其0x40之后与zImage没区别。

    如何生成uImage文件?
    首先在uboot的/tools目录下寻找mkimage文件,把其copy到系统/usr/local/bin目录下,这样就完成制作工具。然后在内核目录下运行make uImage,如果成功,便可以在arch/arm/boot/目录下发现uImage文件,其大小比zImage多64个字节。

    其实就是一个自动跟手动的区别,有了uImage头部的描述,u-boot就知道对应Image的信息,如果没有头部则需要自己手动去搞那些参数。
    U-boot的U是“通用”的意思。
    zImage是ARM Linux常用的一种压缩映像文件,uImage是U-boot专用的映像文件,它是在zImage之前加上一个长度为0x40的“头”,说明这个映像文件的类型、加载位置、生成时间、大小等信息。换句话说,如果直接从uImage的0x40位置开始执行,zImage和uImage没有任何区别。另外,Linux2.4内核不支持uImage,Linux2.6内核加入了很多对嵌入式系统的支持,但是uImage的生成也需要设置,这个以后我会介绍。


    几种linux内核文件的区别:
    1、vmlinux  编译出来的最原始的内核文件,未压缩。
    2、zImage   是vmlinux经过gzip压缩后的文件。
    3、bzImage bz表示“big zImage”,不是用bzip2压缩的。两者的不同之处在于,zImage解压缩内核到低端内存(第一个640K),bzImage解压缩内核到高端内存(1M以上)。如果内核比较小,那么采用zImage或bzImage都行,如果比较大应该用bzImage。
    4、uImage   U-boot专用的映像文件,它是在zImage之前加上一个长度为0x40的tag。
    5、vmlinuz  是bzImage/zImage文件的拷贝或指向bzImage/zImage的链接。
    6、initrd   是“initial ramdisk”的简写。一般被用来临时的引导硬件到实际内核vmlinuz能够接管并继续引导的状态

          一般情况下都在生成 vmlinux 后,再对内核进行压缩成为 zImage,压缩的目录是 
    kernel/arch/arm/boot。 
         下载到 flash 中的是压缩后的 zImage 文件, zImage 是由压缩后的 vmlinux 和解压缩程序组成,如下图所示: 

    查看 2410 的 datasheet ,发现内存映射的基址是 0x3000 0000 ,那么 0x30008000 又是如何来的呢? 
    在内核文档 kernel/Document/arm/Booting 文件中有: 
    Calling the kernel image 
    Existing boot loaders: MANDATORY 
    New boot loaders: MANDATORY 
    There are two options for calling the kernel zImage. If the zImage is stored in flash, and is linked correctly to be run 
    from flash, then it is legal for the boot loader to call the zImage in flash directly. 
    The zImage may also be placed in system RAM (at any location) and called there. Note that the kernel uses 16K of 
    RAM below the image to store page tables. The recommended placement is 32KiB into RAM. 
    看来在 image 下面用了 32K(0x8000)的空间存放内核页表, 

    0x30008000 就是 2410 的内核在 RAM 中的启动地址,这个地址就是这么来的。 


    用U-Boot启动Linux内核
    1、下载u-boot.bin到SDRAM的0x30008000处
    tftp 0x30008000 uImage
    2、启动内核
    bootm 0x30008000

     

     

     


    from: http://blog.sina.com.cn/s/blog_4a70d5d901012jxp.html

    展开全文
  • 区别:imshow将图像以原始尺寸显示,image和imagesc则会对图像进行适当的缩放(显示出来的尺寸大小)。2、显示灰度图像说明:先搞明白什么是索引图像?(灰度图像也是索引图像的一种) 当用Matlab中的imread函数将...

    1、显示RGB图像

    相同点:这三个函数都是把m*n*3的矩阵中的数值当做RGB值来显示的。

    区别:imshow将图像以原始尺寸显示,image和imagesc则会对图像进行适当的缩放(显示出来的尺寸大小)。

    2、显示灰度图像

    说明:先搞明白什么是索引图像?(灰度图像也是索引图像的一种)

      当用Matlab中的imread函数将图像读入并存入矩阵时,我们知道如果是RGB图像,得到是m*n*3的矩阵,但如果是索引图像,得到就是m*n的矩阵,这个矩阵的每个元素只是1个数值,那么怎么确定它的RGB值来显示图像呢?这就需要colormap了,colormap是一个m*3的矩阵,每一行有3列元素构成RGB组,也就是一种颜色,一个m*3的colormap中有m中颜色,而索引图像存储的数值和colormap中的行号对应起来就可以像RGB那样显示图片了,至于对应方法,可以直接对应(比如1对应1,2对应2)也可以是线性映射对应(比如[-128,128]映射到[1,256])。还有一点要说明的是,默认情况下每一个figure都有且仅有一个colormap,而且默认的是 jet(64),可在figure窗口通过,edit->colormap...查看,另外在弹出的窗口colormap editor中,可通过Tools->Standard colormap来修改当前figure的colormap,这里是Matlab已经做好的一些colormap。

    (1)当灰度图像转化成矩阵后,矩阵中的元素都介于[0,255],下面我们结合具体实例来看看这三个函数的调用效果,并解释原因。代码:

    1. clear all;clc;close all;  
    2. img = imread('lenna.bmp');  
    3. % my picture is named lenna.bmp while yours may be not  
    4. I = rgb2gray(img);  
    5. % Attention: we use the axis off to get rid of the axis.  
    6. figure(1),image(I); %equals to imagesc(I,[1 64]);you can try it.  
    7. colorbar,title('show by image in figure1');axis off;  
    8. figure(2),imagesc(I);  
    9. %equals to imagesc(I,[min(I(:)) max(I(:))]);you can try it.  
    10. colorbar,title('show by imagesc in figure2');axis off;  
    11. %colormap(gray) %use this statement you can get a gray image.  
    12. figure(3),imshow(I),colorbar,title('show by imshow in figure3');  

    显示效果:




         我们看到现象是image 和imagesc 显示出来是彩色的,只有imshow显示出来是灰度图像,为什么会出现这种情况呢?还记得前面所说的吗,索引图像是矩阵和colormap配合起来显示的,而每个figure默认使用的colormap jet(64),而不是gray(graygray(64)是一样的),这个jet(64)就使得figure1figure2中显示出来时是彩色的,当然你也可以修改当前figurecolormap使用colormap(gray)(使用64个等级的灰度色图),或者colormap(gray(256))(使用256个等级的灰度色图,这就是调用imshow函数时使用的colormap,后面有讲解)。而figure3为什么会是灰度图像呢,这是因为当调用imshow来显示索引图像时,这个函数就会把当前的figurecolormap设置成gray(256),这下明白为什么会出现这种情况了吧。我们再仔细观察一下figure1figure2会发现,figure2中人物的轮廓显示的还算可以,而figure1中则出现了大面积的红色的区域,人物的轮廓被抹掉了很多。

    为什么会出现这样的情况呢?这就要说说索引图像矩阵中的数(以下简称矩阵中的数)和colormap中的索引(index)的对应关系了。


    image这个函数,直接把矩阵中的数当做索引值(我称为直接映射),例如colormap中索引为1的是颜色RGB1,索引为2的是颜色RGB2,……,索引为64的是颜色RGB64。那么矩阵中为1的数就显示成颜色RGB1,矩阵中为2的数就显示成颜色RGB2,……,矩阵中为64的数就显示成颜色RGB64,值得注意的是当矩阵中的数小于1时,此时该数也将被显示成颜色RGB1,同样,而矩阵中大于64的数将被显示成颜色RGB64(类似于信号处理里面的限幅,也可以认为是削顶或者削底了),这下我们就能明白为什么figure1中会出现大面积的红色区域,这说明这些地方的数值都大于等于64

     

    imagesc: figure2中我们用imagesc来显示图像与figure1相比能较好的显示出来,同样我们也得搞明白调用imagesc时矩阵的数和colormap中索引的对应关系,与image不同的是imagesc采用的不是直接映射而是线性映射,至于什么是线性映射,我粗略的说一下,比如把区间A = [0,a]映射到区间B = [0,b]我们对A中的元素做A/a*b就可以了,矩阵的数到colormap索引的线性映射大概就是这样,Matlab会自动获取矩阵中数的最小值和最大值,并把区间[Cmin,Cmax]映射到colormap[最小索引,最大索引]比如[1,64],然后再根据这个对应关系把图像显示出来,具体的算法细节是Matlab确定的,当然也可以自己指定显示范围,比如一副索引图像I范围为[27,218],而我只想显示[1 64 ],使用命令imagesc(I,[1 64])就可以了,如果你把上面程序中的imagesc(I)换成imagesc(I,[1,64]),那么figure2中的效果就和figure1中一样了,因为只是把[1,64]这个范围映射到色图,超过的都被认为是64。关于映射,我截图Matlabimageschelp页给大家看看,这里要自己慢慢体会哦,使用imagesc(I)这种线性映射就可以用到整个色图从而将图像较好的显示出来,这就是figure2中的显示效果比figure1中好的原因。



    imshow调用这个函数会把当前figurecolormap设置成gray256,这个前面也有提到,我们先讨论矩阵元素是uint8型(范围:0~255,整数,一般使用imread和 rgb2gray返回的都是uint8型的),同样我们也要搞明白矩阵中的数和colormap中颜色索引的对应关系,imshow的功能是比较全的,它即可使用像image那样的直接映射,也可使用像imagesc那样的线性映射,当我们使用imshow(I),即只有一个矩阵作为参数,这时采用的是直接映射,比如矩阵中元素0就显示成colormap中索引为1的颜色也就是黑色,矩阵中元素255就显示成colormap中索引为256的颜色也就是白色,(注意:uint8范围是0~255,而gray256)的索引是1:256,当然这些我们只要了解就可以了,编程并不会用到,因为这些对应的细节Matlab已经帮我们做好了)如果这样调用imshow(I,[ ])此时矩阵中的数和颜色表就是线性映射,为什么会这样,我解释一下,我们看这种调用方式和imagesc(I,[1 64])很相似,其实原理是一样的,第二个参数是一个向量,这个向量指定了矩阵中映射到颜色表的数的范围,也就是显示范围(Matlab里叫做display range前面已经介绍了,Matlabimshowhelp中说如果采用imshow(I,[low high])调用imshow的话而且你用[ ]代替[low high]那么imshow会使用[min(I(:)) max(I(:))]作为显示范围,也就说I中的最小值会显示成黑色,最大值会显示成白色,这其实就是整个范围的线性映射(没有削顶也没有削底),此时的imshow(I,[ ])函数就相当于imagesc(I);


    为了说明imshow不仅具有image的功能也具有imagesc的功能,同时体会一下直接映射和线性映射的区别,我们来写一段小程序来测试一下,程序如下:

    1. clear all;clc;close all;  
    2. img = imread('lenna.bmp');  
    3.    
    4. I = rgb2gray(img);  
    5.    
    6. figure(1),image(I); colormap(gray(256));  
    7. colorbar,title('show by image in figure1');axis off;  
    8. figure(2),imagesc(I);colormap(gray(256));  
    9. % We can see that the image showed in figure(2) is a little bright  
    10. % than in figure(1).  
    11. colorbar,title('show by imagesc in figure2');axis off;  
    12. % When we use the imshow, we do not need to set the colormap,  
    13. % because the imshow set the colormap to gray(256) automatically.  
    14. figure(3),imshow(I),colorbar,title('show by imshow(I) in figure3');  
    15. % The effectiveness in figure(3) is the same as in figure(1).  
    16. figure(4),imshow(I,[]),colorbar,title('show by imshow(I,[]) in figure3');  
    17. % The effectiveness in figure(4) is the same as in figure(2).  

    显示效果:





    我们可以看出figure2中的图像比figure1中的图像要亮一些,而且,figure3中的显示效果和figure1中是一样的,figure4中的显示效果和figure2中是一样的,为什么会这样呢?这是因为image(I)imshow(I)是将I中的值直接作为colormap(gray(256))中的索引,也就是我所说的直接映射,我这里读到的索引图像矩阵也就是I中的数值的范围是[27,218],也就是说直接映射显示I,只用到的色图(colormap)[27,218]范围的颜色,(比如表示白色的索引255就没有用到),从右边的colorbar也可以看出来。但线性映射就不一样了,imagesc(I),imshow(I,[ ])采用的就是线性映射,线性映射把[27,218]按照线性算法(Matlab写的)映射到色图索引[1,256]然后再显示出来,这样整个色图的颜色都被用到了,这里也可以认为把[27,218]放大到[1,256],这就是figure2中显示效果比figure1中亮的原因。


    小结:直接映射和线性映射的区别在于映射到色图的数值范围,如果是[min(I(:)) max(I(:))]就是线性映射,如果是0-255或者1-64或者0-1就是直接映射。这个数值范围就叫做显示范围(display range)。


    3、最后再说说imageimagesc,imshow 在显示double型数据时的用法,

    我们做图像处理就会对图像进行运算,使用uint8型数据精度不高,因为当运算结果超过255时会被认为是255,而负数就会被认为是0注意在Matlab中数据默认采用double型(64位)进行存储和运算)所以,我们读到灰度图像后一般都会将图像转换成double型(I = double(I))然后再参与运算,运算的结果有正有负,也有小数,正的还可能超过255,比如我经过运算后的得到图像矩阵I,假如I的范围是[-187,152],当然你也可以用max(I(:))min(I(:))去获取,这时怎么显示图像呢?image,imagesc,imshow 都可以用来显示double型数据的图像矩阵,主要区别如下:

    imagedouble型数据取整(正数取整就是把小数部分舍掉)然后使用直接映射的方法按照颜色表显示。

    imagesc这个函数很好,会对数据进行缩放再显示,也就是把显示范围自动设置成[min(I(:)) max(I(:))],也就是线性  映射。

    imshow:这个函数调用方式不同,显示效果也不同,如下:

    imshow(I)直接调用,因为当图像为double型时imshow函数会把显示范围设置成[0 , 1],这样小于0的就变成黑色了,大于1的就变成白色了,所以处理不当就会出现全白的情况。

    imshow( I/(max(I(:)))针对直接调用imshow函数出现的问题,用max(I(:) ) 对图像矩阵进行归一化再显示,这样负数部分会变黑,正数部分还可以正常显示,但有一部分信息丢失了。

    imshow(uint8(I))这种方式把I转化成uint8,负数会被归零,超过255的被置为255,而且小数也会被round(四舍五),当参数为uint8型时,imshow函数把显示范围设置成[0,255],这样图像虽然也能显示出来,但与原始数据相比来说,丢掉很多信息,但有时可能却是想要的结果,这个要看具体情况。

    imshow(I,[ ])这种方式就是把imshow的显示范围设置成[min(I(:)) max(I(:))],也就是线性映射,相当于imagesc(I),colormap(gray(256))可以将整幅图像的信息显示出来。


    综上所述,大家根据自己实际需要选用显示函数和对应的参数,这些是我自己研究学习的心得,表述难免有些疏漏,有发现严重错误的,可以给我留言,但可以给大家一个感性的认识,从云里雾里的困境里走出来。


    展开全文
  • Pillow的使用-Image

    2018-05-07 17:37:26
    Image.open(fp, mode =’r’ ):打开图片文件,返回一个Image对象 fp:图片路径 mode:模式。如果给出,必须是r from PIL import Image im = Image.open(path) Image.alpha_composite(im1, im2):在im1对象.....
  • 微信文件夹下imageimage2是微信表情图片的缓存文件夹,emoji是表情,然后还有很多个类似1a,1b,1c为这样的文件夹,每个文件夹下面也有很多这样的文件夹。 这两个目录里自动保存了微信聊天记录中的表情图片、微信...
  • Image模块 Image模块是在Python PIL图像处理中常见的模块,对图像进行基础操作的功能基本都包含于此模块内。如open、save、conver、show…等功能。 open类 Image.open(file) ⇒ image Image.open(file, ...
  • Python图像库PIL(Python Image Library)是python的第三方图像处理库,但是由于其强大的功能与众多的使用人数,几乎已经被认为是python官方图像处理库了。其官方主页为:PIL。 PIL历史悠久,原来是只支持python2.x的...
  • 原文地址:http://yaxin-cn.github.io/Docker/how-to-delete-a-docker-image.htmldocker中删除images的命令是docker rmi,但有时候执行此命令并不能删除images[yaxin@ubox ~]$docker ...REPOSITORY TAG IMAGE ID ...
  • Flutter Widgets: Image

    2018-07-27 07:36:44
    介绍 类结构 构造方法 属性值 child
  • js的 new image()

    2013-12-24 10:28:27
    Image对象。  创建一个Image对象:var a=new Image();  定义Image对象的src: a.src=”xxx.gif”;  这样做就相当于给浏览器缓存了一张图片  或由new Image()创建的元素都具有onload、onerror、onabort三个事件...
  • src="/image/arrowright.png" 这句就是加载本地图片资源的。想想iOS中的加载本地图片,imageName:,类似。 加载网络图片 微信在加载网络这方面封装的还是很好的,包括语音和视频的加载。直接给'src'这个属性附上...
  • Image模块方法16-25) 16、  Paste 定义1:im.paste(image,box) 含义1:将一张图粘贴到另一张图像上。变量box或者是一个给定左上角的2元组,或者是定义了左,上,右和下像素坐标的4元组,或者为空(与(0,0...
  • 三、Image类的方法 除非另作说明,Image类的所有方法都将返回一个Image类的新实例,这个实例对应于结果图像。 1、  Convert 定义1:im.convert(mode)⇒ image 含义1:将当前图像转换为其他模式,并且返回新的...
  • 传统的图形学和视觉的研究方法,主要还是基于数学和物理的...在图形学和视觉交叉的领域,一系列问题的研究正在围绕深度学习火热展开,特别是在图像编辑(image editing)和图像生成(image generation)方面,已经初见成...
  • Image组件是UGUI里最常用的组件(可能没有之一),我们知道其实还有一个RawImage组件。那么二者的区别是什么呢?之前的文章UGUI内核大探究(八)MaskableGraphic中我们提到过,二者(连同Label)都继承自...
  • vue cli3配置image-webpack-loader对图片进行压缩优化 安装 npm install image-webpack-loader --save-dev 配置vue.config.js chainWebpack: config => { config.plugins.delete('prefetch') config.plugin('...
  • CSS background-image属性

    2017-12-08 21:50:15
    CSS背景图片的background-image就是这样一位牛人,它一登场肯定也会加“特技”。下面我们来看看它的“特技”;background-image属性值模式background-image的属性值模式就是用来给它加“特技”的。它的值模式有: ...
  • WPF中显示图片的控件为Image控件。以下分别介绍显示图片文件和内存位图的使用方法,主要介绍如何赋予Image对象的Source属性值。 (一)使用图片文件 方式一: <Image Width="320" Source="...
  • 通常我们使用 background-image 标签时, url 的值无非就以下几种: 先说上面的第三种: @/assets/media/hd.jpg 会提示文件不存在,编译报错 /assets/media/hd.jpg 不会提示报错,但是实际在开发页面不会显示...
1 2 3 4 5 ... 20
收藏数 1,468,650
精华内容 587,460
关键字:

image