private void bRndTile_Click(object sender, EventArgs e)
{
if (m_RandomTiler == null)
{
m_RandomTiler = new RandomTiler();
m_RandomTiler.Closed += m_RandomTiler_Closed;
m_RandomTiler.Show();
}
else
{
m_RandomTiler.BringToFront();
}
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
PointMap pointMap = new PointMap();
int[] toolHitArray = Enumerable.Repeat(0, 3).ToArray();
double marginX;
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
int punchQtyX = ((int)((spanX - punchingToolList[0].X) / XSpacing)) + 1;
double secondRowOffset = pitch * Math.Cos(Math.PI * 60 / 180);
if (spanX >= ((punchQtyX - 1) * XSpacing + secondRowOffset + punchingToolList[0].X))
{
marginX = (spanX - ((punchQtyX - 1) * XSpacing) - secondRowOffset) / 2;
}
else
{
marginX = (spanX - ((punchQtyX - 1) * XSpacing)) / 2;
}
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
// Record the current layer
int currentLayer = doc.Layers.CurrentLayerIndex;
// Set the layer to perforation
//if (!MetrixUtilities.IsLayerFound("TemporaryPerfLayer"))
//{
// RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
//}
//else
//{
// RhinoUtilities.SetActiveLayer("TemporaryToolHit", System.Drawing.Color.Black);
//}
// Random Engine
RandomTiler randomTileEngine = new RandomTiler();
int totalQty = punchQtyX * punchQtyY;
// except the last tool percentage will be total - all tool hit
List <double> toolHitPercentage = new List <double>(3);
toolHitPercentage.Add(0.368);
toolHitPercentage.Add(0.177);
// Create randomness for tool count
random = new Random();
int toolHitCount = 0;
// Create tile counts
List <int> tileCounts = new List <int>();
foreach (double pc in toolHitPercentage)
{
int toolHitQty = (int)(totalQty * pc);
tileCounts.Add(toolHitQty);
toolHitCount = toolHitCount + toolHitQty;
}
tileCounts.Add(totalQty - toolHitCount);
randomTileEngine.Weight = new int[5, 5]
{
{ 1, 1, 2, 1, 1 },
{ 1, 2, 3, 2, 1 },
{ 2, 3, 0, 3, 2 },
{ 1, 2, 3, 2, 1 },
{ 1, 1, 2, 1, 1 }
};
int[,] tileMap = randomTileEngine.GetTileMap(tileCounts, punchQtyX, punchQtyY);
int[] toolHitCounter = new int[3];
for (int y = 0; y < punchQtyY; y++)
{
if (y % 2 == 0) // even rows
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMap.AddPoint(new PunchingPoint(point));
punchingToolList[tileMap[x, y] - 1].drawTool(point);
toolHitArray[tileMap[x, y] - 1]++;
}
}
}
else // odd rows
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
pointMap.AddPoint(new PunchingPoint(point));
punchingToolList[tileMap[x, y] - 1].drawTool(point);
toolHitArray[tileMap[x, y] - 1]++;
}
}
}
}
//for (int y = 0; y < punchQtyY; y++)
//{
// for (int x = 0; x < punchQtyX; x++)
// {
// point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
// if (punchingToolList[0].isInside(boundaryCurve, point) == true)
// {
// pointMap.AddPoint(new PunchingPoint(point));
// punchingToolList[tileMap[x, y]-1].drawTool(point);
// toolHitArray[tileMap[x, y]-1]++;
// }
// }
//}
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double toolArea = 0;
double totalToolArea = 0;
for (int i = 0; i < 3; i++)
{
toolArea = punchingToolList[i].getArea() * toolHitArray[i];
totalToolArea = totalToolArea + toolArea;
RhinoApp.WriteLine("Tool area{0}: {1} mm^2", i, toolArea.ToString("#.##"));
}
openArea = totalToolArea * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMap, punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
PointMap[] pointMap = new PointMap[AtomicNumber];
for (int x = 0; x < AtomicNumber; ++x)
{
pointMap[x] = new PointMap();
}
int[] toolHitArray = Enumerable.Repeat(0, atomicNumber).ToArray();
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
int punchQtyX = ((int)((spanX - punchingToolList[0].X) / XSpacing)) + 1;
double marginX = (spanX - ((punchQtyX - 1) * XSpacing)) / 2;
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
Point3d origin = new Point3d(firstX, firstY, 0);
int currentLayer = doc.Layers.CurrentLayerIndex;
// Random Engine
RandomTiler randomTileEngine = new RandomTiler();
int totalQty = punchQtyX * punchQtyY;
// except the last tool percentage will be total - all tool hit
List <double> toolHitPercentage = new List <double>(atomicNumber - 1);
double average = 1 / (double)atomicNumber;
double minPercentage = (average - 0.125 * average);
//for (int i = 0; i < atomicNumber-1; i++)
//{
// toolHitPercentage.Add(minPercentage + random.NextDouble() * (2*0.125* average));
//}
double totalPercentage = 0;
for (int i = 0; i < atomicNumber - 1; i++)
{
if (PunchingToolList[i].Gap > 1)
{
PunchingToolList[i].Gap = 1;
}
if (totalPercentage + PunchingToolList[i].Gap <= 1)
{
totalPercentage += PunchingToolList[i].Gap;
toolHitPercentage.Add(PunchingToolList[i].Gap);
}
else
{
totalPercentage = 1;
PunchingToolList[i].Gap = 1 - totalPercentage;
toolHitPercentage.Add(PunchingToolList[i].Gap);
}
}
int toolHitCount = 0;
List <int> tileCounts = new List <int>();
foreach (double pc in toolHitPercentage)
{
int toolHitQty = (int)(totalQty * pc);
tileCounts.Add(toolHitQty);
toolHitCount = toolHitCount + toolHitQty;
}
randomTileEngine.Weight = new int[5, 5]
{
{ 1, 1, 2, 1, 1 },
{ 1, 2, 2, 2, 1 },
{ 2, 2, 0, 2, 2 },
{ 1, 2, 2, 2, 1 },
{ 1, 1, 2, 1, 1 }
};
tileCounts.Add(totalQty - toolHitCount);
int[,] tileMap = randomTileEngine.GetTileMap(tileCounts, punchQtyX, punchQtyY);
int[] toolHitCounter = new int[atomicNumber];
int type;
bool drawClusterToolHit = false;
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawClusterToolHit = true;
break;
}
}
int perforationLayer = currentLayer;
int toolHitlayer = doc.Layers.Find("Tool Hit", true);
if (toolHitlayer < 0)
{
toolHitlayer = doc.Layers.Add("Tool Hit", System.Drawing.Color.Black);
}
doc.Layers.SetCurrentLayerIndex(toolHitlayer, true);
for (int y = 0; y < punchQtyY; y++)
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
type = tileMap[x, y] - 1;
if (punchingToolList[type].ClusterTool.Enable == true)
{
doc.Layers.SetCurrentLayerIndex(perforationLayer, true);
}
else
{
doc.Layers.SetCurrentLayerIndex(toolHitlayer, true);
}
if (punchingToolList[type].isInside(boundaryCurve, point) == true)
{
pointMap[type].AddPoint(new PunchingPoint(point));
for (int t = type; t < AtomicNumber; t++)
{
pointMap[t].AddPoint(new PunchingPoint(point));
}
if (PunchingToolList[type].ClusterTool.Enable == false)
{
punchingToolList[type].drawTool(point);
if (punchingToolList[type].Perforation == true && drawClusterToolHit == true)
{
doc.Layers.SetCurrentLayerIndex(perforationLayer, true);
punchingToolList[type].drawTool(point);
}
}
else if (punchingToolList[type].Perforation == true)
{
punchingToolList[type].drawTool(point);
}
toolHitArray[type]++;
}
}
}
Rhino.DocObjects.RhinoObject [] perforations = doc.Objects.FindByLayer("Perforation");
foreach (var perforation in perforations)
{
perforation.Attributes.DisplayOrder = 1;
perforation.CommitChanges();
}
doc.Views.Redraw();
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double toolArea = 0;
double totalToolArea = 0;
for (int i = 0; i < this.atomicNumber; i++)
{
toolArea = punchingToolList[i].getArea() * toolHitArray[i];
totalToolArea = totalToolArea + toolArea;
RhinoApp.WriteLine("Tool area{0}: {1} mm^2", i, toolArea.ToString("#.##"));
}
openArea = totalToolArea * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMap[i], punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
List <PointMap> pointMapList = new List <PointMap>();
Random random = new Random();
PointMap pointMapTool1 = new PointMap();
double marginX;
pointMapList.Add(pointMapTool1);
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
double secondRowOffset = XSpacing / 2;
int punchQtyX = ((int)((spanX - punchingToolList[0].X) / XSpacing)) + 1;
if (spanX >= ((punchQtyX - 1) * XSpacing + secondRowOffset + punchingToolList[0].X))
{
marginX = (spanX - ((punchQtyX - 1) * XSpacing) - secondRowOffset) / 2;
}
else
{
marginX = (spanX - ((punchQtyX - 1) * XSpacing)) / 2;
}
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
// Record the current layer
int currentLayer = doc.Layers.CurrentLayerIndex;
// Create Perforation Layer
// if (punchingToolList[0].ClusterTool.Enable == true)
{
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
}
//else
//{
// if (!MetrixUtilities.IsLayerFound("TemporaryPerfLayer"))
// {
// RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
// }
// else
// {
// RhinoUtilities.SetActiveLayer("TemporaryToolHit", System.Drawing.Color.Black);
// }
//}
// Random Engine
RandomTiler randomTileEngine = new RandomTiler();
int totalQty = punchQtyX * punchQtyY;
int toolHitQty = (int)(totalQty * randomness);
int blankQty = totalQty - toolHitQty;
List <int> tileCounts = new List <int>();
tileCounts.Add(toolHitQty);
tileCounts.Add(blankQty);
int[,] tileMap = randomTileEngine.GetTileMap(tileCounts, punchQtyX, punchQtyY);
for (int y = 0; y < punchQtyY; y++)
{
if (y % 2 == 0) // even rows
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
if (tileMap[x, y] == 1)
{
pointMapTool1.AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
}
else // odd rows
{
for (int x = 0; x < punchQtyX; x++)
{
point = new Point3d(firstX + secondRowOffset + (x * XSpacing), firstY + y * YSpacing, 0);
if (punchingToolList[0].isInside(boundaryCurve, point) == true)
{
if (tileMap[x, y] == 1)
{
pointMapTool1.AddPoint(new PunchingPoint(point));
punchingToolList[0].drawTool(point);
}
}
}
}
}
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double toolArea = punchingToolList[0].getArea() * pointMapTool1.Count;
RhinoApp.WriteLine("Tool area: {0} mm^2", toolArea.ToString("#.##"));
openArea = toolArea * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMapList[i], punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
private void m_RandomTiler_Closed(object sender, EventArgs e)
{
m_RandomTiler.Dispose();
m_RandomTiler = null;
}
/// <summary>
/// Draws the perforation.
/// </summary>
/// <param name="boundaryCurve">The boundary curve.</param>
/// <returns></returns>
public override double drawPerforation(Curve boundaryCurve)
{
List <PointMap> pointMapList = new List <PointMap>();
Random random = new Random();
PointMap pointMapTool1 = new PointMap();
int tool0count = 0;
int tool1count = 0;
int tool2count = 0;
double marginX;
pointMapList.Add(pointMapTool1);
// Find the boundary
BoundingBox boundingBox = boundaryCurve.GetBoundingBox(Plane.WorldXY);
Point3d min = boundingBox.Min;
Point3d max = boundingBox.Max;
double spanX = max.X - min.X;
double spanY = max.Y - min.Y;
double gap = xSpacing - punchingToolList[2].X;
// Maximum punching qty
int punchQtyX = ((int)((spanX - punchingToolList[2].X) / XSpacing)) + 1;
// PunchQty need to add 1 if the last bit can fit the small rectangle
if (spanX - (punchingToolList[2].X * punchQtyX) > (punchingToolList[0].X + gap))
{
punchQtyX = punchQtyX + 1;
}
// Find the location of the first punch
if (spanX >= ((punchQtyX - 1) * XSpacing + punchingToolList[2].X))
{
marginX = (spanX - ((punchQtyX - 2) * XSpacing) - (punchingToolList[2].X) - gap) / 2;
}
else if (spanX >= ((punchQtyX - 1) * XSpacing + punchingToolList[1].X))
{
marginX = (spanX - ((punchQtyX - 2) * XSpacing) - (punchingToolList[1].X) - gap) / 2;
}
else
{
marginX = (spanX - ((punchQtyX - 2) * XSpacing) - (punchingToolList[0].X) - gap) / 2;
}
int punchQtyY = ((int)((spanY - punchingToolList[0].Y) / YSpacing)) + 1;
double marginY = (spanY - ((punchQtyY - 1) * YSpacing)) / 2;
Point3d point;
RhinoDoc doc = RhinoDoc.ActiveDoc;
double firstX = min.X + marginX;
double firstY = min.Y + marginY;
// Record the current layer
int currentLayer = doc.Layers.CurrentLayerIndex;
// Create Perforation Layer
//if (punchingToolList[0].ClusterTool.Enable == true)
{
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
}
//else
//{
// if (!MetrixUtilities.IsLayerFound("TemporaryPerfLayer"))
// {
// RhinoUtilities.SetActiveLayer(Properties.Settings.Default.ToolHitLayerName, System.Drawing.Color.Black);
// }
// else
// {
// RhinoUtilities.SetActiveLayer("TemporaryToolHit", System.Drawing.Color.Black);
// }
//}
// Random Engine
RandomTiler randomTileEngine = new RandomTiler();
int totalQty = (punchQtyX + 1) * punchQtyY;
int toolHitQty = (int)(totalQty * randomness);
int blankQty = totalQty - toolHitQty;
List <int> tileCounts = new List <int>();
tileCounts.Add(toolHitQty);
tileCounts.Add(blankQty);
int[,] tileMap = randomTileEngine.GetTileMap(tileCounts, punchQtyX + 1, punchQtyY);
Point3d pointMedL;
Point3d pointMedR;
Point3d pointShortL;
Point3d pointShortR;
Point3d pointLeft, pointRight, pointTop, pointBottom;
double toolOffset = XSpacing / 6;
double rowOffset = XSpacing / 3;
for (int y = 0; y < punchQtyY; y++)
{
if (y % 3 == 0) // Long tool row
{
// first X
firstX = min.X + marginX;
}
else if (y % 3 == 1) // Med tool row
{
firstX = min.X + marginX - rowOffset;
}
else // short tool rows
{
firstX = min.X + marginX - (2 * rowOffset);
}
bool isBorderPunch = false;
for (int x = 0; x < punchQtyX + 1; x++)
{
point = new Point3d(firstX + x * XSpacing, firstY + y * YSpacing, 0);
pointMedL = new Point3d(firstX + x * XSpacing - toolOffset, firstY + y * YSpacing, 0);
pointMedR = new Point3d(firstX + x * XSpacing + toolOffset, firstY + y * YSpacing, 0);
pointShortL = new Point3d(firstX + x * XSpacing - 2 * toolOffset, firstY + y * YSpacing, 0);
pointShortR = new Point3d(firstX + x * XSpacing + 2 * toolOffset, firstY + y * YSpacing, 0);
pointLeft = new Point3d(firstX + (x - 1) * XSpacing, firstY + y * YSpacing, 0);
pointRight = new Point3d(firstX + (x + 1) * XSpacing, firstY + y * YSpacing, 0);
pointTop = new Point3d(firstX + x * XSpacing, firstY + (y + 1) * YSpacing, 0);
pointBottom = new Point3d(firstX + (x + 1) * XSpacing, firstY + (y - 1) * YSpacing, 0);
// Test if the current punch is close to border
isBorderPunch = false;
if (punchingToolList[0].isInside(boundaryCurve, pointLeft) == false)
{
isBorderPunch = true;
}
if (punchingToolList[0].isInside(boundaryCurve, pointRight) == false)
{
isBorderPunch = true;
}
if (punchingToolList[0].isInside(boundaryCurve, pointTop) == false)
{
isBorderPunch = true;
}
if (punchingToolList[0].isInside(boundaryCurve, pointBottom) == false)
{
isBorderPunch = true;
}
if (isBorderPunch == true || tileMap[x, y] == 1)
{
if (punchingToolList[2].isInside(boundaryCurve, point) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(point));
punchingToolList[2].drawTool(point);
tool2count++;
}
else if (punchingToolList[1].isInside(boundaryCurve, pointMedL) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointMedL));
punchingToolList[1].drawTool(pointMedL);
tool1count++;
}
else if (punchingToolList[1].isInside(boundaryCurve, pointMedR) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointMedR));
punchingToolList[1].drawTool(pointMedR);
tool1count++;
}
else if (punchingToolList[0].isInside(boundaryCurve, pointShortL) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointShortL));
punchingToolList[0].drawTool(pointShortL);
tool0count++;
}
else if (punchingToolList[0].isInside(boundaryCurve, pointShortR) == true)
{
pointMapTool1.AddPoint(new PunchingPoint(pointShortR));
punchingToolList[0].drawTool(pointShortR);
tool0count++;
}
}
}
}
// Display the open area calculation
AreaMassProperties area = AreaMassProperties.Compute(boundaryCurve);
RhinoApp.WriteLine("Total area: {0} mm^2", area.Area.ToString("#.##"));
double tool0Area = punchingToolList[0].getArea() * tool0count;
double tool1Area = punchingToolList[1].getArea() * tool1count;
double tool2Area = punchingToolList[2].getArea() * tool2count;
RhinoApp.WriteLine("Tool 1 area: {0} mm^2", tool0Area.ToString("#.##"));
RhinoApp.WriteLine("Tool 2 area: {0} mm^2", tool1Area.ToString("#.##"));
RhinoApp.WriteLine("Tool 3 area: {0} mm^2", tool2Area.ToString("#.##"));
openArea = (tool0Area + tool1Area + tool2Area) * 100 / area.Area;
RhinoApp.WriteLine("Open area: {0}%", openArea.ToString("#."));
// Draw the cluster for each tool
for (int i = 0; i < punchingToolList.Count; i++)
{
// Only draw cluster tool if it is enable
if (punchingToolList[i].ClusterTool.Enable == true)
{
// Draw the cluster tool
drawCluster(pointMapList[i], punchingToolList[i]);
}
}
doc.Views.Redraw();
doc.Layers.SetCurrentLayerIndex(currentLayer, true);
return(openArea);
}
