コード例 #1
0
        public static void C_Sharp_DP213_Gray255_Get_Intial_R_Vreg1_B_Using_Previous_Band_Method(double Prev_Band_Voltage_AM1_R, double Prev_Band_Voltage_AM1_G, double Prev_Band_Voltage_AM1_B, ref int Vreg1_Dec_Init, ref int Gamma_R, ref int Gamma_B,
                                                                                                 bool[] Selected_Band, int[] Previous_Band_Gamma_Red, int[] Previous_Band_Gamma_Green, int[] Previous_Band_Gamma_Blue, int band, double band_Target_Lv, int Previous_Band_Vreg1_Dec
                                                                                                 , double[] Previous_Band_Finally_Measured_Lv, double Voltage_VREF4095, double Voltage_VREF0)
        {
            Form1 f1 = (Form1)Application.OpenForms["Form1"];

            if (band >= 1 && Selected_Band[band] == true)
            {
                SJH_Matrix M = new SJH_Matrix();
                double[]   Previous_Band_Gamma_Red_Voltage   = Get_Previous_Band_Gamma_Voltage(Prev_Band_Voltage_AM1_R, Previous_Band_Vreg1_Dec, Previous_Band_Gamma_Red, Voltage_VREF4095, Voltage_VREF0);
                double[]   Previous_Band_Gamma_Green_Voltage = Get_Previous_Band_Gamma_Voltage(Prev_Band_Voltage_AM1_G, Previous_Band_Vreg1_Dec, Previous_Band_Gamma_Green, Voltage_VREF4095, Voltage_VREF0);
                double[]   Previous_Band_Gamma_Blue_Voltage  = Get_Previous_Band_Gamma_Voltage(Prev_Band_Voltage_AM1_B, Previous_Band_Vreg1_Dec, Previous_Band_Gamma_Blue, Voltage_VREF4095, Voltage_VREF0);

                double[][] A_R = M.MatrixCreate(DP213_Static.Max_Gray_Amount, DP213_Static.Max_Gray_Amount);
                double[][] A_G = M.MatrixCreate(DP213_Static.Max_Gray_Amount, DP213_Static.Max_Gray_Amount);
                double[][] A_B = M.MatrixCreate(DP213_Static.Max_Gray_Amount, DP213_Static.Max_Gray_Amount);

                //Get A[i][count] = Previous_Band_Gamma_Green_Voltage[i]^j
                int count = 0;
                for (int i = 0; i <= (DP213_Static.Max_Gray_Amount - 1); i++)
                {
                    count = 0;
                    for (int j = (DP213_Static.Max_Gray_Amount - 1); j >= 0; j--)
                    {
                        A_R[i][count] = Math.Pow(Previous_Band_Gamma_Red_Voltage[i], j);
                        A_G[i][count] = Math.Pow(Previous_Band_Gamma_Green_Voltage[i], j);
                        A_B[i][count] = Math.Pow(Previous_Band_Gamma_Blue_Voltage[i], j);
                        count++;
                    }
                }

                //Get C[DP213_Static.Max_Gray_Amount] = inv(A)[DP213_Static.Max_Gray_Amount,DP213_Static.Max_Gray_Amount] * Previous_Band_Target_Lv[DP213_Static.Max_Gray_Amount]
                double[][] Inv_A_R = M.MatrixCreate(DP213_Static.Max_Gray_Amount, DP213_Static.Max_Gray_Amount);
                double[][] Inv_A_G = M.MatrixCreate(DP213_Static.Max_Gray_Amount, DP213_Static.Max_Gray_Amount);
                double[][] Inv_A_B = M.MatrixCreate(DP213_Static.Max_Gray_Amount, DP213_Static.Max_Gray_Amount);
                double[]   C_R     = new double[DP213_Static.Max_Gray_Amount];
                double[]   C_G     = new double[DP213_Static.Max_Gray_Amount];
                double[]   C_B     = new double[DP213_Static.Max_Gray_Amount];
                Inv_A_R = M.MatrixInverse(A_R);
                Inv_A_G = M.MatrixInverse(A_G);
                Inv_A_B = M.MatrixInverse(A_B);
                C_R     = M.Matrix_Multiply(Inv_A_R, Previous_Band_Finally_Measured_Lv);
                C_G     = M.Matrix_Multiply(Inv_A_G, Previous_Band_Finally_Measured_Lv);
                C_B     = M.Matrix_Multiply(Inv_A_B, Previous_Band_Finally_Measured_Lv);

                //Show "C10*(Vdata^10) + C9*(Vdata^9) + C8*(Vdata^8) + C7*(Vdata^7) + C6*(Vdata^6) + .... + C1*Vdata + C0 = Lv"
                double Target_Lv              = band_Target_Lv;
                double Calculated_Vdata_Red   = 0;
                double Calculated_Vdata_Green = 0;
                double Calculated_Vdata_Blue  = 0;
                double Calculated_Target_Lv   = 0;
                int    iteration;

                //Get Vreg1 From Gamma_Green (Or the "Actual_Previous_Vdata_Green" can directly get from the datagridview_voltage_table
                //Didn't get data directly from the datagridview_voltage_table, because it's gonna be easier to code in cpp dll
                double Previous_Band_Vreg1_Voltage = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(Voltage_VREF4095, Voltage_VREF0, Previous_Band_Vreg1_Dec);
                double Actual_Previous_Vdata_Red   = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(Voltage_VREF4095, Previous_Band_Vreg1_Voltage, Previous_Band_Gamma_Red[0]);
                double Actual_Previous_Vdata_Green = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(Voltage_VREF4095, Previous_Band_Vreg1_Voltage, Previous_Band_Gamma_Green[0]);
                double Actual_Previous_Vdata_Blue  = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Voltage(Voltage_VREF4095, Previous_Band_Vreg1_Voltage, Previous_Band_Gamma_Blue[0]);

                //Red
                for (double Vdata = Actual_Previous_Vdata_Red; Vdata <= Voltage_VREF4095; Vdata += 0.001)
                {
                    Calculated_Target_Lv = 0;
                    iteration            = 0;
                    for (int j = (DP213_Static.Max_Gray_Amount - 1); j >= 0; j--)
                    {
                        Calculated_Target_Lv += (Math.Pow(Vdata, j) * C_R[iteration++]);
                    }
                    if ((Calculated_Target_Lv < Target_Lv) && Calculated_Vdata_Red == 0)
                    {
                        Calculated_Vdata_Red = Vdata;
                        break;
                    }
                }

                //Green
                for (double Vdata = Actual_Previous_Vdata_Green; Vdata <= Voltage_VREF4095; Vdata += 0.001)
                {
                    Calculated_Target_Lv = 0;
                    iteration            = 0;
                    for (int j = (DP213_Static.Max_Gray_Amount - 1); j >= 0; j--)
                    {
                        Calculated_Target_Lv += (Math.Pow(Vdata, j) * C_G[iteration++]);
                    }

                    if ((Calculated_Target_Lv < Target_Lv) && Calculated_Vdata_Green == 0)
                    {
                        Calculated_Vdata_Green = Vdata;
                        break;
                    }
                }

                //Blue
                for (double Vdata = Actual_Previous_Vdata_Blue; Vdata <= Voltage_VREF4095; Vdata += 0.001)
                {
                    Calculated_Target_Lv = 0;
                    iteration            = 0;
                    for (int j = (DP213_Static.Max_Gray_Amount - 1); j >= 0; j--)
                    {
                        Calculated_Target_Lv += (Math.Pow(Vdata, j) * C_B[iteration++]);
                    }
                    if ((Calculated_Target_Lv < Target_Lv) && Calculated_Vdata_Blue == 0)
                    {
                        Calculated_Vdata_Blue = Vdata;
                        break;
                    }
                }

                f1.GB_Status_AppendText_Nextline("RBVreg1 Algorithm)Calculated_Vdata_Red/Calculated_Vdata_Green/Calculated_Vdata_Blue : "
                                                 + Calculated_Vdata_Red.ToString() + "/" + Calculated_Vdata_Green.ToString() + "/" + Calculated_Vdata_Blue.ToString(), Color.Blue);

                double Calculated_Vreg1_voltage = Voltage_VREF4095 + ((Calculated_Vdata_Green - Voltage_VREF4095) * (900.0 / (Previous_Band_Gamma_Green[0] + 389.0))); //just use HBM_Gamma[0], because other normal band copy G255 R/G/B From HBM
                Vreg1_Dec_Init = Imported_my_cpp_dll.DP213_Get_Vreg1_Dec(Voltage_VREF4095, Voltage_VREF0, Calculated_Vreg1_voltage);

                f1.GB_Status_AppendText_Nextline("RBVreg1 Algorithm)Calculated_Vreg1_voltage : " + Calculated_Vreg1_voltage.ToString(), Color.Blue);

                //Got the Vreg1
                //Need to get Gamma_R/B
                Gamma_R = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Calculated_Vreg1_voltage, Calculated_Vdata_Red);
                Gamma_B = Imported_my_cpp_dll.DP213_Get_AM2_Gamma_Dec(Voltage_VREF4095, Calculated_Vreg1_voltage, Calculated_Vdata_Blue);

                DP213_If_One_Of_RGB_Near_Register_Min_Max_Set_Gamma_As_Prev_Band_Gamma(ref Gamma_R, ref Previous_Band_Gamma_Blue[0], ref Gamma_B, Previous_Band_Gamma_Red[0], Previous_Band_Gamma_Green[0], Previous_Band_Gamma_Blue[0]);
            }
            else //Band0 + Other not selected Bands's
            {
                //Do nothing
            }
        }
コード例 #2
0
        public static void C_Sharp_DP213_Get_Intial_R_G_B_Using_3Points_Method(double Combine_Lv_Ratio, double[] Band_Voltage_AM1_R, double[] Band_Voltage_AM1_G, double[] Band_Voltage_AM1_B,
                                                                               ref int Gamma_R, ref int Gamma_G, ref int Gamma_B, bool[] Selected_Band, int[] Band_Gray_Gamma_Red, int[] Band_Gray_Gamma_Green, int[] Band_Gray_Gamma_Blue, double[] Band_Gray_Finally_Measured_Lv, int Current_Band_Dec_Vreg1,
                                                                               int[] Band_Vreg1_Dec, int band, int gray, double Target_Lv, double Prvious_Gray_Gamma_R_Voltage, double Prvious_Gray_Gamma_G_Voltage, double Prvious_Gray_Gamma_B_Voltage, double Voltage_VREF4095, double Voltage_VREF0)
        {
            if (band >= 1 && Selected_Band[band] == true && gray >= 1)//gray255(gray = 0)use vreg1 compensation (skip this option)
            {
                SJH_Matrix M = new SJH_Matrix();

                double[][] Band_Gray_Gamma_Red_Voltage   = M.MatrixCreate(band, DP213_Static.Max_Gray_Amount);
                double[][] Band_Gray_Gamma_Green_Voltage = M.MatrixCreate(band, DP213_Static.Max_Gray_Amount);
                double[][] Band_Gray_Gamma_Blue_Voltage  = M.MatrixCreate(band, DP213_Static.Max_Gray_Amount);

                for (int i = 0; i < band; i++)
                {
                    int[] Previous_Band_Gamma_R = new int[DP213_Static.Max_Gray_Amount];
                    int[] Previous_Band_Gamma_G = new int[DP213_Static.Max_Gray_Amount];
                    int[] Previous_Band_Gamma_B = new int[DP213_Static.Max_Gray_Amount];

                    for (int g = 0; g < DP213_Static.Max_Gray_Amount; g++)
                    {
                        Previous_Band_Gamma_R[g] = Band_Gray_Gamma_Red[(DP213_Static.Max_Gray_Amount * i) + g];
                        Previous_Band_Gamma_G[g] = Band_Gray_Gamma_Green[(DP213_Static.Max_Gray_Amount * i) + g];
                        Previous_Band_Gamma_B[g] = Band_Gray_Gamma_Blue[(DP213_Static.Max_Gray_Amount * i) + g];
                    }
                    //double[][] Band_Gray_Gamma_Red_Voltage <- (int[] Band_Vreg1_Dec , int[][] Band_Gray_Gamma_Red)
                    Band_Gray_Gamma_Red_Voltage[i]   = Get_Previous_Band_Gamma_Voltage(Band_Voltage_AM1_R[i], Band_Vreg1_Dec[i], Previous_Band_Gamma_R, Voltage_VREF4095, Voltage_VREF0);
                    Band_Gray_Gamma_Green_Voltage[i] = Get_Previous_Band_Gamma_Voltage(Band_Voltage_AM1_G[i], Band_Vreg1_Dec[i], Previous_Band_Gamma_G, Voltage_VREF4095, Voltage_VREF0);
                    Band_Gray_Gamma_Blue_Voltage[i]  = Get_Previous_Band_Gamma_Voltage(Band_Voltage_AM1_B[i], Band_Vreg1_Dec[i], Previous_Band_Gamma_B, Voltage_VREF4095, Voltage_VREF0);
                }


                //Need to...
                //Fx_3points_Combine_LV_1, Fx_3points_Combine_LV_2, Fx_3points_Combine_LV_3, Fx_3points_Combine_Lv_Distance
                int      Points_Num = band * DP213_Static.Max_Gray_Amount;
                double[] Gamma_Red_Voltage_Points   = new double[Points_Num];
                double[] Gamma_Green_Voltage_Points = new double[Points_Num];
                double[] Gamma_Blue_Voltage_Points  = new double[Points_Num];
                double[] Target_Lv_Points           = new double[Points_Num];

                for (int b = 0; b < band; b++)
                {
                    for (int g = 0; g < DP213_Static.Max_Gray_Amount; g++)
                    {
                        Gamma_Red_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]   = Band_Gray_Gamma_Red_Voltage[b][g];
                        Gamma_Green_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g] = Band_Gray_Gamma_Green_Voltage[b][g];
                        Gamma_Blue_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]  = Band_Gray_Gamma_Blue_Voltage[b][g];
                        Target_Lv_Points[(DP213_Static.Max_Gray_Amount * b) + g]           = Band_Gray_Finally_Measured_Lv[(DP213_Static.Max_Gray_Amount * b) + g];
                    }
                }

                Array.Sort(Gamma_Red_Voltage_Points);
                Array.Sort(Gamma_Green_Voltage_Points);
                Array.Sort(Gamma_Blue_Voltage_Points);
                Array.Sort(Target_Lv_Points);
                Array.Reverse(Target_Lv_Points);


                //-----------------Added On 200311-------------------
                List <double> Combinded_Gamma_Red_Voltage_Points   = new List <double>();
                List <double> Combinded_Gamma_Green_Voltage_Points = new List <double>();
                List <double> Combinded_Gamma_Blue_Voltage_Points  = new List <double>();
                List <double> Combinded_Target_Lv_Points           = new List <double>();

                for (int b = 0; b < band; b++)
                {
                    for (int g = 0; g < DP213_Static.Max_Gray_Amount; g++)
                    {
                        if (b == 0 && g == 0)//First Point
                        {
                            Combinded_Gamma_Red_Voltage_Points.Add(Gamma_Red_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                            Combinded_Gamma_Green_Voltage_Points.Add(Gamma_Green_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                            Combinded_Gamma_Blue_Voltage_Points.Add(Gamma_Blue_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                            Combinded_Target_Lv_Points.Add(Target_Lv_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                        }
                        else
                        {
                            double Abs_Diff_Lv_Between_Two_Points = Math.Abs(Combinded_Target_Lv_Points[Combinded_Target_Lv_Points.Count - 1] - Target_Lv_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                            double Threshold_Lv = (Target_Lv_Points[(DP213_Static.Max_Gray_Amount * b) + g] * Combine_Lv_Ratio);

                            if (Abs_Diff_Lv_Between_Two_Points > Threshold_Lv)
                            {
                                Combinded_Gamma_Red_Voltage_Points.Add(Gamma_Red_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                                Combinded_Gamma_Green_Voltage_Points.Add(Gamma_Green_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                                Combinded_Gamma_Blue_Voltage_Points.Add(Gamma_Blue_Voltage_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                                Combinded_Target_Lv_Points.Add(Target_Lv_Points[(DP213_Static.Max_Gray_Amount * b) + g]);
                            }
                        }
                    }
                }
                //----------------------------------------------------
                //int Formula_Num = Points_Num - 2; //((band * 8) - 2 = Points_Num - 2)
                int Formula_Num = Combinded_Target_Lv_Points.Count - 2; //Formula_Num = Points_Num - 2;

                double[][] Three_points_Gamma_Red_Voltage   = M.MatrixCreate(Formula_Num, 3);
                double[][] Three_points_Gamma_Green_Voltage = M.MatrixCreate(Formula_Num, 3);
                double[][] Three_points_Gamma_Blue_Voltage  = M.MatrixCreate(Formula_Num, 3);
                double[][] Three_points_Target_Lv           = M.MatrixCreate(Formula_Num, 3);
                double[][] Three_points_C_R = M.MatrixCreate(Formula_Num, 3);
                double[][] Three_points_C_G = M.MatrixCreate(Formula_Num, 3);
                double[][] Three_points_C_B = M.MatrixCreate(Formula_Num, 3);

                double[][] Temp_A_R     = M.MatrixCreate(3, 3);
                double[][] Temp_A_G     = M.MatrixCreate(3, 3);
                double[][] Temp_A_B     = M.MatrixCreate(3, 3);
                double[][] Temp_Inv_A_R = M.MatrixCreate(3, 3);
                double[][] Temp_Inv_A_G = M.MatrixCreate(3, 3);
                double[][] Temp_Inv_A_B = M.MatrixCreate(3, 3);

                double[] C_R = new double[3];
                double[] C_G = new double[3];
                double[] C_B = new double[3];

                int count = 0;
                for (int k = 0; k < Formula_Num; k++)
                {
                    for (int i = 0; i <= 2; i++)
                    {
                        //Get "Three_points_Target_Lv"
                        Three_points_Target_Lv[k][i] = Combinded_Target_Lv_Points[i + k];
                        count = 0;
                        //Get "A"
                        for (int j = 2; j >= 0; j--)
                        {
                            Temp_A_R[i][count] = Math.Pow(Combinded_Gamma_Red_Voltage_Points[i + k], j);
                            Temp_A_G[i][count] = Math.Pow(Combinded_Gamma_Green_Voltage_Points[i + k], j);
                            Temp_A_B[i][count] = Math.Pow(Combinded_Gamma_Blue_Voltage_Points[i + k], j);
                            count++;
                        }
                    }

                    //Get Inv_A (by using "A")
                    Temp_Inv_A_R = M.MatrixInverse(Temp_A_R);
                    Temp_Inv_A_G = M.MatrixInverse(Temp_A_G);
                    Temp_Inv_A_B = M.MatrixInverse(Temp_A_B);

                    //Get C (by using "Inv_A" , "Three_points_Target_Lv")
                    Three_points_C_R[k] = M.Matrix_Multiply(Temp_Inv_A_R, Three_points_Target_Lv[k]);
                    Three_points_C_G[k] = M.Matrix_Multiply(Temp_Inv_A_G, Three_points_Target_Lv[k]);
                    Three_points_C_B[k] = M.Matrix_Multiply(Temp_Inv_A_B, Three_points_Target_Lv[k]);

                    //Get C (Target belongs to [Three_points_Target_Lv[k][2],Three_points_Target_Lv[k][0]])
                    if (Three_points_Target_Lv[k][2] < Target_Lv && Target_Lv < Three_points_Target_Lv[k][0])
                    {
                        for (int i = 0; i <= 2; i++)
                        {
                            C_R[i] = Three_points_C_R[k][i];
                            C_G[i] = Three_points_C_G[k][i];
                            C_B[i] = Three_points_C_B[k][i];
                        }
                        break; //Break for k loop
                    }
                }

                //Get Calculated Voltage_R/G/B
                double Calculated_Target_Lv;
                int    iteration;
                double Calculated_R_Vdata = 0;
                double Calculated_G_Vdata = 0;
                double Calculated_B_Vdata = 0;

                for (double Vdata = Prvious_Gray_Gamma_R_Voltage; Vdata <= Voltage_VREF4095; Vdata += 0.001)
                {
                    Calculated_Target_Lv = 0;
                    iteration            = 0;

                    for (int j = 2; j >= 0; j--)
                    {
                        Calculated_Target_Lv += (Math.Pow(Vdata, j) * C_R[iteration++]);
                    }

                    if ((Calculated_Target_Lv < Target_Lv) && Calculated_R_Vdata == 0)
                    {
                        Calculated_R_Vdata = Vdata;
                        break;
                    }
                }

                for (double Vdata = Prvious_Gray_Gamma_G_Voltage; Vdata <= Voltage_VREF4095; Vdata += 0.001)
                {
                    Calculated_Target_Lv = 0;
                    iteration            = 0;

                    for (int j = 2; j >= 0; j--)
                    {
                        Calculated_Target_Lv += (Math.Pow(Vdata, j) * C_G[iteration++]);
                    }

                    if ((Calculated_Target_Lv < Target_Lv) && Calculated_G_Vdata == 0)
                    {
                        Calculated_G_Vdata = Vdata;
                        break;
                    }
                }

                for (double Vdata = Prvious_Gray_Gamma_B_Voltage; Vdata <= Voltage_VREF4095; Vdata += 0.001)
                {
                    Calculated_Target_Lv = 0;
                    iteration            = 0;

                    for (int j = 2; j >= 0; j--)
                    {
                        Calculated_Target_Lv += (Math.Pow(Vdata, j) * C_B[iteration++]);
                    }

                    if ((Calculated_Target_Lv < Target_Lv) && Calculated_B_Vdata == 0)
                    {
                        Calculated_B_Vdata = Vdata;
                        break;
                    }
                }

                //Get Gamma_R/G/B From Calculated Voltage_R/G/B
                double Current_Band_Vreg1_Voltage = Imported_my_cpp_dll.DP213_Get_Vreg1_Voltage(Voltage_VREF4095, Voltage_VREF0, Band_Vreg1_Dec[band]);
                Gamma_R = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Dec(Band_Voltage_AM1_R[band], Prvious_Gray_Gamma_R_Voltage, Calculated_R_Vdata, gray);
                Gamma_G = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Dec(Band_Voltage_AM1_G[band], Prvious_Gray_Gamma_G_Voltage, Calculated_G_Vdata, gray);
                Gamma_B = Imported_my_cpp_dll.DP213_Get_GR_Gamma_Dec(Band_Voltage_AM1_B[band], Prvious_Gray_Gamma_B_Voltage, Calculated_B_Vdata, gray);

                int Prev_Band_Current_Gray_Gamma_R = Band_Gray_Gamma_Red[(DP213_Static.Max_Gray_Amount * (band - 1)) + gray];
                int Prev_Band_Current_Gray_Gamma_G = Band_Gray_Gamma_Green[(DP213_Static.Max_Gray_Amount * (band - 1)) + gray];
                int Prev_Band_Current_Gray_Gamma_B = Band_Gray_Gamma_Blue[(DP213_Static.Max_Gray_Amount * (band - 1)) + gray];
                DP213_If_One_Of_RGB_Near_Register_Min_Max_Set_Gamma_As_Prev_Band_Gamma(ref Gamma_R, ref Gamma_G, ref Gamma_B, Prev_Band_Current_Gray_Gamma_R, Prev_Band_Current_Gray_Gamma_G, Prev_Band_Current_Gray_Gamma_B);
            }
            else //Band0 + Other not selected Bands's
            {
            }
        }