3D Application Development

NaroCAD porting to OpenCascade 6.5.2

2012-01-11T11:12:00.000-08:00

My colleague generated an OCC 6.5.2 wrapper version and also ported the projects on Visual Studio 2010. Everything compiles smoothly and Naro runs. Together had a debugging sessions to see what problems appeared with this porting.
There are some memory leaks that need to be solved, the selection seems to be broken, also the Naro tools need some fixing. Not all fixing is related to 6.5.2 wrappers, some of the fixing is caused by some OCC 652 changes in API functionality.

Next step is to fix the selection, point and line tools to see if with these tools everything goes ok. In parallel also the memory leaking on wrappers will be fixed.

Going Native

2011-12-18T12:12:00.000-08:00

... or not so much.

What's about Microsoft initiative named: Going Native? This is Microsoft's attempt to promote C++ 11 standard and future Visual Studio version that will improve the broken C++/.Net bridges.
Which are the reasons? Basically: using VNext (the "codename" for the next version), you will have outline of your code like you were able to do for some time in Eclipse CDT plugin.
The problem is in my understanding not the marketing part, which is cool (as is presented in the first part), like you can get the ultimate performance as you can get the ultimate control, you can map in shared memory, so another process can reuse your data and other "cool stuff like that". In fact I've got it, you can get huge performance using those constructs, yet the problem is after how many years, after how much testing. The reason that I was sold out for .Net languages is the service part: language have rich support for type information (named reflection or RTTI), which makes that the compiler to rarely fail on code completion, have saner defaults for memory management and decent performance. Where in NaroCAD performance was the issue, was because of the wrong algorithms, or not profiling the code.
The last days I was working with wrappers for OpenCascade 6.5.x. I was fairly surprised of how fast the compilation of C++ code works (as machines are much powerful as they were some years ago) and even I did not finish to port them, I've noticed some parts that were overall slow: disk access, the number of frameworks that NaroCAD use (by default NaroCAD uses WPF which is DirectX wrapped by a framework CodeCLR, .Net, OpenGL and OpenCascade, GDI+ (to host OpenGL/Occ window)). If it would be no framework, or Windows would have a way that frameworks will be always up-and-running, I think that NaroCAD would start (close-to) instantly.
So at the end I felt that this is why people do not tend to go native: is all about how many things you get for granted with high level languages/platforms: tools to make fast an UI, a great debugger, no chance (excluding a VM bug) to get "Invalid address" errors or like. And at the end a person that would want to extend NaroCAD, would not care at the ultimate performance you may get using a compiler as GCC that would inline differently some parts of the code based on your constants flow, but it would want to have a way to inspect the API, a way to script it (maybe using Boo), a way to import Step files and to export them back.
If and when NaroCAD will be performance bound, I do think that the way to improve it is: be multi-threaded (to be able to use the AMD's 8 cores, by using parallel extensions), be multi-process and distribute over the network (as WCF permit that much easily than any C++ framework I know it would be able to).
At the end the trend of using native is true for phones, and I agree that there are "native" ways to improve your performance for limited hardware, but NaroCAD as it stands, I don't see it that to happen any time soon. And if (ever) NaroCAD would work on an Android or IPad class hardware, it would take at least 1-2 years to complete it, so maybe it would address the hardware that would exist at that time, and it would be likely at least an ARM dual core (as is iPad 2) or ARM quad core (as is NVidia Tegra 3), where the stated arguments (multi-core and maybe multi-process) remain the way to improve. And the framework to use? Maybe Mono Touch and Mono for Android.

Up and running

2011-12-14T21:45:00.000-08:00

This week NaroCAD development restarted. We had a meeting and established a roadmap.

Among the features we planned are:
- Enhance the solver: make it faster and more reliable,
- Update to OpenCascade 6.5.X and enhance wrappers,
- Fix the 2D tools and make a more stable release,
- Improve docs and strengthen the unit tests.

After the Sketching part will be ok we'll start fixing the 3D features.

At the beginning the development progress will be slower, in a month planning to contribute at full speed.

Naro 1.6.3 version development started

2011-09-19T02:20:00.000-07:00

After a short development break, we'll restart working at NaroCAD.
First step would be stabilizing the 2D tools and enhance solver to be faster and restrict it to find solutions that affect only the current shape, not the entire scene.

Same coordinate hints

2011-06-29T09:00:00.001-07:00

Added an important hint at NaroCAD: on a Sketch when the current drawing point is on the same X or Y coordinate with an existing shape some hint is displayed to help user "catch" that coordinate:

It also catches line mid points and axis origin.

Unit tests enhancements

2011-06-25T09:58:00.000-07:00

In order to make a new release version started bug fixing the Sketch related issues. The first step was to fix the project building paths for all modules, then fix some unit tests. Added tests for SketchCreator, a class that manages sketches and calculates projections on them.
Will try to isolate bugs in unit tests before fixing them.

Hinter bug fixing

2011-06-24T08:40:00.000-07:00

Fixed the parallel to axis hint display. Added support for coloured hints display so that parallels with OX are shown with red, parallels to OY with green and to OZ with blue.

Feature development started

2011-06-23T09:09:00.001-07:00

After a couple days of wrapper enhancements and fixes for trying to port Naro on OCC 6.5.0 and 6.5.1 ported the enhancements on the 6.3.0 and built a working Naro on 6.3.0.

In order to show some progress on the Naro feature side will start bug fixing and enhancing it leaving the 6.5.X porting as a secondary task. The problem doesn't seem to be be on the wrapper side but seems to be caused by different usage on the OpenCascade side. Tried also playing with the OCC environment settings (like changing the memory allocator and multithreading), the problem doesn't seem to be on that side.

OpenCascade 650 wrappers

2011-06-15T06:58:00.000-07:00

Ported the new wrappers to OpenCascade 6.5.0. Fixed Naro to work with these wrappers.
Started investigating on crashes that appear on 6.5.0.
Not committed yet on Sourceforge until some stable version of wrappers is made.

Wrappers review and bug fixing

2011-06-10T08:59:00.000-07:00

Together with my colleague reviewed and fixed the new wrappers.
One big fix was made: the IsSameTransient method was fixed. Now selections work properly on Naro.

Also investigated why Naro's memory increases with usage. With some memory mapper that was tracking allocations and deallocations it seems that all objects are properly deallocated. Added also a CppDisplayLeaks() method that dumps memory leaks in the Output window, nothing dumped as leak.
It seems that at the wrapper level no leaking is made but still the memory increasing while using Naro is suspect, leaking is not completely excluded.

Started researching on crashes when running Naro with OpenCascade 6.5.0, this is the next fix we need to make.

Fixes on splash screen

2011-06-06T01:07:00.000-07:00

The splash screen was changed so that it doesn't stay on top of other windows.
Making the splash screen stay on top on all other application can be very annoying when working with other applications, because it cannot be moved out of the way.
We made this fix after reading the error reports. Thank you for reporting, and don't hesitate to tell us about other problems as well. Other issues might take more time time to fix, but we always keep track of them. You can also discuss on the forum about such problems.
This fix is will be available from the next release and in all nighty builds. Thank you for the cooperation and enjoy NaroCAD.

NaroCAD wrapper memory leaks fixed

2011-06-04T08:59:00.000-07:00

NaroCAD leaks in the new wrapper were fixed. Also, as the project does not depend to have the same wrapped Visual Studio version worked with just a project migration to run in VS 2010 (this is a topic for future discussion, but the idea remains: is just a project migration away, the C++ code will be generated with VS 2010 compiler, yet the target runtime for upgraded project is still .Net 3.5 SP1, to not ask an extra big download dependency for running NaroCAD).
The single remaining bug is IsSameTransient equality test and all tooling is ready for OpenCascade 6.5 usage crashes (that will be likely be ported very very soon, before the next release).

Folder Paths Updated

2011-05-31T13:23:00.000-07:00

NaroCAD installer paths are possible to be set in Program Files/User directory setup like for Windows XP/Vista/Windows 7 machines.
So you may expect that your NaroCAD on Windows experience to be smoother.

OCWrapper Replacement With PInvoke Version

2011-05-31T12:46:00.000-07:00

NaroCAD had a surgical change based on the prototype was presented earlier. How will affect NaroCAD?
From user standpoint, will unlikely change it. The wrapper will be a bit smaller, but will make no change in rest.
From developper standpoint, will make possible to build the wrapper and to DEBUG it. The new wrapper also is using open (read: not WOK) build systems, based on XML to declare/expose the APIs, QMake as C++ project generator (even is not a Qt project). The XML parsing to read and expose APIs will make easier to work on long run.
Also, the imported parts are minimal parts we really use in NaroCAD. At the end there are two underlying final migration advantages: we can migrate right now from Visual Studio 2008 to 2010 with a recompilation of NaroCAD (without rebuilding C++ wrappers) and if all work, will be no extra issue. And we can go to 6.5 wrapper stubs in minutes by simply relinking and making easier to debug them, simplifying all runtime based problems we had previously with Visual C++.Net runtime.

NaroCAD New Wrapper Prototype Finished

2011-05-20T01:14:00.000-07:00

As said in previous post, I worked to a replacement of OCWrappers and it is made.
How it works: there are three steps build:
- generate a XML API file, this is equivalent of CDL files but is easier to parse and populate. There is a visual tool that will scan from old OCWrappers with reflection and you will pick which methods are used. This API file make distinction between methods and properties.
- from this XML file are generated and updated C# and C++ projects with code. This is the most boring side, but also is where the power stands. The code generator makes patterns of code that are friendlier to debug. Also this part will make sure that the compiled code (mostly C++ side) will not include more than is needed.
- you have to rebuild the updated projects. In a typical workflow you will want to link to the C# project to see if all dependent classes. For now just the string type have to be fixed manually (because strings can be both wide strings and char* strings, two ways or repreenting Unicode and ANSI string encodings). Also, the C++ build is based on QMake (part of Qt SDK) for simplicity.
This design permit to improve all wrapping stack, is also a C# codebase and at the end makes a easier to work with both resulting code and with wrappers in themselves. As when the 6.5 OpenCascade issues will be found, the migration to new wrappers is possible as classes were written in a separate namespace and uses a different naming convention, so from gp_Pnt will get to gpPnt, and functions that return one number, will be likely automatically become properties which make easier for C# used eye.
The C++/C# projects permit to use different compilers (mostly different Visual Studio versions) for C++ side of wrapper/C# side, so makes sense in future to migrate to Visual Studio 2010 (when the C++ wrapper is still using VS 2008) so no binary compatibility issues will be involved.

NaroCAD Wrappers Review. Work on Previewing Sketch Constraints to Remain Persistent

2011-05-17T17:53:00.000-07:00

Probably you heard about Xamarin, if not, is not an issue. The opensource .Net implementation (Mono) was forked as the main company did not support it that. I don't want to discuss politics, but I just wish to this new company to succeed and to promote Free/OpenSource as Miguel de Icaza (the creator of Gnome and Mono project) is its owner.
Right now I want to discuss on development on wrappers. In fact, why if things work right, most likely I will try to remove the the original CLI wrappers and to import just the necessary methods/clasess. The design will be a bit different from the actual wrappers and we will try to work using .Net technologies and will extract the information from the existing wrappers.
This approach have many advantages, one of them is the possibility to debug using those wrappers and to make some changes that are at least nice to have for a C#/.Net programmer: automatically using of properties (like gpPnt.X() is better to be used in its property form gpPnt.X and so on), P/Invoke which will make easier to migrate to Visual Studio 2010 (C++ side of wrappers do not need to be recompiled for migrating to VS 2010 for example). This prototype is advanced yet not complete.
This will mean a thing for contributors that were interested in wrappers: is hard for our team to support them and is even harder for every new package to us to investigate why things crash and so on. Also, it make little sense (excluding for making a package) to give wrappers that later will make others' product to crash cause of our fault.
At the end, is just about to separate the codebase and to let as most as possible of C++ behind. If the prototype will not work, we will still use the old wrappers, but if will work (with minimal flaws), we have likely no reason to still use the C++/CLI (aka C++.Net) wrappers. You are still welcome to take Svn snapshot and provide patches and we will include in our Svn tree if you need them and you will want to contribute.
In between I did prepare the code to make previews of constraints persistent (they were shown just in previewing of lines) and if possible to make possible to delete them by selecting and pressing delete. It would be nice if clicking on a constraint to switch automatically to constraint action but this is not also certain.

NaroCAD 1.6.2 (Alpha) Released

2011-05-11T04:56:00.000-07:00

NaroCAD gets new capabilities and big changes happen from inside.

This new version focuses on:
- Constraint automatic detection: so drawing perpendicular, parallel, middle of points will create automatically constraints with the SketchSolve based component. Circle/arc based were also added in default setup (yet are not detected automatically) so you can work with more constraint combinations
- a Fixed-Point constraint was done: this will fix the annoyances that a SketchSolve solution will mess your entire sketch.
- Sketch constraints are previewed (now only with line action) and shows texturing capabilities that will likely permit that more components will use in future this capability
- more sketch related unit tests/Boo scripts will work (fixes are still needed but as they are fixed, easier will be to test crashes and inconsistencies)
-it was investigated and a working OpenCascade 6.5 (ultimate upstream version) wrapper was done. Seems that behavior was changed to work with Opencascade so crashes are not from wrapping side (or should be minimalist) but from usage side. We don't support those wrappers but if someone wants a starting C#/.Net way to work with wrappers you're welcome to use them taking the source or the binaries from SVN repository

Download it from here.

Constraints are Fixed, In Two Ways

2011-05-09T14:30:00.001-07:00

So constraint preview had a random crash because NaroCAD uses wrappers that obey to .Net virtual machine and this can break references in previews of textures, a functionality offered by OpenCascade using an indirect reference that .Net liked to destroy it. The solution was to stick references to used objects so .Net memory manager (garbage collector) to not delete it. The solution will create a transparent way to store this reference and a good part to it is that can be used in future to all other cases that may have similar crashes (yet this is the first case that was really necessary to not make a really custom development to make it work).

Another development based on work of Sami and bxtrx initially, enhanced, mapped and completed by myself is that points can be constrained. A full action will preview all points initially with blue, and you can constraint them by clicking them and they will transform with red color to know that they are constrained. After that the constraining will not be jumping.
See video here: (made with a virtual machine setup, so sadly it skip frames)

SortedDictionary ...

2011-05-06T10:38:00.000-07:00

NaroCAD uses in a lot of instances SortedDictionary and of course this is rarely needed. The reason using it for that many times, is to have good performance profile. For who knows O(log n) search time, knows that performance of lookups is scalable in time with number of digits of the search entries.
But in a lot of cases this is not needed (to have items sorted by key) and as someone informed me, I will use Dictionary generic class instead in future.
Relevant quote:

"Retrieving a value by using its key is very fast, close to O(1), because the Dictionary class is implemented as a hash table." Looks like the query time for Dictionary is O(1), but the query time for SortedDictionary is O(logn) -- "The SortedDictionary generic class is a binary search tree with O(log n) retrieval, where n is the number of elements in the dictionary. In this respect, it is similar to the SortedList generic class. The two classes have similar object models, and both have O(log n) retrieval. Where the two classes differ is in memory use and speed of insertion and removal."

So, for your better writing code, use Dictioary always.
Fixes are made lately so most of your Boo scripts will work as sketch code is automatically handled, more shapes will also work. Dangling texture rectangles shown in preview of automatic constraints were fixed and are display and will disappear at the end of your design. There is a crash of .Net/C++ memory management that will be fixed before release in this area.

Fixed point constraints

2011-05-05T01:16:00.001-07:00

Because the solutions found by the solver algorithm move all the points of the constrained shapes and there is no fixed point constraint we had to implement one.
Implemented a fixed vertical and horizontal point position constraint, made tests with it and it seems to work well. Adding this constraint to Naro will be a must have feature added probably on next week, this will enhance a lot the solver solutions - currently the constrained shapes "jump" on scene because of the solver solutions found.

Unit Testing/Boo Script Fixes

2011-04-29T16:28:00.000-07:00

A lot of code was not updated to be sketch aware and this showed some areas with problems. This made that the Sketch based code to be a bit harder to use and made a lot of 2D sketch shapes to not work out of actions range. Right now somelike 50% of scripts and unit-tests affected are working again.
Unit tests are critical to make a baseline of NaroCAD code to know that errors are in usage of code, and to not propagate all errors to break everything. I will work more to fix them as it appears that where unit-tests are fully broken, most of functionality (at least on Boo scripting level) seem also to be completely broken.

OpenCascade 6.5.0 wrapper work schedule

2011-04-28T09:02:00.000-07:00

Built a final version of OpenCascade 6.5.0 wrappers and started investigating why Naro crashes with the new wrappers.

It seems that on 6.5.0 the installer doesn't set the environment variables anymore. Made a script that launches Naro in Visual Studio previously setting its environment variables.
Some crashes appear when opening and closing local contexts. Possibly something on OpenCascade functionality changed in this area.
Some crashes appear when selecting something. Made a sample movie for this case:

The crashes are not created by adding finalizers at all wrappers, I tested also with wrappers that don't have finalizers and the behaviour is the same. It seems to be generated by some changes on OCC. Investigating this issue will probably take time.

As on next week a Naro release is scheduled will save the wrappers work on this state and change the environment back to 6.3.0 to help at finishing the current release.
Will continue wrapper work after release.

Constraints Icon Preview Working

2011-04-25T13:16:00.001-07:00

NaroCAD have right now icon previews for applied constraints. And some bug fixes are done to not apply random constraints in tree like: parallel line with itself, or such, making sketch based solver to get crazy in most cases.

Some small issues were fixed as projects layout copied DLLs to specific sketch based projects and this code was also fixed.

So look here to demo:

Solver Geometry Jumping and a Resharper tip

2011-04-23T12:36:00.001-07:00

I did and I do work for a simple and smooth experience to work with a sketch solver. Anyway, as solution is applied real time, some solutions may not appear as obvious and the solver do some jumping. I did improve a little but are still corner cases when it still jumps and I did not found a simple use-case to reduce those cases. I will hope to find a proper solution but in the mean time I will improve in other ways the solver integration. (like I try to find a proper way to display visually the applied constraints, to not make user to navigate in tree or to select all combinations to see why some things are not moving because some constraints are applied).

Other thing I want to describe is that in my coding experience Resharper (no marketing intended, yet this software addon is one of the best I've found), had always some odd issues when is working with Visual Studio setup in Spanish (the language of my Windows + Visual Studio setup). This make me reticent every time I've upgraded that I will lose the keyboard mapping and was really odd to setup one by one key combination.
So the tip is the following: go to Herramientas->Opciones->Teclado, set as default: Visual C++ 6 as default shortcut mapping and after this go to Resharper->Options->Visual Studio Integration and apply the Visual Studio style. After this you will be able go use great shortcut integration that Resharper provides.

And let's not forget: Happy Easters for everyone! (for who celebrates it!)

Naro on OCC 6.5.0 wrappers

2011-04-21T09:38:00.000-07:00

Built a 6.5.0 wrapper library for the wrappers used in NaroCAD. Fixed also Naro so that it compiles with the new library. Still have problems at starting it, possibly because of environment settings.

Pushed the new compiled set of wrappers on SVN and also a 6.5.0 Naro on the bxtrx Mercurial repository.

Next step is to fix Naro starting and investigate if it works correctly with the new wrappers.

NaroCAD New Background Colors and a Twist

2011-04-19T13:38:00.000-07:00

NaroCAD had for some time background gradients, yet this made it awful to work with them, because sometimes they were flickering. This is the reason that we patched them using a patch from OpenCascade forum. We also made some ugly yet explicit tricks to make it happen right: we force updating screen after some seconds after NaroCAD starts. The flickering was still there but in rare cases after patching.
I've eventually found another way to do it, flicker free as it seem and also the color theme is a bit more vivid.
The reason is that we display a bitmap based background instead a layers based background which OCC (6.3) seemed to have that much problems with.

6.5.0 wrappers

2011-04-19T10:39:00.000-07:00

Finalized wrapping the 6.5.0 packages, merged on them previous wrapper fixes and pushed on SVN. Next step (estimated to take 1-2 days) would be to fix the compiling errors.
A problem that might appear after the new wrapper library is generated could be some problems on memory allocation deallocation caused by the fact that now all wrappers have finalizers (a good point will be that memory leaks will be greatly reduced).

Sketch Constraint Circle/Arc More Constraints

2011-04-18T14:46:00.000-07:00

Based on SketchSolve's implementation more constraints are accessible. The code was changed at multiple levels to make constraints to be easy to set and less prone to errors (by using generics).

See a demo here:

Sketch Hinter Preview

2011-04-17T09:50:00.000-07:00

The Sketch's hinter will detect four combinations so far: if a line is horizontal/vertical and if two lines are parallel/perpendicular on each other.
When you will click on it, it will actually check if those relations are possible and it will apply them as constraints.
A video preview can be seen here:

6.5.0 wrapping status

2011-04-15T06:11:00.000-07:00

Generated wrappers for the OpenCascade 6.5.0 and started verifying by hand and merging from previous version the compile fixes and bug fixes we made during time. Around 30% of the wrappers reviewed until now. After finishing will compile them and make tests to see if Naro crashes.
All the new wrappers classes will have finalizers, this might lead to crashes during running.

Sketch Hinter Work

2011-04-14T14:55:00.000-07:00

Hinter NaroCAD component have some limitation and it work odd for a sketch based drawing:
- it practically have no high level information (and is really hard to achieve on complex shapes like a combination of results of different tooling). Sketch drawing works with much less shapes. For this reason a second point will likely become true:
- the hinter will be able to introduce constraints automatically for shapes that can take advantage of it. Also the hinter may know some specific interactions to handle them in a proper way. To be more precise: the hinter in the past was simply know that an edge was parallel with the previous two points. The new hinter will likely know that you want a line with another line to be parallel and will do the corresponding work for you. In the global hinter, dragging the radius of a circle will give to you likely erroneous hints like line parallelism, which is at best useless
- hinter will scale better: there will be no shape extraction logic, or a shape that is made of clone to simply pollute the entire scene with edges. If your sketch is unique, all the rest of scene will simply be ignored, so you will notice less clutter and will see it as working faster

So you, the reader, already grasp the ideas and utility of the sketch hinter and when implementation will take shape, I hope you will enjoy working with it!

6.5.0 wrappers

2011-04-14T03:15:00.000-07:00

Today started working at updating the wrappers for the 6.5.0 version. Will analyze package differences and probably in a few days will have a new wrapper library.

1.6.1 Alpha preview

2011-04-13T06:16:00.000-07:00

Today we made a 1.6.1 alpha build to offer users some preview on the latest features we plan to launch.

We made a big rewrite on NaroCAD and added: integrated a solver algorithm, implemented the Sketch concept and 2D tools that use the Sketch, reimplemented Extrude to work with sketch shapes, added 2D dragging handles that work on the current sketch. A final updater version was also included in this build.

A sample movie that demonstrates lines drawn having a perpendicular constraint on them. Demonstrates solver behavior when a point is dragged:

Another sample that demonstrates drawing a rectangle (that is built from lines with constraints) and also a circle center connected to one rectangle corner:

Download NaroCAD 1.6.1 Alpha from here.

Rectangle as Constrained Lines

2011-04-12T19:02:00.000-07:00

Rectangle implementation is defined right now as constrained based four lines shapes.
This implementation shows lively how constrains work and will be a good test case to them too.
So look here for details:

Sketch Constraint Document Apply

2011-04-09T17:07:00.000-07:00

Sketch shapes that are referred by constraints if changed on commit they will trigger automatically the solver. This also implied a code refactor that exposes which shapes are lively changed in document. Also, based on Sami's work that when you press Sketch button, the sketch shapes buttons are enabled, the code was made better both as quality and how behaves making it more consistent and easy to use. The Sketch Constraints button was moved to the Sketch Section so will be easily accessible to access shapes.

2D shapes dragging handles

2011-04-08T14:47:00.000-07:00

Modified line dragging handles so that the user can drag 2D shapes only in their Sketch plane. Implemented also a new type of 2D rectangle dragging handles used for 2D shapes. Will apply these modifications also at the other 2D shapes.

SketchSolve Action Preview

2011-04-07T15:22:00.000-07:00

A full solver for sketch shapes (based on SketchSolve code) is right now in preview state in an easy to use action. So this video explains it how it works and how to use it:

2D Sketching tools

2011-04-06T10:26:00.001-07:00

Worked at porting the 2D drawing tools to use the Sketch concept. Implemented the Arc CSE (center, start, end), Arc SER (start, end, radius), Ellipse tools including animations. Fixed the line and circle tools, improved the sketch launch/close functionality.

SketchSolve NaroCAD Infrastructure Explained

2011-04-03T05:44:00.000-07:00

SketchSolve is a 2D Sketch Constraint Solver and NaroCAD is a 3D based designer.
SketchSolve have mostly a dynamic programming solution optimizer that will apply the constraints using a big dispatcher to compute the errors that may happen in applying the constraints.
From NaroCAD standpoint challenges are at two levels: sketch shapes need to be sketch oriented, so by design all shapes get references to a sketch. The second problem is how to setup at programming level map the Line, Point, Arc and Circle from NaroCAD to SketchSolve semantics and after the SketchSolve is done, to make things back. Another small feature, yet useful is that those constraints are in a chain, so at programming level, the code at NaroCAD level is smart enough that by simply stating a shape, will build all the dependency chains to be computed in SketchSolve. To be both efficient, this code uses the GraphMapping component that compute back-references and get the mapped constraints.

So let's take a simple(st) case:
"NaroCAD have defined two points and one constraint (PointToPoint) and one point may be moved"
How the back logic works:
- the scene computes the back references: so P1, P2 are references by P2PC
- BFS algorithm will find in P1 -> P2PC -> P2
- a re-mapping will translate NaroCAD shapes and constraints will be converted in SketchSolve logic
- SketchSolve will solve the the constraint system and will retranslate shapes to make the system to work
- at the end shapes will be un-mapped from SketchSolve so the constraints will work accordingly

SketchSolve Infrastructure Implemented

2011-03-31T20:16:00.001-07:00

SketchSolve is a great project and offers inherited capabilities for 2D shapes yet a translation in between NaroCAD logic and SketchSolve data are needed. So I've ported an unit-test (yet the easiest one) to make possible to work with those two components (NaroCAD's document structure and SketchSolve data).

In fact this code works with minimal code to include all existing SketchSolve in NaroCAD.
This code is also an internal working feature and we are team are thinking the way things will work integrated eventually at UI level.

This milestone is important as matches the most of refactors of NaroCAD were just in idea of separating the internal logic between sketch shapes to permit SketchSolve to operate.

Close behavior on application button double click

2011-03-30T08:03:00.000-07:00

A few fixes to the NaroCAD window were made: a few pixels were lost from the Quickaccess toolbar buttons when NaroCAD was in full-screen mode; The same fix was applied to the application button in full-screen mode.
I also implemented a close behavior when double clicking the application button.

Extrude Look&Feel

2011-03-29T14:42:00.000-07:00

Extrude tool right now works concomitantly so you can select more face to extrude them. Also, auto-facing appears automatically (as semi-transparent faces.
If you did click on an extrude and was a wrong choice, you will click once again and it will be removed from actual list of extrudes.
Bugs are mostly in flickering area and sometimes auto-facing will not catch all faces. Probably when code will be ported to OpenCascade 6.5 a lot of fixes will appear in this area.
Hopefully this new extrude will save clicks, will be more precise (as you can use both the slider and the values using expressions if needed). so enjoy using it! (after last of bug fixing will make it better)

Sketch concept

2011-03-28T22:29:00.000-07:00

Finalized implementing a Sketch concept like the ones used in other CAD applications. Each 2D shape will hold a reference to a sketch, a sketch holds as info a plane, the 2D shapes tools will not work without having a sketch active.
The sketch will be useful also when integrating the solver, as the solver uses 2D coordinates to find solutions. We'll use the sketch plane to calculate the 2D points from the 3D ones.

Modified the circle tool to work on sketch. It started to work. Some final polishing needed.

Extrude revamping (part II)

2011-03-28T05:30:00.001-07:00

Extrude is improved by having a live drag handler and a dialog that you can put precise values to it.
There are remaining bugs there but they are going down (mostly in auto-face area)and finishing the dialog that sets extrude.
The code is a bit harder to work with cause can be as many extrudes at once and previously were bugs in how references are stored. Hopefully in short time the extrude will be previewed as a video to express it how it works.

Extrude Revamping (Part I)

2011-03-20T20:21:00.000-07:00

Extrude tool is good but not that good. Some limitations are easy to spot and as we work extensively to improve the internal abstractions, one of them is how extrude tool will work.
Some of the changes will be:
- you can extrude more faces at once that are generated just in the moment you select extrude
- there will be a non-intrusive mini-dialog specific for extrude

Work is still ongoing, but I just wanted to post this as things start getting shape.

Updater - Part VII

2011-03-18T08:29:00.001-07:00

The updater is now mostly done. I added a few notification windows: if newer version are available and the appropriate update check boxes are checked, NaroCAD will show a window with the new features of the newer version and will give you the opportunity to update now, next time or never; the never option is not implemented yet, but it will only uncheck the update check boxes from options; After the main downloads are done, a small window will appear in the lower right side of your screen, telling you that the main downloads are completed; this window will automatically close in 5 seconds, and will not freeze NaroCAD, or do other nasty things. The last window that will bother you, will appear at the next NaroCAD restart, after the update has been successfully completed; as the last one, it will appear in the lower right side of the screen, and will close automatically
With this, the Updater is almost completed. The only things that need to be done are to implement the options from the first message box and to test it for any possible bugs.
The updater from the last release has a bigger problem than expected. If you want it to do nightly updates, you have to check both updater check boxes, and delete the "auxiliary' directory from NaroCAD. This problem only appears for nightly updates, but even so, it's not quite what I had expected.

Line Internal Changes (Part III)

2011-03-15T10:40:00.000-07:00

Circle and Line was migrated to reference based points. This obviously make that tools that depend on it, to crash if they will not use the same constructs (like circle will use direct point instead a reference to an existing point).
The places where this code which fails were around (and now are fixed):
- face picker feedback (a circle that shows the plan you're in)
- some actions will have a skeleton to be fixed that they are dependent (here is about the Arc actions)
- another action (Extrude) have a skeleton that will be developed in future to be smarter, right now the skeleton code is here, but more will follow in another blog post

Solver algorithm started working

2011-03-13T12:27:00.000-07:00

Debugged and fixed the Sketchsolve algorithm ported to C# by my colleague. Made unit tests for basic use cases. For point to point, horizontal and vertical constraints it seems to find correct solutions.
Next steps would be to add also parallelism and perpendicular constraints (to cover cases like a rectangle made from lines with constraints) then start integrating into Naro the solver.

Line Internal Changes (Part II)

2011-03-12T12:26:00.000-08:00

The line was internally simplified and more cases of the code were replaced. Line in poly mode and Line angle does not work yet, but soon will be. Practically almost all lines were replaced with those changes. Still crashes are waiting over the corner, but I will continue diligently to fix those cases and to break others (mostly circle based shapes will also be moved in the same framework) and fix them back.

Line Internal Changes

2011-03-09T17:19:00.000-08:00

Line is changed to be expressed as reference to a shared net of points. AutoGroup/AutoFace is also disabled by default.
This will make really easy from internal logic point of view things like smarter common point dragging will make all shapes related to move, without any "constraint" logic and so on.
Also the code is made fairly simple by making that mostly the changes to go from:
builder[1].Point3D = Points[0];
to:
var documentPointLinker = new DocumentPointLinker(_previewDocument);
var firstPointBuilder = documentPointLinker.GetPoint(Points[0]).Node;
builder[1].Reference = firstPointBuilder;

This will make automatically all "magic" to reference external points.
The external code that uses internal line structure, change minimalistic too, like from: axis.SetLocation(Dependency[3].TransformedPoint3D.GpPnt);
to:
axis.SetLocation(Dependency[3].RefTransformedPoint3D.GpPnt);

As user, you will see somelike this:

Why 1.6.x?

2011-03-09T16:20:00.000-08:00

We know many +1 versions and version names are mostly esoteric for all purposes. For example Linux Kernel is "forever" 2.6 (from 2004, and the previous releases are +0.2 every two years, so in 1998 you will probably get installed in your distro a 2.0 kernel, in 2000 a 2.2, in 2002 a 2.4, etc.) and not changed for a long time and 1.6.0 brings little changes compared to 1.5.7 version.
NaroCAD tries to keep the cadence of a new release at every 3 weeks (and we focus to do development for first three weeks) and we mostly consider a line of releases and at every new release we will add a 0.0.1 to its number.
Anyway, as people we judge version numbers. Windows 7 even is like a new Explorer and a Windows Vista SP2 kernel, we consider Windows 7 as being "vastly superior" to Vista bad reputation.
So we did jump to 1.6 line as we considered that if you did not like the 1.5.0, it worth the upgrade. Doing a bit of cherry picking, you will find that 1.6 will have back the updater, will have a smoother experience all over the place, a faster hinter (both UI wise and how is computed internally), you have gizmos. So if you refrained to use NaroCAD as it was missing this or that feature, was an invitation just to check if it does really gets better.
So in short what should be to learn: we do development incrementally, we try to make all builds stable (yet some specific tools lack on it, we love crash reports, and if we can reproduce we work hard to fix those tools, or rewrite them to be easier to use and to make more sense). Also we do at every around 3 weeks a new release, if you will like to know if you are ready to upgrade, try this blog to get the announcement and to see if new features make you love those tools and if they do, you're more than welcome to update.
At the end, we want to increase the version number to you to know that it worth the upgrade, if you had a 1.5.0 like release, and was something you dislike (who knows, maybe 1.6 it will be the case for you) and as you may see that this development of 1.6.1 will not fully fill your needs (we cannot rewrite all NaroCAD in 3 weeks), you can certainly try 1.7.x and you will likely be more than impressed. We also have an updater that makes it easier to you to be up-to-date so you're encouraged to test releases, and every crash will make for us possible to test and fix your problems.

Updater - Part VI

2011-03-08T06:25:00.000-08:00

The updater is now working correctly. I also made some improvements:
- duplicate code was removed. At the beginning, the version files were added manually in our projects. After the changes, the version files are red from the full.iss files.
- another improvement is a project that automatically generates all the version data ( the version XML file and all compressed files)
The only thing that's missing is a window that tells the user if newer versions are available and the new tools. At the moment, the updater will automatically search for new versions if the appropriate check boxes are checked from the options menu.

NaroCAD 1.6.0 Released

2011-03-08T05:39:00.000-08:00

NaroCAD team worked to improve in many areas and really notable features are:
- Updater: is much better than previous iterations: it have better consistency checks. You will use much less bandwidth, because it will download just necessary files, even for us, the versioning is made in a much smoother way. We will continue to make the updating experience as smooth as possible.
- Spline interpolated, Control point spline: they will work more precise and smooth than ever: you will see live how they are made, you are able to use command line to set precise coordinates, you can combine and split them with an intuitive way to do it: click on the points that are automatically computed to show to you where you can split those lines, and those splines will be cut accordingly
- Gizmo points are hinter aligned: gizmo will work more precise as hinter will automatically align with various geometry you will have around
- Edge intersection for horizontal, vertical lines: horizontal and vertical lines did not compute previously the intersection points, and right now they do and they do it in a correct way
- Fixed fillet/chamfer 2D: and you can use them in your designs. Another
- Angle between lines: if you have various lines in your scene and you want a precise drawing
- Hinter toolbar: user can enable with just one click point alignment, line continuation and so on. It is much faster and enjoyable to work!
- Redo tool: pressing Tilde key and if you have selected any tool, NaroCAD will switch automatically to the same shape/tool creation context.
- Customizable per action toolbar: so future actions (today Spline and Angle Between Lines are using it) may have specific customization without having a floating (sometimes modal) dialog box making it less intrusive and let you focus on design.

Interested? Download it from here.

Layer 2D Manager Bugs

2011-03-07T19:13:00.000-08:00

Layers mouse-following text was appear to be broken in some cases.
I found that causes were mostly for two reasons: was a bug in the way this code was used (by mistake, every time an action was started, was creating a new layer manager), the way it was updated (hinter component of our code may call update view just before adding layer, so nothing visible) and also I think an OCC related bug (that layers seems to not update if no scene (OCC context) changes are made).
So the whole code was moved up and down (in the idea that View component will include the OCC layer manager) so will not make possible cases like previous told. Also those layer structures are cleaned up every time you switch an action (making this code less prone to memory leaks) and will be less prone for API misuse. This refactor make it possible to discover that spline tools show mouse coordinate juxtaposed with hinter text, and this was also fixed.

Re(do) Shapes Pressing Tilde

2011-03-04T17:27:00.000-08:00

Pressing Tilde will switch to the tool that will create the same shape.

See a small demo here:

Bug Fixing Again

2011-03-04T14:51:00.000-08:00

All splines (regular, interpolated, control point and regular "old" one) have accessible and exposed the dragging control points. They are more useful than normal ones.
I've updated the code of Line angle to compute the regular one and give an exception, so you always lose the angle if you will do a Line Set angle, but hopefully I'll find why (or who knows, bxtrx ;) ).

Updater - Part V

2011-03-03T00:22:00.000-08:00

I changed the versioning file from txt to xml. The advantage is that I have more control over the code because I serialize and deserialize with the help of a special class. This way, it’s enough to deserialize the versioning data once, in order to obtain and easily use all information stored in it. Of course, the older versions with the versioning file as txt won’t work with this one. Even more, the updater code is not completed yet. It is possible that some nightly builds had old updater code. If you have problems starting NaroCAD in the last period, it might be due to unfinished code. If you have such problems, it is best to reinstall NaroCAD. Also be aware that nightly builds might not always work correctly due to unfinished tools.

Bug Fixing

2011-03-02T14:35:00.000-08:00

I work on bug fixing and I will work on spline area to do more fixes to be more complete as coding goes. I've also worked a little reviewing Sami's code on updater.
Editing works different for Spline new code as editing tools work by scanning automatically the internal structure of shapes dependency.

Combine Spline Tool. Angle Between Lines Tool

2011-02-28T18:37:00.000-08:00

Spline have a new tool that is used to combine two coincident splines. It is useful if you will work with multiple splines or you split an already existing spline and you found (later) that you want to be again in one piece.
A tool to chose the angle between lines (this tool is a bit unpolished, so may change a little in future).
A preview is shown below:

Updater - Part IV

2011-02-28T07:35:00.001-08:00

The updater now does a file compression. This means that NaroCAD downloads the compressed files, makes an uncompressing and continues with its job. By downloading compressed files, the download is 3-4 times smaller. One other advantage is that NaroCAD can detect if the file was downloaded correctly by trying to uncompress. If it works, the download was successful. If not, the uncompressing will fail. This way, it’s much easier to determine if a file was downloaded correctly or not. While this change is definitely good for the user, it also benefits us, because it doesn’t take so much time to upload NaroCAD and makes testing the updater a bit faster.

Spline Tools Improvements

2011-02-27T13:43:00.001-08:00

Split Spline is a new tool. It will preview the points you defined your spline so you can split in parts. Spline tools have a fast-access buttons (this view right under ribbon control) will make much faster to access without going to contextual spline menu over and over (you may try for example to define an interpolated spline, then try to split and then go back to interpolated spline and you will understand right away what I'm talking about :) ).
Interpolated Spline and Control Point spline have two small improvements:
- pressing shift for a point on a spline will delete it. This is useful if you made a point that was defined on a wrong coordinate and you don't want to remake it
- if you start dragging a point, you can insert the coordinate from command line, so you may can work right away and fix it later.
The editing component of spline is not yet finished, but expect more goodies in this area.

See a small demo here:

Spline Undo/Redo Fixes

2011-02-27T03:15:00.000-08:00

Spline have a representation that was prone to Undo/Redo errors as there is a need for custom logic for having a dynamic sized shape. This logic is fixed
Also I've did the skeleton work for Split Spline tool but this will be described (most likely) in the next blog post.

Block Plane Enhancement

2011-02-25T15:31:00.000-08:00

Block Plane is smarter: if you will select a face like on XOY, YOZ or ZOX plane, the view will also follow suit (for example if you picked XOY design, the view will switch to Top), so you can start doing designs right away.
Hinter is also shown live how it works as it can be seen here:

TreeView Assert Fix and Solver Quick Enablement

2011-02-24T16:48:00.000-08:00

TreeView can assert (and crash) sometimes with an assertion. This assertion is made to not introduce twice the same element. Right now even if an element is introduced twice, the event is logged but will not crash NaroCAD.
Solver options are exposed from the main interface to be one click away. One other change is that (excluding this screenshot that was a development photo) is changed to be named Hinter. In this way I will not use erroneously interchangeably those two words.

Updater - Part III

2011-02-24T07:22:00.001-08:00

I managed to solve all the problems related to downloading the needed files. The main problem was that I made too many tests after downloading the files, so many that the integrity of files was never ok. I also made a cool trick while fixing these problems. NaroCAD will not only download the newer files, but will also check if the current files are still valid. Because I couldn’t use the hash code for many of the files, I checked the file lengths (in case they even exist on disk). What does this mean? Let’s say that the user “accidentally” deletes the help files, some NaroCAD icons, and more. If NaroCAD needs update and still has enough files to start, the update will verify that even the unchanged files still exist on disk and that they have the correct size. This way, the updater will automatically download those files for you, and will fix and update NaroCAD at the next start-up. Even if you have the latest version, and “accidentally” delete some files that are not critical to NaroCAD at start-up, just change the version number from the Version file to a lower one. NaroCAD will try an update and will heal itself :) Don’t worry if the internet connection is lost during that process. NaroCAD will try again at the next start-up, not from scratch, but it will continue from where it had left off.

Cubic Spline Improvments

2011-02-23T14:25:00.000-08:00

I've finished polishing spline related tools in NaroCAD to be more complete and easier to use.
So you will have three spline types under NaroCAD and they will work a bit better than in the past.
Some fixes may be still needed but at large Spline related tools are nice to work with and you may enjoy using them (in next releases). OpenCascade 2D layers do not work concomitantly (or I've misunderstood how they work) but I've rewrite to make possible to write multiple texts so when you will use Spline you will see coordinates)
Note: cause of internal changes, if you was using in the past Spline Path tool, I do recommend you to work with nighties, because this functionality is rewritten in a non compatible way. Also the old code was making to add features on it (like a proper editing code) very hard, so will be unlikely to get fixes will be in that area.
So take a look:

Mistake: cubic splines are defined by 4 points.

Arc gizmos

2011-02-23T07:32:00.000-08:00

For simpler editing of Arc(start, end, radius) and Arc (radius, start, end) added Gizmos for them. Made Gizmos also for the cone base, that would allow users to modify the cone base by dragging with mouse.

Updater - Part II

2011-02-23T07:08:00.001-08:00

Yesterday I told you that NaroCAD will only download the files that were changed during the new release. Although I encountered problem with checking the file length, the hash code was a bit tricky. The main problem is that the hash code had different values depending on the time the file was created, and other parameters.

The main problem was that every build changed the hash code of the project files. The only solution to this problem would be to study how the date information is stored in files, study the encryption and decide whether the new file has useful information or not. Still, we mustn’t forget that the size of these files is small (very small if compressed). Even if I were to study these changes, I would still have to download the file in order to do the analysis. Even more, the analysis would be time consuming. The best way is to download all the generated files and check if changes were made to all the other files. This is a bit easier because these files don’t suffer from small changes, usually no changes at all. Given that the files without such problems are more than 70% of all NaroCAD files, the updater will prove much faster than actually downloading and installing NaroCAD.

To tell the truth, even the other files have different hash code when created by the installer. The advantage is that building the projects will not change these files. This means that the developers will not store different hash code for these files when generating the information of the versioning files. If these files are changed, the information from the versioning files will also change. Knowing this helps me to implement a faster updater. The only trick is that the newer hash code of these files (for example OpenCascade libraries, icons, etc) will be compared with the hash code from the current versioning files. This way, the contents of these files will not be red. What does this mean? If someone changes a character of such a file on purpose (so that the length remains the same) the updater will not be able to tell the difference.

So, to make it brief: the files generated by the NaroCAD projects will always be replaced in the new versions, and all other files will be downloaded only if needed.

NaroCAD Startup Time And Lazy Loading

2011-02-22T14:48:00.000-08:00

NaroCAD historically was used to use SCSF and as it was removed for some time, NaroCAD improves start time from like (I will use timing from my machine) 7-8 seconds to 4 seconds. Most of this time was because of JIT of SCSF and SCSF related logic.
As of today the startup time is splitted like this: library startup (.Net, DirectX subset used by WPF, OpenCascade startup, browser control that is used both on Tips window and on Help view), JIT (still, but at a smaller margin), layouting (Ribbon control will layout all buttons to fit right, all menu items and so on), NaroCAD framework logic and some Boo evaluation code.
So as for now on my machine (which is an i5M CPU class laptop) is around 3 seconds and I will explain what was changed in mostly the last 2 months, from when SCSF was removed and how JIT time was also greatly removed.
When we register things in NaroCAD (like actions, buttons) we always hit constructors. And this constructors are compiled with everything is in them. So, the logic that was in the past, regarding them was moved to an external method, that can be overriden named OnRegister. This will be called lazily as needed, so you will likely you will not see that an action will need a list of inputs to be setup. Another thing is that most actions will inherit mostly two classes (ModifierContainer or DrawingLiveShape) making precompiling to happen just once.
Another small issue was that layouting of all tabs take around 0.7 seconds, so tabs are also layouted from first time when you activate them. This will add just 0.2 seconds on average (for first time) when you will switch tab, but is much better if you will start often NaroCAD (hopefully not for crashing reasons).
Another section that was seen in profiling, and was made in 1.5.7 timeframe (so you get this even without nightly builds) is that Boo expression evaluator will be used in any instance using an interpreter. This will mean that your expresions if are like loops, they will likely execute slower (yet, external methods are executed through a compiler). To run as an interpreter, makes the logic of the code much simpler from Boo parsing and executing side and will likely speedup 3x in most cases.
At the end, regular poly tool was compiled at NaroCAD startup, but today is compiled just first time when is used.
Why I wrote this post? Mostly to know that we do keep an eye on how NaroCAD works both outside (we get on average fewer errors than in previous releases as bug reports even as download count goes up) and from inside.
Also, I wanted to you to know how and why "NaroCAD is slow": WPF is like starting a small DirectX game, and similarly when we start OpenCascade libraries (that load OpenGL libraries), Internet Explorer control, Ribbon to do layouting, and so on, at the end you will get this startup time.
Do you have a specific case when NaroCAD works slow for you? May you share it with us? Use NaroCAD and with your feedback we will make it better.
As an update: sometimes Polar Coordinate setup may lose its values from options and all around bugs were fixed. We use cubic spline "magic number", so if you will draw splines that are placed in corned of a square, the 4 leg spline will approximate a circle as described here. The next nightly may show it to you.

Updater - Part I

2011-02-22T01:10:00.000-08:00

I’ve started to implement an updater. Since it’s a lot to explain and since my work is not done yet, I will do it step by step. The user will be able to use 2 check boxes that allow NaroCAD to search for nightly builds, stable builds or nothing at all. I will use a button with different colors in order to tell the user if new updates are available, if files are being downloaded, or if the latest download is finished. One of my purposes is to download as less as possible in order to update NaroCAD. This is why I will use a versioning file that contains the current version (nightly or stable) and information about critical files in NaroCAD. As expected, newer versions will have a different version number and some of the files will disappear, new ones might probably appear or some of them might change because new features were implemented. In order to investigate if one of these files was changed, I decided to check the length of the file and its hash code. With this strategy, just a few files will be downloaded for each new NaroCAD version. I will end for today with the explanation of the 2 check boxes: the first one is called “Check for updates”; if this check box is unchecked, NaroCAD will not search for any new updates. When checking it, a new check box will appear “Experimental builds (nightly)”; if the user doesn’t check it, only the stable builds will be downloaded. If both of them are checked, NaroCAD will search for every Nightly Build. Note that the nightly builds contain the stable builds, so don’t worry, no features will be lost.

Polar Coordinate Match

2011-02-21T17:02:00.000-08:00

The last release (1.5.7) have a nice tool that locks lines on three major axis (OX, OY and OZ) that can be enabled/disabled (named Ortho tool). At the end I hope that you will feel more at home with free angles.
Look how it works in this small video. If you want to test it, pick the nightly build from right:

Note, if you will want to test the new spline code, this code is fairly broken.

Non Common Cases Crash Fixes. Reviewed To Improve Spline

2011-02-19T15:54:00.000-08:00

Some categories of bugs are named "bugs that are not in normal flow". One of those bugs was noticed by Sami and is that some parts of the code are done "just in the right moment", like "Tree View node creation". Sometimes this Tree View can be updated forcifully and can lead to crashes because scanning of shapes in scene can encounter invalid shapes when is populated, or can appear artifacts. Sadly this crash can be triggered in cases when you change solver options.
So the solution is for now to not update any time tree view, and when is needed, will restore everything in a stable state (to be certain that those crashes will not happen).
Splines in major design tools are of three types:
- one of as many points as possible, being the equation that is defined by all points of it. Was our original spline tool implementation
- another two are based on 4 point spline "legs", one is made by using control points and other one for simplicity uses the same control points but will interpolate the values for user, because it reduces the click count by a third
So logically the "Control Point" and "Interpolated" spline are both implemented in the same time, anyway, as both shapes have some exceptions from other shapes, some problems in implementation were obvious (like is one shape that transformation is handled separately). Editing in 1.5.7 works just for first leg of Spline, and so on.
I was evaluated problems of it and I've looked to other how they do it, and I found and I'm on the right track to solve all class of problems: Spline (interpolate and control point) will be consolidated in a single shape), also the actions that expose it will share a good bunch of code (excluding the interpolate "automatical generation of points" that will be different between those two tools). In this time I've also evaluated and solve some small issues I've found around the way: NaroCAD had no dashed fixed distance (not infinite) line that I wanted to use it for previewing the control lines. Also a small bug, but for certain annyoing was that the code for setup the color was not working for "interactives", and the root cause was that we setup style for shapes (a great thing for rectangles).
So in short hopefully soon you will see a spline that will work fairly right in most design ways and will be a useful and friendly tool.
Note: Did you know that you can insert coordinates for Spline from command line? In case you wanted a precise tunning?

Magic points with Gizmos

2011-02-18T07:26:00.000-08:00

Enabled magic points on Gizmos. The feature seems to behave well and is useful in many situations/ Will work with it more to see if it has problems.

A video sample of using it:

Horizontal and Vertical lines intersection points

2011-02-18T02:33:00.000-08:00

Finalized the horizontal vertical lines intersection magic points. This feature will allow users to use horizontal and vertical lines as guidelines for other geometry.

Fixed and improved Fillet and Chamfer tools

2011-02-17T09:31:00.001-08:00

Fixed the Fillet 2D, Fillet 3D, Chamfer 2D and Chamfer 3D tools.

Simplified the usage of all these tools. Now the usage flow is the following: click on the tool icon, the tool when starts automatically changes selection mode to edge (where needed), the user clicks on the edge/wire to fillet/chamfer, a dialog appears on which the user can enter the fillet/chamfer radius (the modifications on the dialog are previewed live on scene).

Because fillet/chamfer were the last tools that needed the selection change tool, disabled for the moment the change selection tool.

NaroCAD 1.5.7 Released

2011-02-16T05:51:00.000-08:00

"Thinking in 2D": A lot of 2D related work was done inside NaroCAD codebase and you can enjoy it by downloading the last release (link bellow):

Added Ortho tool: Blocks drawing on horizontal vertical direction:
Added Trim tool: so you can make proper designs combining 2D shapes
Block plane tool: The user can block drawing on a specific plane: you can work without annoyances in any free form plane so you can make your designs to really work
Measurement tool: so you can see distances without actually creating geometry
Enhanced line tool: The line length can be inserted on command line.
Added spline path tool: is an enhanced spline, with fewer of "multi-point" spline. It is more precise and you will get more changes later.
Copy paste tool: combines copy paste with precision translate: so will make repetitive shape creation even nicer
Modify solver precision with scene zoom level: so the solver will feel both precise and useful
The solver returns the closest point, not the first solution found: making an "non-calibrated" solver to give relevant point that you may search

Download it from here.
We also ported (mostly, some bugs stop to make it even as a future prospect, but who knows, we welcome reviewing code) SketchSolve, and in case it will be finished, a full 2D solver, C# based may be a part of NaroCAD.

Bug Fixing and Zoom

2011-02-12T15:15:00.000-08:00

I've work on bug fixing as the next week will go in this area. One small feature is implemented also, so is existing framework so when is computed the zoom level to view, this will be used to have "around area" solver sensitivity. This will make it more smooth "around point" experience.
Line as it was rewritten to handle command line differently, a bug was that you could possibly create a zero length line. Right now the "double clicks" are ignored.

Line Improvements

2011-02-10T13:05:00.001-08:00

I've mostly fixed problems with Line tool handling in two kind of fixes:
- Line will not compute parallel line solver checks with points from previous line
- command line was fixed to handle custom "Unknown" type (previously command line was used to work with specifed types only) to make
In the last days I've converted line to line to C# SketchSolve. Anyway, there are some problems and that code works a lot with pointers/references and for this reason, the code does not work as it should. There may be little mistakes, but are enough to make this code to break. Most likely I do work on a copy when I should not, or vice-versa. If are any takers that need a full solver in 2D (with constraints) and want to be C# ready, please take a look to this project and try to spot where are the problems. The code include both code-bases in a project under: Lib\Install\Lib\NaroSketchSolve\NaroSketchSolve\. I'll put the code as LGPL, so if you will fix, please contribute back this source code but also you will be able later to put it under your project, even is comercial. If you are pleased with the original C only implementation, you may wrap it using P/Invoke, so you will not have any LGPL restriction, but will be hard to see where are problems and why. (The original code is under BSD) This project is also better written as is OOP, it mostly respect NaroCAD codestyle, (even will keep for now a lot of variables and names from original code), so you may find it easier to navigate than the original code.

NaroCAD shape locations on scene

2011-02-10T00:05:00.000-08:00

Lately we had a lot of problems at tools like Trim and Mirror caused by the way we generate shapes vs the way Opencascade generates shapes:
- when building a line let's say as example the (10, 10, 0) to (20, 20, 0) line we generate internally the (0, 0, 0) to (10, 10, 0) line and hold on some transformation interpreter the transformations applied on the shape, in our case a translation to (10, 10, 0). In this way we can expose to the user on the property grid the shape transformations and allow user to change them. A simulated shape in Draw Test Harness is like the following:

vertex v1 0 0 0
vertex v2 10 10 0
edge e1 v1 v2
ttranslate e1 10 10 0
dump e1

The dump result is:

Dump of 1 Curves
-------
1 : Line
Origin :0, 0, 0
Axis :0.707106781186547, 0.707106781186547, 0
Dump of 1 Locations
-------
1 :
Elementary location
( 1 0 0 10 )
( 0 1 0 10 )
( 0 0 1 0 )

The shape geometry is generated on (0, 0, 0) and holds the shape transformation on Location.

- When applying Opencascade algorithms like Trim or Mirror on our geometry like the one described above the result is a shape with Geometry generated in (10, 10, 0) and Location to (0, 0, 0). This creates us a lot of problems because we don't know where geometry is located, we don't have access to transformations, we have problems when a shape generated like this is passed to an algorithm together with a shape generated like in the case below. A Draw Test Harness sample of this type of shape:

vertex v1 10 10 0
vertex v1 20 20 0
edge e1 v1 v2
dump e1

The dump result:

Dump of 1 Curves
-------

1 : Line
Origin :20, 20, 0
Axis :-0.707106781186547, -0.707106781186547, 0

-------
Dump of 0 Locations
-------

The solution:

We decided to use everywhere only shapes located on (0, 0, 0) and hold transformations on our internal interpreter. That assumes an extra step on our side to prepare geometry before using OCC API: we have to save current transformations, translate all shapes involved towards origin, apply the API, translate the result at the saved transformations by applying the transformations on the interpreter.

Modified the Pipe and Trim tool to work like this and it seems to work well even on shapes that have rotations applied on them. If testing passes successfully we'll start modifying tools like mirror, extrude, cut to use this approach.

Trimming tool

2011-02-09T23:57:00.000-08:00

Finalized a first version of the Trim tool that works on basic situations like line intersecting line or line intersecting circle. Had difficulties making the tool work not because of the trimming algorithm but mostly because of the way we and Opencascade generate shapes. Will make another post with technical details related to this issue.

A circle and 2 lines trimmed with another line:

Copy/Paste Fix

2011-02-06T15:22:00.000-08:00

Copy/Paste when you copy and nothing is selected crash is fixed. I've did some work on an improved 2D solver logic but yet the advances are there but is not yet something substantial, because I've started from a C codebase, but I will be back with details if things will get in a proper direction.
So make sure that you select something before you try using Ctrl+C to copy an object to not crash on Paste.

Lines' Length and Orthogonal Axis Lock

2011-02-02T16:17:00.001-08:00

You will be able to set either the next coordinate or to write just the length for line (in command line) and the line will be drawn accordingly.
You can also lock drawing to make it that you can move mouse just parallel with main axis. This works internally as a Solver mechanism, so in some cases that disable solver all-together may seem to not work, but in general with every shape drawn you will have this possibility.
To use it, you may check the nightly build.

New Spline Code

2011-02-01T16:31:00.000-08:00

Spline will have a new way of creation. The original spline used an equation that will add-up as much as many points are done. This is both imprecise and fairly unconventional. So the design worked to improve this are by making spline as defined in portions that are defined by two end points and two control points. This also scales better, as the old spline was limited to around 20 points, this one will get as many points you will throw to it, because the full spline is a chain of smaller splines. The implementation was mostly done from yesterday, but the work was done to define automatically good defaults for handlers, so you will have a precise spline with a clear preview. So, enjoy using it (is named Spline Path and is under the Spline drop down).
A handy tool is the measure tool: you will click between points and you will get the distance between them. It may be used to define distances between shapes without defining extra geometry in scene.

Trimming tool

2011-02-01T08:39:00.000-08:00

Implemented a Trim method that receives as parameters two edges and a point in space. The method trimms one of the edges with the second one on the side shown by the point in space. For now it seems to work well on unit tests made for it.

The output of Trim is for the moment a wire in space. In order to make the tool much more powerful the plan for the final Trim tool is to generate geometry that we "know" in Naro. Ex: a trimmed Circle will create an Arc Node in Tree View editable in Property Grid, a trimmed Line will generate a Line Node.

Smart Copy Tool

2011-02-01T04:20:00.000-08:00

This tool isn't as simple as Ctrl+C and Ctrl+V. The main idea is to create more copies of an object. We saw that the circular and array pattern create copies of an object that have a calculated location compared to the base shape. What if the copies are to be made at locations that do not correspond with any pattern? The idea is to copy a shape at any desired location with just one mouse click.
Copy works like this:
- The user presses the "Copy" button
- The user selects the shape to be copied
- The user selects the desired base point
- The user selects a location where the copy is to be made. The base point of the copy will become the selected location
- The user selects other locations where other copies are to be made
Be careful that this command does not end. Any given point will generate a copy of the desired object. The user can create as many copies as necessary. The base point is required, because NaroCAD needs it in order to calculate the translation vector (move the object from the base point to the given location). Without giving the base point, NaroCAD would have to use the pivot or the gravity center as default. I prefer not to use values that cannot be changed when making a new feature. This way, the user has enough control over the shapes that are to be copied. After selecting the base shape and the base point, the user just has to select the desired locations where the copy is to be made. At every mouse click, a new copy will be generated. In order to try out this tool, you can download the last nightly build from www.narocad.com, under the downloads section.

Block Drawing Plane

2011-01-31T03:30:00.000-08:00

This command allows the user to block the drawing plane by selecting a surface. The idea is to block the current drawing plane, so that all shapes that are to be drawn should be generated only in the desired plane. If this tool is not activated, the drawing plane changes as the user moves the mouse over surfaces or solid faces.
Block drawing plane works like this:
- The user presses the "Block Drawing Plane" button
- The user selects a surface / does nothing
The selected surface should be planar. NaroCAD tries to extract the normal line of the selected surface. If it fails, the blocked plane will be the last one used. If the user selects an invalid surface from the very beginning, NaroCAD will set the drawing plant to the XOY plane. The user also has the option to simply push the "Block Drawing Plane" button, without selecting any other shape. As expected, NaroCAD will block the last defined plane.
Notice that the solver points have bigger priority compared to this tool. This means that solver endpoints will work even if the block plane is activated. For example, if the user starts a line and selects the first point as the endpoint of another line that is not in the current drawing plane, that point will be recognized as valid. If the second point is not generated with the help of the solver, it will be generated in the drawing plane.
The last thing to mention is the difference between the activated and non-activated drawing plane. When the user blocks the drawing plane, the "Block Drawing Plane" button will change its background color to red, and its text to white. This way, the user knows when this tool is active. Deactivating it will return its colors to default.

You can test this new tool by downloading the last nightly build from www.narocad.com, under the download section.

Some Changes

2011-01-30T15:46:00.000-08:00

I've did working on a new Spline some changes as were noticed as missing. They are more or less like a bugfixing/features completeness and they are in short:
- Boo expressions will work for integer based expressions
- almost all cases (excluding cases that can work with impracticable large shape count) will update tree-view correctly. As code level some cases will get easier to make populating this code easier to do (it can be defined a root node, and all nodes will be added in cascade)

NaroCAD 1.5.6 Released

2011-01-26T04:50:00.001-08:00

- TreeView speed improvement for big scenes - all simple shapes will do minimal updates on tree view
- Boo script evaluator on property grid, command line - input is evaluated thought the Boo compiler making possible to use sine, cosine, operators, parentheses, and so on,
- Scene export as Boo script - to make transition to future versions and integrating with Boo code easier
- Linear pattern - an advanced yet simple to use pattern over a line
- Circular pattern - an advanced yet simple to rotate a shape and clone it over a line
Support for composed shapes from basic shapes - to make possible to make regular or shapes depending on other shapes easy
- Fixed mirror - solids will mirror nicely by using right OpenCascade code to do it
- Fixed color picker, solver hint positioning - so you will enjoy even more using NaroCAD

Download it from here.

Update: we have problems with SourceForge hosting so we put it on alternate link. Please refollow the download site and we will use NaroCAD site till SF will work back reliable.

Fixed mirror tools

2011-01-25T11:34:00.000-08:00

On last two days studied OpenCascade shape topology especially because the mirrored shapes had some "inside out" look.

Made a change at the TopoDsShapeInterpreter that affects the way that all shapes generated on scene are built. It seems to work well. On the interpreter we're now using BRepBuilderAPI_Transform to apply transformations on all generated shapes.
Fixed also the mirror point/line/plane tools. Visually the shapes look ok.
We don't fully understand yet how OpenCascade generates shapes in cases like mirroring (with a reversed local coordinate system and a transformation on them), in time this area will be improved.

Array Pattern

2011-01-25T08:24:00.000-08:00

Array Pattern is now finished. The user can now draw an array of objects as described in the earlier post. The attached image shows array pattern in action. The board was generated with the help of one of the initial rectangles. for the sphere, 2 array pattern were used, each with 2 rows and 8 colomns.
Be careful though, because array pattern is made in the current drawing plane. This means that hovering the mouse over surfaces or faces, might change the drawing plane without giving any warning :P
The array pattern is available in the last nightly build. Please post on the forum if you want to comment about anything about it.

Boo-gfixes and updates

2011-01-24T12:54:00.000-08:00

As my previous development was more or less related with Boo integration (and some other development, mostly on fixing) Samy found on usage some bugs and here are those fixes:
- Boo will have an option to evaluate (or not) your double based values. This will bring faster response time when you will input values (because to evaluate 5+5 will mostly imply a small class compilation)
- when Boo Gear was made some Boo compiler bugs were encountered which makes NaroCAD to take the version their Git. This made that the old Boo compiler version accepted a construct (that after review, I found that was a mistake) and the new version give correctly a compiler error. This affected using Export to Boo plugin so I've fixed this
- BooView for this very reason will not enable the Execute button when compiler error are pending. This will remove the annoyance and discomfort for people did not look down and make a small typo and will be bombarded with Boo messages. Anyway, if you're fast, you can still get them (like writing ; and go as fast as possible to Execute button before is disabled)
- solver's visual hints were bad placed, so I've found why: the TextOut method in OpenCascade API seems to not position them right on the coordinate, but is sensible also to the width/height factor, so this is fixed now :)

Array Pattern - first steps

2011-01-24T07:52:00.000-08:00

I started to implement the array pattern command. It can be used to make something similar with a chess board.
Before starting the command, the user will select the desired object to pattern and a direction. It seems pretty normal that array pattern should work in a plane. This is why I will use current drawing plane as the pattern plane(without asking the user). So, be careful with the drawing planes. But still, the drawing plane is not enough to even start the command. It is pretty obvious that the rows have some king of direction; the same goes for the colomns. this is why I will ask the user to select the row direction. Still, I will not ask the user to select the colomns direction because it must be perpendicular with the rows direction. So, NaroCAD will do it for you. 4 more parameters are: the number of rows and colomns and the distance between the objects(row distance and colomn distance).
The row direction will depend on how the line is drawn: from the first point, to the second point. Due to the fact that the patterned objects might not appear in the desired direction, I added 2 check-boxes in order to allow the user to reverse the desired direction, if necessary.
With this functionality, I hope that I covered everything a user needs in order to make an array pattern. If you have any new ideas, or wish to ask questions about this command, do not hesitate to post on the forum. The command will be available tomorrow in the last nightly build.

Boo Shapes Plugin (Part IV)

2011-01-21T11:08:00.000-08:00

And the last part. Probably for a regular polygon (and a gear) seems to be described in too many blog posts. Anyway, they do stress development in the idea that NaroCAD will have more external code in its package. Library shapes infrastructure support was the next logical and I will explain it using this shown diagram.
Let's say you will want to draw an OpenCascade shape: you will have to define a function that draws the topological shape, after this an action will use a NodeBuilder to instantiate it, to create it's corresponding shape, to set up extra attributes and at the end will put it in document.
A LibraryShape implementation works in a similar way with a Function (a shape generator) but instead using low level OpenCascade calls, will use Functions and will do it by using directly NodeBuilder and document.
So in this manner actions can take one step further and generate complex shapes on top of already existing shapes in NaroCAD (mostly as shapes are any item you will see on your tree of objects).
As Functions wrap OpenCascade code (so it need to be written just once!), they will need a component to get parameters. This component is the dependency part: this will make notifications automatically. So you will get both shape generation and propagation for free.
A library Shape will have dependencies, or arguments, but they will simply mean a creator framework. So a gear is simply defined as: tooth count, smaller range, bugger range and extrusion value. A regular polygon is defined as two points (center, the second to define its range) and the edges count.
Both will iterate and create the result combining functions (in both cases are lines, auto-face and an extrude).
The last fixes and improvements permit not only to register those LibraryShape globally as a function, but to you to be able to write them both in C# and in Boo (in fact the yesterday's screenshot was rewritten in Boo), and will make possible to change this script dynamically.
In fact the code was made accessible to make possible that from one LibraryShape to access another shape.
So if in future I want to make a gear with a hole in it, where is it's revolution axis, I will instantiate a gear, I will create an cylinder where I want to make extrusion happen, and at the end I will do a boolean substract between two.
So in fact the possibilities are much greater as the level of accessing shapes is at a much higher level than OpenCascade is.
At the end, you will get huge possibilities by customizing Library Shapes and if you don't know how to create a shape, just use the BooExporter plugin to your simple shapes as starting point and add loops and your extra tricks.

Circular Pattern

2011-01-21T07:59:00.000-08:00

This command allows the user to generate shapes along a line, at a specified angle. The main purpose of this command is to generate shapes that can be used to draw stairs . Due to the user-friendly parameters, the user can also choose a 0 height. This way, the circular pattern command can be used in 2D.

Circular pattern is described in better detail in the forum and in NaroCad documentation. You can download the last nightly, where the last version of circular pattern can be found. Please tell me in forum if there are any other options you would like to have in circular Pattern.

The attached image show a 2D and 3D circular Pattern.

Boo Shapes Plugin (Part III)

2011-01-20T12:44:00.000-08:00

Almost succeeded to make Boo shapes to have library like coding.
This code have little relation with the previous post about Boo shapes. The previous code was to export your code to Boo, to make possible to "survive" to NaroCAD XML document changes.
This code changes are shapes that if they implement ShapeLibrary class (or for Boo: BooShapeLibrary) they are accessible in an unified way and they can be made to NaroCAD as composed shapes.
I've bin hit by some Boo compiler bugs so this is a new BooShapeLibrary class defined which did make me to not finish yet (probably tomorrow or over the weekend will be last issues pinned down).
What will mean for now? That will be defined two actions/shapes (regular polygon and gear) as live shapes and the code will be separated by a contract based design, and as in future if desired any complex shapes can be defined using the same template, will make possible to define and compose shapes from here. So both gear and regular polygon are defined on top of simple shapes. Another part is that you can define complex shapes from both from Boo/C# and looking from BooGearPlugin source-code you can identify easier where is shape creation and where is event creation. This is important for complex shape creation and when you want to separate preview from code.
What may mean for future? It may mean that a Library View may be added and will expose all those shapes in an unified manner, and all dependencies will be solved in a similar fashion as MetaActions/Property grid. At the end you will be able to benefit from shapes that will be hard to be defined just from clicks, but also imply some more complex definition with relation with extern code and some default values that also may be provided as shape dependencies.

10.000 ...

2011-01-20T03:21:00.000-08:00

Hello world, we are here... today we just reached 10000 downloads.
We cannot do it without you and we are really happy to achieve it.
Also we just hope that you will enjoy what we will add to NaroCAD in future to be the best Free/OpenSource CAD you can use.

Boo Shapes Plugin (Part II)

2011-01-19T16:12:00.000-08:00

One hard category of bugs that NaroCAD can fix are those bugs that are reported in one version and we have no clue if they are fixed or regressed on shapes that are sometimes just +0.0.1 newer.
The reason is that at times for the very good reasons we rewrite some data representation that makes NaroXml incompatible with earlier versions. Also another hard topic is that we (NaroCAD devs) do know what to do with Boo scripting (I think I'm the only one for now that masters how to use it to almost full potential) but for most users is hard to start.
So one of the best solutions I've found is this: the user creates a scene, and NaroCAD will generate it's Boo script. Also, the start of script will be exposed in BooScriptTemplate.boo file, so when you will want to add/extend your header of your script you will be more than easy to do.
This exporter will navigate throughout the entire scene and will make all constructions that may be needed to remake the scene based on interpreters. This design will permit that in future (or by other developer that wants to export information like layers, colors (which are not yet supported for now) to be able to extend this code. Also will make this code less fragile if big format changes will happen. At the end this code is separated in a plugin, so you may enable just if will make sense to you to update your NaroCAD files. In this way is a nice way to have guaranteed that your hard done scenes will not be lost over changes that happen from time to time in NaroCAD internal format. And if those changes will happen, eventually the Boo script is exposed and you will be able to fix it with replaces.
At the end you are are encouraged to make shapes and to try to combine with Boo to get all power available to make your complex designs to shine.

Boo Shapes Plugin (Part I)

2011-01-17T14:10:00.000-08:00

I am working to make some "high level shapes" like the gear or a regular polygon as part of NaroCAD accessible via actions. This work is directed in two parts: to make at least as a sample how to integrate Boo shapes to NaroCAD, and to reuse as much code in a possible future library of Boo based shapes.
The first part may be more or less clear for developers, but in short is to make the code to implement an extra action of a boo based shape as short as possible.
The second part will not create a library before of release, but will provide a framework to make a Boo shape to explicitly show it's dependencies and those can be solved by two ways: via an action (like for every required point will give the coordinate) or via a dialog (think to property grid). As property grid in itself may be a bit big to handle in a stable way all cases (and some questions appaear if the action works on an external shape, as an action can be theoretically to change the selected shape transparency) may be implemented in subsequent releases.
But the separation between Action/Boo shapes will be in an explicit fashion (at least this is intended to do).
Out of the topic, the build will separate the unit tests assemblies of out final installer. So you may not ask yourself why moq,dll is a part of final installer and what it does there.

Fixed (Again) Nant Building

2011-01-13T17:27:00.001-08:00

Visual Studio uses a build algorithm different from .Net standard one (named MSBuild) so Visual Studio may work if you will build with right click and build, but when you will want to make your NaroCAD automated build, you may notice issues that the build will fail with a WPF related error. I've pin down why the error appear, and I fixed putting the direct class name. Anyway this fix will likely will not stand for long as much as most people will still use Visual Studio/SharpDevelop. Another issue is that the command line will fail initially, but will generate the assembly so you can do more iterations until the build will pass.
So if you will find errors when you will try to launch the build script via nant tooling (under Lib\Install folder) and your build will give to you errors related with WPF/Xaml properties that are not found, just execute it once or twice and most likely the build will eventually pass. If you will just take the code from lordcip branch, you will not have issues, but anyway, if you will see those kind of build breakage, it will be nice to contact me and I will pin them down and fix them.

New Selection Code

2011-01-12T13:11:00.000-08:00

Selection Code is advancing by making able to select AIS_InteractiveObjects as TopoDS_Shapes too. This simply means that you can delete right now dimensions. Also you can select shapes that are related with it, like: radius circle constraint and so on.
Enjoy using the new selection mode!