学而不思则罔，思而不学则殆
【Android】图像像素点理解
前言
图像处理 -ARGB初始
原图
Alpha
R值测试
G值测试
B值测试
非R值测试
非G值测试
非B值测试
高级图片处理
取反1
取反2
灰阶处理
Demo


前言
我们知道图像是有像素点组成，那么什么是像素点呢？


查看一张图片的属性，该图片的宽度是690像素，高度是460像素。

每一个像素点是一个数字，表示颜色的具体值。

像素值如下：



比如【#AA03DAC5】




像素
说明
举例




A
透明度
AA


R
R值
03


G
G值
DA


B
B值
C5


图像处理 -ARGB初始
原图
     Bitmap ycy = BitmapFactory.decodeResource(getResources(), R.drawable.ycy);

设置给ImageView,展示如下：



图像处理代码，主要把像素点的值根据传入的flag做转换处理。
    private Bitmap pictureProcessing(Bitmap bitmap, int flag) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        Log.d("zhangyu", "width:" + width + " height:" + height);//690 460
        Bitmap newBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        for (int w = 0; w < width; w++) {
            for (int h = 0; h < height; h++) {
                int c = bitmap.getPixel(w, h);
                newBitmap.setPixel(w, h, c & flag); //处理像素点
            }
        }
        show(newBitmap);
        return newBitmap;
    }

Alpha
只保留透明度
Bitmap bitmap = pictureProcessing(ycy, 0XFF00_0000);


R值测试
保留透明度和R值
        Bitmap bitmap = pictureProcessing(ycy, 0XFFFF_000);


G值测试
保留透明度和G值
        Bitmap bitmap = pictureProcessing(ycy, 0XFF00_FF00);


B值测试
保留透明度和B值
        Bitmap bitmap = pictureProcessing(ycy, 0XFF00_00FF);


非R值测试
只清除R值
        Bitmap bitmap = pictureProcessing(ycy, 0XFF00_FFFF);


非G值测试
        Bitmap bitmap = pictureProcessing(ycy, 0XFFFF_00FF);


非B值测试
        Bitmap bitmap = pictureProcessing(ycy, 0XFFFF_FF00);


高级图片处理
取反1
    //图片取反1
    private Bitmap negation1(Bitmap bitmap) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        Bitmap newBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        for (int w = 0; w < width; w++) {
            for (int h = 0; h < height; h++) {
                int c = bitmap.getPixel(w, h);
                int a = c & 0xff00_0000 >> 24;
                int r = c & 0x00ff_0000 >> 16;
                int g = c & 0x0000_ff00 >> 8;
                int b = c & 0x0000_00ff;
                newBitmap.setPixel(w, h, Color.argb(255 - a, 255 - r, 255 - g, 255 - b));
            }
        }
        return newBitmap;
    }


取反2
    //图片取反2
    private Bitmap negation2(Bitmap bitmap) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();
        Bitmap newBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        for (int w = 0; w < width; w++) {
            for (int h = 0; h < height; h++) {
                int c = bitmap.getPixel(w, h);
                int newC = ~c;
                newC = newC | 0xff00_0000;
                newBitmap.setPixel(w, h, newC);
            }
        }
        return newBitmap;
    }


灰阶处理
    //灰阶处理1
    public static Bitmap grayLevelOne(Bitmap originBitmap) {
        //【图片灰阶处理】
        //生成新的Bitmap
        Bitmap grayBitmap = Bitmap.createBitmap(originBitmap.getWidth(), originBitmap.getHeight(), Bitmap.Config.ARGB_8888);
        //创建画布
        Canvas canvas = new Canvas(grayBitmap);
        Paint mPaint = new Paint();

        //创建颜色变换矩阵
        ColorMatrix colorMatrix = new ColorMatrix();
        //设置饱和度为0，实现灰阶效果
        colorMatrix.setSaturation(0);
        //创建颜色过滤矩阵
        ColorMatrixColorFilter colorFilter = new ColorMatrixColorFilter(colorMatrix);

        //设置画笔的颜色过滤矩阵
        mPaint.setColorFilter(colorFilter);

        //使用处理后的画笔绘制图像
        canvas.drawBitmap(originBitmap, 0, 0, mPaint);
        return grayBitmap;
    }



灰阶处理应用见：【Android】应用黑白显示

Android图像处理见ColorMatrix，这个类主要是处理像素点的，通过一个长度为20的数组表示矩阵，用来处理像素点运算。
Demo
https://github.com/aJanefish/BitmapDemo

在很多时候进行图片处理深度学习都需要知道坐标，再此以获取照片的地址做一个例子，讲述一种通过鼠标获取像素点的方法

必须清楚：这个方法只能在python idle上实现，不能用jupyter notebook打开的（亲测过）。
import os , re
import numpy as np
img = Image.open(save_path+'/0.jpg')
print(img.size)
image_arr = np.array(img)
imshow(image_arr)
print ('Please click 4 points')
x =ginput(4)
print ('you clicked:',x)





参考链接

1	基于图像单像素点的处理
看过数字图像处理一书的都知道，图像处理中基于像素点的处理分为两种

灰度变换：本质就是基于单像素点的变化处理。

空间滤波：本质就是基于邻域像素点的变化处理。

今天要讲的是在OpenCv下基于基于单像素点的处理，其中会讲到OpenCv针对单像素处理封装好的一些ApI，即实质原理。
1.1	图像像素点的访问
要进行基于单像素点的处理，首先就必须知道，给你一幅图，你如何去访问图中的每一个像素点。无论是网上还是各种教程书上都给出了三种访问像素点的方式，分别是：

1、	指针访问。实质就是通过数据指针直接访问数据。

2、	迭代器访问。类似STL中容器的访问。

3、	动态地址计算。将每个像素转换为对应类型（uchar或Vec3b）,再进行访问。

下面以为图像中每个像素点加1为例说明三种方法。
/************************************************/
/*访问图像像素点的三种方法
/************************************************/
	int rows = img.rows;
	int cols = img.cols;
	int channels = img.channels();
	uchar *pRow = 0;

// 方法一：指针法访问
	for (int i = 0; i < rows; ++i)
	{
		// 获取行指针
		pRow = img.ptr<uchar>(i);
		for (int j = 0; j < cols; ++j)
		{
			if (channels == 1) //单通道
			{
				pRow[j] = pRow[j] + 1;
			}
			else if (channels == 3) //三通道
			{
				pRow[j * 3 ] = pRow[j * 3 ] + 1;
				pRow[j * 3 + 1] = pRow[j * 3 + 1] + 1;
				pRow[j * 3 + 2] = pRow[j * 3 + 2] + 1;
			}
		}
	}

// 方法一：迭代器法访问、事先得知道图像通道数,这里假设为3通道
	Mat_<Vec3b>::iterator it = img.begin<Vec3b>(); //初始位置迭代器
	Mat_<Vec3b>::iterator end = img.end<Vec3b>(); //终止位置迭代器
	for (; it != end; ++it)
	{
		(*it)[0] = (*it)[0] + 1;
		(*it)[1] = (*it)[1] + 1;
		(*it)[2] = (*it)[2] + 1;
	}

// 方法一：动态地址访问、事先得知道图像通道数,这里假设为3通道
	for (int i = 0; i < rows; ++i)
	{
		for (int j = 0; j < cols; ++j)
		{
			if (channels == 1) //单通道
			{
				img.at<uchar>(i,j) = img.at<uchar>(i, j)+1;
			}
			else if (channels == 3) //三通道
			{
				img.at<Vec3b>(i, j)[0] = img.at<Vec3b>(i, j)[0] + 1;
				img.at<Vec3b>(i, j)[1] = img.at<Vec3b>(i, j)[1] + 1;
				img.at<Vec3b>(i, j)[2] = img.at<Vec3b>(i, j)[2] + 1;
			}
		}
	}

1.2	图像亮度和对比度调整
知道如何对图像单像素点进行操作后，其实就可以对图像进行很多操作了，其中最有用，最让人产生直观感受的就是亮度和对比度的调整了。

基于单像素点变换分为以下几种：r为源像素点值，s为变换后像素点值。这里的值有可能是灰度图像中的灰度值，RGB颜色模型中的红、绿、蓝分量值，或者是HSV颜色模型中的色调、饱和度、亮度值。

1、	翻转变换
s=L-1-r
2、	线性变换
s=a*r+b
作用：a控制对比度，b控制亮度。
3、	对数变化
s=clog(1+r)
作用：围较窄的低灰度值映射到范围较宽的灰度区间，同时将范围较宽的高灰度值区间映射为较窄的灰度区间，从而扩展了暗像素的值，压缩了高灰度的值，能够对图像中低灰度细节进行增强。
4、幂（伽马）变换
s=cr^γ
作用：
当γ=c=1时：恒等变换。
当c=1，γ<1时：扩展低灰度级范围，压缩高灰度级范围，灰度值整体增大，变亮。γ 的值越小，对图像低灰度值的扩展越明显。
当c=1，γ>1时：压缩低灰度级范围，扩展高灰度级范围，灰度值整体减小，变暗。γ的值越大，对图像高灰度值部分的扩展越明显。
伽马变换主要用于图像的校正，对灰度值过高（图像过亮）或者过低（图像过暗）的图像进行修正，增加图像的对比。
值得注意的是上述4个变换中，除了翻转变换结果不可能溢出，即值在范围0-255之间，其他的都有可能溢出，特别是线性变换还可能出现负值。下面就以线性变换为例写一个小例子。例子是基于QT的，但不妨碍理解。
主要源码：
void QtGuiApplication1::update()
{
	int rows = m_Sor.rows;
	int cols = m_Sor.cols;
	int channels = m_Sor.channels();
	uchar *pSorRow = 0;
	uchar *pDstRow = 0;

	float contrast = m_Value1 / 10.f;
	// 方法一：指针法访问
	for (int i = 0; i < rows; ++i)
	{
		// 获取行指针
		pSorRow = m_Sor.ptr<uchar>(i);
		pDstRow = m_Dst.ptr<uchar>(i);
		for (int j = 0; j < cols; ++j)
		{
			if (channels == 1) //单通道
			{
				pDstRow[j] = pSorRow[j] + 1;
			}
			else if (channels == 3) //三通道
			{
				pDstRow[j * 3] = saturate_cast<uchar>(pSorRow[j * 3]* contrast + m_Value2);
				pDstRow[j * 3 + 1] = saturate_cast<uchar>(pSorRow[j * 3 + 1] * contrast + m_Value2);
				pDstRow[j * 3 + 2] = saturate_cast<uchar>(pSorRow[j * 3 + 2] * contrast + m_Value2);
			}
		}
	}

	//normalize(m_Dst, m_Dst, 0, 255,NORM_MINMAX);
	imshow("Dst", m_Dst);
}

使用到的opencv API：
saturate_cast(v)
作用：将输入值V限制在给定类型T范围内。
normalize()
void normalize( InputArray src, InputOutputArray dst, double alpha = 1, double beta = 0,

int norm_type = NORM_L2, int dtype = -1, InputArray mask = noArray());

参数：src：输出数组。

dst：输出数组。

alpha：参数。

beta：参数。

norm_type：类型。

dtype：输出数组的元素类型。默认和src一致。

mask：是否对src中的指定元素变换，默认全部元素变换。

norm_type取值：



作用：归一化函数，将数值限制在指定范围内，值得注意的是该函数支持输入值为负数哟。对数变换和指数变换后都需要使用该函数进行范围限制。
1.3 颜色空间缩减
什么是颜色空间缩减，目前我们接触到的图像都是256个灰度值的图像，对于显示来说自然是灰度值等级越多，图像越细腻，但是进行图像处理的时候可不是灰度值等级越多越好，而是适当就行，什么是适合呢？是100个灰度等级还是10个灰度等级，这得要具体情况具体对待了。

颜色空间缩减非常简单，一个公式就能明白，例如我们要把256个灰度级缩减到26个灰度级，那么

s=r/10*10

即对每个像素点都进行上述变换，那么一幅256个灰度级的图像最终就变为26个灰度级的图像。

为了提高提高变换的效率，这里可使用查表法，就是预先把每个灰度值将要变换为的灰度值体现算好，放在表中，变换时直接查表。Opencv提供了一个现成的API专门处理的这种查表式变换。
源码例子：
#include "QtGuiApplication1.h"

//#define Ui
#ifndef Ui

#include <QFileInfo>
#include <QDir>
#include <opencv2\opencv.hpp>
using namespace cv;

#else

#include <QtWidgets/QApplication>

#endif

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);

#ifdef Ui
	QtGuiApplication1 w;
	w.show();
	return a.exec();
#else
	QString path = QFileInfo(QCoreApplication::applicationDirPath(), "../../../../../").absoluteDir().absolutePath() + "/imgs/";
	Mat src = imread(path.toStdString() + "sor1.jpg", IMREAD_GRAYSCALE);
	imshow("src", src);

	int divideWith = 50;
	Mat table(1,256,CV_8U);
	for (int i = 0; i < 256; ++i)
	{
		table.data[i] = (i / divideWith) * divideWith;
	}

	Mat dst;
	LUT(src, table, dst);
	imshow("dst", dst);
	waitKey();

	return 0;
#endif
	
}

效果图：明显灰度级较少之后，图片变得很粗糙了。

最近这几天闲来无事，想起来18年12月末帮别人做了一个编程题。题目就是如何统计一张图片中的气泡数目，以及每个气泡的面积。



上面这张图就是案例，里面白色的都是不规则形态的气泡。当拿到这个题目时看一眼就大致有些思路。因为怎么说也是学了数据结构的人嘛！当时就是想借用数据结构中的“广度优先遍历”算法的思路去做。但是不全是，就是稍微改变一下。不过代码写完加调试估计花了我3个多小时，间接说明我编程能力赶不上我的思维能力。说白了我就菜......

        为了给别人理解，我当时就没有采用像素点(三维数据)去直接做，而是多做一步无用功。就是先把像素点降维成为一维数据并且进行简单的二分化。这里二分化就是把所有像素点变成纯黑或纯白，因为这张图片在黑白相间处的像素点存在杂色的像素点(毕竟不是矢量图)。



#coding:utf-8

from PIL import Image


# 打开图片,convert图像类型有L,RGBA
img = Image.open('1.jpg').convert('L')
img = img.transpose(Image.ROTATE_90)
#img.show();print(img.size[0],img.size[1])


# 将黑白图转化为0-1表示
def blackWrite(img):
    pixelShift = []
    for x in range(img.size[0]):
        rowList = []
        for y in range(img.size[1]):
            # 存在单一像素点不是纯黑纯白,取50为黑白分界线
            if img.getpixel((x,y)) < 50:
                rowList.append(0)
            else:
                rowList.append(1)
            pixelShift.append(rowList)
    return pixelShift

如果把一张图片看成一个二维数组，上面的代码就是把像素点变成0，1存储的二维数组，二维数组的行数和列数就是图片原始的分辨率大小。

然后你就可以把图片类型文件问题转变成我们基本都会的二维数组的字符问题了，剩下来就是如何对二维数组操作了。之前上面提到的“广度优先遍历”，学过数据结构的应该都知道这个图遍历算法。从一个点开始出发，查看它的四周有没有连接点(邻居)，有的话就把它邻居都打入队列中去，然后没有邻居了之后就从队列的队首取出它之前的邻居点，然后查看这个点的邻居(就是邻居的邻居)。之后步骤和上面一样，但是需要对访问过的点做好标记，避免多次重复访问同一个点陷入死循环。

from queue import Queue


# 统计各气泡数字1
def statisticalNum(resultPixel):
    bubble = []     # 用于存放各气泡面积
    for x in range(len(resultPixel)):
        for y in range(len(resultPixel[0])):
            if resultPixel[x][y] == 1:
                resultPixel[x][y] = 0
                Coordinate = Queue()    # 存放该点四周为1的坐标点
                onlyCoordinate = []     # 防止重复的坐标点入队,并统计个数
                Coordinate.put([x,y])
                while not Coordinate.empty():
                    row = clo = 0
                    [row,clo] = Coordinate.get()
                    onlyCoordinate.append([row,clo])
                    # 查看左边坐标点
                    if clo > 0:
                        if (resultPixel[row][clo-1] == 1) and ([row,clo-1] not in onlyCoordinate):
                            Coordinate.put([row,clo-1])
                            resultPixel[row][clo-1] = 0
                    # 查看右边坐标点
                    if clo < (img.size[1]-1):
                        if (resultPixel[row][clo+1] == 1) and ([row,clo+1] not in onlyCoordinate):
                            Coordinate.put([row,clo+1])
                            resultPixel[row][clo+1] = 0
                    # 查看下边坐标点
                    if row < (img.size[0]-1):
                        if (resultPixel[row+1][clo] == 1) and ([row+1,clo] not in onlyCoordinate):
                            Coordinate.put([row+1,clo])
                            resultPixel[row+1][clo] = 0
                bubble.append(len(onlyCoordinate))
    return bubble

 

我的思路：



	
从第0行开始遍历，遇到第一个1(白色像素点)时，开始对其左，右，下三个方向数组点值做判断，周围邻居值是1就说明它们都在同一个气泡中，然后把邻居们压入队列中。
	
	

	
当这个点访问完成后，需要这个点的值1置为0表示访问完毕，避免它右邻居点在访问时把左边的它压入队列再次访问，会使得这个气泡的面积变大，甚至是死循环。(不要问我为什么这么清楚，呜呜呜呜呜)
	
	

	
把置0点的左边存在一个list列表中，类似c/java中的数组类型。
	
	

	
当第一层循环结束时得到了一个气泡，只需要用len方法就知道这个气泡点的个数，即面积。
	
	

	
然后第二次循环时，二维数组中的1减少一部分；即使代码是3个循环嵌套，也不要说我的代码时间复杂度是O(n^3)。
	


关于时间复杂度，我从来都喜欢用书本上的公式来衡量一个算法好坏。我就喜欢用实际中它运行的真实次数和时间来衡量一个算法的好坏。这么说吧，书上喜欢把O(n^2)+O(n)当成O(n^2)来衡量，忽略O(n)。如果在实际中n比较大的时候，O(n)消耗的资源成本也要考虑到的。想成为一个好的程序员就要比别人多注意一些细节，在大数据时代更是如此。

项目源码和图片的链接在此：https://gitee.com/mjTree/MyPython/tree/master/图片气泡统计

 

 




银长臂猿

        银长臂猿?：栖息在热带及亚热带的雨林和密林，树栖性、日行性。生活在高大的树林中，采用“臂行法”行动，像荡秋千一样从一棵树到另一棵树，一次可跨越3米左右，加上树枝的反弹力可以达8-9米，且速度惊人。但是它们在地面上却显得十分笨拙。食性：杂食性，以树叶、水果、果实、花苞为食。

        由于爪哇岛人口的增长，而雨林正在迅速消失中。只有百分之四的银长臂猿的栖息地仍然存在。除了gununghalimun国家公园可能生活着1000只以上的银长臂猿，其他地区只有分散的小种群，很难维持其生存繁衍，目前野生的银长臂猿数量不满2000。