Exemplo n.º 1
0
        /// <summary>
        /// Given the left and right image, computer the disparity map and the 3D point cloud.
        /// </summary>
        /// <param name="left">The left image</param>
        /// <param name="right">The right image</param>
        /// <param name="disparityMap">The left disparity map</param>
        /// <param name="points">The 3D point cloud within a [-0.5, 0.5] cube</param>
        private static void Computer3DPointsFromStereoPair(Image <Gray, Byte> left, Image <Gray, Byte> right, out Image <Gray, short> disparityMap, out MCvPoint3D32f[] points)
        {
            Size size = left.Size;

            disparityMap = new Image <Gray, short>(size);

            //using (StereoSGBM stereoSolver = new StereoSGBM(5, 64, 0))
            using (StereoBM stereoSolver = new StereoBM())
            //using (Mat dm = new Mat())
            {
                stereoSolver.Compute(left, right, disparityMap);

                float scale = Math.Max(size.Width, size.Height);

                //Construct a simple Q matrix, if you have a matrix from cvStereoRectify, you should use that instead
                using (Matrix <double> q = new Matrix <double>(
                           new double[, ] {
                    { 1.0, 0.0, 0.0, -size.Width / 2 },  //shift the x origin to image center
                    { 0.0, -1.0, 0.0, size.Height / 2 }, //shift the y origin to image center and flip it upside down
                    { 0.0, 0.0, -1.0, 0.0 },             //Multiply the z value by -1.0,
                    { 0.0, 0.0, 0.0, scale }
                }))                                      //scale the object's corrdinate to within a [-0.5, 0.5] cube
                    points = PointCollection.ReprojectImageTo3D(disparityMap, q);
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Given the left and right image, computer the disparity map and the 3D point cloud.
        /// </summary>
        /// <param name="left">The left image</param>
        /// <param name="right">The right image</param>
        /// <param name="outputDisparityMap">The left disparity map</param>
        /// <param name="points">The 3D point cloud within a [-0.5, 0.5] cube</param>
        private static void Computer3DPointsFromStereoPair(IInputArray left, IInputArray right, Mat outputDisparityMap, Mat points)
        {
            Size size;

            using (InputArray ia = left.GetInputArray())
                size = ia.GetSize();

            using (StereoBM stereoSolver = new StereoBM())
            {
                stereoSolver.Compute(left, right, outputDisparityMap);

                float scale = Math.Max(size.Width, size.Height);

                //Construct a simple Q matrix, if you have a matrix from cvStereoRectify, you should use that instead
                using (Matrix <double> q = new Matrix <double>(
                           new double[, ]
                {
                    { 1.0, 0.0, 0.0, -size.Width / 2 },  //shift the x origin to image center
                    { 0.0, -1.0, 0.0, size.Height / 2 }, //shift the y origin to image center and flip it upside down
                    { 0.0, 0.0, -1.0, 0.0 },             //Multiply the z value by -1.0,
                    { 0.0, 0.0, 0.0, scale }
                }))                                      //scale the object's coordinate to within a [-0.5, 0.5] cube
                {
                    CvInvoke.ReprojectImageTo3D(outputDisparityMap, points, q, false, DepthType.Cv32F);
                }
                //points = PointCollection.ReprojectImageTo3D(outputDisparityMap, q);
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Given the left and right image, computer the disparity map and the 3D point cloud.
        /// </summary>
        /// <param name="left">The left image</param>
        /// <param name="right">The right image</param>
        /// <param name="outputDisparityMap">The left disparity map</param>
        /// <param name="points">The 3D point cloud within a [-0.5, 0.5] cube</param>
        private static void Computer3DPointsFromStereoPair(IInputArray left, IInputArray right, Mat outputDisparityMap, Mat points, bool handleMissingValues = true)
        {
            System.Drawing.Size size;
            using (InputArray ia = left.GetInputArray())
                size = ia.GetSize();

            using (StereoBM leftMatcher = new StereoBM())
                using (RightMatcher rightMatcher = new RightMatcher(leftMatcher))
                    using (Mat leftDisparity = new Mat())
                        using (Mat rightDisparity = new Mat())
                            using (DisparityWLSFilter wls = new DisparityWLSFilter(leftMatcher))
                            {
                                leftMatcher.Compute(left, right, leftDisparity);
                                rightMatcher.Compute(right, left, rightDisparity);
                                wls.Filter(leftDisparity, left, outputDisparityMap, rightDisparity, rightView: right);
                                float scale = Math.Max(size.Width, size.Height);

                                //Construct a simple Q matrix, if you have a matrix from cvStereoRectify, you should use that instead
                                using (Matrix <double> q = new Matrix <double>(
                                           new double[, ]
                                {
                                    { 1.0, 0.0, 0.0, -size.Width / 2 },  //shift the x origin to image center
                                    { 0.0, -1.0, 0.0, size.Height / 2 }, //shift the y origin to image center and flip it upside down
                                    { 0.0, 0.0, -1.0, 0.0 },             //Multiply the z value by -1.0,
                                    { 0.0, 0.0, 0.0, scale }
                                }))                                      //scale the object's coordinate to within a [-0.5, 0.5] cube
                                {
                                    CvInvoke.ReprojectImageTo3D(outputDisparityMap, points, q, handleMissingValues, DepthType.Cv32F);
                                    //CvInvoke.ReprojectImageTo3D(leftDisparity, points, q, false, DepthType.Cv32F);
                                    //CvInvoke.ReprojectImageTo3D(leftDisparity, points, q, handleMissingValues, DepthType.Cv32F);
                                }
                                //points = PointCollection.ReprojectImageTo3D(outputDisparityMap, q);
                            }
        }
Exemplo n.º 4
0
        public AlgorithmResult DetectDisparity(
            string filenameL,
            string filenameR,
            int numberOfDisparities,
            int blockSize)
        {
            AlgorithmResult   result     = new AlgorithmResult();
            Image <Bgr, byte> imageLeft  = ImageHelper.GetImage(filenameL);
            Image <Bgr, byte> imageRight = ImageHelper.GetImage(filenameR);
            var resultImage = new Image <Bgr, byte>(imageLeft.Width, imageLeft.Height);

            // Create new (gray, float) image for disparity
            var imageDisparity = new Image <Gray, float>(imageLeft.Size);

            StereoBM stereoBM = new StereoBM(numberOfDisparities, blockSize);

            StereoMatcherExtensions.Compute(
                stereoBM,
                imageLeft.Convert <Gray, byte>(),
                imageRight.Convert <Gray, byte>(),
                imageDisparity);

            // Normalize
            CvInvoke.Normalize(imageDisparity, imageDisparity, 0, 255, NormType.MinMax, DepthType.Cv8U);

            // Set resultImage after normalizing
            resultImage = imageDisparity.Convert <Bgr, byte>();

            result.ImageArray = ImageHelper.SetImage(resultImage);

            return(result);
        }
        private void Display3D(Mat left, Mat right)
        {
            //TODO: try to use StereoSGBM
            using (StereoBM stereoSolver = new StereoBM())
            {
                Mat output    = new Mat();
                Mat left8bit  = ConvertInto8bitMat(left);
                Mat right8bit = ConvertInto8bitMat(right);
                stereoSolver.Compute(left8bit, right8bit, output);
                Mat   points = new Mat();
                float scale  = Math.Max(left.Size.Width, left.Size.Height);
                if (!_isCalibrate)
                {
                    Q = new Matrix <double>(
                        new double[, ]
                    {
                        { 1.0, 0.0, 0.0, -left.Width / 2 },  //shift the x origin to image center
                        { 0.0, -1.0, 0.0, left.Height / 2 }, //shift the y origin to image center and flip it upside down
                        { 0.0, 0.0, -1.0, 0.0 },             //Multiply the z value by -1.0,
                        { 0.0, 0.0, 0.0, scale }
                    });
                    _isCalibrate = true;
                }
                //Construct a simple Q matrix, if you have a matrix from cvStereoRectify, you should use that instead
                //scale the object's coordinate to within a [-0.5, 0.5] cube
                if (_isCameraMatrixCount)
                {
                    Mat map11 = new Mat();
                    Mat map12 = new Mat();
                    Mat map21 = new Mat();
                    Mat map22 = new Mat();
                    CvInvoke.InitUndistortRectifyMap(cameraMatrix1, distCoeff1, R1, P1, left8bit.Size,
                                                     DepthType.Cv16S, map11, map12);
                    CvInvoke.InitUndistortRectifyMap(cameraMatrix2, distCoeff2, R2, P2, left8bit.Size,
                                                     DepthType.Cv16S, map21, map22);

                    Mat img1r = new Mat();
                    Mat img2r = new Mat();
                    CvInvoke.Remap(left8bit, img1r, map11, map12, Inter.Linear);
                    CvInvoke.Remap(right8bit, img2r, map21, map22, Inter.Linear);
                    left8bit  = img1r;
                    right8bit = img2r;
                }
                //stereoSolver.FindStereoCorrespondence(left, right, disparityMap);
                CvInvoke.ReprojectImageTo3D(output, points, Q, false, DepthType.Cv32F);
                //points = PointCollection.ReprojectImageTo3D(output, Q);
                Mat pointsArray     = points.Reshape(points.NumberOfChannels, points.Rows * points.Cols);
                Mat colorArray      = left.Reshape(left.NumberOfChannels, left.Rows * left.Cols);
                Mat colorArrayFloat = new Mat();
                colorArray.ConvertTo(colorArrayFloat, DepthType.Cv32F);
                WCloud cloud = new WCloud(pointsArray, colorArray);

                Display3DImage(cloud);

                //points = PointCollection.ReprojectImageTo3D(outputDisparityMap, q);
            }
        }
Exemplo n.º 6
0
 /// <summary>
 /// BM算法
 /// </summary>
 private void bmBtn_Click(object sender, EventArgs e)
 {
     if (BM_NumOfDis == 0 || BM_BlockSize == 0)
     {
         Data.LogString = "[error]  BM初始化参数错误";
         return;
     }
     bm          = new StereoBM(BM_NumOfDis, BM_BlockSize); //初始化BM类
     BM_CAL_FLAG = true;
 }
Exemplo n.º 7
0
        public DepthMapBuilder(ICommandBus commandBus)
        {
            _commandBus    = commandBus;
            _emitDelay     = TimeSpan.FromMilliseconds(1000.0 / DEPTH_MAP_PER_SECONDS);
            _stereoMatcher = StereoBM.Create();

            _stereoMatcher.MinDisparity      = 4;
            _stereoMatcher.NumDisparities    = 128;
            _stereoMatcher.BlockSize         = 21;
            _stereoMatcher.SpeckleRange      = 16;
            _stereoMatcher.SpeckleWindowSize = 45;
        }
Exemplo n.º 8
0
        public override Mat ComputeDepthMap(Image <Bgr, byte> leftImage, Image <Bgr, byte> rightImage)
        {
            StereoBM _stereoBM = CreateStereoBM();

            ConvertImageToGray(leftImage, rightImage);

            Mat imageDisparity = new Mat();
            Mat imageToSave    = new Mat();

            _stereoBM.Compute(LeftGrayImage, RightGrayImage, imageDisparity);
            imageDisparity.ConvertTo(imageToSave, DepthType.Cv8U);

            return(imageDisparity);
        }
Exemplo n.º 9
0
        //窗体初始化
        private void DisparityMeasure_Load(object sender, EventArgs e)
        {
            //初始化BM、SGBM类对象
            bmMatch   = StereoBM.Create();
            sgbmMatch = StereoSGBM.Create(sgbm_minDisparity, sgbm_numofDisparities, sgbm_blockSize, sgbm_P1, sgbm_P2,
                                          sgbm_disp12MaxDiff, sgbm_preFilterCap, sgbm_uniquenessRatio, sgbm_speckleWindowSize,
                                          sgbm_speckleRange, sgbm_Mode);
            //初始化定时器
            //dmTimer = new System.Threading.Timer(disparitymeTime, null, -1, 50);
            timer_disparityMeasure.Enabled = true;
            timer_disparityMeasure.Stop();
            //计算有效视差区
            //初始化BM参数
            this.ucTrackBar_preFilterSize.Value = bm_preFilterSize;
            this.textBox_preFilterSize.Text     = bm_preFilterSize.ToString();
            this.ucTrackBar_preFilterCap.Value  = bm_preFilterCap;
            this.textBox_preFilterCap.Text      = bm_preFilterCap.ToString();
            this.ucTrackBar_SADWinSize.Value    = bm_SADWinSize;
            this.textBox_SADWinSize.Text        = bm_SADWinSize.ToString();
            this.ucTrackBar_minDIsparity.Value  = bm_minDisparity;
            this.textBox_minDisparity.Text      = bm_minDisparity.ToString();
            //16倍倍数关系
            this.ucTrackBar_numOfDis.Value = bm_numOfDisparities / 16;
            this.textBox_numOfDis.Text     = bm_numOfDisparities.ToString();

            this.ucTrackBar_uniquenessRatio.Value = bm_uniquenessRatio;
            this.textBox_uniquenessRatio.Text     = bm_uniquenessRatio.ToString();
            this.ucTrackBar_textureThre.Value     = bm_textureThreshold;
            this.textBox_textureThreshold.Text    = bm_textureThreshold.ToString();
            this.ucTrackBar_speckleWinSize.Value  = bm_speckleWinSize;
            this.textBox_speckleWinSize.Text      = bm_speckleWinSize.ToString();
            this.ucTrackBar_speckleRange.Value    = bm_speckleRange;
            this.textBox_speckleRange.Text        = bm_speckleRange.ToString();
            this.ucTrackBar_disp12MaxDiff.Value   = bm_disp12MaxDiff;
            this.textBox_disp12MaxDiff.Text       = bm_disp12MaxDiff.ToString();

            //初始化SGBM参数
            this.numericUpDown_preFilterCap.Value     = sgbm_preFilterCap;
            this.numericUpDown_sadWinSize.Value       = sgbm_blockSize;
            this.numericUpDown_minDisparity.Value     = sgbm_minDisparity;
            this.numericUpDown_numOfDisparities.Value = sgbm_numofDisparities;
            this.numericUpDown_p1.Value = sgbm_P1;
            this.numericUpDown_p2.Value = sgbm_P2;
            this.numericUpDown_uniquenessRatio.Value = sgbm_uniquenessRatio;
            this.numericUpDown_disp12MaxDiff.Value   = sgbm_disp12MaxDiff;
            this.numericUpDown_speckleWinSize.Value  = sgbm_speckleWindowSize;
            this.numericUpDown_speckcleRange.Value   = sgbm_speckleRange;
        }
Exemplo n.º 10
0
        public void SimpleCompute()
        {
            var left  = Image("tsukuba_left.png", ImreadModes.GrayScale);
            var right = Image("tsukuba_right.png", ImreadModes.GrayScale);

            var sbm       = StereoBM.Create();
            var disparity = new Mat();

            sbm.Compute(left, right, disparity);

            /*
             * double min, max;
             * Cv2.MinMaxLoc(disparity, out min, out max);
             *
             * var disparityU8 = new Mat();
             * disparity.ConvertTo(disparityU8, MatType.CV_8UC1, 255 / (max - min), -255 * min / (max - min));
             * Window.ShowImages(disparityU8);
             * //*/
        }
Exemplo n.º 11
0
        public void SimpleCompute()
        {
            var left  = Image("tsukuba_left.png", ImreadModes.Grayscale);
            var right = Image("tsukuba_right.png", ImreadModes.Grayscale);

            var sbm       = StereoBM.Create();
            var disparity = new Mat();

            sbm.Compute(left, right, disparity);

            if (Debugger.IsAttached)
            {
                Cv2.MinMaxLoc(disparity, out double min, out double max);

                var disparityU8 = new Mat();
                disparity.ConvertTo(disparityU8, MatType.CV_8UC1, 255 / (max - min), -255 * min / (max - min));
                Window.ShowImages(disparityU8);
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// Given the left and right image, computer the disparity map and the 3D point cloud.
        /// </summary>
        /// <param name="left">The left image</param>
        /// <param name="right">The right image</param>
        /// <param name="disparityMap">The left disparity map</param>
        /// <param name="points">The 3D point cloud within a [-0.5, 0.5] cube</param>
        private static void Computer3DPointsFromStereoPair(Image <Gray, Byte> left, Image <Gray, Byte> right, out Image <Gray, short> disparityMap, out MCvPoint3D32f[] points)
        {
            Size size = left.Size;

            disparityMap = new Image <Gray, short>(size);
            //using (StereoSGBM stereoSolver = new StereoSGBM(5, 64, 0, 0, 0, 0, 0, 0, 0, 0, false))
            using (StereoBM stereoSolver = new StereoBM(Emgu.CV.CvEnum.STEREO_BM_TYPE.BASIC, 0))
            {
                stereoSolver.FindStereoCorrespondence(left, right, disparityMap);

                //Construct a simple Q matrix, if you have a matrix from cvStereoRectify, you should use that instead
                using (Matrix <double> q = new Matrix <double>(
                           new double[, ] {
                    { 1.0, 0.0, 0.0, -size.Width / 2 },  //shift the x origin to image center
                    { 0.0, 1.0, 0.0, -size.Height / 2 }, //shift the y origin to image center
                    { 0.0, 0.0, 1.0, 0.0 },              //Multiply the z value by 1.0,
                    { 0.0, 0.0, 0.0, 1.0 }
                }))
                    points = PointCollection.ReprojectImageTo3D(disparityMap, q);
            }
        }
Exemplo n.º 13
0
        // Use this for initialization
        void Start()
        {
            //Read the left and right images
            Texture2D texLeft  = Resources.Load("tsukuba_l") as Texture2D;
            Texture2D texRight = Resources.Load("tsukuba_r") as Texture2D;
            Mat       imgLeft  = new Mat(texLeft.height, texLeft.width, CvType.CV_8UC1);
            Mat       imgRight = new Mat(texRight.height, texRight.width, CvType.CV_8UC1);

            Utils.texture2DToMat(texLeft, imgLeft);
            Utils.texture2DToMat(texRight, imgRight);
            //or
            //Mat imgLeft = Imgcodecs.imread (Utils.getFilePath ("tsukuba_l.png"), Imgcodecs.IMREAD_GRAYSCALE);
            //Mat imgRight = Imgcodecs.imread (Utils.getFilePath ("tsukuba_r.png"), Imgcodecs.IMREAD_GRAYSCALE);


            Mat imgDisparity16S = new Mat(imgLeft.rows(), imgLeft.cols(), CvType.CV_16S);
            Mat imgDisparity8U  = new Mat(imgLeft.rows(), imgLeft.cols(), CvType.CV_8UC1);

            if (imgLeft.empty() || imgRight.empty())
            {
                Debug.Log("Error reading images ");
            }

            StereoBM sbm = StereoBM.create(16, 15);

            sbm.compute(imgLeft, imgRight, imgDisparity16S);

            //normalize to CvType.CV_8U
            Core.normalize(imgDisparity16S, imgDisparity8U, 0, 255, Core.NORM_MINMAX, CvType.CV_8U);


            Texture2D texture = new Texture2D(imgDisparity8U.cols(), imgDisparity8U.rows(), TextureFormat.RGBA32, false);

            Utils.matToTexture2D(imgDisparity8U, texture);

            gameObject.GetComponent <Renderer> ().material.mainTexture = texture;
        }
Exemplo n.º 14
0
 internal static extern void cvFindStereoCorrespondenceBM(Arr left, Arr right, Arr disparity, StereoBM state);