**标注多个圆孔面积**
 

![image.png](/static/img/5ae1fb130025807b1e7c96675ed5feef.image.png)  


斑点工具

![image.png](/static/img/16c9e179c7a989c3487beb182f6e4f30.image.png)  


创建脚本
 
![image.png](/static/img/fade89375344d63cc4c6146be200b8a9.image.png)


引入泛型集合命名空间
 
![image.png](/static/img/00ab4225c3e57dfb841f578a6d94115d.image.png)
 

![image.png](/static/img/dfdf37410103e2b00a01b512efc5b8d8.image.png)


:::note{title="定义一个泛型集合列表  "}
`List<CogGraphicLabel>  myLabel = new List<CogGraphicLabel>(); `
:::

![image.png](/static/img/8f99e113ed69b53a72fc0766b328508c.image.png)
    
获取工具及其结果  
![image.png](/static/img/27ac5e2b204f84f40638088ab2aa7c67.image.png)
遍历集合中的所有斑点，并显示在图像上
 
![image.png](/static/img/e0906b729ba759e490da58d7fb44d180.image.png)
 

![image.png](/static/img/f767173f6f8fe1c5229b91abcf66f065.image.png)

VisionPro练习—标注多个圆孔面积

**保险丝分类统计**
 
![image.png](/static/img/ea42c956d0d96723d1c34a7b59e4dca0.image.png)

新建需要提取的颜色  
 
![image.png](/static/img/a67e4fae8373d847df3442fa4874ec90.image.png)  

图像简单处理
 
![image.png](/static/img/4fcf9ef0fc35c41bebf2c92d3aa733eb.image.png)  

膨胀处理
 
![image.png](/static/img/ccea9836c3bdb7b413ff4fc28b919793.image.png)  

斑点工具  

![image.png](/static/img/e5abc01c88394144a741e7292b81fb7e.image.png)  

过滤不需要的 
 
 
![image.png](/static/img/4f08e46461c1bc39657ddb6b4e41126d.image.png)  


![image.png](/static/img/00231d9d728c88ec1f49eb8dde6b9184.image.png)  

将斑点工具找到的结果用文字标签工具显示在图像上
 

![image.png](/static/img/77594d27f507661fcadb5627854a68a4.image.png)

VisionPro练习—保险丝分类统计

Program.cs

```c#
using System;

namespace Equals判断相等 {
  class Program {
    static void Main(string[] args) {
      //ToString Equals Object
      int a = 12;
      int b = 34;
      Console.WriteLine(a.Equals(b)); // 值为Flase  a == b

      string str1 = "siki";
      string str2 = "siki";
      Console.WriteLine(str1.Equals(str2));

      Student stu1 = new Student(18, "小芳");
      Student stu2 = new Student(18, "小芳");
      //默认方法值为Flase         重写Equals方法后值为True
      Console.WriteLine(stu1.Equals(stu2));
      Console.WriteLine(stu1 == stu2);
    }
  }
}

```

:::tip{title="提示"}
- 所有值类型、字符串比较就相当于a==b  
- 引用类型用Equals作比较时，比较的是引用地址，若需比较引用地址中的数据值，则需重写Equals方法
:::
Student.cs

```c#
using System;
using System.Collections.Generic;
using System.Text;

namespace Equals判断相等 {
  class Student {
    private int age;
    private string name;

    public Student(int age, string name) {
      this.age = age;
      this.name = name;
    }

    public override bool Equals(object obj) //重写Equals方法
    {
      Student stu = (Student) obj; //强制转换
      if (age == stu.age && name == stu.name) {
        return true;
      }
      return false;
    }
  }
}

```

equals方法扩展

myList.cs
```c#     
using System;
using System.Collections.Generic;
using System.Text;

namespace MyList列表 {
  class MyList < T > {
    private T[] data = new T[0]; //data null
    private int count = 0; // 元素个数 数据个数

    public int Capacity //获取容量大小
    {
      get {
        return data.Length;
      }
    }
    public int Count //获取元素个数
    {
      get {
        return count;
      }
    }

    public void Add(T item) //添加元素
    {
      if (data.Length == 0) {
        data = new T[4];
      }
      if (data.Length == count) //添加元素之前 ，先判断数组是否已经满
      {
        T[] temp = new T[count * 2];
        for (int i = 0; i < data.Length; i++) {
          temp[i] = data[i];
        }
        data = temp;
      }
      data[count] = item;
      count++;
    }

    public T this[int index] //访问元素
    {
      get {
        if (index < 0 || index > count - 1) { //抛出异常
          throw new ArgumentOutOfRangeException("索引参数超出范围了");
        }
        return data[index];
      }
      set {
        data[index] = value;
      }
    }

    public void Insert(int index, T item) //插入元素
    {
      if (index < 0 || index > count - 1) //判断是否存在索引
      {
        throw new ArgumentOutOfRangeException("索引参数超出范围了");
      }

      for (int i = count - 1; i > index - 1; i--) {
        // count-1     index
        data[i + 1] = data[i];
      }
      data[index] = item;
      count++;
    }
    public void RemoveAt(int index) //移除指定位置元素
    {
      if (index < 0 || index > count - 1) {
        throw new ArgumentOutOfRangeException("索引参数超出范围了");
      }
      for (int i = index + 1; i < count; i++) {
        // index+1   count-1
        data[i - 1] = data[i];
      }
      count--;
    }
    public int IndexOf(T item) //从前往后获取元素所在的索引位置
    {
      int index = -1;
      for (int i = 0; i < count; i++) { // ToString Equals
        if (item.Equals(data[i])) {
          index = i;
          break;
        }
      }
      return index; //从前往后
    }

    public int LastIndexOf(T item) //从后往前获取元素所在的索引位置
    {
      int index = -1;
      for (int i = count - 1; i >= 0; i--) { // ToString Equals
        if (item.Equals(data[i])) {
          index = i;
          break;
        }
      }
      return index; //从后往前
    }

    public void Sort() //排序
    {
      Array.Sort(data, 0, count); //0, count  指范围
    }
  }
}
```  
Program.cs
```c#

using System;
using System.Collections.Generic;

namespace MyList列表 {
  class Program {
    static void Main(string[] args) {
      // 1.Capacity 获取容量⼤⼩
      MyList < int > list = new MyList < int > ();
      Console.WriteLine(list.Capacity);

      // 2.Add()⽅法添加元素
      list.Add(1);
      list.Add(2);
      list.Add(3);
      list.Add(4);
      list.Add(5);
      list.Add(4);

      // 5.Count属性访问元素个数
      Console.WriteLine(list.Count);
      //遍历集合
      for (int i = 0; i < list.Count; i++) {
        Console.Write(list[i] + " ");
      }

      // 3.Insert()⽅法插⼊元素
      list.Insert(2, 100);
      for (int i = 0; i < list.Count; i++) //遍历集合
      {
        Console.Write(list[i] + " ");
      }
      Console.WriteLine();

      // 4.[index]访问元素(索引器) 
      int temp1 = list[10];
      int temp2 = list[-1];
      List < int > l = new List < int > ();
      int temp = l[-1];

      // 6.RemoveAt()⽅法移除指定位置的元素
      list.RemoveAt(3);
      for (int i = 0; i < list.Count; i++) //遍历集合
      {
        Console.Write(list[i] + " ");
      }
      Console.WriteLine();

      // 7.IndexOf()⽅法取得⼀个元素所在列表中的索引位置
      Console.WriteLine(list.IndexOf(4)); //从前往后搜索
      Console.WriteLine(list.LastIndexOf(4)); //从后往前搜索

      // 8.Sort()对列表中是元素进⾏从⼩到⼤排序
      list.Sort();
      for (int i = 0; i < list.Count; i++) //遍历集合
      {
        Console.Write(list[i] + " ");
      }
      Console.WriteLine();
    }
  }
}

```

集合类MyList 

## 重写ToString 方法
右键笔刷   生成重写（ToString()）
```c#
public override string ToString() {
 string result = age + ":" + name;
  return result;
  }
```   
## 泛型
泛型是什么？  
通过参数化类型来实现在同⼀份代码上操作多种数据类型。利⽤“**参数化类型**”将类型抽象化，从⽽实现灵活的复⽤。

## 泛型类定义
定义⼀个泛型类就是指的是，定义⼀个类，这个类中某些字段的类型是不确定的，这些类型可以在类构造的时候确定下来

创建⼀个类处理  int类型和double类型的相加  

```c#
class ClassA<T>{ //T  指类型   可为int、double、string
private T a; 
private T b; 
public ClassA(T a,T b){ 
this.a = a ;this.b = b; 
} 
//public T GetSum(){ 
//return a+“”+b; 
//注释部分可使用以下方式
 dynamic num1 = a;
 dynamic num2 = b;
 dynamic result = num1 + num2;
 return (T)result;
} 
}

//使用
ClassA<int> a = new ClassA<int>(45, 65);
Console.WriteLine(a.GetSum());  //👉   110
```
## 泛型⽅法
定义泛型⽅法就是定义⼀个⽅法，这个⽅法的参数的类型可以是不确定的，当调⽤这个⽅
法的时候再去确定⽅法的参数的类型。  

实现任意类型组拼成字符串的⽅法  

```c#
public static T GetSum<T>(T a,T b){
return a+""+b;}
GetSum<int>(23,12);
GetSum<double>(23.2,12);
```

使⽤泛型和索引器来实现⼀个我们⾃⼰的集合类MyList  
有下⾯的⽅法和属性  
1. Capacity获取容量⼤⼩  
2. Add()⽅法添加元素  
3. Insert()⽅法插⼊元素  
4. [index]访问元素(索引器)  
5. Count属性访问元素个数  
6. RemoveAt()⽅法移除指定位置的元素  
7. IndexOf()⽅法取得⼀个元素所在列表中的索引位置  
   LastIndexOf()上⾯的⽅法是从前往后搜索，这个是从后往前搜索，搜索到满⾜条件的就停⽌  
   上⾯的两个⽅法，如果没有找到指定元素就返回-1  
8. Sort()对列表中是元素进⾏从⼩到⼤排序  

索引器：通过[index]这种形式去访问数据，就是索引器

泛型⽅法

msvalidate.01

360-site-verification

sogou_site_verification

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

《千纸鹤》是一个关于个人成长、心灵探索和生活哲学的博客。通过结合纸鹤的象征意义，博客传递着希望、自由、勇气和梦想的理念，分享作者在人生旅途中所遇到的挑战与感悟。每一篇文章都如同一只飞翔的纸鹤，轻盈地载着思想与情感，带领读者在迷茫与困顿中找到属于自己的方向。