void UpdateHierarchy(List <HierarchyIndex> hierarchy)
{
int count = hierarchy.Count;
for (int i = 0; count > i; i++)
{
HierarchyIndex cur = hierarchy[i];
cur.Previous = i - 1;
cur.Next = i + 1 == count ? -1 : i + 1;
cur.Parent = -1;
cur.Child = -1;
}
}
public Contorno(int profundidad, int indice, Point[][] contornos, HierarchyIndex[] jerarquias, Contorno padre = null)
{
this.profundidad = profundidad;
this.indiceOriginal = indice;
this.padre = padre;
contorno = contornos[indice];
jerarquia = jerarquias[indice];
var indiceHijo = jerarquia.Child;
while (indiceHijo != -1)
{
hijos.Add(new Contorno(profundidad + 1, indiceHijo, contornos, jerarquias, this));
indiceHijo = jerarquias[indiceHijo].Next;
}
}
public IslaContornos(int indice, Point[][] contornos, HierarchyIndex[] jerarquias)
{
this.indice = indice;
this.jerarquias = jerarquias;
this.contornos = contornos;
jerarq = jerarquias[indice];
contorno = contornos[indice];
var indiceHijo = jerarq.Child;
while (indiceHijo != -1)
{
hijos.Add(contornos[indiceHijo]);
indiceHijo = jerarquias[indiceHijo].Next;
}
}
public void Extraer()
{
if (recuadros == null && (recuadros = FindObjectOfType <EncontrarRecuadros>()) == null)
{
return;
}
if (recuadros.recuadros.Count == 0)
{
return;
}
ClearTexturas();
Point[][] contornos = recuadros.contornos;
HierarchyIndex[] jerarquias = recuadros.jerarquiaContornos;
Recuadro recuadro = recuadros.recuadros[indiceRecuadroSel % recuadros.recuadros.Count];
HierarchyIndex jerarquia = jerarquias[recuadro.indiceContorno];
Mat matUmbral = recuadros.matUmbralEscalado.Clone();
Cv2.Dilate(matUmbral, matUmbral, new Mat(), null, 3);
Cv2.Erode(matUmbral, matUmbral, new Mat(), null, 2);
Cv2.CvtColor(matUmbral, matUmbral, ColorConversionCodes.GRAY2BGR);
List <int> hijosDirectos = new List <int>();
int hijo = jerarquia.Child;
while (hijo != -1)
{
if (contornos[hijo].Length > 1)
{
hijosDirectos.Add(hijo);
}
hijo = jerarquias[hijo].Next;
}
Debug.Log(hijosDirectos.Aggregate("", (s, e) => $"{e}({contornos[e].Length})-{s}"));
foreach (var i in hijosDirectos)
{
Cv2.DrawContours(matUmbral, contornos, i, colRojo);
Cv2.Polylines(matUmbral, new Point[][] { Cv2.ConvexHull(contornos[i]) }, true, colVerde);
}
var texturaObjetos = OCVUnity.MatToTexture(matUmbral, GenerarTextura(matUmbral.Width, matUmbral.Height));
}
public ContoursInfo Process(ContoursInfo Info)
{
List <Point[]> points = new List <Point[]>();
List <HierarchyIndex> hierarchy = new List <HierarchyIndex>();
int length = Info.Length;
for (int i = 0; length > i; i++)
{
Point[] point = Info.Contours[i];
HierarchyIndex index = Info.Hierarchy[i];
int len = point.Length;
if (len >= UnderLimitation && len <= MaxLimitation)
{
bool use = true;
int plen = point.Length;
for (int pi = 1; plen > pi; pi++)
{
Point pb = point[pi - 1];
Point cur = point[pi];
double distance = Math.Sqrt(Math.Pow(cur.X - pb.X, 2) + Math.Pow(cur.Y - pb.Y, 2));
if (distance < MinimumDistance)
{
use = false;
break;
}
}
if (use)
{
points.Add(point);
hierarchy.Add(index);
}
}
}
UpdateHierarchy(hierarchy);
return(new ContoursInfo(points.ToArray(), hierarchy.ToArray()));
}
public List <Point2f> GetCorners()
{
if (mFrame != null)
{
Point[][] contours = new Point[][] { };
HierarchyIndex[] hierarchy = new HierarchyIndex[] { };
Cv2.FindContours(mFrame, out contours, out hierarchy, RetrievalModes.Tree, ContourApproximationModes.ApproxSimple);
Point[] rect = new Point[] { };
double maxLength = 0;
foreach (var item in contours)
{
var perimeter = Cv2.ArcLength(item, true);
var approx = Cv2.ApproxPolyDP(item, 0.015 * perimeter, true);
if (approx.Length == 4 && perimeter > maxLength)
{
maxLength = perimeter;
rect = approx;
}
}
mResult = new List <Point2f>();
foreach (var item in rect)
{
mResult.Add(new Point2f(item.X, item.Y));
}
OrderPoints();
return(mResult);
}
return(null);
}
private void button1_Click(object sender, EventArgs e)
{
String cFileName = @".\images\IMG01.jpg";
int iMinVal = StringEx.getInt(IMG_MIN.Text);
int iMaxVal = StringEx.getInt(IMG_MAX.Text);
int iGrayMinVal = StringEx.getInt(GRAY_MIN.Text);
int iGrayMaxVal = StringEx.getInt(GRAY_MAX.Text);
int iEXPORT_IMAGE = StringEx.getInt(INIConfig.ReadString("Config", AppConfig.EXPORT_IMAGE, "0"));
String cID = "Export";
Mat BgrImage = null;
Mat GrayImage = null;
List <Mat> ImageList = new List <Mat>();
String cAbsoDir = Path.GetDirectoryName(cFileName);
String cExportDir = cAbsoDir + @"\" + cID;
if (!Directory.Exists(cExportDir))
{
Directory.CreateDirectory(cExportDir); //不存在文件夹，创建
}
BgrImage = Cv2.ImRead(cFileName, ImreadModes.AnyColor);
GrayImage = Cv2.ImRead(cFileName, ImreadModes.Grayscale);
GrayImage.SaveImage("IMG02.jpg");
//Image<Gray, byte> binaryImage = GrayImage.ThresholdBinary(new Gray(thresholdBinary), new Gray(iVal));
// ThresholdToZeroInv反取零 ThresholdToZero取零 ThresholdBinary二值 ThresholdBinaryInv反二值 ThresholdTrunc截断
Mat binaryImage = GrayImage.Threshold(iGrayMinVal, iMaxVal, ThresholdTypes.Binary);
GrayImage.SaveImage("IMG03.jpg");
try
{
OpenCvSharp.Point[][] rvs = new OpenCvSharp.Point[1][];
HierarchyIndex[] hierarchys = new HierarchyIndex[1];
Cv2.FindContours(binaryImage, out rvs, out hierarchys, RetrievalModes.CComp, ContourApproximationModes.ApproxNone);
for (int i = 0; i < rvs.Length; i++)
{
OpenCvSharp.Point[] objItem = rvs[i];
Rect vRect = Cv2.BoundingRect(objItem);
if ((vRect.Width < iMinVal) || (vRect.Height < iMinVal))
{
continue;
}
if ((vRect.Width > iMaxVal) || (vRect.Height > iMaxVal))
{
continue;
}
//j++;
//Point p1 = new Point(vRect.X, vRect.Y);
//Point p2 = new Point(vRect.X + vRect.Width, vRect.Y + vRect.Height);
Mat vResult = new Mat(BgrImage, vRect);
ImageList.Add(vResult);
//String cFileName = DateTime.Now.ToString("yyyyMMddHHmmss") + "_" + i.ToString();
//vResult.Save(cExportDir + "\\" + i + ".jpg");
//ImageList.Add(cExportDir + "\\" + i + ".jpg");
Cv2.Rectangle(BgrImage, vRect, new Scalar(255, 0, 0));
}
BgrImage.SaveImage("IMG04.jpg");
pictureBox1.Image = BitmapConverter.ToBitmap(BgrImage);
}
catch (Exception ex)
{
log4net.WriteTextLog("报错，原因为：" + ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
void openCV_method()
{
rectangle.SetActive(true);
triangularity.SetActive(true);
sphere.SetActive(true);
polygon.SetActive(true);
quadRender.material.mainTexture = processedTexture;
var src = new Mat(filePath, ImreadModes.AnyDepth | ImreadModes.AnyColor).Resize(new Size(640, 480));
var srcCopy = new Mat();
src.CopyTo(srcCopy);
var image_gray = new Mat();
var image_canny = new Mat();
var image_circle = new Mat();
Cv2.CvtColor(srcCopy, image_gray, ColorConversionCodes.BGRA2GRAY);
image_gray.CopyTo(image_circle);
Cv2.Canny(image_gray, image_gray, 150, 250, 3);
Cv2.Blur(image_gray, image_canny, new Size(3, 3));
var kenel = new Mat();
kenel = Cv2.GetStructuringElement(MorphShapes.Ellipse, new Size(11, 11));
var morph = new Mat();
Cv2.MorphologyEx(image_gray, morph, MorphTypes.Close, kenel);
Point[][] contours = new Point[100][];
HierarchyIndex[] hierarchy = new HierarchyIndex[100];
Cv2.FindContours(morph, out contours, out hierarchy, RetrievalModes.CComp,
ContourApproximationModes.ApproxSimple, new Point(0, 0));
int idx;
Mat contours_img = new Mat();
Cv2.CvtColor(image_gray, contours_img, ColorConversionCodes.GRAY2BGR);
for (idx = 0; idx < contours.Length; idx++)
{
Cv2.DrawContours(contours_img, contours, idx, Scalar.Red, 2);
}
Mat poly_img = new Mat();
Mat ractangle_img = new Mat();
Cv2.CvtColor(image_gray, poly_img, ColorConversionCodes.GRAY2BGR);
Cv2.CvtColor(image_gray, ractangle_img, ColorConversionCodes.GRAY2BGR);
find_circle(image_circle, 50.0f);
find_polygon(3, 50.0f, contours, image_circle);
find_polygon(4, 50.0f, contours, image_circle);
find_polygon(10000, 50.0f, contours, image_circle);
foreach (Polygon_T s in polygon_array)
{
DrawGraphic(s);
}
rectangle.SetActive(false);
triangularity.SetActive(false);
sphere.SetActive(false);
polygon.SetActive(false);
filePath = string.Empty;
}
