private void ExportNode(ComponentOccurrence componentOccurrence, SceneBuilder scene, NodeBuilder node)
{
var componentOccurrenceDefinition = componentOccurrence.Definition;
if (includeSynthData)
{
var occurrencePath = GetOccurrencePath(componentOccurrence);
node.Name = occurrencePath;
allComponentRealNames[occurrencePath] = componentOccurrence.Name;
}
else
{
node.Name = componentOccurrence.Name;
}
// ExportAppearanceCached(componentOccurrence.Appearance);
// node.LocalTransform = InvToGltfMatrix4X4(componentOccurrence.Transformation); TODO: mesh caching by using definitions instead of occurrences (materials were an issue)
switch (componentOccurrenceDefinition.Type)
{
case ObjectTypeEnum.kAssemblyComponentDefinitionObject:
ExportNodeAssembly(componentOccurrence, scene, node);
break;
case ObjectTypeEnum.kPartComponentDefinitionObject:
ExportNodePart(componentOccurrence, scene, node);
break;
}
}
/// <summary>
/// Adds the supplied component as a node with its corresponding parents and children.
/// </summary>
/// <param name="component"></param>
public void AddComponent(ComponentOccurrence component)
{
if (!component.Visible)
{
return;
}
TreeNode node = new TreeNode(component.Name);
node.Name = node.Text;
node.Tag = component;
node = GenerateFullTree(component, node);
TreeNodeCollection iterator = Nodes;
while (iterator.ContainsKey(node.Name) && node.Nodes.Count == 1)
{
iterator = iterator[iterator.IndexOfKey(node.Name)].Nodes;
node = node.Nodes[0];
}
iterator.RemoveByKey(node.Name);
iterator.Add(node);
}
public void getForm()
{
int offsetY = 30, offsetX = 10;
Form f = new Form();
f.Height = 150; f.Width = 400; f.WindowState = FormWindowState.Normal; f.Text = "Смещение"; f.StartPosition = FormStartPosition.CenterScreen;
f.AutoSizeMode = System.Windows.Forms.AutoSizeMode.GrowAndShrink; f.AutoSize = true;
System.Drawing.Point insPt = new System.Drawing.Point(5, 5);
InterfaceDll.Lbl lbs = new Lbl(offsetX, offsetY, 100, 15, insPt, f, "Дистанция");
InterfaceDll.CB cbs = new CB(offsetX, offsetY, 200, 15, insPt, f);
cbs.position(lbs.last(), true);
//cbs.last().Items.AddRange(new[] { "2.65", "2.8", "3", "4.5", "6" });
ComponentOccurrence occ = ss[1] as ComponentOccurrence;
if (occ == null)
{
return;
}
ins = occ.Constraints[1] as InsertConstraint;
if (ins == null)
{
return;
}
cbs.last().Text = last(ins.Distance);
InterfaceDll.Btn btns = new Btn(offsetX, offsetY, 100, 20, insPt, f, click, "Добавить");
btns.center(cbs.last(), offsetY + 5);
f.Show();
}
public double[] FindOrigin(ComponentOccurrence oCompOccur)
{
UnitsOfMeasure oUOM = _invApp.ActiveDocument.UnitsOfMeasure;
AssemblyComponentDefinition oCompDef = (AssemblyComponentDefinition)oCompOccur.Definition;
object oWorkPointProxy;
double[] c = new double[3];
WorkPoint oWP = oCompDef.WorkPoints[1];
oCompOccur.CreateGeometryProxy(oWP, out oWorkPointProxy);
c[0] = ((WorkPointProxy)oWorkPointProxy).Point.X;
c[1] = ((WorkPointProxy)oWorkPointProxy).Point.Y;
c[2] = ((WorkPointProxy)oWorkPointProxy).Point.Z;
for (int k = 0; k < 3; k++)
{
c[k] = oUOM.ConvertUnits(c[k], "cm", "m");
}
string AbsolutePosition, name;
name = FormatName(oCompOccur.Name);
return(c);
}
private void AddCasingComponentRecursive(ComponentOccurrence occurrence, Component component)
{
try
{
if (occurrence.DefinitionDocumentType == DocumentTypeEnum.kAssemblyDocumentObject)
{
AssemblyDocument assembly = (AssemblyDocument)occurrence.Definition.Document;
Component subComponent = GetCasingComponent(assembly);
// check whether the component exists
bool hasComponent = false;
foreach (Component componentLoc in component.Components)
{
if (componentLoc.FullFileName == subComponent.FullFileName)
{
hasComponent = true;
}
}
if (!hasComponent)
{
component.Components.Add(subComponent);
}
// Recursive call
//foreach (ComponentOccurrence subOccurrence in assembly.ComponentDefinition.Occurrences)
//{
// AddCasingComponentRecursive(subOccurrence, subComponent);
//}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, System.Reflection.MethodBase.GetCurrentMethod().Name, MessageBoxButton.OK);
}
}
public static List <ComponentOccurrence> GetComponentOccurrencesFromNodes(List <RigidNode_Base> nodes)
{
if (nodes == null)
{
return(null);
}
// Get all node ID's
List <string> nodeIDs = new List <string>();
;
foreach (RigidNode_Base node in nodes)
{
nodeIDs.AddRange(node.GetModelID().Split(new String[] { "-_-" }, StringSplitOptions.RemoveEmptyEntries));
}
// Select all nodes
List <ComponentOccurrence> occurrences = new List <ComponentOccurrence>();
foreach (string id in nodeIDs)
{
ComponentOccurrence occurrence = GetOccurrence(id);
if (occurrence != null)
{
occurrences.Add(occurrence);
}
}
return(occurrences);
}
private void button5_Click(object sender, EventArgs e)
{
if (_invApp.Documents.Count == 0)
{
MessageBox.Show("Need to open an Assembly document");
return;
}
if (_invApp.ActiveDocument.DocumentType != DocumentTypeEnum.kAssemblyDocumentObject)
{
MessageBox.Show("Need to have an Assembly document active");
return;
}
AssemblyDocument asmDoc = (AssemblyDocument)_invApp.ActiveDocument;
// Get the attribute manager for the document
AttributeManager attbMan = asmDoc.AttributeManager;
// Find the objects with the attributes
ObjectCollection objCol = default(ObjectCollection);
objCol = attbMan.FindObjects("myPartGroup", "PartGroup1", "Group1");
AttributeSets attbSets = default(AttributeSets);
// Delete the attribute from the ComponentOccurrence
foreach (object obj in objCol)
{
ComponentOccurrence compOcc = (ComponentOccurrence)obj;
attbSets = compOcc.AttributeSets;
attbSets["myPartGroup"].Delete();
// Make the ComponentOccurrence visible
compOcc.Visible = true;
}
}
private BrowserFolder getFolderForFile(BrowserPane browserPane, string searchedFileName)
{
BrowserFolder folder = null;
foreach (BrowserFolder curentFolder in browserPane.TopNode.BrowserFolders)
{
foreach (BrowserNode node in curentFolder.BrowserNode.BrowserNodes)
{
if (node.NativeObject is ComponentOccurrence)
{
ComponentOccurrence occ = (ComponentOccurrence)node.NativeObject;
string currentFileName = occ.ReferencedFileDescriptor.FullFileName;
if (!searchedFileName.Equals(currentFileName, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
}
else
{
continue;
}
folder = curentFolder;
break;
}
}
if (folder == null)
{
ObjectCollection colNodes = inventor.TransientObjects.CreateObjectCollection();
folder = browserPane.AddBrowserFolder("temp", colNodes);
}
return(folder);
}
private MeshBuilder <VertexPositionNormal> ExportMesh(ComponentOccurrence componentOccurrence)
{
var occurrencePath = GetOccurrencePath(componentOccurrence);
var mesh = new MeshBuilder <VertexPositionNormal>(occurrencePath);
if (includeSynthData)
{
try
{
massPropertiesMap[occurrencePath] = componentOccurrence.MassProperties;
}
catch { }
}
foreach (SurfaceBody surfaceBody in componentOccurrence.SurfaceBodies)
{
if (exportMaterials && exportFaceMaterials)
{
var surfaceBodyFaces = surfaceBody.Faces;
foreach (Face face in surfaceBodyFaces)
{
ExportPrimitive(face, mesh.UsePrimitive(ExportAppearanceCached(face.Appearance)));
}
}
else
{
ExportPrimitive(surfaceBody, mesh.UsePrimitive(ExportAppearanceCached(componentOccurrence.Appearance)));
}
}
return(mesh);
}
/// <summary>
/// Adds a component to the Component Property Dictionary.
/// </summary>
/// <param name="ComponentID"></param>
/// <param name="Component"></param>
public static void AddComponents(string ComponentID, ComponentOccurrence Component)
{
switch (Component.DefinitionDocumentType)
{
case DocumentTypeEnum.kPartDocumentObject:
CompPropertyDictionary.Add(Component.Name, ComponentID);
break;
case DocumentTypeEnum.kAssemblyDocumentObject:
AssemblyComponentDefinition AsmDef = (AssemblyComponentDefinition)Component.Definition;
List <string> AssemblyPartList = new List <string>();
foreach (ComponentOccurrence Comp in AsmDef.Occurrences.AllLeafOccurrences)
{
try
{
AssemblyPartList.Add(Comp.Name);
CompPropertyDictionary.Add(Comp.Name, ComponentID);
}
catch (ArgumentException) { }
}
try
{
AssemblyDictionary.Add(Component.Name, AssemblyPartList);
}
catch (ArgumentException)
{
AssemblyDictionary.Remove(Component.Name);
AssemblyDictionary.Add(Component.Name, AssemblyPartList);
}
break;
default:
throw new ArgumentException("ERROR: Component not an assembly or part", "Component");
}
}
/// <summary>
/// Adds parent and child components to the given node and returns the root node.
/// </summary>
/// <param name="component"></param>
/// <param name="node"></param>
/// <returns>The node</returns>
private TreeNode GenerateFullTree(ComponentOccurrence component, TreeNode node)
{
node = AddComponentChildren(component, node);
node = AddComponentParents(component, node);
node = FindRootNode(node);
return(node);
}
public ListViewItemTag(
ComponentOccurrence occurrence,
TreeNode treeNode)
{
Occurrences = new List <ComponentOccurrence>();
Occurrences.Add(occurrence);
TreeNode = treeNode;
}
public TreeNodeTag(
ComponentOccurrence occurrence,
ListViewItem listViewItem)
{
Occurrences = new List <ComponentOccurrence>();
Occurrences.Add(occurrence);
ListViewItem = listViewItem;
}
private void onClickBundle(NameValueMap Context)
{
Document oDoc = inventor.ActiveDocument;
if (!(oDoc is AssemblyDocument))
{
return;
}
AssemblyDocument doc = (AssemblyDocument)oDoc;
BrowserPane browserPane = doc.BrowserPanes[MODELBROWSERNAME];
BrowserNode topNode = browserPane.TopNode;
BrowserNode selectedNode = getSelectedNode(topNode);
if (selectedNode == null)
{
return;
}
string fileToBundle = "";
if (selectedNode.NativeObject is ComponentOccurrence)
{
ComponentOccurrence occ = (ComponentOccurrence)selectedNode.NativeObject;
fileToBundle = occ.ReferencedFileDescriptor.FullFileName;
BrowserFolder folder = getFolderForFile(browserPane, fileToBundle);
List <BrowserNode> nodesWithFileName = getNodesWithFileName(fileToBundle, topNode);
foreach (BrowserNode foundNode in nodesWithFileName)
{
folder.Add(foundNode);
}
folder.Name = nodesWithFileName.Count + "x " + System.IO.Path.GetFileNameWithoutExtension(fileToBundle);
}
else if (selectedNode.NativeObject is BrowserFolder)
{
BrowserFolder folder = (BrowserFolder)selectedNode.NativeObject;
if (folder.BrowserNode.BrowserNodes[1].NativeObject is ComponentOccurrence)
{
ComponentOccurrence occ = (ComponentOccurrence)folder.BrowserNode.BrowserNodes[1].NativeObject;
fileToBundle = occ.ReferencedFileDescriptor.FullFileName;
folder.Delete();
folder = getFolderForFile(browserPane, fileToBundle);
List <BrowserNode> nodesWithFileName = getNodesWithFileName(fileToBundle, topNode);
foreach (BrowserNode foundNode in nodesWithFileName)
{
folder.Add(foundNode);
}
folder.Name = nodesWithFileName.Count + "x " + System.IO.Path.GetFileNameWithoutExtension(fileToBundle);
}
}
}
public void offset(ComponentOccurrence occ, double d = 20)
{
ins = occ.Constraints[1] as InsertConstraint;
if (ins == null)
{
return;
}
str(ins.Distance, d);
}
public static ComponentOccurrence GetParent(ComponentOccurrence cO)
{
if (cO.ParentOccurrence != null)
{
return(GetParent(cO.ParentOccurrence));
}
else
{
return(cO);
}
}
public string ReturnParentName(ComponentOccurrence occur)
{
try
{
return(occur.Definition.Document.PropertySets.Item("Inventor User Defined Properties").Item("Parent").Value);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(null);
}
}
/// <summary>
/// Exports from a ComponentOccurrence.
/// </summary>
/// <param name="component"></param>
/// <param name="bestResolution"></param>
/// <param name="separateFaces"></param>
/// <param name="ignorePhysics"></param>
public void Export(ComponentOccurrence component, bool bestResolution = false,
bool separateFaces = false, bool ignorePhysics = false)
{
List <ExportPlan> plans = new List <ExportPlan>();
plans.AddRange(GenerateExportList(component, bestResolution, separateFaces, ignorePhysics));
for (int i = 0; i < plans.Count; i++)
{
AddFacets(plans[i].surf, plans[i].bestResolution, plans[i].separateFaces);
}
}
public double[] ComputeRelativeOffset(ComponentOccurrence Child, ComponentOccurrence Parent)
{
double[] c1 = FindOrigin(Parent);
double[] c2 = FindOrigin(Child);
double[] c3 = new double[3];
for (int k = 0; k < 3; k++)
{
c3[k] = c2[k] - c1[k];
}
return(c3);
}
/// <summary>
/// Gets the status of component in the assembly
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public bool GetComponentStatus(string name)
{
try
{
ComponentOccurrence occ = _adoc._adef.Occurrences.ItemByName[name];
return(occ.Suppressed);
}
catch
{
throw new Exception("Could not find component " + name);
}
}
/// <summary>
/// Get the occurence path as a list of strings
/// </summary>
/// <param name="occurrence"></param>
/// <returns></returns>
public static List <string> GetOccurencePath(this ComponentOccurrence occurrence)
{
var tempList = new List <string>();
if (occurrence != null)
{
foreach (ComponentOccurrence c in occurrence.OccurrencePath)
{
tempList.Add(c.Name);
}
}
return(tempList);
}
/// <summary>
/// Gets the occurence path as large string
/// </summary>
/// <param name="occurrence"></param>
/// <returns></returns>
public static string GetOccurencePathString(this ComponentOccurrence occurrence)
{
string temp = "";
if (occurrence != null)
{
foreach (ComponentOccurrence c in occurrence.OccurrencePath)
{
temp += c.Name;
}
}
return(temp);
}
//Main form Buttons
#region Buttons
//ok button
private void button2_Click(object sender, EventArgs e)
{
try
{
var_es.part_doc.SaveAs(path + @"/Shaft.ipt", true);
TransientGeometry TG = var_es.InventorApp.TransientGeometry;
Matrix matrix = TG.CreateMatrix();
ComponentOccurrence Shaft1 = var_es._Doc.ComponentDefinition.Occurrences.Add(path + @"/Shaft.ipt", matrix);
//ComponentOccurrence Shaft = var_es._Doc.ComponentDefinition.Occurrences.Add(path + @"/Shaft.iam", matrix);
var_es.part_doc.Close(true);
Close();
}
catch { }
}
public InstanceData(
ComponentOccurrence occ, int index)
{
// Could be assembly or part, but their relevant
// properties are the same, so can use "dynamic"
dynamic doc = occ.Definition.Document;
AssemblyDocument asm = occ.ContextDefinition.Document as AssemblyDocument;
// occurrences have no unique ID, only documents have
// let's create it based on the top assembly doc ID + component index
string internalName = asm.InternalName + "-" + index.ToString(); // Returns GUID + index
Debug.Print(internalName);
Vector pos = occ.Transformation.Translation;
string jsonProps = Util.GetPropertiesJson( );
// /a/src/web/CompHoundWeb/model/instance.js
// _id : UniqueId // suppress automatic generation
// project : String
// path : String
// urn : String
// family : String
// symbol : String
// category : String
// level : String
// x : Number
// y : Number
// z : Number
// easting : Number // Geo2d?
// northing : Number
// properties : String // json dictionary of instance properties and values
_id = internalName;
project = asm.DisplayName; // Assembly doc name
path = asm.File.FullFileName; // Assembly doc path
urn = string.Empty;
family = doc.DisplayName;
symbol = occ.Name; // Component occurrence name?
category = "";
level = "-1";
x = Util.ConvertCmToMillimetres( pos.X );
y = Util.ConvertCmToMillimetres( pos.Y );
z = Util.ConvertCmToMillimetres( pos.Z );
easting = 0;
northing = 0;
properties = jsonProps;
}
private void insertPartsAndMateEdges()
{
// create an assembly
AssemblyDocument oAssDoc = (AssemblyDocument)mApp.Documents.Add(DocumentTypeEnum.kAssemblyDocumentObject);
AssemblyComponentDefinition oAssDef = oAssDoc.ComponentDefinition;
Matrix oM = mApp.TransientGeometry.CreateMatrix();
//place the two parts
ComponentOccurrence oOcc1 = oAssDef.Occurrences.Add("c:\\temp\\test1.ipt", oM);
ComponentOccurrence oOcc2 = oAssDef.Occurrences.Add("c:\\temp\\test2.ipt", oM);
// find the two faces to mate
PartDocument oDoc1 = (PartDocument)oOcc1.Definition.Document;
ObjectCollection oObjCollection = oDoc1.AttributeManager.FindObjects("demoAttset", "demoAtt");
Face oFace1 = null;
if (oObjCollection[1] is Face)
{
oFace1 = (Face)oObjCollection[1];
}
PartDocument oDoc2 = (PartDocument)oOcc2.Definition.Document;
oObjCollection = oDoc2.AttributeManager.FindObjects("demoAttset", "demoAtt");
Face oFace2 = null;
if (oObjCollection[1] is Face)
{
oFace2 = (Face)oObjCollection[1];
}
Object tempObj;
//create the proxy objects for the two faces
oOcc1.CreateGeometryProxy(oFace1, out tempObj);
FaceProxy oAsmProxyFace1 = (FaceProxy)tempObj;
oOcc2.CreateGeometryProxy(oFace2, out tempObj);
FaceProxy oAsmProxyFace2 = (FaceProxy)tempObj;
// add the mate constraint
oAssDef.Constraints.AddMateConstraint(oAsmProxyFace1, oAsmProxyFace2, 0);
}
private void ExportNodeAssembly(ComponentOccurrence componentOccurrence, SceneBuilder scene, NodeBuilder node)
{
// ReSharper disable once SuspiciousTypeConversion.Global
var assemblyComponentDefinition = (AssemblyComponentDefinition)componentOccurrence.Definition;
try
{
if (visitedDocuments.Add(assemblyComponentDefinition.Document.InternalName()))
{
progressBar.Message = "Exporting mesh " + visitedDocuments.Count + " of " + progressTotal + "...";
progressBar.UpdateProgress();
}
}
catch { }
ExportNodes(componentOccurrence.SubOccurrences.Cast <ComponentOccurrence>(), scene, node);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static bool FindParentFeature(AssemblyDocument ParentDocument,
PartFeature partFeature,
out PartFeature asmFeature,
out ComponentOccurrence occurrence)
{
asmFeature = null;
occurrence = null;
try
{
AttributeSet set = partFeature.AttributeSets[_AttributeSet];
Byte[] contextData = set["ContextData"].Value as Byte[];
int keyContext = ParentDocument.ReferenceKeyManager.LoadContextFromArray(ref contextData);
Byte[] refKey1 = set["AsmFeatureRefKey"].Value as Byte[];
object MatchType1;
asmFeature = ParentDocument.ReferenceKeyManager.BindKeyToObject(ref refKey1,
keyContext,
out MatchType1) as PartFeature;
Byte[] refKey2 = set["OccurrenceRefKey"].Value as Byte[];
object MatchType2;
occurrence = ParentDocument.ReferenceKeyManager.BindKeyToObject(ref refKey2,
keyContext,
out MatchType2) as ComponentOccurrence;
if (asmFeature != null && occurrence != null)
{
return(true);
}
return(false);
}
catch
{
return(false);
}
}
void DocumentEvents_OnChangeSelectSet(
EventTimingEnum BeforeOrAfter,
NameValueMap Context,
out HandlingCodeEnum HandlingCode)
{
HandlingCode = HandlingCodeEnum.kEventNotHandled;
if (!_InventorSelectionEnabled)
{
return;
}
try
{
if (BeforeOrAfter == EventTimingEnum.kAfter)
{
if (ActiveDocument.SelectSet.Count != 0)
{
object obj = ActiveDocument.SelectSet[ActiveDocument.SelectSet.Count];
if (obj is ComponentOccurrence)
{
ComponentOccurrence occurrence = obj as ComponentOccurrence;
foreach (TreeNode childNode in _treeView.Nodes[0].Nodes)
{
foreach (TreeNode subChildNode in childNode.Nodes)
{
TreeNodeTag tag = subChildNode.Tag as TreeNodeTag;
if (tag.Occurrences.Contains(occurrence))
{
childNode.Expand();
_treeView.SelectedNode = subChildNode;
}
}
}
}
}
}
}
catch
{
}
}
/// <summary>
/// Adds the mesh for the given component, and all its subcomponents to the mesh storage structure.
/// </summary>
/// <param name="occ">The component to export</param>
/// <param name="bestResolution">Use the best possible resolution</param>
/// <param name="separateFaces">Export each face as a separate mesh</param>
/// <param name="ignorePhysics">Don't add the physical properties of this component to the exporter</param>
/// <returns>All the sufaces to export</returns>
private List <ExportPlan> GenerateExportList(ComponentOccurrence occ, bool bestResolution = false, bool separateFaces = false, bool ignorePhysics = false)
{
List <ExportPlan> plannedExports = new List <ExportPlan>();
if (!ignorePhysics)
{
// Compute physics
try
{
outputMesh.physics.Add((float)occ.MassProperties.Mass, Utilities.ToBXDVector(occ.MassProperties.CenterOfMass));
Console.WriteLine(InventorManager.Instance.ActiveDocument.UnitsOfMeasure.MassUnits.ToString());
}
catch
{
}
}
if (!occ.Visible)
{
return(plannedExports);
}
foreach (SurfaceBody surf in occ.SurfaceBodies)
{
Console.Write("Including: " + surf.Parent.Name);
plannedExports.Add(new ExportPlan(surf, bestResolution, separateFaces));
}
double totalVolume = 0;
foreach (ComponentOccurrence occ2 in occ.SubOccurrences)
{
totalVolume += Utilities.BoxVolume(occ2.RangeBox);
}
totalVolume /= occ.SubOccurrences.Count * adaptiveDegredation;
foreach (ComponentOccurrence item in occ.SubOccurrences)
{
if (!adaptiveIgnoring || Utilities.BoxVolume(item.RangeBox) >= totalVolume)
{
plannedExports.AddRange(GenerateExportList(item, bestResolution, separateFaces, true));
}
}
return(plannedExports);
}
private void button1_Click(object sender, EventArgs e)
{
a = Convert.ToDouble(this.textBox1.Text.Replace(',', separator)) / 10;
b = Convert.ToDouble(this.textBox2.Text.Replace(',', separator)) / 10;
this.Hide();
try
{
invApp = (Inventor.Application)m_PartDoc.Parent;
if (m_PartDoc.SubType == "{9C464203-9BAE-11D3-8BAD-0060B0CE6BB4}")
{
smcd = (SheetMetalComponentDefinition)m_PartDoc.ComponentDefinition;
}
tr = invApp.TransactionManager.StartTransaction((_Document)m_PartDoc, "Шипы");
objCol = invApp.TransientObjects.CreateObjectCollection();
if (asmDoc != null)
{
ComponentOccurrence co = asmDoc.ComponentDefinition.Occurrences.OfType <ComponentOccurrence>().FirstOrDefault(c => c.Name.ToLower().IndexOf("обтекатель") != -1);
if (co != null)
{
//PartDocument pDoc;
if (((Document)co.Definition.Document).SubType == "{9C464203-9BAE-11D3-8BAD-0060B0CE6BB4}")
{
smcd = (SheetMetalComponentDefinition)((PartDocument)co.Definition.Document).ComponentDefinition;
}
PlanarSketch plsk = smcd.Sketches.OfType <PlanarSketch>().FirstOrDefault(p => p.Name == "Шип");
if (plsk == null)
{
project(smcd, "Шип");
}
}
return;
}
profiles = selectFromSketch();
//offsetAdaptive(profiles);
offset(profiles);
tr.End();
this.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
tr.End();
this.Close();
}
}
/// <summary>
/// Allows the user to see if they have already added a collision component in select mode.
/// </summary>
/// <param name="PreSelectEntity"></param>
/// <param name="DoHighlight"></param>
/// <param name="MorePreSelectEntities"></param>
/// <param name="SelectionDevice"></param>
/// <param name="ModelPosition"></param>
/// <param name="ViewPosition"></param>
/// <param name="View"></param>
void selectEvents_OnPreSelect(ref object PreSelectEntity, out bool DoHighlight, ref ObjectCollection MorePreSelectEntities, SelectionDeviceEnum SelectionDevice, Inventor.Point ModelPosition, Point2d ViewPosition, Inventor.View View)
{
DoHighlight = true;
if (PreSelectEntity is ComponentOccurrence)
{
ComponentOccurrence componentOccurrence = (ComponentOccurrence)PreSelectEntity;
if (CollisionObjectsView.Nodes.Find(componentOccurrence.Name, true).Length > 0)
{
CollisionObjectsView.Invoke(new Action(() =>
{
CollisionObjectsView.SelectedNode = CollisionObjectsView.Nodes.Find(componentOccurrence.Name, true)[0];
CollisionObjectsView.SelectedNode.EnsureVisible();
}));
}
}
}
public OccurenceWrapper(ComponentOccurrence oCompOc)
{
nativeCompOccurence = oCompOc;
}
public void GetSelectedObject(GenericObject selection, out ObjectTypeEnum objectType, out NameValueMap additionalData, out ComponentOccurrence containingOccurrence, ref Object selectedObject)
{
InternalGetSelectedObject( selection, out objectType, out additionalData, out containingOccurrence, ref selectedObject);
}
private void InternalGetSelectedObject(GenericObject selection, out ObjectTypeEnum objectType, out NameValueMap additionalData, out ComponentOccurrence containingOccurrence, ref Object selectedObject)
{
PartDocumentInstance.GetSelectedObject( selection, out objectType, out additionalData, out containingOccurrence, ref selectedObject);
}
public void CreateAttribute(ComponentOccurrence myPart)
{
AttributeSets attribSets;
attribSets = myPart.AttributeSets;
AttributeSet attribSet;
if((attribSet = attribSets.Add("MyAttribSet", false)) == null)
{
attribSet = attribSets["MyAttribSet"];
}
Inventor.Attribute attrib;
if(attribSet.Count == 0)
{
attrib = attribSet.Add("MyAttrib", ValueTypeEnum.kStringType, "Some Text");
}
}
public void DeleteAttributes(ComponentOccurrence myPart)
{
AttributeSets attribSets;
attribSets = myPart.AttributeSets;
if(attribSets.get_NameIsUsed("MyAttribSet"))
{
Inventor.Attribute attrib;
attrib = attribSets["MyAttribSet"]["MyAttrib"];
attrib.Delete();
attribSets["MyAttribSet"].Delete();
}
}
public void RetrievAttributes(ComponentOccurrence myPart)
{
AttributeSets attribSets;
attribSets = myPart.AttributeSets;
Inventor.Attribute attrib;
attrib = attribSets["MyAttribSet"]["MyAttrib"];
MessageBox.Show(attrib.Value.ToString());
}
internal void PlaceWorkGeometryForContsraints(PartComponentDefinition layoutComponentDefinition, ComponentOccurrence layoutOccurrence, int moduleNumber)
{
PartDocument partDoc = (PartDocument)layoutComponentDefinition.Document;
ReferenceKeyManager refKeyManager = partDoc.ReferenceKeyManager;
//TODO: Property ModuleId can be factored out and _binder.ContextData can be used instead.
ModuleId = moduleNumber;
for (int i = 0; i < PointObjects.Count; i++)
{
//Each ModuleObject needs to have its ContextManager set.
PointObjects[i].Binder.ContextManager.BindingContextManager = refKeyManager;
WorkPoint workPoint;
if (PointObjects[i].Binder.GetObjectFromTrace<WorkPoint>(out workPoint))
{
Inventor.Point newLocation = PersistenceManager.InventorApplication.TransientGeometry.CreatePoint(InternalModulePoints[i].X,
InternalModulePoints[i].Y,
InternalModulePoints[i].Z);
workPoint.SetFixed(InternalModulePoints[i].ToPoint());
}
else
{
workPoint = layoutComponentDefinition.WorkPoints.AddFixed(InternalModulePoints[i].ToPoint(), false);
PointObjects[i].Binder.SetObjectForTrace<WorkPoint>(workPoint, ModuleUtilities.ReferenceKeysSorter);
}
//workPoint.Visible = false;
object workPointProxyObject;
layoutOccurrence.CreateGeometryProxy(workPoint, out workPointProxyObject);
LayoutWorkPointProxies.Add((WorkPointProxy)workPointProxyObject);
LayoutWorkPoints.Add(workPoint);
}
//If we will have more than 2 constraints, it will help assembly stability later
//if we have a plane to constrain to first.
if (InternalModulePoints.Count > 2)
{
WorkPlane workPlane;
//TODO: Is this a good idea? Why is this a list? Will we ever have more
//than work plane?
PlaneObjects[0].Binder.ContextManager.BindingContextManager = refKeyManager;
if (PlaneObjects[0].Binder.GetObjectFromTrace<WorkPlane>(out workPlane))
{
if (workPlane.DefinitionType == WorkPlaneDefinitionEnum.kThreePointsWorkPlane)
{
workPlane.SetByThreePoints(LayoutWorkPoints[0], LayoutWorkPoints[1], LayoutWorkPoints[2]);
LayoutWorkPlane = workPlane;
object wPlaneProxyObject;
layoutOccurrence.CreateGeometryProxy(workPlane, out wPlaneProxyObject);
LayoutWorkPlaneProxy = (WorkPlaneProxy)wPlaneProxyObject;
}
}
else
{
//If the first three points are colinear, adding a workplane will fail. We will check the area of a triangle
//described by the first three points. If the area is very close to 0, we can assume these points are colinear, and we should
//not attempt to construct a work plane from them.
Inventor.Point pt1 = LayoutWorkPoints[0].Point;
Inventor.Point pt2 = LayoutWorkPoints[1].Point;
Inventor.Point pt3 = LayoutWorkPoints[2].Point;
if (Math.Abs(pt1.X * (pt2.Y - pt3.Y) + pt2.X * (pt3.Y - pt1.Y) + pt3.X * (pt1.Y - pt2.Y)) > .0000001)
{
workPlane = layoutComponentDefinition.WorkPlanes.AddByThreePoints(LayoutWorkPoints[0], LayoutWorkPoints[1], LayoutWorkPoints[2], false);
PlaneObjects[0].Binder.SetObjectForTrace<WorkPlane>(workPlane, ModuleUtilities.ReferenceKeysSorter);
workPlane.Grounded = true;
//workPlane.Visible = false;
LayoutWorkPlane = workPlane;
object wPlaneProxyObject;
layoutOccurrence.CreateGeometryProxy(workPlane, out wPlaneProxyObject);
LayoutWorkPlaneProxy = (WorkPlaneProxy)wPlaneProxyObject;
}
}
}
}
