private void button3_Click(object sender, EventArgs e)
{
// Connect to or start Solid Edge.
YCC_solidedge.getEdgeApplication(ref SEApp, true);
SolidEdgeAssembly.AssemblyDocument asydoc = (SolidEdgeAssembly.AssemblyDocument)SEApp.ActiveDocument;
SolidEdgeAssembly.Occurrences occs = (SolidEdgeAssembly.Occurrences)asydoc.Occurrences;
SolidEdgeAssembly.Occurrence occ = (SolidEdgeAssembly.Occurrence)occs.Item(2);
Array MinRangePoint = Array.CreateInstance(typeof(double), 0);
Array MaxRangePoint = Array.CreateInstance(typeof(double), 0);
//object[] w = new object[3];
occ.GetRangeBox(ref MinRangePoint, ref MaxRangePoint);
SolidEdgePart.PartDocument ps = (SolidEdgePart.PartDocument)occ.OccurrenceDocument;
//SolidEdgePart.Models ms = (SolidEdgePart.Models)ps.Models.Item[1];
SolidEdgePart.Model m = (SolidEdgePart.Model)ps.Models.Item(1);
SolidEdgeGeometry.Body b = (SolidEdgeGeometry.Body)m.Body;
SolidEdgeGeometry.Edges ees = (SolidEdgeGeometry.Edges)b.Edges[SolidEdgeGeometry.FeatureTopologyQueryTypeConstants.igQueryAll];
SolidEdgeGeometry.Edge ee = (SolidEdgeGeometry.Edge)ees.Item(1);
//ee.GetRange(ref MinRangePoint, ref MaxRangePoint);
b.GetRange(ref MinRangePoint, ref MaxRangePoint);
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
// Get the active document.
assemblyDocument = application.GetActiveDocument <SolidEdgeAssembly.AssemblyDocument>(false);
if (assemblyDocument != null)
{
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
foreach (var occurrence in occurrences.OfType <SolidEdgeAssembly.Occurrence>())
{
Array MinRangePoint = Array.CreateInstance(typeof(double), 0);
Array MaxRangePoint = Array.CreateInstance(typeof(double), 0);
occurrence.GetRangeBox(ref MinRangePoint, ref MaxRangePoint);
// Convert from System.Array to double[]. double[] is easier to work with.
double[] a1 = MinRangePoint.OfType <double>().ToArray();
double[] a2 = MaxRangePoint.OfType <double>().ToArray();
// Report the occurrence matrix.
Console.WriteLine("{0} range box:", occurrence.Name);
Console.WriteLine("|MinRangePoint: {0}, {1}, {2}|",
a1[0],
a1[1],
a1[2]);
Console.WriteLine("|MaxRangePoint: {0}, {1}, {2}|",
a2[0],
a2[1],
a2[2]);
}
}
else
{
throw new System.Exception("No active document.");
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void AddWithMatrix(SolidEdgeAssembly.Occurrences occurrences)
{
SolidEdgeAssembly.Occurrence occurrence = null;
// Get path to Solid Edge program directory. Typically, 'C:\Program Files\Solid Edge XXX\Program'.
DirectoryInfo programDirectory = new DirectoryInfo(GetSolidEdgeInstallPath());
// Get path to Solid Edge training directory. Typically, 'C:\Program Files\Solid Edge XXX\Training'.
DirectoryInfo trainingDirectory = new DirectoryInfo(Path.Combine(programDirectory.FullName, "Training"));
FileInfo fileInfo = new FileInfo(Path.Combine(trainingDirectory.FullName, "Strap Handle.par"));
// A single-dimension array that defines a valid transformation matrix.
double[] m =
{
1.0,
0.0,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0,
0.0,
0.07913,
1.0
};
// Convert from double[] to System.Array.
Array matrix = m;
if (fileInfo.Exists)
{
// Add the new occurrence using a matrix.
occurrence = occurrences.AddWithMatrix(
OccurrenceFileName: fileInfo.FullName,
Matrix: ref matrix);
Console.WriteLine("Added '{0}' using AddWithMatrix().", fileInfo.FullName);
}
else
{
throw new FileNotFoundException("File not found.", fileInfo.FullName);
}
}
static void AddWithTransform(SolidEdgeAssembly.Occurrences occurrences)
{
SolidEdgeAssembly.Occurrence occurrence = null;
// Get path to Solid Edge program directory. Typically, 'C:\Program Files\Solid Edge XXX\Program'.
DirectoryInfo programDirectory = new DirectoryInfo(GetSolidEdgeInstallPath());
// Get path to Solid Edge training directory. Typically, 'C:\Program Files\Solid Edge XXX\Training'.
DirectoryInfo trainingDirectory = new DirectoryInfo(Path.Combine(programDirectory.FullName, "Training"));
string[] filenames =
{
"strainer.asm",
"handle.par",
};
// {OriginX, OriginY, OriginZ, AngleX, AngleY, AngleZ}
// Origin in meters.
// Angle in radians.
double[,] transforms = new double[, ]
{
{ 0, 0, 0.02062, 0, 0, 0 }, // strainer.asm
{ -0.06943, -0.00996, 0.05697, 0, 0, 0 }, // handle.par
};
// Add each occurrence in array.
for (int i = 0; i <= transforms.GetUpperBound(0); i++)
{
FileInfo fileInfo = new FileInfo(Path.Combine(trainingDirectory.FullName, filenames[i]));
if (fileInfo.Exists)
{
// Add the new occurrence using a transform.
occurrence = occurrences.AddWithTransform(
OccurrenceFileName: fileInfo.FullName,
OriginX: transforms[i, 0],
OriginY: transforms[i, 1],
OriginZ: transforms[i, 2],
AngleX: transforms[i, 3],
AngleY: transforms[i, 4],
AngleZ: transforms[i, 5]);
Console.WriteLine("Added '{0}' using AddWithTransform().", fileInfo.FullName);
}
else
{
throw new FileNotFoundException("File not found.", fileInfo.FullName);
}
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeFramework.Documents documents = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
SolidEdgeAssembly.Occurrence occurrence = null;
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
// Get a reference to the documents collection.
documents = application.Documents;
// Create a new assembly document.
assemblyDocument = documents.AddAssemblyDocument();
// Always a good idea to give SE a chance to breathe.
application.DoIdle();
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
// Build path to file.
string filename = System.IO.Path.Combine(SolidEdgeCommunity.SolidEdgeUtils.GetTrainingFolderPath(), "Coffee Pot.par");
// Add the base feature at 0 (X), 0 (Y), 0 (Z).
occurrence = occurrences.AddByFilename(filename);
// Switch to ISO view.
application.StartCommand(SolidEdgeConstants.AssemblyCommandConstants.AssemblyViewISOView);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void PopulateDocumentItems(SolidEdgeAssembly.Occurrences occurrences, DocumentItem parentItem)
{
foreach (SolidEdgeAssembly.Occurrence occurrence in occurrences)
{
var occurrenceItem = new DocumentItem(occurrence);
// Make sure the DocumentItem hasn't already been added.
if (parentItem.DocumentItems.Contains(occurrenceItem) == false)
{
parentItem.DocumentItems.Add(occurrenceItem);
if (occurrence.SubOccurrences != null)
{
PopulateDocumentItems(occurrence.SubOccurrences, occurrenceItem);
}
}
}
}
static void AddOccurrenceByFilename(SolidEdgeAssembly.Occurrences occurrences)
{
SolidEdgeAssembly.Occurrence occurrence = null;
// Get path to Solid Edge program directory. Typically, 'C:\Program Files\Solid Edge XXX\Program'.
DirectoryInfo programDirectory = new DirectoryInfo(GetSolidEdgeInstallPath());
// Get path to Solid Edge training directory. Typically, 'C:\Program Files\Solid Edge XXX\Training'.
DirectoryInfo trainingDirectory = new DirectoryInfo(Path.Combine(programDirectory.FullName, "Training"));
FileInfo fileInfo = new FileInfo(Path.Combine(trainingDirectory.FullName, "Coffee Pot.par"));
if (fileInfo.Exists)
{
// Add the base feature at 0 (X), 0 (Y), 0 (Z).
occurrence = occurrences.AddByFilename(fileInfo.FullName);
Console.WriteLine("Added '{0}' using AddByFilename().", fileInfo.FullName);
}
else
{
throw new FileNotFoundException("File not found.", fileInfo.FullName);
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeFramework.Documents documents = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
SolidEdgeAssembly.Occurrence occurrence = null;
string[] filenames = { "strainer.asm", "handle.par" };
// Jagged array
// {OriginX, OriginY, OriginZ, AngleX, AngleY, AngleZ}
// Origin in meters.
// Angle in radians.
double[][] transforms = new double[][]
{
new double[] { 0, 0, 0.02062, 0, 0, 0 },
new double[] { -0.06943, -0.00996, 0.05697, 0, 0, 0 },
};
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
// Get a reference to the documents collection.
documents = application.Documents;
// Create a new assembly document.
assemblyDocument = documents.AddAssemblyDocument();
// Always a good idea to give SE a chance to breathe.
application.DoIdle();
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
// Get path to Solid Edge training directory. Typically, 'C:\Program Files\Solid Edge XXX\Training'.
DirectoryInfo trainingDirectory = new DirectoryInfo(SolidEdgeCommunity.SolidEdgeUtils.GetTrainingFolderPath());
// Add each occurrence in array.
for (int i = 0; i < transforms.Length; i++)
{
// Build path to file.
string filename = Path.Combine(trainingDirectory.FullName, filenames[i]);
// Add the new occurrence using a transform.
occurrence = occurrences.AddWithTransform(
OccurrenceFileName: filename,
OriginX: transforms[i][0],
OriginY: transforms[i][1],
OriginZ: transforms[i][2],
AngleX: transforms[i][3],
AngleY: transforms[i][4],
AngleZ: transforms[i][5]);
}
// Switch to ISO view.
application.StartCommand(SolidEdgeConstants.AssemblyCommandConstants.AssemblyViewISOView);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void ReportOccurrences(SolidEdgeAssembly.Occurrences occurrences)
{
SolidEdgeAssembly.Occurrence occurrence = null;
Console.WriteLine();
for (int i = 1; i <= occurrences.Count; i++)
{
occurrence = occurrences.Item(i);
// Allocate a new array to hold transform.
double[] transform = new double[6];
// Allocate a new array to hold matrix.
Array matrix = Array.CreateInstance(typeof(double), 16);
// Get the occurrence transform.
occurrence.GetTransform(
OriginX: out transform[0],
OriginY: out transform[1],
OriginZ: out transform[2],
AngleX: out transform[3],
AngleY: out transform[4],
AngleZ: out transform[5]);
// Get the occurrence matrix.
occurrence.GetMatrix(ref matrix);
// Convert from System.Array to double[]. double[] is easier to work with.
double[] m = matrix.OfType <double>().ToArray();
// Report the occurrence transform.
Console.WriteLine("{0} transform:", occurrence.Name);
Console.WriteLine("OriginX: {0} (meters)", transform[0]);
Console.WriteLine("OriginY: {0} (meters)", transform[1]);
Console.WriteLine("OriginZ: {0} (meters)", transform[2]);
Console.WriteLine("AngleX: {0} (radians)", transform[3]);
Console.WriteLine("AngleY: {0} (radians)", transform[4]);
Console.WriteLine("AngleZ: {0} (radians)", transform[5]);
Console.WriteLine();
// Report the occurrence matrix.
Console.WriteLine("{0} matrix:", occurrence.Name);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[0],
m[1],
m[2],
m[3]);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[4],
m[5],
m[6],
m[7]);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[8],
m[9],
m[10],
m[11]);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[12],
m[13],
m[14],
m[15]);
Console.WriteLine();
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeFramework.Documents documents = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
try
{
Console.WriteLine("Registering OleMessageFilter.");
// Register with OLE to handle concurrency issues on the current thread.
OleMessageFilter.Register();
Console.WriteLine("Connecting to Solid Edge.");
// Connect to or start Solid Edge.
application = SolidEdgeUtils.Connect(true);
// Make sure user can see the GUI.
application.Visible = true;
// Bring Solid Edge to the foreground.
application.Activate();
// Get a reference to the documents collection.
documents = application.Documents;
Console.WriteLine("Creating a new assembly document.");
// Create a new assembly document.
assemblyDocument = (SolidEdgeAssembly.AssemblyDocument)
documents.Add("SolidEdge.AssemblyDocument");
// Always a good idea to give SE a chance to breathe.
application.DoIdle();
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
AddOccurrenceByFilename(occurrences);
AddWithTransform(occurrences);
AddWithMatrix(occurrences);
Console.WriteLine("Switching to ISO view.");
ReportOccurrences(occurrences);
// Switch to ISO view.
application.StartCommand(
(SolidEdgeFramework.SolidEdgeCommandConstants)
SolidEdgeConstants.AssemblyCommandConstants.AssemblyViewISOView);
}
catch (System.Exception ex)
{
#if DEBUG
System.Diagnostics.Debugger.Break();
#endif
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeFramework.Documents documents = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
SolidEdgeAssembly.Occurrence occurrence = null;
// A single-dimension array that defines a valid transformation matrix.
double[] matrix =
{
1.0,
0.0,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0,
0.0,
0.07913,
1.0
};
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
// Get a reference to the documents collection.
documents = application.Documents;
// Create a new assembly document.
assemblyDocument = documents.AddAssemblyDocument();
// Always a good idea to give SE a chance to breathe.
application.DoIdle();
// Build path to part file.
string filename = System.IO.Path.Combine(SolidEdgeCommunity.SolidEdgeUtils.GetTrainingFolderPath(), "Strap Handle.par");
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
// Convert from double[] to System.Array.
Array matrixArray = matrix;
// Add the new occurrence using a matrix.
occurrence = occurrences.AddWithMatrix(
OccurrenceFileName: filename,
Matrix: ref matrixArray);
// Switch to ISO view.
application.StartCommand(SolidEdgeConstants.AssemblyCommandConstants.AssemblyViewISOView);
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
SolidEdgeAssembly.InterferenceStatusConstants interferenceStatus;
SolidEdgeConstants.InterferenceComparisonConstants compare = SolidEdgeConstants.InterferenceComparisonConstants.seInterferenceComparisonSet1vsAllOther;
SolidEdgeConstants.InterferenceReportConstants reportType = SolidEdgeConstants.InterferenceReportConstants.seInterferenceReportPartNames;
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
// Get a reference to the active assembly document.
assemblyDocument = application.GetActiveDocument <SolidEdgeAssembly.AssemblyDocument>(false);
if (assemblyDocument != null)
{
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
foreach (var occurrence in occurrences.OfType <SolidEdgeAssembly.Occurrence>())
{
Array set1 = Array.CreateInstance(occurrence.GetType(), 1);
object numInterferences = 0;
object retSet1 = Array.CreateInstance(typeof(SolidEdgeAssembly.Occurrence), 0);
object retSet2 = Array.CreateInstance(typeof(SolidEdgeAssembly.Occurrence), 0);
object confirmedInterference = null;
object interferenceOccurrence = null;
set1.SetValue(occurrence, 0);
// Check interference.
assemblyDocument.CheckInterference(
NumElementsSet1: set1.Length,
Set1: ref set1,
Status: out interferenceStatus,
ComparisonMethod: compare,
NumElementsSet2: 0,
Set2: Missing.Value,
AddInterferenceAsOccurrence: false,
ReportFilename: Missing.Value,
ReportType: reportType,
NumInterferences: out numInterferences,
InterferingPartsSet1: ref retSet1,
InterferingPartsOtherSet: ref retSet2,
ConfirmedInterference: ref confirmedInterference,
InterferenceOccurrence: out interferenceOccurrence,
IgnoreThreadInterferences: Missing.Value
);
// Process status.
switch (interferenceStatus)
{
case SolidEdgeAssembly.InterferenceStatusConstants.seInterferenceStatusNoInterference:
break;
case SolidEdgeAssembly.InterferenceStatusConstants.seInterferenceStatusConfirmedAndProbableInterference:
case SolidEdgeAssembly.InterferenceStatusConstants.seInterferenceStatusConfirmedInterference:
case SolidEdgeAssembly.InterferenceStatusConstants.seInterferenceStatusIncompleteAnalysis:
case SolidEdgeAssembly.InterferenceStatusConstants.seInterferenceStatusProbableInterference:
if (retSet2 != null)
{
for (int j = 0; j < (int)numInterferences; j++)
{
object obj1 = ((Array)retSet1).GetValue(j);
object obj2 = ((Array)retSet2).GetValue(j);
// Use helper class to get the object type.
var objectType1 = SolidEdgeCommunity.Runtime.InteropServices.ComObject.GetPropertyValue <SolidEdgeFramework.ObjectType>(obj1, "Type", (SolidEdgeFramework.ObjectType) 0);
var objectType2 = SolidEdgeCommunity.Runtime.InteropServices.ComObject.GetPropertyValue <SolidEdgeFramework.ObjectType>(obj2, "Type", (SolidEdgeFramework.ObjectType) 0);
SolidEdgeFramework.Reference reference1 = null;
SolidEdgeFramework.Reference reference2 = null;
SolidEdgeAssembly.Occurrence occurrence1 = null;
SolidEdgeAssembly.Occurrence occurrence2 = null;
switch (objectType1)
{
case SolidEdgeFramework.ObjectType.igReference:
reference1 = (SolidEdgeFramework.Reference)obj1;
break;
case SolidEdgeFramework.ObjectType.igPart:
case SolidEdgeFramework.ObjectType.igOccurrence:
occurrence1 = (SolidEdgeAssembly.Occurrence)obj1;
break;
}
switch (objectType2)
{
case SolidEdgeFramework.ObjectType.igReference:
reference2 = (SolidEdgeFramework.Reference)obj2;
break;
case SolidEdgeFramework.ObjectType.igPart:
case SolidEdgeFramework.ObjectType.igOccurrence:
occurrence2 = (SolidEdgeAssembly.Occurrence)obj2;
break;
}
}
}
break;
}
}
}
else
{
throw new System.Exception("No active document.");
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeFramework.Documents documents = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
SolidEdgeAssembly.Tube tube = null;
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
try
{
// Get the active document.
assemblyDocument = application.GetActiveDocument <SolidEdgeAssembly.AssemblyDocument>(false);
}
catch
{
}
// If there is not an active assembly, we can use an assembly from the training folder.
if (assemblyDocument == null)
{
documents = application.Documents;
// Build path to part file.
string filename = System.IO.Path.Combine(SolidEdgeCommunity.SolidEdgeUtils.GetTrainingFolderPath(), @"Try It\zone_try_it.asm");
assemblyDocument = (SolidEdgeAssembly.AssemblyDocument)documents.Open(filename);
}
if (assemblyDocument != null)
{
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
foreach (var occurrence in occurrences.OfType <SolidEdgeAssembly.Occurrence>())
{
if (occurrence.IsTube())
{
tube = occurrence.GetTube();
Console.WriteLine("Occurrences[{0}] is a tube.", occurrence.Index);
Console.WriteLine("PartFileName: {0}", tube.PartFileName);
object CutLength = 0.0;
object NumOfBends = 0;
object FeedLengthArray = new double[] { };
object RotationAngleArray = new double[] { };
object BendRadiusArray = new double[] { };
object ReverseBendOrder = 0;
object SaveToFileName = Missing.Value;
object BendAngleArray = new double[] { };
tube.BendTable(
CutLength: out CutLength,
NumOfBends: out NumOfBends,
FeedLength: out FeedLengthArray,
RotationAngle: out RotationAngleArray,
BendRadius: out BendRadiusArray,
ReverseBendOrder: ref ReverseBendOrder,
SaveToFileName: SaveToFileName,
BendAngle: out BendAngleArray);
StringBuilder FeedLength = new StringBuilder();
foreach (double d in (double[])FeedLengthArray)
{
FeedLength.AppendFormat("{0}, ", d);
}
StringBuilder RotationAngle = new StringBuilder();
foreach (double d in (double[])RotationAngleArray)
{
RotationAngle.AppendFormat("{0}, ", d);
}
StringBuilder BendRadius = new StringBuilder();
foreach (double d in (double[])BendRadiusArray)
{
BendRadius.AppendFormat("{0}, ", d);
}
StringBuilder BendAngle = new StringBuilder();
foreach (double d in (double[])BendAngleArray)
{
BendAngle.AppendFormat("{0}, ", d);
}
Console.WriteLine("BendTable information:");
Console.WriteLine("CutLength: {0}", CutLength);
Console.WriteLine("NumOfBends: {0}", NumOfBends);
Console.WriteLine("FeedLength: {0}", FeedLength.ToString().Trim().TrimEnd(','));
Console.WriteLine("RotationAngle: {0}", RotationAngle.ToString().Trim().TrimEnd(','));
Console.WriteLine("BendRadius: {0}", BendRadius.ToString().Trim().TrimEnd(','));
Console.WriteLine("BendAngle: {0}", BendAngle.ToString().Trim().TrimEnd(','));
Console.WriteLine();
}
}
}
else
{
throw new System.Exception("No active document.");
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect(true, true);
// Get the active document.
assemblyDocument = application.GetActiveDocument <SolidEdgeAssembly.AssemblyDocument>(false);
if (assemblyDocument != null)
{
// Get a reference to the Occurrences collection.
occurrences = assemblyDocument.Occurrences;
foreach (var occurrence in occurrences.OfType <SolidEdgeAssembly.Occurrence>())
{
// Allocate a new array to hold transform.
double[] transform = new double[6];
// Get the occurrence transform.
occurrence.GetTransform(
OriginX: out transform[0],
OriginY: out transform[1],
OriginZ: out transform[2],
AngleX: out transform[3],
AngleY: out transform[4],
AngleZ: out transform[5]);
// Report the occurrence transform.
Console.WriteLine("{0} transform:", occurrence.Name);
Console.WriteLine("OriginX: {0} (meters)", transform[0]);
Console.WriteLine("OriginY: {0} (meters)", transform[1]);
Console.WriteLine("OriginZ: {0} (meters)", transform[2]);
Console.WriteLine("AngleX: {0} (radians)", transform[3]);
Console.WriteLine("AngleY: {0} (radians)", transform[4]);
Console.WriteLine("AngleZ: {0} (radians)", transform[5]);
Console.WriteLine();
// Allocate a new array to hold matrix.
Array matrix = Array.CreateInstance(typeof(double), 16);
// Get the occurrence matrix.
occurrence.GetMatrix(ref matrix);
// Convert from System.Array to double[]. double[] is easier to work with.
double[] m = matrix.OfType <double>().ToArray();
// Report the occurrence matrix.
Console.WriteLine("{0} matrix:", occurrence.Name);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[0],
m[1],
m[2],
m[3]);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[4],
m[5],
m[6],
m[7]);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[8],
m[9],
m[10],
m[11]);
Console.WriteLine("|{0}, {1}, {2}, {3}|",
m[12],
m[13],
m[14],
m[15]);
Console.WriteLine();
}
}
else
{
throw new System.Exception("No active document.");
}
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
static void Main(string[] args)
{
SolidEdgeFramework.Application application = null;
SolidEdgeFramework.SelectSet selectSet = null;
SolidEdgeAssembly.AssemblyDocument assemblyDocument = null;
SolidEdgeAssembly.Occurrences occurrences = null;
try
{
// Register with OLE to handle concurrency issues on the current thread.
SolidEdgeCommunity.OleMessageFilter.Register();
// Connect to or start Solid Edge.
application = SolidEdgeCommunity.SolidEdgeUtils.Connect();
// Get a reference to the active selectset.
selectSet = application.ActiveSelectSet;
// Temporarily suspend selectset UI updates.
selectSet.SuspendDisplay();
// Clear the selectset.
selectSet.RemoveAll();
// Get a reference to the active document.
assemblyDocument = application.GetActiveDocument <SolidEdgeAssembly.AssemblyDocument>(false);
if (assemblyDocument != null)
{
// Get a reference to the occurrences collection.
occurrences = assemblyDocument.Occurrences;
// Loop through the occurrences.
foreach (var occurrence in occurrences.OfType <SolidEdgeAssembly.Occurrence>())
{
// If status equals seOccurrenceStatusUnderDefined, add to selectset.
if (occurrence.Status == SolidEdgeAssembly.OccurrenceStatusConstants.seOccurrenceStatusUnderDefined)
{
selectSet.Add(occurrence);
}
}
}
else
{
throw new System.Exception("No active document");
}
// Re-enable selectset UI display.
selectSet.ResumeDisplay();
// Manually refresh the selectset UI display.
selectSet.RefreshDisplay();
}
catch (System.Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
SolidEdgeCommunity.OleMessageFilter.Unregister();
}
}
