Halcon变量控制类型、数据类型转换、字符串格式化、元组操作

*变量控制类型：

Halcon的基础控制类型共5种：string(字符串)、integer(整数)、real(实数/小数)、tuple(元组)、handle(句柄)

数据类型核心特性总结 :
1. 弱类型语言：Halcon无需声明变量类型，赋值即定义，自动识别类型
2. 类型兼容：整数可以自动转为实数，反之需要强制转换（tuple_real()）
3. 元组万能：所有变量都是元组，元组可以嵌套元组，支持所有运算/操作

*// ===================== Halcon 五大核心数据类型  =====================
*// Halcon的基础控制类型共5种：string(字符串)、integer(整数)、real(实数/小数)、tuple(元组)、handle(句柄)


*// -------------------- 1. string 字符串类型：单引号包裹 --------------------
str := '哈工大'
address := '经开第十六大街'
str_mix := 'Halcon字符串：123abc视觉' 

*// -------------------- 2. integer 整数类型：正整数/负整数/0，无小数位 --------------------
num := 123
count := 100
sumAdd := 5050
int_neg := -99
int_zero := 0

*// -------------------- 3. real 实数/浮点型：带小数位的数值，支持科学计数法 --------------------
pai := 3.14
score := 95.5
*// 高精度小数
real_precise := 3.1415926535 
*// 科学计数法，等效 123000.0
real_science := 1.23e5       

*// -------------------- 4. handle 句柄类型：【核心】资源标识，本质是内存地址的整型映射
*// 句柄用途：标识窗口、图像、区域、XLD、文件、算子等系统资源，Halcon中最常用的是 窗口句柄/图像句柄
*// 特点：句柄是「独占资源」，使用完建议释放，避免内存泄漏；句柄变量命名规范：xxxHandle
*// 创建主窗口，返回窗口句柄WindowHandle
dev_open_window (0, 0, 800, 600, 'black', WindowHandle) 

*// -------------------- 5. tuple 元组类型：【Halcon灵魂】最核心、最常用的复合类型，重中之重
*// tuple 可以存储【所有类型】：整数、实数、字符串、句柄，支持「混合类型存储」，无类型限制
*// tuple 表示形式：必须用 [] 包裹，元素用逗号分隔；可以是空元组 []，也可以是单元素/多元素/混合元素
*// tuple 特性：Halcon中「所有变量本质都是元组」，单个数值/字符串本质是【长度为1的元组】
*// 混合类型元组（整数+实数+字符串+窗口句柄）
arr := [1,3,5,3.14,11,'abc','你好',WindowHandle] 
*// 纯整数元组
tuple_int := [10,20,30,40]                        
*// 纯字符串元组
tuple_str := ['哈工大','中国','Halcon']          
*// 长度为1的元组，等效 real类型变量
tuple_single := [99.9]                           
*// 空元组
tuple_empty := []                               

*// ===================== 数据类型核心特性总结 =====================
*// 1. 弱类型语言：Halcon无需声明变量类型，赋值即定义，自动识别类型
*// 2. 类型兼容：整数可以自动转为实数，反之需要强制转换（tuple_real()）
*// 3. 元组万能：所有变量都是元组，元组可以嵌套元组，支持所有运算/操作

*数据类型转换：

*// Halcon数据类型转换
*// 把实型（real）转换成整型int）
*// 规则：int()函数为 截断取整（直接舍弃小数部分，非四舍五入）
*// 如需四舍五入用round()
real01:= 3.14
real01_2:= 3.99
int01 := int(real01)// 截断取整 → 结果：3（非4）
int01_round := round(real01_2)// 四舍五入取整 → 结果：4

*// 把整型转换成实型
int02 := 123
*// real()
real02 := real(int02)// 结果：123.0（实型）

*// 把整型（int）转换成字符串（string）
*// 可以使用字符串拼接方式
int03:= 119
str01 := int03 + ''

*// 把实型转换成字符串类型
real03 := 3.14
str02:= real03 + ''

*字符串格式化：

*// Halcon数据类型格式化
*// 字符串格式化: //--------------------- 
*// 语法：数值$'.Nf'（N为保留的小数位数，超出部分四舍五入，不足补0）   
score:=160.61
score1:=score$'.1f'//160.6
score2:=score$'.2f'//160.61

*// 整数，默认采用的是十进制形式
*// 二进制 八进制 十进制 十六进制
*// 二进制 不  支持//--------------------- 

*// 八进制：//---------------------
*// 语法：数值$'0No'（N为目标长度，o表示八进制）
*// 语法：#o → 带0前缀的八进制；单纯'o' → 无前缀
*// 如果位数不够，左边补零，小于等于位数，没有变化
num02 := 8$'#o'// 十进制8→八进制10，带0前缀 → 结果："010"
num02_2 := 8$'o'// 无前缀八进制 → 结果："10"
num02_3 := 8$'03o'// 3位八进制，补零 → 结果："010"
num02_4 := 10$'02o'// 十进制10→八进制12，刚好2位 → 结果："12"

*// 十进制：//---------------------
*// 语法：数值$'0Nd'（N为目标长度，d表示十进制)
*// 如果位数不够，左边补零，小于等于位数，没有变化
num:=2
num2:=20
num1:=num$'02d'//02
num3:=num2$'02d'//20

*// 十六进制：//---------------------
*// 语法：数值$'0Nx'/$'0NX'（N为目标长度，x/X表示十六进制）
*// 单纯x/X → 无前缀
*// 如果位数不够，左边补零，小于等于位数，没有变化
num03 := 16$'#x'// 十进制16→十六进制10，小写前缀 → 结果："0x10"
num03_2 := 16$'#X'// 大写前缀 → 结果："0X10"
num03_3 := 16$'x'// 无前缀小写 → 结果："10"
num03_4 := 16$'03x' // 3位十六进制，补零 → 结果："010"
num03_5 := 17$'02X'// 十进制17→十六进制11，刚好2位 → 结果："11"

*// 对于小数类型来说，#f，默认保留6位//--------------------- 
*// 如果不够6位自动补零，超出会四舍五入
f3 := 1.3$'#f'// 1.3→保留6位小数，补0 → 结果："1.300000"
f3_2 := 1.3456789$'#f'// 超出6位，四舍五入 → 结果："1.345679"

*// 让数字保留6位有效数字，#g，不够补零 //--------------------- 
*// 如果超出采用科学计数法
*// '1.23457e+08'= 1.23457 *10^8
f4 := 123456789$'#g'// 有效数字超6位，科学计数法 → 结果："1.23457e+08"
f5 := 1234$'#g'// 有效数字≤6位，常规格式+补0 → 结果："1234.00"
f5_2 := 1.23$'#g'// 有效数字3位，补0至6位 → 结果："1.23000"

*// 数字转换成字符串后文本对齐//--------------------- 
*// 正数=右对齐，负数=左对齐
*// 位数不够，补空格，小于等于位数，没有变化
f6 := 12345$'4'// 右对齐，12345（5位）>4位 → 结果："12345"（无变化）
f6_2 := 123$'4'// 右对齐，123（3位）<4位 → 补空格 → 结果：" 123"
f7 := 12345$'-4'// 左对齐，12345>4位 → 结果："12345"
f7_2 := 123$'-4'// 左对齐，123<4位 → 补空格 → 结果："123 "

*// $'.数字' 如果位数不够，左边补零，小于等于位数，没有变化//--------------------- 
f8 := 123$'.4'//0123

*元组操作：

•元组对位相加:tuple_add ()

•元组对位相减:tuple_sub()

•元组对位相除:tuple_div()

•元组对位趋于:tuple_mod ()

•插入元素:tuple_insert()

•删除元素:tuple_remove()

•替换元素:tuple_remove ()

•查找元素:tuple_find_first()

•取前 N 个元素值 :tuple_first_n ()

•取指定索引位置的元素 :tuple_select ()

•去重:tuple_uniq ()

•元祖升序排序:tuple_sort()

•元组元素随机打乱:tuple_shuffle()

•元组中的元素位置翻转:tuple_inverse()

•元组中元素的类型判断:tuple_is_int()

•判断某个元素是否指定类型:tuple_is_int_elem()

•判断元组的元素是否是数字类:tuple_is_number()

•最大值:tuple_max()

•最小值:tuple_min()

•元祖元素长度(个数):tuple_length ()

•|元祖名称|--->个数:变量名称 := |元组名称|

•平均值:tuple_mean ()

•中值:tuple_median ()

•绝对值:tuple_abs ()

•向上取整:tuple_ceil ()

•向下取整:tuple_floor ()

•合并两个元组:tuple_concat ()

•并集运算:tuple_union()

•交集运算 :tuple_intersection ()

•差集运算:tuple_difference()

•补集运算 :tuple_symmdiff ()

•清除窗口:dev_clear_window ()

•展示文本:dev_disp_text()

*// Halcon元组核心操作（增删改查+运算+特殊操作）
Tuple1 :=[1,3,5,10,20,100]
Tuple2 :=[10,20,30,40,50,60]

*// 数值运算：
*// 规则：对应索引元素相加，若长度不同，短元组末尾补0后相加
*// 元组对位相加
tuple_add (Tuple1, Tuple2, Sum)
*// 元组对位相减
tuple_sub (Tuple1, Tuple2, Sub)  
*// 元组对位相除
tuple_div (Tuple1, Tuple2, Div)  
*// 元组对位取余
tuple_mod (Tuple1, Tuple2, Mod)

*// 增：插入元素
* tuple_insert(原元组, 插入位置(索引从0开始), 插入值(单值/元组), 输出元组)
* 在指定位置(多个位置不允许)可以插入单个或者一个元祖数据
tuple_insert (Tuple1, 0, 110, Extended)//[110,1,3,5,10,20,100]
tuple_insert (Extended, 0, [11,22,33], Extended1)//[11,22,33,110,1,3,5,10,20,100]

*// 删：删除元素，删除指定位置(多个位置支持)的元素值//---------------------
* tuple_remove(原元组, 删除位置(单/多索引), 输出元组)
* 规则：多位置删除时，Halcon会自动按索引从大到小删
tuple_remove (Extended1, [0,2], Reduced)//[22,110,1,3,5,10,20,100]

*// 改：替换元素，修改指定位置(多个位置支持)的元素值//---------------------
* tuple_replace(原元组, 替换位置(单/多索引), 替换值(单/多值), 输出元组)
* 规则：替换位置数量 = 替换值数量（多值时一一对应）
tuple_replace (Reduced, [2,3,4], [19,29,39], Replaced)//[22,110,19,29,39,10,20,100]

*// 查：查找元素 如果没有找到返回-1//---------------------
Tuple3 := ['张三','李四','王五','赵六','小四','张三','赵六','张三']
* 查找张三元素第一次出现的位置 0
tuple_find_first (Tuple3, '张三', Index)
* 查找张三元素最后一次出现的位置 7
tuple_find_last (Tuple3, '张三',Index2)

*// 取前 N 个元素值 返回一个元组，参数 2 为 N（数量），代表从索引 0 开始的前 N 个元素
tuple_first_n (Tuple3, 2, Selected)//['张三','李四']
* 取指定索引位置的元素 返回一个元组，参数 2 为索引列表（单 / 多索引），仅返回对应索引的元素
tuple_select (Tuple3, [0,2,4], Selected2)//['张三','王五','小四']

*// 去重：仅去除连续的重复元素, 保留第一个//---------------------
Tuple4 := ['张三','张三','张三','张三','李四','王五','赵六','小四','张三','赵六','张三']
tuple_uniq (Tuple4, Uniq)

*// 特殊操作：排序/打乱/翻转/类型判断//---------------------
Tuple5 := [1,3,100,30,50,20,80,60,40]

*// 元祖升序排序
tuple_sort (Tuple5, Sorted)

*// 元组元素随机打乱
tuple_shuffle (Sorted, Shuffled)

*// 元组中的元素位置翻转
tuple_inverse (Shuffled, Inverted)

*// 元组中元素的类型判断 1-true 0-false
tuple_is_int (Inverted, IsInt)//1
Tuple6 := [3.14,5.67,9.5]
tuple_is_int (Tuple6, IsInt2)//0

*// 判断某个元素是否指定类型
* tuple is int/real/string/handle elem 判断元素是否为整数/小数/字符串/句柄
tuple_is_int_elem (123.0, IsInt3)//0

*// 判断元组的元素是否是数字类
tuple_is_number (Tuple4, IsNumber)

dev_get_window (WindowHandle)
*// 判断单个元素是否为句柄
tuple_is_handle_elem (WindowHandle, IsHandle)

*// 特征值获取：最值/长度/平均值/中值//---------------------
*// 最值:最大值、最小值
tuple_max (Tuple5, Max)
tuple_min (Tuple5, Min)

*// 元祖元素长度(个数)
tuple_length (Tuple5, Length)
*// |元祖名称|--->个数
length1 := |Tuple5|

*// 平均值
tuple_mean (Tuple5, Mean)
*// 中值
tuple_median (Tuple5, Median)
*// 绝对值
tuple_abs (Median, Abs)
*// 向上取整
tuple_ceil (Abs, Ceil)
*// 向下取整
tuple_floor (Ceil, Floor)

*// 查找包含有元素的本地函数//---------------------
*// find(元祖，目标值)返回是目标值在元祖的索引位置
result1 := find(Tuple5, 100)

*// sum()求和
Tuple6:=[1,2,3]
sumAdd := sum(Tuple6)

*// 元祖切片操作连续操作//---------------------
*// 定义一个元祖 值包含从1到100
Tuple7:= [1:100]// 1到100，步长1

*// 定义元祖 还可以设置步长
Tuple8 := [3:2:100]// 3到100，步长2 
Tuple9:=[100:-2:-100] // 100到-100，步长-2

*// 元祖集合运算 交并补差//---------------------
Tuple10 := [1,3,5,7,9,11,13,15]
Tuple11 := [1,2,3,4,5,7,8,9,10]

*// 元组元素拼接 合并两个元组不去重
tuple_concat (Tuple11, Tuple11, Concat)

*// 并集运算 合并去重
tuple_union (Tuple10, Tuple11, Union)

*// 交集运算 提取两个元祖中相同的元素
tuple_intersection (Tuple10, Tuple11, Intersection)

*// 差集运算 求第一个元祖中存在但是在第二个元祖中没有的元素
tuple_difference (Tuple10, Tuple11, Difference)

*// 补集运算 获取的是双方在对方当中都不存在的元素(交集的反集)
*// 对称差集 等价于 并集 - 交集
tuple_symmdiff (Tuple10, Tuple11, SymmDiff)

希望对大家有所帮助, 感谢大家的关注和点赞。