internal override void Create_BR(TransientGeometry TG, ref PlanarSketch sketch, EdgeCollection eColl, ref Face B_face, ref Face E_face, ref PartComponentDefinition partDef)
{
ChamferFeature chamf_Feature;
switch (Side)
{
case ('r'):
try
{
eColl.Add(B_face.Edges[1]);
}
catch
{
MessageBox.Show("Catch r");
//eColl.Add(B_face.Edges[2]);
}
chamf_Feature = partDef.Features.ChamferFeatures.AddUsingDistance(eColl, Distance);
break;
case ('l'):
try
{
eColl.Add(E_face.Edges[2]);
}
catch
{
MessageBox.Show("Catch l");
//eColl.Add(E_face.Edges[1]);
}
chamf_Feature = partDef.Features.ChamferFeatures.AddUsingDistance(eColl, Distance);
break;
}
}
public void ClearVertex(IVertex v)
{
if (v == null)
{
throw new ArgumentNullException("v");
}
if (!this.ContainsVertex(v))
{
throw new ArgumentException("v is not part of the graph");
}
EdgeCollection edges = new EdgeCollection();
foreach (IEdge e in this.VisitedGraph.OutEdges(v))
{
edges.Add(e);
}
foreach (IEdge e in this.VisitedGraph.InEdges(v))
{
edges.Add(e);
}
foreach (IEdge e in edges)
{
if (this.VisitedGraph.ContainsEdge(e))
{
RemoveEdge(e);
}
}
}
/// <summary>
/// Add a new vertex from source to target
///
/// Complexity: 2 search + 1 insertion
/// </summary>
/// <param name="source">Source vertex</param>
/// <param name="target">Target vertex</param>
/// <returns>Created Edge</returns>
/// <exception cref="ArgumentNullException">source or target is null</exception>
/// <exception cref="Exception">source or target are not part of the graph</exception>
public virtual IEdge AddEdge(
IVertex source,
IVertex target
)
{
// look for the vertex in the list
if (!VertexOutEdges.ContainsKey(source))
{
throw new VertexNotFoundException("Could not find source vertex");
}
if (!VertexOutEdges.ContainsKey(target))
{
throw new VertexNotFoundException("Could not find target vertex");
}
// if parralel edges are not allowed check if already in the graph
if (!this.AllowParallelEdges)
{
if (ContainsEdge(source, target))
{
return(null);
}
}
// create edge
IEdge e = Provider.ProvideEdge(source, target);
VertexOutEdges[source].Add(e);
m_Edges.Add(e);
return(e);
}
/// <summary>
/// Remove the edge (u,v) from the graph.
/// If the graph allows parallel edges this remove all occurrences of
/// (u,v).
/// </summary>
/// <param name="u">source vertex</param>
/// <param name="v">target vertex</param>
public virtual void RemoveEdge(IVertex u, IVertex v)
{
if (u == null)
{
throw new ArgumentNullException("source vertex");
}
if (v == null)
{
throw new ArgumentNullException("targetvertex");
}
EdgeCollection edges = VertexOutEdges[u];
// marking edges to remove
EdgeCollection removedEdges = new EdgeCollection();
foreach (IEdge e in edges)
{
if (e.Target == v)
{
removedEdges.Add(e);
}
}
//removing edges
foreach (IEdge e in removedEdges)
{
edges.Remove(e);
m_Edges.Remove(e);
}
}
public static void createFillet(PartDocument oDoc)
{
SheetMetalComponentDefinition oCompDef = (SheetMetalComponentDefinition)oDoc.ComponentDefinition;
SheetMetalFeatures sFeatures = (SheetMetalFeatures)oCompDef.Features;
foreach (Edge oEdge in oCompDef.SurfaceBodies[1].ConcaveEdges)
{
int tmpCount = oCompDef.SurfaceBodies[1].ConcaveEdges.Count;
coloroEntita(oDoc, 255, 0, 0, oEdge);
try
{
EdgeCollection oBendEdges = iApp.TransientObjects.CreateEdgeCollection();
oBendEdges.Add(oEdge);
BendDefinition oBendDef = sFeatures.BendFeatures.CreateBendDefinition(oBendEdges);
BendFeature oBendFeature = sFeatures.BendFeatures.Add(oBendDef);
//if (tmpCount != oCompDef.SurfaceBodies[1].ConcaveEdges.Count)
//{
createFillet(oDoc);
break;
//}
}
catch { }
}
}
/// <summary>
/// Removes <paramref name="vertex" /> from the graph
/// </summary>
/// <param name="vertex">The vertex.</param>
/// <returns>
/// true if <paramref name="vertex" /> was successfully removed; otherwise falSE.
/// </returns>
public bool RemoveVertex(TVertex vertex)
{
if (!this.ContainsVertex(vertex))
{
return(false);
}
// Remove all of the edges.
this.VertexEdges[vertex].Clear();
// iterage over edges and remove each edge touching the vertex
var edgeToRemove = new EdgeCollection <TVertex, TEdge>();
foreach (var entry in this.VertexEdges)
{
if (entry.Key.Equals(vertex))
{
continue;
}
foreach (var edge in entry.Value)
{
if (edge.Target.Equals(vertex))
{
edgeToRemove.Add(edge);
}
}
foreach (var edge in edgeToRemove)
{
entry.Value.Remove(edge);
}
}
return(this.VertexEdges.Remove(vertex));
}
/// <summary>
/// Removes all edges that match <paramref name="predicate" />.
/// </summary>
/// <param name="vertex">The vertex.</param>
/// <param name="predicate">
/// A pure delegate that takes an
/// <typeparamref name="TEdge" /> and returns true if the edge should
/// be removed.
/// </param>
/// <returns>
/// The number of edges removed.
/// </returns>
/// <exception cref="System.ArgumentNullException">predicate</exception>
public int RemoveEdge(TVertex vertex, Func <TEdge, bool> predicate)
{
if (!this.ContainsVertex(vertex))
{
return(0);
}
if (predicate == null)
{
throw new ArgumentNullException("predicate");
}
var edges = this.VertexEdges[vertex];
var edgeToRemove = new EdgeCollection <TVertex, TEdge>();
foreach (var edge in edges)
{
if (predicate(edge))
{
edgeToRemove.Add(edge);
}
}
foreach (var edge in edgeToRemove)
{
edges.Remove(edge);
if (this.EdgeList.Contains(edge))
{
this.EdgeList.Remove(edge);
}
}
return(edgeToRemove.Count);
}
/// <summary>
/// Remove all the out-edges of vertex u for which the predicate pred
/// returns true.
/// </summary>
/// <param name="u">vertex</param>
/// <param name="pred">edge predicate</param>
public void RemoveOutEdgeIf(IVertex u, IEdgePredicate pred)
{
if (u == null)
{
throw new ArgumentNullException("vertex u");
}
if (pred == null)
{
throw new ArgumentNullException("predicate");
}
EdgeCollection edges = VertexOutEdges[u];
EdgeCollection removedEdges = new EdgeCollection();
foreach (IEdge e in edges)
{
if (pred.Test(e))
{
removedEdges.Add(e);
}
}
foreach (IEdge e in removedEdges)
{
RemoveEdge(e);
}
}
/// <summary>
/// Augments the <see cref="VisitedGraph"/> with reversed edges.
/// </summary>
/// <exception cref="InvalidOperationException">
/// The graph has already been augmented.
/// </exception>
public void AddReversedEdges()
{
if (this.Augmented)
{
throw new InvalidOperationException("Graph already augmented");
}
// step 1, find edges that need reversing
EdgeCollection notReversedEdges = new EdgeCollection();
foreach (IEdge edge in this.VisitedGraph.Edges)
{
// if reversed already found, continue
if (this.reversedEdges.Contains(edge))
{
continue;
}
IEdge reversedEdge = this.FindReversedEdge(edge);
if (reversedEdge != null)
{
// setup edge
this.reversedEdges[edge] = reversedEdge;
// setup reversed if needed
if (!this.reversedEdges.Contains(reversedEdge))
{
this.reversedEdges[reversedEdge] = edge;
}
continue;
}
// this edge has no reverse
notReversedEdges.Add(edge);
}
// step 2, go over each not reversed edge, add reverse
foreach (IEdge edge in notReversedEdges)
{
if (this.reversedEdges.Contains(edge))
{
continue;
}
// already been added
IEdge reversedEdge = this.FindReversedEdge(edge);
if (reversedEdge != null)
{
this.reversedEdges[edge] = reversedEdge;
continue;
}
// need to create one
reversedEdge = this.VisitedGraph.AddEdge(edge.Target, edge.Source);
this.augmentedEgdes.Add(reversedEdge);
this.reversedEdges[edge] = reversedEdge;
this.reversedEdges[reversedEdge] = edge;
this.OnReservedEdgeAdded(new EdgeEventArgs(reversedEdge));
}
this.augmented = true;
}
/// <summary>
/// Merges the temporary circuit with the current circuit
/// </summary>
/// <returns>true if all the graph edges are in the circuit</returns>
protected bool CircuitAugmentation()
{
EdgeCollection newC = new EdgeCollection();
int i, j;
// follow C until w is found
for (i = 0; i < Circuit.Count; ++i)
{
IEdge e = Circuit[i];
if (e.Source == CurrentVertex)
{
break;
}
newC.Add(e);
}
// follow D until w is found again
for (j = 0; j < TemporaryCircuit.Count; ++j)
{
IEdge e = TemporaryCircuit[j];
newC.Add(e);
OnCircuitEdge(e);
if (e.Target == CurrentVertex)
{
break;
}
}
TemporaryCircuit.Clear();
// continue C
for (; i < Circuit.Count; ++i)
{
IEdge e = Circuit[i];
newC.Add(e);
}
// set as new circuit
circuit = newC;
// check if contains all edges
if (Circuit.Count == VisitedGraph.EdgesCount)
{
return(true);
}
return(false);
}
private void CreatePart_Click(object sender, EventArgs e)
{
if (inventor == null)
{
MessageBox.Show("No inventor instance detected", "error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
PartDocument doc = inventor.Documents.Add(DocumentTypeEnum.kPartDocumentObject, null, true) as PartDocument;
doc.PropertySets["{F29F85E0-4FF9-1068-AB91-08002B27B3D9}"]["Author"].Value = "Vladyslav Romanchuk";
//User-defined property
doc.PropertySets["{D5CDD505-2E9C-101B-9397-08002B2CF9AE}"].Add("Parts R Us", "Supplier");
PartComponentDefinition partDefinition = (PartComponentDefinition)doc.ComponentDefinition;
// Create a 2D sketch on the X-Y plane.
PlanarSketch sketch1 = (PlanarSketch)partDefinition.Sketches.Add(partDefinition.WorkPlanes[3]);
TransientGeometry tg = inventor.TransientGeometry;
Point2d[] points = new Point2d[5] {
tg.CreatePoint2d(0, 0), tg.CreatePoint2d(0, 20), tg.CreatePoint2d(20, 20), tg.CreatePoint2d(20, -10), tg.CreatePoint2d(10, -10)
};
SketchLine[] lines = new SketchLine[5];
lines[0] = sketch1.SketchLines.AddByTwoPoints(points[0], points[1]);
for (int i = 1; i < lines.Length - 1; i++)
{
lines[i] = sketch1.SketchLines.AddByTwoPoints(lines[i - 1].EndSketchPoint, points[i + 1]);
}
sketch1.SketchArcs.AddByCenterStartEndPoint(tg.CreatePoint2d(10, 0), lines[3].EndSketchPoint, lines[0].StartSketchPoint, false);
//Extrude
Profile profile = sketch1.Profiles.AddForSolid();
ExtrudeDefinition extrudeDefinition = partDefinition.Features.ExtrudeFeatures.CreateExtrudeDefinition(profile, PartFeatureOperationEnum.kNewBodyOperation);
extrudeDefinition.SetDistanceExtent(6, PartFeatureExtentDirectionEnum.kSymmetricExtentDirection);
ExtrudeFeature extrude = (ExtrudeFeature)partDefinition.Features.ExtrudeFeatures.Add(extrudeDefinition);
//second scatch
Face topCap = extrude.EndFaces[1];
sketch1 = partDefinition.Sketches.Add(topCap, false);
Point2d center = sketch1.ModelToSketchSpace(tg.CreatePoint(2.5, 1.5, 1.5));
SketchCircle Circle = sketch1.SketchCircles.AddByCenterRadius(center, 1);
profile = sketch1.Profiles.AddForSolid(true, null, null);
extrudeDefinition = partDefinition.Features.ExtrudeFeatures.CreateExtrudeDefinition(profile, PartFeatureOperationEnum.kJoinOperation);
extrudeDefinition.SetDistanceExtent(4, PartFeatureExtentDirectionEnum.kSymmetricExtentDirection);
extrude = (ExtrudeFeature)partDefinition.Features.ExtrudeFeatures.Add(extrudeDefinition);
Edges cylinderEdges = extrude.SideFaces[1].Edges;
EdgeCollection filletEdges = inventor.TransientObjects.CreateEdgeCollection(null);
//foreach (var el in cylinderEdges)
// filletEdges.Add(el);
filletEdges.Add(cylinderEdges[2]);
//adding fillet
partDefinition.Features.FilletFeatures.AddSimple(filletEdges, 0.25, false, false, false, false, false, true);
//doc.SaveAs("D:\\SaveTest2.ipt", false);
}
/// <summary>
/// Processes isolated edges by computing their labelling and adding them
/// to the isolated edges list.
/// Isolated edges are guaranteed not to touch the boundary of the target
/// (since if they did, they would have caused an intersection to be
/// computed and hence would not be isolated)
/// </summary>
private void LabelIsolatedEdges(int thisIndex, int targetIndex)
{
for (IEdgeEnumerator ei = arg[thisIndex].EdgeIterator; ei.MoveNext();)
{
Edge e = ei.Current;
if (e.Isolated)
{
LabelIsolatedEdge(e, targetIndex, arg[targetIndex].Geometry);
isolatedEdges.Add(e);
}
}
}
internal override void Create_BR(TransientGeometry TG, ref PlanarSketch sketch, EdgeCollection eColl, ref Face B_face, ref Face E_face, ref PartComponentDefinition partDef)
{
FilletFeature fillet_Feature;
switch (Side)
{
case ('r'):
/*foreach (Edge e in B_face.Edges)
* eColl.Add(e);*/
try
{
//MessageBox.Show("2 - r");
eColl.Add(B_face.Edges[1]);
}
catch
{
//MessageBox.Show("1 - r");
eColl.Add(B_face.Edges[2]);
}
fillet_Feature = partDef.Features.FilletFeatures.AddSimple(eColl, Radius);
break;
case ('l'):
/*foreach (Edge e in E_face.Edges)
* eColl.Add(e);*/
try
{
//MessageBox.Show("2 - l");
eColl.Add(E_face.Edges[2]);
}
catch
{
//MessageBox.Show("1 - l");
eColl.Add(E_face.Edges[1]);
}
fillet_Feature = partDef.Features.FilletFeatures.AddSimple(eColl, Radius);
break;
}
}
/// <summary>
/// Remove the edge (u,v) from the graph.
/// If the graph allows parallel edges this remove all occurrences of
/// (u,v).
/// </summary>
/// <param name="u">source vertex</param>
/// <param name="v">target vertex</param>
public override void RemoveEdge(IVertex u, IVertex v)
{
if (u == null)
{
throw new ArgumentNullException("source vertex");
}
if (v == null)
{
throw new ArgumentNullException("targetvertex");
}
EdgeCollection outEdges = VertexOutEdges[u];
EdgeCollection inEdges = VertexInEdges[v];
// marking edges to remove
EdgeCollection removedEdges = new EdgeCollection();
foreach (IEdge e in outEdges)
{
if (e.Target == v)
{
removedEdges.Add(e);
}
}
foreach (IEdge e in inEdges)
{
if (e.Source == u)
{
removedEdges.Add(e);
}
}
//removing edges
foreach (IEdge e in removedEdges)
{
RemoveEdge(e);
}
}
/// <summary>
/// Given some input EdgeCollection, iterates through its edges and adds 'valid' ones to a new
/// collection, which is then returned.
/// Validity is determined through the _IsLedgeValid function.
/// </summary>
/// <param name="ledgeColl"></param>
/// <param name="preTileMap"></param>
/// <param name="superTileMap"></param>
/// <returns></returns>
private static EdgeCollection <TileEdge> _BuildHoleGroupValidLedges(EdgeCollection <TileEdge> ledgeColl, TileMap preTileMap, TileMap superTileMap)
{
var validLedges = new EdgeCollection <TileEdge>();
foreach (TileEdge ledge in ledgeColl)
{
if (_IsLedgeValid(ledge, preTileMap, superTileMap))
{
TileEdge superimposedLedge = ledge.GetShiftedByN(SHIFT_DIST);
if (!validLedges.HasEdgePoints(superimposedLedge))
{
validLedges.Add(superimposedLedge);
}
}
}
return(validLedges);
}
/// <summary>
/// Simplifies the outer perim using EdgeCollections simplification algorithm.
/// </summary>
private Vector2[] _SimplifyOuterPerim()
{
var edgeCollection = new EdgeCollection <PolyEdge>();
for (int i = 0; i < this.outerPerimNodes.Count; i++)
{
var thisCoord = new Vector2(this.outerPerimNodes[i].x, this.outerPerimNodes[i].y);
var nextCoord = new Vector2(this.outerPerimNodes[(i + 1) % this.outerPerimNodes.Count].x,
this.outerPerimNodes[(i + 1) % this.outerPerimNodes.Count].y);
if (thisCoord == nextCoord)
{
continue;
}
var polyEdge = new PolyEdge(thisCoord, nextCoord);
edgeCollection.Add(polyEdge);
}
return(edgeCollection.GetSimplifiedPerim().ToArray());
}
public void SetChooseEdge(QuickGraph.Concepts.IVertex v, int k, QuickGraph.Concepts.IEdge e)
{
if (k == 0)
{
this.successors.Add(v, new EdgeCollection());
}
EdgeCollection col = this.successors[v];
if (col.Count <= k)
{
col.Add(e);
}
else
{
col[k] = e;
}
}
/// <summary>
/// Given a single perimeter, separate it into different ledge groups as appropriate, separate its Edges
/// into different EdgeCollections, one for each ledge group, then return both as dictionaries.
/// </summary>
/// <param name="ledgeCollMap">Dict which maps ledge group to EdgeCollection.</param>
/// <param name="ledgeGroupMap">Dict which maps superimposed TileMap to ledge group.</param>
/// The above two are here for copy-and-return purposes (maintaining object immutability).
/// <param name="tileMaps">List of all TileMaps.</param>
/// <param name="tileMap">TileMap that ledges are being filled for.</param>
///<param name="perimeter">EdgeCollection holding perimeter which will be separated in this func.</param>
/// <param name="tileGroup">TileGroup that ledges are being filled for.</param>
/// <param name="holeGroup">HoleGroup that ledges are being filled for.</param>
/// <returns>Two dictionaries matching the two input dicts but with the new ledge data added to each.</returns>
private static (Dictionary <LedgeCollKey, EdgeCollection <TileEdge> >, Dictionary <LedgeGroupKey, int>) _FillLedges(
IDictionary <LedgeCollKey, EdgeCollection <TileEdge> > ledgeCollMap,
IDictionary <LedgeGroupKey, int> ledgeGroupMap,
TileMapList tileMaps,
TileMap tileMap,
EdgeCollection <TileEdge> perimeter,
int tileGroup,
int holeGroup)
{
var ledgeCollMapClone = new Dictionary <LedgeCollKey, EdgeCollection <TileEdge> >(ledgeCollMap);
var ledgeGroupMapClone = new Dictionary <LedgeGroupKey, int>(ledgeGroupMap);
var ledges = new EdgeCollection <TileEdge>();
int ledgeGroup = 0;
foreach (TileEdge edge in perimeter)
{
Vector2 currentTile = edge.tileCoords;
int currentLayer = tileMap.ZIndex;
Vector2 adjTile = _GetAdjacentLowerTile(tileMaps, edge, currentLayer);
if (adjTile == currentTile)
{ //no adjacent tile exists
ledges.Add(edge);
}
else if (ledges.Count > 0)
{ //gap in ledges, finish current ledge group and move to next one
ledgeCollMapClone.Add(new LedgeCollKey(tileMap, tileGroup, holeGroup, tileMap, ledgeGroup),
new EdgeCollection <TileEdge>(ledges.GetOrderedCollection()));
ledgeGroup++;
ledges = new EdgeCollection <TileEdge>();
}
}
if (ledges.Count > 0)
{ //store ledges if not done already
ledgeCollMapClone.Add(new LedgeCollKey(tileMap, tileGroup, holeGroup, tileMap, ledgeGroup),
new EdgeCollection <TileEdge>(ledges.GetOrderedCollection()));
ledgeGroup++;
}
ledgeGroupMapClone.Add(new LedgeGroupKey(tileMap, tileGroup, holeGroup, tileMap), ledgeGroup);
return(ledgeCollMapClone, ledgeGroupMapClone);
}
/// <summary>
/// If edges which have undergone dimensional collapse are found,
/// replace them with a new edge which is a L edge
/// </summary>
private void ReplaceCollapsedEdges()
{
EdgeCollection replacableEdges = new EdgeCollection();
for (IEdgeEnumerator it = edgeList.Iterator(); it.MoveNext();)
{
Edge e = it.Current;
if (e.IsCollapsed)
{
replacableEdges.Add(e);
}
}
int nCount = replacableEdges.Count;
for (int i = 0; i < nCount; i++)
{
Edge e = replacableEdges[i];
edgeList.Replace(e, e.CollapsedEdge);
}
}
private void Node_MouseUp(object sender, MouseEventArgs e)
{
if (_ball != null && _ball.IsRunning)
{
return;
}
Node ctl = (Node)sender;
if (e.Button == MouseButtons.Left)
{
if (this.Tool == DrawingTools.Edge)
{
Point p2 = this.PointToClient(ctl.PointToScreen(e.Location));
Node node = this.GetChildAtPoint(p2) as Node;
if (node != null)
{
_edges.Add(new Edge(_startIndex, node.Index));
}
}
Invalidate();
OnContentChanged(null, null);
}
}
public static List <Lavorazione> main(EdgeLoops oEdgeLoops, Inventor.Application iApp)
{
List <Lavorazione> result = new List <Lavorazione>();
foreach (EdgeLoop oEdgeLoop in oEdgeLoops)
{
string nameLav = whois(oEdgeLoop.Edges);
if (!string.IsNullOrEmpty(nameLav))
{
EdgeCollection oEdgeColl = iApp.TransientObjects.CreateEdgeCollection();
foreach (Edge oEdge in oEdgeLoop.Edges)
{
oEdgeColl.Add(oEdge);
}
result.Add(new Lavorazione(nameLav, oEdgeColl));
}
}
return(result);
}
/// <summary>
/// Remove all the edges from graph g for which the predicate pred
/// returns true.
/// </summary>
/// <param name="pred">edge predicate</param>
public void RemoveEdgeIf(IEdgePredicate pred)
{
if (pred == null)
{
throw new ArgumentNullException("predicate");
}
// marking edge for removal
EdgeCollection removedEdges = new EdgeCollection();
foreach (IEdge e in Edges)
{
if (pred.Test(e))
{
removedEdges.Add(e);
}
}
// removing edges
foreach (IEdge e in removedEdges)
{
RemoveEdge(e);
}
}
public void AddEdge(string node1, string node2)
{
EdgeCollection.Add(new Edge {
EDG_NODE1 = node1, EDG_NODE2 = node2, EDG_LENGTH = 1, EDG_WEIGTH = 1
});
}
public void AddEdge(string node1, string node2, int length, int weigth)
{
EdgeCollection.Add(new Edge {
EDG_NODE1 = node1, EDG_NODE2 = node2, EDG_LENGTH = length, EDG_WEIGTH = weigth
});
}
/// <summary>
/// Computes a set of eulerian trail, starting at <paramref name="s"/>
/// that spans the entire graph.
/// </summary>
/// <remarks>
/// <para>
/// This method computes a set of eulerian trail starting at <paramref name="s"/>
/// that spans the entire graph.The algorithm outline is as follows:
/// </para>
/// <para>
/// The algorithms iterates throught the Eulerian circuit of the augmented
/// graph (the augmented graph is the graph with additional edges to make
/// the number of odd vertices even).
/// </para>
/// <para>
/// If the current edge is not temporary, it is added to the current trail.
/// </para>
/// <para>
/// If the current edge is temporary, the current trail is finished and
/// added to the trail collection. The shortest path between the
/// start vertex <paramref name="s"/> and the target vertex of the
/// temporary edge is then used to start the new trail. This shortest
/// path is computed using the <see cref="BreadthFirstSearchAlgorithm"/>.
/// </para>
/// </remarks>
/// <param name="s">start vertex</param>
/// <returns>eulerian trail set, all starting at s</returns>
/// <exception cref="ArgumentNullException">s is a null reference.</exception>
/// <exception cref="Exception">Eulerian trail not computed yet.</exception>
public EdgeCollectionCollection Trails(IVertex s)
{
if (s == null)
{
throw new ArgumentNullException("s");
}
if (this.Circuit.Count == 0)
{
throw new Exception("Circuit is empty");
}
// find the first edge in the circuit.
int i = 0;
for (i = 0; i < this.Circuit.Count; ++i)
{
IEdge e = this.Circuit[i];
if (TemporaryEdges.Contains(e))
{
continue;
}
if (e.Source == s)
{
break;
}
}
if (i == this.Circuit.Count)
{
throw new Exception("Did not find vertex in eulerian trail?");
}
// create collections
EdgeCollectionCollection trails = new EdgeCollectionCollection();
EdgeCollection trail = new EdgeCollection();
BreadthFirstSearchAlgorithm bfs =
new BreadthFirstSearchAlgorithm(VisitedGraph);
PredecessorRecorderVisitor vis = new PredecessorRecorderVisitor();
bfs.RegisterPredecessorRecorderHandlers(vis);
bfs.Compute(s);
// go throught the edges and build the predecessor table.
int start = i;
for (; i < this.Circuit.Count; ++i)
{
IEdge e = this.Circuit[i];
if (TemporaryEdges.Contains(e))
{
// store previous trail and start new one.
if (trail.Count != 0)
{
trails.Add(trail);
}
// start new trail
// take the shortest path from the start vertex to
// the target vertex
trail = vis.Path(e.Target);
}
else
{
trail.Add(e);
}
}
// starting again on the circuit
for (i = 0; i < start; ++i)
{
IEdge e = this.Circuit[i];
if (TemporaryEdges.Contains(e))
{
// store previous trail and start new one.
if (trail.Count != 0)
{
trails.Add(trail);
}
// start new trail
// take the shortest path from the start vertex to
// the target vertex
trail = vis.Path(e.Target);
}
else
{
trail.Add(e);
}
}
// adding the last element
if (trail.Count != 0)
{
trails.Add(trail);
}
return(trails);
}
private void ButtonBuild_Click(object sender, EventArgs e)
{
if (FalseWrite)
{
MessageBox.Show("Неправильно заданы входные параметры\nИсправьте красные поля");
return;
}
string docName = "Первая деталь";
CreateDoc(docName);
// Создание эскиза на YX
PlanarSketch Sketch = CompDef[docName].Sketches.Add(CompDef[docName].WorkPlanes[3]); // 1 - YZ ; 2 - ZX; 3 - XY
// Создание массивов Точек, Линий, Дуг, Окружностей
List <SketchPoint> points = new List <SketchPoint>(); // Точки
List <SketchLine> lines = new List <SketchLine>(); // Линии
List <SketchArc> arcs = new List <SketchArc>(); // Дуги
List <SketchCircle> circles = new List <SketchCircle>(); // Окружности
/////////////////////////////////////////////////////////// Выдавливание
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(0, 0), false));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(0, 5.0 / 10), false));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(0, 10.0 / 10), false));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(0, 15.0 / 10), false));
arcs.Add(Sketch.SketchArcs.AddByCenterStartEndPoint(points[points.Count - 2], points[points.Count - 3], points[points.Count - 1], true));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(0, 20.0 / 10), false));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(20.0 / 10, 20.0 / 10), false));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(20.0 / 10, 0), false));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[0], points[points.Count - 1]));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(10.0 / 10, 10.0 / 10), false));
circles.Add(Sketch.SketchCircles.AddByCenterRadius(points[points.Count - 1], 4.0 / 10));
Profile ProfileMain = (Profile)Sketch.Profiles.AddForSolid();
ExtrudeFeature ExtrudeDef = CompDef[docName].Features.ExtrudeFeatures.AddByDistanceExtent(
/*Эскиз*/ ProfileMain,
/*Длина в см*/ 10.0 / 10,
/*Направление вдоль оси*/ PartFeatureExtentDirectionEnum.kPositiveExtentDirection,
/*Операция*/ PartFeatureOperationEnum.kJoinOperation,
/*Эскиз*/ ProfileMain);
/////////////////////////////////////////////////////////// Вращение
WorkPlane WorkinPlace = CompDef[docName].WorkPlanes.AddByPlaneAndOffset(
CompDef[docName].WorkPlanes[2], 20.0 / 10);
WorkinPlace.Visible = false;
Sketch = CompDef[docName].Sketches.Add(WorkinPlace);
SketchLine line_axis;
points.Clear();
lines.Clear();
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(-(10.0 - 5) / 10, 0), false));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(-(10.0 - 5) / 10, 10.0 / 10), false));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(-10.0 / 10, 10.0 / 10), false));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(-10.0 / 10, 0), false));
line_axis = Sketch.SketchLines.AddByTwoPoints(points[points.Count - 2], points[points.Count - 1]);
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[0], points[points.Count - 1]));
Profile ProfileExternal = (Profile)Sketch.Profiles.AddForSolid();
RevolveFeature revolvefeature = CompDef[docName].Features.RevolveFeatures.AddFull(
ProfileExternal,
line_axis,
PartFeatureOperationEnum.kCutOperation);
Trans[docName].End();
/////////////////////////////////////////////////////////// Вторая деталь
docName = "Вторая деталь";
CreateDoc(docName);
Sketch = CompDef[docName].Sketches.Add(CompDef[docName].WorkPlanes[3]);
points.Clear();
lines.Clear();
///////////////////////////////////////////////// Шестиугольник
double R = 2 * (4.0 / 10) / Math.Sqrt(3), Angle;
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(
1.65 * Math.Cos(((double)210 / 180) * Math.PI),
1.65 * Math.Sin(((double)210 / 180) * Math.PI)), true));
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(points[0].Geometry.X + R, points[0].Geometry.Y), true));
for (int i = 2; i < 7; i++)
{
Angle = ((((double)i - 2) * 60 + 120) / 180);
points.Add(Sketch.SketchPoints.Add(TransGeom[docName].CreatePoint2d(
points[i - 1].Geometry.X + R * Math.Cos(Angle * Math.PI),
points[i - 1].Geometry.Y + R * Math.Sin(Angle * Math.PI)), true));
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[i - 1], points[i]));
}
lines.Add(Sketch.SketchLines.AddByTwoPoints(points[6], points[1]));
ProfileMain = (Profile)Sketch.Profiles.AddForSolid();
ExtrudeDef = CompDef[docName].Features.ExtrudeFeatures.AddByDistanceExtent(
/*Эскиз*/ ProfileMain,
/*Длина*/ 10.0 / 10,
/*Направление вдоль оси*/ PartFeatureExtentDirectionEnum.kPositiveExtentDirection,
/*Операция*/ PartFeatureOperationEnum.kJoinOperation,
/*Эскиз*/ ProfileMain);
///////////////////////////////////////////////// Фаска
ChamferFeature Fillet;
EdgeCollection Edges = ThisApplication.TransientObjects.CreateEdgeCollection();
int k = 0;
foreach (SurfaceBody SurfBody in PartDoc[docName].ComponentDefinition.SurfaceBodies)
{
foreach (Edge Edge in SurfBody.Edges)
{
if (k == 2)
{
Edges.Add(Edge);
}
if (k == 5)
{
Edges.Add(Edge);
}
if (k == 8)
{
Edges.Add(Edge);
}
if (k == 11)
{
Edges.Add(Edge);
}
if (k == 14)
{
Edges.Add(Edge);
}
if (k == 17)
{
Edges.Add(Edge);
}
k++;
}
}
Fillet = CompDef[docName].Features.ChamferFeatures.AddUsingDistance(Edges, 2.0 / 10);
///////////////////////////////////////////////// СОПРЯЖЕНИЕ
FilletFeature Fillet1;
Edges.Clear();
int n = 0;
foreach (SurfaceBody SurfBody in PartDoc[docName].ComponentDefinition.SurfaceBodies)
{
foreach (Edge Edge in SurfBody.Edges)
{
if (n == 18)
{
Edges.Add(Edge);
}
if (n == 20)
{
Edges.Add(Edge);
}
if (n == 21)
{
Edges.Add(Edge);
}
if (n == 23)
{
Edges.Add(Edge);
}
if (n == 26)
{
Edges.Add(Edge);
}
if (n == 27)
{
Edges.Add(Edge);
}
n++;
}
}
Fillet1 = CompDef[docName].Features.FilletFeatures.AddSimple(Edges, /*Радиус*/ 1.0 / 10);
// Заврешение транзакции
Trans[docName].End();
}
/// <summary>
/// Adds temporary edges to the graph to make all vertex even.
/// </summary>
/// <param name="g"></param>
/// <returns></returns>
public EdgeCollection AddTemporaryEdges(IMutableVertexAndEdgeListGraph g)
{
if (g == null)
{
throw new ArgumentNullException("g");
}
// first gather odd edges.
VertexCollection oddVertices = AlgoUtility.OddVertices(g);
// check that there are an even number of them
if (oddVertices.Count % 2 != 0)
{
throw new Exception("number of odd vertices in not even!");
}
// add temporary edges to create even edges:
EdgeCollection ec = new EdgeCollection();
bool found, foundbe, foundadjacent;
while (oddVertices.Count > 0)
{
IVertex u = oddVertices[0];
// find adjacent odd vertex.
found = false;
foundadjacent = false;
foreach (IEdge e in g.OutEdges(u))
{
IVertex v = e.Target;
if (v != u && oddVertices.Contains(v))
{
foundadjacent = true;
// check that v does not have an out-edge towards u
foundbe = false;
foreach (IEdge be in g.OutEdges(v))
{
if (be.Target == u)
{
foundbe = true;
break;
}
}
if (foundbe)
{
continue;
}
// add temporary edge
IEdge tempEdge = g.AddEdge(v, u);
// add to collection
ec.Add(tempEdge);
// remove u,v from oddVertices
oddVertices.Remove(u);
oddVertices.Remove(v);
// set u to null
found = true;
break;
}
}
if (!foundadjacent)
{
// pick another vertex
if (oddVertices.Count < 2)
{
throw new Exception("Eulerian trail failure");
}
IVertex v = oddVertices[1];
IEdge tempEdge = g.AddEdge(u, v);
// add to collection
ec.Add(tempEdge);
// remove u,v from oddVertices
oddVertices.Remove(u);
oddVertices.Remove(v);
// set u to null
found = true;
}
if (!found)
{
oddVertices.Remove(u);
oddVertices.Add(u);
}
}
temporaryEdges = ec;
return(ec);
}
