private static void Main(string[] args)
{
var undirectedCompletedGraph = new UndirectedGraph <string, TaggedUndirectedEdge <string, int> >();
var edge1 = new TaggedUndirectedEdge <string, int>("A", "B", 2);
var edge2 = new TaggedUndirectedEdge <string, int>("A", "E", 5);
var edge3 = new TaggedUndirectedEdge <string, int>("A", "D", 12);
var edge4 = new TaggedUndirectedEdge <string, int>("B", "C", 4);
var edge5 = new TaggedUndirectedEdge <string, int>("B", "D", 8);
var edge6 = new TaggedUndirectedEdge <string, int>("C", "E", 3);
var edge7 = new TaggedUndirectedEdge <string, int>("C", "D", 3);
var edge8 = new TaggedUndirectedEdge <string, int>("D", "E", 10);
undirectedCompletedGraph.AddVerticesAndEdgeRange(
new List <TaggedUndirectedEdge <string, int> > {
edge1, edge2, edge3, edge4, edge5, edge6, edge7, edge8
});
var startVertex = "B";
var travelingSalesmanResolver = new TravelingSalesmanResolver();
var travelingVertices =
travelingSalesmanResolver.ApproximateWith2Approximation(undirectedCompletedGraph, startVertex);
Console.WriteLine($"Salesman should travel followering vertices: {string.Join(", ", travelingVertices)}");
Console.ReadLine();
}
public void Run()
{
var g = new UndirectedGraph <int, TaggedUndirectedEdge <int, int> >();
var e1 = new TaggedUndirectedEdge <int, int>(1, 2, 57);
var e2 = new TaggedUndirectedEdge <int, int>(1, 4, 65);
var e3 = new TaggedUndirectedEdge <int, int>(2, 3, 500);
var e4 = new TaggedUndirectedEdge <int, int>(2, 4, 1);
var e5 = new TaggedUndirectedEdge <int, int>(3, 4, 78);
var e6 = new TaggedUndirectedEdge <int, int>(3, 5, 200);
g.AddVerticesAndEdge(e1);
g.AddVerticesAndEdge(e2);
g.AddVerticesAndEdge(e3);
g.AddVerticesAndEdge(e4);
g.AddVerticesAndEdge(e5);
g.AddVerticesAndEdge(e6);
foreach (var v in g.Edges)
{
Console.WriteLine(v);
}
Console.WriteLine("--------");
//Func<TaggedUndirectedEdge<int, int>, double> edgeWeights = (q) =>
//{
// g.Edges.SingleOrDefault(m => q == m).Tag;
//};
var mst = g.MinimumSpanningTreePrim(e => e.Tag).ToList();
foreach (var v in mst)
{
Console.WriteLine(v);
}
}
public void Equals()
{
var tag1 = new TestObject(1);
var tag2 = new TestObject(2);
var edge1 = new TaggedUndirectedEdge <int, TestObject>(1, 2, tag1);
var edge2 = new TaggedUndirectedEdge <int, TestObject>(1, 2, tag1);
var edge3 = new TaggedUndirectedEdge <int, TestObject>(1, 2, tag2);
var edge4 = new TaggedUndirectedEdge <int, TestObject>(1, 2, null);
Assert.AreEqual(edge1, edge1);
Assert.AreNotEqual(edge1, edge2);
Assert.AreNotEqual(edge2, edge1);
Assert.IsFalse(edge1.Equals(edge2));
Assert.IsFalse(edge2.Equals(edge1));
Assert.AreNotEqual(edge1, edge3);
Assert.AreNotEqual(edge3, edge1);
Assert.IsFalse(edge1.Equals(edge3));
Assert.IsFalse(edge3.Equals(edge1));
Assert.AreNotEqual(edge1, edge4);
Assert.AreNotEqual(edge4, edge1);
Assert.IsFalse(edge1.Equals(edge4));
Assert.IsFalse(edge4.Equals(edge1));
Assert.AreNotEqual(edge1, null);
Assert.IsFalse(edge1.Equals(null));
}
public ArrayList CurveToPoints()
{
ArrayList curveOfEdge = CurveOfEdges;
ArrayList curveOfPoints;
Pixel lastPoint;
Pixel firstPoint;
firstPoint = null;
lastPoint = null;
curveOfPoints = new ArrayList();
if (curveOfEdge.Count == 1)
{
curveOfPoints.Add(((TaggedUndirectedEdge <Pixel, EdgeTag>)curveOfEdge[0]).Source);
curveOfPoints.Add(((TaggedUndirectedEdge <Pixel, EdgeTag>)curveOfEdge[0]).Target);
}
else
{
for (int i = 0; i < curveOfEdge.Count; i++)
{
TaggedUndirectedEdge <Pixel, EdgeTag> ed = (TaggedUndirectedEdge <Pixel, EdgeTag>)curveOfEdge[i];
if (i == 0)
{
firstPoint = ed.Source;
lastPoint = ed.Target;
}
else
{
if (i == 1)
{
if (ed.Source.Equals(firstPoint))
{
firstPoint = lastPoint;
lastPoint = ed.Source;
}
else if (ed.Target.Equals(firstPoint))
{
firstPoint = lastPoint;
lastPoint = ed.Target;
}
curveOfPoints.Add(firstPoint);
curveOfPoints.Add(lastPoint);
}
if (ed.Source.Equals(lastPoint))
{
lastPoint = ed.Target;
}
else
{
lastPoint = ed.Source;
}
if (i > 0)
{
curveOfPoints.Add(lastPoint);
}
}
}
}
return(curveOfPoints);
}
private static void AddNewEdge(Pixel p1, Pixel p2, Color cA, Color cB, UndirectedGraph <Pixel, TaggedUndirectedEdge <Pixel, EdgeTag> > graph)
{
TaggedUndirectedEdge <Pixel, EdgeTag> e;
bool b = !cA.Equals(cB);
graph.TryGetEdge(p1, p2, out TaggedUndirectedEdge <Pixel, EdgeTag> e1);
graph.TryGetEdge(p2, p1, out TaggedUndirectedEdge <Pixel, EdgeTag> e2);
p1.color = cA;
p1.colorB = cB;
p2.color = cA;
p2.colorB = cB;
if (e1 == null && e2 == null && b) // adicionado o "b" para adicionar apenas arestas visiveis ao grafo
{
if (p1 < p2)
{
e = new TaggedUndirectedEdge <Pixel, EdgeTag>(p1, p2, new EdgeTag(cA, cB, b));
graph.AddEdge(e);
}
if (b) //conta valencia apenas se for visivel
{
p1.valence++;
p2.valence++;
}
}
}
public void TagChanged()
{
var edge = new TaggedUndirectedEdge <int, TestObject>(1, 2, null);
int changeCount = 0;
edge.TagChanged += (sender, args) => ++ changeCount;
edge.Tag = null;
Assert.AreEqual(0, changeCount);
var tag1 = new TestObject(1);
edge.Tag = tag1;
Assert.AreEqual(1, changeCount);
edge.Tag = tag1;
Assert.AreEqual(1, changeCount);
var tag2 = new TestObject(2);
edge.Tag = tag2;
Assert.AreEqual(2, changeCount);
edge.Tag = tag1;
Assert.AreEqual(3, changeCount);
}
public void ObjectToString()
{
var edge1 = new TaggedUndirectedEdge <int, TestObject>(1, 2, null);
var edge2 = new TaggedUndirectedEdge <int, TestObject>(1, 2, new TestObject(12));
Assert.AreEqual("1 <-> 2 (no tag)", edge1.ToString());
Assert.AreEqual("1 <-> 2 (12)", edge2.ToString());
}
private void Update()
{
// В позиции 1: если есть "ребро 1" или "ребро 2", удалем их из графа
//
if (slider.value == 1)
{
if (AirSystem.graphAir.ContainsEdge(input.myVertexName, output1.myVertexName) || AirSystem.graphAir.ContainsEdge(input.myVertexName, output2.myVertexName))
{
if (AirSystem.graphAir.TryGetEdge(input.myVertexName, output1.myVertexName, out var e1))
{
TurnOffGraphWalking(output1.myVertexName);
AirSystem.graphAir.RemoveEdge(e1);
}
if (AirSystem.graphAir.TryGetEdge(input.myVertexName, output2.myVertexName, out var e2))
{
TurnOffGraphWalking(output2.myVertexName);
AirSystem.graphAir.RemoveEdge(e2);
}
}
}
// В позиции 0: Если есть "ребро 2" или нет "ребра 1", удаляем "ребро 2" и добавляем "ребро 1" в граф
//
if (slider.value == 0)
{
if (AirSystem.graphAir.ContainsEdge(input.myVertexName, output2.myVertexName) || !AirSystem.graphAir.ContainsEdge(input.myVertexName, output1.myVertexName))
{
var e1 = new TaggedUndirectedEdge <string, string>(input.myVertexName, output1.myVertexName, "DistributorEdge1");
AirSystem.graphAir.AddEdge(e1);
TurnOffGraphWalking(output2.myVertexName);
AirSystem.graphAir.TryGetEdge(input.myVertexName, output2.myVertexName, out var e2);
AirSystem.graphAir.RemoveEdge(e2);
}
}
// В позиции 2: Если есть "ребро 1" или нет "ребра 2", удаляем "ребро 1" и добавляем "ребро 2" в граф
//
if (slider.value == 2)
{
if (AirSystem.graphAir.ContainsEdge(input.myVertexName, output1.myVertexName) || !AirSystem.graphAir.ContainsEdge(input.myVertexName, output2.myVertexName))
{
var e2 = new TaggedUndirectedEdge <string, string>(input.myVertexName, output2.myVertexName, "DistributorEdge2");
AirSystem.graphAir.AddEdge(e2);
TurnOffGraphWalking(output1.myVertexName);
AirSystem.graphAir.TryGetEdge(input.myVertexName, output1.myVertexName, out var e1);
AirSystem.graphAir.RemoveEdge(e1);
}
}
}
public void AddEdge(CreateVertex v1, CreateVertex v2)
{
vertex1 = v1;
vertex2 = v2;
isConnected = true;
var edge = new TaggedUndirectedEdge <string, string>(v1.myVertexName, v2.myVertexName, "CableEdge");
AirSystem.graphAir.AddEdge(edge);
}
private double AngleBetween2Lines(TaggedUndirectedEdge <Pixel, bool> edge1, TaggedUndirectedEdge <Pixel, bool> edge2)
{
double angle1 = Math.Atan2(edge1.Source.y - edge1.Target.y
, edge1.Source.x - edge1.Target.x);
double angle2 = Math.Atan2(edge2.Source.y - edge2.Target.y
, edge2.Source.x - edge2.Target.x);
return(angle1 - angle2);
}
public double curveSize()
{
TaggedUndirectedEdge <Pixel, EdgeTag> edge = null;
double lenght = 0;
foreach (var e in curve)
{
edge = (TaggedUndirectedEdge <Pixel, EdgeTag>)e;
Point p1 = edge.Source.getPoint();
Point p2 = edge.Target.getPoint();
lenght += (Math.Sqrt(Math.Pow(p1.X - p2.X, 2) + Math.Pow(p1.Y - p2.Y, 2)));
}
return(lenght);
}
public void Equals()
{
var tag1 = new TestObject(1);
var tag2 = new TestObject(2);
var edge1 = new TaggedUndirectedEdge <int, TestObject>(1, 2, tag1);
var edge2 = new TaggedUndirectedEdge <int, TestObject>(1, 2, tag1);
var edge3 = new TaggedUndirectedEdge <int, TestObject>(2, 1, tag1);
var edge4 = new TaggedUndirectedEdge <int, TestObject>(1, 2, tag2);
var edge5 = new TaggedUndirectedEdge <int, TestObject>(1, 2, null);
Assert.AreEqual(edge1, edge1);
Assert.AreNotEqual(edge1, edge2);
Assert.AreNotEqual(edge1, edge3);
Assert.AreNotEqual(edge1, edge4);
Assert.AreNotEqual(edge1, edge5);
Assert.AreNotEqual(edge1, null);
}
private void Update()
{
if (!input || !output1 || !output2)
{
input = transform.Find("Input").GetComponent <CreateVertex>();
output1 = transform.Find("Output 1").GetComponent <CreateVertex>();
output2 = transform.Find("Output 2").GetComponent <CreateVertex>();
}
else
{
if (!AirSystem.graphAir.ContainsEdge(input.myVertexName, output1.myVertexName) || !AirSystem.graphAir.ContainsEdge(input.myVertexName, output2.myVertexName))
{
var edge1 = new TaggedUndirectedEdge <string, string>(input.myVertexName, output1.myVertexName, "FittingEdge1");
var edge2 = new TaggedUndirectedEdge <string, string>(input.myVertexName, output2.myVertexName, "FittingEdge2");
AirSystem.graphAir.AddEdge(edge1);
AirSystem.graphAir.AddEdge(edge2);
}
}
}
private int CurveSize(TaggedUndirectedEdge <Pixel, EdgeTag> edge)
{
int size = 0;
bool hasEdge = true;
TaggedUndirectedEdge <Pixel, EdgeTag> nextEdge1 = edge; //a primeira direção do vertice
TaggedUndirectedEdge <Pixel, EdgeTag> nextEdge2 = edge; //a segunda direção do vertice
if (edge.Source.valence == 2 || edge.Target.valence == 2)
{
size++;
while (hasEdge)
{
hasEdge = false;
if (nextEdge1.Source.valence == 2 && !nextEdge1.Source.Equals(edge.Source))
{
size++;
foreach (var e in g.AdjacentEdges(nextEdge1.Source))
{
if (!e.Equals(nextEdge1))
{
nextEdge1 = e;
hasEdge = true;
}
}
}
if (nextEdge2.Source.valence == 2 && !nextEdge1.Source.Equals(edge.Source))
{
size++;
foreach (var e in g.AdjacentEdges(nextEdge2.Source))
{
if (!e.Equals(nextEdge2))
{
nextEdge2 = e;
hasEdge = true;
}
}
}
}
}
return(size);
}
private Pixel GetLastPixel(ArrayList curve)
{
TaggedUndirectedEdge <Pixel, EdgeTag> lastEdge = (TaggedUndirectedEdge <Pixel, EdgeTag>)curve[curve.Count - 1];
if (curve.Count < 2)
{
return(lastEdge.Target);
}
else
{
TaggedUndirectedEdge <Pixel, EdgeTag> beforeLastEdge = (TaggedUndirectedEdge <Pixel, EdgeTag>)curve[curve.Count - 2];
if (lastEdge.Source.Equals(beforeLastEdge.Target) || lastEdge.Source.Equals(beforeLastEdge.Source))
{
return(lastEdge.Target);
}
else
{
return(lastEdge.Source);
}
}
}
private Pixel GetFirstPixel(ArrayList curve)
{
TaggedUndirectedEdge <Pixel, EdgeTag> firstEdge = (TaggedUndirectedEdge <Pixel, EdgeTag>)curve[0];
if (curve.Count < 2)
{
return(firstEdge.Source);
}
else
{
TaggedUndirectedEdge <Pixel, EdgeTag> secondEdge = (TaggedUndirectedEdge <Pixel, EdgeTag>)curve[1];
if (firstEdge.Source.Equals(secondEdge.Target) || firstEdge.Source.Equals(secondEdge.Source))
{
return(firstEdge.Target);
}
else
{
return(firstEdge.Source);
}
}
}
private static void AddNewEdge(Pixel p1, Pixel p2, Color cA, Color cB, UndirectedGraph<Pixel, TaggedUndirectedEdge<Pixel, EdgeTag>> graph)
{
TaggedUndirectedEdge<Pixel, EdgeTag> e;
TaggedUndirectedEdge<Pixel, EdgeTag> e1;
TaggedUndirectedEdge<Pixel, EdgeTag> e2;
bool b = !cA.Equals(cB);
graph.TryGetEdge(p1, p2, out e1);
graph.TryGetEdge(p2, p1, out e2);
p1.color = cA;
p1.colorB = cB;
p2.color = cA;
p2.colorB = cB;
if (e1 == null && e2 == null && b) // adicionado o "b" para adicionar apenas arestas visiveis ao grafo
{
e = new TaggedUndirectedEdge<Pixel, EdgeTag>(p1, p2, new EdgeTag(cA, cB, b));
graph.AddEdge(e);
if (b) //conta valencia apenas se for visivel
{
p1.valence++;
p2.valence++;
}
}
}
private double AngleBetween2Lines(TaggedUndirectedEdge<Pixel, bool> edge1, TaggedUndirectedEdge<Pixel, bool> edge2)
{
double angle1 = Math.Atan2(edge1.Source.y - edge1.Target.y
, edge1.Source.x - edge1.Target.x);
double angle2 = Math.Atan2(edge2.Source.y - edge2.Target.y
, edge2.Source.x - edge2.Target.x);
return angle1 - angle2;
}
private int CurveSize(TaggedUndirectedEdge<Pixel, EdgeTag> edge)
{
int size = 0;
bool hasEdge = true;
TaggedUndirectedEdge<Pixel, EdgeTag> nextEdge1 = edge; //a primeira direção do vertice
TaggedUndirectedEdge<Pixel, EdgeTag> nextEdge2 = edge; //a segunda direção do vertice
if (edge.Source.valence == 2 || edge.Target.valence == 2)
{
size++;
while (hasEdge)
{
hasEdge = false;
if (nextEdge1.Source.valence == 2 && !nextEdge1.Source.Equals(edge.Source))
{
size++;
foreach (var e in g.AdjacentEdges(nextEdge1.Source))
{
if (!e.Equals(nextEdge1))
{
nextEdge1 = e;
hasEdge = true;
}
}
}
if (nextEdge2.Source.valence == 2 && !nextEdge1.Source.Equals(edge.Source))
{
size++;
foreach (var e in g.AdjacentEdges(nextEdge2.Source))
{
if (!e.Equals(nextEdge2))
{
nextEdge2 = e;
hasEdge = true;
}
}
}
}
}
return size;
}
/*
* Examinar blocos de 2x2 nodos para eliminar a maior quantidade de arestas, e remover cruzamentos ambiguos
* 00 10
* 01 11
*/
internal String SolveAmbiguities()
{
for (int y = 0; y < Height - 1; y++)
{
for (int x = 0; x < Width - 1; x++)
{
Pixel p00 = VertexSearch(x, y, g);
Pixel p10 = VertexSearch(x + 1, y, g);
Pixel p01 = VertexSearch(x, y + 1, g);
Pixel p11 = VertexSearch(x + 1, y + 1, g);
//Console.WriteLine("P= " + x + " " + y + " Valence =" + p00.valence);
TaggedUndirectedEdge <Pixel, EdgeTag> edge1 = null;
TaggedUndirectedEdge <Pixel, EdgeTag> edge2 = null;
g.TryGetEdge(p11, p00, out edge1);
g.TryGetEdge(p01, p10, out edge2);
if (edge1 != null)
{
if (edge2 != null)
{
//Identificada uma ambiguidade
if (Pixel.colorIsSimilar(p00.color, p01.color))
{
//Se as 4 cores são iguais remove todas as arestas internas
if (edge1 != null)
{
g.RemoveEdge(edge1);
}
if (edge2 != null)
{
g.RemoveEdge(edge2);
}
}
//Heuristica da ilha
else if (edge1.Source.valence == 1 || edge1.Target.valence == 1)
{
if (edge2 != null)
{
g.RemoveEdge(edge2);
}
}
else if (edge2.Source.valence == 1 || edge2.Target.valence == 1)
{
if (edge1 != null)
{
g.RemoveEdge(edge1);
}
}
else
{
//Heuristica da curva
if (edge1.Source.valence == 2 || edge1.Target.valence == 2 || edge2.Source.valence == 2 || edge2.Target.valence == 2)
{
if (CurveSize(edge1) <= CurveSize(edge2))
{
if (edge1 != null)
{
g.RemoveEdge(edge1);
}
}
else
{
if (edge2 != null)
{
g.RemoveEdge(edge2);
}
}
}
else
//Heuristica dos pixels sobrepostos
{
Pixel p1 = VertexSearch(edge1.Source.x, edge1.Source.y, g);
Pixel p2 = VertexSearch(edge2.Source.x, edge2.Source.y, g);
//Pixel p3 = VertexSearch(edge1.Target.x, edge1.Target.y, g);
//Pixel p4 = VertexSearch(edge2.Target.x, edge2.Target.y, g);
Color c1 = p1.color;
Color c2 = p2.color;
int sumC1 = 0, sumC2 = 0;
//Inicializa x e y com -4 posicoes para verificar 3 pixeis em ambas direções
int xs = p1.x - 4;
int ys = p1.y - 4;
while (xs <= p1.x + 3)
{
while (ys <= p1.y + 3)
{
Pixel pixel = VertexSearch(x, y, g);
if (pixel.color == c1)
{
sumC1++;
}
else
if (pixel.color == c2)
{
sumC2++;
}
ys++;
}
xs++;
}
//A cor em maior quantidade representa o fundo, e deve se manter os detalhes conectados
if (sumC1 > sumC2) //Remove a cor em menor quantidade
{
g.RemoveEdge(edge1);
}
else
{
g.RemoveEdge(edge2);
}
}
}
}
}
}
}
SvgVector svg = new SvgVector();
svg.Height = Height;
svg.Width = Width;
//svg.DrawValence = true;
return(svg.toImageSVG(g, "AmbiguitiesSolved.svg"));
}
/*
* p11 p12 p13
* p21 p p23
* p31 p32 p33
*/
internal String ImageToGraph(Bitmap b)
{
// FastBitmap fb = new FastBitmap(b);
Bitmap fb = b;
Height = b.Height;
Width = b.Width;
//Le imagem orignal e adiciona vertex - nodos
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Pixel p = new Pixel(x, y, fb.GetPixel(x, y));
g.AddVertex(p);
}
}
//Le imagem orignal e adiciona edges - arestas
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Pixel p = VertexSearch(x, y, g);
Pixel p11 = VertexSearch(x - 1, y - 1, g);
if (p11 != null && Pixel.colorIsSimilar(p11.color, p.color))
{
var e1 = new TaggedUndirectedEdge <Pixel, EdgeTag>(p, p11, new EdgeTag());
g.AddEdge(e1);
p.valence++;
p11.valence++;
}
Pixel p12 = VertexSearch(x, y - 1, g);
if (p12 != null && Pixel.colorIsSimilar(p12.color, p.color))
{
var e2 = new TaggedUndirectedEdge <Pixel, EdgeTag>(p, p12, new EdgeTag());
g.AddEdge(e2);
p.valence++;
p12.valence++;
}
Pixel p13 = VertexSearch(x + 1, y - 1, g);
if (p13 != null && Pixel.colorIsSimilar(p13.color, p.color))
{
if (p <= p13)
{
var e3 = new TaggedUndirectedEdge <Pixel, EdgeTag>(p, p13, new EdgeTag());
g.AddEdge(e3);
}
else
{
var e3 = new TaggedUndirectedEdge <Pixel, EdgeTag>(p13, p, new EdgeTag());
g.AddEdge(e3);
}
p.valence++;
p13.valence++;
}
Pixel p21 = VertexSearch(x - 1, y, g);
if (p21 != null && Pixel.colorIsSimilar(p21.color, p.color))
{
var e4 = new TaggedUndirectedEdge <Pixel, EdgeTag>(p, p21, new EdgeTag());
g.AddEdge(e4);
p.valence++;
p21.valence++;
}
}
}
SvgVector svg = new SvgVector
{
Height = Height,
Width = Width
};
return(svg.ToImageSVG(g, "Graph.svg"));
}
/*
* Detectar os ciclos dentro do grafo para transforma-los em objetos coloridos
*/
internal String CreateShapes()
{
Shapes shapes = new Shapes();
Shape shape = new Shape();
ArrayList processedCurves = new ArrayList();
Pixel lastPixel;
Pixel firstPixel;
Color color;
bool hasCurve;
foreach (Curve curve in curvesC)
{
Curve processingCurve = curve;
color = processingCurve.Color;
if (!processedCurves.Contains(processingCurve))
{
processedCurves.Add(processingCurve);
ArrayList curveArray = processingCurve.CurveOfEdges;
firstPixel = GetFirstPixel(curveArray);
lastPixel = GetLastPixel(curveArray);
shape.Add(curve);
if (!firstPixel.Equals(lastPixel)) // se primeiro e ultimo são iguais, então o circuito já esta fechado
{
hasCurve = true;
while (hasCurve)
{
foreach (Curve newCurve in curvesC) // verifico todas as curvas procurando uma que comece ou termine com o ultimo pixel da pesquisada
{
if ((newCurve.Color == color && newCurve != curve && !processedCurves.Contains(newCurve))) // Precisa ser uma curva não processessada e com cor igual
{
hasCurve = false;
ArrayList newCurveArray = newCurve.CurveOfEdges;
TaggedUndirectedEdge <Pixel, EdgeTag> firstNewEdge = (TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0];
TaggedUndirectedEdge <Pixel, EdgeTag> lastNewEdge = (TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[newCurveArray.Count - 1];
if (firstNewEdge.Source.Equals(lastPixel) || firstNewEdge.Target.Equals(lastPixel) || lastNewEdge.Target.Equals(lastPixel) || lastNewEdge.Source.Equals(lastPixel)) // se a curva analizada possui o primeiro ou ultimo pixel igual a um pixel do lastEdge // simplificado apenas para conter um dos pixeis da ultima aresta da curva
{
if (firstNewEdge.Source.Equals(lastPixel) || firstNewEdge.Target.Equals(lastPixel))
{
if (newCurveArray.Count == 1)
{
if (((TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0]).Source.Equals(lastPixel))
{
lastPixel = ((TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0]).Target;
}
else
{
lastPixel = ((TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0]).Source;
}
}
else
{
lastPixel = GetLastPixel(newCurveArray);
}
}
else
{
if (newCurveArray.Count == 1)
{
if (((TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0]).Source.Equals(lastPixel))
{
lastPixel = ((TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0]).Target;
}
else
{
lastPixel = ((TaggedUndirectedEdge <Pixel, EdgeTag>)newCurveArray[0]).Source;
}
}
else
{
lastPixel = GetFirstPixel(newCurveArray);
newCurveArray.Reverse();
}
}
processedCurves.Add(newCurve);
if (!lastPixel.Equals(firstPixel))
{
shape.Add(newCurve);
hasCurve = true;
break;
}
else // terminou o grupo de curvas
{
shape.Add(newCurve);
shapes.Add(shape);
hasCurve = false;
}
}
}
}
}
}
else
{
shapes.Add(shape);
}
shape = new Shape();
}
}
//remove shapes iguais de cores diferentes
ArrayList remove = new ArrayList();
foreach (Shape shapeItem in shapes)
{
foreach (Shape shapeItem2 in shapes)
{
if (!remove.Contains(shapeItem) && !remove.Contains(shapeItem2) && shapeItem.GetColor() != Color.Beige && shapeItem2.GetColor() != Color.Beige)
{
if (shapeItem.GetColor() != shapeItem2.GetColor() && shapeItem.IsSameShape(shapeItem2))
{
Color c = new Color();
//localiza o pixel de cor dentro do poligono
foreach (Pixel v in g.Vertices)
{
if (v.pixelInsidePolygon(shapeItem.ToPoints()))
{
c = v.color;
break;
}
}
if (shapeItem.GetColor() == c)
{
remove.Add(shapeItem2);
break;
}
else
if (shapeItem2.GetColor() == c)
{
remove.Add(shapeItem);
break;
}
}
}
}
}
foreach (Shape item in remove)
{
shapes.Remove(item);
}
//Ordena do objeto com maior area para os de menor area
shapes.Sort();
SvgVector svg = new SvgVector
{
Height = Height * scale,
Width = Width * scale,
scale = 1
};
return(svg.NewImage(g, shapes, "NewImage.svg"));
}
/*
* p11 p12 p13
* p21 p p23
* p31 p32 p33
*/
internal String ImageToGraph(Bitmap b)
{
FastBitmap fb = new FastBitmap(b);
Height = b.Height;
Width = b.Width;
//Le imagem orignal e adiciona vertex - nodos
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Pixel p = new Pixel(x, y, fb.GetPixel(x, y));
g.AddVertex(p);
}
}
//Le imagem orignal e adiciona edges - arestas
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
Pixel p = VertexSearch(x, y, g);
Pixel p11 = VertexSearch(x - 1, y - 1, g);
if (p11 != null && Pixel.colorIsSimilar(p11.color, p.color))
{
var e1 = new TaggedUndirectedEdge<Pixel, EdgeTag>(p, p11, new EdgeTag());
g.AddEdge(e1);
p.valence++;
p11.valence++;
}
Pixel p12 = VertexSearch(x, y - 1, g);
if (p12 != null && Pixel.colorIsSimilar(p12.color, p.color))
{
var e2 = new TaggedUndirectedEdge<Pixel, EdgeTag>(p, p12, new EdgeTag());
g.AddEdge(e2);
p.valence++;
p12.valence++;
}
Pixel p13 = VertexSearch(x + 1, y - 1, g);
if (p13 != null && Pixel.colorIsSimilar(p13.color, p.color))
{
var e3 = new TaggedUndirectedEdge<Pixel, EdgeTag>(p, p13, new EdgeTag());
g.AddEdge(e3);
p.valence++;
p13.valence++;
}
Pixel p21 = VertexSearch(x - 1, y, g);
if (p21 != null && Pixel.colorIsSimilar(p21.color, p.color))
{
var e4 = new TaggedUndirectedEdge<Pixel, EdgeTag>(p, p21, new EdgeTag());
g.AddEdge(e4);
p.valence++;
p21.valence++;
}
}
}
SvgVector svg = new SvgVector();
svg.Height = Height;
svg.Width = Width;
return svg.toImageSVG(g, "Graph.svg");
}
