Metis_xctg/Adjust/AdjustIntent.cs

using OpenCvSharp;
using OpenCvSharp.Extensions;
using PaintDotNet.Adjust.BaseImage;
using PaintDotNet.Base;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace PaintDotNet.Adjust
{
    public struct UVT
    {
        //[FieldOffset(0)]
        public double u;
        //[FieldOffset(1)]
        public double v;
        //[FieldOffset(2)]
        public double t;
    }

    /// <summary>
    /// 图像调节
    /// </summary>
    public unsafe class AdjustIntent
    {
        /// <summary>
        /// 全局的mat，用来做中间变量，但是需要注意销毁
        /// </summary>
        private static Mat phaseTemp1;
        private static Mat phaseTempMax;
        private static Mat phaseTempMin;
        private static Mat localMeansMatrix;// = new Mat(src.Rows, src.Cols, MatType.CV_32FC1);
        private static Mat localVarianceMatrix;// = new Mat(src.Rows, src.Cols, MatType.CV_32FC1);
        private static double contrast = 1.5;        //对比度 contrast Enter the alpha value [1.0-3.0]:  
        private static double brightness = 50;       //亮度 brightness Enter the beta value [0-100]
        private static int localThreshold;               //阈值
        private static int dstWidth;                     //图像的宽度
        private static int dstChannel;                    //图像的通道数
        //(三通道)图像拷贝
        private static Mat calMats;
        //白平衡C-翻译
        private static double localTemp = -1.0, localGreen = -1.0, localEqual = 1.0, INITIALBLACKBODY = 4000.0;
        private static string localMethod = "Custom";
        private static int settings_CRI_color = 4; // Number for display Lab value; 0 = disabled
        private static bool settings_verbose = false;
        private static double[][] cie_colour_match_jd = {//350nm to 830nm   5 nm J.Desmis 10° Standard Observer.
            new double[]{0.000000000000, 0.000000000000, 0.000000000000},
            new double[]{0.000000000000, 0.000000000000, 0.000000000000},
            new double[]{0.000000122200, 0.000000013398, 0.000000535027},
            new double[]{0.000000919270, 0.000000100650, 0.000004028300},
            new double[]{0.000005958600, 0.000000651100, 0.000026143700},
            new double[]{0.000033266000, 0.000003625000, 0.000146220000},
            new double[]{0.000159952000, 0.000017364000, 0.000704776000},
            new double[]{0.000662440000, 0.000071560000, 0.002927800000},
            new double[]{0.002361600000, 0.000253400000, 0.010482200000},
            new double[]{0.007242300000, 0.000768500000, 0.032344000000},
            new double[]{0.019109700000, 0.002004400000, 0.086010900000},
            new double[]{0.043400000000, 0.004509000000, 0.197120000000},
            new double[]{0.084736000000, 0.008756000000, 0.389366000000},
            new double[]{0.140638000000, 0.014456000000, 0.656760000000},
            new double[]{0.204492000000, 0.021391000000, 0.972542000000},
            new double[]{0.264737000000, 0.029497000000, 1.282500000000},
            new double[]{0.314679000000, 0.038676000000, 1.553480000000},
            new double[]{0.357719000000, 0.049602000000, 1.798500000000},
            new double[]{0.383734000000, 0.062077000000, 1.967280000000},
            new double[]{0.386726000000, 0.074704000000, 2.027300000000},
            new double[]{0.370702000000, 0.089456000000, 1.994800000000},
            new double[]{0.342957000000, 0.106256000000, 1.900700000000},
            new double[]{0.302273000000, 0.128201000000, 1.745370000000},
            new double[]{0.254085000000, 0.152761000000, 1.554900000000},
            new double[]{0.195618000000, 0.185190000000, 1.317560000000},
            new double[]{0.132349000000, 0.219940000000, 1.030200000000},
            new double[]{0.080507000000, 0.253589000000, 0.772125000000},
            new double[]{0.041072000000, 0.297665000000, 0.570060000000},
            new double[]{0.016172000000, 0.339133000000, 0.415254000000},
            new double[]{0.005132000000, 0.395379000000, 0.302356000000},
            new double[]{0.003816000000, 0.460777000000, 0.218502000000},
            new double[]{0.015444000000, 0.531360000000, 0.159249000000},
            new double[]{0.037465000000, 0.606741000000, 0.112044000000},
            new double[]{0.071358000000, 0.685660000000, 0.082248000000},
            new double[]{0.117749000000, 0.761757000000, 0.060709000000},
            new double[]{0.172953000000, 0.823330000000, 0.043050000000},
            new double[]{0.236491000000, 0.875211000000, 0.030451000000},
            new double[]{0.304213000000, 0.923810000000, 0.020584000000},
            new double[]{0.376772000000, 0.961988000000, 0.013676000000},
            new double[]{0.451584000000, 0.982200000000, 0.007918000000},
            new double[]{0.529826000000, 0.991761000000, 0.003988000000},
            new double[]{0.616053000000, 0.999110000000, 0.001091000000},
            new double[]{0.793832000000, 0.982380000000, 0.000000000000},
            new double[]{0.878655000000, 0.955552000000, 0.000000000000},
            new double[]{0.951162000000, 0.915175000000, 0.000000000000},
            new double[]{1.014160000000, 0.868934000000, 0.000000000000},
            new double[]{1.074300000000, 0.825623000000, 0.000000000000},
            new double[]{1.118520000000, 0.777405000000, 0.000000000000},
            new double[]{1.134300000000, 0.720353000000, 0.000000000000},
            new double[]{1.123990000000, 0.658341000000, 0.000000000000},
            new double[]{1.089100000000, 0.593878000000, 0.000000000000},
            new double[]{1.030480000000, 0.527963000000, 0.000000000000},
            new double[]{0.950740000000, 0.461834000000, 0.000000000000},
            new double[]{0.856297000000, 0.398057000000, 0.000000000000},
            new double[]{0.754930000000, 0.339554000000, 0.000000000000},
            new double[]{0.647467000000, 0.283493000000, 0.000000000000},
            new double[]{0.535110000000, 0.228254000000, 0.000000000000},
            new double[]{0.431567000000, 0.179828000000, 0.000000000000},
            new double[]{0.343690000000, 0.140211000000, 0.000000000000},
            new double[]{0.268329000000, 0.107633000000, 0.000000000000},
            new double[]{0.204300000000, 0.081187000000, 0.000000000000},
            new double[]{0.152568000000, 0.060281000000, 0.000000000000},
            new double[]{0.112210000000, 0.044096000000, 0.000000000000},
            new double[]{0.081260600000, 0.031800400000, 0.000000000000},
            new double[]{0.057930000000, 0.022601700000, 0.000000000000},
            new double[]{0.040850800000, 0.015905100000, 0.000000000000},
            new double[]{0.028623000000, 0.011130300000, 0.000000000000},
            new double[]{0.019941300000, 0.007748800000, 0.000000000000},
            new double[]{0.013842000000, 0.005375100000, 0.000000000000},
            new double[]{0.009576880000, 0.003717740000, 0.000000000000},
            new double[]{0.006605200000, 0.002564560000, 0.000000000000},
            new double[]{0.004552630000, 0.001768470000, 0.000000000000},
            new double[]{0.003144700000, 0.001222390000, 0.000000000000},
            new double[]{0.002174960000, 0.000846190000, 0.000000000000},
            new double[]{0.001505700000, 0.000586440000, 0.000000000000},
            new double[]{0.001044760000, 0.000407410000, 0.000000000000},
            new double[]{0.000727450000, 0.000284041000, 0.000000000000},
            new double[]{0.000508258000, 0.000198730000, 0.000000000000},
            new double[]{0.000356380000, 0.000139550000, 0.000000000000},
            new double[]{0.000250969000, 0.000098428000, 0.000000000000},
            new double[]{0.000177730000, 0.000069819000, 0.000000000000},
            new double[]{0.000126390000, 0.000049737000, 0.000000000000},
            new double[]{0.000090151000, 0.000035540500, 0.000000000000},
            new double[]{0.000064525800, 0.000025486000, 0.000000000000},
            new double[]{0.000046339000, 0.000018338400, 0.000000000000},
            new double[]{0.000033411700, 0.000013249000, 0.000000000000},
            new double[]{0.000024209000, 0.000009619600, 0.000000000000},
            new double[]{0.000017611500, 0.000007012800, 0.000000000000},
            new double[]{0.000012855000, 0.000005129800, 0.000000000000},
            new double[]{0.000009413630, 0.000003764730, 0.000000000000},
            new double[]{0.000006913000, 0.000002770810, 0.000000000000},
            new double[]{0.000005093470, 0.000002046130, 0.000000000000},
            new double[]{0.000003767100, 0.000001516770, 0.000000000000},
            new double[]{0.000002795310, 0.000001128090, 0.000000000000},
            new double[]{0.000002082000, 0.000000842160, 0.000000000000},
            new double[]{0.000001553140, 0.000000629700, 0.000000000000},
            new double[]{0.000000000000, 0.000000000000, 0.000000000000}//手动加0
        };
        // spectral data for Daylight direct Sun: I have choose 5300K because Nikon=5200K, Olympus=5300K, Panasonic=5500K, Leica=5400K, Minolta=5100K
        private static double[] Daylight5300_spect = {
            24.82, 26.27, 27.72, 28.97, 30.22, 29.71, 29.19, 31.95, 34.71, 45.49, 56.26, 59.97, 63.68, 65.30, 66.92, 65.39, 63.86, 72.59, 81.32, 87.53, 93.73, 95.15, 96.56, 96.55, 96.54, 98.13, 99.73, 97.70, 95.66, 97.19, 98.72,
            98.90, 99.08, 98.98, 98.87, 101.13, 103.39, 102.48, 101.57, 102.14, 102.71, 101.36, 100.00, 98.71, 97.42, 97.81, 98.21, 95.20, 92.20, 93.92, 95.63, 96.15, 96.67, 96.34, 96.01, 94.21, 92.41, 93.58, 94.74, 93.05, 91.36, 92.29,
            93.21, 95.25, 97.28, 95.30, 93.32, 87.92, 82.51, 84.29, 86.06, 86.94, 87.81, 80.24, 72.68, 77.32, 81.96, 84.88, 87.79, 81.01, 74.22, 64.41, 54.60, 66.55, 78.51, 76.35, 74.20, 74.79, 75.38, 72.48, 69.58, 65.11, 60.64,
            63.88, 67.13, 68.85, 70.57
        };
        //spectral data for Daylight Cloudy: I have choose 6200K because Nikon=6000K, Olympus=6000K, Panasonic=6200K, Leica=6400K, Minolta=6500K
        private static double[] Cloudy6200_spect = {
            39.50, 40.57, 41.63, 43.85, 46.08, 45.38, 44.69, 47.20, 49.71, 63.06, 76.41, 80.59, 84.77, 85.91, 87.05, 84.14, 81.23, 90.29, 99.35, 105.47, 111.58, 112.23, 112.87, 111.74, 110.62, 111.41, 112.20, 108.98, 105.76, 106.32,
            106.89, 106.34, 105.79, 104.62, 103.45, 105.09, 106.72, 105.24, 103.76, 103.75, 103.75, 101.87, 100.00, 98.29, 96.58, 96.46, 96.34, 92.85, 89.37, 90.25, 91.12, 91.06, 90.99, 90.17, 89.35, 87.22, 85.10, 85.48, 85.85,
            84.03, 82.20, 82.45, 82.69, 83.92, 85.15, 83.14, 81.13, 76.65, 72.17, 73.27, 74.36, 75.65, 76.95, 70.34, 63.74, 67.98, 72.22, 74.88, 77.54, 71.59, 65.65, 56.82, 47.99, 58.53, 69.06, 67.27, 65.47, 65.96, 66.44, 63.92, 61.41, 57.52,
            53.63, 56.47, 59.31, 60.80, 62.29
        };
        //spectral data for Daylight Shade: I have choose 7600K because Nikon=8000K, Olympus=7500K, Panasonic=7500K, Leica=7500K, Minolta=7500K
        private static double[] Shade7600_spect = {
            64.42, 64.46, 64.51, 68.35, 72.20, 70.22, 68.24, 69.79, 71.35, 87.49, 103.64, 108.68, 113.72, 114.12, 114.53, 109.54, 104.55, 113.59, 122.63, 128.52, 134.41, 134.02, 133.63, 131.02, 128.41, 128.08, 127.75, 123.16,
            118.57, 117.89, 117.22, 115.72, 114.22, 111.60, 108.99, 109.84, 110.68, 108.57, 106.45, 105.71, 104.98, 102.49, 100.00, 97.78, 95.55, 94.82, 94.08, 90.47, 86.87, 86.94, 87.01, 86.45, 85.88, 84.57, 83.27, 80.83, 78.40, 78.21,
            78.03, 76.22, 74.42, 74.15, 73.89, 74.41, 74.92, 73.01, 71.09, 67.26, 63.42, 64.01, 64.60, 66.10, 67.60, 61.83, 56.06, 59.94, 63.82, 66.27, 68.71, 63.49, 58.26, 50.30, 42.34, 51.64, 60.95, 59.45, 57.95, 58.35, 58.76, 56.57,
            54.38, 51.00, 47.62, 50.10, 52.58, 53.88, 55.19
        };
        //spectral data for tungsten - incandescent 2856K
        private static double[] A2856_spect = {
            4.75, 5.42, 6.15, 6.95, 7.83, 8.78, 9.80, 10.91, 12.09, 13.36, 14.72, 16.16, 17.69, 19.30, 21.01, 22.80, 24.68, 26.65, 28.71, 30.86, 33.10, 35.42, 37.82, 40.31, 42.88, 45.53, 48.25, 51.05, 53.92, 56.87, 59.87, 62.94, 66.07, 69.26, 72.50,
            75.80, 79.14, 82.53, 85.95, 89.42, 92.91, 96.44, 100.00, 103.58, 107.18, 110.80, 114.43, 118.07, 121.72, 125.38, 129.03, 132.68, 136.33, 139.97, 143.60, 147.21, 150.81, 154.39, 157.95, 161.48, 164.99, 168.47, 171.92, 175.34,
            178.72, 182.07, 185.38, 188.65, 191.88, 195.06, 198.20, 201.30, 204.34, 207.34, 210.29, 213.19, 216.04, 218.84, 221.58, 224.28, 226.91, 229.49, 232.02, 234.49, 236.91, 239.27, 241.57, 243.82, 246.01, 248.14, 250.21, 252.23, 254.19,
            256.10, 257.95, 259.74, 261.47
        };
        //spectral data for fluo  F1 Daylight 6430K
        private static double[] FluoF1_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.87, 2.36, 2.94, 3.47, 5.17, 19.49, 6.13, 6.24, 7.01, 7.79, 8.56, 43.67, 16.94, 10.72, 11.35, 11.89, 12.37, 12.75, 13.00, 13.15, 13.23, 13.17, 13.13, 12.85, 12.52,
            12.20, 11.83, 11.50, 11.22, 11.05, 11.03, 11.18, 11.53, 27.74, 17.05, 13.55, 14.33, 15.01, 15.52, 18.29, 19.55, 15.48, 14.91, 14.15, 13.22, 12.19, 11.12, 10.03, 8.95, 7.96, 7.02, 6.20, 5.42, 4.73, 4.15, 3.64, 3.20, 2.81,
            2.47, 2.18, 1.93, 1.72, 1.67, 1.43, 1.29, 1.19, 1.08, 0.96, 0.88, 0.81, 0.77, 0.75, 0.73, 0.68, 0.69, 0.64, 0.68, 0.69, 0.61, 0.52, 0.43, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo  F2 Cool white 4230K
        private static double[] FluoF2_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.18, 1.48, 1.84, 2.15, 3.44, 15.69, 3.85, 3.74, 4.19, 4.62, 5.06, 34.98, 11.81, 6.27, 6.63, 6.93, 7.19, 7.40, 7.54, 7.62, 7.65, 7.62, 7.62, 7.45, 7.28, 7.15, 7.05, 7.04, 7.16, 7.47, 8.04, 8.88, 10.01, 24.88, 16.64, 14.59, 16.16, 17.60, 18.62, 21.47, 22.79, 19.29, 18.66, 17.73, 16.54, 15.21, 13.80, 12.36, 10.95, 9.65, 8.40, 7.32, 6.31, 5.43, 4.68, 4.02, 3.45,
            2.96, 2.55, 2.19, 1.89, 1.64, 1.53, 1.27, 1.10, 0.99, 0.88, 0.76, 0.68, 0.61, 0.56, 0.54, 0.51, 0.47, 0.47, 0.43, 0.46, 0.47, 0.40, 0.33, 0.27, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };

        //spectral data for fluo  F3 White 3450K
        private static double[] FluoF3_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.82, 1.02, 1.26, 1.44, 2.57, 14.36, 2.70, 2.45, 2.73, 3.00, 3.28, 31.85, 9.47, 4.02, 4.25, 4.44, 4.59, 4.72, 4.80, 4.86, 4.87, 4.85, 4.88, 4.77, 4.67, 4.62, 4.62, 4.73, 4.99, 5.48, 6.25,
            7.34, 8.78, 23.82, 16.14, 14.59, 16.63, 18.49, 19.95, 23.11, 24.69, 21.41, 20.85, 19.93, 18.67, 17.22, 15.65, 14.04, 12.45, 10.95, 9.51, 8.27, 7.11, 6.09, 5.22, 4.45, 3.80, 3.23, 2.75, 2.33, 1.99, 1.70, 1.55,
            1.27, 1.09, 0.96, 0.83, 0.71, 0.62, 0.54, 0.49, 0.46, 0.43, 0.39, 0.39, 0.35, 0.38, 0.39, 0.33, 0.28, 0.21, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F4 Warm white 2940K
        private static double[] FluoF4_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.57, 0.70, 0.87, 0.98, 2.01, 13.75, 1.95, 1.59, 1.76, 1.93, 2.10, 30.28, 8.03, 2.55, 2.70, 2.82, 2.91, 2.99, 3.04, 3.08, 3.09, 3.09, 3.14, 3.06, 3.00, 2.98, 3.01,
            3.14, 3.41, 3.90, 4.69, 5.81, 7.32, 22.59, 15.11, 13.88, 16.33, 18.68, 20.64, 24.28, 26.26, 23.28, 22.94, 22.14, 20.91, 19.43, 17.74, 16.00, 14.42, 12.56, 10.93, 9.52, 8.18, 7.01, 6.00, 5.11, 4.36, 3.69, 3.13, 2.64,
            2.24, 1.91, 1.70, 1.39, 1.18, 1.03, 0.88, 0.74, 0.64, 0.54, 0.49, 0.46, 0.42, 0.37, 0.37, 0.33, 0.35, 0.36, 0.31, 0.26, 0.19, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F5 Daylight 6350K
        private static double[] FluoF5_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.87, 2.35, 2.92, 3.45, 5.10, 18.91, 6.00, 6.11, 6.85, 7.58, 8.31, 40.76, 16.06, 10.32, 10.91, 11.40, 11.83, 12.17, 12.40, 12.54, 12.58, 12.52, 12.47, 12.20, 11.89,
            11.61, 11.33, 11.10, 10.96, 10.97, 11.16, 11.54, 12.12, 27.78, 17.73, 14.47, 15.20, 15.77, 16.10, 18.54, 19.50, 15.39, 14.64, 13.72, 12.69, 11.57, 10.45, 9.35, 8.29, 7.32, 6.41, 5.63, 4.90, 4.26,
            3.72, 3.25, 2.83, 2.49, 2.19, 1.93, 1.71, 1.52, 1.43, 1.26, 1.13, 1.05, 0.96, 0.85, 0.78, 0.72, 0.68, 0.67, 0.65, 0.61, 0.62, 0.59, 0.62, 0.64, 0.55, 0.47, 0.40, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F6 Lite white 4150K
        private static double[] FluoF6_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.05, 1.31, 1.63, 1.90, 3.11, 14.8, 3.43, 3.30, 3.68, 4.07, 4.45, 32.61, 10.74, 5.48, 5.78, 6.03, 6.25, 6.41, 6.52, 6.58, 6.59, 6.56, 6.56, 6.42, 6.28, 6.20, 6.19, 6.30, 6.60, 7.12, 7.94, 9.07, 10.49, 25.22, 17.46, 15.63, 17.22, 18.53,
            19.43, 21.97, 23.01, 19.41, 18.56, 17.42, 16.09, 14.64, 13.15, 11.68, 10.25, 8.96, 7.74, 6.69, 5.71, 4.87, 4.16, 3.55, 3.02, 2.57, 2.20, 1.87, 1.60, 1.37, 1.29, 1.05, 0.91, 0.81, 0.71, 0.61, 0.54, 0.48, 0.44,
            0.43, 0.40, 0.37, 0.38, 0.35, 0.39, 0.41, 0.33, 0.26, 0.21, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F7 D65 Daylight simulator 6500K
        private static double[] FluoF7_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.56, 3.18, 3.84, 4.53, 6.15, 19.37, 7.37, 7.05, 7.71, 8.41, 9.15, 44.14, 17.52, 11.35, 12.00, 12.58, 13.08, 13.45, 13.71, 13.88, 13.95, 13.93, 13.82, 13.64, 13.43, 13.25, 13.08, 12.93, 12.78, 12.60,
            12.44, 12.33, 12.26, 29.52, 17.05, 12.44, 12.58, 12.72, 12.83, 15.46, 16.75, 12.83, 12.67, 12.43, 12.19, 11.89, 11.60, 11.35, 11.12, 10.95, 10.76, 10.42, 10.11, 10.04, 10.02, 10.11, 9.87, 8.65, 7.27, 6.44, 5.83, 5.41,
            5.04, 4.57, 4.12, 3.77, 3.46, 3.08, 2.73, 2.47, 2.25, 2.06, 1.90, 1.75, 1.62, 1.54, 1.45, 1.32, 1.17, 0.99, 0.81, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F8 D50 simulator Sylvania F40 Design 5000K
        private static double[] FluoF8_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.21, 1.5, 1.81, 2.13, 3.17, 13.08, 3.83, 3.45, 3.86, 4.42, 5.09, 34.1, 12.42, 7.68, 8.60, 9.46, 10.24, 10.84, 11.33, 11.71, 11.98, 12.17, 12.28, 12.32, 12.35, 12.44, 12.55, 12.68, 12.77, 12.72,
            12.60, 12.43, 12.22, 28.96, 16.51, 11.79, 11.76, 11.77, 11.84, 14.61, 16.11, 12.34, 13.61, 13.87, 14.07, 14.20, 14.16, 14.13, 14.34, 14.50, 14.46, 14.00, 12.58, 10.99, 9.98, 9.22, 8.62, 8.07, 7.39, 6.71, 6.16, 5.63, 5.03, 4.46, 4.02, 3.66,
            3.36, 3.09, 2.85, 2.65, 2.51, 2.37, 2.15, 1.89, 1.61, 1.32, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F9 Cool white deluxe 4150K
        private static double[] FluoF9_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.9, 1.12, 1.36, 1.60, 2.59, 12.8, 3.05, 2.56, 2.86, 3.30, 3.82, 32.62, 10.77, 5.84, 6.57, 7.25, 7.86, 8.35, 8.75, 9.06, 9.31, 9.48, 9.61, 9.68, 10.04, 10.26, 10.48, 10.63, 10.76, 10.96,
            11.18, 27.71, 16.29, 12.28, 12.74, 13.21, 13.65, 16.57, 18.14, 14.55, 14.65, 14.66, 14.61, 14.50, 14.39, 14.40, 14.47, 14.62, 14.72, 14.55, 14.4, 14.58, 14.88, 15.51, 15.47, 13.20, 10.57, 9.18, 8.25, 7.57, 7.03,
            6.35, 5.72, 5.25, 4.80, 4.29, 3.80, 3.43, 3.12, 2.86, 2.64, 2.43, 2.26, 2.14, 2.02, 1.83, 1.61, 1.38, 1.12, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F10 Philips TL85 - 5000K
        private static double[] FluoF10_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.11, 0.63, 0.62, 0.57, 1.48, 12.16, 2.12, 2.70, 3.74, 5.14, 6.75, 34.39, 14.86, 10.4, 10.76, 10.11, 9.27, 8.29, 7.29, 7.91, 16.64, 16.73, 10.44, 5.94, 3.34, 2.35, 1.88, 1.59, 1.47,
            1.80, 5.71, 40.98, 73.69, 33.61, 8.24, 3.38, 2.47, 4.86, 11.45, 14.79, 12.16, 8.97, 6.52, 8.81, 44.12, 34.55, 12.09, 12.15, 10.52, 4.43, 1.95, 2.19, 3.19, 2.77, 2.29, 2.00, 1.52, 1.35, 1.47, 1.79, 1.74, 1.02, 1.14,
            3.32, 4.49, 2.05, 0.49, 0.24, 0.21, 0.21, 0.24, 0.24, 0.21, 0.17, 0.21, 0.22, 0.17, 0.12, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F11 Philips TL84 4150K
        private static double[] FluoF11_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.91, 0.63, 0.46, 0.37, 1.29, 12.68, 1.59, 1.79, 2.46, 3.38, 4.49, 33.94, 12.13, 6.95, 7.19, 7.12, 6.72, 6.13, 5.46, 4.79, 5.66, 14.29, 14.96, 8.97, 4.72, 2.33, 1.47, 1.10, 0.89, 0.83, 1.18, 4.90, 39.59,
            72.84, 32.61, 7.52, 2.83, 1.96, 1.67, 4.43, 11.28, 14.76, 12.73, 9.74, 7.33, 9.72, 55.27, 42.58, 13.18, 13.16, 12.26, 5.11, 2.07, 2.34, 3.58, 3.01, 2.48, 2.14, 1.54, 1.33, 1.46, 1.94, 2.00, 1.20, 1.35, 4.10, 5.58,
            2.51, 0.57, 0.27, 0.23, 0.21, 0.24, 0.24, 0.20, 0.24, 0.32, 0.26, 0.16, 0.12, 0.09, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for fluo F12 Philips TL83 3000K
        private static double[] FluoF12_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.96, 0.64, 0.45, 0.33, 1.19, 12.48, 1.12, 0.94, 1.08, 1.37, 1.78, 29.05, 7.90, 2.65, 2.71, 2.65, 2.49, 2.33, 2.10, 1.91, 3.01, 10.83, 11.88, 6.88, 3.43, 1.49, 0.92, 0.71, 0.60, 0.63, 1.10, 4.56, 34.4, 65.40, 29.48,
            7.16, 3.08, 2.47, 2.27, 5.09, 11.96, 15.32, 14.27, 11.86, 9.28, 12.31, 68.53, 53.02, 14.67, 14.38, 14.71, 6.46, 2.57, 2.75, 4.18, 3.44, 2.81, 2.42, 1.64, 1.36, 1.49, 2.14, 2.34, 1.42, 1.61, 5.04, 6.98, 3.19, 0.71, 0.30, 0.26, 0.23, 0.28, 0.28, 0.21,
            0.17, 0.21, 0.19, 0.15, 0.10, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for HMI lamp studio "Osram" 4800K (for film, spectacle, studio...)
        private static double[] HMI_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 9.66, 11.45, 13.24, 14.93, 16.63, 17.90, 19.20, 20.12, 21.03, 23.84, 26.65, 26.38, 26.12, 26.52, 27.92, 31.15, 34.37, 34.98, 35.61, 35.71, 35.81, 34.90, 34.02, 34.06, 34.08, 34.68, 35.28, 34.72, 34.20, 33.63,
            33.05, 34.70, 36.35, 38.01, 39.48, 37.29, 35.10, 36.22, 37.28, 38.76, 40.24, 39.56, 38.90, 39.35, 39.79, 38.90, 38.01, 38.05, 38.10, 37.45, 36.64, 35.82, 35.00, 35.06, 33.13, 33.85, 34.55, 35.26, 35.77, 34.92,
            34.09, 33.40, 32.72, 32.08, 31.45, 26.83, 22.23, 21.50, 20.79, 21.41, 22.03, 11.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for GTI lamp : Graphiclite & ColorMatch for Photography 5000K
        private static double[] GTI_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 3.26, 4.71, 6.17, 12.71, 19.27, 20.53, 21.80, 19.15, 16.53, 28.25, 39.97, 48.52, 57.06, 43.66, 30.27, 30.22, 30.16, 31.48, 32.98, 34.01, 35.04, 35.83, 36.62, 37.12, 37.62, 37.99, 38.19, 38.29, 38.48,
            38.82, 39.16, 45.40, 51.63, 51.83, 62.04, 52.41, 42.80, 42.95, 43.09, 45.64, 48.20, 46.23, 44.27, 43.74, 43.22, 43.30, 43.41, 43.10, 42.78, 42.03, 41.29, 40.29, 39.29, 37.89, 36.58, 34.92, 33.27, 31.47, 29.68, 27.90,
            26.13, 24.55, 22.98, 21.42, 19.86, 18.40, 16.92, 14.46, 13.99, 12.36, 11.73, 5.86, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for JudgeIII Lamp D50
        private static double[] JudgeIII_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 4.08, 4.25, 4.43, 6.90, 9.40, 9.75, 10.11, 9.30, 8.54, 14.90, 21.16, 26.01, 30.83, 24.90, 19.00, 19.00, 19.00, 19.56, 20.13, 20.28, 20.44, 20.64, 20.85, 21.05, 21.24, 21.65, 22.11, 22.85, 23.58, 24.00, 24.43,
            27.75, 31.27, 33.90, 36.59, 30.90, 25.32, 25.05, 24.76, 26.03, 27.31, 25.90, 24.48, 23.85, 23.29, 23.10, 22.94, 23.24, 23.53, 24.02, 24.52, 23.80, 23.13, 24.51, 25.76, 27.90, 29.15, 24.70, 20.25, 16.60, 12.98, 11.63, 10.27, 9.30, 8.34,
            7.60, 6.91, 6.25, 5.67, 5.15, 4.68, 2.34, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data for Solux lamp : 3500K
        private static double[] Solux3500_spect = {
            0.5268, 0.93, 1.3278, 1.51, 1.6987, 2.65, 3.6100, 3.80, 3.9927, 6.08, 8.1680, 11.02, 13.863, 15.66, 17.4600, 18.78, 20.130, 21.43, 22.749, 24.02, 25.290, 27.40, 29.504, 31.77, 34.031, 36.35, 38.672, 40.55, 42.426, 44.15, 45.865, 47.37, 48.879,
            49.71, 50.531, 51.2, 51.872, 51.9, 51.928, 52.97, 54.015, 55.93, 57.846, 60.25, 62.650, 64.36, 66.065, 66.72, 67.369, 68.81, 70.260, 71.37, 72.487, 72.53, 72.578, 72.51, 72.447, 72.46, 72.471,
            72.76, 73.047, 74.25, 75.449, 76.5, 77.543, 78.79, 80.040, 80.72, 81.394, 82.12, 82.840, 83.23, 83.614, 83.36, 83.100, 82.36, 81.615, 80.11, 78.606, 75.91, 73.221, 69.61, 66.006, 62.43, 58.844, 56.07, 53.292,
            51.07, 48.839, 46.93, 45.013, 43.54, 42.070, 40.61, 39.150, 37.79, 36.425
        };
        //spectral data for Solux lamp : 4100K
        private static double[] Solux4100_spect = {
            0.5717, 0.70, 0.8286, 1.16, 1.522, 2.01, 2.384, 3.45, 4.57, 6.46, 8.4548, 11.31, 14.205, 16.10, 17.949, 19.51, 21.068, 22.60, 24.197, 25.37, 26.566, 28.15, 29.742, 30.90, 32.060, 33.26, 34.481, 34.80, 35.130, 35.42, 35.697, 36.20, 36.763,
            37.90, 39.004, 40.26, 41.494, 43.10, 44.690, 45.80, 46.900, 47.45, 47.885, 47.75, 47.635, 47.00, 46.410, 46.22, 46.058, 46.70, 47.344, 48.65, 50.005, 51.02, 52.045, 53.55, 55.075, 55.98, 56.823,
            56.85, 56.884, 56.15, 55.523, 54.60, 53.732, 52.55, 51.425, 50.30, 49.1830, 48.76, 48.273, 48.22, 48.169, 49.92, 49.915, 51.90, 53.099, 54.95, 56.852, 58.45, 60.090, 61.67, 63.2530, 63.55, 63.834, 63.55, 63.468,
            62.40, 61.373, 59.75, 58.1810, 56.25, 54.395, 51.90, 49.496, 47.05, 44.620
        };
        //spectral data for Solux lamp : near Daylight (for example  "Musée d'Orsay") - 4700K
        private static double[] Solux4700_spect = {
            0.4590, 0.83, 1.2011, 1.53, 1.8647, 2.15, 2.5338, 3.06, 3.5809, 3.99, 4.4137, 4.82, 5.2228, 5.63, 6.0387, 6.53, 6.9944, 7.55, 8.0266, 8.475, 8.9276, 8.90, 9.7840, 10.20, 10.6390, 11.00, 11.3600, 11.75, 12.1340, 12.36, 12.5880, 12.74, 12.8790,
            13.07, 13.2560, 13.38, 13.5220, 13.41, 13.3070, 13.35, 13.3990, 13.37, 13.3420, 13.39, 13.4220, 13.65, 13.2710, 13.25, 13.2330, 13.12, 13.0110, 12.93, 12.8470, 12.805, 12.7630, 12.66, 12.5760, 12.563, 12.5490,
            12.59, 12.6330, 12.617, 12.6010, 12.616, 12.6310, 12.6275, 12.6240, 12.70, 12.7710, 12.776, 12.7810, 12.786, 12.7950, 12.74, 12.6850, 12.64, 12.5950, 12.55, 12.5420, 12.43, 12.3180, 12.07, 11.8340, 11.72, 11.6190, 11.55, 11.5020,
            11.32, 11.1510, 11.05, 10.9530, 10.80, 10.6550, 10.495, 10.4390, 10.31, 10.1790
        };
        //spectral data for Solux lamp : near Daylight 4400K - test National Gallery
        private static double[] NG_Solux4700_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 139, 152, 170, 185, 202, 223, 240, 257, 270, 282, 293, 305, 317, 329, 342, 355, 367, 378, 387, 395, 401, 405, 408, 411, 414, 415, 416, 415, 414, 414, 416, 419, 423, 427, 432, 437, 442, 447, 452,
            456, 461, 467, 475, 483, 488, 490, 491, 490, 487, 485, 481, 477, 472, 466, 461, 455, 449, 442, 434, 427, 419, 411, 403, 395, 386, 377, 367, 359, 351, 343, 335, 327, 322, 316, 312, 306, 305, 301, 299, 299, 298,
            0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.0
        };
        //spectral data for LED LSI Lumelex 2040 - test National Gallery
        private static double[] NG_LEDLSI2040_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.5, 1.2, 0.5, 0.7, 0.6, 1.6, 1.7, 7.0, 16.6, 35.5, 64, 106, 162.5, 230.5, 272.2, 249, 213.4, 214, 227.6, 231.9, 233, 235.2, 241.4, 253.7, 270.3, 288.5, 306.2, 322.3, 337.6, 352.5, 367.2, 381.7, 395.9, 409.6, 416.2, 423.2, 429.7, 435.8, 442.8,
            451.7, 464.2, 480.3, 501, 526.3, 555.9, 587.5, 625.4, 655.1, 681.7, 705.3, 721.5, 728.5, 729, 719.8, 702.5, 676.7, 646.2, 611.5, 571.7, 530.3, 488.3, 445.9, 404, 365.2, 326.8, 290.8, 257.6, 226.9, 199.8, 175.2, 154.2, 133.8, 116.4, 101.5, 88.5, 76.6, 67.3, 57.9, 50.7, 44.2, 38.2,
            0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.0
        };
        //spectral data for LED CRS SP12 WWMR16 - test National Gallery
        private static double[] NG_CRSSP12WWMR16_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.14, 0.33, 1.31, 3.34, 7.9, 17.4, 36.5, 72.6, 145.4, 260.5, 359.2, 365.3, 303.1, 256.1, 221.7, 193.6, 185.8, 191.4, 207.3, 232.8, 257.5, 285.1, 310.5, 333.4, 351.5, 368.8, 383.7, 398.8, 411.6, 424.7, 435.6, 447.9, 459.7, 471.7,
            484.6, 497.9, 512.3, 531.1, 548.9, 567.9, 587.5, 608.6, 625.3, 640.1, 648.6, 654.0, 654.3, 647.2, 633.9, 616.1, 590.5, 561.5, 526.5, 494.8, 457.9, 420.8, 382.4, 347.3, 309.9, 280.5, 249.2, 220.0, 194.9, 170.8, 149.1, 130.0, 112.3, 97.5, 84.9, 73.2, 63.1, 54.1, 45.6, 39.0, 32.6, 27.4,
            0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.0
        };
        //Data for flash :
        // in theory, should be the spectral data of each owner flash (Nikon, Canon, Sony ...) or studio flash (Profoto. ..)
        // but: 1) I did not, 2) the data vary depending on the power used ... so by default, although this is not true, I chose the values "Daylight" for temp...
        // CRI for flash near of 95 - 97 !!
        //spectral data for Flash daylight 5500K (Leica...)
        private static double[] Flash5500_spect = {
            27.77, 29.17, 30.58, 32.02, 33.47, 33.00, 32.53, 35.28, 38.04, 49.46, 60.88, 64.68, 68.48, 69.99, 71.51, 69.68, 67.85, 76.70, 85.54, 91.74, 97.93, 99.17, 100.41, 100.14, 99.86, 101.28, 102.70, 100.37, 98.04, 99.35, 100.65,
            100.66, 100.67, 100.32, 99.97, 102.08, 104.20, 103.15, 102.09, 102.53, 102.96, 101.48, 100.00, 98.61, 97.22, 97.49, 97.76, 94.60, 91.44, 92.94, 94.44, 94.80, 95.16, 94.70, 94.25, 92.36, 90.48, 91.42, 92.36, 90.63,
            88.89, 89.62, 90.36, 92.18, 94.00, 92.00, 90.00, 84.86, 79.72, 81.30, 82.88, 83.88, 84.89, 77.58, 70.27, 74.80, 82.19, 85.03, 78.47, 71.91, 62.37, 52.82, 64.39, 75.96, 73.91, 71.85, 72.41, 72.97, 70.17, 67.38, 63.07,
            58.75, 61.89, 65.02, 66.68, 68.34
        };
        //spectral data for Flash daylight 6000K (Canon, Pentax, Olympus,...Standard)
        private static double[] Flash6000_spect = {
            36.00, 37.18, 38.36, 40.36, 42.35, 41.77, 41.19, 43.79, 46.40, 59.24, 72.09, 76.15, 80.22, 81.47, 82.71, 80.12, 77.52, 86.54, 95.56, 101.70, 107.85, 108.66, 109.46, 108.57, 107.68, 108.65, 109.61, 106.63, 103.65, 104.42,
            105.19, 104.79, 104.39, 103.45, 102.51, 104.28, 106.05, 104.68, 103.31, 103.42, 103.54, 101.77, 100.00, 98.38, 96.75, 96.74, 96.72, 93.30, 89.89, 90.92, 91.95, 91.99, 92.03, 91.30, 90.57, 88.51, 86.45, 86.96,
            87.47, 85.66, 83.85, 84.21, 84.57, 85.95, 87.32, 85.31, 83.30, 78.66, 74.03, 75.24, 76.45, 77.68, 78.91, 72.13, 65.35, 69.67, 73.98, 76.68, 79.39, 73.29, 67.19, 58.19, 49.19, 59.98, 70.77, 68.91, 67.05, 67.55, 68.05,
            65.47, 62.88, 58.89, 54.90, 57.81, 60.72, 62.25, 63.78
        };
        //spectral data for Flash daylight 6500K (Nikon, Minolta, Panasonic, Sony...)
        private static double[] Flash6500_spect = {
            44.86, 45.72, 46.59, 49.16, 51.74, 50.83, 49.92, 52.26, 54.60, 68.65, 82.69, 87.06, 91.42, 92.39, 93.37, 90.00, 86.63, 95.72, 104.81, 110.88, 116.96, 117.36, 117.76, 116.29, 114.82, 115.35, 115.89, 112.33, 108.78, 109.06,
            109.33, 108.56, 107.78, 106.28, 104.78, 106.23, 107.68, 106.04, 104.40, 104.22, 104.04, 102.02, 100.00, 98.17, 96.34, 96.06, 95.79, 92.24, 88.69, 89.35, 90.02, 89.81, 89.61, 88.66, 87.71, 85.51, 83.30, 83.51, 83.72,
            81.88, 80.05, 80.14, 80.24, 81.27, 82.30, 80.31, 78.31, 74.03, 69.74, 70.69, 71.63, 73.00, 74.37, 68.00, 61.62, 65.76, 69.91, 72.51, 75.11, 69.36, 63.61, 55.02, 46.43, 56.63, 66.83, 65.11, 63.40, 63.86, 64.32, 61.90, 59.47,
            55.72, 51.97, 54.72, 57.46, 58.89, 60.33
        };
        //
        private static Dictionary<string, double[]> spectMap = new Dictionary<string, double[]>()
        {
           {"Daylight", Daylight5300_spect},
           {"Cloudy", Cloudy6200_spect},
           {"Shade", Shade7600_spect},
           {"Tungsten", A2856_spect},
           {"Fluo F1", FluoF1_spect},
           {"Fluo F2", FluoF2_spect},
           {"Fluo F3", FluoF3_spect},
           {"Fluo F4", FluoF4_spect},
           {"Fluo F5", FluoF5_spect},
           {"Fluo F6", FluoF6_spect},
           {"Fluo F7", FluoF7_spect},
           {"Fluo F8", FluoF8_spect},
           {"Fluo F9", FluoF9_spect},
           {"Fluo F10", FluoF10_spect},
           {"Fluo F11", FluoF11_spect},
           {"Fluo F12", FluoF12_spect},
           {"HMI Lamp", HMI_spect},
           {"GTI Lamp", GTI_spect},
           {"JudgeIII Lamp", JudgeIII_spect},
           {"Solux Lamp 3500K", Solux3500_spect},
           {"Solux Lamp 4100K", Solux4100_spect},
           {"Solux Lamp 4700K", Solux4700_spect},
           {"NG Solux Lamp 4700K", NG_Solux4700_spect},
           {"LED LSI Lumelex 2040", NG_LEDLSI2040_spect},
           {"LED CRS SP12 WWMR16", NG_CRSSP12WWMR16_spect},
           {"Flash 5500K", Flash5500_spect},
           {"Flash 6000K", Flash6000_spect},
           {"Flash 6500K", Flash6500_spect}
        };
        private static double[][] sRGBd65_xyz = {
            new double[]{ 3.2404542, -1.5371385, -0.4985314},
            new double[]{ -0.9692660,  1.8760108,  0.0415560},
            new double[]{0.0556434, -0.2040259,  1.0572252}
        };

        // Data for Color ==> CRI (Color Rendering Index and Palette
        // actually 20 color that must be good enough for CRI
        // I think 40  color for palette (Skin, Sky, gray)
        //spectral data Colorchecker24 : Red C3
        private static double[] ColorchechredC3_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0478, 0.0476, 0.0474, 0.0472, 0.0470, 0.0466, 0.0461, 0.0460, 0.0459, 0.0456, 0.0453, 0.0451, 0.0449, 0.0448, 0.0447, 0.0446, 0.0445, 0.0441, 0.0437, 0.0432, 0.0427, 0.0424, 0.0421, 0.0419,
            0.0417, 0.0415, 0.0412, 0.0412, 0.0412, 0.0413, 0.0413, 0.0415, 0.0416, 0.0421, 0.0426, 0.0436, 0.0446, 0.0469, 0.0491, 0.0549, 0.0607, 0.0773, 0.0939, 0.1376, 0.1812, 0.2568, 0.3323, 0.4070, 0.4816, 0.5308,
            0.5800, 0.6059, 0.6317, 0.6447, 0.6577, 0.6653, 0.6728, 0.6761, 0.6793, 0.6820, 0.6847, 0.6878, 0.6909, 0.6945, 0.6980, 0.7013, 0.7046, 0.7065, 0.7084, 0.7107, 0.7129, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Orange A2
        private static double[] ColorchechOraA2_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0520, 0.0530, 0.0540, 0.0535, 0.0530, 0.0532, 0.0534, 0.0532, 0.0529, 0.0529, 0.0528, 0.0530, 0.0532, 0.0537, 0.0542, 0.0550, 0.0557, 0.0565, 0.0573, 0.0585, 0.0597, 0.0613, 0.0628, 0.0656, 0.0683, 0.0793,
            0.0902, 0.1085, 0.1268, 0.1414, 0.1559, 0.1645, 0.1730, 0.1837, 0.1944, 0.2184, 0.2424, 0.2877, 0.3329, 0.3923, 0.4517, 0.5021, 0.5525, 0.5739, 0.5952, 0.5967, 0.5982, 0.5962, 0.5942, 0.5932, 0.5922, 0.5927,
            0.5932, 0.5938, 0.5944, 0.5988, 0.6032, 0.6105, 0.6178, 0.6284, 0.6389, 0.6498, 0.6607, 0.6699, 0.6791, 0.6839, 0.6886, 0.6879, 0.6871, 0.6886, 0.6901, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 :yellow D3
        private static double[] ColorchechYelD3_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0476, 0.0482, 0.0488, 0.0492, 0.0496, 0.0498, 0.0499, 0.0498, 0.0496, 0.0501, 0.0506, 0.0516, 0.0526, 0.0547, 0.0567, 0.0610, 0.0652, 0.0733, 0.0813, 0.0962, 0.1110, 0.1333, 0.1556, 0.1884, 0.2211,
            0.2782, 0.3353, 0.4023, 0.4692, 0.5198, 0.5703, 0.5976, 0.6249, 0.6400, 0.6551, 0.6667, 0.6783, 0.6901, 0.7018, 0.7095, 0.7171, 0.7231, 0.7290, 0.7329, 0.7367, 0.7395, 0.7423, 0.7447, 0.7471, 0.7490, 0.7508,
            0.7533, 0.7558, 0.7578, 0.7598, 0.7623, 0.7647, 0.7654, 0.7661, 0.7677, 0.7693, 0.7720, 0.7746, 0.7780, 0.7814, 0.7845, 0.7876, 0.7889, 0.7902, 0.7920, 0.7938,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Green E2
        private static double[] ColorchechGreE2_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0560, 0.0583, 0.0605, 0.0626, 0.0646, 0.0650, 0.0653, 0.0657, 0.0661, 0.0669, 0.0676, 0.0692, 0.0708, 0.0737, 0.0765, 0.0816, 0.0867, 0.0956, 0.1044, 0.1194, 0.1344, 0.1581, 0.1818, 0.2196, 0.2574, 0.3166, 0.3757,
            0.4297, 0.4837, 0.5142, 0.5446, 0.5541, 0.5636, 0.5608, 0.5579, 0.5480, 0.5381, 0.5258, 0.5135, 0.4959, 0.4783, 0.4570, 0.4356, 0.4124, 0.3891, 0.3710, 0.3529, 0.3425, 0.3320, 0.3266, 0.3211, 0.3180, 0.3149,
            0.3129, 0.3108, 0.3123, 0.3137, 0.3193, 0.3248, 0.3335, 0.3422, 0.3518, 0.3613, 0.3693, 0.3772, 0.3810, 0.3847, 0.3838, 0.3829, 0.3838, 0.3847, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //const double ColorTemp::ColorGreenM25_spect[97] = {
        //    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
        //    0.0758, 0.0614, 0.0662, 0.0591, 0.0648, 0.0633, 0.0671, 0.0613, 0.0621, 0.0610, 0.0680, 0.0690, 0.0784, 0.0830, 0.0920, 0.1070, 0.1231, 0.1423, 0.1607, 0.1731, 0.1816, 0.1911, 0.1951, 0.1986, 0.1915, 0.1889,
        //    0.1758, 0.1673, 0.1606, 0.1505, 0.1384, 0.1317, 0.1230, 0.1149, 0.1081, 0.0992, 0.0882, 0.0785, 0.0709, 0.0629, 0.0550, 0.0502, 0.0486, 0.0474, 0.0445, 0.0434, 0.0429, 0.0423, 0.0411, 0.0405, 0.0397, 0.0387, 0.0399, 0.0398, 0.0398, 0.0407, 0.0408, 0.0426, 0.0445, 0.0443, 0.0468,
        //    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        //};
        ////0 658 45 0 0 131 98 84 123 104 131 112 121 121 139 128 148 199 296 389 476 689 945 1132 1326 1490 1674 1741 1775 1868 1914 1928 1961 1972 1992 2045 2064 2053 2048 2072 2086 2081 2069 2056 2073 2096 2114 2067 2089 2100 2061 2019 1983 1971 1961 2016 1956 1946 1922 1983 1991
        //const double ColorTemp::ColorYellowkeltano_spect[97] = {
        //    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
        //    0.0, 0.0658, 0.0045,  0.0,  0.0, 0.0131,  0.0098,  0.0084, 0.0123, 0.0104, 0.0131, 0.0112, 0.0121, 0.0121, 0.0139,
        //    0.0128, 0.0148, 0.0199, 0.0296, 0.0389, 0.0476, 0.0689, 0.0945, 0.1132, 0.1326, 0.1490,  0.1674, 0.1741, 0.1775, 0.1868,
        //    0.1914, 0.1928, 0.1961, 0.1972, 0.1992, 0.2045, 0.2064, 0.2053, 0.2048, 0.2072, 0.2086, 0.2081, 0.2069, 0.2056,  0.2073,
        //    0.2096, 0.2114, 0.2067, 0.2089, 0.2100, 0.2061, 0.2019, 0.1983, 0.1971, 0.1961, 0.2016, 0.1956, 0.1946, 0.1922, 0.1983, 0.1991,
        //    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        //};
        //spectral data Colorchecker24 : Green B3
        private static double[] ColorchechGreB3_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0531, 0.0545, 0.0559, 0.0563, 0.0566, 0.0571, 0.0576, 0.0576, 0.0575, 0.0581, 0.0586, 0.0596, 0.0606, 0.0629, 0.0652, 0.0699, 0.0745, 0.0839, 0.0932, 0.1101, 0.1270, 0.1521, 0.1771, 0.2098, 0.2424,
            0.2789, 0.3154, 0.3312, 0.3470, 0.3431, 0.3392, 0.3303, 0.3213, 0.3089, 0.2964, 0.2788, 0.2612, 0.2442, 0.2271, 0.2117, 0.1962, 0.1815, 0.1667, 0.1527, 0.1386, 0.1284, 0.1182, 0.1124, 0.1066, 0.1035, 0.1003,
            0.0987, 0.0971, 0.0961, 0.0950, 0.0950, 0.0950, 0.0962, 0.0973, 0.0994, 0.1014, 0.1045, 0.1075, 0.1106, 0.1137, 0.1157, 0.1176, 0.1175, 0.1173, 0.1173, 0.1173,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Cyan F3
        private static double[] ColorchechCyaF3_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0813, 0.1048, 0.1282, 0.1611, 0.1940, 0.2198, 0.2456, 0.2575, 0.2693, 0.2807, 0.2921, 0.3079, 0.3237, 0.3424, 0.3611, 0.3820, 0.4029, 0.4234, 0.4439, 0.4547, 0.4654, 0.4638, 0.4621, 0.4482, 0.4342, 0.4119, 0.3895,
            0.3656, 0.3417, 0.3160, 0.2903, 0.2654, 0.2404, 0.2167, 0.1929, 0.1720, 0.1510, 0.1368, 0.1226, 0.1138, 0.1049, 0.0993, 0.0936, 0.0890, 0.0844, 0.0810, 0.0776, 0.0759, 0.0742, 0.0733, 0.0724, 0.0723, 0.0722, 0.0727,
            0.0732, 0.0745, 0.0757, 0.0763, 0.0768, 0.0764, 0.0759, 0.0748, 0.0736, 0.0723, 0.0710, 0.0703, 0.0696, 0.0707, 0.0718, 0.0756, 0.0793, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Purple D2
        private static double[] ColorchechPurD2_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0854, 0.1047, 0.1240, 0.1468, 0.1696, 0.1826, 0.1955, 0.1963, 0.1970, 0.1910, 0.1849, 0.1750, 0.1651, 0.1541, 0.1430, 0.1322, 0.1213, 0.1117, 0.1020, 0.0944, 0.0868, 0.0809, 0.0750, 0.0703, 0.0655,
            0.0627, 0.0599, 0.0583, 0.0567, 0.0550, 0.0533, 0.0525, 0.0517, 0.0518, 0.0519, 0.0523, 0.0526, 0.0525, 0.0524, 0.0520, 0.0516, 0.0523, 0.0529, 0.0560, 0.0591, 0.0662, 0.0732, 0.0828, 0.0924, 0.1021,
            0.1117, 0.1222, 0.1327, 0.1469, 0.1610, 0.1796, 0.1981, 0.2173, 0.2365, 0.2532, 0.2698, 0.2826, 0.2953, 0.3022, 0.3090, 0.3126, 0.3161, 0.3238, 0.3314, 0.3504, 0.3694, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Magenta E3
        private static double[] ColorchechMagE3_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.1112, 0.1438, 0.1763, 0.2294, 0.2824, 0.3188, 0.3552, 0.3623, 0.3693, 0.3653, 0.3612, 0.3510, 0.3407, 0.3269, 0.3130, 0.2981, 0.2832, 0.2686, 0.2539, 0.2385, 0.2230, 0.2083, 0.1935, 0.1818, 0.1700, 0.1600, 0.1499,
            0.1394, 0.1288, 0.1188, 0.1088, 0.1051, 0.1014, 0.1026, 0.1038, 0.1041, 0.1043, 0.1064, 0.1085, 0.1225, 0.1364, 0.1701, 0.2037, 0.2532, 0.3027, 0.3587, 0.4147, 0.4683, 0.5219, 0.5672, 0.6124, 0.6455, 0.6785, 0.7009,
            0.7232, 0.7391, 0.7550, 0.7629, 0.7707, 0.7737, 0.7766, 0.7778, 0.7790, 0.7803, 0.7815, 0.7835, 0.7854, 0.7896, 0.7937, 0.8026, 0.8114, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Skin A1
        //use also for palette WB
        private static double[] ColorchechSkiA138_13_14_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0479, 0.051, 0.0553, 0.058, 0.0610, 0.062, 0.0626, 0.0622, 0.0619, 0.0617, 0.0616, 0.0615, 0.0614, 0.0614, 0.0615, 0.0617, 0.0618, 0.0618, 0.0619, 0.0618, 0.0618, 0.062, 0.0622, 0.063, 0.0638, 0.066, 0.0696,
            0.073, 0.0767, 0.078, 0.0801, 0.0807, 0.0817, 0.0831, 0.0845, 0.0870, 0.0902, 0.0955, 0.1017, 0.1096, 0.1175, 0.1250, 0.1336, 0.1385, 0.1435, 0.1455, 0.1479, 0.1490, 0.1514, 0.1547, 0.1580, 0.1625, 0.1675,
            0.173, 0.1772, 0.181, 0.1842, 0.1846, 0.1853, 0.1831, 0.1811, 0.1788, 0.1765, 0.1769, 0.1773, 0.181, 0.1834, 0.1874, 0.1914, 0.1965, 0.2018, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Gray C4 L=67
        //use also for palette WB
        private static double[] ColorchechGraC4_67_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.1074, 0.1380, 0.1704, 0.22, 0.2705, 0.305, 0.3409, 0.35, 0.3601, 0.3628, 0.3655, 0.3675, 0.3698, 0.371, 0.3724, 0.373, 0.3733, 0.3725, 0.3715, 0.3705, 0.3692,
            0.369, 0.3689, 0.368, 0.3673, 0.3678, 0.3684, 0.37, 0.3711, 0.3712, 0.3714, 0.3714, 0.3714, 0.371, 0.3707, 0.37, 0.3694, 0.3697, 0.3703, 0.3697, 0.3692, 0.3688, 0.3685, 0.3675, 0.3669, 0.3657, 0.3647, 0.3635, 0.3625, 0.361,
            0.3596, 0.3585, 0.3579, 0.357, 0.3560, 0.3555, 0.3548, 0.3535, 0.3526, 0.3513, 0.3500, 0.349, 0.3475, 0.3467, 0.3460, 0.3452, 0.3444, 0.3431, 0.3421, 0.3411, 0.3403, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : Skin B1
        //use also for palette WB
        private static double[] ColorchechSkiB166_18_18_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0962, 0.114, 0.1328, 0.152, 0.1706, 0.1755, 0.1877, 0.189, 0.1903, 0.1913, 0.1923, 0.1946, 0.1971, 0.2015, 0.2064, 0.215, 0.2245, 0.239, 0.2535, 0.273, 0.2922, 0.31, 0.3274, 0.337, 0.3473,
            0.348, 0.3489, 0.335, 0.3224, 0.303, 0.2835, 0.275, 0.2671, 0.27, 0.2728, 0.2735, 0.2741, 0.279, 0.2836, 0.308, 0.3334, 0.375, 0.4183, 0.457, 0.4950, 0.516, 0.5409, 0.5515, 0.5625, 0.568, 0.5731, 0.5786,
            0.5820, 0.586, 0.5902, 0.596, 0.6025, 0.611, 0.6174, 0.627, 0.6375, 0.65, 0.6626, 0.677, 0.6910, 0.704, 0.7171, 0.723, 0.7339, 0.741, 0.7475,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorchecker24 : blue sky C1
        //use also for palette WB
        private static double[] ColorchechBluC150_m5_m22_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.1053, 0.134, 0.1633, 0.2075, 0.2518, 0.283, 0.3163, 0.324, 0.3325, 0.334, 0.3355, 0.3352, 0.3349, 0.332, 0.3294, 0.325, 0.3199, 0.3127, 0.3055, 0.2955, 0.2863, 0.28, 0.2737, 0.267, 0.2612, 0.249, 0.2378, 0.228, 0.2199,
            0.218, 0.2173, 0.2146, 0.2118, 0.20, 0.1884, 0.178, 0.1682, 0.166, 0.1639, 0.162, 0.1613, 0.158, 0.1550, 0.1504, 0.1458, 0.1415, 0.1375, 0.135, 0.1327, 0.1316, 0.1305, 0.1304, 0.1302, 0.131, 0.1322, 0.1342, 0.1362,
            0.1367, 0.1372, 0.1356, 0.1340, 0.1311, 0.1288, 0.1253, 0.1227, 0.1205, 0.1187, 0.1195, 0.1205, 0.1255, 0.1303, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data ColorcheckerDC : blue sky N8
        //use also for palette WB
        private static double[] ColorchechDCBluN881_m7_m14_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.1371, 0.17, 0.2029, 0.291, 0.3790, 0.495, 0.6100, 0.67, 0.7249, 0.737, 0.7501, 0.7545, 0.7597, 0.764, 0.7677, 0.7685, 0.7693, 0.7677, 0.7662, 0.763, 0.7593, 0.753, 0.7471, 0.737, 0.7289, 0.718, 0.7077, 0.705, 0.6819, 0.666, 0.6515, 0.636, 0.6244,
            0.61, 0.5948, 0.577, 0.5581, 0.544, 0.5293, 0.522, 0.5147, 0.512, 0.5091, 0.506, 0.5029, 0.499, 0.4950, 0.494, 0.4931, 0.497, 0.5007, 0.508, 0.5176, 0.527, 0.5359, 0.542, 0.5487, 0.549, 0.5494, 0.544,
            0.5375, 0.531, 0.5244, 0.522, 0.5207, 0.524, 0.5264, 0.532, 0.5369, 0.542, 0.5505, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data ColorcheckerSG : Skin F7
        //use also for palette WB
        private static double[] ColorchechSGSkiF763_14_26_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0508, 0.064, 0.0776, 0.903, 0.1099, 0.1128, 0.1256, 0.128, 0.1307, 0.133, 0.1357, 0.139, 0.1425, 0.148, 0.1523, 0.159, 0.1669, 0.177, 0.1871, 0.20, 0.2118, 0.2235, 0.2355, 0.2445, 0.2537, 0.259, 0.2655, 0.268,
            0.2700, 0.2708, 0.2716, 0.2743, 0.2770, 0.2803, 0.2827, 0.283, 0.2832, 0.283, 0.2828, 0.295, 0.3079, 0.344, 0.3803, 0.4105, 0.4409, 0.455, 0.4694, 0.477, 0.4851, 0.4896, 0.4962, 0.501, 0.5066, 0.511, 0.5160, 0.521,
            0.5256, 0.529, 0.5318, 0.535, 0.5383, 0.541, 0.5451, 0.549, 0.5524, 0.556, 0.5597, 0.562, 0.5650, 0.568, 0.5709, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data ColorcheckerSG : Skin K2 85 11 17
        //use also for palette WB
        private static double[] ColorchechSGSkiK285_11_17_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.1122, 0.149, 0.1866, 0.259, 0.3318, 0.393, 0.4547, 0.469, 0.4846, 0.4845, 0.4844, 0.4838, 0.4834, 0.4837, 0.4840, 0.4847, 0.4854, 0.4852, 0.4849, 0.4842, 0.4835, 0.4832, 0.4828, 0.485,
            0.4874, 0.501, 0.5150, 0.536, 0.5572, 0.5685, 0.5798, 0.586, 0.5932, 0.5987, 0.6142, 0.6342, 0.6541, 0.683, 0.7119, 0.734, 0.7571, 0.769, 0.7829, 0.788, 0.7932, 0.795, 0.7968, 0.7973,
            0.7977, 0.7974, 0.7969, 0.797, 0.7972, 0.7973, 0.7975, 0.7983, 0.7990, 0.7978, 0.7965, 0.7957, 0.7949, 0.7944, 0.7940, 0.794, 0.7941, 0.7943, 0.7946, 0.7938, 0.7930, 0.7929, 0.7928,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorcheck24 : White A4 L=96
        //use also for palette WB
        private static double[] ColorchechWhiA496_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.1267, 0.172, 0.2179, 0.317, 0.4164, 0.505, 0.6780, 0.758, 0.8397, 0.865, 0.8911, 0.897, 0.9035, 0.9062, 0.9092, 0.9124, 0.9154, 0.9167, 0.9180, 0.9187, 0.9194, 0.92, 0.9225, 0.9217, 0.9209, 0.921,
            0.9212, 0.9227, 0.9242, 0.9235, 0.9227, 0.9232, 0.9238, 0.9243, 0.9248, 0.9237, 0.9227, 0.9239, 0.9252, 0.924, 0.9233, 0.9238, 0.9242, 0.924, 0.9239, 0.9239, 0.9239, 0.924, 0.9242, 0.9239,
            0.9237, 0.925, 0.9264, 0.9276, 0.9288, 0.9298, 0.9308, 0.9296, 0.9284, 0.928, 0.9276, 0.928, 0.9284, 0.9294, 0.9304, 0.9316, 0.9328, 0.9328, 0.9328, 0.9337, 0.9345,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data Colorcheck24 : foliage Green D1
        private static double[] ColorchechGreD1_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0477, 0.0492, 0.0507, 0.0517, 0.0527, 0.0532, 0.0537, 0.054, 0.0544, 0.0554, 0.0563, 0.0573, 0.0584, 0.0592, 0.0601, 0.0607, 0.0611, 0.0613, 0.0619, 0.626, 0.0634, 0.0646, 0.0659, 0.069,
            0.0721, 0.0837, 0.0958, 0.117, 0.1386, 0.156, 0.1748, 0.1802, 0.1855, 0.1795, 0.1742, 0.1636, 0.1529, 0.144, 0.1351, 0.13, 0.1239, 0.1202, 0.1171, 0.1138, 0.1106, 0.108, 0.1048, 0.1035,
            0.1022, 0.1025, 0.1030, 0.1041, 0.1052, 0.106, 0.1068, 0.107, 0.1073, 0.1066, 0.1060, 0.1047, 0.1035, 0.1028, 0.1021, 0.1029, 0.1034, 0.105, 0.1069, 0.1086, 0.1104, 0.1127, 0.1150,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };

        //spectral data ColorchecSG : black N3 L=6
        //use also for palette WB
        private static double[] ColorchechSGBlaN3_6_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.0066, 0.0069, 0.0071, 0.0072, 0.0074, 0.0073, 0.0072, 0.0073, 0.0074, 0.0074, 0.0074, 0.0074, 0.0074, 0.0073, 0.0073, 0.0073, 0.0073, 0.0072, 0.0072, 0.0072, 0.0072, 0.0071, 0.0071, 0.0071,
            0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0070, 0.0070, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0071, 0.0070,
            0.0070, 0.0070, 0.0070, 0.0069, 0.0069, 0.0069, 0.0068, 0.0068, 0.0068, 0.0068, 0.0068, 0.0068, 0.0067, 0.0067, 0.0067, 0.0067, 0.0066, 0.0066, 0.0066, 0.0066, 0.0066, 0.0066, 0.0066, 0.0067,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data 468 color : gray K14 L=44
        //use also for palette WB
        private static double[] JDC468_GraK14_44_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.04240, 0.0485, 0.05500, 0.0624, 0.06930, 0.084, 0.09820, 0.109, 0.12160, 0.127, 0.13300, 0.13490, 0.13690, 0.1379, 0.13890, 0.1396, 0.14060, 0.1407, 0.14080, 0.1423, 0.14380, 0.1488, 0.15370, 0.157, 0.16040,
            0.157, 0.15360, 0.1482, 0.14290, 0.1436, 0.14470, 0.1454, 0.14620, 0.137, 0.12870, 0.1205, 0.11250, 0.116, 0.11930, 0.1261, 0.13350, 0.1367, 0.13990, 0.139, 0.13810, 0.1371, 0.13610, 0.1372, 0.13820,
            0.1408, 0.14330, 0.1475, 0.15170, 0.1583, 0.16500, 0.172, 0.17940, 0.1836, 0.18780, 0.188, 0.18820, 0.186, 0.18430, 0.1801, 0.17620, 0.1741, 0.17210, 0.179, 0.18420, 0.1991, 0.21430,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };
        //spectral data 468 color : Blue H10 - Gamut > WidegamutRGB
        private static double[] JDC468_BluH10_spect = {
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
            0.01590, 0.028, 0.03970, 0.0697, 0.09970, 0.1526, 0.20550, 0.253, 0.30110, 0.3412, 0.38180, 0.423, 0.46610, 0.4683, 0.51030, 0.5005, 0.49950, 0.4785, 0.45810, 0.429, 0.39950, 0.374, 0.35010, 0.3135, 0.29630,
            0.2587, 0.22070, 0.182, 0.14450, 0.1125, 0.09060, 0.072, 0.04810, 0.033, 0.01740, 0.0113, 0.00520, 0.004, 0.00290, 0.0028, 0.00270, 0.0027, 0.00270, 0.0027, 0.00280, 0.0027, 0.00270, 0.0028, 0.00280,
            0.0029, 0.00300, 0.0029, 0.00290, 0.0029, 0.0029, 0.00290, 0.0029, 0.00290, 0.0029, 0.00290, 0.0029, 0.00290, 0.0029, 0.00290, 0.0029, 0.0031, 0.00320, 0.0035, 0.00380, 0.0047, 0.00560,
            0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
        };

        /// <summary>
        /// 反色
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat ReverseColorFunction(Mat src)
        {
            return (~src.CvtColor(ColorConversionCodes.BGRA2BGR)).ToMat().CvtColor(ColorConversionCodes.BGR2BGRA);
        }

        #region 直方图方法


        /// <summary>
        /// 相机调用方法
        /// </summary>
        /// <param name="src"> 待处理的图像 </param>
        /// <param name="methodType"> 0 原图， 1 最佳， 2 最大最小</param>
        /// <param name="gamma45"> 是否计算伽马0.45 </param>
        /// <returns></returns>
        public static Mat CalHistMethod(Mat src, int methodType, bool gamma45)
        {
            Mat[] mats = Cv2.Split(src);//一张图片，将panda拆分成3个图片装进mat
            bool isGray = true;
            /// <summary>
            /// 一个矩阵数组，用来接收直方图,记得全部初始化
            /// </summary>
            Mat[] oldHists = new Mat[] { new Mat(), new Mat(), new Mat() };

            Mat[] mats0 = new Mat[] { mats[0] };//panda的第一个通道，也就是B
            Mat[] mats1 = new Mat[] { mats[1] };//panda的第二个通道，也就是G
            Mat[] mats2 = new Mat[] { mats[2] };//panda的第三个通道，也就是R


            int[] channels0 = new int[] { 0 };//一个通道,初始化为通道0,这些东西可以共用设置一个就行
            int[] channels1 = new int[] { 0 };
            int[] channels2 = new int[] { 0 };
            int[] histsize = new int[] { 256 };//一个通道，初始化为256箱子
            Rangef[] range = new Rangef[1];//一个通道，范围
            range[0] = new Rangef(0.0F, 256.0F);
            Mat mask = new Mat();//不做掩码

            Cv2.CalcHist(mats0, channels0, mask, oldHists[0], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats1, channels1, mask, oldHists[1], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats2, channels2, mask, oldHists[2], 1, histsize, range);//对被拆分的图片单独进行计算

            for (int h = 0; h < oldHists[0].Rows; h++)
            {
                for (int j = oldHists.Length - 1; j >= 1; j--)
                {
                    if (oldHists[j].At<float>(h) != oldHists[0].At<float>(h))
                    {
                        isGray = false;
                        break;
                    }
                }
                if (!isGray)
                    break;
            }

            //if (methodType == 0)
            //{
            //计算对比度
            string label6_Text = "1.00";// (256.0 / (startIndex.Y - startIndex.X)).ToString("f2");
                                        //计算亮度
            string label5_Text = "-0.50";// ((0 - startIndex.X - startIndex.Y) / 510.0).ToString("f2");
            //}
            if (methodType == 1)
            {
                //100 为千分比输入值，需要确认
                OpenCvSharp.Point startIndex = getStartIndex(src, oldHists, 100/*50*//*(float)numericUpDown1.Value*/, isGray);
                //计算对比度
                label6_Text = (256.0 / (startIndex.Y - startIndex.X)).ToString("f2");
                //计算亮度
                label5_Text = ((0 - startIndex.X - startIndex.Y) / 510.0).ToString("f2");
            }
            else if (methodType == 2)
            {
                //100 为千分比输入值，需要确认
                OpenCvSharp.Point startIndex = getStartIndex(src, oldHists, 0/*50*//*(float)numericUpDown1.Value*/, isGray);
                //计算对比度
                label6_Text = (256.0 / (startIndex.Y - startIndex.X)).ToString("f2");
                //计算亮度
                label5_Text = ((0 - startIndex.X - startIndex.Y) / 510.0).ToString("f2");
            }

            return scrollMethod(src, label5_Text, label6_Text, gamma45 ? "0.45" : "1.00", isGray, oldHists);
            ////updateHistogramRect(true);
            //return null;
        }

        /// <summary>
        /// 伽马0.45
        /// </summary>
        public static Mat Gamma45ButtonMethod(Mat src)
        {
            Mat[] mats = Cv2.Split(src);//一张图片，将panda拆分成3个图片装进mat
            bool isGray = true;
            /// <summary>
            /// 一个矩阵数组，用来接收直方图,记得全部初始化
            /// </summary>
            Mat[] oldHists = new Mat[] { new Mat(), new Mat(), new Mat() };

            Mat[] mats0 = new Mat[] { mats[0] };//panda的第一个通道，也就是B
            Mat[] mats1 = new Mat[] { mats[1] };//panda的第二个通道，也就是G
            Mat[] mats2 = new Mat[] { mats[2] };//panda的第三个通道，也就是R

            int[] channels0 = new int[] { 0 };//一个通道,初始化为通道0,这些东西可以共用设置一个就行
            int[] channels1 = new int[] { 0 };
            int[] channels2 = new int[] { 0 };
            int[] histsize = new int[] { 256 };//一个通道，初始化为256箱子
            Rangef[] range = new Rangef[1];//一个通道，范围
            range[0] = new Rangef(0.0F, 256.0F);
            Mat mask = new Mat();//不做掩码

            Cv2.CalcHist(mats0, channels0, mask, oldHists[0], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats1, channels1, mask, oldHists[1], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats2, channels2, mask, oldHists[2], 1, histsize, range);//对被拆分的图片单独进行计算

            for (int h = 0; h < oldHists[0].Rows; h++)
            {
                for (int j = oldHists.Length - 1; j >= 1; j--)
                {
                    if (oldHists[j].At<float>(h) != oldHists[0].At<float>(h))
                    {
                        isGray = false;
                        break;
                    }
                }
                if (!isGray)
                    break;
            }
            //500 为千分比输入值，需要确认
            OpenCvSharp.Point startIndex = getStartIndex(src, oldHists, 0/*(float)numericUpDown1.Value*/, isGray);

            //计算对比度
            string label6_Text = "1.00";// (256.0 / (startIndex.Y - startIndex.X)).ToString("f2");
            int trackBar2_Value = Math.Min(999/*trackBar2.Maximum*/, (int)(double.Parse(label6_Text) * 100));
            //计算亮度
            string label5_Text = "-0.50";// ((0 - startIndex.X - startIndex.Y) / 510.0).ToString("f2");
            int trackBar1_Value = (int)(double.Parse(label5_Text) * 100);

            return scrollMethod(src, label5_Text, label6_Text, "0.45", isGray, oldHists);
        }

        /// <summary>
        /// 最大最小
        /// </summary>
        public static Mat MaxMinButtonMethod(Mat src)
        {
            Mat[] mats = Cv2.Split(src);//一张图片，将panda拆分成3个图片装进mat
            bool isGray = true;
            /// <summary>
            /// 一个矩阵数组，用来接收直方图,记得全部初始化
            /// </summary>
            Mat[] oldHists = new Mat[] { new Mat(), new Mat(), new Mat() };

            Mat[] mats0 = new Mat[] { mats[0] };//panda的第一个通道，也就是B
            Mat[] mats1 = new Mat[] { mats[1] };//panda的第二个通道，也就是G
            Mat[] mats2 = new Mat[] { mats[2] };//panda的第三个通道，也就是R

            int[] channels0 = new int[] { 0 };//一个通道,初始化为通道0,这些东西可以共用设置一个就行
            int[] channels1 = new int[] { 0 };
            int[] channels2 = new int[] { 0 };
            int[] histsize = new int[] { 256 };//一个通道，初始化为256箱子
            Rangef[] range = new Rangef[1];//一个通道，范围
            range[0] = new Rangef(0.0F, 256.0F);
            Mat mask = new Mat();//不做掩码

            Cv2.CalcHist(mats0, channels0, mask, oldHists[0], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats1, channels1, mask, oldHists[1], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats2, channels2, mask, oldHists[2], 1, histsize, range);//对被拆分的图片单独进行计算

            for (int h = 0; h < oldHists[0].Rows; h++)
            {
                for (int j = oldHists.Length - 1; j >= 1; j--)
                {
                    if (oldHists[j].At<float>(h) != oldHists[0].At<float>(h))
                    {
                        isGray = false;
                        break;
                    }
                }
                if (!isGray)
                    break;
            }
            //500 为千分比输入值，需要确认
            OpenCvSharp.Point startIndex = getStartIndex(src, oldHists, 0/*(float)numericUpDown1.Value*/, isGray);

            //计算对比度
            string label6_Text = (256.0 / (startIndex.Y - startIndex.X)).ToString("f2");
            int trackBar2_Value = Math.Min(999/*trackBar2.Maximum*/, (int)(double.Parse(label6_Text) * 100));
            //计算亮度
            string label5_Text = ((0 - startIndex.X - startIndex.Y) / 510.0).ToString("f2");
            int trackBar1_Value = (int)(double.Parse(label5_Text) * 100);

            return scrollMethod(src, label5_Text, label6_Text, "1.00"/*"0.45"*/, isGray, oldHists);
        }

        /// <summary>
        /// 最佳
        /// </summary>
        public static Mat BestButtonMethod(Mat src)
        {
            Mat[] mats = Cv2.Split(src);//一张图片，将panda拆分成3个图片装进mat
            bool isGray = true;
            /// <summary>
            /// 一个矩阵数组，用来接收直方图,记得全部初始化
            /// </summary>
            Mat[] oldHists = new Mat[] { new Mat(), new Mat(), new Mat() };

            Mat[] mats0 = new Mat[] { mats[0] };//panda的第一个通道，也就是B
            Mat[] mats1 = new Mat[] { mats[1] };//panda的第二个通道，也就是G
            Mat[] mats2 = new Mat[] { mats[2] };//panda的第三个通道，也就是R


            int[] channels0 = new int[] { 0 };//一个通道,初始化为通道0,这些东西可以共用设置一个就行
            int[] channels1 = new int[] { 0 };
            int[] channels2 = new int[] { 0 };
            int[] histsize = new int[] { 256 };//一个通道，初始化为256箱子
            Rangef[] range = new Rangef[1];//一个通道，范围
            range[0] = new Rangef(0.0F, 256.0F);
            Mat mask = new Mat();//不做掩码

            Cv2.CalcHist(mats0, channels0, mask, oldHists[0], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats1, channels1, mask, oldHists[1], 1, histsize, range);//对被拆分的图片单独进行计算
            Cv2.CalcHist(mats2, channels2, mask, oldHists[2], 1, histsize, range);//对被拆分的图片单独进行计算

            for (int h = 0; h < oldHists[0].Rows; h++)
            {
                for (int j = oldHists.Length - 1; j >= 1; j--)
                {
                    if (oldHists[j].At<float>(h) != oldHists[0].At<float>(h))
                    {
                        isGray = false;
                        break;
                    }
                }
                if (!isGray)
                    break;
            }
            //500 为千分比输入值，需要确认
            OpenCvSharp.Point startIndex = getStartIndex(src, oldHists, 100/*50*//*(float)numericUpDown1.Value*/, isGray);

            //计算对比度
            string label6_Text = (256.0 / (startIndex.Y - startIndex.X)).ToString("f2");
            int trackBar2_Value = Math.Min(999/*trackBar2.Maximum*/, (int)(double.Parse(label6_Text) * 100));
            //计算亮度
            string label5_Text = ((0 - startIndex.X - startIndex.Y) / 510.0).ToString("f2");
            int trackBar1_Value = (int)(double.Parse(label5_Text) * 100);

            return scrollMethod(src, label5_Text, label6_Text, "1.00"/*"0.45"*/, isGray, oldHists);
            ////updateHistogramRect(true);
            //return null;
        }

        /// <summary>
        /// 根据亮度、对比度、gamma对图片进行处理
        /// </summary>
        private static Mat scrollMethod(Mat src, string label5_Text, string label6_Text, string label7_Text, bool isGray, Mat[] oldHists)
        {
            Mat[] mats = Cv2.Split(src);//一张图片，将panda拆分成3个图片装进mat
            //根据亮度和对比度计算左右阈值
            int grayMin = (int)(0 - (256.0 / (double.Parse(label6_Text) == 0 ? 0.01 : double.Parse(label6_Text)) + double.Parse(label5_Text) * 510.0) / 2.0);
            int grayMax = (int)((256.0 / (double.Parse(label6_Text) == 0 ? 0.01 : double.Parse(label6_Text)) - double.Parse(label5_Text) * 510.0) / 2.0);
            if (grayMin >= grayMax)
            {
                return src;
            }

            Mat dst = new Mat();
            //如果是灰度化图片，则只需计算一个通道。对灰度值进行映射，BGR根据左右阈值做缩放操作
            if (isGray)
            {
                Cv2.Min(mats[0], new Mat(mats[0].Rows, mats[0].Cols, MatType.CV_8UC1, new Scalar(grayMax)), dst);
                Cv2.Max(dst, new Mat(mats[0].Rows, mats[0].Cols, MatType.CV_8UC1, new Scalar(grayMin)), dst);
                Cv2.Normalize(dst, dst, 0, 255, NormTypes.MinMax);
            }
            else
            {
                for (int j = 0; j < oldHists.Length; j++)
                {
                    Cv2.Min(mats[j], new Mat(mats[j].Rows, mats[j].Cols, MatType.CV_8UC1, new Scalar(grayMax)), mats[j]);
                    Cv2.Max(mats[j], new Mat(mats[j].Rows, mats[j].Cols, MatType.CV_8UC1, new Scalar(grayMin)), mats[j]);
                    Cv2.Normalize(mats[j], mats[j], 0, 255, NormTypes.MinMax);
                }
                Cv2.Merge(mats, dst);
            }
            //灰度归一化
            dst.ConvertTo(dst, MatType.CV_64F, 1.0 / 255, 0);
            //gamma运算，gamma值根据AxioVision对比 取最小值0.01进行计算
            Cv2.Pow(dst, Math.Max(0.01, double.Parse(label7_Text)), dst);
            dst.ConvertTo(dst, MatType.CV_8U, 255, 0);

            return dst;
            //Document document = Document.FromImage(OpenCvSharp.Extensions.BitmapConverter.ToBitmap(dst));
            //this.AppWorkspace.ActiveDocumentWorkspace.Document = document;
            //this.AppWorkspace.ActiveDocumentWorkspace.Refresh();
        }

        /// <summary>
        /// 通过颜色通道去除像素点的千分比计算有效阈值
        /// </summary>
        /// <param name="hists"></param>
        /// <param name="percentValue"></param>
        /// <returns></returns>
        private static OpenCvSharp.Point getStartIndex(Mat mat, Mat[] hists, float percentValue, bool isGray)
        {
            //灰度化图片取第一通道
            Mat histGray = hists[0];
            //彩色图片取灰度化后的通道
            if (!isGray)
            {
                OpenCvSharp.Point startIndex = new OpenCvSharp.Point(0, histGray.Rows);

                //计算三次
                OpenCvSharp.Point startIndex0 = getStartRange(mat, hists[0], percentValue);
                OpenCvSharp.Point startIndex1 = getStartRange(mat, hists[1], percentValue);
                OpenCvSharp.Point startIndex2 = getStartRange(mat, hists[2], percentValue);

                startIndex.X = Math.Min(startIndex0.X, Math.Min(startIndex1.X, startIndex2.X));
                startIndex.Y = Math.Max(startIndex0.Y, Math.Max(startIndex1.Y, startIndex2.Y));

                startIndex.Y = Math.Min(255 - 1, startIndex.Y);
                startIndex.X = Math.Max(startIndex.X, 1);
                startIndex.Y = Math.Max(startIndex.X + 1, startIndex.Y);

                return startIndex;
            }
            return getStartRange(mat, histGray, percentValue);
        }

        private static OpenCvSharp.Point getStartRange(Mat mat, Mat histGray, float percentValue)
        {
            //if (this.AppWorkspace.ActiveDocumentWorkspace == null)
            //{
            //    return new OpenCvSharp.Point(1, 254); ;
            //}
            //计算灰度分布密度
            float totalPoints = mat.Cols * mat.Rows;
            OpenCvSharp.Point startIndex = new OpenCvSharp.Point(0, histGray.Rows);
            bool foundStartTag = false;
            bool foundEndTag = false;
            //根据累计直方图分布计算左右阈值
            float equalizeHists = 0;
            for (int i = 0; i < histGray.Rows; ++i)
            {
                equalizeHists += ((float)(histGray.At<float>(i) / (totalPoints * 1.0))) * 1000;

                if (!foundStartTag && equalizeHists > percentValue)
                {
                    foundStartTag = true;
                    startIndex.X = i;
                }
                else if (equalizeHists >= 1000 - percentValue)
                {
                    foundEndTag = true;
                    startIndex.Y = i;
                }

                if (foundStartTag && foundEndTag)
                    break;
            }
            startIndex.Y = Math.Min(255 - 1, startIndex.Y);
            startIndex.X = Math.Max(startIndex.X, 1);
            startIndex.Y = Math.Max(startIndex.X + 1, startIndex.Y);
            return startIndex;
        }

        #endregion

        /// <summary>
        /// 灰度化
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat Bgr2GrayFunction(Mat src)
        {
            return src.CvtColor(ColorConversionCodes.BGR2GRAY);
        }

        /// <summary>
        /// 白平衡C-限制最大最小值
        /// </summary>
        /// <param name="temp"></param>
        /// <param name="green"></param>
        /// <param name="equal"></param>
        public static void clip(double temp1, double green1, double equal1, out double temp, out double green, out double equal)
        {
            temp = Math.Max(1500.0/*min*/, Math.Min(temp1, 60000.0/*max*/));
            green = Math.Max(0.02, Math.Min(green1, 10.0));
            equal = Math.Max(0.8, Math.Min(equal1, 1.5));
        }

        /// <summary>
        /// calculate XYZ from spectrum data (color) and illuminant : J.Desmis December 2011
        /// </summary>
        /// <param name="spec_color"></param>
        /// <param name="spec_intens"></param>
        /// <param name="xx"></param>
        /// <param name="yy"></param>
        /// <param name="zz"></param>
        public static void spectrum_to_color_xyz_preset(double[] spec_color, double[] spec_intens, out double xx, out double yy, out double zz)
        {
            int i;
            double lambda, X = 0, Y = 0, Z = 0, Yo = 0;
            for (i = 0, lambda = 350; lambda < 830.1; i++, lambda += 5)
            {
                double Me;
                double Mc;
                Me = get_spectral_color(lambda, spec_color);
                Mc = get_spectral_color(lambda, spec_intens);
                X += Mc * cie_colour_match_jd[i][0] * Me;
                Y += Mc * cie_colour_match_jd[i][1] * Me;
                Z += Mc * cie_colour_match_jd[i][2] * Me;
            }
            for (i = 0, lambda = 350; lambda < 830.1; i++, lambda += 5)
            {
                double Ms;
                Ms = get_spectral_color(lambda, spec_intens);
                Yo += cie_colour_match_jd[i][1] * Ms;
            }
            xx = X / Yo;
            yy = Y / Yo;
            zz = Z / Yo;
        }


        /*
            Calculate Planck's radiation
        */
        //calculate spectral data for blackbody at temp!
        public static double blackbody_spect(double wavelength, double temperature)
        {
            double wlm = wavelength * 1e-9;   /* Wavelength in meters */
            return (3.7417715247e-16 / Math.Pow(wlm, 5)) /              //3.7417..= c1 = 2*Pi*h*c2  where h=Planck constant, c=velocity of light
                   (Math.Exp(1.438786e-2 / (wlm * temperature)) - 1.0); //1.4387..= c2 = h*c/k  where k=Boltzmann constant
        }

        /// <summary>
        /// calculate XYZ from spectrum data (color) and illuminant : J.Desmis december 2011
        /// </summary>
        /// <param name="spec_color"></param>
        /// <param name="_temp"></param>
        /// <param name="xx"></param>
        /// <param name="yy"></param>
        /// <param name="zz"></param>
        public static void spectrum_to_color_xyz_blackbody(double[] spec_color, double _temp, out double xx, out double yy, out double zz)
        {
            int i;
            double lambda, X = 0, Y = 0, Z = 0;
            for (i = 0, lambda = 350; lambda < 830.1; i++, lambda += 5)
            {
                double Me = spec_color[i];
                double Mc = blackbody_spect(lambda, _temp);
                X += Mc * cie_colour_match_jd[i][0] * Me;
                Y += Mc * cie_colour_match_jd[i][1] * Me;
                Z += Mc * cie_colour_match_jd[i][2] * Me;
            }
            xx = X / Y;
            yy = 1.0;
            zz = Z / Y;
        }
        /// <summary>
        /// spectrum_to_xyz_blackbody
        /// </summary>
        /// <param name="_temp"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void spectrum_to_xyz_blackbody(double _temp, out double x, out double y, out double z)
        {
            int i;
            double lambda, X = 0, Y = 0, Z = 0, XYZ;
            for (i = 0, lambda = 350.0; lambda < 830.1; i++, lambda += 5.0)
            {
                double Me = blackbody_spect(lambda, _temp);
                X += Me * cie_colour_match_jd[i][0];
                Y += Me * cie_colour_match_jd[i][1];
                Z += Me * cie_colour_match_jd[i][2];
            }
            XYZ = (X + Y + Z);
            x = X / XYZ;
            y = Y / XYZ;
            z = Z / XYZ;
        }

        /// <summary>
        /// calculate XYZ from spectrum data (color) and illuminant : J.Desmis december 2011
        /// </summary>
        /// <param name="spec_color"></param>
        /// <param name="_m1"></param>
        /// <param name="_m2"></param>
        /// <param name="xx"></param>
        /// <param name="yy"></param>
        /// <param name="zz"></param>
        public static void spectrum_to_color_xyz_daylight(double[] spec_color, double _m1, double _m2, out double xx, out double yy, out double zz)
        {
            int i;
            double lambda, X = 0, Y = 0, Z = 0;
            for (i = 0, lambda = 350; lambda < 830.1; i++, lambda += 5)
            {
                double Me = spec_color[i];
                double Mc = daylight_spect(lambda, _m1, _m2);
                X += Mc * cie_colour_match_jd[i][0] * Me;
                Y += Mc * cie_colour_match_jd[i][1] * Me;
                Z += Mc * cie_colour_match_jd[i][2] * Me;
            }

            xx = X / Y;
            yy = 1.0;
            zz = Z / Y;
        }

        /// <summary>
        /// 白平衡C-翻译-色度toRGB
        /// </summary>
        /// <param name="wavelength"></param>
        /// <param name="array"></param>
        /// <returns></returns>
        public static double get_spectral_color(double wavelength, double[] array)
        {
            int wlm = (int)((wavelength - 350.0) / 5.0);
            return array[wlm];
        }
        /// <summary>
        /// 白平衡C-翻译-色度toRGB
        /// </summary>
        /// <param name="spec_intens"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void spectrum_to_xyz_preset(double[] spec_intens, out double x, out double y, out double z)
        {
            int i = 0;
            double lambda = 350.0, X = 0, Y = 0, Z = 0, XYZ;
            for (; lambda < 830.1; i++, lambda += 5.0)
            {
                double Me = get_spectral_color(lambda, spec_intens);
                X += Me * cie_colour_match_jd[i][0];
                Y += Me * cie_colour_match_jd[i][1];
                Z += Me * cie_colour_match_jd[i][2];
            }
            XYZ = (X + Y + Z);
            x = X / XYZ;
            y = Y / XYZ;
            z = Z / XYZ;
        }
        /// <summary>
        /// 白平衡C-翻译-色度toRGB
        /// </summary>
        /// <param name="wavelength"></param>
        /// <param name="m1"></param>
        /// <param name="m2"></param>
        /// <returns></returns>
        public static double daylight_spect(double wavelength, double m1, double m2)
        {
            //Values for Daylight illuminant: s0 s1 s2
            //s0
            double[] s0 = {61.80, 61.65, 61.50, 65.15, 68.80, 66.10, 63.40, 64.60, 65.80, 80.30, 94.80, 99.80, 104.80, 105.35, 105.90, 101.35, 96.80, 105.35, 113.90, 119.75, 125.60, 125.55, 125.50, 123.40, 121.30, 121.30, 121.30, 117.40, 113.50, 113.30,
                                  113.10, 111.95, 110.80, 108.65, 106.50, 107.65, 108.80, 107.05, 105.30, 104.85, 104.40, 102.20, 100.00, 98.00, 96.00, 95.55, 95.10, 92.10, 89.10, 89.80, 90.50, 90.40, 90.30, 89.35, 88.40, 86.20, 84.00, 84.55, 85.10,
                                  83.50, 81.90, 82.25, 82.60, 83.75, 84.90, 83.10, 81.30, 76.60, 71.90, 73.10, 74.30, 75.35, 76.40, 69.85, 63.30, 67.50, 71.70, 74.35, 77.00, 71.10, 65.20, 56.45, 47.70, 58.15, 68.60, 66.80, 65.00, 65.50, 66.00, 63.50, 61.00, 57.15,
                                  53.30, 56.10, 58.90, 60.40, 61.90
                                 };
            //s1
            double[] s1 = {41.60, 39.80, 38.00, 40.70, 43.40, 40.95, 38.50, 36.75, 35.00, 39.20, 43.40, 44.85, 46.30, 45.10, 43.90, 40.50, 37.10, 36.90, 36.70, 36.30, 35.90, 34.25, 32.60, 30.25, 27.90, 26.10, 24.30, 22.20, 20.10, 18.15, 16.20, 14.70,
                                  13.20, 10.90, 8.60, 7.35, 6.10, 5.15, 4.20, 3.05, 1.90, 0.95, 0.00, -0.80, -1.60, -2.55, -3.50, -3.50, -3.50, -4.65, -5.80, -6.50, -7.20, -7.90, -8.60, -9.05, -9.50, -10.20, -10.90, -10.80, -10.70, -11.35, -12.00, -13.00, -14.00,
                                  -13.80, -13.60, -12.80, -12.00, -12.65, -13.30, -13.10, -12.90, -11.75, -10.60, -11.10, -11.60, -11.90, -12.20, -11.20, -10.20, -9.00, -7.80, -9.50, -11.20, -10.80, -10.50, -10.60, -10.15, -9.70, -9.00, -8.30,
                                  -8.80, -9.30, -9.55, -9.80, 0.0
                                 };//手动加0
            //s2
            double[] s2 = {6.70, 6.00, 5.30, 5.70, 6.10, 4.55, 3.00, 2.10, 1.20, 0.05, -1.10, -0.80, -0.50, -0.60, -0.70, -0.95, -1.20, -1.90, -2.60, -2.75, -2.90, -2.85, -2.80, -2.70, -2.60, -2.60, -2.60, -2.20, -1.80, -1.65, -1.50, -1.40, -1.30,
                                  -1.25, -1.20, -1.10, -1.00, -0.75, -0.50, -0.40, -0.30, -0.15, 0.00, 0.10, 0.20, 0.35, 0.50, 1.30, 2.10, 2.65, 3.65, 4.10, 4.40, 4.70, 4.90, 5.10, 5.90, 6.70, 7.00, 7.30, 7.95, 8.60, 9.20, 9.80, 10.00, 10.20, 9.25, 8.30, 8.95,
                                  9.60, 9.05, 8.50, 7.75, 7.00, 7.30, 7.60, 7.80, 8.00, 7.35, 6.70, 5.95, 5.20, 6.30, 7.40, 7.10, 6.80, 6.90, 7.00, 6.70, 6.40, 5.95, 5.50, 5.80, 6.10, 6.30, 6.50, 0.0
                                 };//手动加0
            int wlm = (int)((wavelength - 350.0) / 5.0);
            return (s0[wlm] + m1 * s1[wlm] + m2 * s2[wlm]);
        }
        /// <summary>
        /// 白平衡C-翻译-色度toRGB
        /// </summary>
        /// <param name="_m1"></param>
        /// <param name="_m2"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="z"></param>
        public static void spectrum_to_xyz_daylight(double _m1, double _m2, out double x, out double y, out double z)
        {
            int i = 0;
            double lambda = 350.0, X = 0, Y = 0, Z = 0, XYZ;
            for (; lambda < 830.1; i++, lambda += 5.0)
            {
                double Me = daylight_spect(lambda, _m1, _m2);
                X += Me * cie_colour_match_jd[i][0];
                Y += Me * cie_colour_match_jd[i][1];
                Z += Me * cie_colour_match_jd[i][2];
            }
            XYZ = (X + Y + Z);
            x = X / XYZ;
            y = Y / XYZ;
            z = Z / XYZ;
        }

        /*
         *      Name:   XYZtoCorColorTemp.c
         *
         *      Author: Bruce Justin Lindbloom
         *
         *      Copyright (c) 2003 Bruce Justin Lindbloom. All rights reserved.
         *
         *
         *      Description:
         *              This is an implementation of Robertson's method of computing the correlated color
         *              temperature of an XYZ color. It can compute correlated color temperatures in the
         *              range [1666.7K, infinity].
         *
         *      Reference:
         *              "Color Science: Concepts and Methods, Quantitative Data and Formulae", Second Edition,
         *              Gunter Wyszecki and W. S. Stiles, John Wiley & Sons, 1982, pp. 227, 228.
         */
        public static UVT CreateUVT(double u, double v, double t)
        {
            UVT uVT = new UVT();
            uVT.u = u;
            uVT.v = v;
            uVT.t = t;
            return uVT;
        }
        /// <summary>
        /// adaptation to RT by J.Desmis
        /// </summary>
        /// <param name="x0"></param>
        /// <param name="y0"></param>
        /// <param name="z0"></param>
        /// <param name="temp"></param>
        /// <returns></returns>
        public static int XYZtoCorColorTemp(double x0, double y0, double z0, out double temp)
        {
            ////  typedef enum information id
            //public enum TUCAM_IDINFO
            //{
            //    TUIDI_BUS = 0x01,             // the bus type USB2.0/USB3.0
            //    TUIDI_VENDOR = 0x02,             // the vendor id
            //    TUIDI_PRODUCT = 0x03,             // the product id 
            //    TUIDI_VERSION_API = 0x04,             // the API version    
            //    TUIDI_VERSION_FRMW = 0x05,             // the firmware version
            //    TUIDI_VERSION_FPGA = 0x06,             // the FPGA version
            //    TUIDI_VERSION_DRIVER = 0x07,             // the driver version
            //    TUIDI_TRANSFER_RATE = 0x08,             // the transfer rate
            //    TUIDI_CAMERA_MODEL = 0x09,             // the camera model (string)
            //    TUIDI_CURRENT_WIDTH = 0x0A,             // the camera image data current width(must use TUCAM_Dev_GetInfoEx and after calling TUCAM_Buf_Alloc)
            //    TUIDI_CURRENT_HEIGHT = 0x0B,             // the camera image data current height(must use TUCAM_Dev_GetInfoEx and after calling TUCAM_Buf_Alloc)
            //    TUIDI_CAMERA_CHANNELS = 0x0C,             // the camera image data channels
            //    TUIDI_BCDDEVICE = 0x0D,             // the USB bcdDevice
            //    TUIDI_ENDINFO = 0x0E,             // the string id end
            //};
            //public struct UVT
            //{
            //    //[FieldOffset(0)]
            //    public double u;
            //    //[FieldOffset(1)]
            //    public double v;
            //    //[FieldOffset(2)]
            //    public double t;
            //}
            double[] rt = new double[31]{       /* reciprocal temperature (K) */
                double.MinValue,  10.0e-6,  20.0e-6,  30.0e-6,  40.0e-6,  50.0e-6,
                60.0e-6,  70.0e-6,  80.0e-6,  90.0e-6, 100.0e-6, 125.0e-6,
                150.0e-6, 175.0e-6, 200.0e-6, 225.0e-6, 250.0e-6, 275.0e-6,
                300.0e-6, 325.0e-6, 350.0e-6, 375.0e-6, 400.0e-6, 425.0e-6,
                450.0e-6, 475.0e-6, 500.0e-6, 525.0e-6, 550.0e-6, 575.0e-6,
                600.0e-6
            };
            UVT[] uvt = new UVT[31]{
                CreateUVT(0.18006, 0.26352, -0.24341),
                CreateUVT(0.18066, 0.26589, -0.25479),
                CreateUVT(0.18133, 0.26846, -0.26876),
                CreateUVT(0.18208, 0.27119, -0.28539),
                CreateUVT(0.18293, 0.27407, -0.30470),
                CreateUVT(0.18388, 0.27709, -0.32675),
                CreateUVT(0.18494, 0.28021, -0.35156),
                CreateUVT(0.18611, 0.28342, -0.37915),
                CreateUVT(0.18740, 0.28668, -0.40955),
                CreateUVT(0.18880, 0.28997, -0.44278),
                CreateUVT(0.19032, 0.29326, -0.47888),
                CreateUVT(0.19462, 0.30141, -0.58204),
                CreateUVT(0.19962, 0.30921, -0.70471),
                CreateUVT(0.20525, 0.31647, -0.84901),
                CreateUVT(0.21142, 0.32312, -1.0182),
                CreateUVT(0.21807, 0.32909, -1.2168),
                CreateUVT(0.22511, 0.33439, -1.4512),
                CreateUVT(0.23247, 0.33904, -1.7298),
                CreateUVT(0.24010, 0.34308, -2.0637),
                CreateUVT(0.24792, 0.34655, -2.4681),
                CreateUVT(0.25591, 0.34951, -2.9641),
                CreateUVT(0.26400, 0.35200, -3.5814),
                CreateUVT(0.27218, 0.35407, -4.3633),
                CreateUVT(0.28039, 0.35577, -5.3762),
                CreateUVT(0.28863, 0.35714, -6.7262),
                CreateUVT(0.29685, 0.35823, -8.5955),
                CreateUVT(0.30505, 0.35907, -11.324),
                CreateUVT(0.31320, 0.35968, -15.628),
                CreateUVT(0.32129, 0.36011, -23.325),
                CreateUVT(0.32931, 0.36038, -40.770),
                CreateUVT(0.33724, 0.36051, -116.45)
            };

            double us, vs, p, di = 0.0, dm;
            int i;

            if ((x0 < 1.0e-20) && (y0 < 1.0e-20) && (z0 < 1.0e-20))
            {
                temp = 0.0;
                return -1;    /* protect against possible divide-by-zero failure */
            }

            us = (4.0 * x0) / (x0 + 15.0 * y0 + 3.0 * z0);
            vs = (6.0 * y0) / (x0 + 15.0 * y0 + 3.0 * z0);
            dm = 0.0;

            for (i = 0; i < 31; i++)
            {
                di = (vs - uvt[i].v) - uvt[i].t * (us - uvt[i].u);

                if ((i > 0) && (((di < 0.0) && (dm >= 0.0)) || ((di >= 0.0) && (dm < 0.0))))
                {
                    break;    /* found lines bounding (us, vs) : i-1 and i */
                }

                dm = di;
            }

            if (i == 31)
            {
                temp = 0.0;
                return -1;    /* bad XYZ input, color temp would be less than minimum of 1666.7 degrees, or too far towards blue */
            }

            di = di / Math.Sqrt(1.0 + uvt[i].t * uvt[i].t);
            dm = dm / Math.Sqrt(1.0 + uvt[i - 1].t * uvt[i - 1].t);
            p = dm / (dm - di);     /* p = interpolation parameter, 0.0 : i-1, 1.0 : i */
            p = 1.0 / intp(p, rt[i], rt[i - 1]);
            temp = p;
            return 0;      /* success */
        }

        /// <summary>
        /// 白平衡C-翻译-色度toRGB
        /// </summary>
        /// <param name="temp"></param>
        /// <param name="method"></param>
        /// <param name="Xxyz"></param>
        /// <param name="Zxyz"></param>
        public static void temp2mulxyz(double temp, string method1/*, out string method*/, out double Xxyz, out double Zxyz)
        {
            double x, y, z;
            if (spectMap.ContainsKey(method1))
            {
                spectrum_to_xyz_preset(spectMap[method1], out x, out y, out z);
            }
            else
            {
                // from 4000K up to 25000K: using the D illuminant (daylight) which is standard
                double x_D, y_D;

                if (temp <= 7000)
                {
                    x_D = -4.6070e9 / (temp * temp * temp) + 2.9678e6 / (temp * temp) + 0.09911e3 / temp + 0.244063;
                }
                else if (temp <= 25000)
                {
                    x_D = -2.0064e9 / (temp * temp * temp) + 1.9018e6 / (temp * temp) + 0.24748e3 / temp + 0.237040;
                }
                else /*if (temp > 25000)*/
                {
                    x_D = -2.0064e9 / (temp * temp * temp) + 1.9018e6 / (temp * temp) + 0.24748e3 / temp + 0.237040 - ((temp - 25000) / 25000) * 0.025;    //Jacques empirical adjustment for very high temp (underwater !)
                }

                y_D = -3.0 * x_D * x_D + 2.87 * x_D - 0.275; //modify blue / red action
                                                             //calculate D -daylight in function of s0, s1, s2 and temp ==> x_D y_D
                                                             //S(lamda)=So(lambda)+m1*s1(lambda)+m2*s2(lambda)
                double interm = 0.0241 + 0.2562 * x_D - 0.734 * y_D;
                double m1 = (-1.3515 - 1.7703 * x_D + 5.9114 * y_D) / interm;
                double m2 = (0.03 - 31.4424 * x_D + 30.0717 * y_D) / interm;
                spectrum_to_xyz_daylight(m1, m2, out x, out y, out z);
            }
            Xxyz = x / y;
            Zxyz = (1.0 - x - y) / y;
        }

        public static double intp(double a, double b, double c)
        {
            // calculate a * b + (1 - a) * c
            // following is valid:
            // intp(a, b+x, c+x) = intp(a, b, c) + x
            // intp(a, b*x, c*x) = intp(a, b, c) * x
            return a * (b - c) + c;
        }

        public static void cieCAT02(double Xw, double Yw, double Zw, out double CAM02BB00, out double CAM02BB01, out double CAM02BB02, out double CAM02BB10, out double CAM02BB11, out double CAM02BB12, out double CAM02BB20, out double CAM02BB21, out double CAM02BB22, double adap)
        {
            // CIECAT02  - J.Desmis January 2012 review September 2012
            double[] whiteD50p = new double[3] { 0.9646019585, 1.0, 0.8244507152 }; //calculate with these tool
            double[] cam_dest = new double[3] { 0.0, 0.0, 0.0 };
            double[] cam_orig = new double[3] { 0.0, 0.0, 0.0 };
            double[][] CAT02 = new double[3][]{new double[3]{0.7328,   0.4296,  -0.1624},//CAT02 2002
                new double[3]{ -0.7036,  1.6975,   0.0061},
                new double[3]{0.0030,   0.0136,   0.9834}
            };
            double[][] INVCAT02 = new double[3][]{new double[3]{1.09612382083551,      -0.278869000218287,    0.182745179382773},  //Inverse CAT02
                new double[3]{0.454369041975359,      0.4735331543070412,   0.0720978037172291},
                new double[3]{ -0.009627608738442936, -0.00569803121611342,  1.01532563995454}
            };
            double[][] inv_white_orig = new double[3][]{new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0}
            };
            double[][] intermed = new double[3][]{new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0}
            };
            double[][] intermed_2 = new double[3][]{new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0}
            };
            double[][] CAM02 = new double[3][]{new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0},
                new double[3]{0.0,  0.0,  0.0}
            };
            double D = adap;
            //white destination Wd : RT use always D50
            cam_dest[0] = CAT02[0][0] * whiteD50p[0] + CAT02[0][1] * whiteD50p[1] + CAT02[0][2] * whiteD50p[2]; //Cone response RoD
            cam_dest[1] = CAT02[1][0] * whiteD50p[0] + CAT02[1][1] * whiteD50p[1] + CAT02[1][2] * whiteD50p[2]; //GaD
            cam_dest[2] = CAT02[2][0] * whiteD50p[0] + CAT02[2][1] * whiteD50p[1] + CAT02[2][2] * whiteD50p[2]; //BeD

            //origin white Ws : A, D65, custom, etc.
            cam_orig[0] = CAT02[0][0] * Xw + CAT02[0][1] * Yw + CAT02[0][2] * Zw; //Cone response RoS
            cam_orig[1] = CAT02[1][0] * Xw + CAT02[1][1] * Yw + CAT02[1][2] * Zw;
            cam_orig[2] = CAT02[2][0] * Xw + CAT02[2][1] * Yw + CAT02[2][2] * Zw;

            //inverse white
            inv_white_orig[0][0] = 1.0 / cam_orig[0]; // 1/RoS
            inv_white_orig[1][1] = 1.0 / cam_orig[1]; // 1/GaS
            inv_white_orig[2][2] = 1.0 / cam_orig[2]; // 1/BeS

            //intermediates computation
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                {
                    intermed[i][j] = inv_white_orig[i][i] * CAT02[i][j];
                }

            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                {
                    intermed_2[i][j] = cam_dest[i] * intermed[i][j];
                }

            //and CAM02
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                    for (int k = 0; k < 3; k++)
                    {
                        CAM02[i][j] += INVCAT02[i][k] * intermed_2[k][j];
                    }

            //adaptation jdc : slightly different from CIECAM02 : Rc=(Yw(D/Rw)+(1-D))*R , but it's work !   true at 0 and 1
            CAM02[1][1] = (CAM02[1][1] - 1.0) * D + 1.0;
            CAM02[0][0] = (CAM02[0][0] - 1.0) * D + 1.0;
            CAM02[2][2] = (CAM02[2][2] - 1.0) * D + 1.0;
            CAM02[0][1] *= D;
            CAM02[0][2] *= D;
            CAM02[1][0] *= D;
            CAM02[1][2] *= D;
            CAM02[2][0] *= D;
            CAM02[2][1] *= D;
            //CAT02  matrix with D adaptation
            CAM02BB00 = CAM02[0][0];
            CAM02BB01 = CAM02[0][1];
            CAM02BB02 = CAM02[0][2];
            CAM02BB10 = CAM02[1][0];
            CAM02BB11 = CAM02[1][1];
            CAM02BB12 = CAM02[1][2];
            CAM02BB20 = CAM02[2][0];
            CAM02BB21 = CAM02[2][1];
            CAM02BB22 = CAM02[2][2];
        }

        /// <summary>
        /// 白平衡代码调用入口1-RGB转色度的方法
        /// </summary>
        /// <param name="mulr"></param>
        /// <param name="mulg"></param>
        /// <param name="mulb"></param>
        /// <param name="e"></param>
        public static void ColorTemp(double mulr, double mulg, double mulb, double e, out double temp, out double green)
        {
            localEqual = e;
            mul2temp(mulr, mulg, mulb, localEqual, out temp, out green);
        }

        /// <summary>
        /// 白平衡C代码翻译-RGB2色度的方法
        /// </summary>
        /// <param name="rmul"></param>
        /// <param name="gmul"></param>
        /// <param name="bmul"></param>
        /// <param name="equal"></param>
        /// <param name="temp"></param>
        /// <param name="green"></param>
        public static void mul2temp(double rmul, double gmul, double bmul, double equal, out double temp, out double green)
        {
            double maxtemp = 60000.0, mintemp = 1500.0;
            double tmpr = 0.0, tmpg = 0.0, tmpb;
            temp = (maxtemp + mintemp) / 2;

            while (maxtemp - mintemp > 1)
            {
                temp2mul(temp, 1.0, equal, out tmpr, out tmpg, out tmpb);

                if (tmpb / tmpr > bmul / rmul)
                {
                    maxtemp = temp;
                }
                else
                {
                    mintemp = temp;
                }

                temp = (maxtemp + mintemp) / 2;
            }

            green = (tmpg / tmpr) / (gmul / rmul);
            temp = Math.Max(1500.0/*min*/, Math.Min(temp, 60000.0/*max*/));
            green = Math.Max(0.02, Math.Min(green, 10.0));
        }

        /// <summary>
        /// 白平衡C代码翻译-色度2RGB的方法
        /// </summary>
        /// <param name="temp"></param>
        /// <param name="green"></param>
        /// <param name="equal"></param>
        /// <param name="rmul"></param>
        /// <param name="gmul"></param>
        /// <param name="bmul"></param>
        public static void temp2mul(double temp, double green, double equal, out double rmul, out double gmul, out double bmul)
        {
            clip(temp, green, equal, out temp, out green, out equal);
            double Xwb, Zwb;
            temp2mulxyz(temp, localMethod, out Xwb, out Zwb);
            double adj = 1.0;
            if (equal < 0.9999 || equal > 1.0001)
            {
                adj = (100.0 + (1000.0 - (1000.0 * equal)) / 20.0) / 100.0;
            }
            /*if (isRaw) {
                rmul = sRGB_xyz[0][0]*X + sRGB_xyz[0][1]*Y + sRGB_xyz[0][2]*Z;
                gmul = sRGB_xyz[1][0]*X + sRGB_xyz[1][1]*Y + sRGB_xyz[1][2]*Z;
                bmul = sRGB_xyz[2][0]*X + sRGB_xyz[2][1]*Y + sRGB_xyz[2][2]*Z;
            } else {*/
            //recalculate channels multipliers with new values of XYZ tue to whitebalance
            rmul = sRGBd65_xyz[0][0] * Xwb * adj + sRGBd65_xyz[0][1] + sRGBd65_xyz[0][2] * Zwb / adj; // Jacques' empirical modification 5/2013
            gmul = sRGBd65_xyz[1][0] * Xwb + sRGBd65_xyz[1][1] + sRGBd65_xyz[1][2] * Zwb;
            bmul = sRGBd65_xyz[2][0] * Xwb * adj + sRGBd65_xyz[2][1] + sRGBd65_xyz[2][2] * Zwb / adj;
            //};
            gmul /= green;
            //printf("rmul=%f gmul=%f bmul=%f\n",rmul, gmul, bmul);
            double maxRGB = Math.Max(rmul, Math.Max(gmul, bmul));
            rmul /= maxRGB;
            gmul /= maxRGB;
            bmul /= maxRGB;
            if (settings_CRI_color != 0)
            { //activate if CRi_color !=0
              // begin CRI_RT : color rendering index RT - adaptation of CRI by J.Desmis
              // CRI = 100 for Blackbody and Daylight
              // calculate from spectral data  values X, Y, Z , for  color of colorchecker24 , SG, DC, JDC_468
              // only for lamp different of tungstene
              // first calcul with illuminant (choice)
              // and calcul with : blackbody at equivalent temp of lamp
              // CRI_color-1 = display Lab values of color CRI_color -1
                double[] whiteD50 = { 0.9646019585, 1.0, 0.8244507152 }; //calculate with this tool : spect 5nm
                double[] Xchk = new double[50], Ychk = new double[50], Zchk = new double[50]; //50 : I think it's a good limit for number of color : for CRI and Palette
                double[] Xcam02 = new double[50], Ycam02 = new double[50], Zcam02 = new double[50];

                double[] XchkLamp = new double[50], YchkLamp = new double[50], ZchkLamp = new double[50];
                double[] Xcam02Lamp = new double[50], Ycam02Lamp = new double[50], Zcam02Lamp = new double[50];
                double epsilon = 0.008856; //Lab

                double[] xr = new double[50], yr = new double[50], zr = new double[50];

                int illum = 0;
                int numero_color = settings_CRI_color - 1;

                //spectral data illuminant (actually 21): only those necessary (lamp, fluorescent, LED) others CRI=100 (not Flash...)
                double[][] spec_color = {
                    ColorchechredC3_spect, ColorchechOraA2_spect, ColorchechYelD3_spect, ColorchechGreE2_spect, ColorchechGreB3_spect,
                    ColorchechCyaF3_spect, ColorchechPurD2_spect, ColorchechMagE3_spect, ColorchechSkiA138_13_14_spect, ColorchechGraC4_67_spect,
                    ColorchechSkiB166_18_18_spect, ColorchechBluC150_m5_m22_spect, ColorchechDCBluN881_m7_m14_spect, ColorchechSGSkiF763_14_26_spect,
                    ColorchechSGSkiK285_11_17_spect, ColorchechWhiA496_spect, ColorchechGreD1_spect, ColorchechSGBlaN3_6_spect,
                    JDC468_GraK14_44_spect, JDC468_BluH10_spect
                };

                int N_c = spec_color.Length;// sizeof(spec_color) / sizeof(spec_color[0]); //number of color

                bool CRI_type = false;
                double tempw = 0;

                if (localMethod == "Fluo F1")
                {
                    CRI_type = true;
                    tempw = 6430;
                    illum = 1;
                }
                else if (localMethod == "Fluo F2")
                {
                    CRI_type = true;
                    tempw = 4230;
                    illum = 2;
                }
                else if (localMethod == "Fluo F3")
                {
                    CRI_type = true;
                    tempw = 3450;
                    illum = 3;
                }
                else if (localMethod == "Fluo F4")
                {
                    CRI_type = true;
                    tempw = 2940;
                    illum = 4;
                }
                else if (localMethod == "Fluo F5")
                {
                    CRI_type = true;
                    tempw = 6350;
                    illum = 5;
                }
                else if (localMethod == "Fluo F6")
                {
                    CRI_type = true;
                    tempw = 4150;
                    illum = 6;
                }
                else if (localMethod == "Fluo F7")
                {
                    CRI_type = true;
                    tempw = 6500;
                    illum = 7;
                }
                else if (localMethod == "Fluo F8")
                {
                    CRI_type = true;
                    tempw = 5020;
                    illum = 8;
                }
                else if (localMethod == "Fluo F9")
                {
                    CRI_type = true;
                    tempw = 4330;
                    illum = 9;
                }
                else if (localMethod == "Fluo F10")
                {
                    CRI_type = true;
                    tempw = 5300;
                    illum = 10;
                }
                else if (localMethod == "Fluo F11")
                {
                    CRI_type = true;
                    tempw = 4000;
                    illum = 11;
                }
                else if (localMethod == "Fluo F12")
                {
                    CRI_type = true;
                    tempw = 3000;
                    illum = 12;
                }
                else if (localMethod == "HMI Lamp")
                {
                    CRI_type = true;
                    tempw = 4760;
                    illum = 13;
                }
                else if (localMethod == "GTI Lamp")
                {
                    CRI_type = true;
                    tempw = 5000;
                    illum = 14;
                }
                else if (localMethod == "JudgeIII Lamp")
                {
                    CRI_type = true;
                    tempw = 5100;
                    illum = 15;
                }
                else if (localMethod == "Solux Lamp 3500K")
                {
                    CRI_type = true;
                    tempw = 3480;
                    illum = 16;
                }
                else if (localMethod == "Solux Lamp 4100K")
                {
                    CRI_type = true;
                    tempw = 3930;
                    illum = 17;
                }
                else if (localMethod == "Solux Lamp 4700K")
                {
                    CRI_type = true;
                    tempw = 4700;
                    illum = 18;
                }
                else if (localMethod == "NG Solux Lamp 4700K")
                {
                    CRI_type = true;
                    tempw = 4480;
                    illum = 19;
                }
                else if (localMethod == "LED LSI Lumelex 2040")
                {
                    CRI_type = true;
                    tempw = 2970;
                    illum = 20;
                }
                else if (localMethod == "LED CRS SP12 WWMR16")
                {
                    CRI_type = true;
                    tempw = 3050;
                    illum = 21;
                }
                else
                {
                    CRI_type = false;
                }

                if (CRI_type)
                {
                    double x, y, z;
                    double Ywb = 1.0;

                    double[][] spect_illum = {
                        Daylight5300_spect, Cloudy6200_spect, Shade7600_spect, A2856_spect, FluoF1_spect, FluoF2_spect, FluoF3_spect,
                        FluoF4_spect, FluoF5_spect, FluoF6_spect, FluoF7_spect, FluoF8_spect, FluoF9_spect, FluoF10_spect, FluoF11_spect,
                        FluoF12_spect, HMI_spect, GTI_spect, JudgeIII_spect, Solux3500_spect, Solux4100_spect, Solux4700_spect,
                        NG_Solux4700_spect, NG_CRSSP12WWMR16_spect, NG_CRSSP12WWMR16_spect
                    };

                    float[] DeltaE = new float[50], DeltaEs = new float[8];
                    float quadCRI = 0.0f, quadCRIs = 0.0f;
                    float CRI_RT = (float)0.0;
                    float[] CRI = new float[50];
                    float CRI_RTs = (float)0.0;
                    float[] CRIs = new float[8];

                    for (int i = 0; i < N_c; i++)
                    {
                        spectrum_to_color_xyz_preset(spec_color[i], spect_illum[illum + 3], out XchkLamp[i], out YchkLamp[i], out ZchkLamp[i]);
                    }

                    //calculate XYZ for each color : for Blackbody and Daylight at tempw
                    if (tempw <= INITIALBLACKBODY)
                    {
                        for (int i = 0; i < N_c; i++)
                        {
                            spectrum_to_color_xyz_blackbody(spec_color[i], tempw, out Xchk[i], out Ychk[i], out Zchk[i]);
                        }

                        spectrum_to_xyz_blackbody(tempw, out x, out y, out z);//for white point
                    }
                    else
                    { // after 6600K (arbitrary) I use daylight...because ...but there is no lamp...
                        double m11, m22, x_DD, y_DD, interm2;

                        if (tempw <= 7000)
                        {
                            x_DD = -4.6070e9 / (tempw * tempw * tempw) + 2.9678e6 / (tempw * tempw) + 0.09911e3 / tempw + 0.244063;
                        }
                        else
                        {
                            x_DD = -2.0064e9 / (tempw * tempw * tempw) + 1.9018e6 / (tempw * tempw) + 0.24748e3 / tempw + 0.237040;
                        }

                        y_DD = -3.0 * x_DD * x_DD + 2.87 * x_DD - 0.275;
                        //calculate D -daylight in function of s0, s1, s2 and temp ==> x_D y_D
                        //S(lamda)=So(lambda)+m1*s1(lambda)+m2*s2(lambda)
                        interm2 = (0.0241 + 0.2562 * x_DD - 0.734 * y_DD);
                        m11 = (-1.3515 - 1.7703 * x_DD + 5.9114 * y_DD) / interm2;
                        m22 = (0.03 - 31.4424 * x_DD + 30.0717 * y_DD) / interm2;

                        for (int i = 0; i < N_c; i++)
                        {
                            spectrum_to_color_xyz_daylight(spec_color[i], m11, m22, out Xchk[i], out Ychk[i], out Zchk[i]);
                        }

                        spectrum_to_xyz_daylight(m11, m22, out x, out y, out z);
                    }

                    if (settings_verbose)
                    {
                        double correl_temp = 0.0;
                        XYZtoCorColorTemp(Xwb, Ywb, Zwb, out correl_temp);
                        //printf("Correlated temperature (lamp)=%i\n", (int)correl_temp); //use only for lamp...otherwise It give an information!!
                    }

                    double Xwb_bb = x / y; //white balance for blackbody
                    double Ywb_bb = 1.0;
                    double Zwb_bb = (1.0 - x - y) / y;

                    //calculate Matrix CAM02 : better than Von Kries and Bradford==> for Lamp
                    double adap = 1.0;
                    double CAM02BB00, CAM02BB01, CAM02BB02, CAM02BB10, CAM02BB11, CAM02BB12, CAM02BB20, CAM02BB21, CAM02BB22; //for CIECAT02
                    cieCAT02(Xwb, Ywb, Zwb, out CAM02BB00, out CAM02BB01, out CAM02BB02, out CAM02BB10, out CAM02BB11, out CAM02BB12, out CAM02BB20, out CAM02BB21, out CAM02BB22, adap);

                    //here new value of X,Y,Z for lamp with chromatic CAM02 adaptation
                    for (int i = 0; i < N_c; i++)
                    {
                        Xcam02Lamp[i] = CAM02BB00 * XchkLamp[i] + CAM02BB01 * YchkLamp[i] + CAM02BB02 * ZchkLamp[i];
                        Ycam02Lamp[i] = CAM02BB10 * XchkLamp[i] + CAM02BB11 * YchkLamp[i] + CAM02BB12 * ZchkLamp[i];
                        Zcam02Lamp[i] = CAM02BB20 * XchkLamp[i] + CAM02BB21 * YchkLamp[i] + CAM02BB22 * ZchkLamp[i];
                    }

                    //now calculate CAM02 for Blackbody (or Daylight) at tempx

                    cieCAT02(Xwb_bb, Ywb_bb, Zwb_bb, out CAM02BB00, out CAM02BB01, out CAM02BB02, out CAM02BB10, out CAM02BB11, out CAM02BB12, out CAM02BB20, out CAM02BB21, out CAM02BB22, adap);

                    //here new value of X,Y,Z for blackbody with chromatic CAM02 adaptation

                    for (int i = 0; i < N_c; i++)
                    {
                        Xcam02[i] = CAM02BB00 * Xchk[i] + CAM02BB01 * Ychk[i] + CAM02BB02 * Zchk[i];
                        Ycam02[i] = CAM02BB10 * Xchk[i] + CAM02BB11 * Ychk[i] + CAM02BB12 * Zchk[i];
                        Zcam02[i] = CAM02BB20 * Xchk[i] + CAM02BB21 * Ychk[i] + CAM02BB22 * Zchk[i];
                        //  printf("CoulXYZ %i X %f Y %f Z %f\n", i, Xchk[i],Ychk[i],Zchk[i]);
                        //  printf("CoulCAM %i X %f Y %f Z %f\n", i, Xcam02[i],Ycam02[i],Zcam02[i]);
                    }

                    //now conversion to Lab
                    // Lamp
                    double[] fx = new double[50], fy = new double[50], fz = new double[50];

                    for (int i = 0; i < N_c; i++)
                    {
                        xr[i] = Xcam02Lamp[i] / whiteD50[0];
                        yr[i] = Ycam02Lamp[i] / whiteD50[1];
                        zr[i] = Zcam02Lamp[i] / whiteD50[2];

                        // xr, yr , zr > epsilon
                        if (xr[i] > epsilon)
                        {
                            fx[i] = Math.Pow/*std::cbrt*/(xr[i], 1.0 / 3);
                        }
                        else
                        {
                            fx[i] = (903.3 * xr[i] + 16.0) / 116.0;
                        }

                        if (yr[i] > epsilon)
                        {
                            fy[i] = Math.Pow(yr[i], 1.0 / 3);
                        }
                        else
                        {
                            fy[i] = (903.3 * yr[i] + 16.0) / 116.0;
                        }

                        if (zr[i] > epsilon)
                        {
                            fz[i] = Math.Pow(zr[i], 1.0 / 3);
                        }
                        else
                        {
                            fz[i] = (903.3 * zr[i] + 16.0) / 116.0;
                        }
                    }

                    double[] Llamp = new double[50], alamp = new double[50], blamp = new double[50];
                    for (int i = 0; i < N_c; i++)
                    {
                        Llamp[i] = 116.0 * fy[i] - 16.0;
                        alamp[i] = 500.0 * (fx[i] - fy[i]);
                        blamp[i] = 200.0 * (fy[i] - fz[i]);
                    }

                    //blackbody at tempx
                    for (int i = 0; i < N_c; i++)
                    {
                        xr[i] = Xcam02[i] / whiteD50[0];
                        yr[i] = Ycam02[i] / whiteD50[1];
                        zr[i] = Zcam02[i] / whiteD50[2];

                        //
                        if (xr[i] > epsilon)
                        {
                            fx[i] = Math.Pow(xr[i], 1.0 / 3);
                        }
                        else
                        {
                            fx[i] = (903.3 * xr[i] + 16.0) / 116.0;
                        }

                        if (yr[i] > epsilon)
                        {
                            fy[i] = Math.Pow(yr[i], 1.0 / 3);
                        }
                        else
                        {
                            fy[i] = (903.3 * yr[i] + 16.0) / 116.0;
                        }

                        if (zr[i] > epsilon)
                        {
                            fz[i] = Math.Pow(zr[i], 1.0 / 3);
                        }
                        else
                        {
                            fz[i] = (903.3 * zr[i] + 16.0) / 116.0;
                        }
                    }

                    double[] Lbb = new double[50], abb = new double[50], bbb = new double[50];

                    for (int i = 0; i < N_c; i++)
                    {
                        Lbb[i] = 116.0 * fy[i] - 16.0;
                        abb[i] = 500.0 * (fx[i] - fy[i]);
                        bbb[i] = 200.0 * (fy[i] - fz[i]);
                    }

                    ////display value to verify calculus
                    //if (settings_CRI_color != 0)
                    //{
                    //    //printf("Color Number %i\n", numero_color);
                    //    //printf("L_refer=%2.2f a=%2.2f b=%2.2f\n", Lbb[numero_color], abb[numero_color], bbb[numero_color]);
                    //    //printf("L_lamp=%2.2f al=%2.2f bl=%2.2f\n", Llamp[numero_color], alamp[numero_color], blamp[numero_color]);
                    //}

                    //then calculate DeltaE CIE 1976
                    for (int i = 0; i < 8; i++)
                    {
                        DeltaEs[i] = (float)Math.Sqrt((Lbb[i] - Llamp[i]) * (Lbb[i] - Llamp[i]) + (abb[i] - alamp[i]) * (abb[i] - alamp[i]) + (bbb[i] - blamp[i]) * (bbb[i] - blamp[i]));
                    }

                    for (int i = 0; i < 8; i++)
                    {
                        CRIs[i] = 100 - 3.0f * DeltaEs[i];    //3.0 coef to adapt ==> same results than CRI "official"
                    }

                    for (int i = 0; i < 8; i++)
                    {
                        CRI_RTs += CRIs[i];
                    }

                    CRI_RTs /= 8;

                    for (int i = 0; i < 8; i++)
                    {
                        quadCRIs += (CRIs[i] - CRI_RTs) * (CRIs[i] - CRI_RTs);
                    }

                    quadCRIs /= 8;

                    for (int i = 0; i < N_c; i++)
                    {
                        DeltaE[i] = (float)Math.Sqrt((Lbb[i] - Llamp[i]) * (Lbb[i] - Llamp[i]) + (abb[i] - alamp[i]) * (abb[i] - alamp[i]) + (bbb[i] - blamp[i]) * (bbb[i] - blamp[i]));
                    }

                    for (int i = 0; i < N_c; i++)
                    {
                        CRI[i] = 100 - 3.0f * DeltaE[i];    //3.0 coef to adapt ==> same results than CRI "official"
                    }

                    for (int i = 0; i < N_c; i++)
                    {
                        CRI_RT += CRI[i];
                    }

                    CRI_RT /= N_c;

                    for (int i = 0; i < N_c; i++)
                    {
                        quadCRI += (CRI[i] - CRI_RT) * (CRI[i] - CRI_RT);
                    }

                    quadCRI /= N_c;

                    //if (settings_CRI_color != 0)
                    //{
                    //    //printf("CRI_standard=%i CRI:1->8=%i %i %i %i %i %i %i %i  Sigma=%2.1f\n", (int)CRI_RTs, (int)CRIs[0], (int)CRIs[1], (int)CRIs[2], (int)CRIs[3], (int)CRIs[4], (int)CRIs[5], (int)CRIs[6], (int)CRIs[7], sqrt(static_cast<double>(quadCRIs)));
                    //    //printf("CRI_RT_exten=%i CRI:9->20=%i %i %i %i %i %i %i %i %i %i %i %i Sigma=%2.1f\n", (int)CRI_RT, (int)CRI[8], (int)CRI[9], (int)CRI[10], (int)CRI[11], (int)CRI[12], (int)CRI[13], (int)CRI[14], (int)CRI[15], (int)CRI[16], (int)CRI[17], (int)CRI[18], (int)CRI[19], static_cast<double>(sqrt(quadCRI)));
                    //}
                }
            }
        }

        ///// <summary>
        ///// 白平衡-图像转换方法(Image8.cc)
        ///// </summary>
        ///// <param name="src"></param>
        //public static void/*Mat*/ imgGetStdImage(Mat src)
        //{
        //    Mat dst = src.Clone();
        //    // compute channel multipliers
        //    double/*float*/ rm = 1.0f, gm = 1.0f, bm = 1.0f;
        //    if (localTemp/*ctemp.getTemp()*/ >= 0)
        //    {
        //        double drm, dgm, dbm;
        //        temp2mul(localTemp, localGreen, localEqual, out drm, out dgm, out dbm);
        //        //ctemp.getMultipliers(drm, dgm, dbm);
        //        rm = drm;
        //        gm = dgm;
        //        bm = dbm;

        //        rm = 1.0f / rm;
        //        gm = 1.0f / gm;
        //        bm = 1.0f / bm;
        //        double/*float*/ mul_lum = 0.299f * rm + 0.587f * gm + 0.114f * bm;
        //        rm /= mul_lum;
        //        gm /= mul_lum;
        //        bm /= mul_lum;
        //    }
        //    int imwidth = src.Width;// image->getWidth(); // Destination image
        //    int imheight = src.Height;// image->getHeight(); // Destination image
        //    int maxx = imwidth - 1;// width; // Source image
        //    int maxy = imheight - 1;// height; // Source image
        //    int sx1 = 0, sy1 = 0;
        //    double/*float*/ rm2 = rm;
        //    double/*float*/ gm2 = gm;
        //    double/*float*/ bm2 = bm;

        //    // Iterating all the rows of the destination image
        //    for (int iy = 0; iy < imheight; iy++)
        //    {
        //        // special case (speedup for 1:1 scale)
        //        // i: source image, first line of the current destination row
        //        int src_y = sy1 + iy;

        //        // overflow security check, not sure that it's necessary
        //        if (src_y >= maxy)
        //        {
        //            continue;
        //        }

        //        for (int dst_x = 0, src_x = sx1; dst_x < imwidth; dst_x++, src_x++)
        //        {
        //            double/*float*/ r_, g_, b_;

        //            // overflow security check, not sure that it's necessary
        //            if (src_x >= maxx)
        //            {
        //                continue;
        //            }

        //            Vec3b rgb123 = dst.At<Vec3b>(src_y, src_x);
        //            r_ = rgb123.Item2;
        //            g_ = rgb123.Item1;
        //            b_ = rgb123.Item0;
        //            Vec3b rgb = new Vec3b();
        //            rgb[0] = (byte)Math.Max(0, Math.Min(255, bm2 * b_)); //m_pLookupB[rgb123[0]];
        //            rgb[1] = (byte)Math.Max(0, Math.Min(255, gm2 * g_)); //m_pLookupG[rgb123[1]];
        //            rgb[2] = (byte)Math.Max(0, Math.Min(255, rm2 * r_));

        //            dst.Set<Vec3b>(src_y, src_x, rgb);
        //        }
        //    }
        //    Cv2.ImShow("dst", dst);
        //}

        ///// <summary>
        ///// 白平衡-图像转换方法(rawimagesource.cc)
        ///// </summary>
        ///// <param name="src"></param>
        //public static void RawImageSource_getImage(Mat src)
        //{
        //}

        ///// <summary>
        ///// 白平衡-图像转换方法
        ///// </summary>
        ///// <param name="value"></param>
        ///// <param name="position"></param>
        //private static void ForeachFunctionVeb3ForWhiteBalance(Vec3b* value, int* position)
        //{
        //    //对每个像素点的操作
        //    Vec3b rgb = new Vec3b();
        //    rgb[0] = (byte)Math.Max(0, Math.Min(255, bm2 * value->Item0));
        //    rgb[1] = (byte)Math.Max(0, Math.Min(255, gm2 * value->Item1));
        //    rgb[2] = (byte)Math.Max(0, Math.Min(255, rm2 * value->Item2));
        //    phaseTemp1.Set(position[0], position[1], rgb);
        //}

        /// <summary>
        /// 白平衡【完美反射算法<--灰度世界算法】、手动模式
        /// 灰度世界算法以灰度世界假设为基础，假设为：对于一幅有着大量色彩变化的图像，RGB三个分量的平均值趋于同一个灰度值(https://mp.weixin.qq.com/s/aiVIci0NQVyUTJ7V8ElH3g)
        /// 完美反射理论假设图像中最亮的点就是白点，并以此白点为参考对图像进行自动白平衡，最亮点定义为[公式]的最大值(https://zhuanlan.zhihu.com/p/96001776)
        /// 
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat WhiteBalanceFunction(Mat src, List<Args> lists)
        {
            if (src.Channels() == 1)
            {
                src = src.CvtColor(ColorConversionCodes.GRAY2BGR);
            }
            Args args = lists[0];
            int modeValue = int.Parse(args.Value.ToString());
            if (modeValue == 2 || modeValue == 3)//色板取色、原图取色
            {
                Args objectSelectA;
                if (modeValue == 2)
                {
                    objectSelectA = args.choiseList[1];
                }
                else
                {
                    objectSelectA = args.choiseList[2];
                }
                Color phaseColor = Color.FromArgb(int.Parse(objectSelectA.Lists[0].Value.ToString()));

                //Mat[] dst = Cv2.Split(src);

                //求原始图像的RGB分量的均值
                double R, G, B;

                B = phaseColor.B;// Cv2.Mean(dst[0])[0]; 21;// 226;// 217;//
                G = phaseColor.G;// Cv2.Mean(dst[1])[0]; 24;// 163;// 150;//
                R = phaseColor.R;// Cv2.Mean(dst[2])[0]; 32;// 111;// 98;//

                /*
                  temp = Math.Max(1500.0/*min*//*, Math.Min(temp1, 60000.0/*max*///));
                /*green = Math.Max(0.02, Math.Min(green1, 10.0));
                  equal = Math.Max(0.8, Math.Min(equal1, 1.5));
                */
                ColorTemp(R / 255.0, G / 255.0, B / 255.0, 1.0, out localTemp, out localGreen);//6464.4126892089844, 0.96839510452584376..
                //temp2mul(localTemp, localGreen, localEqual, out localMulR, out localMulG, out localMulB);
                //imgGetStdImage(src);

                // compute channel multipliers
                double rm = 1.0f, gm = 1.0f, bm = 1.0f;
                if (localTemp >= 0)
                {
                    temp2mul(localTemp, localGreen, localEqual, out rm, out gm, out bm);
                    rm = 1.0f / rm;
                    gm = 1.0f / gm;
                    bm = 1.0f / bm;
                    double mul_lum = 0.299f * rm + 0.587f * gm + 0.114f * bm;
                    rm /= mul_lum;
                    gm /= mul_lum;
                    bm /= mul_lum;
                }
                //phaseTemp1/*Mat dst1*/ = src.Clone();
                //rm2 = rm;
                //gm2 = gm;
                //bm2 = bm;
                //src.ForEachAsVec3b(ForeachFunctionVeb3ForWhiteBalance);
                //if (phaseTemp1 != null && !phaseTemp1.IsDisposed) {
                //    phaseTemp1.CopyTo(src);
                //    phaseTemp1.Dispose();
                //}

                Mat[] dst = Cv2.Split(src);
                if (dst.Length == 1)
                {
                    dst[0] = dst[0] * bm;
                    dst[1] = dst[0] * gm;
                    dst[2] = dst[0] * rm;
                }
                else
                {
                    dst[0] = dst[0] * bm;
                    dst[1] = dst[1] * gm;
                    dst[2] = dst[2] * rm;
                }
                Mat dst1 = new Mat();
                Cv2.Merge(dst, dst1);

                //Mat[] dst = Cv2.Split(src);
                ////需要调整的RGB分量的增益
                //double KR, KG, KB;
                //KB = (R + G + B) / (3 * phaseColor.B);
                //KG = (R + G + B) / (3 * phaseColor.G);
                //KR = (R + G + B) / (3 * phaseColor.R);
                //dst[0] = dst[0] * KB;
                //dst[1] = dst[1] * KG;
                //dst[2] = dst[2] * KR;
                ////RGB三通道图像合并
                //Mat dst1 = new Mat();
                //Cv2.Merge(dst, dst1);

                return dst1;// src;//
            }

            ////灰度世界算法-->
            //OpenCvSharp.XPhoto.LearningBasedWB grayworldWB = OpenCvSharp.XPhoto.LearningBasedWB.Create();
            //grayworldWB.BalanceWhite(src, src);
            //grayworldWB.Dispose();
            //return src;

            //OpenCvSharp.XPhoto.SimpleWB simpleWB = OpenCvSharp.XPhoto.SimpleWB.Create();
            //simpleWB.BalanceWhite(src, src);
            //simpleWB.Dispose();
            //return src;

            //基于图像分析的偏色检测及颜色校正方法

            //3 从原图中分离出三个通道
            Mat[] vMatRGB = Cv2.Split(src);


            //4 分别求三个通道的平均值
            double fAverageR = Cv2.Mean(vMatRGB[2])[0]; //mean(dst[2])[0];
            double fAverageG = Cv2.Mean(vMatRGB[1])[0];
            double fAverageB = Cv2.Mean(vMatRGB[0])[0];

            //5 求每个通道的平衡系数
            double fKR = (fAverageR + fAverageG + fAverageB) / (3 * fAverageR);
            double fKG = (fAverageR + fAverageG + fAverageB) / (3 * fAverageG);
            double fKB = (fAverageR + fAverageG + fAverageB) / (3 * fAverageB);

            //6 根据平衡系数，调整每个通道的像素值，以便图像达到白平衡
            vMatRGB[2] = vMatRGB[2] * fKR;
            vMatRGB[1] = vMatRGB[1] * fKG;
            vMatRGB[0] = vMatRGB[0] * fKB;

            //7 合并调整后的三个通道图，就是白平衡图
            Mat matDst = new Mat();
            Cv2.Merge(vMatRGB, matDst);
            return matDst;

            ////3 从原图中分离出三个通道
            //Mat[] vMatRGB = Cv2.Split(src);

            ////4 分别求三个通道的平均值
            //double fAverageR = Cv2.Mean(vMatRGB[2])[0]; //mean(dst[2])[0];
            //double fAverageG = Cv2.Mean(vMatRGB[1])[0];
            //double fAverageB = Cv2.Mean(vMatRGB[0])[0];

            ////5 求每个通道的平衡系数
            //double fKR = (fAverageR + fAverageG + fAverageB) / (3 * fAverageR);
            //double fKG = (fAverageR + fAverageG + fAverageB) / (3 * fAverageG);
            //double fKB = (fAverageR + fAverageG + fAverageB) / (3 * fAverageB);

            ////6 根据平衡系数，调整每个通道的像素值，以便图像达到白平衡
            //vMatRGB[2] = vMatRGB[2] * fKR;
            //vMatRGB[1] = vMatRGB[1] * fKG;
            //vMatRGB[0] = vMatRGB[0] * fKB;

            ////7 合并调整后的三个通道图，就是白平衡图
            //Mat matDst = new Mat();
            //Cv2.Merge(vMatRGB, matDst);
            //return matDst;

            //完美反射算法
            //OpenCvSharp.XPhoto.SimpleWB simpleWB = OpenCvSharp.XPhoto.SimpleWB.Create();
            //simpleWB.BalanceWhite(src, src);
            //simpleWB.Dispose();
            //return src;
        }
        /// <summary>
        /// 图像旋转
        /// </summary>
        /// <param name="src"></param>
        /// <param name="lists"></param>
        /// <returns></returns>
        public static Mat MatRotate(Mat src, List<Args> lists)
        {
            Color phaseColor = Color.Red;
            int iColor = -1973791;
            float rotate = 0;
            if (lists.Count > 0)
            {
                foreach (Args args in lists)
                {
                    switch (args.key)
                    {
                        case "Rotate":
                            rotate = float.Parse(lists[0].value.ToString());
                            break;
                        case "phaseColor":
                            iColor = int.Parse(args.Value.ToString());
                            phaseColor = Color.FromArgb(iColor);
                            break;
                    }
                }
            }
            Mat mat = GeometryIntent.MatRotate(src, rotate, new OpenCvSharp.Scalar(phaseColor.B, phaseColor.G, phaseColor.R, 255));
            return mat;
        }
        /// <summary>
        /// 色彩平衡
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat ColorBalanceFunction(Mat src, List<Args> lists)
        {
            //保持明度
            bool m_bPreserveLuminosity = true;
            //0阴影 1中间调 2高光
            int ToneRgn = 1;
            //红
            int cyan_red = 0;
            //绿
            int magenta_green = 0;
            //蓝
            int yellow_blue = 0;
            //阴影
            int TONE_SHADOWS = 0;
            //中间调
            int TONE_MIDTONES = 1;
            //高光
            int TONE_HIGHLIGHTS = 2;

            foreach (Args args in lists)
            {
                switch (args.key)
                {
                    case "Red":
                        cyan_red = int.Parse(args.Value.ToString());
                        break;
                    case "Green":
                        magenta_green = int.Parse(args.Value.ToString());
                        break;
                    case "Blue":
                        yellow_blue = int.Parse(args.Value.ToString());
                        break;
                }
            }

            int[] cyan_red_rgn = new int[3] { 0, 0, 0 };
            int[] magenta_green_rgn = new int[3] { 0, 0, 0 };
            int[] yellow_blue_rgn = new int[3] { 0, 0, 0 };

            cyan_red_rgn[ToneRgn] = cyan_red;
            magenta_green_rgn[ToneRgn] = magenta_green;
            yellow_blue_rgn[ToneRgn] = yellow_blue;

            // add for lightening, sub for darkening
            double[] highlights_add = new double[256];
            double[] midtones_add = new double[256];
            double[] shadows_add = new double[256];
            double[] highlights_sub = new double[256];
            double[] midtones_sub = new double[256];
            double[] shadows_sub = new double[256];

            for (int i = 0; i < 256; i++)
            {
                highlights_add[i] = shadows_sub[255 - i] = (1.075 - 1 / (i / 16.0 + 1));
                midtones_add[i] = midtones_sub[i] = 0.667 * (1 - Math.Pow((i - 127.0) / 127.0, 2));
                shadows_add[i] = highlights_sub[i] = 0.667 * (1 - Math.Pow((i - 127.0) / 127.0, 2));
            }

            // Set the transfer arrays (for speed)
            double[][] cyan_red_transfer = new double[3][];
            double[][] magenta_green_transfer = new double[3][];
            double[][] yellow_blue_transfer = new double[3][];
            cyan_red_transfer[TONE_SHADOWS] = (cyan_red_rgn[TONE_SHADOWS] > 0) ? shadows_add : shadows_sub;
            cyan_red_transfer[TONE_MIDTONES] = (cyan_red_rgn[TONE_MIDTONES] > 0) ? midtones_add : midtones_sub;
            cyan_red_transfer[TONE_HIGHLIGHTS] = (cyan_red_rgn[TONE_HIGHLIGHTS] > 0) ? highlights_add : highlights_sub;
            magenta_green_transfer[TONE_SHADOWS] = (magenta_green_rgn[TONE_SHADOWS] > 0) ? shadows_add : shadows_sub;
            magenta_green_transfer[TONE_MIDTONES] = (magenta_green_rgn[TONE_MIDTONES] > 0) ? midtones_add : midtones_sub;
            magenta_green_transfer[TONE_HIGHLIGHTS] = (magenta_green_rgn[TONE_HIGHLIGHTS] > 0) ? highlights_add : highlights_sub;
            yellow_blue_transfer[TONE_SHADOWS] = (yellow_blue_rgn[TONE_SHADOWS] > 0) ? shadows_add : shadows_sub;
            yellow_blue_transfer[TONE_MIDTONES] = (yellow_blue_rgn[TONE_MIDTONES] > 0) ? midtones_add : midtones_sub;
            yellow_blue_transfer[TONE_HIGHLIGHTS] = (yellow_blue_rgn[TONE_HIGHLIGHTS] > 0) ? highlights_add : highlights_sub;

            int[] m_pLookupR = new int[256];
            int[] m_pLookupG = new int[256];
            int[] m_pLookupB = new int[256];
            for (int i = 0; i < 256; i++)
            {
                int r_n = i, g_n = i, b_n = i;

                r_n += (int)(cyan_red_rgn[TONE_SHADOWS] * cyan_red_transfer[TONE_SHADOWS][r_n]); if (r_n < 0) r_n = 0; if (r_n > 255) r_n = 255;
                r_n += (int)(cyan_red_rgn[TONE_MIDTONES] * cyan_red_transfer[TONE_MIDTONES][r_n]); if (r_n < 0) r_n = 0; if (r_n > 255) r_n = 255;
                r_n += (int)(cyan_red_rgn[TONE_HIGHLIGHTS] * cyan_red_transfer[TONE_HIGHLIGHTS][r_n]); if (r_n < 0) r_n = 0; if (r_n > 255) r_n = 255;

                g_n += (int)(magenta_green_rgn[TONE_SHADOWS] * magenta_green_transfer[TONE_SHADOWS][g_n]); if (g_n < 0) g_n = 0; if (g_n > 255) g_n = 255;
                g_n += (int)(magenta_green_rgn[TONE_MIDTONES] * magenta_green_transfer[TONE_MIDTONES][g_n]); if (g_n < 0) g_n = 0; if (g_n > 255) g_n = 255;
                g_n += (int)(magenta_green_rgn[TONE_HIGHLIGHTS] * magenta_green_transfer[TONE_HIGHLIGHTS][g_n]); if (g_n < 0) g_n = 0; if (g_n > 255) g_n = 255;

                b_n += (int)(yellow_blue_rgn[TONE_SHADOWS] * yellow_blue_transfer[TONE_SHADOWS][b_n]); if (b_n < 0) b_n = 0; if (b_n > 255) b_n = 255;
                b_n += (int)(yellow_blue_rgn[TONE_MIDTONES] * yellow_blue_transfer[TONE_MIDTONES][b_n]); if (b_n < 0) b_n = 0; if (b_n > 255) b_n = 255;
                b_n += (int)(yellow_blue_rgn[TONE_HIGHLIGHTS] * yellow_blue_transfer[TONE_HIGHLIGHTS][b_n]); if (b_n < 0) b_n = 0; if (b_n > 255) b_n = 255;

                m_pLookupR[i] = r_n;
                m_pLookupG[i] = g_n;
                m_pLookupB[i] = b_n;
            }

            for (int k = 0; k < src.Height; k++)
            {
                for (int m = 0; m < src.Width; m++)
                {
                    Vec3b rgb123 = src.At<Vec3b>(k, m);
                    Vec3b rgb = new Vec3b();
                    rgb[0] = (byte)m_pLookupB[rgb123[0]];
                    rgb[1] = (byte)m_pLookupG[rgb123[1]];
                    rgb[2] = (byte)m_pLookupR[rgb123[2]];
                    //mat.Set<Vec3b>(k, m, rgb);

                    if (m_bPreserveLuminosity) // preserve luminosity
                    {
                        double H = 0, L = 0, S = 0;
                        BaseTools.RGBtoHLS(rgb, out H, out L, out S);

                        // calculate L value
                        int cmax = Math.Max(rgb123[0], Math.Max(rgb123[1], rgb123[2]));
                        int cmin = Math.Min(rgb123[0], Math.Min(rgb123[1], rgb123[2]));
                        L = (cmax + cmin) / 2.0 / 255.0;
                        rgb = BaseTools.HLStoRGB(H, L, S);
                    }
                    src.Set<Vec3b>(k, m, rgb);
                }
            }
            return src;
        }

        /// <summary>
        /// 阴影校正
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat ShadingCorrection(Mat src)
        {
            if (src.Channels() == 1)
                return src;
            Mat temp = null, Ag = null, A0 = null, Aglp = null, dst = null;
            try
            {
                src.ConvertTo(src, MatType.CV_32FC3);
                temp = src.CvtColor(ColorConversionCodes.BGR2YCrCb);

                Mat[] tempArr = temp.Split();
                Ag = new Mat();
                tempArr[0].CopyTo(Ag); ;

                A0 = new Mat();
                Ag.CopyTo(A0);

                Aglp = BaseTools.ImageSmoothIIR(Ag, 0.99);
                tempArr[0] = A0 - Aglp + Cv2.Mean(Aglp);

                dst = new Mat();
                Cv2.Merge(tempArr, dst);

                dst = dst.CvtColor(ColorConversionCodes.YCrCb2BGR);
                dst.ConvertTo(dst, MatType.CV_8UC3);
                dst.CopyTo(src);
                return src;
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (temp != null) temp.Dispose();
                if (Ag != null) Ag.Dispose();
                if (A0 != null) A0.Dispose();
                if (Aglp != null) Aglp.Dispose();
                if (dst != null) dst.Dispose();
                GC.Collect();
            }
        }

        /// <summary>
        /// //调节图像的色相、饱和度、/*亮*/明度(明度)
        /// HSL空间图像亮度、饱和度调节 https://blog.csdn.net/feilong_csdn/article/details/82755816?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase
        /// </summary>
        /// <param name="src1"></param>
        /// <param name="dH"></param>
        /// <param name="dS"></param>
        /// <param name="dV"></param>
        public static bool AddHSV(Mat src1, double dH, double dS, double dV)
        {
            bool bResult = false;
            dH *= 0.9;//根据PS效果图调试值，待确认
            //dS *= 2.55;//根据PS效果图调试值，待确认
            //dV *= 2.55;//根据PS效果图调试值，待确认
            //phaseTemp1 = new Mat(src.Size(), src.Type());  //创建一个和原图像大小相同，类型相同，像素值为0的图像。
            phaseTemp1 = src1.CvtColor(ColorConversionCodes.BGR2HLS/*BGR2HSV*/);
            int height = phaseTemp1.Height;
            int width = phaseTemp1.Width;
            int channels = phaseTemp1.Channels();
            //contrast = (contrast - 1.0) / 2.0 + 1.0;//待确认参数范围
            //if (channels == 3 || channels == 4)     //如果是彩色图像
            //{
            //    src.ForEachAsVec3b(ForeachFunctionByteForBCGTransferMultiChannel);
            //}
            //else if (channels == 1)  //灰度图像
            //{
            //    src.ForEachAsDouble(ForeachFunctionByteForBCGTransferOneChannel);//ForEachAsByte
            //}
            ////src.ConvertTo(phaseTemp1, -1, contrast, brightness);
            //////phaseTemp1 = src.ConvertScaleAbs((brightness + 100) / 100.0, (1.0 - contrast) * 50);
            //////Cv2.Normalize(phaseTemp1, phaseTemp1, 1, 255, NormTypes.MinMax);

            //对每个像素点的操作
            for (int i = 0; i < height; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    if (channels == 3 || channels == 4)     //如果是彩色图像
                    {
                        double v0 = (phaseTemp1.At<Vec3b>(i, j)[0]) + dH;
                        double v2 = (phaseTemp1.At<Vec3b>(i, j)[2]) + dS;
                        double v1 = (phaseTemp1.At<Vec3b>(i, j)[1]) + dV;
                        if (v0 > 180) v0 -= 180;
                        else if (v0 < 0) v0 += 180;
                        if (v1 > 255) v1 = 255;
                        else if (v1 < 0) v1 = 0;
                        if (v2 > 255) v2 = 255;
                        else if (v2 < 0) v2 = 0;

                        Vec3b vec = new Vec3b();
                        vec[0] = (byte)v0;
                        vec[1] = (byte)v1;
                        vec[2] = (byte)v2;
                        phaseTemp1.Set<Vec3b>(i, j, vec);
                    }
                    else if (channels == 1)  //灰度图像
                    {
                        double v = contrast * (phaseTemp1.At<byte>(i, j)) + brightness;
                        if (v > 255) v = 255;
                        if (v < 0) v = 0;
                        phaseTemp1.Set<double>(i, j, v);
                    }
                }
            }
            phaseTemp1 = phaseTemp1.CvtColor(ColorConversionCodes.HLS2BGR/*HSV2BGR*/);

            return bResult;
        }

        /// <summary>
        /// 色度/饱和度/亮度
        /// gmip有源码，效果差不多，回头考虑换还是不换
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat BshTransferFunction(Mat src, List<Args> lists)
        {
            ImageMagick.MagickImage image = null;

            try
            {
                image = new ImageMagick.MagickImage(OpenCvSharp.Extensions.BitmapConverter.ToBitmap(src));
                //参数读取
                ImageMagick.Percentage brightness = new ImageMagick.Percentage(0);
                ImageMagick.Percentage saturation = new ImageMagick.Percentage(0);
                ImageMagick.Percentage hue = new ImageMagick.Percentage(0);
                double dH = 0;
                double dS = 0;
                double dV = 0;
                for (int i = 0; i < lists.Count; i++)
                {
                    Args args = lists[i];
                    switch (args.Key)
                    {
                        case "Hue":
                            double hueNum = 0;
                            if (double.TryParse(args.Value.ToString(), out hueNum))
                            {
                                hue = new ImageMagick.Percentage(hueNum);
                                dH = hueNum - 100.0;
                            }
                            break;
                        case "Saturation":
                            double saturationNum = 0;
                            if (double.TryParse(args.Value.ToString(), out saturationNum))
                            {
                                saturation = new ImageMagick.Percentage(saturationNum);
                                dS = saturationNum - 100.0;
                            }
                            break;
                        case "Brightness":
                            double brightnessNum = 0;
                            if (double.TryParse(args.Value.ToString(), out brightnessNum))
                            {
                                brightness = new ImageMagick.Percentage(brightnessNum);
                                dV = brightnessNum - 100.0;
                            }
                            break;

                        default:
                            break;
                    }
                }
                //image.Modulate(brightness, saturation, hue);
                AddHSV(src, dH, dS, dV);
                phaseTemp1.CopyTo(src);
                return src;
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (image != null) image.Dispose();
                if (phaseTemp1 != null && !phaseTemp1.IsDisposed) phaseTemp1.Dispose();
                GC.Collect();
            }
        }
        private static void ForeachFunctionByteForBCGTransferMultiChannel(Vec3b* value, int* position)
        {
            int y = position[0];
            int x = position[1];
            double v0 = contrast * (value->Item0 - 128.0) + 128.0 + brightness;
            double v1 = contrast * (value->Item1 - 128.0) + 128.0 + brightness;
            double v2 = contrast * (value->Item2 - 128.0) + 128.0 + brightness;
            if (v0 > 255) v0 = 255;
            else if (v0 < 0) v0 = 0;
            if (v1 > 255) v1 = 255;
            else if (v1 < 0) v1 = 0;
            if (v2 > 255) v2 = 255;
            else if (v2 < 0) v2 = 0;

            Vec3b vec = new Vec3b();
            vec[0] = (byte)v0;
            vec[1] = (byte)v1;
            vec[2] = (byte)v2;
            phaseTemp1.Set<Vec3b>(y, x, vec);
        }
        private static void ForeachFunctionByteForBCGTransferOneChannel(double* value, int* position)
        {
            int y = position[0];
            int x = position[1];
            double v = contrast * (*value - 128.0) + 128.0 + brightness;
            if (v > 255) v = 255;
            else if (v < 0) v = 0;
            phaseTemp1.Set<double>(y, x, v);
        }

        /// <summary>
        /// 亮度/对比度/伽马值
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat BCGTransferFunction(Mat src, List<Args> lists)
        {
            bool isFourChannels = false;
            if (src.Channels() == 4)
            {
                Cv2.CvtColor(src, src, OpenCvSharp.ColorConversionCodes.BGRA2BGR);
                isFourChannels = true;
            }

            phaseTemp1 = new Mat(src.Size(), src.Type());  //创建一个和原图像大小相同，类型相同，像素值为0的图像。
            Mat imageGamma = null;
            try
            {
                // 需要确定这个范围，可能可以定义
                //double contrast = 1.5;        //对比度 contrast Enter the alpha value [1.0-3.0]:  
                //double brightness = 50;       //亮度 brightness Enter the beta value [0-100]
                double gamma = 5;            //伽马值 gamma

                for (int i = 0; i < lists.Count; i++)
                {
                    Args args = lists[i];
                    switch (args.Key)
                    {
                        case "Brightness":
                            double.TryParse(args.Value.ToString(), out brightness);
                            break;
                        case "Contrast":
                            double.TryParse(args.Value.ToString(), out contrast);
                            break;
                        case "Gamma":
                            double.TryParse(args.Value.ToString(), out gamma);
                            break;

                        default:
                            break;
                    }
                }

                //int height = src.Height;
                //int width = src.Width;
                int channels = src.Channels();
                contrast = (contrast - 1.0) / 2.0 + 1.0;//待确认参数范围
                if (channels == 3 || channels == 4)     //如果是彩色图像
                {
                    src.ForEachAsVec3b(ForeachFunctionByteForBCGTransferMultiChannel);
                }
                else if (channels == 1)  //灰度图像
                {
                    src.ForEachAsDouble(ForeachFunctionByteForBCGTransferOneChannel);//ForEachAsByte
                }

                //对每个像素点的操作
                //for (int i = 0; i < height; i++)
                //{
                //    for (int j = 0; j < width; j++)
                //    {
                //        if (channels == 3 || channels == 4)     //如果是彩色图像
                //        {
                //            double v0 = contrast * (src.At<Vec3b>(i, j)[0]) + brightness;
                //            double v1 = contrast * (src.At<Vec3b>(i, j)[1]) + brightness;
                //            double v2 = contrast * (src.At<Vec3b>(i, j)[2]) + brightness;
                //            if (v0 > 255) v0 = 255;
                //            if (v0 < 0) v0 = 0;
                //            if (v1 > 255) v1 = 255;
                //            if (v1 < 0) v1 = 0;
                //            if (v2 > 255) v2 = 255;
                //            if (v2 < 0) v2 = 0;

                //            Vec3b vec = new Vec3b();
                //            vec[0] = (byte)v0;
                //            vec[1] = (byte)v1;
                //            vec[2] = (byte)v2;
                //            phaseTemp1.Set<Vec3b>(i, j, vec);
                //        }
                //        else if (channels == 1)  //灰度图像
                //        {
                //            double v = contrast * (src.At<byte>(i, j)) + brightness;
                //            if (v > 255) v = 255;
                //            if (v < 0) v = 0;
                //            phaseTemp1.Set<double>(i, j, v);
                //        }
                //    }
                //}

                imageGamma = new Mat();
                //灰度归一化
                phaseTemp1.ConvertTo(imageGamma, MatType.CV_64F, 1.0 / 255, 0);
                Cv2.Pow(imageGamma, gamma, imageGamma);//dist 要与imageGamma有相同的数据类型
                imageGamma.ConvertTo(imageGamma, MatType.CV_8U, 255, 0);
                //return imageGamma;
                imageGamma.CopyTo(phaseTemp1);
                phaseTemp1.CopyTo(src);

                if (isFourChannels)
                {
                    Cv2.CvtColor(src, src, OpenCvSharp.ColorConversionCodes.BGR2BGRA);
                }

                return src;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                //if (dst != null) dst.Dispose();
                if (imageGamma != null) imageGamma.Dispose();
                if (phaseTemp1 != null && !phaseTemp1.IsDisposed) phaseTemp1.Dispose();
                GC.Collect();
            }
        }

        /// <summary>
        /// 获取图像的局部均值与局部标准差的图
        /// https://blog.csdn.net/u013921430/article/details/83865427
        /// </summary>
        /// <param name="src"></param>
        /// <param name="meansDst"></param>
        /// <param name="varianceDst"></param>
        /// <param name="winSize"></param>
        /// <returns></returns>
        public static bool getVarianceMean(Mat src/*, Mat meansDst, Mat varianceDst*/, int winSize)
        {
            System.Diagnostics.Debug.Assert(winSize % 2 == 1);
            int copyBorderSize = (winSize - 1) / 2;
            //扩充图像边界；
            Mat copyBorder_yChannels = src.CopyMakeBorder(copyBorderSize, copyBorderSize, copyBorderSize, copyBorderSize, BorderTypes.Replicate/*Reflect*/);

            for (int i = 0; i < src.Rows; i++)
            {
                for (int j = 0; j < src.Cols; j++)
                {
                    //Rect rect = new Rect(j, i, winSize, winSize);
                    Mat temp = new Mat(copyBorder_yChannels, new Rect(j, i, winSize, winSize));
                    //Mat temp = copyBorder_yChannels.Clone(rect);   //截取扩展后的图像中的一个方块；

                    Mat mean = new Mat();
                    Mat dev = new Mat();
                    Cv2.MeanStdDev(temp, mean, dev);
                    localVarianceMatrix.Set(i, j, dev.At<double>(0, 0));
                    localMeansMatrix.Set(i, j, mean.At<double>(0, 0));
                }
            }

            return true;
        }

        /// <summary>
        /// 获取图像的局部均值与局部标准差对的图
        /// </summary>
        /// <param name="mat">源图像</param>
        /// <param name="kernel">边径长度</param>
        /// <param name="threshold">阈值</param>
        /// <returns></returns>
        public static bool adaptEdgeEnhancement(Mat mat, int kernel, int threshold)
        {
            localThreshold = threshold;
            dstWidth = mat.Width;
            dstChannel = mat.Channels();
            phaseTemp1 = mat.Clone();
            calMats = mat.Clone();

            //求最大值最小值
            Mat element = Cv2.GetStructuringElement(MorphShapes.Rect, new OpenCvSharp.Size(kernel, kernel));
            //腐蚀
            phaseTempMin = new Mat();
            Cv2.Erode(mat, phaseTempMin, element, null, 1, BorderTypes.Constant);
            //膨胀
            phaseTempMax = new Mat();
            Cv2.Dilate(mat, phaseTempMax, element, null, 1, BorderTypes.Constant);
            Mat f = new Mat();
            Cv2.Subtract(phaseTempMax, phaseTempMin, f);
            //实现边界增强
            f.ForEachAsVec4b(ForeachFunctionVeb4ForThreshold);

            return true;
        }

        private static void ForeachFunctionVeb4ForThreshold(Vec4b* value, int* position)
        {
            ////对每个像素点的操作
            byte* pixels3 = (byte*)phaseTempMax.Data;
            byte* pixels4 = (byte*)phaseTempMin.Data;
            byte* pixels5 = (byte*)calMats.Data;
            int offset = (position[0] * dstWidth + position[1]) * dstChannel;
            Vec4b aa = new Vec4b(pixels5[offset], pixels5[offset + 1], pixels5[offset + 2], 255);
            bool toedit = false;
            if (value->Item0 > localThreshold)
            {
                toedit = true;
                byte ff = pixels3[offset];
                byte pp = pixels4[offset];
                if ((ff + pp) / 2 < aa.Item0)
                    aa.Item0 = ff;
                else
                    aa.Item0 = pp;
            }
            if (value->Item1 > localThreshold)
            {
                toedit = true;
                byte ff = pixels3[offset + 1];
                byte pp = pixels4[offset + 1];
                if ((ff + pp) / 2 < aa.Item1)
                    aa.Item1 = ff;
                else
                    aa.Item1 = pp;
            }
            if (value->Item2 > localThreshold)
            {
                toedit = true;
                byte ff = pixels3[offset + 2];
                byte pp = pixels4[offset + 2];
                if ((ff + pp) / 2 < aa.Item2)
                    aa.Item2 = ff;
                else
                    aa.Item2 = pp;
            }
            if (toedit)
                phaseTemp1.Set(position[0], position[1], aa);
        }

        /// <summary>
        /// 获取图像的局部均值与局部标准差对的图
        /// </summary>
        /// <param name="src"></param>
        /// <param name="winSize"></param>
        /// <param name="maxCg"></param>
        /// <returns></returns>
        public static bool adaptContrastEnhancement(Mat src, int winSize, int maxCg)
        {
            bool bResult = false;
            Mat ycc = src.CvtColor(ColorConversionCodes.BGR2YUV/*BGR2YCrCb*/);//转换空间到YCrCb
            Mat[] channels = Cv2.Split(ycc);//分离通道

            localMeansMatrix = new Mat(src.Rows, src.Cols, MatType.CV_64F);
            localVarianceMatrix = new Mat(src.Rows, src.Cols, MatType.CV_64F);
            if (!getVarianceMean(channels[0], winSize))//对Y通道进行增强
            {
                //phaseTemp1 = ycc.CvtColor(ColorConversionCodes.YUV2BGR/*YCrCb2BGR*/);
                return false;
            }
            Mat temp = channels[0].Clone();

            //Mat mean = new Mat();
            //Mat dev1 = new Mat();
            //Cv2.MeanStdDev(temp, mean, dev1);

            double meansGlobal = Cv2.Mean(channels[0])[0];// mean.At<Vec4b>(0, 0)[0];
            //for (int i = 0; i < mean.Rows; i++)
            //{
            //    for (int j = 0; j < mean.Cols; j++)
            //    {
            //        meansGlobal += mean.At<Vec4b>(i, j)[0];
            //    }
            //}
            Mat enhanceMatrix = new Mat(src.Rows, src.Cols, MatType.CV_8UC1);
            for (int i = 0; i < src.Rows; i++)            //遍历，对每个点进行自适应调节
            {
                for (int j = 0; j < src.Cols; j++)
                {
                    //if (localVarianceMatrix.At<float>(i, j) >= 0.01)
                    //{
                    double cg = (double)(/*1.0*/0.2 * meansGlobal / localVarianceMatrix.At<double>(i, j));
                    double cgs = cg > maxCg ? maxCg : cg;
                    cgs = cgs < 1 ? 1 : cgs;
                    if (localVarianceMatrix.At<double>(i, j) == 0)
                    {
                        cgs = maxCg;
                    }

                    int channel1 = temp.Channels();
                    int row1 = temp.Rows;
                    int col1 = temp.Cols;

                    //cgs = 1.0;
                    double mean1 = localMeansMatrix.At<double>(i, j);
                    byte temp1 = temp.At<byte>(i, j);

                    int e = (int)(localMeansMatrix.At<double>(i, j) + cgs * (temp.At<byte>(i, j) - localMeansMatrix.At<double>(i, j)));// cgs * (temp.At<double>(i, j)) + (localMeansMatrix.At<double>(i, j)) * (1.0 - cgs);// (double)(localMeansMatrix.At<double>(i, j)/*localMeansMatrix.At<double>(i, j)*/ + 1.0/*cgs*/ * (channels[0].At<double/*uchar*/>(i, j) - localMeansMatrix.At<double>(i, j)/*localMeansMatrix.At<double>(i, j)*/));
                    if (e > 255) { e = 255; }
                    else if (e < 0) { e = 0; }
                    enhanceMatrix.Set<byte>(i, j, (byte)e);
                    //enhanceMatrix.At<byte/*uchar*/>(i, j) = e;
                    //}
                    //else
                    //{
                    //    enhanceMatrix.Set<byte>(i, j, temp.At<byte/*uchar*/>(i, j));
                    //    //enhanceMatrix.At<byte/*uchar*/>(i, j) = temp.at<uchar>(i, j);
                    //}
                }
            }
            channels[0] = enhanceMatrix;
            Cv2.Merge(channels, ycc);
            phaseTemp1 = ycc.CvtColor(ColorConversionCodes.YUV2BGR/*YCrCb2BGR*/);

            //dH *= 0.9;//根据PS效果图调试值，待确认
            ////dS *= 2.55;//根据PS效果图调试值，待确认
            ////dV *= 2.55;//根据PS效果图调试值，待确认
            ////phaseTemp1 = new Mat(src.Size(), src.Type());  //创建一个和原图像大小相同，类型相同，像素值为0的图像。
            //phaseTemp1 = src1.CvtColor(ColorConversionCodes.BGR2HSV);
            //int height = phaseTemp1.Height;
            //int width = phaseTemp1.Width;
            //int channels = phaseTemp1.Channels();
            ////contrast = (contrast - 1.0) / 2.0 + 1.0;//待确认参数范围
            ////if (channels == 3 || channels == 4)     //如果是彩色图像
            ////{
            ////    src.ForEachAsVec3b(ForeachFunctionByteForBCGTransferMultiChannel);
            ////}
            ////else if (channels == 1)  //灰度图像
            ////{
            ////    src.ForEachAsDouble(ForeachFunctionByteForBCGTransferOneChannel);//ForEachAsByte
            ////}
            //////src.ConvertTo(phaseTemp1, -1, contrast, brightness);
            ////////phaseTemp1 = src.ConvertScaleAbs((brightness + 100) / 100.0, (1.0 - contrast) * 50);
            ////////Cv2.Normalize(phaseTemp1, phaseTemp1, 1, 255, NormTypes.MinMax);

            ////对每个像素点的操作
            //for (int i = 0; i < height; i++)
            //{
            //    for (int j = 0; j < width; j++)
            //    {
            //        if (channels == 3 || channels == 4)     //如果是彩色图像
            //        {
            //            double v0 = (phaseTemp1.At<Vec3b>(i, j)[0]) + dH;
            //            double v1 = (phaseTemp1.At<Vec3b>(i, j)[1]) + dS;
            //            double v2 = (phaseTemp1.At<Vec3b>(i, j)[2]) + dV;
            //            if (v0 > 180) v0 -= 180;
            //            else if (v0 < 0) v0 += 180;
            //            if (v1 > 255) v1 = 255;
            //            else if (v1 < 0) v1 = 0;
            //            if (v2 > 255) v2 = 255;
            //            else if (v2 < 0) v2 = 0;

            //            Vec3b vec = new Vec3b();
            //            vec[0] = (byte)v0;
            //            vec[1] = (byte)v1;
            //            vec[2] = (byte)v2;
            //            phaseTemp1.Set<Vec3b>(i, j, vec);
            //        }
            //        else if (channels == 1)  //灰度图像
            //        {
            //            double v = contrast * (phaseTemp1.At<byte>(i, j)) + brightness;
            //            if (v > 255) v = 255;
            //            if (v < 0) v = 0;
            //            phaseTemp1.Set<double>(i, j, v);
            //        }
            //    }
            //}
            //phaseTemp1 = phaseTemp1.CvtColor(ColorConversionCodes.HSV2BGR);

            return bResult;
        }

        /// <summary>
        /// 描绘
        /// 目前用的是ImageMagick的局部对比度增强
        /// 网上有opencv自适应局部对比度增强算法，回头看情况换不换
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat PortrayFunction(Mat src, List<Args> lists)
        {
            ImageMagick.MagickImage image = null;
            try
            {
                image = new ImageMagick.MagickImage(OpenCvSharp.Extensions.BitmapConverter.ToBitmap(src));
                //参数读取
                ImageMagick.Percentage hue = new ImageMagick.Percentage(0);
                double radius = 49;
                for (int i = 0; i < lists.Count; i++)
                {
                    Args args = lists[i];
                    switch (args.Key)
                    {
                        case "Threshold":
                            double hueNum = 0;
                            if (double.TryParse(args.Value.ToString(), out hueNum))
                            {
                                hue = new ImageMagick.Percentage(hueNum);
                            }
                            break;
                        case "Size":
                            double sizeNum = 0;
                            if (double.TryParse(args.Value.ToString(), out sizeNum))
                            {
                                radius = sizeNum;
                            }
                            break;

                        default:
                            break;
                    }
                }
                adaptEdgeEnhancement(src, (int)/*15*/radius, (int)/*10*/hue);
                phaseTemp1.CopyTo(src);
                //image.LocalContrast(radius, hue);
                //OpenCvSharp.Extensions.BitmapConverter.ToMat(image.ToBitmap()).CopyTo(src);
                return src;
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (image != null) image.Dispose();
                if (phaseTemp1 != null && !phaseTemp1.IsDisposed) phaseTemp1.Dispose();
                if (calMats != null && !calMats.IsDisposed) calMats.Dispose();
                if (phaseTempMin != null && !phaseTempMin.IsDisposed) phaseTempMin.Dispose();
                if (phaseTempMax != null && !phaseTempMax.IsDisposed) phaseTempMax.Dispose();
                if (localMeansMatrix != null && !localMeansMatrix.IsDisposed) localMeansMatrix.Dispose();
                if (localVarianceMatrix != null && !localVarianceMatrix.IsDisposed) localVarianceMatrix.Dispose();
                GC.Collect();
            }
        }

        /// <summary>
        /// 加强轮廓
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat EnhanceContourFunction(Mat src, List<Args> lists)
        {
            Mat mat1 = null;
            Mat dst = null;
            Mat cc = null;
            try
            {
                int strength = 1;
                if (lists != null)
                {
                    for (int i = 0; i < lists.Count; i++)
                    {
                        Args args = lists[i];
                        switch (args.Key)
                        {
                            case "Strength":
                                strength = int.Parse(args.Value.ToString());
                                break;

                            default:
                                break;
                        }
                    }
                }
                else
                {
                    strength = 10;
                }

                mat1 = new Mat();
                src.ConvertTo(mat1, MatType.CV_32F);
                dst = new Mat();
                Cv2.Laplacian(src, dst, MatType.CV_32F, 1);

                for (int i = 0; i < dst.Height; i++)
                {
                    for (int j = 0; j < dst.Width; j++)
                    {
                        byte value = dst.At<byte>(i, j);
                        if (value > 255) value = 255;
                        if (value < 0) value = 0;
                        dst.Set<byte>(i, j, value);
                    }
                }

                cc = mat1 - dst * strength;
                cc.ConvertTo(cc, MatType.CV_8UC3);
                cc.CopyTo(src);
                return src;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (mat1 != null) mat1.Dispose();
                if (dst != null) dst.Dispose();
                if (cc != null) cc.Dispose();
            }
        }

        /// <summary>
        /// 虚化蒙版
        /// 是从下面的第三方库中的代码翻译过来的
        /// 库名：kaliko的图像处理库
        /// 源码：引入的第三方库\NetImageLibrary-master
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat BlurMaskFunction(Mat src, List<Args> lists)
        {
            Bitmap map = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(src);
            float radius = 3f;
            int threshold = 0;
            float amount = 3f;

            for (int i = 0; i < lists.Count; i++)
            {
                Args args = lists[i];
                switch (args.Key)
                {
                    case "Radius":
                        radius = float.Parse(args.Value.ToString()) * 3.14f;
                        break;
                    case "Amount":
                        amount = float.Parse(args.Value.ToString());
                        break;
                    case "Threshold":
                        threshold = int.Parse(args.Value.ToString());
                        break;

                    default:
                        break;
                }
            }

            //像素矩阵
            var inPixels = BaseTools.ByteArray(map);
            var workPixels = new int[inPixels.Length];
            var outPixels = new int[inPixels.Length];

            //半径
            if (radius > 0)
            {
                Kernel kernel = BaseTools.CreateKernel(radius);
                BaseTools.ConvolveAndTranspose(kernel, inPixels, workPixels, map.Width, map.Height, true, true, false, 1);
                BaseTools.ConvolveAndTranspose(kernel, workPixels, outPixels, map.Height, map.Width, true, false, true, 1);
            }

            for (int index = 0; index < inPixels.Length; index++)
            {
                int rgb1 = inPixels[index];
                int r1 = (rgb1 >> 16) & 0xff;
                int g1 = (rgb1 >> 8) & 0xff;
                int b1 = rgb1 & 0xff;

                int rgb2 = outPixels[index];
                int r2 = (rgb2 >> 16) & 0xff;
                int g2 = (rgb2 >> 8) & 0xff;
                int b2 = rgb2 & 0xff;

                if (Math.Abs(r1 - r2) >= threshold)
                {
                    r1 = (int)((amount + 1) * (r1 - r2) + r2);
                    if (r1 < 0) r1 = 0;
                    if (r1 > 255) r1 = 255;
                }
                if (Math.Abs(g1 - g2) >= threshold)
                {
                    g1 = (int)((amount + 1) * (g1 - g2) + g2);
                    if (g1 < 0) g1 = 0;
                    if (g1 > 255) g1 = 255;
                }
                if (Math.Abs(b1 - b2) >= threshold)
                {
                    b1 = (int)((amount + 1) * (b1 - b2) + b2);
                    if (b1 < 0) b1 = 0;
                    if (b1 > 255) b1 = 255;
                }

                inPixels[index] = (int)(rgb1 & 0xff000000) | (r1 << 16) | (g1 << 8) | b1;
            }

            var byteArray = new byte[inPixels.Length * 4];

            for (int i = 0; i < inPixels.Length; i++)
            {
                Array.Copy(BitConverter.GetBytes(inPixels[i]), 0, byteArray, i * 4, 4);
            }

            Bitmap Image = new Bitmap(map.Width, map.Height, PixelFormat.Format32bppArgb);
            var data = ((Bitmap)Image).LockBits(new Rectangle(0, 0, Image.Width, Image.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            if (data.Stride == Image.Width * 4)
            {
                Marshal.Copy(byteArray, 0, data.Scan0, byteArray.Length);
            }
            else
            {
                for (int i = 0, l = Image.Height; i < l; i++)
                {
                    var p = new IntPtr(data.Scan0.ToInt32() + data.Stride * i);
                    Marshal.Copy(byteArray, i * Image.Width * 4, p, Image.Width * 4);
                }
            }

            ((Bitmap)Image).UnlockBits(data);
            return OpenCvSharp.Extensions.BitmapConverter.ToMat((Bitmap)Image);
        }

        /// <summary>
        /// 实时图像拼接
        /// </summary>
        /// <param name="src"></param>
        /// <returns></returns>
        public static Mat RealTimeStitchingFunction(Mat src, List<Args> lists)
        {
            Mat dst = new Mat();
            Mat mat1 = new Mat();
            try
            {
                for (int i = 0; i < lists.Count; i++)
                {
                    Args args = lists[i];
                    switch (args.Key)
                    {
                        case "Src2":
                            mat1 = (Mat)args.Value;
                            break;

                        default:
                            break;
                    }
                }
                Boolean errorFlag = false;
                dst = MatchPicByXFeatures2D(new Mat[] { src, mat1 }, out errorFlag);
                //dst = MatchPicBySift(src, mat1);
                if (errorFlag)
                {
                    MessageBox.Show("Picture splicing failed");
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                src.CopyTo(dst);
            }
            finally
            {
                if (src != null) dst.CopyTo(src);
                if (dst != null) dst.Dispose();
            }
            return src;
        }

        /// <summary>
        /// 图像拼接方法，返回拼接好的mat
        /// </summary>
        /// <param name="matSrcs">需要拼接的mat集合</param>
        /// <param name="errorFlag">返回true表示拼接失败</param>
        /// <returns></returns>
        public static Mat MatchPicByXFeatures2D(Mat[] matSrcs, out Boolean errorFlag)
        {
            Mat mat = matSrcs[0].Clone();// (~(matSrcs[0].Clone().CvtColor(ColorConversionCodes.BGRA2BGR))).ToMat().CvtColor(ColorConversionCodes.BGR2BGRA);//
            errorFlag = false;//C:\Users\win10SSD\Desktop\工作目录\显微镜\图像拼接\Images0223\Images
            int totalMat = matSrcs.Length;
            int totalLen = matSrcs.Length;
            if (totalMat < 2)
            {
                return mat;
            }
            totalMat -= 1;
            int index = totalLen;
            List<int> failureIndex = new List<int>();
            List<int> finishIndex = new List<int>();
            do
            {
                index = Math.Max(1, (index + 1) % totalLen);
                if (finishIndex.Contains(index)) continue; //跳过拼接完成的图片
                try
                {
                    Mat mat1 = matSrcs[index];// (~(matSrcs[index].Clone().CvtColor(ColorConversionCodes.BGRA2BGR))).ToMat().CvtColor(ColorConversionCodes.BGR2BGRA);//
                    KeyPoint[] keyPointsSrc = new KeyPoint[0];
                    Mat matSrcRet = null;
                    KeyPoint[] keyPointsTo = new KeyPoint[0];
                    Mat matToRet = null;
                    int matCount = Math.Min(mat.Width * mat.Height, mat1.Width * mat1.Height);
                    int orbCount = matCount / 40000;
                    do
                    {
                        orbCount *= 10;
                        Mat resMat = MatchPicBySift(mat, mat1, out errorFlag, ref keyPointsSrc, ref matSrcRet,
                            ref keyPointsTo, ref matToRet, orbCount);
                        if (!errorFlag)
                        {
                            mat = resMat.Clone();
                            resMat.Dispose();
                        }
                    } while (orbCount <= matCount && errorFlag);
                    //mat = MatchPicBySift(mat, mat1);
                    if (errorFlag)
                    {
                        if (failureIndex.Contains(index)) break; //剩下一些无法拼接的图片后退出循环，避免程序卡死
                        failureIndex.Add(index);
                    }
                }
                catch (Exception)
                {
                    errorFlag = true;
                    if (failureIndex.Contains(index)) break; //剩下一些无法拼接的图片后退出循环，避免程序卡死
                    failureIndex.Add(index);
                }
                finally
                {
                    if (!failureIndex.Contains(index))
                    {
                        finishIndex.Add(index);
                        failureIndex.Clear();
                    }
                    GC.Collect();
                }
            } while (finishIndex.Count() < totalMat);
            return mat;
        }


        public static Mat MosaicsMat = null;
        public static System.Drawing.Point MosaicsMoveP;

        /// <summary>
        /// 图像拼接方法，返回拼接好的mat
        /// </summary>
        /// <param name="matSrcs">需要拼接的mat集合</param>
        /// <param name="colNum">列数</param>
        /// <param name="percent">拼接率</param>
        /// <param name="errorFlag">返回true表示拼接失败</param>
        /// <returns></returns>
        public static Mat MatchPicOneByOne2D(Mat[] matSrcs, int colNum, double percent, out Boolean errorFlag, bool usePercent = true)
        {
            if (MosaicsMat != null)
                MosaicsMat.Dispose();
            MosaicsMat = new Mat();
            MosaicsMoveP = new System.Drawing.Point(0, 0);

            //Mat mat = matSrcs[0].Clone();// (~(matSrcs[0].Clone().CvtColor(ColorConversionCodes.BGRA2BGR))).ToMat().CvtColor(ColorConversionCodes.BGR2BGRA);//
            errorFlag = false;//C:\Users\win10SSD\Desktop\工作目录\显微镜\图像拼接\Images0223\Images
            int totalMat = matSrcs.Length;
            int totalLen = matSrcs.Length;
            if (totalMat < 2)
            {
                return matSrcs[0].Clone();// mat;
            }
            totalMat -= 1;
            int moveindex = totalLen;
            List<System.Drawing.Point> movePoints = new List<System.Drawing.Point>();
            List<int> successIndex = new List<int>();
            List<int> failureIndex = new List<int>();
            List<int> finishIndex = new List<int>();

            int rowIndex = 0;//行数 Y方向
            int colIndex = 0;//列数 X方向
            //从1到3分别是右、下、左
            int directionRect = 1;

            do
            {
                //int index = totalLen;
                moveindex = Math.Max(1, (moveindex + 1) % totalLen);
                rowIndex = (int)(moveindex * 1.0 / colNum);// + ((moveindex + 1) % colNum > 0 ? 1 : 0);
                colIndex = moveindex % colNum;
                if (finishIndex.Contains(moveindex)) continue; //跳过拼接完成的图片
                try
                {
                    int index = moveindex;
                    int lastindex = index - 1;
                    directionRect = 1;
                    if (rowIndex % 2 == 1)
                    {
                        index = colNum * (rowIndex + 1) - colIndex - 1;
                        if (colIndex == 0)
                        {
                            lastindex = index - colNum;
                            directionRect = 2;
                        }
                        else
                        {
                            lastindex = index + 1;
                            directionRect = 3;
                        }
                    }
                    else if (colIndex == 0)
                    {
                        lastindex = index - colNum;
                        directionRect = 2;
                    }
                    Mat mat1 = matSrcs[index];// (~(matSrcs[index].Clone().CvtColor(ColorConversionCodes.BGRA2BGR))).ToMat().CvtColor(ColorConversionCodes.BGR2BGRA);//

                    int matCount = Math.Min(matSrcs[lastindex]/*mat*/.Width * matSrcs[lastindex]/*mat*/.Height, mat1.Width * mat1.Height);
                    int orbCount = matCount / 40000;
                    do
                    {
                        orbCount *= 10;
                        System.Drawing.Point moveP = MatchOneBySift(matSrcs[lastindex]/*mat*/, mat1, out errorFlag, orbCount, percent, directionRect, usePercent);
                        movePoints.Add(moveP);
                        errorFlag = false;
                        MosaicsMoveP.X += moveP.X;
                        MosaicsMoveP.Y += moveP.Y;
                        successIndex.Add(index);
                    } while (orbCount <= matCount && errorFlag);
                    if (errorFlag)
                    {
                        if (failureIndex.Contains(moveindex)) break; //剩下一些无法拼接的图片后退出循环，避免程序卡死
                        failureIndex.Add(moveindex);
                    }
                }
                catch (Exception)
                {
                    errorFlag = true;
                    if (failureIndex.Contains(moveindex)) break; //剩下一些无法拼接的图片后退出循环，避免程序卡死
                    failureIndex.Add(moveindex);
                }
                finally
                {
                    if (!failureIndex.Contains(moveindex))
                    {
                        finishIndex.Add(moveindex);
                        failureIndex.Clear();
                    }
                    GC.Collect();
                }
            } while (finishIndex.Count() < totalMat);
            if (errorFlag)
            {
                return matSrcs[0].Clone();// mat;
            }

            System.Drawing.Point mat0Point;
            OpenCvSharp.Size outMatSize = GetNewSize(movePoints, matSrcs, successIndex, colNum, out mat0Point);
            Mat outMat = new Mat(outMatSize, MatType.CV_8UC4);

            var matSrc = matSrcs[0];
            Mat posSrc = new Mat(outMat, new Rect(mat0Point.X, mat0Point.Y, matSrc.Width, matSrc.Height));

            //Rect roi_rect = new Rect(mat0Point.X, mat0Point.Y, matSrc.Width, matSrc.Height);
            matSrc.CopyTo(posSrc/*outMat.AdjustROI(mat0Point.X, mat0Point.Y, matSrc.Width, matSrc.Height)*/);

            //Mat maskSrc = new Mat(outMatSize, MatType.CV_8UC1, Scalar.All(0));
            //for (int i = 0; i < matSrc.Width; i++)
            //{
            //    for (int j = 0; j < matSrc.Height; j++)
            //    {
            //        maskSrc.Set<Byte>(j, i, 1);
            //    }
            //}
            //matSrc.CopyTo(outMat, maskSrc/*, maskSrc*//*.CvtColor(ColorConversionCodes.BGRA2GRAY)*/);//原图像复制到新图像

            System.Drawing.Point movePoint = new System.Drawing.Point(mat0Point.X, mat0Point.Y);
            for (int indexP = 0; indexP < movePoints.Count; indexP++)
            {
                int aver_X = movePoints[indexP].X;
                int aver_Y = movePoints[indexP].Y;

                movePoint.X += (int)aver_X;
                if (successIndex[indexP] % (colNum * 2) == 0)
                {
                    movePoint.X = (int)aver_X;
                }
                movePoint.Y += (int)aver_Y;

                aver_X = movePoint.X;
                aver_Y = movePoint.Y;
                int newOriX = 0;
                int newOriY = 0;
                var matTo = matSrcs[successIndex[indexP]];

                //得到变换矩阵后拼接图像
                if (aver_X > 0)
                    newOriX = (int)aver_X;
                if (aver_Y > 0)
                    newOriY = (int)aver_Y;

                if (newOriX + matTo.Width > outMat.Width || newOriY + matTo.Height > outMat.Height)
                {
                    errorFlag = true;
                    return matSrcs[0].Clone();// mat;
                }

                Mat pos = new Mat(outMat, new Rect(newOriX, newOriY, matTo.Width, matTo.Height));
                OptimizeSeam(pos, matTo);
                matTo.CopyTo(pos/*, mask*//*.CvtColor(ColorConversionCodes.BGRA2GRAY)*/);//原图像复制到新图像

                //pos.Dispose();
                GC.Collect();
            }

            return outMat;
        }

        public unsafe static void OptimizeSeam(Mat matBig, Mat matNew)
        {
            //判断上边沿宽度 
            int i, j;
            Mat mat;
            Mat mean = new Mat();
            Mat std = new Mat();
            for (i = 0; i < 100; i++)
            {
                mat = new Mat(matBig, new Rect(100, i, matBig.Width - 200, 1));
                mat.MeanStdDev(mean, std);
                if (std.At<double>(0) == 0)
                    break;
            }
            if (i > 0)
            {
                OptimizeSeamTop(matNew, matBig, i);
            }

            //判断右边沿宽度
            for (j = 0; j < 100; j++)
            {
                mat = new Mat(matBig, new Rect(j, 100, 1, matBig.Height - 200));
                mat.MeanStdDev(mean, std);
                if (std.At<double>(0) == 0)
                    break;
            }
            if (j > 0)
            {
                OptimizeSeamLeft(matNew, matBig, j);
            }

            //判断左边沿宽度
            for (j = 0; j < 100; j++)
            {
                mat = new Mat(matBig, new Rect(matBig.Width - j - 1, 100, 1, matBig.Height - 200));
                mat.MeanStdDev(mean, std);
                if (std.At<double>(0) == 0)
                    break;
            }
            if (j > 0)
            {
                OptimizeSeamRight(matNew, matBig, j);
            }

            for (i = 0; i < 100; i++)
            {
                mat = new Mat(matBig, new Rect(100, matBig.Height - i - 1, matBig.Width - 200, 1));
                mat.MeanStdDev(mean, std);
                if (std.At<double>(0) == 0)
                    break;
            }
            if (i > 0)
            {
                OptimizeSeamBottom(matNew, matBig, i);
            }

        }

        public unsafe static void OptimizeSeamLeft(Mat m1, Mat m2, int thickness)
        {
            int ch = m1.Channels();

            for (int i = 0; i < m2.Height; i++)
            {
                var p1 = (byte*)m1.Ptr(i);
                var p2 = (byte*)m2.Ptr(i);
                for (int j = 0; j < thickness; j++)
                {
                    double a = (j + 1.0) / (thickness + 1.0);
                    int j1 = j * ch;
                    if ((p2[j1] + p2[j1 + 1] + p2[j1 + 2]) == 0)
                        continue;
                    p1[j1] = (byte)(p1[j1] * a + p2[j1] * (1 - a));
                    p1[j1 + 1] = (byte)(p1[j1 + 1] * a + p2[j1 + 1] * (1 - a));
                    p1[j1 + 2] = (byte)(p1[j1 + 2] * a + p2[j1 + 2] * (1 - a));
                }
            }
        }

        public unsafe static void OptimizeSeamRight(Mat m1, Mat m2, int thickness)
        {
            int ch = m1.Channels();
            for (int i = 0; i < m1.Height; i++)
            {
                var p1 = (byte*)m1.Ptr(i);
                var p2 = (byte*)m2.Ptr(i);
                for (int j = 1; j < thickness + 1; j++)
                {
                    double a = j / (thickness + 1.0);
                    var j1 = (m2.Width - j) * ch;
                    if ((p2[j1] + p2[j1 + 1] + p2[j1 + 2]) == 0)
                        continue;
                    p1[j1] = (byte)(p1[j1] * a + p2[j1] * (1 - a));
                    p1[j1 + 1] = (byte)(p1[j1 + 1] * a + p2[j1 + 1] * (1 - a));
                    p1[j1 + 2] = (byte)(p1[j1 + 2] * a + p2[j1 + 2] * (1 - a));
                }
            }
        }

        public unsafe static void OptimizeSeamTop(Mat m1, Mat m2, int thickness)
        {
            int ch = m1.Channels();
            for (int i = 0; i < thickness; i++)
            {
                var p1 = (byte*)m1.Ptr(i);
                var p2 = (byte*)m2.Ptr(i);
                double a = (i + 1.0) / (thickness + 1.0);
                for (int j = 0; j < m1.Width; j++)
                {
                    int j1 = j * ch;
                    int j2 = j * ch;
                    if ((p2[j1] + p2[j1 + 1] + p2[j1 + 2]) == 0)
                        continue;
                    p1[j1] = (byte)(p1[j1] * a + p2[j2] * (1 - a));
                    p1[j1 + 1] = (byte)(p1[j1 + 1] * a + p2[j2 + 1] * (1 - a));
                    p1[j1 + 2] = (byte)(p1[j1 + 2] * a + p2[j2 + 2] * (1 - a));
                }
            }
        }

        public unsafe static void OptimizeSeamBottom(Mat m1, Mat m2, int thickness)
        {
            int ch = m1.Channels();
            for (int i = 0; i < thickness; i++)
            {
                var p1 = (byte*)m1.Ptr(m1.Height - i - 1);
                var p2 = (byte*)m2.Ptr(m2.Height - i - 1);
                double a = (i + 1.0) / (thickness + 1.0);
                for (int j = 0; j < m1.Width; j++)
                {
                    int j1 = j * ch;
                    int j2 = j * ch;
                    if ((p2[j1] + p2[j1 + 1] + p2[j1 + 2]) == 0)
                        continue;
                    p1[j1] = (byte)(p1[j1] * a + p2[j2] * (1 - a));
                    p1[j1 + 1] = (byte)(p1[j1 + 1] * a + p2[j2 + 1] * (1 - a));
                    p1[j1 + 2] = (byte)(p1[j1 + 2] * a + p2[j2 + 2] * (1 - a));
                }
            }
        }

        public static OpenCvSharp.Size GetNewSize(List<System.Drawing.Point> movePoints, Mat[] matSrcs, List<int> successIndex, int colNum, out System.Drawing.Point mat0Point)
        {
            mat0Point = new System.Drawing.Point(0, 0);
            OpenCvSharp.Size newSize = new OpenCvSharp.Size(matSrcs[0].Width, matSrcs[0].Height);
            System.Drawing.Point movePoint = new System.Drawing.Point(0, 0);
            for (int indexP = 0; indexP < movePoints.Count; indexP++)
            {
                int aver_X = movePoints[indexP].X;
                int aver_Y = movePoints[indexP].Y;

                movePoint.X += (int)aver_X;
                if (successIndex[indexP] % (colNum * 2) == 0)
                {
                    movePoint.X = (int)aver_X;
                }
                movePoint.Y += (int)aver_Y;

                aver_X = movePoint.X;
                aver_Y = movePoint.Y;

                var matTo = matSrcs[successIndex[indexP]];

                //得到变换矩阵后拼接图像
                int newWidth = newSize.Width;
                int newHeight = newSize.Height;
                if (aver_X <= 0)
                {
                    newWidth = (int)(newWidth - aver_X);
                    mat0Point.X += (int)(-aver_X);
                }
                else
                {
                    if (matTo.Width + aver_X > newWidth)
                        newWidth = (int)(matTo.Width + aver_X);
                }
                if (aver_Y <= 0)
                {
                    newHeight = (int)(newHeight - aver_Y);
                    mat0Point.Y += (int)(-aver_Y);
                }
                else
                {
                    if (matTo.Height + aver_Y > newHeight)
                        newHeight = (int)(matTo.Height + aver_Y);
                }

                newSize = new OpenCvSharp.Size(newWidth, newHeight);

            }
            return newSize;
        }

        /// <summary>
        /// 图像拼接方法，返回拼接好的mat
        /// </summary>
        /// <param name="matSrc">需要拼接的mat1</param>
        /// <param name="matTo">需要拼接的mat2</param>
        /// <param name="errorFlag">返回true表示拼接失败</param>
        /// <returns></returns>
        public static Mat MatchPicBySift(Mat matSrc, Mat matTo, out Boolean errorFlag)
        {
            errorFlag = false;
            Mat mat = matSrc.Clone();
            try
            {
                mat = MatchPicBySift(matSrc, matTo);
            }
            catch (Exception)
            {
                errorFlag = true;
            }
            return mat;
        }
        /// <summary>
        /// 图像拼接方法，返回拼接好的mat
        /// </summary>
        /// <param name="matSrc">需要拼接的mat1</param>
        /// <param name="matTo">需要拼接的mat2</param>
        /// <returns></returns>
        public static Mat MatchPicBySift(Mat matSrc, Mat matTo)
        {
            using (Mat matSrcRet = new Mat())
            using (Mat matToRet = new Mat())
            {
                KeyPoint[] keyPointsSrc, keyPointsTo;
                //using (var surf = OpenCvSharp.XFeatures2D.SURF.Create(800/*2000*/))
                using (var surf = OpenCvSharp.ORB.Create(800))
                //using (var sift = OpenCvSharp.XFeatures2D.SIFT.Create(2000))//var sift = OpenCvSharp.XFeatures2D.SIFT.Create()
                {
                    surf.DetectAndCompute(matSrc, null, out keyPointsSrc, matSrcRet);
                    surf.DetectAndCompute(matTo, null, out keyPointsTo, matToRet);
                }
                using (var bfMatcher = new OpenCvSharp.BFMatcher())//FlannBasedMatcher
                {
                    var matches = bfMatcher.KnnMatch(matSrcRet, matToRet, k: 2);

                    var pointsSrc = new List<Point2f>();
                    var pointsDst = new List<Point2f>();
                    var goodMatches = new List<DMatch>();
                    //数组按照元素个数由多到少排序
                    var arrXMatches = new List<int>();
                    var arrYMatches = new List<int>();
                    float XCompute = 0; float YCompute = 0; int coutPt = 0;
                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            arrXMatches.Add((int)X_dis);
                            arrYMatches.Add((int)Y_dis);
                        }
                    }
                    int[] arrX = arrXMatches.ToArray();
                    int[] arrY = arrYMatches.ToArray();
                    Array.Sort(arrX);
                    Array.Sort(arrY);
                    int valX1 = arrX[0];//当前
                    int valX2 = 0;//上一个
                    int timeX1 = 1;//当前
                    int timeX2 = 0;//上一个
                    for (int sortI = 1; sortI < arrX.Length; sortI++)
                    {
                        if (arrX[sortI] == valX1)
                        {
                            timeX1++;
                        }
                        else
                        {
                            if (timeX1 > timeX2)
                            {
                                valX2 = valX1;
                                timeX2 = timeX1;
                            }
                            valX1 = arrX[sortI];
                            timeX1 = 1;
                        }
                    }
                    if (timeX1 > timeX2)
                    {
                        valX2 = valX1;
                        timeX2 = timeX1;
                    }
                    int valY1 = arrY[0];//当前
                    int valY2 = 0;//上一个
                    int timeY1 = 1;//当前
                    int timeY2 = 0;//上一个
                    for (int sortI = 1; sortI < arrY.Length; sortI++)
                    {
                        if (arrY[sortI] == valY1)
                        {
                            timeY1++;
                        }
                        else
                        {
                            if (timeY1 > timeY2)
                            {
                                valY2 = valY1;
                                timeY2 = timeY1;
                            }
                            valY1 = arrY[sortI];
                            timeY1 = 1;
                        }
                    }
                    if (timeY1 > timeY2)
                    {
                        valY2 = valY1;
                        timeY2 = timeY1;
                    }

                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            //pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                            //pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                            //goodMatches.Add(items[0]);
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            if ((valX2 >= X_dis - 5 && valX2 <= X_dis + 5) && (valY2 >= Y_dis - 5 && valY2 <= Y_dis + 5))
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1}", X_dis, Y_dis);
                                pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                                pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                                goodMatches.Add(items[0]);
                                //arrXMatches.Add((int)X_dis);
                                ////arrYMatches.Add((int)Y_dis);
                                coutPt++;
                                XCompute += X_dis; YCompute += Y_dis;
                            }
                            else
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1} 舍弃", X_dis, Y_dis);
                            }
                        }
                    }

                    float aver_X = XCompute / coutPt;// 600;//
                    float aver_Y = YCompute / coutPt;// 600;//
                    Console.WriteLine("平均横向距离差：{0}  平均纵向距离差：{1}", aver_X, aver_Y);//计算原图像相对于新图像的(距离差)、-->变换矩阵

                    var outMat = new Mat();

                    // 算法RANSAC对匹配的结果做过滤
                    var pSrc = pointsSrc.ConvertAll(Point2fToPoint2d);
                    var pDst = pointsDst.ConvertAll(Point2fToPoint2d);
                    var outMask = new Mat();
                    var result = new Mat();
                    // 如果原始的匹配结果为空, 则跳过过滤步骤
                    if (pSrc.Count > 0 && pDst.Count > 0)
                    {
                        int srcOriX = 0;
                        int srcOriY = 0;
                        int newOriX = 0;
                        int newOriY = 0;

                        Cv2.FindHomography(pSrc, pDst, HomographyMethods.Ransac, mask: outMask);

                        //得到变换矩阵后拼接图像
                        int newWidth = matSrc.Width;// 2448;
                        int newHeight = matSrc.Height;// 2040;
                        if (aver_X <= 0)
                        {
                            newWidth = (int)(newWidth - aver_X);
                            srcOriX = (int)(-aver_X);
                        }
                        else
                        {
                            for (int i = 0; i < pDst.Count; i++)
                            {
                                pDst[i] = new Point2d(pSrc[i].X, pDst[i].Y);
                            }
                            newOriX = (int)aver_X;
                            if (matTo.Width + aver_X > newWidth)
                                newWidth = (int)(matTo.Width + aver_X);
                        }
                        if (aver_Y <= 0)
                        {
                            newHeight = (int)(newHeight - aver_Y);
                            srcOriY = (int)(-aver_Y);
                        }
                        else
                        {
                            for (int i = 0; i < pDst.Count; i++)
                            {
                                pDst[i] = new Point2d(pDst[i].X, pSrc[i].Y);
                            }
                            newOriY = (int)aver_Y;
                            if (matTo.Height + aver_Y > newHeight)
                                newHeight = (int)(matTo.Height + aver_Y);
                        }

                        result = new Mat(new OpenCvSharp.Size(newWidth, newHeight), matSrc.Type());

                        //<-- int index = 9; matSrc
                        Rect rectSrc = new Rect(0, 0, matSrc.Width, matSrc.Height);
                        Mat tempMatSrc = matSrc.Clone(rectSrc);
                        //复制原有区域part1(<--用户选中的区域)到新图像(<--原图像)
                        Mat maskSrc = tempMatSrc.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat posSrc = new Mat(result, new Rect(srcOriX, srcOriY, matSrc.Width, matSrc.Height));
                        tempMatSrc.CopyTo(posSrc, maskSrc);//原图像复制到新图像


                        Rect rect = new Rect(0, 0, matTo.Width, matTo.Height);
                        Mat tempMat = matTo.Clone(rect);
                        //复制原有区域part2(<--用户选中的区域)到新图像(<--原图像)
                        Mat mask = tempMat.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat pos = new Mat(result, new Rect(newOriX, newOriY, matTo.Width, matTo.Height));
                        tempMat.CopyTo(pos, mask);//原图像复制到新图像

                        //Bitmap part2 = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(result);
                        ////、、R3a
                        //part2.Save(@"ResSurfA" + indexRes + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                        return result;
                    }
                    result = matSrc.Clone();
                    return result;
                    //// 如果通过RANSAC处理后的匹配点大于10个,才应用过滤. 否则使用原始的匹配点结果(匹配点过少的时候通过RANSAC处理后,可能会得到0个匹配点的结果).
                    //if (outMask.Rows > 10)
                    //{
                    //    byte[] maskBytes = new byte[outMask.Rows * outMask.Cols];
                    //    outMask.GetArray(0, 0, maskBytes);
                    //    Cv2.DrawMatches(matSrc, keyPointsSrc, matTo, keyPointsTo, goodMatches, outMat, matchesMask: maskBytes, flags: DrawMatchesFlags.NotDrawSinglePoints);
                    //}
                    //else
                    //    Cv2.DrawMatches(matSrc, keyPointsSrc, matTo, keyPointsTo, goodMatches, outMat, flags: DrawMatchesFlags.NotDrawSinglePoints);
                    //return OpenCvSharp.Extensions.BitmapConverter.ToBitmap(/*result*/outMat);
                }
            }
        }
        //大图模式
        private static Mat m_merge;
        private static bool isDebug = false;
        public static double LastWidth;
        public static double LastHeight;

        public static Mat LastMat;
        public static double LastX;
        public static double LastY;

        public static void InitMatchPicOneByOne(bool is_Debug, double lastX = 0, double lastY = 0, Mat mmerge = null)
        {
            isDebug = is_Debug;
            LastMat = null;
            LastX = lastX;
            LastY = lastY;
            m_merge = mmerge;
        }

        public static System.Drawing.Point MatchPicOneByOne(Bitmap img0, Bitmap img1, out Boolean errorFlag)
        {
            errorFlag = false;
            try
            {
                return MatchPic(img0, img1);
            }
            catch (Exception)
            {
                errorFlag = true;
            }
            return new System.Drawing.Point(0, 0);
        }

        public static System.Drawing.Point MatchPic(Bitmap img0, Bitmap img1)
        {
            var matNew = BitmapConverter.ToMat(img0);
            LastMat = BitmapConverter.ToMat(img1);
            using (Mat matSrcRet = new Mat())
            using (Mat matToRet = new Mat())
            {
                KeyPoint[] keyPointsSrc, keyPointsTo;
                using (var surf = OpenCvSharp.ORB.Create(800))
                {
                    surf.DetectAndCompute(LastMat, null, out keyPointsSrc, matSrcRet);
                    surf.DetectAndCompute(matNew, null, out keyPointsTo, matToRet);
                    LastMat = matNew;
                }

                using (var bfMatcher = new OpenCvSharp.BFMatcher())//FlannBasedMatcher
                {
                    var matches = bfMatcher.KnnMatch(matSrcRet, matToRet, k: 2);

                    var pointsSrc = new List<Point2f>();
                    var pointsDst = new List<Point2f>();
                    var goodMatches = new List<DMatch>();
                    //数组按照元素个数由多到少排序
                    var arrXMatches = new List<int>();
                    var arrYMatches = new List<int>();
                    float XCompute = 0; float YCompute = 0; int coutPt = 0;
                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            arrXMatches.Add((int)X_dis);
                            arrYMatches.Add((int)Y_dis);
                        }
                    }
                    int[] arrX = arrXMatches.ToArray();
                    int[] arrY = arrYMatches.ToArray();
                    Array.Sort(arrX);
                    Array.Sort(arrY);
                    int valX1 = arrX[0];//当前
                    int valX2 = 0;//上一个
                    int timeX1 = 1;//当前
                    int timeX2 = 0;//上一个
                    for (int sortI = 1; sortI < arrX.Length; sortI++)
                    {
                        if (arrX[sortI] == valX1)
                        {
                            timeX1++;
                        }
                        else
                        {
                            if (timeX1 > timeX2)
                            {
                                valX2 = valX1;
                                timeX2 = timeX1;
                            }
                            valX1 = arrX[sortI];
                            timeX1 = 1;
                        }
                    }
                    if (timeX1 > timeX2)
                    {
                        valX2 = valX1;
                        timeX2 = timeX1;
                    }
                    int valY1 = arrY[0];//当前
                    int valY2 = 0;//上一个
                    int timeY1 = 1;//当前
                    int timeY2 = 0;//上一个
                    for (int sortI = 1; sortI < arrY.Length; sortI++)
                    {
                        if (arrY[sortI] == valY1)
                        {
                            timeY1++;
                        }
                        else
                        {
                            if (timeY1 > timeY2)
                            {
                                valY2 = valY1;
                                timeY2 = timeY1;
                            }
                            valY1 = arrY[sortI];
                            timeY1 = 1;
                        }
                    }
                    if (timeY1 > timeY2)
                    {
                        valY2 = valY1;
                        timeY2 = timeY1;
                    }

                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            //pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                            //pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                            //goodMatches.Add(items[0]);
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            if ((valX2 >= X_dis - 5 && valX2 <= X_dis + 5) && (valY2 >= Y_dis - 5 && valY2 <= Y_dis + 5))
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1}", X_dis, Y_dis);
                                pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                                pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                                goodMatches.Add(items[0]);
                                coutPt++;
                                XCompute += X_dis;
                                YCompute += Y_dis;
                            }
                            else
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1} 舍弃", X_dis, Y_dis);
                            }
                        }
                    }
                    return new System.Drawing.Point((int)(XCompute / coutPt), (int)(YCompute / coutPt));
                }
            }
        }

        public static Mat MatchPicOneByOne(Mat matNew, Mat matBig)
        {
            if (LastMat == null)
            {
                LastMat = matNew;
                return matNew.Clone();
            }
            using (Mat matSrcRet = new Mat())
            using (Mat matToRet = new Mat())
            {
                KeyPoint[] keyPointsSrc, keyPointsTo;
                //using (var surf = OpenCvSharp.XFeatures2D.SURF.Create(800/*2000*/))
                using (var surf = OpenCvSharp.ORB.Create(800))
                //using (var sift = OpenCvSharp.XFeatures2D.SIFT.Create(2000))//var sift = OpenCvSharp.XFeatures2D.SIFT.Create()
                {
                    surf.DetectAndCompute(LastMat, null, out keyPointsSrc, matSrcRet);
                    surf.DetectAndCompute(matNew, null, out keyPointsTo, matToRet);
                    LastMat = matNew;
                }

                using (var bfMatcher = new OpenCvSharp.BFMatcher())//FlannBasedMatcher
                {
                    var matches = bfMatcher.KnnMatch(matSrcRet, matToRet, k: 2);

                    var pointsSrc = new List<Point2f>();
                    var pointsDst = new List<Point2f>();
                    var goodMatches = new List<DMatch>();
                    //数组按照元素个数由多到少排序
                    var arrXMatches = new List<int>();
                    var arrYMatches = new List<int>();
                    float XCompute = 0; float YCompute = 0; int coutPt = 0;
                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            arrXMatches.Add((int)X_dis);
                            arrYMatches.Add((int)Y_dis);
                        }
                    }
                    int[] arrX = arrXMatches.ToArray();
                    int[] arrY = arrYMatches.ToArray();
                    Array.Sort(arrX);
                    Array.Sort(arrY);
                    int valX1 = arrX[0];//当前
                    int valX2 = 0;//上一个
                    int timeX1 = 1;//当前
                    int timeX2 = 0;//上一个
                    for (int sortI = 1; sortI < arrX.Length; sortI++)
                    {
                        if (arrX[sortI] == valX1)
                        {
                            timeX1++;
                        }
                        else
                        {
                            if (timeX1 > timeX2)
                            {
                                valX2 = valX1;
                                timeX2 = timeX1;
                            }
                            valX1 = arrX[sortI];
                            timeX1 = 1;
                        }
                    }
                    if (timeX1 > timeX2)
                    {
                        valX2 = valX1;
                        timeX2 = timeX1;
                    }
                    int valY1 = arrY[0];//当前
                    int valY2 = 0;//上一个
                    int timeY1 = 1;//当前
                    int timeY2 = 0;//上一个
                    for (int sortI = 1; sortI < arrY.Length; sortI++)
                    {
                        if (arrY[sortI] == valY1)
                        {
                            timeY1++;
                        }
                        else
                        {
                            if (timeY1 > timeY2)
                            {
                                valY2 = valY1;
                                timeY2 = timeY1;
                            }
                            valY1 = arrY[sortI];
                            timeY1 = 1;
                        }
                    }
                    if (timeY1 > timeY2)
                    {
                        valY2 = valY1;
                        timeY2 = timeY1;
                    }

                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            //pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                            //pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                            //goodMatches.Add(items[0]);
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            if ((valX2 >= X_dis - 5 && valX2 <= X_dis + 5) && (valY2 >= Y_dis - 5 && valY2 <= Y_dis + 5))
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1}", X_dis, Y_dis);
                                pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                                pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                                goodMatches.Add(items[0]);
                                //arrXMatches.Add((int)X_dis);
                                ////arrYMatches.Add((int)Y_dis);
                                coutPt++;
                                XCompute += X_dis; YCompute += Y_dis;
                            }
                            else
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1} 舍弃", X_dis, Y_dis);
                            }
                        }
                    }
                    LastX += XCompute / coutPt;
                    LastY += YCompute / coutPt;// 600;//
                    //Console.WriteLine("平均横向距离差：{0}  平均纵向距离差：{1}", currentX, currentY);//计算原图像相对于新图像的(距离差)、-->变换矩阵

                    var outMat = new Mat();

                    // 算法RANSAC对匹配的结果做过滤
                    var pSrc = pointsSrc.ConvertAll(Point2fToPoint2d);
                    var pDst = pointsDst.ConvertAll(Point2fToPoint2d);
                    var outMask = new Mat();
                    var result = new Mat();
                    // 如果原始的匹配结果为空, 则跳过过滤步骤
                    if (pSrc.Count > 0 && pDst.Count > 0)
                    {
                        int srcOriX = 0;
                        int srcOriY = 0;
                        int newOriX = 0;
                        int newOriY = 0;

                        // Cv2.FindHomography(pSrc, pDst, HomographyMethods.Ransac, mask: outMask);

                        //得到变换矩阵后拼接图像
                        int viewWidth = matBig.Width;// 2448;
                        int viewHeight = matBig.Height;// 2040;
                        if (LastX <= 0)
                        {
                            viewWidth = (int)(viewWidth - LastX);
                            srcOriX = (int)(-LastX);
                            newOriX = 0;
                            LastX = 0;
                        }
                        else
                        {
                            viewWidth = (int)Math.Max(LastX + matNew.Width, matBig.Width);
                            newOriX = (int)LastX;
                            //for (int i = 0; i < pDst.Count; i++)
                            //{
                            //    pDst[i] = new Point2d(pSrc[i].X, pDst[i].Y);
                            //}
                        }

                        if (LastY <= 0)
                        {
                            viewHeight = (int)(viewHeight - LastY);
                            srcOriY = (int)(-LastY);
                            newOriY = 0;
                            LastY = 0;
                        }
                        else
                        {
                            //for (int i = 0; i < pDst.Count; i++)
                            //{
                            //    pDst[i] = new Point2d(pDst[i].X, pSrc[i].Y);
                            //}
                            newOriY = (int)LastY;
                            viewHeight = (int)Math.Max(matBig.Height, matNew.Height + LastY);
                        }

                        result = new Mat(new OpenCvSharp.Size(viewWidth, viewHeight), matNew.Type());

                        //Rect rectSrc = new Rect(0, 0, matNew.Width, matNew.Height);
                        //Mat tempMatSrc = matNew.Clone(rectSrc);
                        Mat tempMatSrc = matNew.Clone();
                        //复制原有区域part1(<--用户选中的区域)到新图像(<--原图像)
                        Mat mask = tempMatSrc.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat posSrc = new Mat(result, new Rect(newOriX, newOriY, matNew.Width, matNew.Height));
                        tempMatSrc.CopyTo(posSrc, mask);//原图像复制到新图像


                        //Rect rect = new Rect(0, 0, matBig.Width, matBig.Height);
                        //Mat tempMat = matBig.Clone(rect);
                        Mat tempMat = matBig.Clone();
                        //复制原有区域part2(<--用户选中的区域)到新图像(<--原图像)
                        mask = tempMat.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat pos = new Mat(result, new Rect(srcOriX, srcOriY, matBig.Width, matBig.Height));
                        tempMat.CopyTo(pos, mask);//原图像复制到新图像
                        //Bitmap part2 = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(result);
                        ////、、R3a
                        //part2.Save(@"ResSurfA" + indexRes + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                        return result;
                    }
                    result = matNew.Clone();
                    return result;
                }
            }
        }


        private static Mat BackupMat;

        private static Rect LastRect;
        public static Mat MatchPicRealtime(Mat matSrc, Mat matTo, out Boolean errorFlag, out Rect rect)
        {
            errorFlag = false;
            Mat mat = matSrc.Clone();
            try
            {
                BackupMat = LastMat;
                mat = MatchPicRealtime(matSrc, matTo);
            }
            catch (Exception ex)
            {
                //Console.WriteLine(ex.Message);
                LastMat = BackupMat;
                errorFlag = true;
            }
            rect = LastRect;
            return !isDebug ? mat : null;
        }
        public static Mat MatchPicRealtime(Mat matNew, Mat matBig)
        {
            var time = DateTime.Now;
            if (LastMat == null)
            {
                LastMat = matNew;
                if (isDebug)
                {
                    int srcOriX = 0;
                    int srcOriY = 0;
                    int newOriX = 0;
                    int newOriY = 0;

                    //得到变换矩阵后拼接图像
                    int viewWidth = m_merge.Width;// 2448;
                    int viewHeight = m_merge.Height;// 2040;
                    if (LastX <= 0)
                    {
                        viewWidth = (int)(viewWidth - LastX);
                        srcOriX = (int)(-LastX);
                        newOriX = 0;
                        LastX = 0;
                    }
                    else
                    {
                        viewWidth = (int)Math.Max(LastX + matNew.Width, m_merge.Width);
                        newOriX = (int)LastX;
                        //for (int i = 0; i < pDst.Count; i++)
                        //{
                        //    pDst[i] = new Point2d(pSrc[i].X, pDst[i].Y);
                        //}
                    }

                    if (LastY <= 0)
                    {
                        viewHeight = (int)(viewHeight - LastY);
                        srcOriY = (int)(-LastY);
                        newOriY = 0;
                        LastY = 0;
                    }
                    else
                    {
                        //for (int i = 0; i < pDst.Count; i++)
                        //{
                        //    pDst[i] = new Point2d(pDst[i].X, pSrc[i].Y);
                        //}
                        newOriY = (int)LastY;
                        viewHeight = (int)Math.Max(m_merge.Height, matNew.Height + LastY);
                    }

                    LastWidth = viewWidth;
                    LastHeight = viewHeight;
                    //result = new Mat(new OpenCvSharp.Size(viewWidth, viewHeight), matNew.Type());
                    Mat tempMatSrc = matNew.Clone();
                    //复制原有区域part1(<--用户选中的区域)到新图像(<--原图像)
                    Mat mask = new Mat(tempMatSrc.Rows, tempMatSrc.Cols, MatType.CV_8UC1, new Scalar(255));// tempMatSrc.CvtColor(ColorConversionCodes.RGBA2GRAY);

                    Mat posSrc = new Mat(m_merge/*result*/, new Rect(newOriX, newOriY, matNew.Width, matNew.Height));

                    tempMatSrc.CopyTo(posSrc, mask);
                    LastRect = new Rect(newOriX, newOriY, matNew.Width, matNew.Height);
                    return null;// result;
                }
                else
                {
                    LastRect = new Rect(0, 0, matNew.Width, matNew.Height);
                }
                return matNew.Clone();
            }

            using (Mat matSrcRet = new Mat())
            using (Mat matToRet = new Mat())
            {
                KeyPoint[] keyPointsSrc, keyPointsTo;
                using (var surf = OpenCvSharp.ORB.Create(800))
                {
                    surf.DetectAndCompute(LastMat, null, out keyPointsSrc, matSrcRet);
                    surf.DetectAndCompute(matNew, null, out keyPointsTo, matToRet);
                    LastMat = matNew;
                }

                using (var bfMatcher = new OpenCvSharp.BFMatcher())//FlannBasedMatcher
                {
                    var matches = bfMatcher.KnnMatch(matSrcRet, matToRet, k: 2);

                    var pointsSrc = new List<Point2f>();
                    var pointsDst = new List<Point2f>();
                    var goodMatches = new List<DMatch>();
                    //数组按照元素个数由多到少排序
                    var arrXMatches = new List<int>();
                    var arrYMatches = new List<int>();
                    float XCompute = 0; float YCompute = 0; int coutPt = 0;
                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            arrXMatches.Add((int)X_dis);
                            arrYMatches.Add((int)Y_dis);
                        }
                    }
                    int[] arrX = arrXMatches.ToArray();
                    int[] arrY = arrYMatches.ToArray();
                    Array.Sort(arrX);
                    Array.Sort(arrY);
                    int valX1 = arrX[0];//当前
                    int valX2 = 0;//上一个
                    int timeX1 = 1;//当前
                    int timeX2 = 0;//上一个
                    for (int sortI = 1; sortI < arrX.Length; sortI++)
                    {
                        if (arrX[sortI] == valX1)
                        {
                            timeX1++;
                        }
                        else
                        {
                            if (timeX1 > timeX2)
                            {
                                valX2 = valX1;
                                timeX2 = timeX1;
                            }
                            valX1 = arrX[sortI];
                            timeX1 = 1;
                        }
                    }
                    if (timeX1 > timeX2)
                    {
                        valX2 = valX1;
                        timeX2 = timeX1;
                    }
                    int valY1 = arrY[0];//当前
                    int valY2 = 0;//上一个
                    int timeY1 = 1;//当前
                    int timeY2 = 0;//上一个
                    for (int sortI = 1; sortI < arrY.Length; sortI++)
                    {
                        if (arrY[sortI] == valY1)
                        {
                            timeY1++;
                        }
                        else
                        {
                            if (timeY1 > timeY2)
                            {
                                valY2 = valY1;
                                timeY2 = timeY1;
                            }
                            valY1 = arrY[sortI];
                            timeY1 = 1;
                        }
                    }
                    if (timeY1 > timeY2)
                    {
                        valY2 = valY1;
                        timeY2 = timeY1;
                    }

                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < 0.5 * items[1].Distance)
                        {
                            //pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                            //pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                            //goodMatches.Add(items[0]);
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            if ((valX2 >= X_dis - 5 && valX2 <= X_dis + 5) && (valY2 >= Y_dis - 5 && valY2 <= Y_dis + 5))
                            {
                                //Console.WriteLine("横向距离差：{0} 纵向距离差：{1}", X_dis, Y_dis);
                                pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                                pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                                goodMatches.Add(items[0]);
                                //arrXMatches.Add((int)X_dis);
                                ////arrYMatches.Add((int)Y_dis);
                                coutPt++;
                                XCompute += X_dis; YCompute += Y_dis;
                            }
                            else
                            {
                                //Console.WriteLine("横向距离差：{0} 纵向距离差：{1} 舍弃", X_dis, Y_dis);
                            }
                        }
                    }
                    if (coutPt < 3)
                    {
                        throw new Exception("点太少");
                    }
                    var ofx = XCompute / coutPt;
                    var ofy = YCompute / coutPt;

                    if (Math.Abs(ofx) < matNew.Width / 10 && Math.Abs(ofy) < matNew.Height / 10)
                        throw new Exception("太近了");

                    LastX += XCompute / coutPt;
                    LastY += YCompute / coutPt;// 600;//
                    //Console.WriteLine("平均横向距离差：{0}  平均纵向距离差：{1}", currentX, currentY);//计算原图像相对于新图像的(距离差)、-->变换矩阵

                    var outMat = new Mat();

                    // 算法RANSAC对匹配的结果做过滤
                    var pSrc = pointsSrc.ConvertAll(Point2fToPoint2d);
                    var pDst = pointsDst.ConvertAll(Point2fToPoint2d);
                    var outMask = new Mat();
                    var result = new Mat();
                    // 如果原始的匹配结果为空, 则跳过过滤步骤
                    if (pSrc.Count > 0 && pDst.Count > 0)
                    {
                        int srcOriX = 0;
                        int srcOriY = 0;
                        int newOriX = 0;
                        int newOriY = 0;

                        // Cv2.FindHomography(pSrc, pDst, HomographyMethods.Ransac, mask: outMask);

                        //得到变换矩阵后拼接图像
                        int viewWidth = matBig.Width;// 2448;
                        int viewHeight = matBig.Height;// 2040;
                        if (LastX <= 0)
                        {
                            viewWidth = (int)(viewWidth - LastX);
                            srcOriX = (int)(-LastX);
                            newOriX = 0;
                            LastX = 0;
                        }
                        else
                        {
                            viewWidth = (int)Math.Max(LastX + matNew.Width, matBig.Width);
                            newOriX = (int)LastX;
                            //for (int i = 0; i < pDst.Count; i++)
                            //{
                            //    pDst[i] = new Point2d(pSrc[i].X, pDst[i].Y);
                            //}
                        }

                        if (LastY <= 0)
                        {
                            viewHeight = (int)(viewHeight - LastY);
                            srcOriY = (int)(-LastY);
                            newOriY = 0;
                            LastY = 0;
                        }
                        else
                        {
                            //for (int i = 0; i < pDst.Count; i++)
                            //{
                            //    pDst[i] = new Point2d(pDst[i].X, pSrc[i].Y);
                            //}
                            newOriY = (int)LastY;
                            viewHeight = (int)Math.Max(matBig.Height, matNew.Height + LastY);
                        }


                        if (!isDebug)
                        {
                            Console.WriteLine("开始创建");
                            result = new Mat(new OpenCvSharp.Size(viewWidth, viewHeight), matNew.Type());//非大图模式 //大图模式不需要赋值
                            Mat tempMat = matBig;
                            Mat pos = new Mat(result, new Rect(srcOriX, srcOriY, matBig.Width, matBig.Height));
                            tempMat.CopyTo(pos);//原图像复制到新图像
                            Console.WriteLine("创建完成");
                        }
                        else
                            result = m_merge;

                        //Rect rectSrc = new Rect(0, 0, matNew.Width, matNew.Height);
                        //Mat tempMatSrc = matNew.Clone(rectSrc);
                        Mat tempMatSrc = matNew.Clone();
                        //复制原有区域part1(<--用户选中的区域)到新图像(<--原图像)
                        Mat mask = new Mat(tempMatSrc.Rows, tempMatSrc.Cols, MatType.CV_8UC1, new Scalar(255));// tempMatSrc.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat posSrc = new Mat(result, new Rect(newOriX, newOriY, matNew.Width, matNew.Height));
                        Console.WriteLine((DateTime.Now - time).TotalMilliseconds);
                        time = DateTime.Now;
                        OptimizeSeam(posSrc, tempMatSrc);
                        Console.WriteLine((DateTime.Now - time).TotalMilliseconds);
                        time = DateTime.Now;
                        tempMatSrc.CopyTo(posSrc);//原图像复制到新图像


                        //Rect rect = new Rect(0, 0, matBig.Width, matBig.Height);
                        //Mat tempMat = matBig.Clone(rect);
                        //复制原有区域part2(<--用户选中的区域)到新图像(<--原图像)
                        LastRect = new Rect(newOriX, newOriY, matNew.Width, matNew.Height);
                        //Bitmap part2 = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(result);
                        ////、、R3a
                        //part2.Save(@"ResSurfA" + indexRes + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                        return isDebug ? null : result;
                    }
                    result = isDebug ? null : matNew.Clone();
                    return result;
                }
            }
        }
        /// <summary>
        /// 图像拼接方法，返回拼接好的mat
        /// </summary>
        /// <param name="matSrc">需要拼接的mat1</param>
        /// <param name="matTo">需要拼接的mat2</param>
        /// <param name="errorFlag">返回true表示拼接失败</param>
        /// <param name="keyPointsSrc">matSrc的检测点Points</param>
        /// <param name="matSrcRet">matSrc的检测点Mat</param>
        /// <param name="keyPointsTo">matTo的检测点Points</param>
        /// <param name="matSrcRet">matTo的检测点Mat</param>
        /// <returns></returns>
        public static Mat MatchPicBySift(Mat matSrc, Mat matTo, out Boolean errorFlag, ref KeyPoint[] keyPointsSrc
            , ref Mat matSrcRet, ref KeyPoint[] keyPointsTo, ref Mat matToRet, int orbCount1)
        {
            var result = new Mat();
            errorFlag = false;
            try
            {
                using (var surf = ORB.Create(orbCount1 * 100))
                {
                    if (keyPointsSrc == null || matSrcRet == null)
                    {
                        matSrcRet = new Mat();
                        surf.DetectAndCompute(matSrc, null, out keyPointsSrc, matSrcRet);
                    }
                    if (keyPointsTo == null || matToRet == null)
                    {
                        matToRet = new Mat();
                        surf.DetectAndCompute(matTo, null, out keyPointsTo, matToRet);
                    }
                }
                using (var bfMatcher = new BFMatcher())
                {
                    var matches = bfMatcher.KnnMatch(matSrcRet, matToRet, k: 2);

                    var pointsSrc = new List<Point2f>();
                    var pointsDst = new List<Point2f>();
                    var goodMatches = new List<DMatch>();
                    //数组按照元素个数由多到少排序
                    var arrXMatches = new List<int>();
                    var arrYMatches = new List<int>();
                    double scaleI = 0.9;
                    float XCompute = 0; float YCompute = 0; int coutPt = 0;
                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < scaleI * items[1].Distance)
                        {
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            arrXMatches.Add((int)X_dis);
                            arrYMatches.Add((int)Y_dis);
                        }
                    }
                    int[] arrX = arrXMatches.ToArray();
                    int[] arrY = arrYMatches.ToArray();
                    Array.Sort(arrX);
                    Array.Sort(arrY);
                    int valX1 = arrX[0];//当前
                    int valX2 = 0;//上一个
                    int timeX1 = 1;//当前
                    int timeX2 = 0;//上一个
                    for (int sortI = 1; sortI < arrX.Length; sortI++)
                    {
                        if (arrX[sortI] == valX1)
                        {
                            timeX1++;
                        }
                        else
                        {
                            if (timeX1 > timeX2)
                            {
                                valX2 = valX1;
                                timeX2 = timeX1;
                            }
                            valX1 = arrX[sortI];
                            timeX1 = 1;
                        }
                    }
                    if (timeX1 > timeX2)
                    {
                        valX2 = valX1;
                        timeX2 = timeX1;
                    }
                    int valY1 = arrY[0];//当前
                    int valY2 = 0;//上一个
                    int timeY1 = 1;//当前
                    int timeY2 = 0;//上一个
                    for (int sortI = 1; sortI < arrY.Length; sortI++)
                    {
                        if (arrY[sortI] == valY1)
                        {
                            timeY1++;
                        }
                        else
                        {
                            if (timeY1 > timeY2)
                            {
                                valY2 = valY1;
                                timeY2 = timeY1;
                            }
                            valY1 = arrY[sortI];
                            timeY1 = 1;
                        }
                    }
                    if (timeY1 > timeY2)
                    {
                        valY2 = valY1;
                        timeY2 = timeY1;
                    }

                    foreach (DMatch[] items in matches.Where(x => x.Length > 1))
                    {
                        if (items[0].Distance < scaleI * items[1].Distance)
                        {
                            //pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                            //pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                            //goodMatches.Add(items[0]);
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            if ((valX2 >= X_dis - 5 && valX2 <= X_dis + 5) && (valY2 >= Y_dis - 5 && valY2 <= Y_dis + 5))
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1}", X_dis, Y_dis);
                                pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                                pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                                goodMatches.Add(items[0]);
                                //arrXMatches.Add((int)X_dis);
                                ////arrYMatches.Add((int)Y_dis);
                                coutPt++;
                                XCompute += X_dis; YCompute += Y_dis;
                            }
                            else
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1} 舍弃", X_dis, Y_dis);
                            }
                        }
                    }

                    float aver_X = XCompute / coutPt;// 600;//
                    float aver_Y = YCompute / coutPt;// 600;//
                    Console.WriteLine("平均横向距离差：{0}  平均纵向距离差：{1}", aver_X, aver_Y);//计算原图像相对于新图像的(距离差)、-->变换矩阵

                    var outMat = new Mat();

                    // 算法RANSAC对匹配的结果做过滤
                    var pSrc = pointsSrc.ConvertAll(Point2fToPoint2d);
                    var pDst = pointsDst.ConvertAll(Point2fToPoint2d);
                    var outMask = new Mat();
                    // 如果原始的匹配结果为空, 则跳过过滤步骤
                    if (pSrc.Count > 0 && pDst.Count > 0)
                    {
                        int srcOriX = 0;
                        int srcOriY = 0;
                        int newOriX = 0;
                        int newOriY = 0;

                        Cv2.FindHomography(pSrc, pDst, HomographyMethods.Ransac, mask: outMask);

                        //得到变换矩阵后拼接图像
                        int newWidth = matSrc.Width;// 2448;
                        int newHeight = matSrc.Height;// 2040;
                        if (aver_X <= 0)
                        {
                            newWidth = (int)(newWidth - aver_X);
                            srcOriX = (int)(-aver_X);
                        }
                        else
                        {
                            for (int i = 0; i < pDst.Count; i++)
                            {
                                pDst[i] = new Point2d(pSrc[i].X, pDst[i].Y);
                            }
                            newOriX = (int)aver_X;
                            if (matTo.Width + aver_X > newWidth)
                                newWidth = (int)(matTo.Width + aver_X);
                        }
                        if (aver_Y <= 0)
                        {
                            newHeight = (int)(newHeight - aver_Y);
                            srcOriY = (int)(-aver_Y);
                        }
                        else
                        {
                            for (int i = 0; i < pDst.Count; i++)
                            {
                                pDst[i] = new Point2d(pDst[i].X, pSrc[i].Y);
                            }
                            newOriY = (int)aver_Y;
                            if (matTo.Height + aver_Y > newHeight)
                                newHeight = (int)(matTo.Height + aver_Y);
                        }

                        result = new Mat(new OpenCvSharp.Size(newWidth, newHeight), matSrc.Type());

                        //<-- int index = 9; matSrc
                        Rect rectSrc = new Rect(0, 0, matSrc.Width, matSrc.Height);
                        Mat tempMatSrc = matSrc.Clone(rectSrc);
                        //复制原有区域part1(<--用户选中的区域)到新图像(<--原图像)
                        Mat maskSrc = tempMatSrc.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat posSrc = new Mat(result, new Rect(srcOriX, srcOriY, matSrc.Width, matSrc.Height));
                        tempMatSrc.CopyTo(posSrc, maskSrc);//原图像复制到新图像


                        Rect rect = new Rect(0, 0, matTo.Width, matTo.Height);
                        Mat tempMat = matTo.Clone(rect);
                        //复制原有区域part2(<--用户选中的区域)到新图像(<--原图像)
                        Mat mask = tempMat.CvtColor(ColorConversionCodes.RGBA2GRAY);

                        Mat pos = new Mat(result, new Rect(newOriX, newOriY, matTo.Width, matTo.Height));
                        tempMat.CopyTo(pos, mask);//原图像复制到新图像

                        //Bitmap part2 = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(result);
                        ////、、R3a
                        //part2.Save(@"ResSurfA" + indexRes + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                        return result;
                    }
                    result = matSrc.Clone();
                    //// 如果通过RANSAC处理后的匹配点大于10个,才应用过滤. 否则使用原始的匹配点结果(匹配点过少的时候通过RANSAC处理后,可能会得到0个匹配点的结果).
                    //if (outMask.Rows > 10)
                    //{
                    //    byte[] maskBytes = new byte[outMask.Rows * outMask.Cols];
                    //    outMask.GetArray(0, 0, maskBytes);
                    //    Cv2.DrawMatches(matSrc, keyPointsSrc, matTo, keyPointsTo, goodMatches, outMat, matchesMask: maskBytes, flags: DrawMatchesFlags.NotDrawSinglePoints);
                    //}
                    //else
                    //    Cv2.DrawMatches(matSrc, keyPointsSrc, matTo, keyPointsTo, goodMatches, outMat, flags: DrawMatchesFlags.NotDrawSinglePoints);
                    //return OpenCvSharp.Extensions.BitmapConverter.ToBitmap(/*result*/outMat);
                }
            }
            catch (Exception)
            {
                errorFlag = true;
            }
            return result;
        }

        /// <summary>
        /// 图像拼接方法，返回拼接好的位移
        /// </summary>
        /// <param name="matSrc">需要拼接的mat1</param>
        /// <param name="matTo">需要拼接的mat2</param>
        /// <param name="errorFlag">返回true表示拼接失败</param>
        /// <param name="keyPointsSrc">matSrc的检测点Points</param>
        /// <param name="matSrcRet">matSrc的检测点Mat</param>
        /// <param name="keyPointsTo">matTo的检测点Points</param>
        /// <param name="matSrcRet">matTo的检测点Mat</param>
        /// <returns></returns>
        public static System.Drawing.Point MatchOneBySift(Mat matSrc00, Mat matTo00, out Boolean errorFlag, int orbCount1, double percent, int directionRect, bool usePercent = true)
        {

            ////从1到3分别是右、下、左
            //int directionRect = 1;double percent, int directionRect
            System.Drawing.Point movePoint = new System.Drawing.Point(-1, -1);
            Mat matSrc = null;// new Mat();
            Mat matTo = null;// new Mat();
            KeyPoint[] keyPointsSrc;
            Mat matSrcRet = null;
            KeyPoint[] keyPointsTo;
            Mat matToRet = null;
            //    Rect rectSrc = new Rect(0, 0, matSrc.Width, matSrc.Height);
            //    Mat tempMatSrc = matSrc.Clone(rectSrc);
            if (!usePercent)
            {
                movePoint.X = 0;
                movePoint.Y = 0;
                matSrc = matSrc00;//.Clone();
                matTo = matTo00;//.Clone();
            }
            else
                switch (directionRect)
                {
                    case 1:
                        {
                            movePoint.X = matSrc00.Width - (int)(matSrc00.Width * percent * 1.0);
                            movePoint.Y = 0;

                            matSrc = new Mat(matSrc00, new Rect(movePoint.X, 0, (int)(matSrc00.Width * percent * 1.0), matSrc00.Height));
                            matTo = new Mat(matTo00, new Rect(0, 0, (int)(matSrc00.Width * percent * 1.0), matSrc00.Height));
                        }
                        break;
                    case 2:
                        {
                            movePoint.X = 0;
                            movePoint.Y = matSrc00.Height - (int)(matSrc00.Height * percent * 1.0);
                            matSrc = new Mat(matSrc00, new Rect(0, movePoint.Y, matSrc00.Width, (int)(matSrc00.Height * percent * 1.0)));
                            matTo = new Mat(matTo00, new Rect(0, 0, matSrc00.Width, (int)(matSrc00.Height * percent * 1.0)));
                        }
                        break;
                    case 3:
                        {
                            movePoint.X = (int)(matSrc00.Width * percent * 1.0) - matSrc00.Width;
                            movePoint.Y = 0;
                            matSrc = new Mat(matSrc00, new Rect(0, 0, (int)(matSrc00.Width * percent * 1.0), matSrc00.Height));
                            matTo = new Mat(matTo00, new Rect(-movePoint.X, 0, (int)(matSrc00.Width * percent * 1.0), matSrc00.Height));
                        }
                        break;
                    default:
                        break;
                }

            //var result = new Mat();
            errorFlag = false;
            try
            {

                using (var surf = ORB.Create(orbCount1 * 1000))
                {
                    matSrcRet = new Mat();
                    surf.DetectAndCompute(matSrc, null, out keyPointsSrc, matSrcRet);

                    matToRet = new Mat();
                    surf.DetectAndCompute(matTo, null, out keyPointsTo, matToRet);
                }
                //Cv2.ImShow("matTo", matTo);
                //Cv2.WaitKey();
                using (var bfMatcher = new BFMatcher())
                {
                    var matches = bfMatcher.KnnMatch(matSrcRet, matToRet, k: 2);
                    var pointsSrc = new List<Point2f>();
                    var pointsDst = new List<Point2f>();
                    var goodMatches = new List<DMatch>();
                    //数组按照元素个数由多到少排序
                    var arrXMatches = new List<int>();
                    var arrYMatches = new List<int>();
                    double scaleI = 0.9;
                    float XCompute = 0; float YCompute = 0; int coutPt = 0;
                    foreach (DMatch[] items in matches.Where((e) => e.Length > 1))
                    {
                        if (items[0].Distance < scaleI * items[1].Distance)
                        {
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            arrXMatches.Add((int)X_dis);
                            arrYMatches.Add((int)Y_dis);
                        }
                    }
                    int[] arrX = arrXMatches.ToArray();
                    int[] arrY = arrYMatches.ToArray();
                    Array.Sort(arrX);
                    Array.Sort(arrY);
                    int valX1 = arrX[0];//当前
                    int valX2 = 0;//上一个
                    int timeX1 = 1;//当前
                    int timeX2 = 0;//上一个
                    for (int sortI = 1; sortI < arrX.Length; sortI++)
                    {
                        if (arrX[sortI] == valX1)
                        {
                            timeX1++;
                        }
                        else
                        {
                            if (timeX1 > timeX2)
                            {
                                valX2 = valX1;
                                timeX2 = timeX1;
                            }
                            valX1 = arrX[sortI];
                            timeX1 = 1;
                        }
                    }
                    if (timeX1 > timeX2)
                    {
                        valX2 = valX1;
                        timeX2 = timeX1;
                    }
                    int valY1 = arrY[0];//当前
                    int valY2 = 0;//上一个
                    int timeY1 = 1;//当前
                    int timeY2 = 0;//上一个
                    for (int sortI = 1; sortI < arrY.Length; sortI++)
                    {
                        if (arrY[sortI] == valY1)
                        {
                            timeY1++;
                        }
                        else
                        {
                            if (timeY1 > timeY2)
                            {
                                valY2 = valY1;
                                timeY2 = timeY1;
                            }
                            valY1 = arrY[sortI];
                            timeY1 = 1;
                        }
                    }
                    if (timeY1 > timeY2)
                    {
                        valY2 = valY1;
                        timeY2 = timeY1;
                    }

                    foreach (DMatch[] items in matches.Where((e) => e.Length > 1))
                    {
                        if (items[0].Distance < scaleI * items[1].Distance)
                        {
                            //pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                            //pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                            //goodMatches.Add(items[0]);
                            var X_dis = (keyPointsSrc[items[0].QueryIdx].Pt.X - keyPointsTo[items[0].TrainIdx].Pt.X);
                            var Y_dis = (keyPointsSrc[items[0].QueryIdx].Pt.Y - keyPointsTo[items[0].TrainIdx].Pt.Y);
                            if ((valX2 >= X_dis - 5 && valX2 <= X_dis + 5) && (valY2 >= Y_dis - 5 && valY2 <= Y_dis + 5))
                            {
                                Console.WriteLine("横向距离差：{0} 纵向距离差：{1}", X_dis, Y_dis);
                                pointsSrc.Add(keyPointsSrc[items[0].QueryIdx].Pt);
                                pointsDst.Add(keyPointsTo[items[0].TrainIdx].Pt);
                                goodMatches.Add(items[0]);
                                //arrXMatches.Add((int)X_dis);
                                ////arrYMatches.Add((int)Y_dis);
                                coutPt++;
                                XCompute += X_dis; YCompute += Y_dis;
                            }
                            else
                            {
                                //Console.WriteLine("横向距离差：{0} 纵向距离差：{1} 舍弃", X_dis, Y_dis);
                            }
                        }
                    }

                    float aver_X = XCompute / coutPt;// 600;//
                    float aver_Y = YCompute / coutPt;// 600;//
                    Console.WriteLine("平均横向距离差：{0}  平均纵向距离差：{1}", aver_X, aver_Y);//计算原图像相对于新图像的(距离差)、-->变换矩阵

                    if (usePercent && coutPt > 0 && (Math.Abs(movePoint.X) > 0 ? Math.Abs(aver_X) < Math.Abs(movePoint.X) * 0.15 : Math.Abs(aver_X) < 15)
                         && (Math.Abs(movePoint.Y) > 0 ? Math.Abs(aver_Y) < Math.Abs(movePoint.Y) * 0.15 : Math.Abs(aver_Y) < 15))
                    {
                        movePoint.X += (int)aver_X;
                        movePoint.Y += (int)aver_Y;
                    }
                    else if (!usePercent && coutPt > 0)
                    {
                        movePoint.X += (int)aver_X;
                        movePoint.Y += (int)aver_Y;
                    }
                    else
                    {
                        errorFlag = true;
                        //errorFlag = false;//集成另一套算法进行拼接
                    }
                }
            }
            catch (Exception)
            {
                errorFlag = true;
            }
            finally
            {
                //if (matSrc != null)
                //    matSrc.Dispose();
                //if (matTo != null)
                //    matTo.Dispose();
                if (matSrcRet != null)
                    matSrcRet.Dispose();
                if (matToRet != null)
                    matToRet.Dispose();
                GC.Collect();
            }
            //matSrc, matTo
            //
            if (errorFlag)//集成另一套算法进行拼接
            {
                System.Drawing.Point movePointByAccordDotNet = MatchByAccordDotNet(matSrc, matTo, out errorFlag);
                if (!errorFlag && (Math.Abs(movePoint.X) > 0 ? Math.Abs(movePointByAccordDotNet.X) < Math.Abs(movePoint.X) * 0.25 : Math.Abs(movePointByAccordDotNet.X) < 15)
                         && (Math.Abs(movePoint.Y) > 0 ? Math.Abs(movePointByAccordDotNet.Y) < Math.Abs(movePoint.Y) * 0.25 : Math.Abs(movePointByAccordDotNet.Y) < 15))
                {
                    //Cv2.ImShow("matTo", matTo);
                    //Cv2.WaitKey();
                    if ((Math.Abs(movePoint.X) > 0 ? Math.Abs(movePointByAccordDotNet.X) < Math.Abs(movePoint.X) * 0.1 : Math.Abs(movePointByAccordDotNet.X) < 15)
                         && (Math.Abs(movePoint.Y) > 0 ? Math.Abs(movePointByAccordDotNet.Y) < Math.Abs(movePoint.Y) * 0.1 : Math.Abs(movePointByAccordDotNet.Y) < 15))
                    {
                        string savePath = @"C:\Users\win10SSD\Desktop\工作目录\企业解决方案_显微镜图像处理及分析系统\bin\Debug\test\";
                        Cv2.ImWrite(savePath + "matSrc" + movePoint.X.ToString() + "_" + movePoint.Y.ToString() + ".jpg", matSrc);
                        Cv2.ImWrite(savePath + "matTo" + movePoint.X.ToString() + "_" + movePoint.Y.ToString() + ".jpg", matTo);
                        movePoint.X += movePointByAccordDotNet.X;
                        movePoint.Y += movePointByAccordDotNet.Y;
                    }
                }
                errorFlag = false;//集成另一套算法后重置标记位
            }
            return movePoint;
        }

        /// <summary>
        /// 图片切割
        /// </summary>
        public static Bitmap Cut(Bitmap src, int x, int y, int width, int height)
        {
            var mat = BitmapConverter.ToMat(src);
            mat = new Mat(mat, new Rect(x, y, width, height));
            return BitmapConverter.ToBitmap(mat);
        }
        public enum Side
        {
            Top,
            Left,
            Right,
            Buttom
        }
        /// <summary>
        /// 图片切割
        /// </summary>
        /// <param name="src"></param>
        /// <param name="rate">切割律</param>
        /// <param name="side">切割方向</param>
        /// <returns></returns>
        public static Bitmap Cut(Bitmap src, double rate, Side side)
        {
            int x = 0;
            int y = 0;
            int width = src.Width;
            int height = src.Height;
            switch (side)
            {
                case Side.Top:
                    height = (int)(height * rate);
                    break;
                case Side.Left:
                    width = (int)(width * rate);
                    break;
                case Side.Right:
                    x = (int)(width * (1 - rate));
                    width = (int)(width * rate);
                    break;
                case Side.Buttom:
                    y = (int)(height * (1 - rate));
                    height = (int)(height * rate);
                    break;
            }
            return Cut(src, x, y, width, height);
        }

        private static Point2d Point2fToPoint2d(Point2f input)
        {
            Point2d p2 = new Point2d(input.X, input.Y);
            return p2;
        }

        /// <summary>
        /// 集成Accord.NET的算法计算拼接坐标
        /// </summary>
        /// <param name="matSrc"></param>
        /// <param name="matTo"></param>
        /// <param name="errorFlag"></param>
        /// <returns></returns>
        public static System.Drawing.Point MatchByAccordDotNet(Mat matSrc, Mat matTo, out Boolean errorFlag)
        {
            errorFlag = true;
            System.Drawing.Point movePoint = new System.Drawing.Point(-1, -1);

            Bitmap img1 = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(matSrc);
            Bitmap img2 = OpenCvSharp.Extensions.BitmapConverter.ToBitmap(matTo);

            // Step 1: Detect feature points using Harris Corners Detector
            movePoint = VisualMath.Tools.MatchByAccordDotNet(img1, img2, out errorFlag);
            //int/*VisualMath.Accord.External.AForge.IntPoint*/[] harrisPoints2 = harris.ProcessImageMethod(img2).ToArray();

            //// Show the marked points in the original images
            //Bitmap img1mark = new PointsMarker(harrisPoints1).Apply(img1);
            //Bitmap img2mark = new PointsMarker(harrisPoints2).Apply(img2);

            //// Concatenate the two images together in a single image (just to show on screen)
            //Concatenate concatenate = new Concatenate(img1mark);
            //pictureBox.Image = concatenate.Apply(img2mark);




            return movePoint;
        }

        /// <summary>
        /// Log
        /// </summary>
        /// <param name="src"></param>
        /// <param name="dst"></param>
        public static Mat ResizeMat(Mat src, List<Args> lists)
        {
            try
            {
                int width = 0;
                int height = 0;

                for (int i = 0; i < lists.Count; i++)
                {
                    Args args = lists[i];
                    switch (args.Key)
                    {
                        case "height":
                            height = Convert.ToInt32(args.Value);
                            break;
                        case "width":
                            width = Convert.ToInt32(args.Value);
                            break;
                        default:
                            break;
                    }
                }
                Cv2.Resize(src, src, new OpenCvSharp.Size(width, height));
                return src;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                GC.Collect();
            }
        }


    }
}