【HALCON】【TUPLE】元组操作

最新推荐文章于 2024-02-18 11:09:24 发布

zhy29563

最新推荐文章于 2024-02-18 11:09:24 发布

阅读量7.5k

点赞数 12

分类专栏： # HALCON

本文链接：https://blog.csdn.net/zhy29563/article/details/105842859

版权

HALCON 专栏收录该内容

12 篇文章 9 订阅

订阅专栏

5.1 将元组作为整体进行比较（比较元组的长度、类型、值），结果返回一个值

5.2 将元组对应元素进行比较（比较元组的长度、类型、值），返回多个值

1. 基本数学运算

************************************************************************************************************************
* 加
* 如果两个输入元组的长度相等，对应位置的元素相加
* 如果两个输入元组的长度不等，则必须其中一个的长度为1。在这种情况下，长元组
* 中的每个元素分别加上短元组的单一元素
* 如果两个输入元组都是整数，返回结果时整数
* 如果任何一个元素时浮点数，则返回浮点数
* 如果输入的是字符串，则字符串连接
* 如果输入的一个是数字，一个是字符串，则先将数字转换为字符串，然后再连接
************************************************************************************************************************
* 等价 => Sum := S1 + S2
tuple_add  ([1, 2, 3, '2.2'], [1, 2, 1.0, 1.1], Sum)
* [2, 4, 4.0, '2.21.1']
tuple_add  ([1,2], 1    ,Sum)
* [2, 3]

************************************************************************************************************************
* 减
* 除了不支持字符串减法，其他和tuple_add相同
* 等价 => Diff := D1 - D2
************************************************************************************************************************
* [0, 1]
tuple_sub  ([1, 2], 1, Diff)

************************************************************************************************************************
* 乘
* 除了不支持字符串乘法，其他和tuple_add相同
* 等价 => Prod := P1 * P2
************************************************************************************************************************
tuple_mult (2, 3, Prod)

************************************************************************************************************************
* 除
* 如果输入的两个参数都是整数，则执行地板除
* 如果有一个为浮点数，结果为标准除
* 不支持字符串除法
* 等价 => Quot := Q1 / Q2
************************************************************************************************************************
tuple_div (4,3,Quot)

************************************************************************************************************************
* 相反数
* 不支持字符串取负
* 等价 => Neg := -T
************************************************************************************************************************
tuple_neg (3,Neg)

************************************************************************************************************************
* 绝对值
* 参数为整数时返回整数
* 参数为浮点数时返回浮点数
* 不支持字符串
* 等价 => Abs := abs(T)
************************************************************************************************************************
tuple_abs  (-6.6, Abs)

************************************************************************************************************************
* 绝对值
* 不论参数的类型，均返回浮点数
* 不支持字符串
* 等价 => Abs := fabs(T)
************************************************************************************************************************
tuple_fabs (-6.6, Abs)

************************************************************************************************************************
* 线上取整
* 不论参数的类型，均返回浮点数
* 不支持字符串
* 等价 => Ceil := ceil(T)
************************************************************************************************************************
tuple_ceil (2, Ceil)

************************************************************************************************************************
* 向下取整
* 不论参数的类型，均返回浮点数
* 不支持字符串
* 等价 => Floor := floor(T)
************************************************************************************************************************
tuple_floor (1.99, Floor)

************************************************************************************************************************
* 取余
* 获取整除的剩余部分
* 仅支持整数
* 等价 => Mod := T1 % T2
************************************************************************************************************************
tuple_mod  (3,2, Mod)

************************************************************************************************************************
* 取整
* 对整数和浮点数均可
* 不支持字符串
* 等价 => Fmod := fmod(T1, T2)
************************************************************************************************************************
tuple_fmod (3.5,3.1, Fmod)

************************************************************************************************************************
* 获取两个元组对应元素的最大值
* 对应元素的类型必须相同
* 等价 => Max2 := max2(T1, T2)
************************************************************************************************************************
tuple_max2 ([2,3,'23'],[3,2,'32'], Max)

************************************************************************************************************************
* 获取两个元组对应元素的最小值
* 对应元素的类型必须相同
* 等价 => Min2 := min2(T1, T2)
************************************************************************************************************************
tuple_min2 ([2,3,'23'],[3,2,'32'], Min)

************************************************************************************************************************
* 返回第一个元素到每个索引的累加和
* 所有元素必须为数值型
* 等价 => Cumul := cumul(Tuple)
************************************************************************************************************************
* Cumul = [1, 3, 6, 10]
tuple_cumul([1, 2, 3, 4], Cumul)

************************************************************************************************************************
* 乘方
* 等价 => Pow := pow(T1, T2)
************************************************************************************************************************
tuple_pow (2,2, Pow)

************************************************************************************************************************
* 均方根
* 等价 => Sqrt := sqrt(T)
************************************************************************************************************************
tuple_sqrt(4,Sqrt)

************************************************************************************************************************
* 符号函数
* 等价 => Sgn := sgn(T)
************************************************************************************************************************
tuple_sgn(0, Sgn)

2. 三角函数

************************************************************************************************************************
* 角度制转弧度制
* 不支持字符串
* 等价 => Rad := rad(Deg)
************************************************************************************************************************
tuple_rad (30, Rad)

************************************************************************************************************************
* 弧度制转角度制
* 不支持字符串
* 等价 => Deg := deg(Rad)
************************************************************************************************************************
tuple_deg (Rad, Deg)

************************************************************************************************************************
* 弧度制的正弦
* 不支持字符串
* 等价 => Sin := sin(T)
************************************************************************************************************************
tuple_sin(rad(30), Sin)

************************************************************************************************************************
* 弧度制的余弦
* 不支持字符串
* 等价 => Cos := cos(T)
************************************************************************************************************************
tuple_cos(rad(30), Cos)

************************************************************************************************************************
* 弧度制的正切
* 不支持字符串
* 等价 => Tan := tan(T)
************************************************************************************************************************
tuple_tan(rad(45), Tan)

************************************************************************************************************************
* 弧度制的反正弦
* 不支持字符串
* 等价 => ASin := asin(T)
************************************************************************************************************************
tuple_asin (0.5, ASin)

************************************************************************************************************************
* 弧度制的反余弦
* 不支持字符串
* 等价 => ACos := acos(T)
************************************************************************************************************************
tuple_acos (0.5, ACos)

************************************************************************************************************************
* 弧度制的反正切
* 不支持字符串
* 等价 => ATan := atan(T)
************************************************************************************************************************
tuple_atan (1, ATan)

************************************************************************************************************************
* 先计算Y/X的值，然后计算反正切
* 不支持字符串
* 等价 => ATan := atan2(Y, X)
************************************************************************************************************************
tuple_atan2 ([1,3],[1,4], ATan)

************************************************************************************************************************
* 双曲正弦
* 等价 => Sinh := sinh(T)
************************************************************************************************************************
tuple_sinh (rad(30), Sinh)

************************************************************************************************************************
* 双曲余弦
* 等价 => Cosh := cosh(T)
************************************************************************************************************************
tuple_cosh (rad(30), Cosh)

************************************************************************************************************************
* 双曲正切
* 等价 => Tanh := tanh(T)
************************************************************************************************************************
tuple_tanh (rad(30), Tanh)

3. 指数与对数

************************************************************************************************************************
* 指数运算
* 等价 => Exp := exp(T)
************************************************************************************************************************
tuple_exp (1, Exp)

************************************************************************************************************************
* T1 * 2^{T2}
* 等价 => Ldexp := ldexp(T1, T2)
************************************************************************************************************************
tuple_ldexp (2,3,Ldexp)

************************************************************************************************************************
* 自然对数
* 等价 => Log := log(T)
************************************************************************************************************************
tuple_log (1,Log)

************************************************************************************************************************
* 以10为底的对数
* 等价 => Log := log10(T)
************************************************************************************************************************
tuple_log10(1,Log)

4. 位运算

************************************************************************************************************************
* 按位与
* 等价 => BAnd := T1 band T2
* 1    <===> 00000001
* 3    <===> 00000011
* band <===> 00000001
* bnot <===> 11111110
* bor  <===> 00000011
* bxor <===> 00000010
************************************************************************************************************************
tuple_band (1,  3, BAnd)

************************************************************************************************************************
* 负数的标示：负数通过补码显示
*            如果源码的最左一位是1，则表示负数
*                              0，则表示正数
* 源码： 11111110
* 取反:  00000001
* 加一:  00000010
* 负号: -00000010
* 等价 => BNot := bnot T
************************************************************************************************************************
tuple_bnot ( BAnd, BNot)

************************************************************************************************************************
* 等价 => BOr := T1 bor T2
************************************************************************************************************************
tuple_bor  (1,  3, BOr)

************************************************************************************************************************
* 等价 => BXor := T1 bxor T2
************************************************************************************************************************
tuple_bxor (1,  3, BXor)

************************************************************************************************************************
* 向左移位
* 等价 => Lsh := lsh(T, Shift)
************************************************************************************************************************
tuple_lsh  (32, 2, Lsh)

************************************************************************************************************************
* 向右移位
* 等价 => Rsh := rsh(T, Shift)
************************************************************************************************************************
tuple_rsh  (32, 2, Rsh)

5. 比较运算

5.1 将元组作为整体进行比较（比较元组的长度、类型、值），结果返回一个值

************************************************************************************************************************
* * 等价 => Equal := T1 == T2 or Equal := T1 = T2
************************************************************************************************************************
* Equal = 1
tuple_equal ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Greater := T1 > T2
************************************************************************************************************************
* Equal = 0
tuple_greater ([1,2,3], [1,2,3], Equal)

************************************************************************************************************************
* 等价 => Greatereq := T1 >= T2
************************************************************************************************************************
* Equal = 1
tuple_greater_equal ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Less := T1 < T2
************************************************************************************************************************
* Equal = 0
tuple_less ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Lesseq := T1 <= T2
************************************************************************************************************************
* Equal = 1
tuple_less_equal ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Nequal := T1 != T2 or Nequal := T1 # T2
************************************************************************************************************************
* Equal = 0
tuple_not_equal ([1,2,3],[1,2,3], Equal)

5.2 将元组对应元素进行比较（比较元组的长度、类型、值），返回多个值

************************************************************************************************************************
* 等价 => Equal := T1 [==] T2 or Equal := T1 [=] T2
************************************************************************************************************************
* Equal = [1, 1, 1]
tuple_equal_elem ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Greater := T1 [>] T2
************************************************************************************************************************
* Equal = [0, 0, 0]
tuple_greater_elem ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Greatereq := T1 [>=] T2
************************************************************************************************************************
* Equal = [1, 1, 1]
tuple_greater_equal_elem ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Less := T1 [<] T2
************************************************************************************************************************
* Equal = [0, 0, 0]
tuple_less_elem ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Lesseq := T1 [<=] T2
************************************************************************************************************************
* Equal = [1, 1, 1]
tuple_less_equal_elem ([1,2,3],[1,2,3], Equal)

************************************************************************************************************************
* 等价 => Nequal := T1 [!=] T2 or Nequal := T1 [#] T2
************************************************************************************************************************
* Equal = [0, 0, 0]
tuple_not_equal_elem ([1,2,3],[1,2,3], Equal)

6. 转换

************************************************************************************************************************
* 将整数转换为ASCII码，如果对应的ASCII是可显示字符，则用可显示字符表示
* 每个整数转换为一个ASCII码，输出为这个ASCII码组成的元组
* 等价 => Chr := chr(T)
************************************************************************************************************************
* Chr = ['d', '0', 'ÿ']
tuple_chr ([100, 48, 255], Chr)

************************************************************************************************************************
* 将整数转换为ASCII码，如果对应的ASCII是可显示字符，则用可显示字符表示
* 每个整数转换为一个ASCII码，并将这些ASCII码连接成一个字符串输出
* 等价 => Chrt := chrt(T)
************************************************************************************************************************
* Chr = 'd0ÿ'
tuple_chrt([100,48,255], Chr)

************************************************************************************************************************
* 测试字符串能否表示一个数值
* 等价 => IsNumber := is_number(T)
************************************************************************************************************************
* Chr = [1, 1, 1]
tuple_is_number(['1','2','3.6'], Chr)

************************************************************************************************************************
* 将字符串转换为数值
* 等价 => Number := number(T)
************************************************************************************************************************
* Chr = [1, 2, 3.6]
tuple_number(['1','2','3.6'], Chr)

************************************************************************************************************************
* 将数值型的值转换为整型
* 等价 => Int := int(T)
************************************************************************************************************************
* Chr = [1, 2, 3]
tuple_int([1,2,3.6], Chr)

************************************************************************************************************************
* 将数值型的值转换为浮点数
* 等价 => Real := real(T)
************************************************************************************************************************
* Real = [1.0, 2.0, 3.0]
tuple_real ([1,2,3], Real)

************************************************************************************************************************
* 转换长度为1的字符串为整数
* 等价 => Ord := ord(T)
************************************************************************************************************************
* Ord = 65
tuple_ord  ('A', Ord)

************************************************************************************************************************
* 转换字符串为整数
* 等价 => Ords := ords(T)
************************************************************************************************************************
* Ords = [65, 66]
tuple_ords (['A','B'], Ords)

************************************************************************************************************************
* 四舍五入运算
* 等价 => Round := round(T)
************************************************************************************************************************
* Round = [1, 2, 2]
tuple_round([1.2,1.5,1.6], Round)

7. 字符串格式化

************************************************************************************************************************
* 格式化字符串 tuple_string( : : T, Format : String)
* Format string: <flags><field width><precision><conversion characters>
* flags: 
*    零个或多个标记，按任何顺序排列。修改转换规则的含义
*    - 左对齐。默认是右对齐
*    + 有符号。以正负号开头
*    <space> 如果转换的第一个字符不是符号，则在前面添加空白
*            但+和space同时出现，则不起作用
*    # 值被转换为备用格式。
*      对d和s的转换无效
*      o
* field width:
*    一个十进制数字字符串用于指定最小的宽度
*    如果转换结果的宽度小于给定的宽度，则根据左右对齐填充在前后添加空白
* precision:
*    对于d,o,x,X指定精度的最小位数
*    对于e,f精度出现在点字符后
*    对于g最大数量的字符
*    对于s最大数量的字符串被打印
* conversion characters:
*    指定转换的类型，精度分量指定最小的宽度
*     d 有符号十进制
*     o 无符号8进制
*     x 无符号十六进制，小写字母
*     X 无符号十六进制，大写字母
*     f 浮点数
*     e,E 科学计数法
************************************************************************************************************************
* 数值格式化成字符串
************************************************************************************************************************
* String = '-23'
tuple_string (-23, 'd', String)

* String = '23.00     '
tuple_string (23, '-10.2f', String)

* String = '4.0000000'
tuple_string (4, '.7f', String)

* String = ' +1234.568'
tuple_string (1234.56789, '+10.3f', String)

* String = 'ff'
tuple_string (255, 'x', String)

* String = 'FF'
tuple_string (255, 'X', String)

* String = '00255'
tuple_string (0xff, '.5d', String)

************************************************************************************************************************
* 字符串格式化
************************************************************************************************************************
* String = '     total'
tuple_string ('total', '10s', String)

* String = 'total     '
tuple_string ('total', '-10s', String)

* String = 'tot       '
tuple_string ('total', '-10.3s', String)

* String = '-1234.57'
tuple_string (-1234.56789, '-', String)

8. 创建

************************************************************************************************************************
* 等价 => Concat := [T1, T2]
************************************************************************************************************************
tuple_concat(1,2,Concat)

************************************************************************************************************************
* 等价 => Newtuple := gen_tuple_const(Length, Const)
************************************************************************************************************************
tuple_gen_const(10,1,Newtuple)

************************************************************************************************************************
* 等价 => Sequence := [Start:Step:End]
************************************************************************************************************************
tuple_gen_sequence(0,10,1,Sequence)

************************************************************************************************************************
* 0-1之间的随机数
* 等价 => Rand := rand(Length)
************************************************************************************************************************
tuple_rand(5,Rand)

9. 元素顺序

************************************************************************************************************************
* 等价 => Inverted := inverse(Tuple)
************************************************************************************************************************
tuple_inverse([1,5,2,3],Inverted)

************************************************************************************************************************
* 等价 => Sorted := sort(Tuple)
* 元素增序排列
************************************************************************************************************************
tuple_sort([1,5,2,3], Sorted)

************************************************************************************************************************
* 等价 => Indices := sort_index(Tuple)
************************************************************************************************************************
tuple_sort_index([1,5,2,3],Indices)

10. 特征

************************************************************************************************************************
* 方差
* 等价 => Deviation := deviation(Tuple)
************************************************************************************************************************
tuple_deviation([1,5,2,3,2,4,3,1,2,3,4],Deviation)

************************************************************************************************************************
* 计算值的分布情况 tuple_histo_range( : : Tuple, Min, Max, NumBins : Histo, BinSize)
* 计算在指定范围内的元组值的分布情况
* 值的范围被划分到NumBins个盒子中，每个盒子的大小为 BinSize = (Max - Min) / NumBins。
* 如果输入值都是整数，盒子的大小为：BinSize = (Max - Min + 1) / NumBins。
************************************************************************************************************************
* Histo   = [5, 5, 1]
* BinSize = 1.66667
tuple_histo_range ([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], 1, 5, 3, Histo, BinSize)

************************************************************************************************************************
* 等价 => Length := |Tuple|
************************************************************************************************************************
tuple_length([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], Length)

************************************************************************************************************************
* 等价 => Max := max(Tuple)
************************************************************************************************************************
tuple_max([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], Max)

************************************************************************************************************************
* 等价 => Mean := mean(Tuple)
************************************************************************************************************************
tuple_mean([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], Mean)

************************************************************************************************************************
* 等价 => Median := median(Tuple)
************************************************************************************************************************
tuple_median([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], Median)

************************************************************************************************************************
* 等价 => Min := min(Tuple)
************************************************************************************************************************
tuple_min([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], Min)

************************************************************************************************************************
* 等价 => Sum := sum(Tuple)
************************************************************************************************************************
tuple_sum([1, 5, 2, 3, 2, 4, 3, 1, 2, 3, 4], Sum)

11. 逻辑运算

************************************************************************************************************************
* 输入只能为整数
* 等价 => And := T1 and T2
************************************************************************************************************************
* And = 1
tuple_and(1 , 2, And)

************************************************************************************************************************
* 等价 => Not := not T1
************************************************************************************************************************
* Not = 0
tuple_not(1,Not)

************************************************************************************************************************
* 等价 => Or := T1 or T2
************************************************************************************************************************
* Or = 1
tuple_or(1,2,Or)

************************************************************************************************************************
* 等价 => Xor := T1 xor T2
************************************************************************************************************************
* Xor = 0
tuple_xor(1, 2, Xor)

12. 管理

************************************************************************************************************************
* 根据指定索引插入元素, 索引不能大于当前元组的长度
************************************************************************************************************************
* Extend = [1, 45, 2, 3]
tuple_insert([1,2,3], 1, 45, Extended)

************************************************************************************************************************
* 删除指定索引的元素
* 等价 => Reduced := remove(Tuple, Index)
************************************************************************************************************************
* Reduced = [2, 3]
tuple_remove([1, 2, 3],0,Reduced)

************************************************************************************************************************
* 替换指定索引的元素
* 等价 => Replaced := replace(Tuple, Index, ReplaceTuple)
************************************************************************************************************************
* Replaced = [1, 2, 5]
tuple_replace([1,2,3], 2, 5,Replaced)

13. 选择

************************************************************************************************************************
* 在元组中查找指定元组
* 等价 => Indices := find(Tuple, ToFind)
************************************************************************************************************************
tuple_find([3,4,5,6,1,2,3,4,0], [3,4], Indices)

************************************************************************************************************************
* 等价 => Index := find_first(Tuple, ToFind)
************************************************************************************************************************
tuple_find_first([3,4,5,6,1,2,3,4,0], [3,4], Indices)

************************************************************************************************************************
* 等价 => Index := find_last(Tuple, ToFind)
************************************************************************************************************************
tuple_find_last([3,4,5,6,1,2,3,4,0], [3,4], Indices)

************************************************************************************************************************
* 等价 => Selected := firstn(Tuple, Index)
************************************************************************************************************************
tuple_first_n([3,4,5,6,1,2,3,4,0], 5, Indices)

************************************************************************************************************************
* 等价 => Selected := lastn(Tuple, Index)
************************************************************************************************************************
tuple_last_n([3,4,5,6,1,2,3,4,0], 5, Indices)

************************************************************************************************************************
* 等价 => Selected := Tuple[Index]
*         Selected := subset(Tuple, Index)
************************************************************************************************************************
tuple_select([3,4,5,6,1,2,3,4,0], 0,Indices)

************************************************************************************************************************
* 根据掩码选择元素，0表示不选择，1表示选择
* 等价 => Selected := select_mask(Tuple, Mask)
************************************************************************************************************************
tuple_select_mask([0,1,2,3,4,5], [0,1,0,1,0,1],Selected)

************************************************************************************************************************
* 等价 => Selected := Tuple[Leftindex:Rightindex]
************************************************************************************************************************
tuple_select_range([3,4,5,6,1,2,3,4,0], 0,5,Selected)

************************************************************************************************************************
* 先排序，后按位置进行选择
* 等价 => Selected := select_rank(Tuple, RankIndex)
************************************************************************************************************************
tuple_select_rank([3,4,5,6,1,2,3,4,0], 0, Selected)
* 等价 => Selected := Tuple{Index}
tuple_str_bit_select([3,4,5],2,Selected)
tuple_str_bit_select(['abc','bcde'],2,Selected)

************************************************************************************************************************
* 除了一个元组的连续相同元素外，放弃其他所有元素
* 等价 => Uniq := uniq(Tuple)
************************************************************************************************************************
tuple_uniq([0,0,1,1,1,2,0,1],Uniq)

14. 集合

************************************************************************************************************************
* 等价 => Difference := difference(Set1, Set2)
************************************************************************************************************************
tuple_difference( [0,1,3,3,5],  [2,3,5,10], Difference)

************************************************************************************************************************
* 等价 => Intersection := intersection(Set1, Set2)
************************************************************************************************************************
tuple_intersection( [0,1,3,3,5],  [2,3,5,10], Difference)

************************************************************************************************************************
* 仅保留一个连续相同的元素
* 等价 => SymmDiff := symmdiff(Set1, Set2)
************************************************************************************************************************
tuple_symmdiff( [0,1,3,3,5],  [2,3,5,10], Difference)

************************************************************************************************************************
* 等价 => Union := union(Set1, Set2)
************************************************************************************************************************
tuple_union( [0,1,3,3,5],  [2,3,5,10], Difference)

15. 获取系统环境变量

************************************************************************************************************************
* 获取环境变量的值
* 等价 => Values := environment(Names)
************************************************************************************************************************
tuple_environment('PATH',PathValue)

16. 正则表达式

************************************************************************************************************************
* 正则表达式
* ^      匹配字符串的开头
* $      匹配字符串的结尾 (不支持字符串尾部的换行符)
* .      匹配除换行符意外的任何字符
* [...]  匹配列表中的任意一个字符
*        如果列表的第一个字符是^，则不匹配列表中的任何字符
*        可以使用连字符-，表示连续的字符
*        除字符\意外，其他字符在列表中都表示其原始含义

* 匹配量词
* *      匹配其前的字符或组零次或多次
* +      匹配一次或多次
* ?      匹配零次或一次
* {n,m}  匹配最少n次，最多m次
* {n}    匹配n次
* 默认情况下，匹配量词的结果是贪婪的，即尽可能多的匹配更多的字符。可以在量
* 词后加?，表示尽可能少的匹配字符

* ( )    对子模式分组，并创建捕获组。被组捕获的子串将独立存储
* (?: )  在不创建捕获组的情况下对子模式进行分组

* \      转义字符
*        \d,\D  匹配数字
*        \w,\W  匹配字母、数字、下划线
*        \s,\S  匹配空白字符
*        \b,\B  匹配字符边界

* 额外特征
* ignore_case                        忽略大小写
* multiline                          在模式串的前后分别添加^和$
* dot_matches_all                    使.能够匹配换行符
* newline_lf/newline_crlf/newline_cr 指定换行符的类别，默认：
*                                    Windows: CR/LF
*                                    Unix-like: LF
************************************************************************************************************************

************************************************************************************************************************
* 验证字符串中是否有满足正则表达式模板的子串
* 等价 => NumMatches := regexp_test(Data, Expression) or 
*        NumMatches := Data =~ Expression
************************************************************************************************************************
tuple_regexp_test ('p10662599755', '[A-Z]*', Result)

************************************************************************************************************************
* Returns 0
************************************************************************************************************************
tuple_regexp_test ('p10662599755', ['[A-Z]*','ignore_case'], Result)


* Returns 1
************************************************************************************************************************
* 从字符串中返回【第一个】匹配正则模板的子串
* 等价 => Matches := regexp_match(Data, Expression)
* abba中满足模式a*b*的子串有两个，分别为：abb,a
************************************************************************************************************************
tuple_regexp_match ('abba', 'a*b*', Result)

************************************************************************************************************************
* Returns 'abb'
* abba中满足模式b*a*的子串有两个，分别为：a,bba
************************************************************************************************************************
tuple_regexp_match ('abba', 'b*a*', Result)

************************************************************************************************************************
* Returns 'a'
************************************************************************************************************************
tuple_regexp_match ('abba', 'b+a*', Result)

************************************************************************************************************************
* Returns 'bba'
************************************************************************************************************************

tuple_regexp_match ('abba', '.a', Result)

************************************************************************************************************************
* Returns 'ba'
************************************************************************************************************************
tuple_regexp_match ('abba', '[ab]*', Result)
* Returns 'abba'

************************************************************************************************************************
* 提取子模式子串
************************************************************************************************************************
tuple_regexp_match (['img123','img124'], 'img(.*)', Result)

************************************************************************************************************************
* Returns ['123','124']
************************************************************************************************************************
tuple_regexp_match ('mydir/img001.bmp', 'img(.*)\\.(.*)', Result)
* Returns ['001','bmp']

************************************************************************************************************************
* 替换【第一个】匹配结果
* 可选项：replace_all 替换所有匹配结果
* $0 引用第一个子模式的匹配结果
* $i(i<=9)引用第i+1个子模式的匹配结果
* $$引用字符$
* 等价 => Result := regexp_replace(Data, Expression, Replace)
************************************************************************************************************************
tuple_regexp_replace(['img10.bmp','img11.bmp','img12.bmp'], 'img(.*).bmp', 'out$1.txt', Result)
* Returns ['out10.txt','out11.txt','out12.txt']

************************************************************************************************************************
* 在元组的元素中应用正则表达式，并提取满足条件的元素
* 可选项：invert_match 反转匹配结果
* 等价 => Selection := regexp_select(Data, Expression)
************************************************************************************************************************
tuple_regexp_select (['a.png','b.txt','c.bmp','d.dat'], '.(bmp|png)', Result)

************************************************************************************************************************
* Returns ['a.png','c.bmp']
************************************************************************************************************************
tuple_regexp_select (Result, ['training','invert_match'], Matches)
* Returns all file names that do *not* contain the string 'training'

17. 字符串分割

************************************************************************************************************************
* 通过指定的字符集分割字符转
* 如果需要分割的元组长度和分隔符的元组长度相同，则使用对应元素进行分割
* 否则，引用分隔符元组中的每个字符串配别对输入元组进行分割
* 等价 => Substrings := split(String, Separator)
************************************************************************************************************************
tuple_split('data1;data2:7;data3',[';',':;'], Substrings)

************************************************************************************************************************
* Substrings = ['data1', 'data2:7', 'data3', 'data1', 'data2', '7', 'data3']
************************************************************************************************************************
tuple_split('1,2,3,4,5',',', Substrings)

************************************************************************************************************************
************************************************************************************************************************
* 字符串查找
************************************************************************************************************************
************************************************************************************************************************

************************************************************************************************************************
* 提取从开头到指定索引的子串
* 等价 => Substring := str_firstn(String, Position)
************************************************************************************************************************
tuple_str_first_n('1,2,3,4,5', 4, Substring)

************************************************************************************************************************
* 提取从指定索引到字符串结尾的子串
* 等价 => Substring := str_lastn(String, Position)
************************************************************************************************************************
tuple_str_last_n('1,2,3,4,5', 4, Substring)

************************************************************************************************************************
* 正向查找字符
* 等价 => Position := strchr(String, ToFind)
************************************************************************************************************************
tuple_strchr('1,2,3,4,5',',3', Position)

************************************************************************************************************************
* 方向查找字符
* 等价 => Position := strrchr(String, ToFind)
************************************************************************************************************************
tuple_strrchr('1,2,3,4,5',',3', Position)

************************************************************************************************************************
* 正向查找字符串
* 等价 => Position := strstr(String, ToFind)
************************************************************************************************************************
tuple_strstr('1,2,3,4,5', ',2', Position)

************************************************************************************************************************
* 反向查找字符串
* 等价 => Position := strrstr(String, ToFind)
************************************************************************************************************************
tuple_strrstr('1,2,3,4,5', ',2' ,Position)


************************************************************************************************************************
* 获取字符串元组中每个元素的长度
* 等价 => Length := strlen(T1)
************************************************************************************************************************
tuple_strlen(['123','adfad','dafdfasfd'], Length)

************************************************************************************************************************
* 获取子串
************************************************************************************************************************
* 等价 => Substring := String{Position1:Position2}
tuple_substr('dafdfasfd', 2,4,Substring1)

18. 类型判断

************************************************************************************************************************
* 是否全部元素的类型都为整型，空元组也可以是整型
* 等价 => IsInt := is_int(T)
************************************************************************************************************************
* IsIntA = false
tuple_is_int ([3.1416,'pi',3], IsIntA)
* IsIntB = true  
tuple_is_int ([1,2,3], IsIntB)
* IsIntC = true
tuple_is_int ([], IsIntC)

************************************************************************************************************************
* 判断元组元素的类型是否为整型
* 等价 => IsInt := is_int_elem(T)
************************************************************************************************************************
* IsInt = [false, false, true, false]
tuple_is_int_elem ([3.1416,'pi',3,3.0], IsInt)

************************************************************************************************************************
* 判断元组是否为混合类型
* 等价 => IsMixed := is_mixed(T)
************************************************************************************************************************
* IsMixedA = true
tuple_is_mixed ([3.1416,'pi',3], IsMixedA)
* IsMixedB = false  
tuple_is_mixed (['a','b','111'], IsMixedB)
* IsMixedC = true
tuple_is_mixed ([], IsMixedC)

************************************************************************************************************************
* 判断元组的所有元素是否都是浮点型
* 等价 => IsReal := is_real(T)
************************************************************************************************************************
* IsRealA = false
tuple_is_real ([3.1416,'pi',3], IsRealA)
* IsRealB = true
tuple_is_real ([1.0,2.0,3.0], IsRealB)
* IsRealC = true
tuple_is_real ([], IsRealC)

************************************************************************************************************************
* 判断元组的每个元素是否为浮点型
* 等价 => IsReal := is_real_elem(T)
************************************************************************************************************************
* IsReal = [true, false, false, true]
tuple_is_real_elem ([3.1416,'pi',3,3.0], IsReal)

************************************************************************************************************************
* 判断元组的所有元素是否都为字符串
* 等价 => IsString := is_string(T)
************************************************************************************************************************
* IsStringA = false
tuple_is_string ([3.1416,'pi',3], IsStringA)
* IsStringB = true
tuple_is_string (['a','b','111'], IsStringB)
* IsStringC = true
tuple_is_string ([], IsStringC)

************************************************************************************************************************
* 判断元组的每个元素是否为字符串
* 等价 => IsString := is_string_elem(T)
************************************************************************************************************************
* IsString = [false, true, false]
tuple_is_string_elem ([3.1416,'pi',3], IsString)

************************************************************************************************************************
* 元组的数据类型
* H_TYPE_INT    (1)
*    所有元素的数据类型都为整型
* H_TYPE_REAL   (2)
*    所有元素的数据类型都为浮点型
* H_TYPE_STRING (4)
*    所有元素的数据类型都为字符串
* H_TYPE_MIXED  (8)
*    1. 元素拥有多种数据类型
*    2. 输入元组在修改单个元素的数据类型之后，即使所有元素的数据类型变成相
*       同的。但由于运行时的原因，导致未能自动的优化。
* H_TYPE_ANY    (15)
*    空元组
*    空元组可以是任何类型，因此使用tuple_is_int，tuple_is_mixed，
*    tuple_is_string，tuple_is_real的结果都为1
* 等价 => Type := type(T)
************************************************************************************************************************
test := [3.1416,'pi',3]
tuple_type (test, TypeA)
* TypeA = H_TYPE_MIXED
test[1] := 4
tuple_type (test, TypeA)
* TypeA = H_TYPE_MIXED
tuple_type (['a','b','111'], TypeB)
* TypeB = H_TYPE_STRING
tuple_type ([], TypeC)
* TypeC = H_TYPE_ANY
************************************************************************************************************************
* 元组中元素的数据类型
* H_TYPE_INT    (1)
* H_TYPE_REAL   (2)
* H_TYPE_STRING (4)
* 等价 => Types := type_elem(T)
************************************************************************************************************************
tuple_type_elem ([3.1416,'pi',3], Types)

zhy29563

关注

12
点赞
踩
51

收藏

觉得还不错? 一键收藏
打赏
2
评论
【HALCON】【TUPLE】元组操作

目录1. 基本数学运算2. 三角函数3. 指数与对数4. 位运算5. 比较运算5.1将元组作为整体进行比较（比较元组的长度、类型、值），结果返回一个值5.2将元组对应元素进行比较（比较元组的长度、类型、值），返回多个值6. 转换7. 字符串格式化8. 创建9. 元素顺序10. 特征11.逻辑运算12.管理13.选择14. 集...
复制链接

扫一扫