HALCON数据结构之字符串

1.1 String字符串的基本操作

*将数字转换为字符串或修改字符串
*tuple_string (T, Format, String) //HALCON语句
*String:= T $ Format  //赋值操作

*Format string 由以下四个部分组成：
*<flags><field width>.<precision><conversion 字符>

*1. flags 标志

*1.1 字符'-'
*转换的结果是在字段中左对齐。

*1.2 字符'+'

*带符号转换的结果总是以符号'+'或'-'开头。

*1.3 <space>

*如果带符号转换的第一个字符不是符号，则在结果前面加一个空格字符。
*这意味着如果空格标志和+标志同时出现，则忽略空格标志。

* 1.4 '#'

*该被转换为“替代形式”。对于d和s转换，此标志不起作用。

* 1.5 '0'

*该值应该是零填充。对于d、o、u、x、x、e、e、f、f、g和g转换，转换后的值在左侧用零填充，而不是空白。如果同时出现0和-标志，则忽略0标志。如果用数字转换(d、o、u、x和x)给出精度，则忽略0标志。

* 2. field width

*一个可选的十进制数字字符串，用于指定最小字段宽度。

*对于输出字段，如果转换值的字符少于字段宽度，则在字段宽度的左侧填充(如果给出了左侧调整标志-，则在右侧填充)。

* 3. precision

*指定d、o、x或x转换时出现的最小位数(该字段用前导零填充)，e和f转换时出现在基数字符之后的位数，g转换时有效位数的最大数目，或s转换时从字符串打印的最大字符数。

* 4. conversion characters

*转换字符表示要应用的转换类型

* 4.1 d,u,o,x,X

*整数参数以有符号十进制(d)、无符号十进制(u)、无符号八进制(o)或无符号十六进制(x和x)的形式打印。x转换使用数字和字母0123456789abcdef, x转换使用数字和字母0123456789ABCDEF。

* 4.2 f

*浮点数参数以[-]dddrddd格式的十进制形式打印，其中基数字符r后面的位数等于精度规范。
*如果从参数中省略精度，则输出六位数字;如果精度显式为0，则不显示基数。

* 4.3 e,E

*浮点数参数以[-]drdddepmdd格式打印，其中基数字符前面有一位数字，后面的位数等于精度。
* 4.4 g,G

*浮点数参数以f格式打印(对于G转换字符，则以e格式打印)，精度指定有效数字的个数。
* 4.5 s

*参数被视为一个字符串，字符串中的字符将被打印，直到字符串的末尾或达到参数的精度规范所指示的字符数。

* 4.6 b

*类似于s转换说明符，不同之处是字符串可以包含反斜杠转义序列，然后将其转换为它们所表示的字符。

*示例1:将数字转换为字符串
*
* '     23.00'
tuple_string (23, '10.2f', String)
String := 23$'10.2f'
*
* '23.00     '
tuple_string (23, '-10.2f', String)
String := 23$'-10.2f'
*
* '4.0000000'
tuple_string (4, '.7f', String)
String := 4$'.7f'
*
* ' +1234.568'
tuple_string (1234.56789, '+10.3f', String)
String := 1234.56789$'+10.3f'
*
* 'ff'
tuple_string (255, 'x', String)
String := 255$'x'
*
* 'FF'
tuple_string (255, 'X', String)
String := 255$'X'
*
* '00255'
tuple_string (0xff, '.5d', String)
String := 0xff$'.5d'

*示例2:修改字符串
*
* '     total'
tuple_string ('total', '10s', String)
String := 'total'$'10s'
*
* 'total     '
tuple_string ('total', '-10s', String)
String := 'total'$'-10s'
*
* 'tot       '
tuple_string ('total', '-10.3s', String)
String := 'total'$'-10.3s'

*示例3：将整数按格式转换为字符串

d1 := 12345$'#o'  //8进制，0为前缀
d2 := 12345$'#x'  //16进制，0x为前缀，3039为赋值
d3 := 12345$'#X'  //16进制，0X为前缀，3039为赋值
d4 := 12345$'#f'  //double型，默认保留小数点后六位

d5 := 12345$'#g'  //使数字始终保持六位，不足补零
d6 := 12345$'#G'  //使数字始终保持六位，不足补零
d7 := 12345$'#e'  //转换成科学计数
d8 := 12345$'#E'  //转换成科学计数

d9 := 12345$'6'   //小于六位时，文本右对齐，大于不影响
d10 := 12345$'-6'  //小于六位时，文本左对齐，大于不影响
d11 := 12345$'.6'  //小于六位时，在左边补零，大于不影响
d12 := 12345$'10.5'  //小于10位时，文本右对齐；小于5位则在左边补零，大于不影响

*示例4：修改字符串
s1 := 'HALCON'$'10'      //文本右对齐
s2 := 'HALCON'$'-10'     //文本左对齐

1.2 String字符串的转换

*1、将一个元组转换为字符串元组

tuple_string ([1,2,3,4.0,5.0,6.0], '.3f', String1)
String1:= [1,2,3,4.0,5.0,6.0] $ '.1f'

*2、检查元组中的元素(整数、实数和字符串)是否表示数字

tuple_is_number (String1, IsNumber1)
IsNumber1:=is_number(String1)

*3、将输入元组转换为数字元组

tuple_number (String1, Number1)
Number1:=number(String1)

*4、将元组中长度为1的字符串元素转换为它们相应的ASCII元组

String2:=['1', '2', '3', '4', '5', '6']
tuple_ord (String2, Ord1)
Ord1:= ord(String2)

*5、将一个字符串元组转换为对应的ASCII整数

String3:=['1a', '2b', '3c', '4d', '5e', '6f']
tuple_ords (String3, Ords1)
Ords1:= ords(String3)

*6、根据ASCII码将整型元组转换为字符元组(每个元素长度为1)

tuple_chr (Ord1, Chr1)
Chr1:=chr(Ord1)

*7、根据ASCII码将整型元组转换为字符元组

tuple_chrt (Ords1, Chrt1)
Chrt1:=chrt(Ords1)

1.3 String字符串的分割

String1:='www.277.558.com'
String2:= ['alpha:1', 'beta:2', 'gamma:3'] 

*1、使用预定义的分隔符将字符串拆分为子字符串(分割字符在原字符串中被删除)

tuple_split (String1, '.', Substrings1)
tuple_split (String2, ':', Substrings2)

tuple_split (String2, 'a:', Substrings3)
tuple_split (String2, ':123', Substrings3)

Substrings3:=split(String2, ':123')

*2、从输入的字符串元组中截取出第0-n位置处的字符，并作为新的字符串元组返回

tuple_str_first_n (String1,6 , Substring4)
tuple_str_first_n (String2,[0,1,2] , Substring5)
Substring5:=str_firstn(String2,[0,1,2])

*3、从输入的字符串元组中截取出第n-最后位置处的字符，并作为新的字符串元组返回

tuple_str_last_n (String1,6 , Substring6)
tuple_str_last_n (String2,[6,5,6] , Substring7)
Substring7:=str_lastn(String2,[6,5,6])

1.4 String字符串的搜索

String1:='www.111.www.277.558.com'
String2:= ['alpha:1', 'beta:2', 'gamma:3'] 

*1、获取字符串元组中每个字符串的长度

tuple_strlen (String1, Length1)
tuple_strlen (String2, Length2)
Length2:=strlen(String2)

*2、前向搜索字符串元组中的字符，并输出对应的位置

*在输入元组的字符串元素中前向搜索输入元组ToFind的字符，并输出对应的位置

tuple_strchr (String1,'w' , Position1)
tuple_strchr (String1,['2','5','c'] , Position2)

tuple_strchr (String2,'a' , Position3)
tuple_strchr (String2,['1','2','3'] , Position4)

Position4:=strchr(String2,['1','2','3'])

*3、前向搜索字符串元组中的字符串，并输出对应的位置

*在输入元组的字符串元素中前向搜索输入元组ToFind的字符串，并输出对应的位置

tuple_strstr (String1,'277' , Position5)
tuple_strstr (String1,['www','257','588','com'] , Position6)

tuple_strstr (String2,'a:' , Position7)
tuple_strstr (String2,['a:1','a:2','a:3'] , Position8)

Position8:=strstr(String2,['a:1','a:2','a:3'])

*4、后向搜索字符串元组中的字符，并输出对应的位置

*在输入元组的字符串元素中后向搜索输入元组ToFind的字符，并输出对应的位置

*后向搜索，即从最后一个字符到第一个字符检查每个字符串

tuple_strrchr (String1,'w' , Position9)
tuple_strrchr (String1,['2','5','c'] , Position10)

tuple_strrchr (String2,'a' , Position11)
tuple_strrchr (String2,['1','2','3'] , Position12)

Position12:=strrchr(String2,['1','2','3'])

*5、后向搜索字符串元组中的字符串，并输出对应的位置

*在输入元组的字符串元素中后向搜索输入元组ToFind的字符串，并输出对应的位置

*后向搜索，即从最后一个字符到第一个字符检查每个字符串

tuple_strrstr (String1,'277' , Position13)
tuple_strrstr (String1,['www','257','588','com'] , Position14)

tuple_strrstr (String2,'a:' , Position15)
tuple_strrstr (String2,['a:1','a:2','a:3'] , Position16)

Position16:=strrstr(String2,['a:1','a:2','a:3'])

1.5 String字符串的正则表达式

1.5.1 测试字符串是否匹配正则表达式

*测试字符串是否匹配正则表达式
*tuple_regexp_test( : : Data, Expression : NumMatches)

*允许ab重复3次
tuple_regexp_test ('ababab', '(ab){3}', NumMatches1)

*允许ab重复3次
tuple_regexp_test ('abababa', '(ab){3}', NumMatches2)

*开头匹配ab，结尾匹配ab，并且重复3次
tuple_regexp_test ('ababab', '^(ab){3}$', NumMatches3)

*匹配失败
tuple_regexp_test ('abababa', '^(ab){3}$', NumMatches3)

1.5.2 使用正则表达式处理文件名

get_system ('image_dir', HalconImages)
get_system ('operating_system', OS)
if (OS{0:2} == 'Win')
    tuple_split (HalconImages, ';', HalconImagesSplit)
else
    tuple_split (HalconImages, ':', HalconImagesSplit)
endif
list_files (HalconImagesSplit[0], ['files', 'follow_links'], Files)

*选择后缀是png文件
tuple_regexp_select (Files, '\\.png$', FilesPNG)

*删除所有以数字结尾的文件名
tuple_regexp_select (FilesPNG, ['\\d\\.png$', 'invert_match'], FilesNoDigit)

*提取不带斜杠的文件名(剥离目录部分)
tuple_regexp_match (FilesNoDigit, '[^/\\\\]*.png', ShortNames)

*转换文件名的后缀名
tuple_regexp_replace (ShortNames, '(.*)\\.png$', 'out_$1.jpg', ConvertedNames)

*统计包含字符'-'或下划线的文件数量
tuple_regexp_test (ShortNames, '_|-', NumCombined)

*再次统计以数字结尾的文明名的文件数量并计算百分比
if (|ShortNames| > 0)
    Result := 100.0 * regexp_test(ShortNames,'\\d') / |ShortNames| + '% of PNG file names contain a digit'
endif
* Return letters 2-n of all files starting with 'a'

*选择以a为开头的元素['angio-part.png', 'atoms.png', 'autobahn.png']
Selection1 := regexp_select(ShortNames, '^a')
Match1:= regexp_match(Selection1,'^a(.*)')

*返回所有以'a'开头的文件名中的第2-n个字母
Result := regexp_match(regexp_select(ShortNames,'^a'),'^a(.*)')

* Data =~ Expression 是regexp_test的缩写，用于布尔表达式
if (ShortNames =~ '^z')
    Result := 'A filename starting with z exists'
endif

1.5.3 使用正则表达式提取子字符串

*使用正则表达式提取子字符串
*tuple_regexp_match( : : Data, Expression : Matches)

* 正则表达式含义:

* ^ 匹配字符串开头；
* $ 匹配字符串的结尾(允许尾部换行符)；
* . 匹配除换行符以外的任何字符；
* [...] 匹配括号中列出的任何字符。如果第一个字符是'^'，这将匹配除括号以内的其他任何字符。

* * 允许前面的文字或组0次或者多次重复；
* + 允许1次或者多次重复；
* ? 允许0次或者1次重复；
* {n,m} 允许 n 到 m 次重复；
* {n}   只允许n次重复；                             
                                                             
* ( ) 对子模式进行分组，并创建一个捕获组；
* (?:)分组子模式而不创建捕获组；                            
                                                             
* \ 转义字符
* \d,\D   匹配一个数组
* \w,\W   匹配字母、数字或下划线
* \s,\S   匹配空白字符
* \b,\B   匹配单词边界                               
                                                                                      
* 正则表达式基础用法:

*a、x*是从字符串开头开始匹配的，x*的第二次匹配是从第一次匹配到的字符串之后的子字符串开始匹配的；
*b、x(.*)提取的是x之后的子字符串；x1(.*)x2 ：获取x1-x2之间的字符串；
*c、x.是从前向后查找，匹配的结果是'x'+'x的后一个字符'(x查找的位置不是最后一个字符)；若x查找的位置是最后一个字符，则匹配的结果为''
*d、.x是从后向前查找，匹配的结果是'x的前一个字符'+'x'(x查找的位置不是第一个字符)；若x查找的位置是第一个字符，则匹配的结果为''5

*1、表达式 ^x 
                             
* 提取开头的字符串'ab'
tuple_regexp_match ('12abba', '^12', Result1)

*2、表达式 x  
  
* 提取字符串'b'                               
tuple_regexp_match ('abba', 'b', Result2) 

*3、表达式 x$ 

* 提取结尾的字符串'a'                               
tuple_regexp_match ('abba5', '5$', Result3)                              

*4、表达式 x*

* 提取字符串'a'
tuple_regexp_match ('abba', 'a*', Result4) 

* 提取字符串''
tuple_regexp_match ('abba', 'b*', Result5)  

* 提取字符串'abb'
* 剩下的字符在剩余的字符串中匹配
tuple_regexp_match ('abba', 'ab*', Result6) 

* 字符'a'在字符串的第一个位置被匹配到
tuple_regexp_match ('abba', 'a', Result61)  //'a'

* 字符'b*'在剩余字符串中再次查找
tuple_regexp_match ('bba', 'b*', Result62)  //'bb'

* 提取字符串'b'  
tuple_regexp_match ('abba', 'ba*', Result7) 

*字符'b'在字符串的第二个位置被找到
tuple_regexp_match ('abba', 'b', Result71)    // 'b'

*字符'a*'在剩余字符串中匹配再次查找
tuple_regexp_match ('ba', 'a*', Result72) // ''

* 5、表达式 x1*x2*

* 提取字符串'abb'
tuple_regexp_match ('abba', 'a*b*', Result8) 
tuple_regexp_match ('abba', 'a*', Result81)  //'a'
tuple_regexp_match ('bba', 'b*', Result82)   //'bb'
 
* 提取字符串'a'
tuple_regexp_match ('abba', 'b*a*', Result9)
tuple_regexp_match ('abba', 'b*', Result91) //''
tuple_regexp_match ('abba', 'a*', Result92) //'a'

* 6、表达式 x1+x2*

* 提取字符串'bba'
tuple_regexp_match ('abba', 'b+a*', Result10)
tuple_regexp_match ('abba', 'b+', Result101) //'bb'
tuple_regexp_match ('a', 'a*', Result102)    //'a'

*7、表达式 x.

* 提取字符串'ab'
tuple_regexp_match ('abba', 'a.', Result111)

* 提取字符串'bb'
tuple_regexp_match ('abba', 'b.', Result112)

* 提取字符串'abb'
tuple_regexp_match ('abba', 'ab.', Result113)

* 提取字符串''
tuple_regexp_match ('abba', 'ba.', Result114)

*7、表达式 .x

* 提取字符串'ba'
tuple_regexp_match ('abba', '.a', Result115)

* 提取字符串'ab'
tuple_regexp_match ('abba', '.b', Result116)

* 提取字符串''
tuple_regexp_match ('abba', '.ab', Result117)

* 提取字符串'bba'
tuple_regexp_match ('abba', '.ba', Result118)

*8、表达式[x]*

* 提取字符串'a'
tuple_regexp_match ('abba', '[a]*', Result121)

* 提取字符串''
tuple_regexp_match ('abba', '[b]*', Result122)

* 提取字符串'abba'
tuple_regexp_match ('abba', '[ab]*', Result123) 

* 提取字符串'abba'
tuple_regexp_match ('abba', '[ba]*', Result124)

*9、表达式x(.*)

* 提取字符串['mg123', 'mg124']
tuple_regexp_match (['img123','img124'], 'i(.*)', Result131)

* 提取字符串['g123', 'g124']
tuple_regexp_match (['img123','img124'], 'im(.*)', Result132)

* 提取字符串['123', '124']
tuple_regexp_match (['img123','img124'], 'img(.*)', Result133)

* 提取字符串['23', '24']
tuple_regexp_match (['img123','img124'], 'img1(.*)', Result134)

* 提取字符串['3', '4']
tuple_regexp_match (['img123','img124'], 'img12(.*)', Result135)

* 提取字符串['', '']
tuple_regexp_match (['img123','img124'], 'img123(.*)', Result136)

*10、表达式 x1(.*)x2 ：获取x1-x2之间的字符串

* 提取字符串['110', '111', '112']
tuple_regexp_match (['img110.bmp','img111.bmp','img112.bmp'], 'img(.*).bmp', Result137)

*11、表达式 x(.*)\\.(.*) :以'.'为分割分组 x(.*)的结果

* 提取字符串 ['001','bmp']
tuple_regexp_match ('mydir/img001.bmp', 'img(.*)\\.(.*)', Result14)

1.5.4 使用正则表达式替换子字符串

*使用正则表达式替换子字符串
*tuple_regexp_replace( : : Data, Expression, Replace : Result)

*匹配失败，在字符串的前面添加'x'
tuple_regexp_replace ('abba', 'b*', 'x', Result1)

*将第一个小'b' 替换为'x'
tuple_regexp_replace ('abba', 'b', 'x', Result2)  
 
*将所有的小'b' 替换为'x'
tuple_regexp_replace ('abba', ['b', 'replace_all'], 'x', Result3) 

*替换为['outimg10.bmp.txt', 'outimg11.bmp.txt', 'outimg12.bmp.txt']
tuple_regexp_replace(['img10.bmp','img11.bmp','img12.bmp'], \
                     'img(.*).bmp', 'out$0.txt', Result4)

*替换为['out10.txt', 'out11.txt', 'out12.txt']
tuple_regexp_replace(['img10.bmp','img11.bmp','img12.bmp'], \
                     'img(.*).bmp', 'out$1.txt', Result5)

*替换为['out.txt', 'out.txt', 'out.txt']
tuple_regexp_replace(['img10.bmp','img11.bmp','img12.bmp'], \
                     'img(.*).bmp', 'out$2.txt', Result6)

*提取的字符串['1234567', '2345678', '3456789']
tuple_regexp_match (['SN/1234567-X', 'SN/2345678-Y', 'SN/3456789-Z'], 'SN/(\\d{7})-([A-Z])', Matches1)

*替换为['Product Model X, Serial Number 1234567', 'Product Model Y, Serial Number 2345678', 'Product Model Z, Serial Number 3456789']
tuple_regexp_replace (['SN/1234567-X', 'SN/2345678-Y', 'SN/3456789-Z'], 'SN/(\\d{7})-([A-Z])', 'Product Model $2, Serial Number $1', Result7)

*提取的字符串['01', '06']
tuple_regexp_match (['01/04/2000', '06/30/2007'], '(\\d{2})/(\\d{2})/(\\d{4})', Matches2)
tuple_regexp_replace (['01/04/2000', '06/30/2007'], '(\\d{2})/(\\d{2})/(\\d{4})', 'Day: $2, Month: $1, Year: $3', Result8)

1.5.5 选择匹配正则表达式的元组元素

*选择匹配正则表达式的元组元素
*tuple_regexp_select( : : Data, Expression : Selection)

get_system ('image_dir', HalconImages)
get_system ('operating_system', OS)
if (OS{0:2} == 'Win')
    tuple_split (HalconImages, ';', HalconImagesSplit)
else
    tuple_split (HalconImages, ':', HalconImagesSplit)
endif

list_files (HalconImagesSplit[0], ['files', 'follow_links'], Files)

*返回所有不包含字符串'pcb'的文件名
tuple_regexp_select (Files, ['pcb','invert_match'], Result2)

*返回元组元素 ['a.png','c.bmp']
tuple_regexp_select (['.','..','mydir','a.png','b.txt','c.bmp','d.dat'], \
                     '.(bmp|png)', Result1)