Exemple #1
0
        void calculateImageMetrics(int j)
        {
            int calculated = 0;

            // Reset Image Metrics
            calibrationDevices[j].leftImageMetrics.sum                 = 0;
            calibrationDevices[j].leftImageMetrics.numPixels           = 0;
            calibrationDevices[j].leftImageMetrics.average             = 0;
            calibrationDevices[j].leftImageMetrics.totalMaskDeviation  = 0;
            calibrationDevices[j].rightImageMetrics.sum                = 0;
            calibrationDevices[j].rightImageMetrics.numPixels          = 0;
            calibrationDevices[j].rightImageMetrics.average            = 0;
            calibrationDevices[j].rightImageMetrics.totalMaskDeviation = 0;

            Mat workingImage = new Mat(calibrationDevices[j].webcam.leftImage.Height,
                                       calibrationDevices[j].webcam.leftImage.Width,
                                       calibrationDevices[j].webcam.leftImage.Type(), 0);
            Mat workingImage2 = new Mat(calibrationDevices[j].webcam.leftImage.Height,
                                        calibrationDevices[j].webcam.leftImage.Width,
                                        MatType.CV_64FC1, 0);
            Mat workingImage3 = new Mat(calibrationDevices[j].webcam.leftImage.Height,
                                        calibrationDevices[j].webcam.leftImage.Width,
                                        MatType.CV_64FC1, 0);

            for (int i = 0; i < 2; i++)
            {
                workingImage.SetTo(0);
                workingImage2.SetTo(0);
                workingImage3.SetTo(0);
                Mat curMat = i == 0 ? calibrationDevices[j].webcam.leftImage :
                             calibrationDevices[j].webcam.rightImage;

                if (calibrationDevices[j].maskImage[i] != null)
                {
                    // 1) Mask out the non-lens portions of the image
                    curMat.CopyTo(workingImage, calibrationDevices[j].maskImage[i]);

                    // 2) Sum the pixel values here
                    double pixelSum = workingImage.Sum().Val0;

                    // 3) Sum the pixel values of the mask
                    double maskSum = calibrationDevices[j].maskImage[i].Sum().Val0 / 255.0;

                    // 4) Calculate the average as image / mask
                    double average = pixelSum / maskSum;

                    workingImage2.SetTo(0);

                    // 5) Convert both to signed double values
                    workingImage.ConvertTo(workingImage2, MatType.CV_64FC1);

                    // 6) Subtract the average from the original masked image
                    Cv2.Subtract(workingImage2, average, workingImage2, calibrationDevices[j].maskImage[i]);

                    // 7) Take the Absolute Value - Unnecessary, the squaring later implies an absolute value
                    //Cv2.Absdiff(workingImage2, averageImage, averageImage);
                    workingImage3.SetTo(0);

                    // 8) Multiply the image by itself
                    Cv2.AccumulateSquare(workingImage2, workingImage3, calibrationDevices[j].maskImage[i]);

                    // 9) Take the Sum - this is the total mask deviation!!!
                    double totalAbsDiff = Cv2.Sum(workingImage3).Val0;

                    // 10) Set the Image Metrics
                    //   -Make sure to compensate for the left/ right switch on the bottom
                    if (i == 0)
                    {
                        calibrationDevices[j].leftImageMetrics.sum                = pixelSum;
                        calibrationDevices[j].leftImageMetrics.numPixels          = maskSum;
                        calibrationDevices[j].leftImageMetrics.average            = pixelSum / maskSum;
                        calibrationDevices[j].leftImageMetrics.totalMaskDeviation = (float)totalAbsDiff;
                    }
                    else
                    {
                        calibrationDevices[j].rightImageMetrics.sum                = pixelSum;
                        calibrationDevices[j].rightImageMetrics.numPixels          = maskSum;
                        calibrationDevices[j].rightImageMetrics.average            = pixelSum / maskSum;
                        calibrationDevices[j].rightImageMetrics.totalMaskDeviation = (float)totalAbsDiff;
                    }
                    calculated++;
                }
            }

            /*if (calculated == 2) {
             * Debug.Log("Left Cost: " + calibrationDevices[j].leftImageMetrics.totalMaskDeviation + "\n" +
             *          "RightCost: " + calibrationDevices[j].rightImageMetrics.totalMaskDeviation);
             * }*/
            workingImage.Release();
            workingImage2.Release();
            workingImage3.Release();
        }