达式、运算符

表达式是JavScript中的一个短语，Javascript解释器会将其计算出一个结果。常量、变量都是一种简单的表达式，复杂表达式是由简单表达式组成的。

原始表达式是最简单的表达式，是表达式的最小单位，它们不再包含其他表达式。JavaScript中的原始表达式包含常量或直接量、关键词和变量。

1.23        // 数字直接量
"hello"     // 字符串直接量
/pattern/   // 正则表达式直接量

对象和数组的初始化表达式实际上是一个新创建的对象和数组。数组初始化表达式是通过一对方括号和其内由逗号隔开的列表构成的。对象初始化表达式和数组初始化表达式类似，由花括号替代了方括号，并且每个子表达式都包含一个属性名和一个冒号作为前缀。

[]                              // 空数组
[1+3,3+5]                       // 拥有两个元素，第一个4，第二个8
[[2,54],[3+5,78]]               // 支持嵌套
var a=[3,,,,2]                // 数组长度5，中间三个默认为undefined
var b={ x:1, y:2 }            // 对象定义
var c={}
c.x=2; c.y=3;               // 定义空对象，并且给对象的x、y属性赋值
var d={ x:{x:1, y:2}, y:{}}   // 支持嵌套

函数定义表达式，定义一个JavaScript函数，表达式的值是这个新定义的函数。

var func=function(x) { return 2*x }

属性访问表达式，能够等到一个对象的属性值或者是一个数组的元素的值。

var a={x:1, y:2}
a.x
var b=[] 

调用表达式是一种调用（或是执行）函数或方法的语法表示。

f(0)                // f是一个函数表达式，0是一个参数表达式
Math.max(x,y,z)     // Math.max是一个函数，x、y、z是参数
a.sort()            // a.sort是一个函数，他没有参数

对象创建表达式创建一个对象并调用一个函数初始化新对象的属性。

new Point(2,3)

运算符

“+”、“-”，一元运算的“+”可以把操作数转换成数字，二元运算的“+”可以进行数字或是字符串操作，一元运算的“-”可以把操作数转换成数字后改变成相反值，二元运算的“-”可以进行数字操作。

var a=+'5'                //=> 5
var b='say' + 'hello'     //=> sayHello
var c=-'5'                //=> -5
var d=9 - 4               //=> 5

“++”递增、“--”递减，对操作数进行加一（减一），如果在操作数左边，则会先操作操作数后返回值。如果在操作数右边，则会先返回值，后对操作数操作。

var i=1, j=++i;     // i和j的值都是2
var i=1, j=i++;     // i是2，j是i
var k=1, k--;         // k是0

“&”按位与，对整型进行逐位执行布尔与（AND），同时为1，结果才为1。

var a=0x1234 & 0x00FF //=> 0x0034

“|”按位或，对整型进行逐位执行布尔或（OR），有一个为1，结果就为1。

var a=0x1234 & 0x00FF //=> 0x12FF

“^”按位异或，对整型进行逐位比对，如果相同则为0，如果不同则为1。

var a=0xFF00 ^ 0xF0F0 //=> 0x012FF

“~”按位非，对整型进行逐位取反。

var a=~0x0F //=> 0xFFFFFFF0

“<<”左移，将操作数的所有二进制位向左移动0~31之间的整数位，右边填充0，从右往左数超过31位的舍弃。

var a=7<<2    //=> 28

“>>”带符号右移，将操作数的所有二进制位向右移动0~31之间的整数位，左边填充0，从左往右数超过31位的舍弃。如果原来是正数，最高位为0，如果原来是负数，最高位为1。

var a=7>>1    //=> 3
var b=-7>>1   //=> -4

“>>>”无符号右移，将操作数的所有二进制位向右移动0~31之间的整数位，左边填充0，从左往右数超过31位的舍弃。

var a=-1>>>4    //=> 0x0FFFFFFF

“==”等于、“===”恒等于、“!=”不等于、“!==”恒不等于，“==”、“===”都是判断左右两边的操作数是否相等，但是“===”更为严格。“!=”、“!==”的结果是对“==”、“===”取反。

“==”等于

1==2              //=> false
1=='1'            //=> true：会先把右边的转型成整型，再进行比较
null==undefined   //=> true
NaN===NaN         //=> false：NaN不等于任何东西，即使是自己也不相等
true==1           //=> true：会把左边的true转型成整型1，false则为0
class a{
    toString(){
        return 1
    }
    valueOf(){
        return -1
    }
}

var b=new a()
console.log(b>0)
// 对象和数字字符串比较，会两边转型成整型，对象转成原始类型，会依次调用valueOf()，如果得不到，接着会调用toString()，还不行则为false。

“===”恒等于

1===2                 //=> false
1==='1'               //=> false：类型不相等，即使转型后相等也是不相等

“<”小于、“>”大于、“<=”小于等于、“>=”大于等于，比较左右两边值大小，支持整型、字符串比较大小。

var a=7
a > 6
a < '4'
a >=15
a <=88

“in”存在，判断右边的对象的属性名中，是否存在左边的字符串（或是可以转换成字符串）同名的属性。

var point={ x:1, y:2 }    // 定义一个对象
"x" in point                //=> true：对象有一个名为"x"的属性
"z" in point                //=> false：对象不存在名为“z”的属性
var data=[5, 6, 7]        // 拥有三个元素的数组
"0" in data                 //=> true：数组中存在0数组下标
1 in data                   //=> true：数组中存在1数组下标
3 in data                   //=> false：数组中不存在3数组下标

“instanceof”类型比较，比较左边对象的类型是否是右边指定的类型。

var a=new Date()
a instanceof Date
a instanceof Object     //=> true：所有对象都是Object实例
a instanceof Number     //=> false

“&&”逻辑与，把左右两边的表达式计算出结果后，并转型成布尔型，只有左右同时为true的时候，才能返回true。

true && false   //=> false
(1>0) && (0<1)  //=> true

“||”逻辑或，把左右两边的表达式计算出结果后，并转型成布尔型，只有左右存在一个或是以上的true的时候，才能返回true。

true || false   //=> true
(1<0) || (0>1)  //=> false

“!”逻辑非，把右边的表达式计算出结果后，并转型成布尔型，然后对布尔型结果取反。

!true   //=> false
!(1<0)  //=> true

“=”赋值，把右边的值赋予左边的变量。

var a=2
var b=1
a+=b        // 等价于a=a+b
a-=b        // 等价于a=a-b
a*=b        // 等价于a=a*b
a/=b        // 等价于a=a/b
a%=b        // 等价于a=a%b
a<<=b       // 等价于a=a<<b
a>>=b       // 等价于a=a>>b
a>>>=b      // 等价于a=a>>>b
a&=b        // 等价于a=a&b
a|=b        // 等价于a=a|b
a^=b        // 等价于a=a^b

eval()，只有一个参数，如果传入的不是字符串，他直接返回参数。如果是，则会把字符串当成JavaScript代码进行编译，编译失败返回异常，成功则执行，返回结果。eval()使用了调用它的变量作用域环境。

“?:”，JavaScript中唯一的三元运算，A?B:C，如果A为true，则返回B，反之则返回C。

var a=1>0?5:3     //=> 5

“typeof”，获取操作数的类型对应的字符串。

var a=1
typeof a                //=> "number"
typeof undefined        //=> "undefined"
typeof null             //=> "object"
typeof true             //=> "boolean"
typeof 1                //=> "number"：NaN也属于number
typeof "hello"          //=> "string"
var b=function(){}
typeof b                //=> "function"
typeof {}               //=> "object"

“delete”删除符，用来删除对象属性或者数组元素。

var point={ x:1, y:2}
delete point.x
"x" in point            //=> false：属性已经被删除了
var a=[1,2,3]
delete a[2]
2 in a                  //=> false：下标2的元素已经被删除了

“void”，会使程序忽略右边的操作数的返回结果，常见的是放在a标签里面。

<a href="javascript：void window.open()">打开一个新的窗口</a>

“,”逗号运算符，会先计算左边操作数，再计算右边操作数，最后返回右边操作数的值。

标

在本教程中, 你将学习到以下内容:

• 访问像素值;
• 用零初始化矩阵;
• 学习CV :: saturate_cast的作用及其有用的原因;
• 学习有关像素变换的很酷的知识;
• 提高图像亮度的实例。

理论

注
下述解释援引自理查德·斯泽利斯基(Richard Szeliski)的<<计算机视觉算法和应用>>一书。

图像处理

常用的图像处理操作是一个函数，它将一个或多个图像作为输入并生成输出图像。

• 图像变可被视为：
• 点运算符（像素变换）;
• 邻近（基于区域的）运算符。

像素变换

• 在图像处理中, 每个输出像素的值仅取决于相应的输入像素值（可能还包括一些全局收集的信息或参数）;
• 此类操作实例包括亮度调整、对比度调整以及颜色的校正和转换。

亮度和对比度调整

两种常用对比度调整的方法是将像素值乘以或加上一个常数：

• 参数α > 0和β通常称为增益参数和偏置参数,通过这两个参数分别来控制对比度和亮度。
• F （ X ）为源图像的像素,G （ X ）为输出图像的像素。可以方便地写出以下表达式：

• 其中i和j表示位于第i行，第j列的像素。

代码

C ++

（Java 版本请访问：

https://github.com/opencv/opencv/blob/master/samples/java/tutorial_code/ImgProc/changing_contrast_brightness_image/BasicLinearTransformsDemo.java

Python 版本请访问：

https://github.com/opencv/opencv/blob/master/samples/python/tutorial_code/imgProc/changing_contrast_brightness_image/BasicLinearTransforms.py）

• 原文可下载源代码（地址在文末）
• 下面的代码执行g(i,j)=α?f(i,j)+β操作

代码详解

C ++

使用CV :: imread加载图像并将其保存到Mat对象中：

接下来，对该图像做一些转换，为此需要创建一个新的Mat对象来存放它。此外，我们希望它具备以下特征：

• 初始像素值为零;
• 与原始图像相同的尺寸和数据类型。

cv::Mat::zeros返回一个基于image.size()和image.type() 的Matlab格式的零初始化值。

• 我们现在要求用户输入α和β值：

• 为了执行g(i,j)=α?f(i,j)+β操作，我们必须访问图像的每个像素。由于是对BGR图像进行操作，所以每个像素包含（B，G和R）三个值，我们必须分别访问它们。具体代码如下：

注意（只适用于C ++代码）：

• 我们利用 image.at<Vec3b>(y,x)[c]来访问图像的各个像素，其中?是行号， X是列号，C是B，G或R（0，1或2）；
• 由于α?p(i,j)+β 操作的值可能溢出或为非整数（如α是浮点数），我们用CV :: saturate_cast来确保该值的有效性；
• 最后，我们用以下方式创建窗口并显示图像。

注我们利用以下简单的命令来取代for循环来访问图像的每个像素：

cv::Mat::convertTo将执行*new_image=a*image + beta*操作.。但是，我们想向你展示如何访问每个像素。在任何情况下，这两种方法都给出相同的结果，但 convertTo 更加优化并且工作速度更快。

结果

我们不运行代码，设置α=2.2和β=50。

实例

在本小节中，我们将以前学到的技巧付诸实战，通过调整图像的亮度和对比度来校正曝光不足的图片。同时,学习利用伽玛校正(gamma correction)技术来校正图像的亮度。

图像亮度和对比度调整

增大（或减小） β值将加大（/减小）各个像素的对比度。像素值超出 [0; 255]范围之外的值将会饱和（即:大于255,或小于0的像素值将钳位到255或 0）。

原始图像的浅灰色直方图中，深灰色亮度=80 GIMP
直方图表示该色彩像素中每种色彩的数目。深色图像的像素值将大于浅色图像的像素值，因此直方图的左半部分会出现一个峰值。当添加一个恒定的偏差之后，整个直方图右移，为所有的像素增加了一个恒定的偏置。
修改参数α将修改水平轴的展幅,如果α <1中，色彩值将被压缩，其结果是图像的对比度降低。

原图像的浅灰色直方图中，深灰色时, 对比度GIMP <0
注意，利用对比度/亮度工具Gimp获得的上述柱状图，亮度工具的偏置参数β应该与之相同，但对比度工具的增益参数α是不同的（可以从前面的直方图中看出）。
调整偏置参数β可以提高亮度，但同时，图像的对比度会下降,图像上似乎会蒙上一层轻微的面纱。调整增益α增益可缓释这种效果，但是由于出现饱和，图像将失去原有明亮区域的一些细节。

伽瑪校正

伽瑪校正利用输入值和输出映射值之间的非线性变换，校正图像的亮度：

由于这种关系是非线性的，其效果不会影响所有的像素，最终输出将取决于像素的原始值。

打印出不同的伽玛值(gamma)
当γ <1时,，原始图像的暗区将变得更加明亮，整个直方图将右移;当γ > 1时, 原始图像的亮区将变得更暗，整个直方图将左移。

纠正曝光不足的图像

我们设置α=1.3和β=40修正下面的图像。

图: Visem的作品 [CC BY-SA 3.0]，来源:维基共享资源

图像的整体亮度得到了改善，但可以看出: 由于色彩的像素数值饱和，图中云彩已经饱和（摄影高光修剪）。
我们用γ=0.4修正下面的图像。

图: Visem的作品 [CC BY-SA 3.0]，来源:维基共享资源
由于映射是非线性的，伽马校正添加了少量的饱和效应，并且不存在前面所述方法的数值饱问题。

左边：α，β校正后的直方图;中间：原始图像的直方图;右边：伽马校正后的直方图
上图比较了三幅图像（三个直方图的y值不相同）的直方图。从中可以发现，大部分的像素值都在原始图像直方图的下部。α ， β修正后，由于图像出现饱和，在255 处可以观察到一个峰值，整个直方图右移。伽玛校正后，直方图右移，图像暗区域中的像素移动的位移比在明亮区域像素移动的位移更大（见伽玛曲线图）。
在本教程中，描述了两种调整图像对比度和亮度简单的方法。它们只是基本技术，不能用作光栅图形编辑器的替代品！

代码

C ++

教程的源代码请访问原文（地址在文末）
伽马校正的源代码Code:

在这里，由于一次只需要计算256 个数值，利用查找表来提高计算性能。

更多资源

图形渲染中的伽玛校正

CRT监视器的伽玛校正和图像显示

数字曝光技术

注：本文以C++语言代码为例，获取Java和python版本可在原文中查看：

https://docs.opencv.org/4.5.2/d3/dc1/tutorial_basic_linear_transform.html