Hello there!
It’s time for the last part of our small tutorial on writing Inventor add-ins. Today we’ll write the actual implementation of the functionality described in previous post and explain some other small details. So, let’s get to work!
INVENTOR HANDLER
Our main functionality will be performed by a single class – InventorHandler (which will also be abstracted by IInventorHandler interface). It’s going to have only one public method AutoBreak() which will be responsible for applying the break to correct view. Let’s start with constructing it.
Private fields
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
private Inventor.Application invInstance; private ISettingsModel settings; private IComparer<DrawingView> comparer; /// <summary> /// Contains allowed types of view orientaton /// </summary> private static List<ViewOrientationTypeEnum> cams = new List<ViewOrientationTypeEnum>( new ViewOrientationTypeEnum[] { ViewOrientationTypeEnum.kBackViewOrientation, ViewOrientationTypeEnum.kBottomViewOrientation, ViewOrientationTypeEnum.kFrontViewOrientation, ViewOrientationTypeEnum.kLeftViewOrientation, ViewOrientationTypeEnum.kRightViewOrientation, ViewOrientationTypeEnum.kTopViewOrientation, ViewOrientationTypeEnum.kArbitraryViewOrientation }); /// <summary> /// Provides condition to remove all views which are in not correct model orientation /// </summary> private Predicate<DrawingView> removePredicate = (DrawingView view) => (!cams.Contains(view.Camera.ViewOrientationType)); |
It consist of three private fields: invInstance which stores reference to current instance of Inventor apllication, settings which stores reference to settings model and comparer which stores reference to IComparer implementation for sorting drawing views descending, area-wise.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
/// <summary> /// Provides IComparer implementation for descending area-wise sorting of views /// </summary> internal class DrawingViewSizeComparerHelper : IComparer<DrawingView> { /// <summary> /// provides IComparer implementation for area-wise sorting of views /// </summary> /// <param name="x">view no. one</param> /// <param name="y">view no. two</param> /// <returns>-1 - view one is bigger; 0 - views are equal size; 1 - view one is smaller</returns> public int Compare(DrawingView x, DrawingView y) { double xArea = x.Height * x.Width; double yArea = y.Height * y.Width; if (xArea > yArea) { return -1; } if (xArea < yArea) { return 1; } return 0; } } |
This implementation is actually an internal class within our InventorHandler class. We won’t need that anywhere else.
Next, we have static list which contains orientation types which can work with our auto-break. This means that all views which are different orientation will not be take into consideration when executing auto break.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/// <summary> /// Contains allowed types of view orientaton /// </summary> private static List<ViewOrientationTypeEnum> cams = new List<ViewOrientationTypeEnum>( new ViewOrientationTypeEnum[] { ViewOrientationTypeEnum.kBackViewOrientation, ViewOrientationTypeEnum.kBottomViewOrientation, ViewOrientationTypeEnum.kFrontViewOrientation, ViewOrientationTypeEnum.kLeftViewOrientation, ViewOrientationTypeEnum.kRightViewOrientation, ViewOrientationTypeEnum.kTopViewOrientation, ViewOrientationTypeEnum.kArbitraryViewOrientation }); |
That list contain only perpendicular projections (back, left, right etc.) and the one called kArbitraryViewOrientation. This is the type of all views generated from a base view. This mean that although isometric views are not present this our collection the add-in will break that kind of view if it is created from an existing view.
The last thing is a predicate that is used for removing all views which are orientated differently than types allowed in the collection that we have just explained.
Constructor
|
1 2 3 4 5 6 7 8 9 10 11 |
/// <summary> /// Default constructor /// </summary> /// <param name="_instance">Current instance of Inventor application</param> /// <param name="_settings">Settings model</param> public InventorHandler(Inventor.Application _instance, ISettingsModel _settings) { invInstance = _instance; settings = _settings; comparer = new DrawingViewSizeComparerHelper(); } |
The constructor for our InventorHandler class is very simple. It sets invInstance and settings to those given as arguments and instantiates new DrawingViewSizeComparerHelper class.
AutoBreak();
Now, let’s go through our only public method in the class:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
/// <summary> /// Performs the auto-breaking /// </summary> public void AutoBreak() { DrawingDocument drawing = invInstance.ActiveDocument as DrawingDocument; DrawingView biggest = getBiggest(drawing.ActiveSheet); //if no usable view or view is too small to be broken if ((biggest == null) || (!canBeBroken(biggest, isHorizontal(biggest)))) { MessageBox.Show("There are no usable views!", "Cannot apply auto-break"); return; } if (biggest.BreakOperations.Count > 0) { MessageBox.Show("There already is a break operation applied!", "Cannot apply auto-break"); return; } Point2d start; Point2d end; if (isHorizontal(biggest)) { horizontalPoints(biggest, (int)settings.Range, out start, out end); } else { verticalPoints(biggest, (int)settings.Range, out start, out end); } biggest.BreakOperations.Add(boolBreakOrientationConvert(isHorizontal(biggest)), start, end, intToBreakStyleConverter(settings.Style), 5, settings.Gap, settings.Symbols, true); } |
It takes current active document in running Inventor application and sets a reference to in in a local variable drawing as a type DrawingDocument. Although property ActiveDocument of invInstance is of Document type (which is more general than DrawingDocument) it is safe to set is as DrawingDocument as our button to execute will be visible only in Drawing ribbon, therefore we’re sure that the active document IS DrawingDocument.
Next, we set another local variable which is of type DrawingView and assign result of getBiggest method executed with argument of drawing.ActiveSheet. This gets currently activated sheet in active document. If it’s null (meaning no drawing views are in the sheet) or it is too small to be broken the add-in will display a message and terminate execution of AutoBreak method. Otherwise, it continues.
Now, it checks if there already is a break applied to the view. If it is, again, it displays appropriate message and terminates.
Next step is to determine start and end points for the break. They are of type Point2d and they are set as local variables inside the method’s body. To give them appropriate values one of two methods is invoked: horizontalPoints or verticalPoints. These methods return boolean whether it is possible to break, and outs break points.
The last step is to apply the break:
|
1 |
biggest.BreakOperations.Add(boolBreakOrientationConvert(isHorizontal(biggest)), start, end, intToBreakStyleConverter(settings.Style), 5, settings.Gap, settings.Symbols, true); |
It is done by executing Add method of BreakOperations collection in a view. It takes several arguments, as follows:
- BreakOrientationTypeEnum – break orientation;
- Point2D – start point;
- Point2D – end point;
- BreakStyleEnum – style of break, rectangular or structural;
- integer – display level, in our case we pass default value of 5;
- double – gap between left and right part of the view;
- int – number of symbols, works only for rectangular view;
- bool – propagate to parent view, defines if the break will be visible in parent view, in our case we pass default value true.
And that’s it. That’s the workflow. Now, as you probably noticed the method described above uses few private methods. To fully comprehend how the add-in works it is necessary to describe them as well.
DrawingView getBiggest(Sheet _sheet)
This method finds the biggest view in the given sheet. All views which are not orientated correctly (remember the list of ViewOrientationTypeEnum?) will be excluded from the selection.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
/// <summary> /// Gets biggest view from given drawing sheet /// </summary> /// <param name="_sheet">Drawing sheet</param> /// <returns>Drawing view</returns> private DrawingView getBiggest(Sheet _sheet) { List<DrawingView> views = new List<DrawingView>(); foreach (DrawingView _view in _sheet.DrawingViews) { views.Add(_view); } views.RemoveAll(removePredicate); if (views.Count > 0) { views.Sort(comparer); return views[0]; } else return null; } |
bool isHorizontal(DrawingView _view)
Simply checks if a view is wider than higher and returns true if does.
|
1 2 3 4 5 6 7 8 9 10 |
/// <summary> /// Determines whether a view is orientated vertically or horizontally /// </summary> /// <param name="_view">Drawing view</param> /// <returns>Return ture if vertical, false if horizontal</returns> private bool isHorizontal(DrawingView _view) { if (_view.Width >= _view.Height) { return true; } return false; } |
bool canBeBroken(DrawingView _view, bool _isHorizontal)
This one checks if a view is sufficiently wide for horizontal break, or sufficiently high for vertical break. Minimum height/width is 5 cm plus gap. Remember that the API operates on centimetres expresses in variables of type double.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
/// <summary> /// Checks if a view can be brokens /// </summary> /// <param name="_view">Drawing view</param> /// <param name="_isHorizontal"></param> /// <returns>True if the view is big enough to be broken, otherwise false</returns> private bool canBeBroken(DrawingView _view, bool _isHorizontal) { //MessageBox.Show("can be broken?"); if (_isHorizontal) { if (_view.Width - settings.Gap >= 5) { return true; } } else { if (_view.Height - settings.Gap >= 5) { return true; } } return false; } |
bool horizontalPoints/verticalPoints(DrawingView _view, int _percentage, out Point2d _start, out Point2d _end)
These two counterparting methods calculate start and end points based on given view and percentage of the view that needs to be removed. Methods return boolean whether a break can be applied and outs the points.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
/// <summary> /// Helper method that outs starting and ending points for horizontal break /// </summary> /// <param name="_view">View to break</param> /// <param name="_percentage">Percentage of view that needs to be removed</param> /// <param name="_start">Out starting point</param> /// <param name="_end">Out ending point</param> /// <returns>True if break points can be used for breaking, ie. break ration is between 0.1 and 0.9</returns> private bool horizontalPoints(DrawingView _view, int _percentage, out Point2d _start, out Point2d _end) { //determine break points //MessageBox.Show("determining break points..."); //MessageBox.Show("percentage: "+_percentage); double breakRatio = (double)_percentage / 100; //MessageBox.Show("ratio: " + breakRatio); if (_view.Width * breakRatio < 5) { breakRatio = 5 / _view.Width; } //MessageBox.Show("ratio: " + breakRatio); double breakWidth = _view.Width * breakRatio; double breakStart = _view.Position.X - breakWidth / 2; double breakEnd = _view.Position.X + breakWidth / 2; _start = invInstance.TransientGeometry.CreatePoint2d(breakStart); _end = invInstance.TransientGeometry.CreatePoint2d(breakEnd); //MessageBox.Show("Width: " + _view.Width); //MessageBox.Show("X centre: " + _view.Position.X); //MessageBox.Show("start: " + _start.X); //MessageBox.Show("end: " + _end.X); if ((breakRatio >= 0.1) && (breakRatio <= 0.9)) { return true; } return false; } /// <summary> /// Helper method that outs starting and ending points for vertical break /// </summary> /// <param name="_view">Wiew to break</param> /// <param name="_percentage">Percentage of view that needs to be removed</param> /// <param name="_start">Out starting point</param> /// <param name="_end">Out ending point</param> /// <returns>True if break points can be used for breaking, ie. break ration is between 0.1 and 0.9</returns> private bool verticalPoints(DrawingView _view, int _percentage, out Point2d _start, out Point2d _end) { //determine break points //MessageBox.Show("determining break points..."); //MessageBox.Show("percentage: "+_percentage); double breakRatio = (double)_percentage / 100; if (_view.Height * breakRatio < 5) { breakRatio = 5 / _view.Height; } //MessageBox.Show("ratio: " + breakRatio); double breakHeight = _view.Height * breakRatio; double breakStart = _view.Position.Y - breakHeight / 2; double breakEnd = _view.Position.Y + breakHeight / 2; _start = invInstance.TransientGeometry.CreatePoint2d(0, breakStart); _end = invInstance.TransientGeometry.CreatePoint2d(0, breakEnd); //MessageBox.Show("Width: " + views[current].Width); //MessageBox.Show("X centre: " + views[current].Position.X); //MessageBox.Show("start: " + startPoint.X); //MessageBox.Show("end: " + endPoint.X); if ((breakRatio >= 0.1) && (breakRatio <= 0.9)) { return true; } return false; } |
Converters
As some values from settings model are of simple types while methods exposed by the API require some arguments of different enum types there are two converters in the InventorHandler class: one is to convert boolean to BreakOrientationEnum
|
1 2 3 4 5 6 7 8 9 10 11 |
/// <summary> /// Converts boolean value to BreakOrientationEnum /// </summary> /// <param name="_isHorizontal">Boolean orientation equivalent</param> /// <returns>BreakOrientationEnum.kHorizontal if argument is true</returns> private BreakOrientationEnum boolBreakOrientationConvert(bool _isHorizontal) { if (!_isHorizontal) { return BreakOrientationEnum.kVerticalBreakOrientation; } return BreakOrientationEnum.kHorizontalBreakOrientation; } |
and the second one is to convert integer to BreakStyleEnum:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/// <summary> /// Converts integer value to BreakStyleEnum /// </summary> /// <param name="_input"></param> /// <returns></returns> private BreakStyleEnum intToBreakStyleConverter(int _input) { switch (_input) { case 0: return BreakStyleEnum.kRectangularBreakStyle; case 1: return BreakStyleEnum.kStructuralBreakStyle; default: return BreakStyleEnum.kRectangularBreakStyle; } } |
And that’s it if it comes to our InventorHandler class. However, to make the add-in actually work there are some changes needed in StandardAddInServer class.
CHANGES IN MAIN ADD-IN CLASS
First of all, we need an instance of InventorHandler. We’ll create a private field for that and initialise it in the constructor:
|
1 2 3 |
//add-in model ISettingsModel model; IInventorHandler handler; |
|
1 2 3 |
// Initialize add-in model model = new SettingsModel(); handler = new InventorHandler(m_inventorApplication, model); |
The last step is to modify action that is fired when the ‘Apply’ button is clicked:
|
1 2 3 4 |
private void customAction(NameValueMap options) { handler.AutoBreak(); } |
And that’s it. The add-in is now functional. See the demo below:
FINAL REMARKS
There are two things I want to mention at this point. First, is about embedding the stdole assembly. When it’s added to the project and the project is built you will get a warning message:
|
1 |
CSC : warning CS1762: A reference was created to embedded interop assembly 'stdole, Version=7.0.3300.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' because of an indirect reference to that assembly created by assembly 'Autodesk.Inventor.Interop, Version=22.0.0.0, Culture=neutral, PublicKeyToken=d84147f8b4276564'. Consider changing the 'Embed Interop Types' property on either assembly. |
Although, it does not affect the build you can get rid of these messages by setting Embed Interop Types property of stdole reference to false:
The other things is a word of explanation about NameValueMap interface. It used (amongst other uses) in the API to pass parameters in the events (as in our case events fired by clicking buttons). It works similarly to dictionaries, it stores pairs of name (which are strings) and values (which are of type object). I will not describe it in details (if you need that, simply go to its metadata in Visual Studio), but now you know the main thing – it is name/value pair to pass event parameters.
CONCLUSION
A vast portion of things can be manually done in Inventor can be automatised. However, the freedom in modelling that software gives you makes it really difficult to develop universal add-ins that will work always, no matter what you’re modelling. But all of translation, conversion, export things can be easily worked with. I know that there are some add-in that allow to generate models of sprockets, pulleys etc. and that works perfectly.
The hard thing when developing add-in is debugging. Possibilities here are limited because every time you want to debug you need to build your project and run the application, and you won’t get any error messages – either the application will crash, the add-in will be disabled or it won’t be executed.
To make things clear – I have worked with that software as a professional for more that 5 years and I am a big, big fan. I have experience with others systems, but this one seems to be most user-friendly, most of the features works as you would expect and has that professional-feel. But, it’s not a review, so I’ll stop here.
Thanks for your time, I hope that it is in any way useful for you. Good luck!
Michal
GitHub repo: https://github.com/mickaj/AutoBreaker-Inventor
Inventor API – Custom add-in Part #1
Inventor API – Custom add-in Part #2
