前言

书接上回，上回我们了解了 castle 代理的一些缺点，本文将开始操作整合 Microsoft.Extension.Dependency和Castle,以让默认的容器可以支持拦截器
我们将以进阶的形式逐步完善我们的封装，以实现一个更方便易用、普适、高性能的基础设施库。

基础版

还是先上代码， 这是基础版本我们要达成的目标，仅需定义一个特性即可完成拦截的目标

/// <summary>
/// 
/// </summary>
public abstract class InterceptorBaseAttribute : Attribute, IInterceptor
{
    void IInterceptor.Intercept(IInvocation invocation)
    {
        var returnType = invocation.Method.ReturnType;
        var builder = AsyncMethodBuilder.TryCreate(returnType);
        if (builder != null)
        {
            var asyncInvocation = new AsyncInvocation(invocation);
            var stateMachine = new AsyncStateMachine(asyncInvocation, builder, task: InterceptAsync(asyncInvocation));
            builder.Start(stateMachine);
            invocation.ReturnValue = builder.Task();
        }
        else
        {
            Intercept(invocation);
        }
    }

    protected virtual void Intercept(IInvocation invocation) { }

    protected abstract ValueTask InterceptAsync(IAsyncInvocation invocation);
    ......
}

如上是我们定义的拦截器基类，我们想要达到的目标是，只要继承该基类，并覆写InterceptAsync 方法即可实现具有特定功能的拦截类，而容器会自动代理到该拦截类，实现拦截。
这里要感谢
https://github.com/stakx/DynamicProxy.AsyncInterceptor
的作者，该库采用
MIT
的许可使用协议，我们可以直接参考使用。
接下来，是重头戏，考虑到易用性，我们以 Microsoft.Extension.DependencyInjection 为基本库，实现一个扩展类，用于实现拦截器功能。
代码如下：

public static class CastleServiceCollectionExtensions
{
    public static IServiceCollection ConfigureCastleDynamicProxy(this IServiceCollection services)
    {
        services.TryAddSingleton<ProxyGenerator>(sp => new ProxyGenerator());
        //TODO:1.从IServiceCollection中获取 方法定义InterceptorBaseAttribute特性子类的ServiceDescriptor

        //TODO:2.逐个处理，获取每个ServiceDescriptor中的ServiceType，识别是具体类还是接口，然后获取InterceptorBaseAttribute特性子类的实例
        //作为拦截器,借用proxyGenerator 去创建对应的代理然后添加到IServiceCollection中

        //TODO:3 移除原始对应的ServiceType注册
        return services;
    }
}

在注释中我们简单描述了该扩展方法的实现过程，我们采用移花接木的方式替换掉原有ServiceType的注册，将代理对象注册为ServiceType的实现即可。

第一步我们这么实现

var descriptors = services.Where(svc =>svc.ServiceType.GetMethods()
    .Any(i => i.GetCustomAttributes(false).Any(i => i.GetType().IsAssignableTo(typeof(InterceptorBaseAttribute))))).ToList();

第二步的核心是
ServiceDescriptor
中 三种生成场景的分开处理，至于是哪三种场景可以看下我的第一篇文章
https://www.cnblogs.com/gainorloss/p/17961153

• descriptor.ImplementationType 有值：已知ServiceType和ImplementationType
  伪代码如下

implementationFactory = sp =>
{
    var generator = sp.GetRequiredService<ProxyGenerator>();

    var interceptors = GetInterceptors(descriptor.ServiceType);//获取拦截器 galoS@2024-1-12 14:47:47

    var proxy = descriptor.ServiceType.IsClass
    ? generator.CreateClassProxy(descriptor.ServiceType,  interceptors.ToArray())
    : generator.CreateInterfaceProxyWithoutTarget(descriptor.ServiceType, interceptors.ToArray());
    return proxy;
};

• descriptor.ImplementationInstance 有值：已知ServiceType和 实现对象实例

implementationFactory = sp =>
{
    var generator = sp.GetRequiredService<ProxyGenerator>();
    var interceptors = GetInterceptors(descriptor.ServiceType, sp);//获取拦截器 galoS@2024-1-12 14:47:47
    var proxy = descriptor.ServiceType.IsClass
    ? generator.CreateClassProxyWithTarget(descriptor.ServiceType, descriptor.ImplementationInstance, interceptors.ToArray())
    : generator.CreateInterfaceProxyWithTarget(descriptor.ServiceType, descriptor.ImplementationInstance, interceptors.ToArray());
    return proxy;
};

• descriptor.ImplementationFactory 有值：已知ServiceType和 实现工厂方法

implementationFactory = sp =>
{
    var generator = sp.GetRequiredService<ProxyGenerator>();
    var interceptors = GetInterceptors(descriptor.ServiceType, sp);//获取拦截器 galoS@2024-1-12 14:47:47
    var proxy = descriptor.ServiceType.IsClass
    ? generator.CreateClassProxyWithTarget(descriptor.ServiceType, descriptor.ImplementationInstance, interceptors.ToArray())
    : generator.CreateInterfaceProxyWithTarget(descriptor.ServiceType, descriptor.ImplementationInstance, interceptors.ToArray());
    return proxy;
};

可以看到 2,3比较雷同，因为拿到 实例和通过委托传入IServiceProvider拿到实例，其实结果是相似的，最终我们都使用工厂注入的形式 生成新的 ServiceDescriptor
services.AddTransinet(descriptor.ServiceType, implementationFactory);
。
最后一步 移除即可
伪代码如下
services.Remove(descriptor);

改造一下之前的代码并测试

 var services = new ServiceCollection();
services.AddLogging();//此处添加日志服务 伪代码 以便获取ILogger<SampleService>
services.TryAddTransient<SampleService>();
services.TryAddTransient<ISampleService, SampleService>();
services.ConfigureCastleDynamicProxy();//一定要在最后，不然会有些服务无法代理到 2024-1-13 13:53:05
var sp = services.BuildServiceProvider();

var proxy = sp.GetRequiredService<SampleService>();
var name = await proxy.ShowAsync();

/// <summary>
/// 异常捕获、日志记录和耗时监控 拦截器 2024-1-12 21:28:22
/// </summary>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
public class CatchLoggingInterceptor : InterceptorBaseAttribute
{
   protected override async ValueTask InterceptAsync(IAsyncInvocation invocation)
   {
       //TODO:类注释所写的逻辑
       await Console.Out.WriteLineAsync("Interceptor  starting...");
       Console.WriteLine("Interceptor  starting...");
       await invocation.ProceedAsync();
       await Console.Out.WriteLineAsync("Interceptor  ended...");
   }
}

运行如下

,

可以看到拦截器这时候是异步方法，并且可以明显看到注入被简化了。
大家可以考虑下为什么
services.ConfigureCastleDynamicProxy()
一定要在BuildServiceProvider()之前，其他注入之后

进阶版本

进阶 版本这里我们不再详细描述，直接看源码
https://gitee.com/gainorloss_259/microsoft-castle.git
主要解决的问题是castle 拦截器不支持 依赖ioc的服务
使用伪代码如下

public class SampleService : ISampleService
{
   [CatchLoggingInterceptor]
   [Interceptor(typeof(LoggingInterceptor))]//第二种使用方式
   public virtual Task<string> ShowAsync()
   {
       Console.WriteLine(nameof(ShowAsync));
       return Task.FromResult(nameof(ShowAsync));
   }
}
//定义拦截器
internal class LoggingInterceptor : InterceptorBase
{
   private readonly ILogger<LoggingInterceptor> _logger;

   public LoggingInterceptor(ILogger<LoggingInterceptor> logger)
   {
       _logger = logger;
   }
   protected override async ValueTask InterceptAsync(IAsyncInvocation invocation)
   {
       await Console.Out.WriteLineAsync(nameof(LoggingInterceptor));
       await invocation.ProceedAsync();
   }
}

总结

以上 整合的核心方案及细节已经介绍完毕了，接下来有时间的话可以出一篇对本整合做性能测试的文章;
AOP
是一个很强大的东西，我们基本已经完成了一个比较普适、比较易用的aop底层整理。接下来我们可以做很多东西，比如 事务拦截器、幂等拦截器、重试拦截器、缓存拦截器等等
打好基础，后续可以自己去实现。
这里还有几个问题 ，大家可以思考下

1. 我们如何能整合两种拦截器 既可以传一些常量又不影响我们的服务注入拦截器
2. 拦截器是否可以再套用拦截器
3. 假设我们再日志拦截器上打了日志拦截器 会怎么样

这些都是一些比较有意思的问题，相信这些问题的思考会让大家对动态代理的理解更深，并可以灵活的将其用到自己的项目中。

源码及声明

当前示例代码已传至
https://gitee.com/gainorloss_259/microsoft-castle.git
如转载请注明出处，谢谢！

如果需要其他图像处理的文章及代码，请移步小编的GitHub地址

传送门：
请点击我

如果点击有误：https://github.com/LeBron-Jian/ComputerVisionPractice

本来在前面博客
OpenCV计算机视觉学习（2）——图像算术运算 &图像阈值（数值计算，掩膜mask操作，边界填充，二值化
）里面已经学习了图像的数值计算，即常量加减等。但是在C++中和python使用不同的方式进行常量计算还是有一点点的区别，比如说python的numpy类型的运算符操作是取模操作，但是opencv的运算符操作却是饱和运算。当然opencv的cv2.add函数在C++和python是一致的。于是我这里将自己认为重要的点梳理一下。

1，什么是饱和运算，什么是取模运算

饱和运算（Saturating Arithmetic）和取模运算（Modulo Operation）是两种不同的数学运算。

1.1 饱和运算（Saturating Arithmetic）

定义
：在计算机图像处理和信号处理中，饱和运算是一种处理溢出的方法。当进行某些运算（例如加法或乘法）时，结果可能会超出数据类型的表示范围，导致溢出。饱和运算就是在发生溢出时，将结果限制在数据类型的最大和最小值之间（通常是通过截断或设置上下界），而不是简单地截断或取模。

具体来说，对于无符号数据类型，饱和运算会将溢出的结果设置为该数据类型的最大值；对于有符号数据类型，饱和运算会将溢出的结果设置为该数据类型的最大正值或最小负值，以保持在有符号范围内。

示例： 在图像处理中，对于8位无符号整数（uchar）的像素值，其范围是0到255。饱和加法将确保结果在0到255之间。如果相加的结果大于255，饱和加法会将结果截断为255，类似地，如果结果小于0，饱和运算将结果设置为0。

1.2 取模运算（Modulo Operation）

定义
： 取模运算是指对两个整数相除，返回余数的运算。通常使用符号“%”表示。对于整数a和正整数b，a % b 的结果是一个非负整数，其大小小于b。

示例： 在图像处理中，取模运算常用于周期性的操作，如周期性的亮度变化。对于像素值的取模加法，可以将结果限制在一个范围内，例如对256取模，确保结果在0到255之间。

总体而言，饱和运算用于控制结果的范围，防止溢出，而取模运算用于获取除法的余数，通常应用于周期性的操作。在图像处理中，这两种运算都有其应用场景，具体取决于需要实现的效果。具体下面来说。

2，在图像处理中，饱和运算和取模运算的区别，联系，应用场景分别是什么？

在图像处理中，饱和运算和取模运算都可以用于对图像像素值的调整，但它们的应用场景和效果略有不同。
饱和运算（Saturating Arithmetic）
特点
：
饱和运算主要用于防止溢出，确保结果在一个合理的范围内，通常是0到255。
对于8位无符号整数（uchar）的像素值，饱和加法会将结果限制在0到255之间，超过255的部分会被截断为255，保持在合法范围内。
应用场景
：
饱和运算常用于图像亮度调整、滤波等场景，确保处理后的像素值不超出可表示的范围。
取模运算（Modulo Operation）
特点
：
取模运算主要用于周期性的操作，将结果限制在一个周期内，通常是对256取模，确保结果在0到255之间。
取模运算可以用于模拟周期性的光照变化、颜色循环等效果。
应用场景
：
取模运算常用于需要产生循环或周期性效果的图像处理，例如通过周期性调整图像的亮度、对比度或颜色，以实现动态的视觉效果。
联系：
饱和运算和取模运算都是对结果进行限制的方式，确保结果在某个特定范围内。
在某些情况下，可以结合使用这两种运算，根据具体需求综合考虑。
总体来说：

1，如果你希望避免结果溢出，使图像保持在一个可接受范围内，使用饱和运算。

2，如果你希望实现周期性的效果，例如循环的光照变化或颜色变换，使用取模运算。

3，实际应用中，饱和运算和取模运算的选择取决于具体的图像处理任务和期望的视觉效果

3，以C++和Python 的具体实例测试

3.1 python实现饱和运算和取模运算

python 示例如下（以加法为例，当然你也可以测试减法，乘法等）：

import numpy as np

# 初始化两个像素点的值
pixel_a = np.uint8([150])
need_to_add_pixel = np.uint8([120])

# 饱和运算：将数值限制在一定范围内，通常是0~255之间
# 在图像处理中，这用于确保像素不会超出表示颜色的范围，例如某个像素的计算结果超出255，则被饱和到255
# 150+120 = 270 => 255
print(cv2.add(pixel_a, need_to_add_pixel))
# 打印结果为：[[255]]

# 取模运算：计算两个数相除的余数
# 在图像处理中，取模运算可以用于创建循环效果，例如在图像边缘处形成循环纹理
# 250+10 = 260 % 256 = 4
print(pixel_a + need_to_add_pixel)
# 打印结果为： [14]

我将python的结果和过程解释都写在代码中了，实际上确实opencv实现的常量运算是饱和运算。而运算符实现的常量运算是取模运算。下面再看C++的。

3.2 C++实现饱和运算和取模运算

C++示例如下：

    // 创建两个单像素的Mat，像素值分别为170和190
    cv::Mat pixel1(1, 1, CV_8UC1, cv::Scalar(170));
    cv::Mat pixel2(1, 1, CV_8UC1, cv::Scalar(190));

    // 创建两个单像素的uchar，像素值分别是200和210
    uchar pixel3 = 200;
    uchar pixel4 = 210;

    std::cout << "Pixel1 value: " << static_cast<int>(pixel1.at<uchar>(0, 0)) << std::endl;
    std::cout << "Pixel2 value: " << static_cast<int>(pixel2.at<uchar>(0, 0)) << std::endl;
    std::cout << "Pixel3 value: " << static_cast<int>(pixel3) << std::endl;
    std::cout << "Pixel4 value: " << static_cast<int>(pixel4) << std::endl;
    std::cout << "Data type of pixel1: " << typeid(pixel1).name() << std::endl;
    std::cout << "Data type of pixel2: " << typeid(pixel2).name() << std::endl;
    std::cout << "Data type of pixel3: " << typeid(pixel3).name() << std::endl;
    std::cout << "Data type of pixel4: " << typeid(pixel4).name() << std::endl;

    // 使用 cv::add 进行饱和运算
    cv::Mat result_add_saturate12;
    cv::add(pixel1, pixel2, result_add_saturate12);

    // 使用 + 运算符进行溢出运算
    cv::Mat result_add_overflow12 = pixel1 + pixel2;
    uchar result_add_overflow34 = pixel3 + pixel4;

    // 输出结果
    std::cout << "Result12 using cv::add: " << static_cast<int>(result_add_saturate12.at<uchar>(0, 0)) << std::endl;
    std::cout << "Result12 using + operator: " << static_cast<int>(result_add_overflow12.at<uchar>(0, 0)) << std::endl;
    std::cout << "Result34 using + operator: " << static_cast<int>(result_add_overflow34) << std::endl;

结果如下：

Pixel1 value: 170
Pixel2 value: 190
Pixel3 value: 200
Pixel4 value: 210
Data type of pixel1: class cv::Mat
Data type of pixel2: class cv::Mat
Data type of pixel3: unsigned char
Data type of pixel4: unsigned char
Result12 using cv::add: 255
Result12 using + operator: 255
Result34 using + operator: 154

但是C++中，我发现如果类型为cv::mat，无论是进行cv::add还是直接使用加法运算符，总是进行饱和操作。而不进行取模操作。但是如果对数据类型设置为uchar，然后使用加法运算符，则结果就是取模运算。

3.3 讨论：为什么opencv的add是饱和运算，而numpy的加法却写成取模

OpenCV的cv::add和NumPy中的加法在设计时可能有不同的考虑，导致了它们在溢出处理上的差异。
OpenCV的 cv::add
cv::add 函数在图像处理中默认采用饱和运算。这是由于在图像处理领域，特别是对于8位无符号整数（uchar）表示的像素值，饱和运算是一种常见的保护手段。饱和运算确保结果不会溢出范围（通常是0到255），防止图像亮度等调整操作导致不可预知的结果。

OpenCV在处理图像时更注重保持图像的可视性，因此默认情况下选择了饱和运算。

NumPy的加法
NumPy是一个通用的数学库，广泛用于科学计算和数组操作，不仅仅是图像处理。NumPy的加法操作默认采用取模运算，这是因为在通用的数学运算中，取模操作更为常见。

在科学计算中，溢出通常表示一个错误，而取模操作则可以使结果在一定范围内循环，更适合一些数学和统计的应用。

虽然OpenCV和NumPy在处理图像时采用了不同的默认溢出处理策略，但两者都提供了灵活的参数选项，允许用户指定其他的溢出处理方法。在OpenCV中，你可以使用cv::addWeighted来实现一定程度上的取模运算；而在NumPy中，你可以使用numpy.remainder函数来实现类似的效果。

总体来说，这种差异主要是由于库设计时的偏好和目标应用的不同。在实际使用中，你可以根据具体需求选择适当的库和参数。

3.4 为什么Opencv要做饱和操作

OpenCV选择使用饱和运算而不是取模运算，主要是因为饱和运算能够更好地处理图像处理任务中的边界情况和避免出现意外的结果。下面是一些理由：

1. 物理解释
   ： 在图像处理中，像素值通常被解释为光强度或颜色强度。对于灰度图像，典型的像素值范围是 [0, 255]，代表黑到白的强度。超出这个范围的值在物理上没有明确的解释。

2. 数学稳定性
   ： 饱和运算确保在进行数学运算时，结果始终保持在合理的范围内，避免了溢出引起的不稳定性。在图像处理算法中，保持数学的稳定性对于正确的输出非常重要。

3. 避免失真
   ： 取模运算可能导致图像失真，因为它不会模拟实际图像处理中的物理行为。在处理图像时，饱和运算更符合图像处理任务的实际需求。

4. 避免伪影
   ： 取模运算可能导致伪影（artifacts），因为回绕到0可能导致图像中出现意外的亮度变化。饱和运算避免了这样的问题。

总的来说，OpenCV选择饱和运算是为了确保在图像处理中获得可靠和直观的结果。取模运算通常更适用于某些特定的应用场景，例如密码学等，而不是图像处理领域。

4，C++中opencv的CV_8U类型，CV_8UC1类型，Uchar类型等笔记

4.1 CV_8U类型

在OpenCV中，
CV_8U
是一种图像数据类型，表示图像中的每个像素值为8位无符号整数（8-bit Unsigned）。在这种数据类型下，每个像素的取值范围为0到255。

具体来说，
CV_8U
表示一个8位无符号整数的图像。这种图像类型通常用于表示灰度图像，其中每个像素的亮度值在0到255之间，0表示最暗，255表示最亮。

以下是使用
CV_8U
数据类型创建一个简单的灰度图像的示例：

    // 创建一个单通道的8位无符号整数图像，大小为 100x100
    cv::Mat grayscaleImage(100, 100, CV_8U, cv::Scalar(128));

4.2 CV_8UC1类型

CV_8UC1
是OpenCV中用于表示8位无符号整数单通道图像的数据类型标识。这个标识的含义如下：

• CV_8U
  ：表示8位无符号整数（uchar），像素值范围为 [0, 255]。
• C1
  ：表示单通道，即灰度图像。

因此，
CV_8UC1
表示单通道的8位无符号整数图像，通常用于表示灰度图像，其中每个像素的值是一个8位无符号整数。例如，以下是创建一个单通道的8位无符号整数图像的示例：

cv::Mat grayImage(100, 100, CV_8UC1, cv::Scalar(0));

这将创建一个100x100的灰度图像，所有像素的初始值为0。

4.3 uchar 类型

uchar类型不是C++标准库中的类型，相反，C++标准库使用了 unsigned char类型。

定义
：unsigned char 是一个整数数据类型，用于存储无符号（非负）的字符值，在C++中，unsigned char 通常用于表示字节，范围是0~255之间。

取值范围
：unsigned char类型是一个1字节的整数类型，其范围是从0~255之间（包括0和255）。因为它是无符号类型，所以它不能表示负数，但可以表示0~255之间的所有整数。

如何打印
：你可以使用 std::cout 来打印 unsigned char 的值：

unsigned char ucharValue = 200;
std::cout << static_cast<int>(ucharValue) << std::endl;;

对于创建的一个uchar类型的 ucharVaule，我们通过将其转换为int并打印。

4.4 CV_8U类型和CV_8UC1类型的区别是什么

在OpenCV中，
CV_8U
和
CV_8UC1
表示图像矩阵的数据类型，但它们之间存在一些区别：

1. CV_8U：

   
   
   1. CV_8U
      表示8位无符号整数。这种数据类型通常用于表示图像中的像素值。
   2. 在
      CV_8U
      类型的矩阵中，每个像素值都是一个无符号字节（0 到 255），表示图像的亮度。

2. CV_8UC1：

   
   
   1. CV_8UC1
      表示8位无符号整数，且矩阵只有一个通道（channel）。这是灰度图像的常见数据类型。
   2. 在
      CV_8UC1
      类型的矩阵中，每个元素表示一个像素的亮度值，而且图像只有一个通道。

总的来说，
CV_8U
表示一个通用的8位无符号整数类型，而
CV_8UC1
表示一个8位无符号整数类型的矩阵，且该矩阵只有一个通道。如果你处理的是灰度图像，通常会使用
CV_8UC1
类型的矩阵。如果处理的是彩色图像，可能会使用
CV_8UC3
（表示三个通道的8位无符号整数类型）等。

如果你使用
cv::Mat
的
at<uchar>(i, j)
打印出来的结果是全零，可能是因为
cv::getStructuringElement
返回的矩阵是
CV_8U
类型，而不是
CV_8UC1
。

在
CV_8U
类型的图像中，元素的值被认为是无符号字节（unsigned byte），而不是灰度值。这可能导致
at<uchar>
访问失败。

你可以尝试使用
at<int>
来访问元素，或者使用
static_cast<uchar>
进行转换。这里是一种可能的修改：

void printStructuringElement(const cv::Mat& kernel) {
    for (int i = 0; i < kernel.rows; ++i) {
        for (int j = 0; j < kernel.cols; ++j) {
            std::cout << static_cast<int>(kernel.at<uchar>(i, j)) << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

这将确保uchar类型的元素被正确的转换并打印。

在OpenCV中，
CV_8U
和
CV_8UC1
都表示8位无符号整数类型。其实，它们的存储方式是相同的，都是使用
uchar
（无符号字符，即
uint8_t
）来存储每个像素的值。在内存中，它们都是占用一个字节。

总体来说，实际上两者是相同的数据类型，都是以
uchar
存储的无符号8位整数。在实际应用中，你可以根据需要选择使用
CV_8U
或
CV_8UC1
，并根据情况是否需要进行强制转换来正确打印。

// 创建一个3x3的CV_8U矩阵
cv::Mat img_8u = cv::Mat::zeros(3, 3, CV_8U);

// 设置矩阵中的像素值
img_8u.at<uchar>(0, 0) = 100;
img_8u.at<uchar>(1, 1) = 200;
img_8u.at<uchar>(2, 2) = 50;

// 打印矩阵中的像素值
std::cout << "CV_8U Matrix:" << std::endl;
for (int i = 0; i < img_8u.rows; ++i) {
    for (int j = 0; j < img_8u.cols; ++j) {
        std::cout << static_cast<int>(img_8u.at<uchar>(i, j)) << " ";
    }
    std::cout << std::endl;
}

// 创建一个3x3的CV_8UC1矩阵
cv::Mat img_8uc1 = cv::Mat::zeros(3, 3, CV_8UC1);

// 设置矩阵中的像素值
img_8uc1.at<uchar>(0, 0) = 150;
img_8uc1.at<uchar>(1, 1) = 50;
img_8uc1.at<uchar>(2, 2) = 255;

// 打印矩阵中的像素值
std::cout << "\nCV_8UC1 Matrix:" << std::endl;
for (int i = 0; i < img_8uc1.rows; ++i) {
    for (int j = 0; j < img_8uc1.cols; ++j) {
        // std::cout << img_8uc1.at<uchar>(i, j) << " ";
        std::cout << static_cast<int>(img_8uc1.at<uchar>(i, j)) << " ";
    }
    std::cout << std::endl;
}

打印的结果：

CV_8U Matrix:
100 0 0
0 200 0
0 0 50

CV_8UC1 Matrix:
150 0 0
0 50 0
0 0 255

4.5  cv::Mat中的cv::Scalar是什么

cv::Scalar
是OpenCV中用于表示多通道数据的数据类型，通常用于表示像素值或颜色信息。它是一个简单的容器，可以存储1到4个数值，分别对应图像中的通道。
cv::Scalar
的构造函数有多个版本，最常用的版本接受1到4个数值，分别对应通道的值。

以下是一些示例：

// 创建一个Scalar对象，表示灰度图像中的像素值
cv::Scalar gray_pixel(128);

// 创建一个Scalar对象，表示RGB图像中的颜色（蓝色）
cv::Scalar blue_color(255, 0, 0);

// 创建一个Scalar对象，表示RGBA图像中的颜色（半透明绿色）
cv::Scalar transparent_green(0, 255, 0, 128);

在处理图像时，
cv::Scalar
可以与
cv::Mat
结合使用，例如设置像素值或提取像素值。例如：

cv::Mat image(100, 100, CV_8UC3, cv::Scalar(0, 0, 255));  // 创建一个红色的图像

cv::Scalar pixel_value = image.at<cv::Vec3b>(50, 50);  // 提取像素值
std::cout << "Pixel value at (50, 50): " << pixel_value << std::endl;

在这个例子中，
cv::Vec3b
表示3通道的
cv::Mat
，
cv::Scalar
用于存储提取的像素值。
cv::Scalar
的使用使得代码更加简洁，而且可以方便地处理不同通道的数值。

4.6  cv::Mat和unsigned char的区别是什么

cv::Mat
和
unsigned char
是两种不同的数据类型，它们分别用于不同的目的。

1. cv::Mat
   ：

   
   
   • cv::Mat
     是OpenCV库中用于表示图像和矩阵数据的数据类型。
   • 它是一个通用的多维数组类，可以表示单通道或多通道的图像，矩阵，甚至是其他类型的数据。
   • cv::Mat
     有丰富的功能和方法，使得在图像处理和计算机视觉任务中更加方便。

2. unsigned char
   ：

   
   
   • unsigned char
     是C++语言中的基本数据类型之一，表示一个8位无符号整数。
   • 它的取值范围是 [0, 255]。
   • 通常用于表示像素值（灰度图像中的每个像素值），其中0表示最暗，255表示最亮。

区别：

• cv::Mat
  是一个复杂的数据结构，用于存储和处理图像和矩阵数据，提供了许多高级的操作和功能。
• unsigned char
  是一个基本的数据类型，主要用于表示8位无符号整数，特别适用于存储像素值。

在图像处理中，你通常会使用
cv::Mat
来处理图像数据，而
unsigned char
可能是
cv::Mat
中像素值的底层数据类型。例如，对于灰度图像，
cv::Mat
可能是单通道
CV_8UC1
类型，其中每个像素值为
unsigned char
。

4.7 cv::Scalar和 cv::Mat的取值范围分别是多少

1. cv::Scalar
   ：

   
   
   • cv::Scalar
     是一个简单的数据结构，通常用于表示颜色或像素值。
   • 对于灰度图像，
     cv::Scalar
     中的每个通道的取值范围是 [0, 255]。
   • 对于彩色图像，每个通道的取值范围同样是 [0, 255]。
   • cv::Scalar
     最多可以存储4个数值，分别对应4个通道。

2. cv::Mat
   ：

   
   
   • cv::Mat
     是OpenCV中用于表示图像和矩阵的多通道数据结构。
   • 对于图像，通常使用8位无符号整数 (
     CV_8U
     ) 类型，其取值范围是 [0, 255]。
   • 对于其他数据类型，例如
     CV_32F
     （32位浮点数），取值范围可以是任意的，取决于具体的数据类型。

在处理图像时，通常会使用
CV_8U
类型的
cv::Mat
，其中像素值的取值范围是 [0, 255]，与
cv::Scalar
中的灰度值或颜色值相匹配。在使用其他数据类型时，需要根据具体的情况来理解像素值的取值范围。

在默认的情况下，对于灰度图像，
cv::Scalar
和
cv::Mat
的取值范围是相同的，都是 [0, 255]。这是因为
cv::Scalar
通常用于表示像素值，而像素值在灰度图像中是单通道的，每个通道的值都在 [0, 255] 范围内。

例如，对于灰度图像，下面的
cv::Scalar
和
cv::Mat
表示相同的像素值：

cv::Scalar scalar_value(128);
cv::Mat mat_value(1, 1, CV_8UC1, cv::Scalar(128));

这两个表示都是灰度值为128的像素。然而，需要注意以下几点：

1. cv::Scalar
   可以用于表示多通道数据： 当处理彩色图像时，
   cv::Scalar
   可以表示多通道的颜色信息，每个通道的值同样在 [0, 255] 范围内。

2. cv::Mat
   的数据类型可以不同： 对于
   cv::Mat
   ，具体的数据类型可能不仅仅是
   CV_8UC1
   ，还可以是其他类型，例如
   CV_32F
   。在这种情况下，像素值的取值范围将根据具体的数据类型而有所不同。

总体而言，当处理灰度图像时，
cv::Scalar
和
cv::Mat
的取值范围是相同的。在处理彩色图像或其他数据类型时，需要考虑具体的通道数和数据类型。

4.8 总结：如果超出取值范围，cv::Mat类型还是会进行饱和运算，而uchar只是进行取模运算

当使用
cv::Mat
作为容器表示像素值时，确实会执行饱和运算。这是因为 OpenCV 在处理图像时通常使用
cv::Mat
类型，而这个类提供了丰富的图像处理功能。

对于
unsigned char
，它是C++的基本数据类型，如果超出了255，将执行取模运算。这是因为
unsigned char
是一个循环数据类型，其值会在达到最大值时回绕到0。

让我们通过一个示例来说明这一点：

#include <iostream>

int main() {
    // 使用 cv::Mat 进行饱和运算
    cv::Mat mat_pixel(1, 1, CV_8UC1, cv::Scalar(400));
    std::cout << "cv::Mat pixel value: " << static_cast<int>(mat_pixel.at<uchar>(0, 0)) << std::endl;

    // 使用 unsigned char 进行取模运算
    unsigned char uchar_pixel = 400;
    std::cout << "unsigned char pixel value: " << static_cast<int>(uchar_pixel) << std::endl;

    return 0;
}

在这个例子中，
cv::Mat
类型的像素值为200，但输出将是255，因为它被饱和到了255。而
unsigned char
的像素值也为200，但输出将是200，因为它进行了取模运算，回绕到了0。

cv::Mat pixel value: 255
unsigned char pixel value: 144

文编|JavaBuild

哈喽，大家好呀！我是JavaBuild，以后可以喊我鸟哥！俺滴座右铭是不在沉默中爆发，就在沉默中灭亡，一起加油学习，珍惜现在来之不易的学习时光吧，等工作之后，你就会发现，想学习真的需要挤时间,厚积薄发啦！

我们知道Java是面向对象的静态型编程语言，在Java的世界里万物皆对象。但我认为是万物皆数据，世界由各种各样数据构建起来，我们通过程序去实现数据的增删改查、转入转出、加减乘除等等，不同语言的实现方式殊途同归。
由此可见，数据对于程序语言的重要性，而在Java中用来规范数据的标准我们将其称之为“
数据类型
”，这便是我们今天的Topic!
在下图中我们将Java中的数据类型分为三个部分：
基本数据类型
，
包装类型
，
引用数据类型

基本数据类型

在Java中“boolean、char、byte、short、int、long、float 和 double”构建起了数据结构的基础，非常重要，也是很多公司面试的高频考点，所以，为了方便记忆，鸟哥整理了一份表格如下：

字节与位的关系

在计算机的物理存储中，一条电路线被称之为1位，二进制识别中为0（低电平）或1（高电平），英文中用bit表示，而8个bit组成一个字节，英文为Byte

布尔类型的说明

对于 boolean，官方文档未明确定义，它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位，但是实际中会考虑计算机高效存储因素。

基本数据类型之间的转换规则

基本数据类型之间也存在着转换关系，往往发生在表达式计算的过程中，而这种转换根据不同场景分为：
自动类型转换&强制类型转换
自动类型转换：Java编译器无需显示处理，一般由等级低的数据类型向等级高的数据类型转换，如int -> long。很明显，int所能存储的数据必定是long的子集，不存在数据丢失问题。

等级由低到高
byte -> short -> int -> long -> float -> double
char -> int -> long -> float -> double

int a = 3;
double b = 1.5;
// 自动类型转换：a 被转换为 double 类型
double result = a * b;
System.out.println("结果: " + result); // 输出：结果: 4.5

强制类型转换：由高等级数据转为低等级数据时往往存在强制类型转换，这时候Java编译器认为存在隐患，需要程序员介入，显示的处理强转，潜在风险是数据丢失或精度丢失。

由左到右需要强转
double -> float -> long -> int -> char -> short -> byte

double c = 10.1;
// 强制类型转换：将 double 类型转换为 int 类型,精度丢失
int d = (int) c;
System.out.println("整数值: " + d); // 输出：整数值: 10

转换规则如下

= 右边先自动转换成表达式中最高级的数据类型，再进行运算。整型经过运算会自动转化最低 int 级别，如两个 char 类型的相加，得到的是一个 int 类型的数值。
= 左边数据类型级别 大于 右边数据类型级别，右边会自动升级
= 左边数据类型级别 小于 右边数据类型级别，需要强制转换右边数据类型
char 与 short，char 与 byte 之间需要强转，因为 char 是无符号类型

包装类型

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。
因为Java中一切皆对象，基本数据类型无法满足这个大口号，比如泛型、序列化、类型转换、高频数据区间的缓存等，故为了弥补，便诞生了8种基本数据类型对应的包装类型。

包装类型与基本数据类型差异

• 使用场景：
  在Java中除了一些常量和局部变量的定义会用到基础数据类型外，绝大部分情况下均采用包装类型，如方法参数，对象属性等，且基本数据类型不能用于泛型，包装类型可以！
• 默认值：
  包装类型比基本类型多了一个非功能值：null，在不做任何赋值的情况下，包装类型的默认就是null，而基本数据类型都有相应的默认值，见上面表格。
• 所占内存
  因为包装类型是对象，会有一些对象头等信息，所以占用空间上要大于基本数据类型。
• 比较方式
  基本类型采用 == 号比较，比较的是值，而对于包装类型来说，==比较的其实是对象的内存地址，对象值的比较需要通过equals()方法完成。

[注意]：
很多同学都以为基本数据类型存在栈中，包装类型作为对象存储在堆中，这个观点是有失偏颇的，如果基础数据类型的成员变量在没有被static关键字修饰的情况下，是存在的堆中的，只有局部变量被存在栈的局部变量表中！而全部对象都存在堆中，也是个不完整的答案，这里涉及到HotSpot中的逃逸分析，等讲到JVM时再展开说吧。

自动装箱与拆箱

在Java中不仅仅基本类型之间存在着转换，基本数据类型与包装类型之间同样存在着转换，在JDK1.5之前是不支持自动装箱与拆箱的，所以那时候需要通过显示的方法调用来实现转换，而JDK1.5开始，自动化程度提升了。
装箱
：基本类型转变为包装器类型的过程。
拆箱
：包装器类型转变为基本类型的过程。

//JDK1.5之前是不支持自动装箱和自动拆箱的，定义Integer对象，必须
Integer i = new Integer(8);
 
//JDK1.5开始，提供了自动装箱的功能，定义Integer对象可以这样
Integer i = 8;
int n = i;//自动拆箱

实现原理

装箱是通过调用包装器类的 valueOf 方法实现的
拆箱是通过调用包装器类的 xxxValue 方法实现的，xxx代表对应的基本数据类型。
如int装箱的时候自动调用Integer的valueOf(int)方法；Integer拆箱的时候自动调用Integer的intValue方法。

【需要注意的问题点】：
1、整型的包装类 valueOf 方法返回对象时，在常用的取值范围内，会返回缓存对象。
2、浮点型的包装类 valueOf 方法返回新的对象。
3、布尔型的包装类 valueOf 方法 Boolean类的静态常量 TRUE | FALSE。

Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;

System.out.println(i1 == i2);//true
System.out.println(i3 == i4);//false
        
Double d1 = 100.0;
Double d2 = 100.0;
Double d3 = 200.0;
Double d4 = 200.0;
System.out.println(d1 == d2);//false
System.out.println(d3 == d4);//false
        
Boolean b1 = false;
Boolean b2 = false;
Boolean b3 = true;
Boolean b4 = true;
System.out.println(b1 == b2);//true
System.out.println(b3 == b4);//true

以上代码中，我们已Integer为例展开解释一下，基本数据类型的包装类除了 Float 和 Double 之外，其他六个包装器类（Byte、Short、Integer、Long、Character、Boolean）都有常量缓存池。而Integer的缓存区间是-128~127。
我们去看一下Integer类的缓存源码

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static {
        // high value may be configured by property
        int h = 127;
    }
}

IntegerCache 这个静态内部类中设置了缓存区间，当我们通过valueOf()方法获取Integer对象时，会先去找该整数是否在缓存池中，有则直接返回，没有则新建并存入缓存池。
这就解释了为什么第一个 == 号结果是true，而第二个为false，因为超出了缓存区间，每次都新建一个对象，而 == 号又是比较对象地址，对于两个不同的对象，地址肯定不一样啦。

引用数据类型

Java的数据类型除了8种基本数据类型和对应的包装类型外，还有一个分类为引用数据类型，在文章开头的树形图中已经分好，引用类型分为：数组，类和接口。
那为什么叫他引用数据类型呢？在创建引用数据类型时，会在栈上给其引用句柄，分配一块内存，然后对象的信息存储在堆上，在程序调用的时候，通过栈上的引用句柄指向堆中的对象，从而获取想要的数据。
因数组，类，接口都包含着太多内容，在后续的博客中会陆续详解，所以本文略做介绍，粗略感受一下。
数组：

int [] arrays = {1,2,3};
System.out.println(arrays);
// 打印结果：[I@2d209079

打印结果中的一串内容，世界上是arrays的对象首地址，要想看到结果，需要调用java.lang.Object 类的 toString() 方法。
类：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
}

String是一个类，也是字符串的代表，所以它也是引用数据类型
接口：

List<String> list = new ArrayList<>();
System.out.println(list);

List 是一个非常典型的接口，属于Java的一种集合，存储的元素是有序的、可重复的。

【注意】

1、包装类可以实现基本类型和字符串之间的转换，字符串转基本类型：parseXXX(String s)；基本类型转字符串：String.valueOf(基本类型)。
2、引用数据类型的默认值为 null，包括数组和接口。
3、char a = 'h'char :单引号，String a = "hello" :双引号。

概念是学习的基础。在学习JS中的文件操作之前，先把文件相关的各种概念搞清楚，很有好处。

1. 二进制：

计算机硬件仅能处理和存储二进制数据，所以不管是你正在写的代码，还是你硬盘里的小姐姐，都是以二进制的形式存储于电脑的内存和硬盘里的。

2. 编码规则：

二进制计算机看得懂，我们看不懂怎么办啊？我们能看懂的是文字、图片、视频。编码规则，就是二者之间的桥梁。

文本的编码规则很简单，就是二进制（先转成16进制）和我们能看懂的字符一一对应，图片和视频的编码要复杂一些。但可以简单理解为：二进制数据经过不同的编码规则，编码成不同的文件格式。

3. 字符集：

字符集是和编码规则密切相关的一个概念，它定义了一组字符以及这些字符对应的二进制编码。

比如Unicode字符集，包括UTF-8、UTF-16、UTF-32几种编码规则。

字符集主要应用于文本数据，相比之下，编码规则这个概念更为广泛，所有类型的文件都有自己的编码规则，不仅限于文本文件。

4. 文本文件：

文本文件，是指采用ASCII、UTF-8等文本编码规则创建的文件，其中的内容主要是人类可直接阅读的文字信息。

5. 二进制文件：

除了文本文件之外，其他类型的文件，如图像、音频、视频和可执行程序等，通常被统称为二进制文件，它们的编码规则相对复杂且非文本形式。

6. 文件类型：

文件类型指的是根据文件的内容或用途进行的大类别划分。例如，文本文件、图像文件、音频文件、视频文件、文档文件、可执行程序等。

7. 文件格式：

相较于文件类型，文件格式是一个更具体的术语，每个大类别的文件类型下可能包含多种不同的文件格式，例如文本文件包括txt、doc、xml等多种具体格式。

8. 文件后缀名：

文件后缀名并不一定是文件的真实类型，我们都知道后缀名是可以随便改的。在Linux系统中，甚至没有文件后缀名。

它的作用，只是让操作系统用默认的程序打开这个文件。在控制面板中，我们知道有一个配置是，每种文件后缀名的默认打开应用。

在这方面，有点类似于浏览器根据响应内容的mime类型，来对响应做不同的处理。

9. 文件的编码：

一个文件的编码，指的是创建这个文件时所使用的编码规则，关键词是“创建”。

10. 用不同的编码打开文件：

只有使用创建文件时采用的编码规则，才能正确打开文件。当我们用其他的编码规则试图打开文件时，将会无法打开，或者看到乱码。

这个过程中，底层的二进制数据保持不变，变化的是：因为编码规则的改变，我们所看到的内容。

11. 文件格式转换：

这个过程中，和上面是相反的。我们看到的内容保持不变，变化的是：因为编码规则的改变，底层的二进制数据不一样了。

比如我们把jpg文件转换为png，我们看到的内容是一样的，但底层的二进制数据就完全变了。

12. 流：

流这个概念，很抽象。流是一种传输数据的方式，快速连续的传输数据，允许数据分段传输。与流相对的，是一次性传输整个数据块（block）。

你可以理解为把一只大象装冰箱，和把大象煮成肉汤用一根管子流入冰箱。

我们对流比较形象的体验包括：服务器想返回一个大的文件，如果直接把文件返回，文件就会全部装入内存，可能导致内存被占满。但如果采用流的方式传输，只占用很少的内存就可以了。

在浏览器端呢，如果不采用流的方式接收文件，就要等文件全部传输完成才能开始下载，比如视频全部下载完成才能开始观看。使用流的方式接收，就可以边传输边下载，边下载边观看了。

流的诞生，首先是因为硬件的发展，开始支持这种数据传输的方式，服务器、浏览器、网络设备具备了传输流、处理流的能力。编程语言又对流进行了高级抽象，提供了流相关的API。它最早出现于Unix系统的I/O模型，然后被用于TCP/IP协议，现在，流被广泛的应用于网络通信、文件I/O、数据库连接、web开发等，可以说流无处不在。

一个最简单的流，包括数据来源（字符串、文件等）和数据的去向。打开流，数据开始传输，传输完成后，再手动关闭流。当然，大部分编程框架为了方便，都提供了传输完成后自动关闭流的功能。

那么在平时开发中，我们和流又有什么关系呢？

服务器端：在服务器端发送和接收数据，是否以流的方式进行，是我们自己选择的。后端语言都提供流相关的API，比如nodejs的Stream类。

网络传输中：数据都是以字节流的形式传输的。

浏览器端：浏览器会自动的以流的形式发送和接收数据，开发者无需显式操作。这也是我们前端在开发中，感受不到流的存在，很少使用流的原因。

需要注意的是，不管服务器是否采用流的方式发送数据，在网络传输阶段，都是字节流。浏览器也不关心服务器是否使用流，因为经过网络传输，到了浏览器这儿，接收到的都是流。

尽管如此，对于服务器来说，显式的以流的方式接收和发送数据，仍然是很有好处的。

13. mime类型：

mime类型是一种标准化的互联网标准，用于描述在网络上传输的数据类型。最初是为了扩展电子邮件以支持多种数据类型而设计的，但现在广泛应用于HTTP协议中。

mime类型由两部分组成：主要类型和子类型，中间用斜线分隔。例如：text/plain、image/jpeg、application/pdf等。

mime类型和文件格式大部分时候一一对应。你可以理解，在我们电脑里是文件格式，在HTTP协议中是mime类型。

14. 一次HTTP请求：

一次完整的HTTP请求，是指从浏览器发送请求，到浏览器接收完所有数据的全过程。如果请求的是一个视频，那么直到浏览器把这个视频下载完成，这次HTTP请求才算结束。

也就是说，一个HTTP请求完全可能持续很长时间，并不都是我们大部分时候看到的很快完成的。当然，得益于接收到的是流数据，浏览器可以边下载边播放。