private void MaterialForm_Load(object sender, EventArgs e)
{
nameTextBox.Text = m_mat.GetName();
countTextBox.Text = m_mat.GetCount().ToString();
if (m_mat.GetMatType() == MAT_TYPE_EX.MAT_EX_RECT)
{
RectMatEx rectMat = (RectMatEx)(m_mat);
Rect2DEx rect = rectMat.GetBoundaryRect();
widthTextBox.Enabled = true;
widthTextBox.Text = rect.GetWidth().ToString("0.000");
heightTextBox.Enabled = true;
heightTextBox.Text = rect.GetHeight().ToString("0.000");
}
else if (m_mat.GetMatType() == MAT_TYPE_EX.MAT_EX_POLY)
{
PolyMatEx polyMat = (PolyMatEx)(m_mat);
Polygon2DEx poly = polyMat.GetMatPolygon();
Rect2DEx rect = poly.GetBoundaryRect();
widthTextBox.Enabled = false;
widthTextBox.Text = rect.GetWidth().ToString("0.000");
heightTextBox.Enabled = false;
heightTextBox.Text = rect.GetHeight().ToString("0.000");
}
}
private void okBtn_Click(object sender, EventArgs e)
{
// verify input.
try
{
Convert.ToDouble(widthTextBox.Text);
Convert.ToDouble(heightTextBox.Text);
Convert.ToInt32(countTextBox.Text);
}
catch (FormatException exception)
{
MessageBox.Show("Incorrect input: " + exception.Message, "NestProfessor DEMO");
return;
}
// update MatEx object.
m_mat.SetName(nameTextBox.Text);
m_mat.SetCount(Convert.ToInt32(countTextBox.Text));
if (m_mat.GetMatType() == MAT_TYPE_EX.MAT_EX_RECT)
{
RectMatEx rectMat = (RectMatEx)(m_mat);
Rect2DEx rect = new Rect2DEx(0.0, Convert.ToDouble(widthTextBox.Text), 0.0, Convert.ToDouble(heightTextBox.Text));
rectMat.SetMatRect(rect);
}
this.DialogResult = DialogResult.OK;
}
// draw the material.
static public void DrawMat(MatEx mat, GlViewPortEx viewPort)
{
viewPort.SetDrawColor(Color.White);
viewPort.SetLineWidth(1);
if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_RECT)
{
RectMatEx rectMat = (RectMatEx)mat;
Rect2DEx rect2D = rectMat.GetBoundaryRect();
Polygon2DEx poly = new Polygon2DEx();
poly.AddPoint(new Point2DEx(rect2D.GetXMin(), rect2D.GetYMin()));
poly.AddPoint(new Point2DEx(rect2D.GetXMax(), rect2D.GetYMin()));
poly.AddPoint(new Point2DEx(rect2D.GetXMax(), rect2D.GetYMax()));
poly.AddPoint(new Point2DEx(rect2D.GetXMin(), rect2D.GetYMax()));
viewPort.DrawPolygon(poly);
}
else if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_POLY)
{
PolyMatEx polyMat = (PolyMatEx)mat;
Polygon2DEx poly = polyMat.GetMatPolygon();
viewPort.DrawPolygon(poly);
// draw the useless holes.
Poly2DListEx uselessHoles = polyMat.GetUselessHoleList();
for (int i = 0; i < uselessHoles.Size(); i++)
{
viewPort.DrawPolygon(uselessHoles.GetPolygonByIndex(i));
}
}
}
// add material to list control.
private void AddMat(MatEx mat)
{
// the boundary rect of the material.
Rect2DEx boundaryRect = null;
if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_RECT)
{
RectMatEx rectMat = (RectMatEx)mat;
boundaryRect = rectMat.GetBoundaryRect();
}
else if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_POLY)
{
PolyMatEx polyMat = (PolyMatEx)mat;
Polygon2DEx polygon = polyMat.GetMatPolygon();
boundaryRect = polygon.GetBoundaryRect();
}
/************************************************************************/
// add a row to list control.
// insert a row.
int iCount = matListView.Items.Count + 1;
ListViewItem item = matListView.Items.Add(iCount.ToString());
// name column.
item.SubItems.Add(mat.GetName());
// material type column.
if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_RECT)
{
item.SubItems.Add("矩形材料");
}
else if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_POLY)
{
item.SubItems.Add("不规则材料");
}
// the material height.
item.SubItems.Add(boundaryRect.GetHeight().ToString("0.000"));
// the material width.
item.SubItems.Add(boundaryRect.GetWidth().ToString("0.000"));
// the material count.
item.SubItems.Add(mat.GetCount().ToString());
// hold the ID.
item.Tag = mat.GetID();
/************************************************************************/
// select the last row.
matListView.SelectedItems.Clear();
matListView.Items[matListView.Items.Count - 1].Selected = true;
matListView.Items[matListView.Items.Count - 1].Focused = true;
matListView.Items[matListView.Items.Count - 1].EnsureVisible();
}
private void editMatBtn_Click(object sender, EventArgs e)
{
ListView.SelectedListViewItemCollection selItems = matListView.SelectedItems;
if (selItems.Count != 1)
{
MessageBox.Show("Please select one row to edit.", "NestProfessor DEMO");
return;
}
else
{
ListViewItem item = selItems[0];
long iMatID = (long)item.Tag;
MatEx mat = m_matList.GetMatByID(iMatID);
if (mat != null)
{
if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_POLY)
{
MessageBox.Show("For irregular material, its width and height can be edited here.", "NestProfessor DEMO");
}
MaterialForm matForm = new MaterialForm(mat);
if (matForm.ShowDialog() == DialogResult.OK)
{
/************************************************************************/
// update the list control.
// name column.
item.SubItems[1].Text = mat.GetName();
if (mat.GetMatType() == MAT_TYPE_EX.MAT_EX_RECT)
{
RectMatEx rectMat = (RectMatEx)(mat);
Rect2DEx rect = rectMat.GetBoundaryRect();
// the material width.
item.SubItems[3].Text = rect.GetWidth().ToString("0.000");
// the material height.
item.SubItems[4].Text = rect.GetHeight().ToString("0.000");
}
// count.
item.SubItems[5].Text = mat.GetCount().ToString();
/************************************************************************/
matPreviewWnd.Invalidate();
}
}
}
}
private void newMatBtn_Click(object sender, EventArgs e)
{
// create a RectMatEx object.
Rect2DEx rect = new Rect2DEx(0, 1200, 0, 2400);
RectMatEx rectMat = new RectMatEx("新材料", rect, 1);
MaterialForm matForm = new MaterialForm(rectMat);
if (matForm.ShowDialog() == DialogResult.OK)
{
m_matList.AddMat(rectMat);
// add material to list control.
AddMat(rectMat);
}
}
static private void SaveMats(XmlDocument xmlDoc, XmlNode matListNode, MatListEx mats, List <KeyValuePair <long, string> > matDxfPath)
{
for (int i = 0; i < mats.Size(); i++)
{
MatEx mat = mats.GetMatByIndex(i);
XmlElement materialNode = xmlDoc.CreateElement("Material");
matListNode.AppendChild(materialNode);
bool bFromDxf = false;
for (int j = 0; i < matDxfPath.Count; j++)
{
if (matDxfPath[j].Key == mat.GetID())
{
XmlElement matPathNode = xmlDoc.CreateElement("MatPath");
matPathNode.InnerText = matDxfPath[j].Value;
materialNode.AppendChild(matPathNode);
// Count
{
XmlElement countNode = xmlDoc.CreateElement("Count");
countNode.InnerText = mat.GetCount().ToString();
materialNode.AppendChild(countNode);
}
bFromDxf = true;
break;
}
}
// material is not from dxf.
if (!bFromDxf)
{
RectMatEx rectMat = (RectMatEx)(mat);
// name
{
XmlElement nameNode = xmlDoc.CreateElement("Name");
nameNode.InnerText = mat.GetName();
materialNode.AppendChild(nameNode);
}
// Width
{
XmlElement widthNode = xmlDoc.CreateElement("Width");
widthNode.InnerText = rectMat.GetBoundaryRect().GetWidth().ToString("0.000000");
materialNode.AppendChild(widthNode);
}
// Height
{
XmlElement heightNode = xmlDoc.CreateElement("Height");
heightNode.InnerText = rectMat.GetBoundaryRect().GetHeight().ToString("0.000000");
materialNode.AppendChild(heightNode);
}
// Count
{
XmlElement countNode = xmlDoc.CreateElement("Count");
countNode.InnerText = rectMat.GetCount().ToString();
materialNode.AppendChild(countNode);
}
}
}
}
static private MatListEx LoadMats_V1(string strTaskFilePath, XmlNode matListNode, List <KeyValuePair <long, string> > matDxfPath, NestParamEx nestParam)
{
MatListEx mats = new MatListEx();
for (int i = 0; i < matListNode.ChildNodes.Count; i++)
{
XmlNode matNode = matListNode.ChildNodes.Item(i);
// whether load material from file.
XmlNode pathNode = matNode.SelectSingleNode("MatPath");
if (pathNode != null)
{
string strMaterialFileFullPath = pathNode.InnerText;
if (!File.Exists(strMaterialFileFullPath))
{
// the new file path.
string strTaskFileFolder = strTaskFilePath.Substring(0, strTaskFilePath.LastIndexOf("\\"));
string strMaterialFileName = strMaterialFileFullPath.Substring(strMaterialFileFullPath.LastIndexOf("\\") + 1, strMaterialFileFullPath.Length - strMaterialFileFullPath.LastIndexOf("\\") - 1);
string strNewMaterialFileFullPath = strTaskFileFolder + "\\" + strMaterialFileName;
// try again.
if (!File.Exists(strNewMaterialFileFullPath))
{
string strMessage = "Cannot find material file: ";
MessageBox.Show(strMessage + strMaterialFileFullPath, "NestProfessor DEMO");
continue;
}
else
{
strMaterialFileFullPath = strNewMaterialFileFullPath;
}
}
MatEx mat = NestHelper.LoadMatFromDxfdwg(strMaterialFileFullPath, nestParam);
mats.AddMat(mat);
matDxfPath.Add(new KeyValuePair <long, string>(mat.GetID(), strMaterialFileFullPath));
// count.
mat.SetCount(Convert.ToInt32(matNode.SelectSingleNode("Count").InnerText));
}
else
{
RectMatEx rectMat = new RectMatEx();
mats.AddMat(rectMat);
// name
rectMat.SetName(matNode.SelectSingleNode("Name").InnerText);
// width.
double dWidth = Convert.ToDouble(matNode.SelectSingleNode("Width").InnerText);
// height.
double dHeight = Convert.ToDouble(matNode.SelectSingleNode("Height").InnerText);
// the material rect.
Rect2DEx matRect = new Rect2DEx(0, dWidth, 0, dHeight);
rectMat.SetMatRect(matRect);
// count.
rectMat.SetCount(Convert.ToInt32(matNode.SelectSingleNode("Count").InnerText));
}
}
return(mats);
}
// load boundary polygon from dxf/dwg file.
static public MatEx LoadMatFromDxfdwg(String strFilePath, NestParamEx nestParam)
{
MatEx mat = null;
/************************************************************************/
// load all geometry items from the dxf/dwg file.
// the file name.
int iDotIndex = strFilePath.LastIndexOf('.');
int iSlashIndex = strFilePath.LastIndexOf('\\');
String strFileName = strFilePath.Substring(iSlashIndex + 1, iDotIndex - iSlashIndex - 1);
// whether the file is dxf file or dwg file.
bool bDwg = true;
String strExt = strFilePath.Substring(iDotIndex, strFilePath.Length - iDotIndex);
strExt = strExt.ToLower();
if (strExt == ".dxf")
{
bDwg = false;
}
else if (strExt == ".dwg")
{
bDwg = true;
}
else
{
return(mat);
}
// extract geometry items from dxf/dwg file.
ImpDataEx impData;
if (!bDwg)
{
impData = NestFacadeEx.ExtractGeomItems(strFilePath);
}
else
{
// the temp folder for dxf.
String strDxfPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
strDxfPath += "\\";
strDxfPath += new Random().Next(1, 100000).ToString();
strDxfPath += ".dxf";
// save dxf file in tmp path.
NestFacadeEx.Dwg2Dxf(strFilePath, strDxfPath);
// extract geometry items from dxf file.
impData = NestFacadeEx.ExtractGeomItems(strDxfPath);
// delete the temp file.
File.Delete(strDxfPath);
}
/************************************************************************/
/************************************************************************/
// get the polygons from the dxf/dwg file.
// build the polygons of all the geometry items.
GeomItemListEx geomItemList = impData.GetAllGeomItem();
Poly2DListEx polyList = NestFacadeEx.BuildPolyListFromLineArc(geomItemList, nestParam.GetConTol());
// if no closed polygon found, return.
if (polyList.Size() == 0)
{
MessageBox.Show("No closed boundary found.", "NestProfessor DEMO");
return(mat);
}
// the outer boundary polygon.
int iMaxIndex = polyList.GetMaxAreaPoly();
Polygon2DEx outerPoly = polyList.GetPolygonByIndex(iMaxIndex);
// the hole polygons.
polyList.DelPolygonByIndex(iMaxIndex);
Poly2DListEx holePolyList = polyList;
/************************************************************************/
/************************************************************************/
// build the material object.
// whether the boundary polygon is a rectangle.
bool bRectMat = true;
if (outerPoly.GetPtCount() != 4)
{
bRectMat = false;
}
else if (holePolyList.Size() > 0)
{
bRectMat = false;
}
else
{
// line items in the polygon.
ArrayList lineItems = outerPoly.GetLineList();
LineItemEx lineItem1 = (LineItemEx)lineItems[0];
LineItemEx lineItem2 = (LineItemEx)lineItems[1];
LineItemEx lineItem3 = (LineItemEx)lineItems[2];
LineItemEx lineItem4 = (LineItemEx)lineItems[3];
if (Math.Abs(lineItem1.GetLength() - lineItem3.GetLength()) > 0.0001)
{
bRectMat = false;
}
if (Math.Abs(lineItem2.GetLength() - lineItem4.GetLength()) > 0.0001)
{
bRectMat = false;
}
Vector2DEx vect1 = lineItem1.GetBaseVector();
Vector2DEx vect2 = lineItem2.GetBaseVector();
if (!vect1.OrthogonalTo(vect2))
{
bRectMat = false;
}
}
// build the material object.
if (bRectMat)
{
mat = new RectMatEx(strFileName, outerPoly.GetBoundaryRect(), 1);
}
else
{
PolyMatEx polyMat = new PolyMatEx(strFileName, outerPoly, 1);
polyMat.SetUselessHoleList(holePolyList);
mat = polyMat;
}
/************************************************************************/
return(mat);
}