Fix all build warnings (CA/CS analyzers) across src and tests

Eliminates every warning surfaced by a clean Release build (174 -> 0):
- CA2000: split chained `LoadImage(...)[rect]`/`new IndexParams()` expressions
  into separate `using` declarations so every disposable is tracked
- CA1861: hoist constant array literals passed to repeatedly-invoked test
  helpers into static readonly fields
- CA5394: mark test files that use seeded `Random` for synthetic data as
  intentionally non-cryptographic (matches existing CoreTest.cs convention)
- CS8602/CS8604: add the missing null checks that StereoCalibrate's
  InputArray overload and FindHomography/FindFundamentalMat's mask parameter
  should have had, and widen InputArray's Mat conversion/factory to accept
  null (mirroring the existing nullable-Mat constructor) so passing a null
  Mat for an optional InputArray? parameter no longer looks unsafe
- CS1573: document the AlgorithmHint `hint` parameter added to
  CvtColor/CvtColorTwoPlane/GaussianBlur/Remap/WarpAffine/WarpPerspective
- CS1591: suppress doc-comment requirements on the internal blittable
  FacemarkAAM/LBF ParamsData marshalling structs (same pattern already used
  for CvEdgeDrawingParams)
- CA1859/CA1805/CA1069/CA1000: narrow InputArray's owned-disposable field to
  Mat, drop a redundant default-value initializer, and suppress the two
  known-intentional false positives (PutTextFlags' dual-axis bit flags,
  SparseMat<T>'s generic static factory)

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: shimat

src/OpenCvSharp/Cv2/Cv2_calib.cs

@@ -570,6 +570,14 @@ public static double StereoCalibrate(
             throw new ArgumentNullException(nameof(cameraMatrix2));
         if (distCoeffs2 is null)
             throw new ArgumentNullException(nameof(distCoeffs2));
+        if (R is null)
+            throw new ArgumentNullException(nameof(R));
+        if (T is null)
+            throw new ArgumentNullException(nameof(T));
+        if (E is null)
+            throw new ArgumentNullException(nameof(E));
+        if (F is null)
+            throw new ArgumentNullException(nameof(F));
         cameraMatrix1.ThrowIfDisposed();
         distCoeffs1.ThrowIfDisposed();
         cameraMatrix2.ThrowIfDisposed();
@@ -592,7 +600,7 @@ public static double StereoCalibrate(
                 ip1Ptrs, ip1Ptrs.Length, ip2Ptrs, ip2Ptrs.Length,
                 cameraMatrix1.ToInputOutputProxy(), distCoeffs1.ToInputOutputProxy(),
                 cameraMatrix2.ToInputOutputProxy(), distCoeffs2.ToInputOutputProxy(),
-                imageSize, R?.ToOutputProxy() ?? default, T?.ToOutputProxy() ?? default, E?.ToOutputProxy() ?? default, F?.ToOutputProxy() ?? default,
+                imageSize, R.ToOutputProxy(), T.ToOutputProxy(), E.ToOutputProxy(), F.ToOutputProxy(),
                 (int) flags, criteria0, out var ret));
 
         GC.KeepAlive(cameraMatrix1);

src/OpenCvSharp/Cv2/Cv2_geometry.cs

@@ -195,7 +195,7 @@ public static Mat FindHomography(
         var p = (@params ?? new UsacParams()).ToNativeStruct();
         NativeMethods.HandleException(
             NativeMethods.geometry_findHomography_UsacParams(
-                srcPoints.ToInputProxy(), dstPoints.ToInputProxy(), mask?.ToOutputProxy() ?? default, ref p,
+                srcPoints.ToInputProxy(), dstPoints.ToInputProxy(), mask.ToOutputProxy(), ref p,
                 out var ret));
 
         GC.KeepAlive(srcPoints);
@@ -1432,7 +1432,7 @@ public static Mat FindFundamentalMat(InputArray points1, InputArray points2, Out
         var p = (@params ?? new UsacParams()).ToNativeStruct();
         NativeMethods.HandleException(
             NativeMethods.geometry_findFundamentalMat_UsacParams(
-                points1.ToInputProxy(), points2.ToInputProxy(), mask?.ToOutputProxy() ?? default, ref p, out var ret));
+                points1.ToInputProxy(), points2.ToInputProxy(), mask.ToOutputProxy(), ref p, out var ret));
 
         GC.KeepAlive(points1);
         GC.KeepAlive(points2);

src/OpenCvSharp/Cv2/Cv2_imgproc.cs

@@ -156,6 +156,7 @@ public static void MedianBlur(InputArray src, OutputArray dst, int ksize)
     /// respectively (see getGaussianKernel() for details); to fully control the result 
     /// regardless of possible future modifications of all this semantics, it is recommended to specify all of ksize, sigmaX, and sigmaY.</param>
     /// <param name="borderType">pixel extrapolation method</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void GaussianBlur(InputArray src, OutputArray dst, Size ksize, double sigmaX,
         double sigmaY = 0, BorderTypes borderType = BorderTypes.Default, AlgorithmHint hint = AlgorithmHint.Default)
     {
@@ -1051,6 +1052,7 @@ public static void Resize(InputArray src, OutputArray dst, Size dsize,
     /// it means that the pixels in the destination image corresponding to the "outliers" 
     /// in the source image are not modified by the function.</param>
     /// <param name="borderValue">value used in case of a constant border; by default, it is 0.</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void WarpAffine(
         InputArray src, OutputArray dst, InputArray m, Size dsize,
         InterpolationFlags flags = InterpolationFlags.Linear,
@@ -1088,6 +1090,7 @@ public static void WarpAffine(
     /// and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation (dst -> src).</param>
     /// <param name="borderMode">pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).</param>
     /// <param name="borderValue">value used in case of a constant border; by default, it equals 0.</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void WarpPerspective(
         InputArray src, OutputArray dst, InputArray m, Size dsize,
         InterpolationFlags flags = InterpolationFlags.Linear,
@@ -1127,6 +1130,7 @@ public static void WarpPerspective(
     /// and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation (dst -> src).</param>
     /// <param name="borderMode">pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).</param>
     /// <param name="borderValue">value used in case of a constant border; by default, it equals 0.</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void WarpPerspective(
         InputArray src, OutputArray dst, float[,] m, Size dsize,
         InterpolationFlags flags = InterpolationFlags.Linear,
@@ -1168,6 +1172,7 @@ public static void WarpPerspective(
     /// it means that the pixels in the destination image that corresponds to the "outliers" in 
     /// the source image are not modified by the function.</param>
     /// <param name="borderValue">Value used in case of a constant border. By default, it is 0.</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void Remap(
         InputArray src, OutputArray dst, InputArray map1, InputArray map2,
         InterpolationFlags interpolation = InterpolationFlags.Linear,
@@ -2430,6 +2435,7 @@ public static void BlendLinear(InputArray src1, InputArray src2, InputArray weig
     /// <param name="dst">The destination image; will have the same size and the same depth as src</param>
     /// <param name="code">The color space conversion code</param>
     /// <param name="dstCn">The number of channels in the destination image; if the parameter is 0, the number of the channels will be derived automatically from src and the code</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void CvtColor(InputArray src, OutputArray dst, ColorConversionCodes code, int dstCn = 0,
         AlgorithmHint hint = AlgorithmHint.Default)
     {
@@ -2464,6 +2470,7 @@ public static void CvtColor(InputArray src, OutputArray dst, ColorConversionCode
     /// - #COLOR_YUV2RGB_NV21
     /// - #COLOR_YUV2BGRA_NV21
     /// - #COLOR_YUV2RGBA_NV21</param>
+    /// <param name="hint">Hint that selects between alternative algorithm implementations (OpenCV 5).</param>
     public static void CvtColorTwoPlane(InputArray src1, InputArray src2, OutputArray dst, ColorConversionCodes code,
         AlgorithmHint hint = AlgorithmHint.Default)
     {

src/OpenCvSharp/Internal/PInvoke/NativeMethods/face/FacemarkParamsData.cs

@@ -1,5 +1,7 @@
 using System.Runtime.InteropServices;
 
+#pragma warning disable 1591
+
 namespace OpenCvSharp.Internal;
 
 /// <summary>

src/OpenCvSharp/Modules/core/InputArray.cs

@@ -16,7 +16,7 @@ public class InputArray : CvObject
 
     // A resource materialized by this InputArray itself (e.g. the Mat produced from a
     // MatExpr). Unlike 'obj', which is merely kept alive, this is disposed with the InputArray.
-    private IDisposable? ownedDisposable;
+    private Mat? ownedDisposable;
 
 #pragma warning disable 1591
     // ReSharper disable InconsistentNaming
@@ -306,7 +306,7 @@ protected override void DisposeManaged()
     /// </summary>
     /// <param name="mat"></param>
     /// <returns></returns>
-    public static InputArray Create(Mat mat) => new(mat);
+    public static InputArray Create(Mat? mat) => new(mat);
 
     /// <summary>
     /// Creates a proxy class of the specified Mat
@@ -609,7 +609,7 @@ private static MatType EstimateType(Type t)
 #pragma warning disable 1591
 #pragma warning disable CA2225
 
-    public static implicit operator InputArray(Mat mat) => Create(mat);
+    public static implicit operator InputArray(Mat? mat) => Create(mat);
 
     public static implicit operator InputArray(UMat mat) => Create(mat);
 

src/OpenCvSharp/Modules/core/SparseMat.cs

@@ -469,7 +469,9 @@ internal static SparseMat<T> WrapShared(SparseMat source)
     /// Creates a typed sparse matrix from a dense <see cref="Mat"/>. The Mat type must match
     /// <typeparamref name="T"/>.
     /// </summary>
+#pragma warning disable CA1000 // Do not declare static members on generic types
     public static new SparseMat<T> FromMat(Mat mat)
+#pragma warning restore CA1000
     {
         if (mat is null)
             throw new ArgumentNullException(nameof(mat));

src/OpenCvSharp/Modules/imgproc/Enum/PutTextFlags.cs

@@ -30,7 +30,9 @@ public enum PutTextFlags
     /// <summary>
     /// Treat the target image as having a top-left origin (default).
     /// </summary>
+#pragma warning disable CA1069 // Intentional: shares 0 with AlignLeft, an independent bitfield (alignment vs. origin), mirroring cv::PutTextFlags.
     OriginTL = 0,
+#pragma warning restore CA1069
 
     /// <summary>
     /// Treat the target image as having a bottom-left origin.

src/OpenCvSharp/Modules/imgproc/Filter2DParams.cs

@@ -24,7 +24,7 @@ public class Filter2DParams
     /// <summary>
     /// Border value used in case of a constant border.
     /// </summary>
-    public Scalar BorderValue { get; set; } = new Scalar();
+    public Scalar BorderValue { get; set; }
 
     /// <summary>
     /// Desired depth of the destination image. -1 means the same depth as the source.

test/OpenCvSharp.Tests/calib3d/FishEyeTest.cs

@@ -6,14 +6,18 @@ namespace OpenCvSharp.Tests.Calib3D;
 // otherwise exercised (issue #1976 follow-up: every migrated method needs >=1 test).
 public class FishEyeTest : TestBase
 {
-    private static Mat CameraMatrix() => Mat.FromPixelData(3, 3, MatType.CV_64FC1, new double[]
+    private static readonly double[] CameraMatrixValues =
     {
         300, 0, 160,
         0, 300, 120,
         0, 0, 1
-    });
+    };
 
-    private static Mat DistCoeffs() => Mat.FromPixelData(4, 1, MatType.CV_64FC1, new[] { 0.1, 0.01, 0.0, 0.0 });
+    private static readonly double[] DistCoeffsValues = { 0.1, 0.01, 0.0, 0.0 };
+
+    private static Mat CameraMatrix() => Mat.FromPixelData(3, 3, MatType.CV_64FC1, CameraMatrixValues);
+
+    private static Mat DistCoeffs() => Mat.FromPixelData(4, 1, MatType.CV_64FC1, DistCoeffsValues);
 
     [Fact]
     public void UndistortPoints()

test/OpenCvSharp.Tests/calib3d/GeometryFunctionsTest.cs

@@ -1,5 +1,7 @@
 using Xunit;
 
+#pragma warning disable CA5394 // Do not use insecure randomness
+
 namespace OpenCvSharp.Tests.Calib3D;
 
 // Tests for the OpenCV 5 geometry/calib functions added to OpenCvSharp:
@@ -20,6 +22,11 @@ public class GeometryFunctionsTest : TestBase
         new Point3f(0, 0, 1), new Point3f(1, 0, 1), new Point3f(0, 1, 1), new Point3f(1, 1, 1)
     };
 
+    private static readonly double[] UnitTranslationX = { 1.0, 0.0, 0.0 };
+    private static readonly double[] UnitTranslationY = { 0.0, 1.0, 0.0 };
+    private static readonly double[] UnitPoint3D = { 1.0, 1.0, 1.0 };
+    private static readonly double[] SmallDistCoeffs = { 0.1, 0.01, 0.0, 0.0 };
+
     [Theory]
     [InlineData(false)]
     [InlineData(true)]
@@ -165,9 +172,9 @@ public void ComposeRT()
     {
         // Two pure translations (no rotation) compose by simply adding the translations.
         using var rvec1 = Mat.ZerosMat(3, 1, MatType.CV_64FC1);
-        using var tvec1 = Mat.FromPixelData(3, 1, MatType.CV_64FC1, new[] { 1.0, 0.0, 0.0 });
+        using var tvec1 = Mat.FromPixelData(3, 1, MatType.CV_64FC1, UnitTranslationX);
         using var rvec2 = Mat.ZerosMat(3, 1, MatType.CV_64FC1);
-        using var tvec2 = Mat.FromPixelData(3, 1, MatType.CV_64FC1, new[] { 0.0, 1.0, 0.0 });
+        using var tvec2 = Mat.FromPixelData(3, 1, MatType.CV_64FC1, UnitTranslationY);
         using var rvec3 = new Mat();
         using var tvec3 = new Mat();
 
@@ -482,8 +489,8 @@ public void RQDecomp3x3()
     [Fact]
     public void SampsonDistance()
     {
-        using var pt1 = Mat.FromPixelData(1, 1, MatType.CV_64FC3, new[] { 1.0, 1.0, 1.0 });
-        using var pt2 = Mat.FromPixelData(1, 1, MatType.CV_64FC3, new[] { 1.0, 1.0, 1.0 });
+        using var pt1 = Mat.FromPixelData(1, 1, MatType.CV_64FC3, UnitPoint3D);
+        using var pt2 = Mat.FromPixelData(1, 1, MatType.CV_64FC3, UnitPoint3D);
         using var f = Mat.FromPixelData(3, 3, MatType.CV_64FC1, new double[]
         {
             0, 0, 0,
@@ -597,7 +604,7 @@ public void FishEyeDistortPointsWithUndistortedMatrix()
             0, 0, 1
         });
         using var kUndistorted = k.Clone();
-        using var d = Mat.FromPixelData(4, 1, MatType.CV_64FC1, new[] { 0.1, 0.01, 0.0, 0.0 });
+        using var d = Mat.FromPixelData(4, 1, MatType.CV_64FC1, SmallDistCoeffs);
 
         Cv2.FishEye.DistortPoints(undistorted, distorted, kUndistorted, k, d);