public void Intersection(uint idA, uint idB)
{
CadFigureMesh figA = GetCadFigureMesh(idA);
CadFigureMesh figB = GetCadFigureMesh(idB);
if (figA == null || figB == null)
{
ItConsole.println("invalid ID");
return;
}
HeModel he_a = figA.mHeModel;
HeModel he_b = figB.mHeModel;
CadMesh a = HeModelConverter.ToCadMesh(he_a);
CadMesh b = HeModelConverter.ToCadMesh(he_b);
CadMesh c = CarveW.Intersection(a, b);
MeshUtil.SplitAllFace(c);
HeModel hem = HeModelConverter.ToHeModel(c);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
CadOpe ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig.ID);
Session.AddOpe(ope);
Controller.CurrentLayer.AddFigure(fig);
Session.PostRemakeObjectTree();
}
private void testTriangulate()
{
CadFigure tfig = GetTargetFigure();
if (tfig == null || tfig.Type != CadFigure.Types.POLY_LINES)
{
return;
}
if (tfig.PointCount < 3)
{
return;
}
VertexList vl = tfig.GetPoints(12);
CadMesh m = IglW.Triangulate(vl, "a1000q");
HeModel hem = HeModelConverter.ToHeModel(m);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
Controller.CurrentLayer.AddFigure(fig);
}
public void SetMesh(HeModel mesh)
{
mHeModel = mesh;
mPointList = mHeModel.VertexStore;
UpdateSegList();
}
public CadFigureMesh()
{
Type = Types.MESH;
mHeModel = new HeModel();
mPointList = mHeModel.VertexStore;
}
public CadFigure MesthToFig(CadMesh cm)
{
HeModel hem = HeModelConverter.ToHeModel(cm);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
return(fig);
}
public void DrawHarfEdgeModel(
DrawBrush brush, DrawPen pen, DrawPen edgePen, double edgeThreshold, HeModel model)
{
DrawHeFaces(brush, model);
DrawHeEdges(pen, edgePen, edgeThreshold, model);
if (SettingsHolder.Settings.DrawNormal)
{
DrawHeFacesNormal(model);
}
}
public void CutMesh(uint id)
{
CadFigureMesh tfig = GetCadFigureMesh(id);
if (tfig == null)
{
ItConsole.println("invalid ID");
return;
}
(Vector3d p0, Vector3d p1) = InputLine();
if (p0.IsInvalid() || p1.IsInvalid())
{
return;
}
HeModel he = tfig.mHeModel;
CadMesh src = HeModelConverter.ToCadMesh(he);
Vector3d normal = CadMath.Normal(
p1 - p0, (Controller.DC.ViewDir));
(CadMesh m1, CadMesh m2) = MeshUtil.CutMeshWithVector(src, p0, p1, normal);
CadFigureMesh fig1 = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig1.SetMesh(HeModelConverter.ToHeModel(m1));
CadFigureMesh fig2 = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig2.SetMesh(HeModelConverter.ToHeModel(m2));
CadOpe ope;
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig1.ID);
Session.AddOpe(ope);
Controller.CurrentLayer.AddFigure(fig1);
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig2.ID);
Session.AddOpe(ope);
Controller.CurrentLayer.AddFigure(fig2);
ope = new CadOpeRemoveFigure(Controller.CurrentLayer, tfig.ID);
Session.AddOpe(ope);
Controller.CurrentLayer.RemoveFigureByID(tfig.ID);
Controller.ClearSelection();
Session.PostRemakeObjectTree();
}
public void ToPolyLine(uint id)
{
CadFigure fig = Controller.DB.GetFigure(id);
if (!(fig is CadFigureMesh))
{
return;
}
CadFigureMesh figMesh = (CadFigureMesh)fig;
HeModel hm = figMesh.mHeModel;
CadFigure figPoly = Controller.DB.NewFigure(CadFigure.Types.POLY_LINES);
hm.ForReachEdgePoint(v =>
{
figPoly.AddPoint(v);
});
if (figPoly.PointCount < 1)
{
return;
}
figPoly.IsLoop = true;
CadOpeList opeRoot = new CadOpeList();
CadOpe ope;
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, figPoly.ID);
opeRoot.Add(ope);
Controller.CurrentLayer.AddFigure(figPoly);
ope = new CadOpeRemoveFigure(Controller.CurrentLayer, fig.ID);
opeRoot.Add(ope);
Controller.CurrentLayer.RemoveFigureByID(fig.ID);
Session.AddOpe(opeRoot);
Env.RunOnMainThread(() =>
{
Controller.ClearSelection();
});
Session.PostRemakeObjectTree();
}
public void DrawHarfEdgeModel(
DrawBrush brush, DrawPen pen, DrawPen edgePen, double edgeThreshold, HeModel model)
{
for (int i = 0; i < model.FaceStore.Count; i++)
{
HeFace f = model.FaceStore[i];
HalfEdge head = f.Head;
HalfEdge c = head;
HalfEdge pair;
for (; ;)
{
bool edge = false;
pair = c.Pair;
if (pair == null)
{
edge = true;
}
else
{
double s = CadMath.InnerProduct(model.NormalStore[c.Normal], model.NormalStore[pair.Normal]);
if (Math.Abs(s) < edgeThreshold)
{
edge = true;
}
}
HalfEdge next = c.Next;
DrawPen dpen = edge ? edgePen : pen;
DrawLine(dpen,
model.VertexStore.Ref(c.Vertex).vector,
model.VertexStore.Ref(next.Vertex).vector
);
c = next;
if (c == head)
{
break;
}
}
}
}
private void testAminusB()
{
List <CadFigure> figList = Controller.DB.GetSelectedFigList();
if (figList.Count < 2)
{
return;
}
if (figList[0].Type != CadFigure.Types.MESH)
{
return;
}
if (figList[1].Type != CadFigure.Types.MESH)
{
return;
}
CadFigureMesh fig_a = (CadFigureMesh)figList[0];
CadFigureMesh fig_b = (CadFigureMesh)figList[1];
if (fig_a.Current)
{
CadFigureMesh t = fig_a;
fig_a = fig_b;
fig_b = t;
}
ItConsole.println("ID:" + fig_a.ID.ToString() + " - ID:" + fig_b.ID.ToString());
HeModel he_a = fig_a.mHeModel;
HeModel he_b = fig_b.mHeModel;
CadMesh a = HeModelConverter.ToCadMesh(he_a);
CadMesh b = HeModelConverter.ToCadMesh(he_b);
CadMesh c = CarveW.AMinusB(a, b);
HeModel hem = HeModelConverter.ToHeModel(c);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
Controller.CurrentLayer.AddFigure(fig);
}
private void test002()
{
CadMesh cm = MeshMaker.CreateSphere(new Vector3d(0, 0, 0), 20, 16, 16);
HeModel hem = HeModelConverter.ToHeModel(cm);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
CadOpe ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig.ID);
Controller.HistoryMan.foward(ope);
Controller.CurrentLayer.AddFigure(fig);
Controller.UpdateObjectTree(true);
}
private void testLoadOff()
{
string fname = @"F:\TestFiles\bunny.off";
CadMesh cm = IglW.ReadOFF(fname);
HeModel hem = HeModelConverter.ToHeModel(cm);
for (int i = 0; i < hem.VertexStore.Count; i++)
{
hem.VertexStore[i] *= 500.0;
}
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
Controller.CurrentLayer.AddFigure(fig);
}
private void DrawHeFaces(DrawBrush brush, HeModel model)
{
if (brush.IsNullBrush)
{
return;
}
EnableLight();
for (int i = 0; i < model.FaceStore.Count; i++)
{
HeFace f = model.FaceStore[i];
HalfEdge head = f.Head;
HalfEdge c = head;
GL.Begin(PrimitiveType.Polygon);
GL.Color4(brush.Color4());
if (f.Normal != HeModel.INVALID_INDEX)
{
Vector3d nv = model.NormalStore[f.Normal];
GL.Normal3(nv);
}
for (; ;)
{
GL.Vertex3((model.VertexStore.Ref(c.Vertex).vector *DC.WorldScale));
c = c.Next;
if (c == head)
{
break;
}
}
GL.End();
}
DisableLight();
}
public static MpHeModel_v1001 Create(HeModel model)
{
MpHeModel_v1001 ret = new MpHeModel_v1001();
ret.VertexStore = MpUtil_v1001.VertexListToMp(model.VertexStore);
ret.NormalStore = MpUtil_v1001.Vector3dListToMp(model.NormalStore);
ret.FaceStore = MpUtil_v1001.HeFaceListToMp(model.FaceStore);
ret.HeIdCount = model.HeIdProvider.Counter;
ret.FaceIdCount = model.FaceIdProvider.Counter;
List <HalfEdge> heList = model.GetHalfEdgeList();
ret.HalfEdgeList = MpUtil_v1001.HalfEdgeListToMp(heList);
return(ret);
}
private void testLoadDxf()
{
CadDxfLoader loader = new CadDxfLoader();
CadMesh cm = loader.Load(@"F:\work\恐竜.DXF", 20.0);
HeModel hem = HeModelConverter.ToHeModel(cm);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
Controller.CurrentLayer.AddFigure(fig);
RunOnMainThread(() =>
{
Controller.UpdateObjectTree(true);
});
Redraw();
}
private void DrawHeFacesNormal(HeModel model)
{
DisableLight();
for (int i = 0; i < model.FaceStore.Count; i++)
{
HeFace f = model.FaceStore[i];
HalfEdge head = f.Head;
HalfEdge c = head;
for (; ;)
{
HalfEdge next = c.Next;
Vector3d p = model.VertexStore.Ref(c.Vertex).vector;
if (c.Normal != HeModel.INVALID_INDEX)
{
Vector3d nv = model.NormalStore[c.Normal];
Vector3d np0 = p;
Vector3d np1 = p + (nv * 10);
DrawArrow(DC.GetPen(DrawTools.PEN_NORMAL), np0, np1, ArrowTypes.CROSS, ArrowPos.END, 3, 3);
}
c = next;
if (c == head)
{
break;
}
}
}
EnableLight();
}
public void CutMeshWithVector(CadFigureMesh tfig, Vector3d p0, Vector3d p1, Vector3d normal)
{
HeModel he = tfig.mHeModel;
CadMesh src = HeModelConverter.ToCadMesh(he);
(CadMesh m1, CadMesh m2) = MeshUtil.CutMeshWithVector(src, p0, p1, normal);
if (m1 == null || m2 == null)
{
return;
}
CadFigureMesh fig1 = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig1.SetMesh(HeModelConverter.ToHeModel(m1));
CadFigureMesh fig2 = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig2.SetMesh(HeModelConverter.ToHeModel(m2));
CadOpeList opeRoot = new CadOpeList();
CadOpe ope;
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig1.ID);
opeRoot.Add(ope);
Controller.CurrentLayer.AddFigure(fig1);
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig2.ID);
opeRoot.Add(ope);
Controller.CurrentLayer.AddFigure(fig2);
ope = new CadOpeRemoveFigure(Controller.CurrentLayer, tfig.ID);
opeRoot.Add(ope);
Controller.CurrentLayer.RemoveFigureByID(tfig.ID);
Controller.HistoryMan.foward(opeRoot);
}
// 押し出し
public void Extrude(uint id, Vector3d v, double d, int divide)
{
CadFigure tfig = Controller.DB.GetFigure(id);
if (tfig == null || tfig.Type != CadFigure.Types.POLY_LINES)
{
return;
}
v = v.UnitVector();
v *= -d;
CadMesh cm = MeshMaker.CreateExtruded(tfig.GetPoints(16), v, divide);
HeModel hem = HeModelConverter.ToHeModel(cm);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.RecalcNormal();
fig.SetMesh(hem);
CadOpeList root = new CadOpeList();
CadOpe ope;
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig.ID);
root.Add(ope);
ope = new CadOpeRemoveFigure(Controller.CurrentLayer, tfig.ID);
root.Add(ope);
Session.AddOpe(root);
Controller.CurrentLayer.AddFigure(fig);
Controller.CurrentLayer.RemoveFigureByID(tfig.ID);
Session.PostRemakeObjectTree();
}
public HeModel Restore()
{
HeModel ret = new HeModel();
ret.VertexStore = MpUtil_v1001.VertexListFromMp(VertexStore);
ret.NormalStore = MpUtil_v1001.Vector3dListFromMp(NormalStore);
// Create dictionary
Dictionary <uint, HalfEdge> dic = new Dictionary <uint, HalfEdge>();
dic[0] = null;
for (int i = 0; i < HalfEdgeList.Count; i++)
{
HalfEdge he = HalfEdgeList[i].Restore();
dic.Add(he.ID, he);
HalfEdgeList[i].TempHalfEdge = he;
}
// Create links
for (int i = 0; i < HalfEdgeList.Count; i++)
{
HalfEdge he = HalfEdgeList[i].TempHalfEdge;
he.Pair = dic[HalfEdgeList[i].PairID];
he.Next = dic[HalfEdgeList[i].NextID];
he.Prev = dic[HalfEdgeList[i].PrevID];
}
ret.FaceStore = MpUtil_v1001.HeFaceListFromMp(FaceStore, dic);
ret.HeIdProvider.Counter = HeIdCount;
ret.FaceIdProvider.Counter = FaceIdCount;
return(ret);
}
private void test003()
{
CadFigure tfig = GetTargetFigure();
if (tfig == null || tfig.Type != CadFigure.Types.POLY_LINES)
{
return;
}
CadMesh cm = MeshMaker.CreateExtruded(tfig.GetPoints(16), Vector3d.UnitZ * -20);
HeModel hem = HeModelConverter.ToHeModel(cm);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
CadOpe ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig.ID);
Controller.HistoryMan.foward(ope);
Controller.CurrentLayer.AddFigure(fig);
Controller.UpdateObjectTree(true);
}
// option:
// e.g.
// a100q30 max area = 100, min degree = 30
// a100q max area = 100, min degree = default (20)
// min degree < 34
// Other options see
// https://www.cs.cmu.edu/~quake/triangle.switch.html
//
public void Triangulate(uint figID, string option)
{
CadFigure tfig = Controller.DB.GetFigure(figID);
if (tfig == null || tfig.Type != Types.POLY_LINES)
{
return;
}
if (tfig.PointCount < 3)
{
return;
}
CadFigure cfig = FigUtil.Clone(tfig);
Vector3d org = cfig.PointList[0].vector;
Vector3d dir = Vector3d.UnitZ;
Vector3d faceNormal = CadUtil.TypicalNormal(cfig.PointList);
Vector3d rotateV = default;
double t = 0;
if (!faceNormal.EqualsThreshold(dir) && !(-faceNormal).EqualsThreshold(dir))
{
rotateV = CadMath.Normal(faceNormal, dir);
t = -CadMath.AngleOfVector(faceNormal, dir);
CadUtil.RotateFigure(cfig, org, rotateV, t);
}
//Controller.CurrentLayer.AddFigure(cfig);
VertexList vl = cfig.GetPoints(12);
CadMesh m = IglW.Triangulate(vl, option);
HeModel hem = HeModelConverter.ToHeModel(m);
CadFigureMesh fig = (CadFigureMesh)Controller.DB.NewFigure(CadFigure.Types.MESH);
fig.SetMesh(hem);
for (int i = 0; i < fig.PointCount; i++)
{
CadVertex v = fig.PointList[i];
v.Z = org.Z;
fig.PointList[i] = v;
}
if (t != 0)
{
CadUtil.RotateFigure(fig, org, rotateV, -t);
}
CadOpeList root = new CadOpeList();
CadOpe ope;
ope = new CadOpeAddFigure(Controller.CurrentLayer.ID, fig.ID);
Session.AddOpe(ope);
Controller.CurrentLayer.AddFigure(fig);
ope = new CadOpeRemoveFigure(Controller.CurrentLayer, figID);
Session.AddOpe(ope);
Controller.CurrentLayer.RemoveFigureByID(figID);
Controller.CurrentFigure = null;
Session.PostRemakeObjectTree();
}
private void DrawHeEdges(DrawPen borderPen, DrawPen edgePen, double edgeThreshold, HeModel model)
{
bool drawBorder = !borderPen.IsNullPen;
bool drawEdge = !edgePen.IsNullPen;
if (!drawBorder && !drawEdge)
{
return;
}
DisableLight();
GL.LineWidth(1.0f);
Color4 color = borderPen.Color4();
Color4 edgeColor = edgePen.Color4();
Vector3d shift = GetShiftForOutLine();
Vector3d p0;
Vector3d p1;
for (int i = 0; i < model.FaceStore.Count; i++)
{
HeFace f = model.FaceStore[i];
HalfEdge head = f.Head;
HalfEdge c = head;
HalfEdge pair;
p0 = model.VertexStore.Ref(c.Vertex).vector *DC.WorldScale + shift;
for (; ;)
{
bool drawAsEdge = false;
pair = c.Pair;
if (drawEdge)
{
if (pair == null)
{
drawAsEdge = true;
}
else
{
if (edgeThreshold != 0)
{
double s = CadMath.InnerProduct(model.NormalStore[c.Normal], model.NormalStore[pair.Normal]);
if (Math.Abs(s) <= edgeThreshold)
{
drawAsEdge = true;
}
}
}
}
p1 = model.VertexStore.Ref(c.Next.Vertex).vector *DC.WorldScale + shift;
if (drawAsEdge)
{
GL.Color4(edgeColor);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(p0);
GL.Vertex3(p1);
GL.End();
}
else
{
if (drawBorder)
{
GL.Color4(color);
GL.Begin(PrimitiveType.Lines);
GL.Vertex3(p0);
GL.Vertex3(p1);
GL.End();
}
}
p0 = p1;
c = c.Next;
if (c == head)
{
break;
}
}
}
}
