private static void TestShapeTermsImpl(string testName, ShapeModel shapeModel, IEnumerable<VertexConstraints> vertexConstraints, IEnumerable<EdgeConstraints> edgeConstraints, Size imageSize)
{
ShapeConstraints constraintSet = ShapeConstraints.CreateFromConstraints(shapeModel.Structure, vertexConstraints, edgeConstraints);
// Get CPU results
Image2D<ObjectBackgroundTerm> shapeTermsCpu = new Image2D<ObjectBackgroundTerm>(imageSize.Width, imageSize.Height);
CpuShapeTermsLowerBoundCalculator calculatorCpu = new CpuShapeTermsLowerBoundCalculator();
calculatorCpu.CalculateShapeTerms(shapeModel, constraintSet, shapeTermsCpu);
Image2D.SaveToFile(shapeTermsCpu, -1000, 1000, String.Format("./{0}_cpu.png", testName));
// Get GPU results
Image2D<ObjectBackgroundTerm> shapeTermsGpu = new Image2D<ObjectBackgroundTerm>(imageSize.Width, imageSize.Height);
GpuShapeTermsLowerBoundCalculator calculatorGpu = new GpuShapeTermsLowerBoundCalculator();
calculatorGpu.CalculateShapeTerms(shapeModel, constraintSet, shapeTermsGpu);
Image2D.SaveToFile(shapeTermsGpu, -1000, 1000, String.Format("./{0}_gpu.png", testName));
// Compare with CPU results
for (int x = 0; x < imageSize.Width; ++x)
for (int y = 0; y < imageSize.Height; ++y)
{
Assert.AreEqual(shapeTermsCpu[x, y].ObjectTerm, shapeTermsGpu[x, y].ObjectTerm, 1e-2f);
Assert.AreEqual(shapeTermsCpu[x, y].BackgroundTerm, shapeTermsGpu[x, y].BackgroundTerm, 1e-2f);
}
}
private Image CreateStatusImage(Shape shape)
{
return(this.DrawConstraintsOnTopOfImage(
this.segmentedImage, 2, ShapeConstraints.CreateFromShape(shape), false, false, false, true));
}
private Image CreateStatusImage(
ShapeConstraints shapeConstraints, bool drawVertexConstraints, bool drawMinEdgeWidth, bool drawMaxEdgeWidth, bool drawAverageEdgeWidth)
{
return(this.DrawConstraintsOnTopOfImage(
this.segmentedImage, 2, shapeConstraints, drawVertexConstraints, drawMinEdgeWidth, drawMaxEdgeWidth, drawAverageEdgeWidth));
}
private Image DrawConstraintsOnTopOfImage(
Image backgroundImage, float drawSizeRatio, ShapeConstraints shapeConstraints, bool drawVertexConstraints, bool drawMinEdgeWidth, bool drawMaxEdgeWidth, bool drawAverageEdgeWidth)
{
const float pointRadius = 4;
const float lineWidth = 2;
Bitmap statusImage = new Bitmap((int)(backgroundImage.Width * drawSizeRatio), (int)(backgroundImage.Height * drawSizeRatio));
using (Graphics graphics = Graphics.FromImage(statusImage))
{
graphics.DrawImage(backgroundImage, 0, 0, statusImage.Width, statusImage.Height);
if (drawVertexConstraints)
{
foreach (VertexConstraints vertexConstraint in shapeConstraints.VertexConstraints)
{
graphics.DrawRectangle(
new Pen(Color.Orange, lineWidth),
(float)vertexConstraint.MinCoord.X * drawSizeRatio,
(float)vertexConstraint.MinCoord.Y * drawSizeRatio,
(float)(vertexConstraint.MaxCoord.X - vertexConstraint.MinCoord.X) * drawSizeRatio,
(float)(vertexConstraint.MaxCoord.Y - vertexConstraint.MinCoord.Y) * drawSizeRatio);
}
}
foreach (VertexConstraints vertexConstraint in shapeConstraints.VertexConstraints)
{
graphics.FillEllipse(
Brushes.Black,
(float)vertexConstraint.MiddleCoord.X * drawSizeRatio - pointRadius,
(float)vertexConstraint.MiddleCoord.Y * drawSizeRatio - pointRadius,
2 * pointRadius,
2 * pointRadius);
}
for (int i = 0; i < shapeConstraints.ShapeStructure.Edges.Count; ++i)
{
ShapeEdge edge = shapeConstraints.ShapeStructure.Edges[i];
Vector point1 = shapeConstraints.VertexConstraints[edge.Index1].MiddleCoord * drawSizeRatio;
Vector point2 = shapeConstraints.VertexConstraints[edge.Index2].MiddleCoord * drawSizeRatio;
graphics.DrawLine(new Pen(Color.Black, lineWidth), MathHelper.VecToPointF(point1), MathHelper.VecToPointF(point2));
if (drawMinEdgeWidth || drawMaxEdgeWidth || drawAverageEdgeWidth)
{
EdgeConstraints edgeConstraint = shapeConstraints.EdgeConstraints[i];
Vector diff = point2 - point1;
Vector edgeNormal = (new Vector(diff.Y, -diff.X)).GetNormalized();
if (drawMaxEdgeWidth)
{
DrawOrientedRectange(graphics, point1, point2, edgeNormal, (float)edgeConstraint.MaxWidth * drawSizeRatio, new Pen(Color.Cyan, lineWidth));
}
if (drawMinEdgeWidth)
{
DrawOrientedRectange(graphics, point1, point2, edgeNormal, (float)edgeConstraint.MinWidth * drawSizeRatio, new Pen(Color.Red, lineWidth));
}
if (drawAverageEdgeWidth)
{
DrawOrientedRectange(graphics, point1, point2, edgeNormal, (float)(edgeConstraint.MinWidth + edgeConstraint.MaxWidth) * drawSizeRatio * 0.5f, new Pen(Color.Blue, lineWidth));
}
}
}
}
return(statusImage);
}
private void OnBranchAndBoundCompleted(object sender, BranchAndBoundCompletedEventArgs e)
{
this.bestConstraints = e.ResultConstraints;
}
static void Main(string[] args)
{
if (args.Count() < 3)
{
Console.WriteLine("Arguments: <diagram_type> <number of images> <generated images path> ");
Environment.Exit(1);
}
String diagram = args[0].ToLower();
int numDiag = Int32.Parse(args[1]);
String directory = args[2];
//specify diagram type here
DiagramType diagramType;
switch (diagram)
{
case "flowchart":
diagramType = DiagramType.FlowChart;
break;
case "sequencediagram":
diagramType = DiagramType.SequenceDiagram;
break;
case "statediagram":
diagramType = DiagramType.StateDiagram;
break;
default:
diagramType = DiagramType.FlowChart;
break;
}
ImageLayout.ImageConstraints constraints = new ImageLayout.ImageConstraints();
switch (diagramType)
{
case DiagramType.FlowChart:
constraints.Width = 299; constraints.Height = 299;
constraints.AllowedShapes = new List <ShapeType>()
{
ShapeType.Circle, ShapeType.Ellipse, ShapeType.Rectangle, ShapeType.Rhombus, ShapeType.Parallelogram
};
constraints.MandatoryShapes = new List <ShapeType>()
{
ShapeType.Ellipse
};
constraints.SingleOccurrenceShapes = new List <ShapeType>()
{
ShapeType.Ellipse
};
constraints.MaxShapes = 8; constraints.MinShapes = 3;
constraints.ShapeConstraints.Add(ShapeType.Ellipse,
new ShapeConstraints()
{
HasFixedLocation = true,
MinInDegree = 0,
MaxInDegree = 0,
MinOutDegree = 1,
MaxOutDegree = 1
});
var stopConstraints = new ShapeConstraints()
{
PlacementConstraint = (row, col) => row > 0,
HasFixedLocation = false,
MinInDegree = 1,
MaxInDegree = Int32.MaxValue,
MaxOutDegree = 0,
MinOutDegree = 0
};
constraints.ShapeConstraints.Add(ShapeType.Circle, stopConstraints);
var processConstraints = new ShapeConstraints(stopConstraints);
processConstraints.MaxInDegree = 1;
processConstraints.MinInDegree = 1;
processConstraints.MaxOutDegree = 1;
processConstraints.MinOutDegree = 1;
var conditionConstraints = new ShapeConstraints(stopConstraints);
conditionConstraints.MaxInDegree = 1;
conditionConstraints.MaxOutDegree = 4;
conditionConstraints.MinInDegree = 1;
conditionConstraints.MinOutDegree = 2;
constraints.ShapeConstraints.Add(ShapeType.Rectangle, processConstraints);
constraints.ShapeConstraints.Add(ShapeType.Parallelogram, processConstraints);
constraints.ShapeConstraints.Add(ShapeType.Rhombus, conditionConstraints);
break;
case DiagramType.StateDiagram:
constraints.Width = 299; constraints.Height = 299;
constraints.AllowedShapes = new List <ShapeType>()
{
ShapeType.Circle, ShapeType.Ellipse, ShapeType.Rectangle
};
constraints.MaxShapes = 4; constraints.MinShapes = 3;
constraints.SameTypeShapes = true;
var stateConstraints = new ShapeConstraints();
stateConstraints.MaxInDegree = 4;
stateConstraints.MaxOutDegree = 4;
stateConstraints.MinInDegree = 1;
stateConstraints.MinOutDegree = 1;
constraints.ShapeConstraints.Add(ShapeType.Rectangle, stateConstraints);
constraints.ShapeConstraints.Add(ShapeType.Circle, stateConstraints);
constraints.ShapeConstraints.Add(ShapeType.Ellipse, stateConstraints);
break;
case DiagramType.SequenceDiagram:
constraints.Width = 299; constraints.Height = 299;
constraints.AllowedShapes = new List <ShapeType>()
{
ShapeType.Rectangle
};
constraints.MaxShapes = 6; constraints.MinShapes = 3;
constraints.SameTypeShapes = true;
var objectConstraints = new ShapeConstraints();
objectConstraints.MaxInDegree = 4;
objectConstraints.MaxOutDegree = 4;
objectConstraints.MinInDegree = 1;
objectConstraints.MinOutDegree = 1;
constraints.ShapeConstraints.Add(ShapeType.Rectangle, objectConstraints);
break;
}
LogicalImageGenerator generator = new LogicalImageGenerator(constraints);
int i = 1;
if (diagramType == DiagramType.FlowChart || diagramType == DiagramType.StateDiagram)
{
foreach (var image in generator.GenerateImage(100))
{
if (i > numDiag)
{
break;
}
Console.WriteLine($"Figure: {i}");
//printImage(image, constraints);
build_image(directory, image, constraints, i);
i++;
}
}
else if (diagramType == DiagramType.SequenceDiagram)
{
foreach (var image in generator.GenerateImage(100))
{
if (i > numDiag)
{
break;
}
Console.WriteLine($"Figure: {i}");
//printImage(image, constraints);
build_image_sd(directory, image, constraints, i);
i++;
}
}
}
