Halcon学习笔记——Tuple类算子
数组运算
y:=[1, 2, 10, 5, 0, 10]
x:=[10, 10, 20, 0, 5, -10]
a:=[10.5, -10.5, 0 ,3]
b:=[3.1415, 0,1.5708, 0.785]
c:=[2, 1, -2, 3, 5, -10]
d:=[3, -10.5, 0, 5]
tuple_abs (a, Abs)
* 计算一个元组的绝对值
* 元组中的元素为整型，则返回绝对值也为整型，为浮点型，则返回浮点型，可以混合
* [10.5, 10.5, 0，3]
tuple_fabs (a, Fabs)
* 计算一个元组（例如浮点数）的绝对值
* 统一返回浮点型的绝对值
* [10.5, 10.5, 0.0, 3.0]
tuple_add (a, d, Sum)
* 等同于 Sum := a + b
* 两个元组对应元素相加
* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相加，否则会引发异常
* [13.5，-21.0，0，8]
tuple_sub (a, d, Diff)
* 等同于 Diff:= a - b
* 两个元组对应元素相减
* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相减，否则会引发异常
* [7.5, 0.0, 0 ,-2]
tuple_div (x, c, Quot)
* 等同于 Quot:= x / c
* 两个元组对应元素相除，要确保参数2中不能含有0元素，否则会引发异常
* 需要用tuple_find()查找参数2中是否含有0元素
* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相减，否则会引发异常
* [5, 10, -10, 0, 1, 1]
tuple_mult (b, x, Prod)
* 等同于 Prod:= b * c
* 两个元组对应元素相乘
* 要保证参数1和参数2的元素个数（数组长度相同）才能进行相减，否则会引发异常
* [20.0, 10, -40, 0, 25, 100]
tuple_neg (y, Neg)
* 取反---乘-1
* [-1, -2, -10, -5, 0, -10]数组位操作
数组比较
a:=[3,2,1]
b:=[4,2,3]
c:=[4,3,3]
tuple_equal (a, b, Equal)
* 两个元组是否相同
* 0--不同 1--相同
tuple_not_equal (b, c, Nequal)
* 两个元组是不是不等
* 0--相同 1--不同
******** -elem
tuple_equal_elem (a, 2 , Equalem)
* 判断元祖中的每个元素是否等于参数2
* 参数3 ： 返回数组[0,1,0]
* 0--不同 1--相同
tuple_not_equal_elem (a, 2, Nequalem)
* 判断元祖中的每个元素是否不等于参数2
* 参数3 ： 返回数组[1,0,1]
* 0--相同 1--不同
tuple_greater (b, c, Greater)
* 一个元组是否大于另一个元组
* 按顺序比较
* 0--b<=c 1--b>c
tuple_greater_elem (a, 2, Greaterem)
* 判断元祖中的每个元素是否大于参数2
* 参数2 ： 不能传入多元素
* 参数3 ： 返回数组[1,0,0]
* 0--a<=2 1--a>2
****** 加上-equal
tuple_greater_equal
* 1--b>=c
tuple_greater_equal_elem
* 1--a>=2
******
tuple_less (b, c, Less)
* 一个元组是否小于另一个元组
* 按顺序比较
* 0--b>=c 1--b=2 1--a<2
****** 加上-equal
tuple_less_equal
* 1--b<=c
tuple_less_equal_elem
* 1--a<=2
****** 数组转换
a:=[65,97,49]
b:=[4.5,-2.9,3.4567]
c:='6814031a'
d:='12345678'
e:=['A', 'a', '1']
f:='liming'
tuple_chr (a, Chr)
* 根据ASCII码将整型元组转换为字符数组
* 参数1：ASCII码
* 参数2: 返回数组
* ['A', 'a', '1']
tuple_chrt (a, Chrt)
* 根据ASCII码将整型元组转换为字符串
* 参数2： 返回单个字符串
* 'Aa1'
tuple_int (b, Int)
* 一个元组转换为一个整型元组
* 小数部分直接抛弃，不四舍五入
* [4, -2, 3]
tuple_real (a, Real)
* 转换为浮点数
* [65.0, 97.8, 49.0]
tuple_round (b, Round)
* 转换为整型数--四舍五入
* [5，3, 3]
tuple_is_number (c, IsNumber)
* 检测一个字符串元组是否表示数字，只含有数字的字符串再算数字字符串
* 1--数字字符串 0--非数字字符串
tuple_number (d, Number)
* 将一个字符串元组转换为一个数值
* 如果d不是数字字符串，就返回原字符串
* 12345678
tuple_ord (e, Ord)
* 将长度为1的字符串的元组转换为它们相应的ASCII码元组
* 参数1： 字符串的长度只能为1，否则会引发异常
* [65, 97, 49]
tuple_ords (f, Ords)
* 将一个字符串的元组转换为它们ASCII码的元组
* 拆分成单个
* [108, 105, 109, 105, 110, 103]
tuple_string (f, '-10.3s', String)
* 转换为字符串
* 参数1：输入
* 参数2：格式
* 数值时：
* '10.2f' 总长度10位，小数点2位 f表示浮点数
* '-10.2f' -表示左对齐 否则右对齐
* '.7f' 总长度不限，小数点7位
* '+10.3f' +表示前面加上+-号
* 'x' 转化为小写16进制
* 'X' 转化为大写16进制
* '.8d' 转化为十进制，总长度8位
* 字符串时：
* '10s' 转换为总长度10位的字符串
* '-10s' -表示左对齐 否则右对齐
* '-10.3s' 总长度10位，截取前3个字符 'lim 数组创建
a:=[1,2,3]
b:=[10,20,30]
tuple_concat (a, b, Concat)
* 两个数组合并，参数1在前，参数2在后
* [1, 2, 3, 10, 20, 30]
tuple_gen_const (5, 0, Newtuple)
* 创建一个特殊长度的元组并初始化它的元素
* 参数1：新元组长度
* 参数2：用于初始化元组元素的常量
* 参数3：新元组
* [0, 0, 0, 0, 0]
tuple_gen_sequence( : : Start, End, Step : Sequence)
* 生成具有等距值序列的元组
* 输入参数：
* Start ———— 起始值
* End ———— 截至值
* Step ———— 步长 ，可以为小数
* 输出参数：
* Sequence———— 输出的数组
tuple_rand (6, Rand)
* 返回0到1之间的随机数元组
* 参数1：要生成的元组的长度
* 参数2：随机数的元组
* [0.693658, 0.168389, 0.895945, 0.365523, 0.332642, 0.601562]数组元素顺序
a:=[1,2,3]
b:=[10,20,30]
c:=[500,200,400]
tuple_inverse (b, Inverted)
* 将一个元组反置（反转）
* [30, 20, 10]
tuple_sort (c, Sorted)
* 按升序排序
* [200, 400, 500]
tuple_sort_index (c, Indices)
* 先按升序排序,返回排序后的元素在原元组中的索引(从0开始)
* [1, 2, 0]数组特征
a:=[1,2,3]
b:=[10.2,20,30.4,80,90,60,50]
c:=[500,200,400]
tuple_deviation (a, Deviation)
* 返回元组元素的标准差
* 1.0
tuple_length (a, Length)
* 返回元组元素数目
* 3
tuple_max (c, Max)
* 返回元组的最大元素
* 500
tuple_min (a, Min)
* 返回元组的最小元素
* 1
tuple_mean (a, Mean)
* 返回元组的平均值
* 2.0
tuple_median (b, Median)
* 返回一个元组元素的中值
* 50
tuple_sum (a, Sum)
* 返回所有元素的和
* 6数组选择
a:=[3,'tuple',5,6,1,2,3,'tuple',0]
b:=[3,'tuple']
c:=[7,1]
tuple_find (a, b, Indices)
* 返回参数2在参数1中出现的索引
* 如果没有返回-1
* 如果其中一个或两个输入元组都为空，则运算符返回一个空元组,
* 参数2可以有多个元素，但在查找时，也必须满足顺序。当b:=['tuple',3]则返回-1
* 允许混合字符串和数字
* [0, 6]
tuple_first_n (a, 5, Selected)
* 选择前面的元素，直到索引n [包含索引n的元素]
* 参数2：索引n
* 索引从0开始，总共返回索引+1个元素
* 如果参数1为空，则会引发异常
* [3, 'tuple', 5, 6, 1, 2]
tuple_last_n (a, 3, Selected1)
* 选择从索引“n”开始到元组末尾的所有元素 [包含索引n的元素]
* 元组元素的索引从0开始，如果Tuple为空，则会引发异常
* [6, 1, 2, 3, 'tuple', 0]
tuple_remove (a, c, Reduced)
* 移出指定索引的元素
* 参数2：需要移除的索引
* 元组元素的索引从0开始，即第一个元组元素的索引为0。
* 将忽略超出范围的索引和重复项
* 如果元组（参数1）为空，则运算符返回一个空元组
* [3, 5, 6, 1, 2, 3, 0]
tuple_select (a, c, Selected2)
* 返回指定索引的元素
* 参数2：需要返回的索引
* 元组元素的索引从0开始
* 如果参数1为空，则会引发异常
* ['tuple', 'tuple']
tuple_select_range (a, 3, 5, Selected3)
* 返回指定索引区域的元素
* 参数2：起始索引 Startindex
* 参数3：终止索引 Endindex
* 参数2和参数3的元素都包含；如果索引相等，则只选择一个元素
* 如果Startindex[]和Endindex[]是空元组，则运算符返回空元组
* Startindex和Endindex 只能含有一个元素，否则会引发异常
* 如果这些参数或元组中只有一个是空元组，则会引发异常
* [6, 1, 2]
d := [4,30,5,6,1,2,3,20,0]
tuple_select_rank (d, 4, Selected4)
* 先升序排序，再返回排序后指定索引的元素
* 参数1：不允许混合字符串
* 参数2：索引
* 参数2只允许单个元素，否则会引发异常
* 4
e:=['abc','liming','mKbc','5842']
tuple_str_bit_select (e, 1, Selected5)
* 返回每个字符串中指定索引的字符
* 参数2：索引
* 参数2只允许单个元素，否则会引发异常
* 要是参数2的索引超过了字符串的索引范围，则返回['', i ,'','']空元素
* ['b', 'i', 'K', '8']
g:=[0,0,1,1,1,2,0,1]
tuple_uniq (g, Uniq)
* 连续且相同元素只取一个
* 允许在输入元组中混合字符串和数字
* [0, 1, 2, 0, 1]