public ShapeOfAIDI(AIDIShape badShape)
{
Area = Convert.ToDouble(badShape.area);
CenterX = Convert.ToDouble(badShape.cx);
CenterY = Convert.ToDouble(badShape.cy);
Width = Convert.ToDouble(badShape.width);
Height = Convert.ToDouble(badShape.height);
Score = Convert.ToDouble(badShape.score);
Type = badShape.type_name;
//
List <double> pointXs = new List <double>();
List <double> pointYs = new List <double>();
List <int> pointNums = new List <int>();
foreach (var badPoint in badShape.contours)
{
var pointX = Convert.ToDouble(badPoint.x);
var pointY = Convert.ToDouble(badPoint.y);
var point = new PointShape(pointX, pointY);
pointXs.Add(pointX);
pointYs.Add(pointY);
Contours.Add(point);
}
pointNums.Add(badShape.contours.Count);
Region = new ShapeOf2D(pointYs, pointXs, pointNums);
}
public void SetUpTestCase()
{
Contour currentContour = new Contour(Contours.Count + 1);
Contours.Add(currentContour);
Point pt1 = new Point(0, 0);
pt1.T = 0;
currentContour.Add(pt1);
Point pt2 = new Point(100, 0);
pt2.T = 100;
currentContour.Add(pt2);
Point pt3 = new Point(0, 100);
pt3.T = 0;
currentContour.Add(pt3);
//Point pt4 = new Point(0, 100);
//pt4.T = 0;
//currentContour.Add(pt4);
//Point pt5 = new Point(0, 40);
//pt5.T = 1;
//currentContour.Add(pt5);
currentContour.Add(pt1);
}
private void AddContourCommand_Executed(object sender, ExecutedRoutedEventArgs e)
{
var contour = Contour.AlignInUnitRectangle(ContourInput.Contour);
if (contour != null)
{
Contours.Add(new ContourInformation(contour));
}
}
private void AddFromCommand_Executed(object sender, ExecutedRoutedEventArgs e)
{
if (m_ofd.ShowDialog() == true)
{
using (Stream stream = File.Open(m_ofd.FileName, FileMode.Open))
{
try
{
ContourInformationCollection.Load(stream).ForEach(c => Contours.Add(c));
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
}
}
private void DFScycle(int u, int endV, int[] color, int unavailableEdge, ElementsContour contour)
{
//если u == endV, то эту вершину перекрашивать не нужно, иначе мы в нее не вернемся, а вернуться необходимо
if (u != endV)
{
color[u] = 2; // Закрашиваем посещенную вершину
}
else if (contour.Count >= 2)
{
if (isContourFree(contour)) // Проверяем, существует ли эта цепь
{
Contours.Add(contour);
if (Contours.Count > 15)
{
throw new WrongSchemeException("Too difficult");
}
return;
}
}
for (int w = 0; w < Connectors.Count; w++)
{
if (w == unavailableEdge)
{
continue;
}
if (color[Connectors[w].NodeB.Number] == 1 && Connectors[w].NodeA.Number == u)
{
ElementsContour newContour = new ElementsContour(contour);
newContour.AddNode(Connectors[w].NodeB);
DFScycle(Connectors[w].NodeB.Number, endV, color, w, newContour);
color[Connectors[w].NodeB.Number] = 1;
}
else if (color[Connectors[w].NodeA.Number] == 1 && Connectors[w].NodeB.Number == u)
{
ElementsContour newContour = new ElementsContour(contour);
newContour.AddNode(Connectors[w].NodeA);
DFScycle(Connectors[w].NodeA.Number, endV, color, w, newContour);
color[Connectors[w].NodeA.Number] = 1;
}
}
}
public ContouredImage(string imageFile)
{
GreyImage = getPreprocessedImage(imageFile);
//!!!try to make more primitive
//Mat tmp = grey.clone();
//morphologyEx(tmp, tmp, MORPH_GRADIENT, getStructuringElement(MORPH_ELLIPSE, Size(3, 3)));
//bitwise_not(tmp, tmp);
//!!!try to smooth
//epsilon = 0.1 * cv.arcLength(cnt, True)
//approx = cv.approxPolyDP(cnt, epsilon, True)
Emgu.CV.CvInvoke.FindContours(GreyImage, CvContours, Hierarchy, RetrType.List, ChainApproxMethod.ChainApproxSimple);
Array hierarchy = Hierarchy.GetData();
for (int i = 0; i < CvContours.Size; i++)
{
Contours.Add(new Contour(hierarchy, i, CvContours[i]));
}
RobustContours = Contours.Where(x => x.Points.Size >= MinContourPointCount).ToList();//!!!RotatedRect cannot be calculated for Points.Size < 5
}
public override void UpdateMesh(ProjectPolygon[] p)
{
ProjectPolygons = p;
PlaneSurface ps = new PlaneSurface()
{
Position = Location, Normal = Axis
};
var bs = ps.GetBasis();
var vec0 = bs[0] * Radius;
//stage1
//check nesting
List <ProjectPolygon> tops = new List <ProjectPolygon>();
foreach (var item in ProjectPolygons)
{
bool good = true;
foreach (var item2 in ProjectPolygons)
{
if (item == item2)
{
continue;
}
var pnts2 = item2.Points.ToArray();
if (GeometryUtils.pnpoly(pnts2, item.Points[0].X, item.Points[0].Y))
{
good = false; break;
}
}
if (good)
{
tops.Add(item);
}
}
List <Vector2d[]> triangls = new List <Vector2d[]>();
double step = AngleStep / 180f * Math.PI;
//extract 3d contours
Contours.Clear();
foreach (var item in tops)
{
var cc = new Contour3d();
Contours.Add(cc);
var maxy = item.Points.Max(z => z.Y) + 1;
var miny = item.Points.Min(z => z.Y) - 1;
for (int i = 0; i < item.Points.Count; i++)
{
var p0 = item.Points[i];
var p1 = item.Points[(i + 1) % item.Points.Count];
double last = 0;
List <Vector2d> cutPoints = new List <Vector2d>();
List <Vector2d> tempPoints = new List <Vector2d>();
cutPoints.Add(p0);
while (true)
{
var p00 = last;
var p11 = p00 + step;
last += step;
p00 = Math.Min(p00, 10 * Math.PI * 2);
p11 = Math.Min(p11, 10 * Math.PI * 2);
if (Math.Abs(p00 - p11) < 1e-8)
{
break;
}
Vector2d ret1 = Vector2d.Zero;
if (GeometryUtils.IntersectSegments(p0, p1, new Vector2d(p11, miny), new Vector2d(p11, maxy), ref ret1))
{
tempPoints.Add(ret1);
}
}
tempPoints.Add(p1);
while (tempPoints.Any())
{
var fr = tempPoints.OrderBy(z => (z - cutPoints.Last()).Length).First();
cutPoints.Add(fr);
tempPoints.Remove(fr);
}
for (int j = 0; j < cutPoints.Count; j++)
{
var ang = cutPoints[j].X;
var mtr = Matrix4d.CreateFromAxisAngle(Axis, -ang);
var rot0 = Vector3d.Transform(vec0 + Axis * cutPoints[j].Y * Lenght, mtr);
cc.Points.Add(Location + rot0);
}
}
}
foreach (var item in tops)
{
List <ProjectPolygon> holes = new List <ProjectPolygon>();
var pnts2 = item.Points.ToArray();
foreach (var xitem in ProjectPolygons.Except(tops))
{
if (GeometryUtils.pnpoly(pnts2, xitem.Points[0].X, xitem.Points[0].Y))
{
holes.Add(xitem);
}
}
PolyBoolCS.PolyBool pb = new PolyBoolCS.PolyBool();
PolyBoolCS.Polygon p1 = new PolyBoolCS.Polygon();
var pl1 = new PolyBoolCS.PointList();
p1.regions = new List <PolyBoolCS.PointList>();
pl1.AddRange(item.Points.Select(z => new PolyBoolCS.Point(z.X, z.Y)).ToArray());
p1.regions.Add(pl1);
var maxy = pl1.Max(z => z.y) + 1;
var miny = pl1.Min(z => z.y) - 1;
double last = 0;
while (true)
//for (double i = step; i < (Math.PI * 2); i += step)
{
var p0 = last;
var p11 = p0 + step;
last += step;
p0 = Math.Min(p0, 10 * Math.PI * 2);
p11 = Math.Min(p11, 10 * Math.PI * 2);
if (Math.Abs(p0 - p11) < 1e-8)
{
break;
}
PolyBoolCS.Polygon p2 = new PolyBoolCS.Polygon();
p2.regions = new List <PolyBoolCS.PointList>();
var pl2 = new PolyBoolCS.PointList();
pl2.Add(new PolyBoolCS.Point(p0, miny));
pl2.Add(new PolyBoolCS.Point(p0, maxy));
pl2.Add(new PolyBoolCS.Point(p11, maxy));
pl2.Add(new PolyBoolCS.Point(p11, miny));
p2.regions.Add(pl2);
if (holes.Any(z => GeometryUtils.AlmostEqual(z.Area(), 0)))
{
throw new GeomPadException("zero area contour detected");
}
var res = pb.intersect(p1, p2);
if (res.regions.Any())
{
foreach (var region in res.regions)
{
var triangls2 = GeometryUtils.TriangulateWithHoles(
new[] { region.Select(z => new Vector2d(z.x, z.y)).ToArray() }
,
holes.Select(z => z.Points.ToArray()).ToArray(), true);
triangls.AddRange(triangls2);
}
}
}
}
//stage2
List <TriangleInfo> tt = new List <TriangleInfo>();
foreach (var item in triangls)
{
TriangleInfo tin = new TriangleInfo();
List <VertexInfo> v = new List <VertexInfo>();
foreach (var d in item)
{
var ang = d.X;
var mtr = Matrix4d.CreateFromAxisAngle(Axis, -ang);
var rot0 = Vector3d.Transform(vec0 + Axis * d.Y * Lenght, mtr);
v.Add(new VertexInfo()
{
Position = Location + rot0
});
}
var v01 = v[1].Position - v[0].Position;
var v11 = v[2].Position - v[0].Position;
var crs = Vector3d.Cross(v01, v11).Normalized();
if (double.IsNaN(crs.X))
{
throw new GeomPadException("normal is NaN");
}
foreach (var item0 in v)
{
item0.Normal = crs;
}
tin.Vertices = v.ToArray();
tt.Add(tin);
}
Mesh = new Mesh()
{
Triangles = tt
};
}
public void PointsInputHandler(object sender, MouseEventArgs e)
{
Contour currentContour = Contours.FirstOrDefault(x => !x.IsCompleted);
if (currentContour == null)
{
currentContour = new Contour(Contours.Count + 1);
Contours.Add(currentContour);
}
var newPoint = new Point(e.X, _drawer.CanvasHeight - e.Y)
{
Index = _lastPointIndex + 1
};
if (currentContour.Head == null)
{
currentContour.Add(newPoint);
_drawer.DrawPoints(Pens.Black, newPoint);
//Ekaterina
_drawer.RefreshImage();
//end Ekaterina
_lastPointIndex++;
}
else
{
if (currentContour.Tail == null)
{
var newLineSegment = new LineSegment(currentContour.Head, newPoint);
if (Contours.Where(x => x != currentContour).Any(x => x.IntersectsWithLineSegment(newLineSegment, IntersectionCheckOptions.WithEdgePoints)) ||
currentContour.IntersectsWithLineSegment(newLineSegment, IntersectionCheckOptions.WithoutEdgePoints))
{
MessageBox.Show(ErrorMessageBoxMessage, ErrorMessageBoxTitle);
}
else
{
currentContour.Add(newPoint);
_drawer.DrawLineSegments(Pens.Black, newLineSegment);
_lastPointIndex++;
}
}
else
{
var newLineSegment = new LineSegment(currentContour.Tail, newPoint);
if (Contours.Where(x => x != currentContour).Any(x => x.IntersectsWithLineSegment(newLineSegment, IntersectionCheckOptions.WithEdgePoints)) ||
currentContour.IntersectsWithLineSegment(newLineSegment, IntersectionCheckOptions.WithoutEdgePoints))
{
MessageBox.Show(ErrorMessageBoxMessage, ErrorMessageBoxTitle);
}
else
{
currentContour.Add(newPoint);
if (!currentContour.IsCompleted)
{
_drawer.DrawLineSegments(Pens.Black, newLineSegment);
_lastPointIndex++;
}
else
{
_drawer.DrawLineSegments(Pens.Black, new LineSegment(currentContour.Tail, currentContour.Head));
}
}
}
}
if (currentContour.IsCompleted)
{
_tabControlHelper.CreatePageForContour(currentContour);
}
}
public Contour GetSingleContour()
{
if (Contours.Count == 0)
{
throw new Exception("Контуры отсутствуют");
}
if (!AllContoursAreCompleted)
{
throw new Exception("Все контуры должны быть замкнуты!");
}
var boundingBoxes = new Dictionary <int, BoundingBox>();
for (int i = 0; i < Contours.Count; i++)
{
boundingBoxes.Add(i, Contours[i].GetBoundingBox());
}
var largestBox = boundingBoxes.FirstOrDefault(x => boundingBoxes.Where(y => y.Key != x.Key).All(y => x.Value.Contains(y.Value)));
var restBoxes = boundingBoxes.Where(x => x.Key != largestBox.Key).ToArray();
if (largestBox.Value == null)
{
throw new Exception("Контуры не образуют единой области. Дальнейшие вычисления невозможны");
}
if (restBoxes.Any(x => restBoxes.Where(y => y.Key != x.Key).Any(y => x.Value.Contains(y.Value))))
{
throw new Exception("Вложенность дырок недопустима. Дальнейшие вычисления невозможны");
}
var largestContour = Contours[largestBox.Key];
largestContour.OrientCounterclockwise();
for (int i = 0; i < Contours.Count; i++)
{
if (i != largestBox.Key)
{
var contour = Contours[i];
contour.OrientClockwise();
var nearestPoints = largestContour.ToDictionary(x => x,
x => contour.ToDictionary(y => y, y => Math.Sqrt(Math.Pow(x.X - y.X, 2) + Math.Pow(x.Y - y.Y, 2))).OrderBy(r => r.Value).First()).
OrderBy(r => r.Value.Value).First();
int largeContourPointIndex = nearestPoints.Key.Index;
int contourPointIndex = nearestPoints.Value.Key.Index;
for (int j = 0; j < contour.Count - contourPointIndex + 1; j++)
{
Point pt = contour[contourPointIndex - 1 + j].Clone();
pt.Index = largeContourPointIndex + 1 + j;
largestContour.Insert(pt.Index - 1, pt);
}
for (int j = 0; j < contourPointIndex; j++)
{
Point pt = contour[j].Clone();
pt.Index = largeContourPointIndex + contour.Count - contourPointIndex + j + 2;
largestContour.Insert(pt.Index - 1, pt);
}
Point self = largestContour[largeContourPointIndex - 1].Clone();
int offset = self.Index + contour.Count + 2;
self.Index = offset;
largestContour.Insert(self.Index - 1, self);
for (int j = offset; j < largestContour.Count; j++)
{
largestContour[j].Index = j + 1;
}
}
}
largestContour.Index = 1;
Contours.Clear();
Contours.Add(largestContour);
return(largestContour);
}
public void Add(Contour c)
{
Contours.Add(c);
}
