精华内容
下载资源
问答
  • 改变图片位深度 """ from PIL import Image import numpy as np import cv2 import os # 方法一: # 单张图片 # img = Image.open(r'C:\Users\znjt\Desktop\huhui\40051.jpg') # img = Image.fromarray(np.uint8...

    代码如下:

    """
    2020.09.26:alian
    改变图片的位深度
    """
    from PIL import Image
    import numpy as np
    import cv2
    import os
    
    
    #  方法一:
    # 单张图片
    # img = Image.open(r'C:\Users\znjt\Desktop\huhui\40051.jpg')
    # img = Image.fromarray(np.uint8(img))
    # t = img.convert('L')
    # img=Image.fromarray(np.uint8(t)*255)
    # img.save(r'C:\Users\znjt\Desktop\huhui\40051(8).jpg')
    
    # 批量转换图片位深度
    path = r'C:\Users\znjt\Desktop\huhui\test\\'
    save_path = r'C:\Users\znjt\Desktop\huhui\\'
    for i in os.listdir(path):
        img = Image.open(path+i)
        img = Image.fromarray(np.uint8(img))
        t = img.convert('L')
        img = Image.fromarray(np.uint8(t))  # *255
        img.save(save_path+i)
    
    
    # 方法二
    # img = cv2.imread(r'C:\Users\znjt\Desktop\huhui\40051.jpg')
    # img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # cv2.imwrite(r'C:\Users\znjt\Desktop\huhui\40051(8).jpg',img)
    

    笔者写了两种方法,都可以使用,转换结果如下所示:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 一个转换程序,可以将24位深度的BMP图片,转为16位深度图片
  • 该资源为图片位深度的转换可转为单色位图等,该实例有源码可做稍加修改使用!可供大家学习与借鉴,希望对大家有帮助
  • 比较清晰,但是我需要8位的gif图片,使用ImageIO进行gif格式转换以后能变成8位的2k大小的图片文件,但是字体特别不清楚,根本看不清,有没有没事比较好的能保留图片清晰的转化图片位深度的方法? ``` ImageIO...
  • 最近调用热敏打印机需要打印单色,位深度为1的bmp照片,找了半天网上都是半成品,最后实现了,先谢谢各位大神,整体还是很有帮助,但是还是有些差距。
  • 图片位深度解析

    千次阅读 2017-09-19 09:39:05
    计算机之所以能够显示颜色,是采用了一种称作“”( bit ) 的记数单位来记录所表示颜色的数据。当这些数据按照一定的 编排方式被记录在计算机中,就构成了一个数字图像的 计算机文件。“ ”( bit )是计算机存储器...

    转自http://baike.sogou.com/v53449609.htm?fromTitle=%E4%BD%8D%E6%B7%B1%E5%BA%A6

    计算机之所以能够显示颜色,是采用了一种称作“位”( bit ) 的记数单位来记录所表示颜色的数据。当这些数据按照一定的 编排方式被记录在计算机中,就构成了一个数字图像的 计算机文件。“ 位”( bit )是计算机存储器里的最小单元,它用来记录每一个 像素颜色的值。图像的色彩越丰富,“位”就越多。每一个像素在计算机中所使用的这种位数就是“位深度”。

    在记录数字图像的颜色时,计算机实际上是用每个像素需要的位深度来表示的。黑白二色的图像是数字图像中最简单的一种,它只有黑、白两种颜色,也就是说它的每个像素只有1位颜色,位深度是1,用2的一次幂来表示;考虑到位深度平均分给R, G, B和Alpha,而只有RGB可以相互组合成颜色。所以4位颜色的图,它的位深度是4,只有2的4次幂种颜色,即16种颜色或16种灰度等级 ) 。8位颜色的图,位深度就是8,用2的8次幂表示,它含有256种颜色 ( 或256种灰度等级 )。24位颜色可称之为真彩色,位深度是24,它能组合成2的24次幂种颜色,即:16777216种颜色 ( 或称千万种颜色 ),超过了人眼能够分辨的颜色数量。当我们用24位来记录颜色时,实际上是以2^(8×3),即红、绿、蓝 ( RGB ) 三基色各以2的8次幂,256种颜色而存在的,三色组合就形成一千六百万种颜色。

    展开全文
  • java 生成带logo、文本的二维码并修改图片位深度,不努力的程序员不是一个好的程序员
  • jpg图片位深度不同异常分析

    千次阅读 2018-09-04 17:18:00
    通为jpg图片,24和32位深度图片有什么不同呢?百度了一下发现,像素点有8、24、32. 24位深度图片像素点值只有r、g、b三个值。 32位深度图片像素点值有r、g、b、Alpha(透明度) 哈哈,知道原因。 ...

    最近进行图片目标识别时,遇到一个问题,同样jpg格式图片,加载报错,怀着求知的心态,进行研究对比。

    正常加载的图片信息,位深度24:

    e3a4be5ae620f00a5b184b6f668a3f8c40e.jpg

    非正常加载的图片信息,位深度32:

    a3f06eee6dce95ffc3dbb5fe2a36b690391.jpg

    通为jpg图片,24和32位深度图片有什么不同呢?百度了一下发现,像素点有8、24、32.

    24位深度图片像素点值只有r、g、b三个值。

    32位深度图片像素点值有r、g、b、Alpha(透明度)

    哈哈,知道原因。

    转载于:https://my.oschina.net/wangzonghui/blog/1942386

    展开全文
  • C# 图片 位深度处理

    千次阅读 2016-04-11 00:51:35
     // 扫描线的宽度,比实际图片要大  int offset = stride - width * 3; // 显示宽度与扫描线宽度的间隙  IntPtr ptr = bmpData.Scan0; // 获取bmpData的内存起始位置的指针  int scanBytesLength = ...
    using System;
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.IO;
    using System.Drawing;
    using System.Drawing.Imaging;
    using System.Runtime.InteropServices;

    namespace ConsoleApplication5
    {
        class Program
        {


            static void Main(string[] args)
            {



                Bitmap b = (Bitmap)Bitmap.FromFile(@"D:\Books\2223.jpg");





                Bitmap returnbit1 = RgbToGrayScale(b);

                Bitmap xxx = GTo2Bit(returnbit1);
                xxx.Save(@"D:\Books\XXXX1.jpg");


            }


            #region 灰度处理
            /// <summary>
            /// 将源图像灰度化,并转化为8位灰度图像。
            /// </summary>
            /// <param name="original"> 源图像。 </param>
            /// <returns> 8位灰度图像。 </returns>
            public static Bitmap RgbToGrayScale(Bitmap original)
            {
                if (original != null)
                {
                    // 将源图像内存区域锁定
                    Rectangle rect = new Rectangle(0, 0, original.Width, original.Height);
                    BitmapData bmpData = original.LockBits(rect, ImageLockMode.ReadOnly,
                            PixelFormat.Format24bppRgb);



                    // 获取图像参数
                    int width = bmpData.Width;
                    int height = bmpData.Height;
                    int stride = bmpData.Stride;  // 扫描线的宽度,比实际图片要大
                    int offset = stride - width * 3;  // 显示宽度与扫描线宽度的间隙
                    IntPtr ptr = bmpData.Scan0;   // 获取bmpData的内存起始位置的指针
                    int scanBytesLength = stride * height;  // 用stride宽度,表示这是内存区域的大小

                    // 分别设置两个位置指针,指向源数组和目标数组
                    int posScan = 0, posDst = 0;
                    byte[] rgbValues = new byte[scanBytesLength];  // 为目标数组分配内存
                    Marshal.Copy(ptr, rgbValues, 0, scanBytesLength);  // 将图像数据拷贝到rgbValues中
                    // 分配灰度数组
                    byte[] grayValues = new byte[width * height]; // 不含未用空间。
                    // 计算灰度数组

                    byte blue, green, red, YUI;



                    for (int i = 0; i < height; i++)
                    {
                        for (int j = 0; j < width; j++)
                        {

                            blue = rgbValues[posScan];
                            green = rgbValues[posScan + 1];
                            red = rgbValues[posScan + 2];
                            YUI = (byte)(0.229 * red + 0.587 * green + 0.144 * blue);
                            //grayValues[posDst] = (byte)((blue + green + red) / 3);
                            grayValues[posDst] = YUI;
                            posScan += 3;
                            posDst++;

                        }
                        // 跳过图像数据每行未用空间的字节,length = stride - width * bytePerPixel
                        posScan += offset;
                    }

                    // 内存解锁
                    Marshal.Copy(rgbValues, 0, ptr, scanBytesLength);
                    original.UnlockBits(bmpData);  // 解锁内存区域

                    // 构建8位灰度位图
                    Bitmap retBitmap = BuiltGrayBitmap(grayValues, width, height);
                    return retBitmap;
                }
                else
                {
                    return null;
                }
            }

            /// <summary>
            /// 用灰度数组新建一个8位灰度图像。
            /// </summary>
            /// <param name="rawValues"> 灰度数组(length = width * height)。 </param>
            /// <param name="width"> 图像宽度。 </param>
            /// <param name="height"> 图像高度。 </param>
            /// <returns> 新建的8位灰度位图。 </returns>
            private static Bitmap BuiltGrayBitmap(byte[] rawValues, int width, int height)
            {
                // 新建一个8位灰度位图,并锁定内存区域操作
                Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
                BitmapData bmpData = bitmap.LockBits(new Rectangle(0, 0, width, height),
                     ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed);

                // 计算图像参数
                int offset = bmpData.Stride - bmpData.Width;        // 计算每行未用空间字节数
                IntPtr ptr = bmpData.Scan0;                         // 获取首地址
                int scanBytes = bmpData.Stride * bmpData.Height;    // 图像字节数 = 扫描字节数 * 高度
                byte[] grayValues = new byte[scanBytes];            // 为图像数据分配内存

                // 为图像数据赋值
                int posSrc = 0, posScan = 0;                        // rawValues和grayValues的索引
                for (int i = 0; i < height; i++)
                {
                    for (int j = 0; j < width; j++)
                    {
                        grayValues[posScan++] = rawValues[posSrc++];
                    }
                    // 跳过图像数据每行未用空间的字节,length = stride - width * bytePerPixel
                    posScan += offset;
                }

                // 内存解锁
                Marshal.Copy(grayValues, 0, ptr, scanBytes);
                bitmap.UnlockBits(bmpData);  // 解锁内存区域

                // 修改生成位图的索引表,从伪彩修改为灰度
                ColorPalette palette;
                // 获取一个Format8bppIndexed格式图像的Palette对象
                using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
                {
                    palette = bmp.Palette;
                }
                for (int i = 0; i < 256; i++)
                {
                    palette.Entries[i] = Color.FromArgb(i, i, i);
                }
                // 修改生成位图的索引表
                bitmap.Palette = palette;


                return bitmap;
            }
            #endregion







            /// <summary>  
            /// 壓縮圖片 /// </summary>  
            /// <param name="fileStream">圖片流</param>  
            /// <param name="quality">壓縮質量0-100之間 數值越大質量越高</param>  
            /// <returns></returns>  
            private static byte[] CompressionImage(Bitmap file, long quality)
            {
                using (System.Drawing.Image img = (Image)file)
                {
                    using (Bitmap bitmap = new Bitmap(img))
                    {
                        //ImageCodecInfo CodecInfo = GetEncoder(img.RawFormat);
                        ImageCodecInfo CodecInfo = GetEncoderInfo("image/jpeg");
                        System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                        EncoderParameters myEncoderParameters = new EncoderParameters(1);
                        EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, quality);
                        myEncoderParameters.Param[0] = myEncoderParameter;
                        using (MemoryStream ms = new MemoryStream())
                        {
                            bitmap.Save(ms, CodecInfo, myEncoderParameters);
                            myEncoderParameters.Dispose();
                            myEncoderParameter.Dispose();
                            return ms.ToArray();
                        }
                    }
                }
            }


            private static ImageCodecInfo GetEncoderInfo(String mimeType)
            {
                int j;
                ImageCodecInfo[] encoders;
                encoders = ImageCodecInfo.GetImageEncoders();
                for (j = 0; j < encoders.Length; ++j)
                {
                    if (encoders[j].MimeType == mimeType)
                        return encoders[j];
                }
                return null;
            }



            #region 二值化
            /*
    1位深度图像 颜色表数组255个元素 只有用前两个 0对应0  1对应255
    1位深度图像每个像素占一位
    8位深度图像每个像素占一个字节  是1位的8倍
    */
            /// <summary>
            /// 将源灰度图像二值化,并转化为1位二值图像。
            /// </summary>
            /// <param name="bmp"> 源灰度图像。 </param>
            /// <returns> 1位二值图像。 </returns>
            public static Bitmap GTo2Bit(Bitmap bmp)
            {
                if (bmp != null)
                {
                    // 将源图像内存区域锁定
                    Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
                    BitmapData bmpData = bmp.LockBits(rect, ImageLockMode.ReadOnly,
                            PixelFormat.Format8bppIndexed);

                    // 获取图像参数
                    int leng, offset_1bit = 0;
                    int width = bmpData.Width;
                    int height = bmpData.Height;
                    int stride = bmpData.Stride;  // 扫描线的宽度,比实际图片要大
                    int offset = stride - width;  // 显示宽度与扫描线宽度的间隙
                    IntPtr ptr = bmpData.Scan0;   // 获取bmpData的内存起始位置的指针
                    int scanBytesLength = stride * height;  // 用stride宽度,表示这是内存区域的大小
                    if (width % 32 == 0)
                    {
                        leng = width / 8;
                    }
                    else
                    {
                        leng = width / 8 + (4 - (width / 8 % 4));
                        if (width % 8 != 0)
                        {
                            offset_1bit = leng - width / 8;
                        }
                        else
                        {
                            offset_1bit = leng - width / 8;
                        }
                    }

                    // 分别设置两个位置指针,指向源数组和目标数组
                    int posScan = 0, posDst = 0;
                    byte[] rgbValues = new byte[scanBytesLength];  // 为目标数组分配内存
                    Marshal.Copy(ptr, rgbValues, 0, scanBytesLength);  // 将图像数据拷贝到rgbValues中
                    // 分配二值数组
                    byte[] grayValues = new byte[leng * height]; // 不含未用空间。
                    // 计算二值数组
                    int x, v, t = 0;
                    for (int i = 0; i < height; i++)
                    {
                        for (x = 0; x < width; x++)
                        {
                            v = rgbValues[posScan];
                            t = (t << 1) | (v > 100 ? 1 : 0);


                            if (x % 8 == 7)
                            {
                                grayValues[posDst] = (byte)t;
                                posDst++;
                                t = 0;
                            }
                            posScan++;
                        }

                        if ((x %= 8) != 7)
                        {
                            t <<= 8 - x;
                            grayValues[posDst] = (byte)t;
                        }
                        // 跳过图像数据每行未用空间的字节,length = stride - width * bytePerPixel
                        posScan += offset;
                        posDst += offset_1bit;
                    }

                    // 内存解锁
                    Marshal.Copy(rgbValues, 0, ptr, scanBytesLength);
                    bmp.UnlockBits(bmpData);  // 解锁内存区域

                    // 构建1位二值位图
                    Bitmap retBitmap = twoBit(grayValues, width, height);
                    return retBitmap;
                }
                else
                {
                    return null;
                }
            }

            /// <summary>
            /// 用二值数组新建一个1位二值图像。
            /// </summary>
            /// <param name="rawValues"> 二值数组(length = width * height)。 </param>
            /// <param name="width"> 图像宽度。 </param>
            /// <param name="height"> 图像高度。 </param>
            /// <returns> 新建的1位二值位图。 </returns>
            private static Bitmap twoBit(byte[] rawValues, int width, int height)
            {
                // 新建一个1位二值位图,并锁定内存区域操作
                Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format1bppIndexed);
                BitmapData bmpData = bitmap.LockBits(new Rectangle(0, 0, width, height),
                     ImageLockMode.WriteOnly, PixelFormat.Format1bppIndexed);

                // 计算图像参数
                int offset = bmpData.Stride - bmpData.Width / 8;        // 计算每行未用空间字节数
                IntPtr ptr = bmpData.Scan0;                         // 获取首地址
                int scanBytes = bmpData.Stride * bmpData.Height;    // 图像字节数 = 扫描字节数 * 高度
                byte[] grayValues = new byte[scanBytes];            // 为图像数据分配内存

                // 为图像数据赋值
                int posScan = 0;                        // rawValues和grayValues的索引
                for (int i = 0; i < height; i++)
                {
                    for (int j = 0; j < bmpData.Width / 8; j++)
                    {
                        grayValues[posScan] = rawValues[posScan];
                        posScan++;
                    }
                    // 跳过图像数据每行未用空间的字节,length = stride - width * bytePerPixel
                    posScan += offset;
                }

                // 内存解锁
                Marshal.Copy(grayValues, 0, ptr, scanBytes);
                bitmap.UnlockBits(bmpData);  // 解锁内存区域

                // 修改生成位图的索引表
                ColorPalette palette;
                // 获取一个Format8bppIndexed格式图像的Palette对象
                using (Bitmap bmp = new Bitmap(1, 1, PixelFormat.Format1bppIndexed))
                {
                    palette = bmp.Palette;
                }
                for (int i = 0; i < 2; i = +254)
                {
                    palette.Entries[i] = Color.FromArgb(i, i, i);
                }
                // 修改生成位图的索引表
                bitmap.Palette = palette;

                return bitmap;
            }
            #endregion

        }   


     
        }

    展开全文
  • 关于修改ico图片位深度的方法

    千次阅读 2014-12-19 10:04:36
    在vs08中载入待修改的图片,并打开,右键选择新建图片类型,然后选择自定义,定义自己需要的位深度图片。再把以前的那个类型删掉就好了
  • 用python批量更改图片位深度

    千次阅读 2021-02-02 17:32:30
    @用python批量更改图片位深度 原因: 因为业务需要,需要进行人脸识别的照片同步功能,上传过程中遇到了个问题,就是图片图片深度需要的是24,但是有的图片是32的,所以需要进行批量的修改,是这个中位深度(如下图): ...
  • 深度学习--------图片位深度含义

    万次阅读 多人点赞 2018-11-15 00:58:04
    以前没接触深度学习的时候没注意过图片位深度的问题,最近研究深度学习图片输入弄的也是莫名奇妙,焦头烂额。记录一下自己搜的资料的总结。首先要明白计算机的储存方式位二进制,只有0和1,因此图片的像素矩阵也不...
  • 原程序来源于网络,仅供参考学习,略有改动。 import os import numpy as np import PIL from PIL import Image import cv2 path = "../Data/errors/" for root, dirs, files in os.walk(path): ...
  • 本文依然是深度学习中,训练数据制作中所要用到的工具类方法。 1 批量转移文件 即:将labelme转换得到多个json命名的文件夹中的散落的图片,批量转移到同一个文件,此处针对png格式图片文件。 代码使用采用C++和QT写...
  •  #region 创建1图像  ///  /// 创建1图像  ///  /// <param name="srcBitmap"></param>  /// <returns></returns>  public Bitmap twoBit(Bitmap srcBitmap)  {  int midrgb = System....
  • 获取图片位深度

    千次阅读 2016-07-27 16:57:08
    !! 大概思路:图像的位深度,就存储在文件的byte数组里,找到位置,就能获取到。...png图片位深度获取: //png int bitsPerPixel = bytes[24] & 0xff; if ((bytes[25] & 0xff) == 2) { bitsPerPixe
  • clc clear close all path = ‘C:\Users\1\Desktop\WET\并集后的照片’; for i = 1: 5 fname = [path,’’,int2str(i),’.png’]; a = imread(fname); % a = imread(‘C:\Users\1\Desktop\5\1.png’);...
  • 图片压缩以及位深度转换

    千次阅读 2018-10-08 11:12:00
    需求:做一个电子签章图片上传,然后在线截取并上传到后台,再对图片进行格式化处理,包括位深度8位,gif格式,删除元数据   实现: 1,先在前台使用了一个cropbox.js的插件,这个插件能实现图片上传并...
  • path = ‘C:\Users\1\Desktop\WET\二值图8位深度’; for i = 1: 19 fname = [path,’’,int2str(i),’.jpg’]; img = imread(fname); %img = img(301:700,701:1100); %img = imresize(img,[320,320],‘nearest’); %...
  • 对图像位深度理解

    千次阅读 2019-05-15 17:34:18
    8位深度如何去读取一张图的通道数目? 一张图片是彩色的,例如是BGR格式的 那么该图也有可能是8位深度的,位深度不能说明这张图是彩色的还是黑白的,说明的是在总通道中所能表达的颜色数目。对 261.png来说,在R...
  • 最近调用热敏打印机需要打印单色,位深度为1的bmp照片,找了半天网上都是半成品,最后实现了,先谢谢各位大神,整体还是很有帮助,但是还是有些差距。 第一次写博客,不怎么会写,可能语言描述不是很好,但是代码是...
  • 1、什么是位深度 单个像素点(一个通道)上需要用多少比特(bit)来存储数据,常见的是8位 ...一句话概括:位深度,每一个像素(仅看一个通道)存储所需要的位(bit)数,深色,每个像素(整张图片
  • 位深度:存储图片一个像素需要消耗多少个bit位。 图像色深:图像的一个像素可以表示多少个bit的颜色。 通道:不同格式图片存储像素的方式,RGB图像的通道为3,灰度图像的通道为1. dpi:dots per inch,每英寸点...
  • java,取得图片位深度

    千次阅读 2014-06-15 22:00:20
    写这个主要是之前要用java显示图片信息的时候,其中的位深度一开始找不到对应的方法调用,上网也找不到资料,最后发现了getPixelSize()这个方法,下面为具体用法。 <pre name="code" class="java">File picture = ...
  • 关于图像位深度,色深的小结 **说明:**有不对的地方恳请指正,这方面不是太确定。 1. 正文 一张图像包括基本的信息(长,宽,通道) from PIL import Image import numpy as np img = Image.o...
  • 参考文章:8, 16,24,32位图片显示原理及对比
  • 首先我们先来理解下位深度与色深这两个概念。 1、位深度指的是存储每个像素所用的位数,主要用于存储 2、色深指的是每一个像素点用多少bit存储颜色,属于图片自身的一种属性 Android Bitmap中的Config参数其实指...
  • labelme 标注生成24位深度图像转换为8位

    千次阅读 热门讨论 2019-07-04 20:11:34
    最近在看别人程序时发现经过图像标注生成的 label 一片黑,且图像深度为 24 ,如下图所示 原始图像 生成的 label 图 label 图信息 运用matlab读入显示0,1 ; 说明图像中存在两种像素 而我的程序需要...
  • python工具(1) — 图片位深度压缩

    千次阅读 2016-07-27 07:58:27
    python脚本,使用pngquant开源工具来压缩图片
  • 纯Win32 API开发, 支持JPG、BMP、TIFF、ICO...支持原生图片尺寸大小 支持文件拖放打开 下载地址: https://pan.baidu.com/s/1yqc-rlELN1v9zuRzesNIhQ 备用下载地址: http://www.ppsbbs.tech/thread-...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,981
精华内容 24,792
关键字:

图片位深度