精华内容
下载资源
问答
  • PNG转换RGBA.exe

    2019-07-29 19:11:52
    因为本人用的是MCU,没使用linux或者andriod等系统,要做图片的透明叠加效果,在网上各种找PNG转565rgba和888rgba的工具软件,找了好久都一直找不到,实在没办法自己写了一个,用在本人的实际项目中。可以选择转换成...
  • ios 修改图片png图片rgba通道

    千次阅读 2018-04-10 17:15:05
    很早之前ios开发用到的图片处理的方法,美工只给了一张png图然后用来用来做一个蒙层的+(UIImage*)imageToClear:(UIImage*) anImage{ CGImageRef imageRef = anImage.CGImage; size_t width = CGImageGetWidth...

    很早之前ios开发用到的图片处理的方法,美工只给了一张png图然后用来用来做一个蒙层的

    +(UIImage*)imageToClear:(UIImage*) anImage

    {

        CGImageRef imageRef = anImage.CGImage;

        size_t width  = CGImageGetWidth(imageRef);  //获取图片像素的宽

        size_t height = CGImageGetHeight(imageRef); //获取图片像素的高

        size_t bitsPerComponent = CGImageGetBitsPerComponent(imageRef);

        size_t bitsPerPixel = CGImageGetBitsPerPixel(imageRef);

        size_t bytesPerRow = CGImageGetBytesPerRow(imageRef);

        CGColorSpaceRef colorSpace = CGImageGetColorSpace(imageRef);

        CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);

        bool shouldInterpolate = CGImageGetShouldInterpolate(imageRef);

        CGColorRenderingIntent intent = CGImageGetRenderingIntent(imageRef);

        CGDataProviderRef dataProvider = CGImageGetDataProvider(imageRef);

        CFDataRef data = CGDataProviderCopyData(dataProvider);

        UInt8 *buffer = (UInt8*)CFDataGetBytePtr(data);

        

        NSUInteger  x, y;

        for (y = 0; y < height; y++) {

            for (x = 0; x < width; x++) {

                UInt8 *tmp;  //UInt8 8位无符号整型  

                tmp = buffer + y * bytesPerRow + x * 4;  //每个像素4个通道  *4代表下一个像素

                

                UInt8 alpha;

                 alpha= *(tmp+3);  //rgba  alpha通道排第四个

                if(alpha>0)    //下面这个 意思是只要图片上的色素都是非纯透明的  都改成纯白色,否则还是纯透明

                {

                    *(tmp+3)=255;              

                    *(tmp + 0) = 255;

                    *(tmp + 1) = 255;

                    *(tmp + 2) = 255;

                }else

                {

                    *(tmp+3)=0;     

                    *(tmp + 0) = 0;

                    *(tmp + 1) = 0;

                    *(tmp + 2) = 0;

                }

                

            }

        }


    //生成图片返回

        CFDataRef effectedData = CFDataCreate(NULL, buffer, CFDataGetLength(data));

        CGDataProviderRef effectedDataProvider = CGDataProviderCreateWithCFData(effectedData);

        CGImageRef effectedCgImage = CGImageCreate(

                                                   width, height,

                                                   bitsPerComponent, bitsPerPixel, bytesPerRow,

                                                   colorSpace, bitmapInfo, effectedDataProvider,

                                                   NULL, shouldInterpolate, intent);

        UIImage *effectedImage = [[UIImage alloc] initWithCGImage:effectedCgImage];

        CGImageRelease(effectedCgImage);

        CFRelease(effectedDataProvider);

        CFRelease(effectedData);

        CFRelease(data);

        return effectedImage ;

        

    }



    注:如果上述处理的图片是网路下载下来的 或者sd_webimage down下来的  处理图片alpha通道之前建议先把图片存到cache 否则可能会崩  

    存图片的代码如下:


    #define HOME_PATH NSHomeDirectory()

    #define LIBRARY_PATH    [HOME_PATH stringByAppendingPathComponent:@"Library/Caches"]


    +(UIImage *)saveImageWithImage:(UIImage*)image WithString:(NSString *)nameString

    {

        NSData *imageData = UIImagePNGRepresentation(image);

        NSString *fileName = [NSString stringWithFormat:@"%@.png", nameString];

        NSString *picPath=[NSString stringWithFormat:@"%@/%@",LIBRARY_PATH,fileName];

        if([[NSFileManager defaultManager]fileExistsAtPath:picPath])

        {

            [[NSFileManager defaultManager]removeItemAtPath:picPath error:nil];

        }

        [[NSFileManager defaultManager] createFileAtPath:picPath contents:imageData attributes:nil];

        

        NSData* newData = [NSData dataWithContentsOfFile:picPath];

        UIImage *image3=[UIImage imageWithData:newData];

        return image3;


    }


    展开全文
  • PNG图像RGBA转索引色

    千次阅读 2016-01-21 14:56:56
    RGBA 转 索引色 的思路有很多种,这里说一种我目前已经用 nodejs 实现的,这个思路是自己摸索出来的,感觉效果还可以。  以下是大概的思路,实际写的时候还是有些细节差别的。  1. 先不考虑 alpha ,把 RGB 想象...

           RGBA 转 索引色 的思路有很多种,这里说一种我目前已经用 nodejs 实现的,这个思路是自己摸索出来的,感觉效果还可以。

           以下是大概的思路,实际写的时候还是有些细节差别的。

           1. 先不考虑 alpha ,把 RGB 想象成一个三维色彩空间,三个坐标轴分别为 R、G、B ,颜色值从 0 - 255,这样我们就得到了一个 256 x 256 x 256 的立方体。

           2. 把每个轴以 16 等分,这样就可以得到  16 x 16 x 16 个小格子

           3. 把所有的颜色分别归入这些格子中

           4. 排序所有格子

           5. 每个格子占比 p = 格子中的颜色数/总的颜色数

           6. 每个格子可以分得的颜色个数为 num = 256 x p

           7. 然后把每个小格子等分,等分的标准为,len = Math.ceil(Math.pow(num,1/3)) ,那么这个小格子可以分为 len x len x len 个更小的格子

           8. 把 16 x 16 x 16 格子中的颜色再放入这些更小的格子中

           9. 这些更小的格子的颜色取所有颜色的重心。 (R的和/个数,G的和/个数,B的和/个数)

          10. 每个小格子按照占比再分得一定数量的颜色数(类似上面的 p)

          11. 每个小格子中还要考虑 alpha,然后把 alpha 等分一下,等分的标准为 len = Math.ceil(Math.sqrt(小格子分得的颜色个数))

          12. 然后把 alpha 的分段按照每个段的颜色个数排序一下,把颜色分给排名靠前的

          

          得到调色板后把颜色转为最靠近的颜色,参考了下 PS 里在颜色差得地方有些噪点,所以我加了个随机。在有色差(一个点与周围的点的颜色有差别)的时候加一个随机颜色(取颜色差最小的两个随机一个)

         上一段用 nodejs 写的 RGBA 转 索引色

            var useColor = {};
            /**
             * 计算立方体中的像素分配情况
             * @param cubic
             */
            var doCubic = function (moreCount) {
                if (cubicList.length == 0) {
                    return;
                }
                var cubic = cubicList.shift();
                var cubicCount = Math.round(allCount * cubic.percent);
                if (allCount && !cubicCount) {
                    cubicCount = 1;
                }
                cubic.count += cubicCount;
                cubic.count += moreCount;
                //已经没有可以分配的调色板颜色,则结束
                if (cubic.count == 0 && allCount == 0) {
                    return;
                }
                if (cubic.count > cubic.list.length) { //如果可分配的颜色数量大于实际颜色数
                    for (var i = 0; i < cubic.list.length; i++) {
                        var color = cubic.list[i];
                        if (useColor[color.a + "." + color.r + "." + color.g + "." + color.b]) continue;
                        plte.push(color.r << 16 | color.g << 8 | color.b);
                        trns.push(color.a);
                        cubic.count--;
                        allCount--;
                        useColor[color.a + "." + color.r + "." + color.g + "." + color.b] = true;
                    }
                } else {
                    //以分配了5个像素为例 : lenCount 为 3,len 为 10, more 为 32 - (3 - 2)*10
                    var lenCount = Math.ceil(Math.pow(cubic.count, 1 / 3));
                    var len = Math.floor(deviceCount / lenCount);
                    var smallCubicList = [];
                    var more = deviceCount - lenCount * len;
                    more = deviceCount - (lenCount - more) * len;
                    for (var r = cubic.r; r < cubic.r + deviceCount;) {
                        for (var g = cubic.g; g < cubic.g + deviceCount;) {
                            for (var b = cubic.b; b < cubic.b + deviceCount;) {
                                smallCubicList.push({r: r, g: g, b: b, list: [], count: 0});
                                b += len;
                                if (b < cubic.b + more) {
                                    b += 1;
                                }
                            }
                            g += len;
                            if (g < cubic.g + more) {
                                g += 1;
                            }
                        }
                        r += len;
                        if (r < cubic.r + more) {
                            r += 1;
                        }
                    }
                    //把立方体中所有颜色放入小格子中
                    var cubicColors = cubic.list;
                    for (var i = 0; i < cubicColors.length; i++) {
                        var cubicColor = cubicColors[i];
                        var index = -1;
                        var dis = 256 * 3;
                        for (var f = 0; f < smallCubicList.length; f++) {
                            var smallCubicColor = smallCubicList[f];
                            if (cubicColor.r >= smallCubicColor.r &&
                                cubicColor.g >= smallCubicColor.g &&
                                cubicColor.b >= smallCubicColor.b) {
                                var diff =
                                    Math.abs(cubicColor.r - smallCubicColor.r) +
                                    Math.abs(cubicColor.g - smallCubicColor.g) +
                                    Math.abs(cubicColor.b - smallCubicColor.b);
                                if (diff < dis) {
                                    dis = diff;
                                    index = f;
                                }
                            }
                        }
                        var smallCubicColor = smallCubicList[index];
                        smallCubicColor.list.push(cubicColor);
                    }
                    smallCubicList.sort(function (a, b) {
                        return a.list.length < b.list.length ? 1 : -1;
                    });
                    var smallCount = cubic.count;
                    for (var i = 0; i < smallCubicList.length; i++) {
                        var smallCubic = smallCubicList[i];
                        if (smallCubic.list.length * Math.pow(lenCount, 3) > cubic.list.length && smallCount) {
                            smallCubic.count = 1;
                            smallCount--;
                        }
                    }
                    var smallAllCount = cubic.list.length;
                    for (var i = 0; i < smallCubicList.length; i++) {
                        var smallCubic = smallCubicList[i];
                        if (smallCount == 0) {
                            break;
                        }
                        var addCount = Math.round(smallCubic.list.length * smallCount / smallAllCount);
                        if (addCount > smallCount) {
                            addCount = smallCount;
                        }
                        if (smallCount && addCount == 0) {
                            addCount = 1;
                        }
                        smallAllCount -= smallCubic.list.length;
                        smallCubic.count += addCount;
                        smallCount -= addCount;
                    }
                    var doSmallCubic = function (moreCount) {
                        if (smallCubicList.length == 0) {
                            return;
                        }
                        var smallCubic = smallCubicList.shift();
                        smallCubic.count += moreCount;
                        if (smallCubic.count == 0) {
                            return;
                        }
                        var smallColorListObject = {};
                        var smallColorList = [];
                        var alphaListObject = [];
                        var alphaList = [];
                        for (var i = 0; i < smallCubic.list.length; i++) {
                            var color = smallCubic.list[i];
                            if (smallColorListObject[color.a + "." + color.r + "." + color.g + "." + color.b]) {
                                continue;
                            }
                            smallColorListObject[color.a + "." + color.r + "." + color.g + "." + color.b] = true;
                            smallColorList.push(color);
                            if (alphaListObject[color.a]) {
                                continue;
                            }
                            alphaListObject[color.a] = true;
                            alphaList.push(color.a);
                        }
                        //如果小立方体内分配到的像素个数大于等于立方体内的像素个数
                        if (smallCubic.count >= smallColorList.length) {
                            for (var i = 0; i < smallColorList.length; i++) {
                                var color = smallColorList[i];
                                if (useColor[color.a + "." + color.r + "." + color.g + "." + color.b]) continue;
                                plte.push(color.r << 16 | color.g << 8 | color.b);
                                trns.push(color.a);
                                smallCubic.count--;
                                cubic.count--;
                                allCount--;
                                useColor[color.a + "." + color.r + "." + color.g + "." + color.b] = true;
                            }
                        } else {
                            var smallCubicColor = {r: 0, g: 0, b: 0};
                            for (var i = 0; i < smallCubic.list.length; i++) {
                                var color = smallCubic.list[i];
                                smallCubicColor.r += color.r;
                                smallCubicColor.g += color.g;
                                smallCubicColor.b += color.b;
                            }
                            smallCubicColor.r = Math.floor(smallCubicColor.r / smallCubic.list.length);
                            smallCubicColor.g = Math.floor(smallCubicColor.g / smallCubic.list.length);
                            smallCubicColor.b = Math.floor(smallCubicColor.b / smallCubic.list.length);
                            if (smallCubic.count >= alphaList.length) {
                                for (var i = 0; i < alphaList.length; i++) {
                                    if (useColor[alphaList[i] + "." + smallCubicColor.r + "." + smallCubicColor.g + "." + smallCubicColor.b]) continue;
                                    plte.push(smallCubicColor.r << 16 | smallCubicColor.g << 8 | smallCubicColor.b);
                                    trns.push(alphaList[i]);
                                    smallCubic.count--;
                                    cubic.count--;
                                    allCount--;
                                    useColor[alphaList[i] + "." + smallCubicColor.r + "." + smallCubicColor.g + "." + smallCubicColor.b] = true;
                                }
                            } else {
                                var smallLenCount = Math.ceil(Math.sqrt(smallCubic.count));
                                var smallLen = 256 / smallLenCount;
                                alphaList = [];
                                for (var i = 0; i < smallLenCount; i++) {
                                    alphaList[i] = {
                                        a: 0,
                                        count: 0
                                    }
                                }
                                for (var i = 0; i < smallCubic.list.length; i++) {
                                    var color = smallCubic.list[i];
                                    var colorIndex = Math.floor(color.a / smallLen);
                                    alphaList[colorIndex].a += color.a;
                                    alphaList[colorIndex].count++;
                                }
                                alphaList.sort(function (a, b) {
                                    return a.count < b.count ? 1 : -1;
                                });
                                for (var i = 0; i < alphaList.length; i++) {
                                    if (!smallCubic.count) {
                                        continue;
                                    }
                                    if (useColor[alphaList[i].a + "." + smallCubicColor.r + "." + smallCubicColor.g + "." + smallCubicColor.b]) continue;
                                    plte.push(smallCubicColor.r << 16 | smallCubicColor.g << 8 | smallCubicColor.b);
                                    trns.push(alphaList[i].a);
                                    smallCubic.count--;
                                    cubic.count--;
                                    allCount--;
                                    useColor[alphaList[i].a + "." + smallCubicColor.r + "." + smallCubicColor.g + "." + smallCubicColor.b] = true;
                                }
                            }
                        }
                        doSmallCubic(smallCubic.count);
                    };
                    doSmallCubic(0);
                }
                doCubic(cubic.count);
            }
            doCubic(0);
            var plte2 = [];
            for (var i = 0; i < plte.length; i++) {
                var color = plte[i];
                var a = trns[i];
                var r = color >> 16 & 0xFF;
                var g = color >> 8 & 0xFF;
                var b = color & 0xFF;
                plte2.push({a: a, r: r, g: g, b: b});
            }
            var per = 0;
            for (var y = 0; y < h; y++) {
                datas[y] = [];
                for (var x = 0; x < w; x++) {
                    var color = colors[y][x];
                    if (color.a == 0) {
                        datas[y][x] = 0;
                    } else {
                        var index = -1;
                        var dis = 256 * 4;
                        for (var i = 0; i < plte2.length; i++) {
                            var diff = Math.abs(plte2[i].a - color.a) +
                                Math.abs(plte2[i].r - color.r) +
                                Math.abs(plte2[i].g - color.g) +
                                Math.abs(plte2[i].b - color.b);
                            if (diff < dis) {
                                dis = diff;
                                index = i;
                                if (dis == 0) {
                                    break;
                                }
                            }
                        }
                        var compareIndexs = [
                                [-2, -2], [-1, -2], [0, -2], [1, -2], [2, -2],
                                [-2, -1], [-1, -1], [0, -1], [1, -1], [2, -1],
                                [-2, 0], [-1, 0], [1, 0], [2, 0],
                                [-2, 1], [-1, 1], [0, 1], [1, 1], [2, 1],
                                [-2, 2], [-1, 2], [0, 2], [1, 2], [2, 2]];
                        var different = false;
                        for (var i = 0; i < compareIndexs.length; i++) {
                            var cx = compareIndexs[i][0] + x;
                            var cy = compareIndexs[i][1] + y;
                            if (cx < 0 || cy < 0 || cx >= w || cy >= h) {
                                continue;
                            }
                            var compareColor = colors[cy][cx];
                            if (Math.abs(compareColor.a - color.a) > 1 ||
                                Math.abs(compareColor.r - color.r) > 1 ||
                                Math.abs(compareColor.g - color.g) > 1 ||
                                Math.abs(compareColor.b - color.b) > 1) {
                                different = true;
                                break;
                            }
                        }
                        if (different) {
                            var index2 = -1;
                            var dis2 = 256 * 4;
                            for (var i = 0; i < plte2.length; i++) {
                                var diff = Math.abs(plte2[i].a - color.a) +
                                    Math.abs(plte2[i].r - color.r) +
                                    Math.abs(plte2[i].g - color.g) +
                                    Math.abs(plte2[i].b - color.b);
                                if (diff < dis2 && diff != dis) {
                                    dis2 = diff;
                                    index2 = i;
                                }
                            }
                            if (dis && Math.abs(dis - dis2) < 10) {
                                datas[y][x] = [index, index2][Math.floor(Math.random() * 2)];
                            } else {
                                datas[y][x] = index;
                            }
                        } else {
                            datas[y][x] = index;
                        }
                    }
                }
                if (Math.floor(y * 100 / h) != per) {
                    per = Math.floor(y * 100 / h);
                    //console.log(per + "%");
                }
            }
            //console.log(plte.length, trns.length);
            return {
                plte: plte, //调色板数组
                trns: trns, //调色板透明度数组
                colors: datas //转换后的颜色
            };
        }



    展开全文
  • PIL将pngRGBA四通道改为jpg的RGB三通道方法

    万次阅读 多人点赞 2019-01-02 15:36:52
    将一张png图像使用PIL读入的时候,发现是一个四通道图像,即:RGBA,分别代表Red(红色)Green(绿色)Blue(蓝色)和Alpha的色彩空间。其中Alpha通道一般用做透明度参数,这就是为啥透明图像都保存成了png格式。 ...

    将一张png图像使用PIL读入的时候,发现是一个四通道图像,即:RGBA,分别代表Red(红色)Green(绿色)Blue(蓝色)和Alpha的色彩空间。其中Alpha通道一般用做透明度参数,这就是为啥透明图像都保存成了png格式。
    那么如果将4通道的png图像读入成jpg格式的3通道呢?
    使用PIL可以使用 Image.convert(" ") 的方法

    from PIL import Image
    
    img = Image.open('test.png')
    # 将一个4通道转化为rgb三通道
    img = img.convert("RGB")
    

    PIL包含九种不同模式:1,L,P,RGB,RGBA,CMYK,YCbCr,I,F
    使用Image.convert(),可以在这九中模式中进行切换。
    模式1为二值图像,非黑即白。
    模式L为灰度图像。
    RGB就是通常说的三原色。
    RGBA就是上例上的在三原色的基础上增加了一个alpha通道。
    不过我使用了cv2,进行数据读取的时候,使用:
    cv.imread(‘test.png’, 1) 直接返回的就是 RGB 三通道。

    展开全文
  • 获取PNG图片的RGBA

    千次阅读 2014-03-20 18:09:59
    先看这篇文章,关于pnglib的入门讲解 下面贴上源代码(在VC 6.0下编译通过): #include "stdafx.h" #include #include "png.h" #include typedef struct {  

    http://www.cnblogs.com/mr-wid/archive/2013/04/19/3029842.html

    先看这篇文章,关于pnglib的入门讲解


    下面贴上源代码(在VC 6.0下编译通过):

    #include "stdafx.h"
    #include <stdio.h>
    #include "png.h"
    #include <stdlib.h>


    typedef struct {
        unsigned char* pixelData;
        int imageWidth;
        int imageHeight;
    }ImageInfo; 


    typedef struct {
        unsigned char* data;
        int size;
        int offset;
    }ImageSource;


    ImageInfo*  decodePNGFromFile(char* fileName)
    {
        char png_header[8];
        png_structp png_ptr;
        png_infop info_ptr;
        int width, height, rowBytes;
        png_byte color_type; 
        png_byte bit_depth;
        png_colorp palette;


        /* open file and test for it being a png */
        FILE *file = fopen(fileName, "rb");
        fread(png_header, 1, 8, file);
        if(png_sig_cmp((png_bytep)png_header, 0, 8))
        {
            //TFC_DEBUG("Not a PNG file...");
            fclose(file);
        }
        /* initialise structures for reading a png file */
        png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
        info_ptr = png_create_info_struct(png_ptr);
        if (setjmp(png_jmpbuf(png_ptr)))
        {
            png_destroy_read_struct(&png_ptr, &info_ptr, 0);
            //TFC_DEBUG("ReadPngFile: Failed to read the PNG file");
            fclose(file);
        }
        //I/O initialisation methods
        png_init_io(png_ptr, file);
        png_set_sig_bytes(png_ptr, 8);  //Required!!!




        /* **************************************************
        * The high-level read interface in libpng (http://www.libpng.org/pub/png/libpng-1.2.5-manual.html)
        * **************************************************
        */
          png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_EXPAND, 0);
          width = info_ptr->width;
          height = info_ptr->height;
          unsigned char* rgba = new unsigned char[width * height * 4];  //each pixel(RGBA) has 4 bytes
          png_bytep* row_pointers = png_get_rows(png_ptr, info_ptr);


          //Original PNG pixel data stored from top-left corner, BUT OGLES Texture drawing is from bottom-left corner
          //int pos = 0;
          //for(int row = 0; row < height; row++)
          //{
              //for(int col = 0; col < (4 * width); col += 4)
              //{
                  //rgba[pos++] = row_pointers[row][col];    // red
                  //rgba[pos++] = row_pointers[row][col + 1]; // green
                  //rgba[pos++] = row_pointers[row][col + 2]; // blue
                  //rgba[pos++] = row_pointers[row][col + 3]; // alpha
              //}
          //}




          //unlike store the pixel data from top-left corner, store them from bottom-left corner for OGLES Texture drawing...
          int pos = (width * height * 4) - (4 * width);
          for(int row = 0; row < height; row++)
          {
              for(int col = 0; col < (4 * width); col += 4)
              {
                  rgba[pos++] = row_pointers[row][col];        // red
                  rgba[pos++] = row_pointers[row][col + 1]; // green
                  rgba[pos++] = row_pointers[row][col + 2]; // blue
                  rgba[pos++] = row_pointers[row][col + 3]; // alpha
              }
              pos=(pos - (width * 4)*2); //move the pointer back two rows
          }


        ImageInfo* imageInfo = (ImageInfo*)malloc(sizeof(ImageInfo));
        imageInfo->pixelData = rgba;
        imageInfo->imageHeight = height;
        imageInfo->imageWidth = width;


        //clean up after the read, and free any memory allocated
        png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
        fclose(file);
        return imageInfo;
    }


    int main(int argc,char* argv[]){
    printf("start!\n");
    ImageInfo* aaa;
    aaa = decodePNGFromFile("test.png");
    printf("imageInfo width:%d \n",aaa->imageWidth);
    printf("imageInfo height:%d \n",aaa->imageHeight);
    printf("imageInfo pixelData:%d \n",aaa->pixelData[0]);
    printf("imageInfo pixelData:%d \n",aaa->pixelData[1]);
    printf("imageInfo pixelData:%d \n",aaa->pixelData[2]);
    printf("imageInfo pixelData:%d \n",aaa->pixelData[3]);


    FILE *stream;
    stream = fopen("test.txt","w+");

    //这里i=3,i=i+4,因为我这里只需要用到alpha值,所以rgb被忽略掉
    for(int i=3;i<aaa->imageWidth * aaa->imageHeight * 4;i=i+4){
    printf("wade%d:%d \n",i,aaa->pixelData[i]);
    fprintf(stream,"%d\n",aaa->pixelData[i]);
    }


    fclose(stream);


    return 0;
    }

    展开全文
  • PyPngnq 是一种量化RGBA格式PNG图片的工具 安装 你需要先安装 libpng,安装 PyPngnq: Debian: apt-get install libpng-dev -y FreeBSD: cd /usr/ports/graphics/png make install clean 安装 PyPngnq: ...
  • nodejs PNG 格式解析

    千次阅读 2016-01-19 16:18:55
     网上很多相关的资料,基本的东西都没有错, PNG 格式分为很多个块,有几个必须的块,还有一些扩展块。以下就我遇到的一些问题说说我自己的理解和遇到的一些问题:    一 是否所有的程序都支持 PNG 的全部功能? ...
  • Java png图片修改像素rgba

    千次阅读 2018-06-18 16:07:29
    ImageIO.write(bufferedImage, "png", new File("D:\\2.png")); } catch (Exception e) { e.printStackTrace(); } } public static boolean comp(int r,int g,int b) {//判断二值化为黑还是白,true为白,...
  • ffmpeg将rgba数据转成png图片

    千次阅读 2018-01-17 11:19:16
    最近在做热区图分析,需要对视频中的一些热区信息产生热区图...2.用ffmepg将rgba数据生成png图(主要讲这部分内容); 具体实现代码如下: bool save_pic(AVFrame *frm, AVPixelFormat pfmt, AVCodecID cid, c
  • Stream #0:0, 2, 1/25: Video: png, 1 reference frame, rgba(pc), 580x820 [SAR 2835:2835 DAR 29:41], 1/25, 25 tbr, 25 tbn, 25 tbc Output #0, image2, to '/home/neusoft/baijd/scale_test/62-output.png': ...
  • 在学习 PNG 的编码规范,看了 PNG文件结构分析,大概知道图像的数据储存在 IDAT 数据块里,不过不是原始数据,而是对其采用 ...这是我测试的 PNG 图像:图像大小是2*3像素,像素 RGBA 值如下:#eb6100ff #22ac38ff #...
  • RGBA图像格式

    千次阅读 2019-12-21 12:19:34
    RGBA是代表Red(红色)Green(绿色)Blue(蓝色)和Alpha的色彩空间。 alpha通道一般用作不透明度参数。如果一个像素的alpha通道数值为0%,那它就是完全透明的(也就是看不见的),而数值为100%则意味着一个完全...
  • rgba2png 用于从单独图像的特定颜色通道生成 PNG 的 OSX 实用程序应用程序(例如 image1.rgb + image2.a = image3.rgba)。 用例: 在 3D 着色器中,使用纹理的各种颜色通道来存储单独的信息是很常见的。 根据您...
  • PNG格式 可移植的C99文件和标头,可将PNG文件转储为不依赖项的原始RGBA像素。 该界面包含一个功能。 它是什么? tPNG的目标之一是:检索原始像素以立即使用而不会麻烦。 标头包含一个函数的一个定义,该定义返回32...
  • 首先进行科普的是,png格式与普通的图像格式有何不同。 最直观的感受就是,相比于其他格式png格式多了一个alpha通道,用来存储透明度信息,像素位置 img(x,y) 取值255为不透明,取值为0则为透明。这就使得png具有...
  • <p>I have an image file, ... I have successfully been able to read the header, however, I need a way to save the raw RGBA as PNG format and/or GIF. How can I do that in PHP?</p> <p>cheers </div>
  • FFMPEG之图片系列 --- png格式

    千次阅读 2017-07-07 23:34:46
    在ffmpeg中,即支持png格式文件,也支持apng格式文件,下面就这两种区别做一描述: 在libavcodec/allcodecs.c中 定义了png和apng的encoder和decoder. REGISTER_ENCDEC (PNG, png); # ff_png_encoder in ...
  • 将Image对像转换为png格式的byte数组

    千次阅读 2017-04-10 17:59:32
    2将ARGB转换成PNG存储用的的RGBA格式 3RGBA格式的数据还要做些小的处理每行后面加一个byte 0 4用LZ77方法将RGBA格式的数组压缩 5附加正确格式PNG24文件头输出即可包括IHEAD IHDR IEND IDAT外壳 但是使用LZ77压缩...
  • 1.纯黑白的处理就简单多了,所有像素设置成RGBA(1,1,1, (R+G+B)/3) 即可。2.多彩色的图片,不能使用纯黑白的处理,否则所有图都会变成黑白,其原理是找出原像素点中RGB分量中最高的值 maxV =Max(R,G,B),一般其透明...
  • PNG格式图片原理

    万次阅读 2016-05-27 15:38:02
    便携式网络图型( Portable Network Graphics [PNG])在过去几十年已经变成App开发里重要的组成部分。它广泛的运用在游戏开发、网页开发和Android开发里,但也可能被大量的滥用。
  • RGBA 图片格式转换 RGB 无损

    千次阅读 2018-10-09 16:50:10
    拿到的图片是webp格式的,然后系统无法处理。只能使用google code的dwebp工具,把图片转成png或者jpg的。 这一步是ok了。 但是转成的图片是RGBA的,系统只能处理RGB。。。 报了下面的错: java.lang....
  • python将PNG格式的图片转化成为jpg

    千次阅读 2019-02-27 11:13:00
    """ 先来说一下jpg图片和png图片的区别 jpg格式:是有损图片... png格式:不是压缩性,能保存透明等图 """ from PIL import Image import cv2 as cv import os def PNG_JPG(PngPath): img = cv.imread...
  • base64,' ”可以在页面上显示图片,但是文件仍然不是png格式 _this.downLoadImage(_this._img)//这一步,将文件转成png格式 _this.tupxs = true }) }, //base64格式转换png downLoadImage...
  • 所以需要将大量的.pvr.ccz图集文件转换为png文件,并保留使用原来的.plist文件。 如果使用TexturePacker客户端打开.pvr.ccz文件,然后在点击[文件>保存]命令,一个一个保存,实在太慢,毕竟一两千个....
  • Python 技术篇-用PIL库修改图片透明度实例演示,改变png图片色道为RGBA、RGB。 PIL 库可以设置图片透明度。 pip install pillow 安装了 pillow 库后就可以使用 PIL 库了。 我们都知道,图片是由无数个点组成的,300...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,502
精华内容 15,400
关键字:

png格式rgba