public List <RegMesh2D> Generate(IContour contour) { IPoint[,] points = new Point[this.nY, this.nX]; ICurve a1 = contour[0]; ICurve a2 = contour[1]; ICurve a3 = contour[2]; ICurve a4 = contour[3]; for (int i = 0; i < this.nY; i++) { double xA, yA, xB, yB; a4.getPoint(1 - i * hY, out xA, out yA); a2.getPoint(i * hY, out xB, out yB); ICurve curve = new Relocate(new Morph(a1, a3, i * hY), new Point(xA, yA), new Point(xB, yB)); for (int j = 0; j < this.nX; j++) { double x, y; curve.getPoint(j * hX, out x, out y); points[i, j] = new Point(x, y); } } return(new List <RegMesh2D>() { new RegMesh2D(points, nX, nY) }); }
static Poly2Tri.Polygon CreatePolygon(IContour cnt) { using (Borrow(out List <Poly2Tri.TriangulationPoint> points)) { //limitation: poly tri not accept duplicated points! *** double prevX = 0; double prevY = 0; int j = cnt.VertexCount; for (int i = 0; i < j; ++i) { cnt.GetVertex(i, out float x, out float y, out object userData); if (x == prevX && y == prevY) { if (i > 0) { //skip duplicated point, not use continue; } } else { //var triPoint = new Poly2Tri.TriangulationPoint(prevX = x, prevY = y) { userData = p }; //points.Add(triPoint); points.Add(new Poly2Tri.TriangulationPoint(prevX = x, prevY = y, userData)); } } return(new Poly2Tri.Polygon(points.ToArray())); } }
/** * @brief Retrieve an IContour object using index (that relates to the given order). * @param[in] index - the zero-based index of the requested contour (between 0 and QueryNumberOfContours()-1 ). * @param[out] contourData - contains the extracted contour line data. * * @return PXCM_STATUS_NO_ERROR - successful operation. * @return PXCM_STATUS_DATA_UNAVAILABLE - index >= number of detected contours. * * @see IContour */ public pxcmStatus QueryContour(Int32 index, out IContour contourData) { IntPtr cd2; pxcmStatus sts = PXCMBlobData_IBlob_QueryContour(instance, index, out cd2); contourData = (sts >= pxcmStatus.PXCM_STATUS_NO_ERROR) ? new IContour(cd2) : null; return(sts); }
public List <RegMesh2D> Generate(IContour contour) { this.mesh = new List <RegMesh2D>(); contourArray = decompos.decomposed(contour); for (int i = 0; i < 3; i++) { mesh.Add(meshgen.Generate(contourArray[i])[0]); } return(mesh); }
// находит цетр для треугольника /// <summary> /// chahged method for find center of pentagon /// </summary> /// <param name="contour"></param> /// <returns> contour</returns> private IPoint findCenterPentagon(IContour contour) { pointsOfCurvs = new List <IPoint>(); IPoint[] points = new IPoint[3]; for (int i = 0; i < 5; ++i) { contour[i].accept(this); } return(new Geometry.Point((pointsOfCurvs[0].X + pointsOfCurvs[1].X + pointsOfCurvs[2].X + pointsOfCurvs[3].X + pointsOfCurvs[4].X) / 5, (pointsOfCurvs[0].Y + pointsOfCurvs[1].Y + pointsOfCurvs[2].Y + pointsOfCurvs[3].Y + pointsOfCurvs[4].Y) / 5)); }
public List <RegMesh2D> Generate(IContour contour) { this.mesh = new List <RegMesh2D>(); this.contour = contour; numOfCurvs = contour.Size; switch (numOfCurvs) { case 4: lenghtOfPart = getSizeOfPart(Tools.length(contour[0])); createVectorOfParam(); mesh.Add(new RegMesh2D(nY, nX)); fillMesh(); return(mesh); default: return(null); } }
public IContour[] decomposed(IContour contour) { triangles = new List <IContour>(); pointOfMiddle = findCenterPentagon(contour); // create five triangles for pentagon triangles.Add(new Contour(new List <ICurve> { contour[0], new Line(pointsOfCurvs[1], pointOfMiddle), new Line(pointOfMiddle, pointsOfCurvs[0]) })); triangles.Add(new Contour(new List <ICurve> { contour[1], new Line(pointsOfCurvs[2], pointOfMiddle), new Line(pointOfMiddle, pointsOfCurvs[1]) })); triangles.Add(new Contour(new List <ICurve> { contour[2], new Line(pointsOfCurvs[3], pointOfMiddle), new Line(pointOfMiddle, pointsOfCurvs[2]) })); triangles.Add(new Contour(new List <ICurve> { contour[3], new Line(pointsOfCurvs[4], pointOfMiddle), new Line(pointOfMiddle, pointsOfCurvs[3]) })); triangles.Add(new Contour(new List <ICurve> { contour[4], new Line(pointsOfCurvs[0], pointOfMiddle), new Line(pointOfMiddle, pointsOfCurvs[4]) })); return(triangles.ToArray()); }
public IContour[] decomposed(IContour contour) { pointsOfCurvs = new List <IPoint>(); generalPoints = new List <IPoint>(); preDecompose = new List <ICurve>(); finalDecompose = new List <IContour>(); for (int i = 0; i < 5; i++) //вызываем кривые, чтобы они вызвали метод visitLine и отдали нам свои точки в pointsOfCurvs { contour[i].accept(this); } preDecompose.Add((new Line(pointsOfCurvs[0], pointsOfCurvs[2]))); //0 preDecompose.Add((new Line(pointsOfCurvs[0], pointsOfCurvs[3]))); //1 preDecompose.Add((new Line(pointsOfCurvs[1], pointsOfCurvs[3]))); //2 preDecompose.Add((new Line(pointsOfCurvs[1], pointsOfCurvs[4]))); //3 preDecompose.Add((new Line(pointsOfCurvs[2], pointsOfCurvs[4]))); //4 generalPoints.Add(findGeneralPoints(preDecompose[0], preDecompose[3])); //1 generalPoints.Add(findGeneralPoints(preDecompose[0], preDecompose[2])); //2 generalPoints.Add(findGeneralPoints(preDecompose[4], preDecompose[2])); //3 generalPoints.Add(findGeneralPoints(preDecompose[1], preDecompose[4])); //4 generalPoints.Add(findGeneralPoints(preDecompose[3], preDecompose[1])); //5 finalDecompose.Add(new Contour(new List <ICurve> { contour[0], new Line(pointsOfCurvs[1], generalPoints[4]), new Line(generalPoints[4], pointsOfCurvs[0]) })); finalDecompose.Add(new Contour(new List <ICurve> { contour[1], new Line(pointsOfCurvs[2], generalPoints[0]), new Line(generalPoints[0], pointsOfCurvs[1]) })); finalDecompose.Add(new Contour(new List <ICurve> { contour[3], contour[4], new Line(pointsOfCurvs[0], pointsOfCurvs[3]) })); finalDecompose.Add(new Contour(new List <ICurve> { new Line(generalPoints[0], pointsOfCurvs[2]), contour[2], new Line(pointsOfCurvs[3], generalPoints[4]), new Line(generalPoints[4], generalPoints[0]) })); return(finalDecompose.ToArray()); }
/* Displaying Depth/Mask Images - for depth image only we use a delay of NumberOfFramesToDelay to sync image with tracking */ private unsafe void DisplayPicture(Image depth, HandData handAnalysis) { if (depth == null) { return; } Image image = depth; //Mask Image if (_form.GetLabelmapState()) { System.Drawing.Bitmap labeledBitmap = null; try { int numOfHands = handAnalysis.NumberOfHands; PointI32[][] pointOuter = new PointI32[numOfHands][]; PointI32[][] pointInner = new PointI32[numOfHands][]; labeledBitmap = new System.Drawing.Bitmap(image.Info.width, image.Info.height, System.Drawing.Imaging.PixelFormat.Format32bppRgb); for (int j = 0; j < numOfHands; j++) { int id; ImageData data; handAnalysis.QueryHandId(AccessOrderType.ACCESS_ORDER_BY_TIME, j, out id); //Get hand by time of appearance IHand handData; handAnalysis.QueryHandData(AccessOrderType.ACCESS_ORDER_BY_TIME, j, out handData); if (handData != null) { image = handData.SegmentationImage; if (image != null) { if (image.AcquireAccess(ImageAccess.ACCESS_READ, PixelFormat.PIXEL_FORMAT_Y8, out data) >= Status.STATUS_NO_ERROR) { var rect = new System.Drawing.Rectangle(0, 0, image.Info.width, image.Info.height); var bitmapdata = labeledBitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, labeledBitmap.PixelFormat); byte *numPtr = (byte *)bitmapdata.Scan0; //dst byte *numPtr2 = (byte *)data.planes[0]; //row int imagesize = image.Info.width * image.Info.height; byte num2 = (_form.GetFullHandModeState()) ? (byte)handData.BodySide : (byte)1; byte tmp = 0; for (int i = 0; i < imagesize; i++, numPtr += 4, numPtr2++) { tmp = (byte)(_lut[numPtr2[0]] * num2 * 100); numPtr[0] = (Byte)(tmp | numPtr[0]); numPtr[1] = (Byte)(tmp | numPtr[1]); numPtr[2] = (Byte)(tmp | numPtr[2]); numPtr[3] = 0xff; } labeledBitmap.UnlockBits(bitmapdata); image.ReleaseAccess(data); } if ((_form.GetContourState())) { int contourNumber = handData.NumberOfContours; if (contourNumber > 0) { for (int k = 0; k < contourNumber; ++k) { IContour contour = handData.Contours[k]; if (contour != null) { if (contour.Outer) { pointOuter[j] = contour.Points; } else { pointInner[j] = contour.Points; } } } } } } } } if (labeledBitmap != null) { _form.DisplayBitmap(labeledBitmap); labeledBitmap.Dispose(); } if (image != null) { image.Dispose(); } for (int i = 0; i < numOfHands; i++) { if (_form.GetContourState()) { if (pointOuter[i] != null && pointOuter[i].Length > 0) { _form.DisplayContour(pointOuter[i], i); } if (pointInner[i] != null && pointInner[i].Length > 0) { _form.DisplayContour(pointInner[i], i); } } } } catch (Exception) { if (labeledBitmap != null) { labeledBitmap.Dispose(); } if (image != null) { image.Dispose(); } } } //end label image //Depth Image else { //collecting 3 images inside a queue and displaying the oldest image ImageInfo info; Image image2; ImageData imageData = new ImageData(); info = image.Info; image2 = Image.CreateInstance(_form.session, info, imageData); //image2 = _form.g_session. CreateImage(info); if (image2 == null) { return; } image2.CopyImage(image); _mImages.Enqueue(image2); if (_mImages.Count == NumberOfFramesToDelay) { System.Drawing.Bitmap depthBitmap; try { depthBitmap = new System.Drawing.Bitmap(image.Info.width, image.Info.height, System.Drawing.Imaging.PixelFormat.Format32bppRgb); } catch (Exception) { image.Dispose(); Image queImage = _mImages.Dequeue(); queImage.Dispose(); return; } ImageData data3; Image image3 = _mImages.Dequeue(); if (image3.AcquireAccess(ImageAccess.ACCESS_READ, PixelFormat.PIXEL_FORMAT_DEPTH, out data3) >= Status.STATUS_NO_ERROR) { float fMaxValue = _maxRange; byte cVal; var rect = new System.Drawing.Rectangle(0, 0, image.Info.width, image.Info.height); var bitmapdata = depthBitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, depthBitmap.PixelFormat); byte * pDst = (byte *)bitmapdata.Scan0; short *pSrc = (short *)data3.planes[0]; int size = image.Info.width * image.Info.height; for (int i = 0; i < size; i++, pSrc++, pDst += 4) { cVal = (byte)((*pSrc) / fMaxValue * 255); if (cVal != 0) { cVal = (byte)(255 - cVal); } pDst[0] = cVal; pDst[1] = cVal; pDst[2] = cVal; pDst[3] = 255; } try { depthBitmap.UnlockBits(bitmapdata); } catch (Exception) { image3.ReleaseAccess(data3); depthBitmap.Dispose(); image3.Dispose(); return; } _form.DisplayBitmap(depthBitmap); image3.ReleaseAccess(data3); } depthBitmap.Dispose(); image3.Dispose(); } } }
//public IContour[] decomposed(IContour contour) //{ // for (int i = 0; i < contour.Size; i++) // { // IContour[] cc = decomposed(contour, i); // //оценка. // //рекорд // } //} public IContour[] decomposed(IContour contour /*, int nom*/) { points = new List <IPoint>(); for (int i = 0; i < contour.Size; i++) { contour[i].accept(this); } List <IContour> contours = new List <IContour>(); double best_grade = -1; int best_index = 0; for (int i = 0; i < 5; i++) { // Декомпозиция // Треугольник contours.Add(new Contour(new List <ICurve> { contour[0], contour[1], new Line(points[2], points[0]) })); // Четырёхугольник contours.Add(new Contour(new List <ICurve> { contour[2], contour[3], contour[4], new Line(points[0], points[2]) })); // считаем качество // Треугольник double contour_grade = 0; IMeshGen generator = new TriaMeshGen(10, 10); List <RegMesh2D> meshs = generator.Generate(contours[0]); foreach (RegMesh2D j in meshs) { contour_grade += new ArithmMeanGrade().Calculate(j); } // Четырёхугольник generator = new QuadCleverMeshGen(10, 10); meshs = generator.Generate(contours[1]); contour_grade += new ArithmMeanGrade().Calculate(meshs[0]); contour_grade = contour_grade / 4.0; if (contour_grade > best_grade) { best_grade = contour_grade; best_index = i; } // мешаем точки IPoint tmp_point = points[0]; points.RemoveAt(0); points.Add(tmp_point); } // в соответствии с индексом восстанавливаем порядок точек for (int i = 0; i < best_index; i++) { IPoint tmp_point = points[0]; points.RemoveAt(0); points.Add(tmp_point); } contours.Clear(); contours.Add(new Contour(new List <ICurve> { contour[0], contour[1], new Line(points[2], points[0]) })); contours.Add(new Contour(new List <ICurve> { contour[2], contour[3], contour[4], new Line(points[0], points[2]) })); return(contours.ToArray()); }
public override void CutOff(IContour wnd, bool outer) { List<Point> segments = new List<Point>(); int inext; int iprev; foreach (IContour cont in this.Contours) { for(int i = 0, n = cont.Points.Count - 1; i <= n; ++i) { if (i < n) { inext = i + 1; } else { inext = 0; } if (i > 0) { iprev = i - 1; } else { iprev = n; } if (outer) { wnd.CalcSegmentIntersection( cont.Points[i], cont.Points[inext], null, segments ); } else { wnd.CalcSegmentIntersection( cont.Points[i], cont.Points[inext], segments, null ); } } for (int i = 0, n = wnd.Points.Count - 1; i <= n; ++i) { if (i < n) { inext = i + 1; } else { inext = 0; } if (i > 0) { iprev = i - 1; } else { iprev = n; } cont.CalcSegmentIntersection( wnd.Points[i], wnd.Points[inext], null, segments ); } } // foreach cont _contCol.Clear(); _contCol.AddRange(BasicRegion.GenerateContours(segments)); }
/** @brief Retrieve an IContour object using index (that relates to the given order). @param[in] index - the zero-based index of the requested contour (between 0 and QueryNumberOfContours()-1 ). @param[out] contourData - contains the extracted contour line data. @return PXCM_STATUS_NO_ERROR - successful operation. @return PXCM_STATUS_DATA_UNAVAILABLE - index >= number of detected contours. @see IContour */ public pxcmStatus QueryContour(Int32 index, out IContour contourData) { IntPtr cd2; pxcmStatus sts = PXCMBlobData_IBlob_QueryContour(instance, index, out cd2); contourData = (sts >= pxcmStatus.PXCM_STATUS_NO_ERROR) ? new IContour(cd2) : null; return sts; }
public abstract void CutOff(IContour wnd, bool outer);
public IContour[] decomposed(IContour contour) { Geometry.IPoint[] newPoints = new Geometry.Point[contour.Size]; //пустой массив для середин линий List <IContour> decFigures = new List <IContour>(); //пустая коллекция для фигур for (int i = 0; i < contour.Size; ++i) //находим середины линий { double x, y; contour[i].getPoint(PART, out x, out y); newPoints[i] = new Geometry.Point(x, y); } //поиск точки центра масс Geometry.IPoint L = new Geometry.Point((newPoints[0].X + newPoints[1].X + newPoints[2].X) / 3, (newPoints[0].Y + newPoints[1].Y + newPoints[2].Y) / 3); MaxPoint = L; for (int i = 0; i < contour.Size; ++i) //что это должно делать { List <ICurve> lines = new List <ICurve>(); int index = i == 0 ? newPoints.Length - 1 : i - 1; lines.Add(new SubCurve(contour[i], 0, PART)); lines.Add(new Line(newPoints[i], L)); lines.Add(new Line(L, newPoints[index])); lines.Add(new SubCurve(contour[index], PART, 1)); decFigures.Add(new Contour(lines)); //Max += grade.Calculate(gen.Generate(new Contour(lines))[0]); } /* * Max = Max / contour.Size; * * while (flag == false) * { * double Local = 0; * double LocalMax = 0; * IPoint LocalMaxPoint = null; * for (int j = 0; j < 4; j++) * { * switch (j) * { * case 0: * L.X = MaxPoint.X + alpha; * L.Y = MaxPoint.Y; * break; * case 1: * L.X = MaxPoint.X - alpha; * L.Y = MaxPoint.Y; * break; * case 2: * L.X = MaxPoint.X ; * L.Y = MaxPoint.Y + alpha; * break; * case 3: * L.X = MaxPoint.X ; * L.Y = MaxPoint.Y - alpha; * break; * } * * for (int i = 0; i < contour.Size; ++i) //что это должно делать * { * List<ICurve> lines = new List<ICurve>(); * int index = i == 0 ? newPoints.Length - 1 : i - 1; * * lines.Add(new SubCurve(contour[i], 0, PART)); * lines.Add(new Line(newPoints[i], L)); * lines.Add(new Line(L, newPoints[index])); * lines.Add(new SubCurve(contour[index], PART, 1)); * Local += grade.Calculate(gen.Generate(new Contour(lines))[0]); * } * Local = Local / contour.Size; * if (Local > LocalMax) * { * LocalMax = Local; * LocalMaxPoint = L; * Local = 0; * } * } * if (Max - LocalMax < -alpha) * { * Max = LocalMax; * MaxPoint = LocalMaxPoint; * } * else * { * flag = true; * } * } * * for (int i = 0; i < contour.Size; ++i) //что это должно делать * { * List<ICurve> lines = new List<ICurve>(); * int index = i == 0 ? newPoints.Length - 1 : i - 1; * * lines.Add(new SubCurve(contour[i], 0, PART)); * lines.Add(new Line(newPoints[i], MaxPoint)); * lines.Add(new Line(MaxPoint, newPoints[index])); * lines.Add(new SubCurve(contour[index], PART, 1)); * decFigures.Add(new Contour(lines)); * } */ return(decFigures.ToArray()); }
public void Add(IContour contour) { contours.Add(contour); }
/// <summary> /// Добавить точки другого контура, применив /// к ним трансформацию. /// </summary> /// <param name="contour">Контур, из которого копируются точки.</param> /// <param name="trans">Трансформация, которая примениться к точкам.</param> public void AddWithTransform(IContour contour, Transform trans) { foreach (Point pnt in contour.Points) DrawningPoints.Add(trans.Apply(pnt)); }
//------- public void Triangulate <T>(IList <T> contours, List <Poly2Tri.Polygon> outputPolygons) where T : IContour { _waitingHoles.Clear(); _flattenContours.Clear(); //-------------------------- //TODO: review here, add hole or not // more than 1 contours, no hole => eg. i, j, ;, etc // more than 1 contours, with hole => eg. a,e , etc //clockwise => not hole int cntCount = contours.Count; Poly2Tri.Polygon mainPolygon = null; // //this version if it is a hole=> we add it to main polygon //TODO: add to more proper polygon *** //eg i //-------------------------- List <Poly2Tri.Polygon> otherPolygons = null; for (int n = 0; n < cntCount; ++n) { IContour cnt = contours[n]; bool cntIsMainPolygon = cnt.IsClockwise; //if (yAxisFlipped) //{ // cntIsMainPolygon = !cntIsMainPolygon; //} if (cntIsMainPolygon) { //main polygon //not a hole if (mainPolygon == null) { //if we don't have mainPolygon before //this is main polygon mainPolygon = CreatePolygon(cnt); if (_waitingHoles.Count > 0) { //flush all waiting holes to the main polygon int j = _waitingHoles.Count; for (int i = 0; i < j; ++i) { mainPolygon.AddHole(_waitingHoles[i]); } _waitingHoles.Clear(); } } else { //if we already have a main polygon //then this is another sub polygon //IsHole is correct after we Analyze() the glyph contour Poly2Tri.Polygon subPolygon = CreatePolygon(cnt); if (otherPolygons == null) { otherPolygons = new List <Poly2Tri.Polygon>(); } otherPolygons.Add(subPolygon); } } else { //this is a hole Poly2Tri.Polygon subPolygon = CreatePolygon(cnt); if (mainPolygon == null) { //add to waiting polygon _waitingHoles.Add(subPolygon); } else { //add to mainPolygon mainPolygon.AddHole(subPolygon); } } } if (_waitingHoles.Count > 0) { throw new NotSupportedException(); } //------------------------------------------ //2. tri angulate Poly2Tri.P2T.Triangulate(mainPolygon); //that poly is triangulated outputPolygons.Add(mainPolygon); if (otherPolygons != null) { outputPolygons.AddRange(otherPolygons); for (int i = otherPolygons.Count - 1; i >= 0; --i) { Poly2Tri.P2T.Triangulate(otherPolygons[i]); } } //------------------------------------------ _waitingHoles.Clear(); _flattenContours.Clear(); }
private void pictureBox1_Paint (object sender, System.Windows.Forms.PaintEventArgs e) { Graphics g = e.Graphics; TContourEdit contour = new TContourEdit(); Random random = new Random(); int countPoint=0; //List<Point> points = new List<Point>(); for (int i=0; i<2; i++) { TContourBitEdit contourBitEdit = new TContourBitEdit(); //for(int y=10; y<100; y*=2) //{ // int ran = random.Next(100); // contourBitEdit.AddPoint(ran + y*3, i * 2 + ran, 0); // // points.Add(new Point(ran + y * 3, i * 2 + ran)); // countPoint++; //} if(i==0) { contourBitEdit.AddPoint(10, 5, 0); contourBitEdit.AddPoint(10, 50, 0); contourBitEdit.AddPoint(50, 100, 0); } if(i==1) { contourBitEdit.AddPoint(150, 150, 0); contourBitEdit.AddPoint(150, 50, 0); contourBitEdit.AddPoint(100, 10, 0); } if (i % 2 != 0) contourBitEdit.SetClosed(true); else contourBitEdit.SetClosed(false); contour.AddContourBit(contourBitEdit); } GraphicsPath path = new GraphicsPath(); for(int i=0; i< contour.GetContourBitCount(); i++) { Point[] points = new Point[contour.GetContourBit(i).GetPointCount()]; for (int y = 0; y < contour.GetContourBit(i).GetPointCount(); y++) { Point newpoint = new Point((int)contour.GetContourBit(i).GetPoint(y).GetX(), (int)contour.GetContourBit(i).GetPoint(y).GetY()); points[y] = newpoint; } path.AddLines(points); } Pen myWind = new Pen(Color.Black); g.DrawPath(myWind, path); TRect_Float rect_Float = new TRect_Float(); rect_Float.X1 = 10; rect_Float.X2 = 100; rect_Float.Y1 = 10; rect_Float.Y2 = 100; myWind = new Pen(Color.Red); g.DrawRectangle(myWind, new Rectangle((int)rect_Float.TrectAngle()[0].GetX() ,(int)rect_Float.TrectAngle()[0].GetY(), (int)rect_Float.TrectAngle()[2].GetX(), (int)rect_Float.TrectAngle()[2].GetY())); Contours contours = new Contours (); contours.AddContour(contour); IContour contour1 = contour.CutContoursByWindow(contours, rect_Float); }