public void DetectConnectedObjects()
        {
            DenseMatrix dmDataBinary = dmSourceData.Copy();

            dmDataBinary.MapInplace(dVal => (dVal >= slicingThresholdingValue) ? (1.0d) : (0.0d));
            Image <Gray, Byte> imgDataBinary = ImageProcessing.grayscaleImageFromDenseMatrixWithFixedValuesBounds(dmDataBinary, 0.0d, 1.0d);

            previewImage = imgDataBinary.CopyBlank().Convert <Bgr, Byte>();
            // VectorOfVectorOfPoint contoursDetected = new VectorOfVectorOfPoint();
            List <Contour <Point> > edgeContoursList = imgDataBinary.DetectContours();

            #region // EmguCV 3.0
            //CvInvoke.FindContours(imgDataBinary, contoursDetected, null, RetrType.List,
            //    ChainApproxMethod.ChainApproxSimple);
            //imgDataBinary.FindContours(Emgu.CV.CvEnum.CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,
            //    Emgu.CV.CvEnum.RETR_TYPE.CV_RETR_LIST);
            //edgeContoursList = new List<VectorOfPoint>();
            //int count = contoursDetected.Size;
            //for (int i = 0; i < count; i++)
            //{
            //    Color currentColor = colorGen.GetNext();
            //    var currentColorBgr = new Bgr(currentColor);
            //    using (VectorOfPoint currContour = contoursDetected[i])
            //    {
            //        edgeContoursList.Add(currContour);
            //        previewImage.Draw(currContour.ToArray(), currentColorBgr, -1);
            //    }
            //}
            #endregion // EmguCV 3.0


            RandomPastelColorGenerator colorGen = new RandomPastelColorGenerator();

            foreach (Contour <Point> currContour in edgeContoursList)
            {
                Color currentColor    = colorGen.GetNext();
                Bgr   currentColorBgr = new Bgr(currentColor);
                previewImage.Draw(currContour, currentColorBgr, -1);
            }
        }
        public void Clusterize()
        {
            ArithmeticsOnImages aoi = new ArithmeticsOnImages();

            aoi.dmY        = dmDensityMesh;
            aoi.ExprString = "grad5p(Y)";
            aoi.RPNeval(true);
            List <DenseMatrix> lDMGradField = aoi.lDMRes;


            DenseMatrix dmMask = dmDensityMesh.Copy();

            dmMask.MapIndexedInplace((r, c, dVal) =>
            {
                // r = y - perc5
                // c = x - median
                Point currPt = new Point(c, r);
                return((conditionOnPoints(currPt)) ? (1.0d) : (0.0d));
                //if (r > c) return 0.0d;
                //else return 1.0d;
            });
            Image <Gray, Byte> imgMask = ImageProcessing.grayscaleImageFromDenseMatrixWithFixedValuesBounds(dmMask, 0.0d, 1.0d);

            // imgMask = imgMask.Flip(FlipType.Vertical);
            imgMask = imgMask.Flip(FLIP.VERTICAL);



            // отфильтровать малые значения - ?

            // выделить классы

            List <ConnectedObjectsAtASlice> lSlicesData = new List <ConnectedObjectsAtASlice>();
            double dthresholdingMaxValue = dmDensityMesh.Values.Max();
            //double dthresholdingMinValue = dmSmoothed.Values.Min();
            double dthresholdingMinValue = 0.0d;
            double dthresholdingDiscrete = (dthresholdingMaxValue - dthresholdingMinValue) / 30.0d;

            for (double dThresholding = dthresholdingMaxValue; dThresholding > dthresholdingMinValue - dthresholdingDiscrete; dThresholding -= dthresholdingDiscrete)
            {
                ConnectedObjectsAtASlice corrSliceObj = new ConnectedObjectsAtASlice(dmDensityMesh, dmDensityMeshXcoord,
                                                                                     dmDensityMeshYcoord, dThresholding);
                corrSliceObj.DetectConnectedObjects();
                //ServiceTools.ShowPicture(corrSliceObj.previewImage, "thresholding value = " + dThresholding.ToString("e"));
                lSlicesData.Add(corrSliceObj);
            }


            ConnectedObjectsAtASlice prevSlice = lSlicesData[0];

            foundClassesContours.AddRange(prevSlice.edgeContoursList);

            foreach (ConnectedObjectsAtASlice currSlice in lSlicesData)
            {
                if (lSlicesData.IndexOf(currSlice) == 0)
                {
                    continue;                                      // самый верхний пропускаем
                }
                //List<Tuple<Contour<Point>, Contour<Point>>> currSliceCoveringContours =
                //    new List<Tuple<Contour<Point>, Contour<Point>>>();
                List <Tuple <Contour <Point>, Contour <Point> > > currSliceCoveringContours =
                    new List <Tuple <Contour <Point>, Contour <Point> > >();
                //item1 - внутренний, из предыдущего слайса
                //item2 - внешний, из текущего слайса

                foreach (Contour <Point> caughtCont in foundClassesContours)
                {
                    Contour <Point> coveringCaughtCont = currSlice.FindContourContainingSample(caughtCont);
                    currSliceCoveringContours.Add(new Tuple <Contour <Point>, Contour <Point> >(caughtCont,
                                                                                                coveringCaughtCont));
                }

                // добавим контуры, которые только что появились и раньше не были видны на срезах
                // но только если количество допустимых клатеров еще позволяет
                // Иначе - будем ждать, когда они вольются в в какой-нибудь из вновь расширившихся контуров
                foreach (Contour <Point> newContour in currSlice.edgeContoursList)
                {
                    if ((currSliceCoveringContours.Find(tpl => (tpl.Item2 == newContour)) == null) && (currSliceCoveringContours.Count() < maxClustersCount))
                    {
                        currSliceCoveringContours.Add(new Tuple <Contour <Point>, Contour <Point> >(newContour, newContour));
                    }
                }

                // что делать, если какой-нибудь новый контур покрывает больше одного предыдущего
                List <IGrouping <Contour <Point>, Tuple <Contour <Point>, Contour <Point> > > > groups =
                    new List <IGrouping <Contour <Point>, Tuple <Contour <Point>, Contour <Point> > > >
                        (currSliceCoveringContours.GroupBy(tpl => tpl.Item2));
                if (groups.Count(grp => (grp.Count() > 1)) > 0)
                {
                    // есть контуры текущего среза, которые содержат более одного контура предыдущего среза
                    foreach (IGrouping <Contour <Point>, Tuple <Contour <Point>, Contour <Point> > > currGroup in groups)
                    {
                        if (currGroup.Count() == 1)
                        {
                            Tuple <Contour <Point>, Contour <Point> > contourTuple = currGroup.First();
                            foundClassesContours.Remove(contourTuple.Item1);
                            foundClassesContours.Add(contourTuple.Item2);
                        }
                        else
                        {
                            // currGroup - группа кортежей контуров, где
                            //              item1 - внутренний, из предыдущего слайса
                            //              item2 - внешний, из текущего слайса
                            // надо точки, которые лежат вне контуров предыдущего слайса отнести к "своим" контурам
                            // попробуем по направлению градиента - относить точку к тому контуру, на который укажет вектор градиента
                            Contour <Point> currCoveringContour = currGroup.Key; // item2 - внешний, из текущего слайса - см.строку группировки



                            Rectangle currCoveringContourBoundingRectangle = currCoveringContour.BoundingRectangle;

                            Image <Gray, byte> tmpImg1 =
                                new Image <Gray, byte>(new Size(currCoveringContourBoundingRectangle.Right,
                                                                currCoveringContourBoundingRectangle.Bottom));
                            tmpImg1.Draw(currCoveringContour, white, -1);
                            foreach (Tuple <Contour <Point>, Contour <Point> > tpl in currGroup)
                            {
                                Contour <Point>    excludingCntr = tpl.Item1;
                                Image <Gray, byte> tmpExcl       = tmpImg1.CopyBlank();
                                tmpExcl.Draw(excludingCntr, white, -1);
                                tmpImg1 = tmpImg1 - tmpExcl;
                            }
                            // в картинке tmpImg1 закрашенными остались только точки, которые надо классифицировать
                            List <Point> lPointsToClassify = new List <Point>();

                            for (int x = 0; x < tmpImg1.Width; x++)
                            {
                                for (int y = 0; y < tmpImg1.Height; y++)
                                {
                                    Point currPt = new Point(x, y);
                                    if (tmpImg1[currPt].Equals(white))
                                    {
                                        lPointsToClassify.Add(currPt);
                                    }
                                }
                            }

                            List <List <Point> > llArraysOfPointsAdding = new List <List <Point> >();
                            foreach (Tuple <Contour <Point>, Contour <Point> > tpl in currGroup)
                            {
                                llArraysOfPointsAdding.Add(new List <Point>());
                            }

                            List <Contour <Point> > lContoursOfTheCurrGroup =
                                (new List <Tuple <Contour <Point>, Contour <Point> > >(currGroup.ToArray())).ConvertAll(
                                    tpl => tpl.Item1);
                            List <PointD>   lPtdMassCenters       = lContoursOfTheCurrGroup.ConvertAll(cntr => cntr.MassCenter());
                            Contour <Point> themassCentersPolygon = new Contour <Point>(new MemStorage());
                            themassCentersPolygon.PushMulti(lPtdMassCenters.ConvertAll <Point>(ptd => ptd.Point()).ToArray(),
                                                            BACK_OR_FRONT.BACK);
                            //themassCentersPolygon.Push(lPtdMassCenters.ConvertAll<Point>(ptd => ptd.Point()).ToArray());
                            Image <Gray, byte> tmpImg = imgMask.CopyBlank();
                            tmpImg.Draw(themassCentersPolygon, white, -1);
                            themassCentersPolygon = tmpImg.DetectContours()[0];



                            foreach (Point currPtToClassify in lPointsToClassify)
                            {
                                int cntrToAddPointTo = AttachPointToOneOfConcurrentContours(
                                    lContoursOfTheCurrGroup,
                                    lPtdMassCenters,
                                    themassCentersPolygon,
                                    currPtToClassify,
                                    lDMGradField);
                                if (cntrToAddPointTo == -1)
                                {
                                    continue;
                                }
                                else
                                {
                                    llArraysOfPointsAdding[cntrToAddPointTo].Add(currPtToClassify);
                                }
                            }
                            // распределили. теперь надо сформировать новые контуры - с учетом добавленных точек.
                            List <Image <Gray, byte> > lImagesToDetectNewContours = new List <Image <Gray, byte> >();
                            foreach (Tuple <Contour <Point>, Contour <Point> > tpl in currGroup)
                            {
                                Image <Gray, byte> tmpImgCurrCont = tmpImg1.CopyBlank();
                                tmpImgCurrCont.Draw(tpl.Item1, white, -1);
                                lImagesToDetectNewContours.Add(tmpImgCurrCont);
                            }


                            for (int cntIdx = 0; cntIdx < currGroup.Count(); cntIdx++)
                            {
                                foreach (Point pt in llArraysOfPointsAdding[cntIdx])
                                {
                                    lImagesToDetectNewContours[cntIdx][pt.Y, pt.X] = white;
                                }

                                #region // obsolete
                                //Contour<Point> cnt1 =
                                //    lImagesToDetectNewContours[cntIdx].FindContours(
                                //        Emgu.CV.CvEnum.CHAIN_APPROX_METHOD.CV_CHAIN_APPROX_SIMPLE,
                                //        Emgu.CV.CvEnum.RETR_TYPE.CV_RETR_LIST);
                                //List<Contour<Point>> lTmpCtrs = new List<Contour<Point>>();
                                //while (true)
                                //{
                                //    lTmpCtrs.Add(cnt1);
                                //    cnt1 = cnt1.HNext;
                                //    if (cnt1 == null)
                                //        break;
                                //}
                                #endregion // obsolete

                                ////найдем наибольший из получившихся контуров
                                List <Contour <Point> > lTmpCtrs = lImagesToDetectNewContours[cntIdx].DetectContours();

                                foundClassesContours.Remove(currGroup.ElementAt(cntIdx).Item1);
                                double maxArea             = lTmpCtrs.Max(cntr => cntr.Area);
                                int    idxOfMaxAreaContour = lTmpCtrs.FindIndex(cntr => cntr.Area >= maxArea);
                                foundClassesContours.Add(lTmpCtrs[idxOfMaxAreaContour]);
                            }
                        }
                    }
                }
                else
                {
                    foreach (Tuple <Contour <Point>, Contour <Point> > contourTuple in currSliceCoveringContours)
                    {
                        foundClassesContours.Remove(contourTuple.Item1);
                        foundClassesContours.Add(contourTuple.Item2);
                    }
                }
                //theLogWindow = ServiceTools.LogAText(theLogWindow,
                //    "processing thresholding value = " + currSlice.slicingThresholdingValue, true);
            }


            //theLogWindow = ServiceTools.LogAText(theLogWindow,
            //        Environment.NewLine +
            //        "========" + Environment.NewLine +
            //        "FINISHED" + Environment.NewLine +
            //        "========" + Environment.NewLine, true);

            Image <Gray, Byte> imgDataBinary = ImageProcessing.grayscaleImageFromDenseMatrixWithFixedValuesBounds(dmDensityMesh, 0.0d, 1.0d);
            Image <Bgr, byte>  previewImage  = imgDataBinary.CopyBlank().Convert <Bgr, Byte>();
            var colorGen = new RandomPastelColorGenerator();
            foreach (Contour <Point> currCntr in foundClassesContours)
            {
                Color currentColor    = colorGen.GetNext();
                var   currentColorBgr = new Bgr(currentColor);
                previewImage.Draw(currCntr, currentColorBgr, -1);
            }
            previewImage = previewImage.And(imgMask.Convert <Bgr, byte>());
            ServiceTools.ShowPicture(previewImage, "");
        }