3D visualization of Kinect skeleton

by abenedik 11. April 2014 10:14

In this blog post I will show you how easy is to show Kinect skeleton as a 3D model.

Ab3d.PowerToys Kinect sample

To jump start into 3D programming we will be using WPF and Ab3d.PowerToys library. The library will help us with providing the standard 3D models that will be used to display the skeleton and cameras that can be easily controller by the user.

The image above shows us that the skeleton is created from yellow spheres that represent the joints and bi-pyramids are used to connect the joints together. To make the sample more interesting the skeleton has a Darth Wader’s head. Below the skeleton model a 3D wire grid is shown. It represents the floor.

In the lower right corner three different types of arrow buttons are shown. They can be used to control the camera – move, rotate and zoom in / out the camera. They are created by simply adding CameraControlPanel to the Window. Camera can be controlled also without using buttons. The MouseCameraController lets you rotate the camera with holding down the left mouse button, zoom in and out with mouse wheel and move the camera with holding control key and left mouse button. The MouseCameraController also provides easy way to specify different combinations of keys and mouse buttons for rotate and move actions.

Before diving into the code that shows the 3D model, let’s quickly look how we get the required 3D data from Kinect. Kinect SKD can provide real time skeleton and depth data. To make the sample work without having an actual Kinect device and an actual actor in front of the sensor, the Kinect data was saved into files with using Kinect Toolkit (an open source helper library). This way we can replay the recorded data any time we want.

For each recorded frame we get data for all recorded skeleton models. For each skeleton we get collection of joints and BoneOrientation objects. With them it is quite easy to get the actual 3D positions of the joints and the transformations (rotations and translations) applied on each of the joint. Once we have that data we can start on code that will show our 3D model.

In our sample we can show the 3D model in 4 different ways.  User can change that by selecting different value in the “Skeleton display mode” ComboBox. The following are the available options:

  • Lines,
  • Pyramids,
  • BiPyramids,
  • TransformedBiPyramids


Using 3D lines

The simplest solution to show 3D model is to show it with 3D lines. Actually, if we would be using only standard WPF 3D objects without Ab3d.PowerToys, this would be the hardest solution to implement. The problem is that WPF 3D does not have native support for 3D lines and therefore they need to be created manually by defining the triangles that would show 3D line. Luckily Ab3d.PowerToys library adds that support to WPF. With the Ab3d.PowerToys library the code to add 3D line between two joints is the following:

AddSkeletonLines(Point3D startPoint, Point3D endPoint)
{
    var lineVisual3D = new LineVisual3D()
    {
        StartPosition = startPoint,
        EndPosition = endPoint,
        LineColor = Colors.Green,
        LineThickness = _skeletonThickness * 100.0
    };

    Placeholder3D.Children.Add(lineVisual3D);
}

The following image shows how the skeleton is shown when using 3D lines:

Ab3d.PowerToys Kinect sample

Note that it is very easy to define the line thickness.

Using pyramids

Using 3D lines already gives you some 3D feeling of the model, especially because you can rotate the camera around the model and observe it from any angle.

To give the model a better 3D look, we will use 3D pyramids to connect joints.

Because we need to orient the pyramid model based on start and end position, we cannot use standard pyramid model from Ab3d.PowerToys library. Instead we need to use a low level object - DirectedPyramidMesh3D. It can create a MeshGeometry3D that represent a pyramid oriented in such a way that the pyramid’s center is defined by start point and the pyramid’s top is define by end position.

The following screenshot shows the skeleton displayed with pyramid:

Ab3d.PowerToys Kinect sample

Using bi-pyramids

Pyramids already gave us a better 3D representation that is more similar to actual 3D person model. But this can be further improved with using bi-pyramids. Bi-pyramids are objects that are created with combining two pyramids together.

We could easily create bi-pyramid with using two objects created with DirectedPyramidMesh3D. All we needed to do is to use the end position of the first directed pyramid as the start position of the second directed pyramid.

But to demonstrate some advanced features of the Ab3d.PowerToys we will create bi-pyramids with using lathe 3D objects. Lathe 3D object is an object that is defined by a 2D shape and start and end position. The 2D shape is than rotated around an axis defined by start and end position. This creates a 3D object – typical lathe objects are glasses and vases.

The following image shows a screenshot from samples that come with Ab3d.PowerToys library and show how a lathe 3D object was created (the 2D shape is shown on the right with red line):


The 2D shape used to define the lathe object is defined by LatheSections. Bi-pyramid is actually one of the simplest lathe objects possible – it requires only one section definition. This section defines how wide the bi-pyramid is.

After implementing the creation of bi-pyramids our skeleton looks like the first image in this blog.

From the list of display mode options you can see that it is also possible to show the skeleton as TransformedBiPyramids. This option shows the same skeleton as with bi-pyramids, but instead of using start and end position to define the object orientation, this time the transformation of the joint is used to rotate the bi-pyramid. This option provides a possible optimization. It can be achieved by creating the bi-pyramid model only once and then apply different transformation to it.

Similar optimization was used for showing joint spheres. Here we create only one instance of sphere GeometryModel3D and then use different transformations to position and scale the individual joint models around the skeleton.

The only thing yet to describe is how the head was created. We used a Darth Wader image and use it as a texture shown on a 3D plane. Once we have the position of the head and a head transformation, it is super easy to add Darth Wader head to the skeleton:

// Add head - show image for head
var headPosition = skeleton.Joints[JointType.Head].Position.ToPoint3D(_skeletonScale) + offset;

var headPlane = new PlaneVisual3D()
{
    CenterPosition = headPosition,
    Material = _headMaterial,
    BackMaterial = _headMaterial,
    HeightDirection = new Vector3D(0, 1, 0),
    Normal = new Vector3D(0, 0, 1),
    Size = new Size(_skeletonScale * 0.3, _skeletonScale * 0.3),
    Transform = skeleton.BoneOrientations[JointType.Head].AbsoluteRotation.ToRotateTransform3D(headPosition)
};

Placeholder3D.Children.Add(headPlane);

Adding special model for head finishes our 3D visualization of Kinect skeleton.

As you have seen, having the right tools makes the job very easy. And Ab3d.PowerToys library contains the ultimate collection of tools to add 3D content to your .Net application very easy. More about the library can be read from Ab3d.PowerToys web page.

The sample with full source code is available with Ab3d.PowerToys library. The trial version of the library can be downloaded from downloads page.

Tags:

Ab3d.PowerToys

New version of Ab3d.PowerToys with better wireframe support and many other improvements

by abenedik 2. April 2014 21:19

I am very happy to announce that a new version of Ab3d.PowerToys is available.

The biggest new feature of the new version is a new WireframeVisual3D class. It can be used to show a 3D model with wireframe rendering. You just need to set a 3D model to OriginalModel property (or set the model as content in XAML) and then decide how you want to show the model and set the WireframeType property accordingly – you can show the model as wireframe only, as wireframe with solid model (can be also used to create wireframe with hidden lines) or as solid model only. What is more, the wireframe color can be fixed (for example all lines black) or the color of the lines can be determined by the color of the model’s material. The same choice can be made for solid model – it can be shown with original color or with fixed color.

The following two screenshots show two sample usages (screenshots from new samples that come with the library):

<visuals:WireframeVisual3D WireframeType="WireframeWithSingleColorSolidModel"
 LineThickness="2" UseModelColor="True" SolidModelColor="Black" > 
     <GeometryModel3D> …

WireframeVisual3D sample 1

 


<visuals:WireframeVisual3D WireframeType="WireframeWithOriginalSolidModel"  LineThickness="2" LineColor="Black" UseModelColor="False" >      <GeometryModel3D> …

WireframeVisual3D sample 1

 

What is more, the code in the new DXEngine (DirectX rendering engine that is being developed by AB4D) is specially optimized to render the wireframe and solid model in the most efficient way.

The new Ab3d.PowerToys also uses an improved algorithm for triangulation. Triangulation is used to create a 3D model (define triangles) from a 2D polygon. The code in the previous version used another version of algorithm that had some problems with some of the polygons. The new code is much better and should handle all possible polygons. But it does not support polygons with holes.

There is also a new DirectedPyramidMesh3D object that can be used to create a pyramid that is facing its peat to the specified direction.

And as always there are also some other improvements and bug fixes. The following is a list of all the changes:

  • Added WireframeVisual3D to simplify showing models with wireframe.
  • Improved triangulator - before in some cases a wrongly triangulated object was returned or an "Improperly formed polygon" error was thrown.
  • Added DirectedPyramidMesh3D to create a pyramid object that is oriented in a specified direction.
  • Added Ab3d.Utilities.ModelUtils class that contains ChangeMaterial (change material on all child Model3D objects) and CopyModel (copy child Model3D objects) methods.
  • Improved 3D Lathe creator - now it is allowed to specify only one segment when start and end positions are closed.
  • Added GetPerpendicularVectors to MathUtil - calculate two vectors that are perpendicular to the input vector.
  • Fixed calling PreviewCameraChanged and CameraChanged events when CameraWidth is changed in Orthographic camera.
  • Fixed Point3DTo2D and Rect3DTo2D if size of Viewport3D is changed or if CameraWidth in Orthographic camera is changed.
  • Added Dump extension methods that can dump (write to Debug console) various WPF 3D objects (Matrix3D, Model3D, Geometry3D, Transform3D, Material, Rect3D). This is very useful to get detaled information in Visual Studio Immediate Window - Window – for example you can write "Ab3d.Utilities.Dumper.Dump(myModel3D)".
  • Added GetWorldToViewportMatrix method to BaseCamera.
  • Fixed Creating wireframe with WireframeFactory when model groups have transformations.
  • Cleaned the code to remove compiler warings when compiling source code.
  • Added overrides to CreateWireframe with additional removedDuplicates parameter - when the parameter is true this can significanlty increase time to create wireframe model, but creates less lines because duplicate lines are removed (this was used in the previous version). Not it is possible to set removedDuplicates to false to greatly reduce the initial creation time but end up with having more 3D lines. This can be user when rendering the lines with DXEngine were rendering lines is super-fast compared to WPF 3D where it is very slow.
  • Added Microsoft Kinect 3D player sample.

 

The list of changes in the Ab3d.PowerToys library ends here. But this is not everything that is new is the new version. There is also a brand new sample project. It was developed with help of a customer that wanted to show the 3D skeleton that was captured with Microsoft Kinect with a 3D model where the user can rotate the camera around the model.

The sample showed again that when having the right tools (Ab3d.PowerToys in this case), it is very easy to create an application that show 3D models and allow user to rotate and move the camera around. You can check the sample with downloading the latest version of the library (note: you will need to install Microsoft Kinect SDK). I will write a separate blog post with more details about that sample in the following days. For now here is a screenshot of the sample:

WireframeVisual3D sample 1

Tags:

Ab3d.PowerToys

Special offer and new price for Ab3d.PowerToys

by abenedik 29. November 2013 20:08

Let’s start with the good news:
All products on AB4D.com are 20% off until the end of December 2013.

This makes December the best time to buy new products or renew the license. Even if your license is not close to expiration yet, it is worth buying a renewal now and get additional year of free upgrades and priority support.


Now to the other news:
After 1st January 2014 the following licensing changes will happen:

  • price for Ab3d.PowerToys will increase,
  • reader libraries and viewers will be sold only as pro licenses (no more basic licenses).


The Ab3d.PowerToys library has been improved many times in the last years and now has really a lot of features. With the latest version the library also got obj file reader so it is possible to import 3D models from obj files. This means that in most cases you do not need the Ab3d.Reader3ds library any more (see the previous blog post for the differences between 3ds and obj file to check if you still need 3ds files).

The new prices for Ab3d.PowerToys will be:

  • Single developer license price: $399
  • Team developer license price: $799
  • Site developer license price: $1599
  • Price for source code will remain the same at $490

Another change related to this price increase is that it will not be possible to buy both Ab3d.Reader3ds and Ab3d.PowerToys for the price of Ab3d.Reader3ds + 1 USD (getting Ab3d.PowerToys for 1 USD). After 1st January you will still be able to get both libraries with discounted price, but this time the discount will be 30% of the total price.

Another licensing change is that from 1st January 2014 on only Pro version of reader libraries and viewers will be sold. This means that it will not be possible to buy basic version of Viewer3ds or basic version of Reader3ds. The reason for that is that very little basic licenses were sold and that this concept added quite some confusion when potential customer tried to decide which version to buy. So from 1st January on instead of 4 types of licenses only 2 types will be available: one with viewer only (Viewer3ds, ViewerSvg or Paste2Xaml) and the other with library license (Ab3d.Reader3ds with Viewer3ds, Ab2d.ReaderSvg with ViewerSvg, Ab2d.ReaderWmf with Past2Xaml).

So to conclude in a better tone, I would just like to say that the Ab3d.PowerToys price increase is just another very good reason to buy the license renewal now.


Tags:

Ab3d.PowerToys | Reader3ds | ReaderSvg | ReaderWmf

Read 3D models from obj files with new version of Ab3d.PowerToys

by abenedik 29. November 2013 13:40

Ab3d.PowerToys library continues to get great new features. The new version gets ability to read 3D models from obj files. This adds a great new value to the Ab3d.PowerToys library because now it is possible to import 3D objects directly with the library.
Obj file format is very common file format to store 3D models. The model data is written in simple text format.

The following screenshot shows a 3D ship model that was read with the new Ab3d.ReaderObj library:
ReaderObj screenshot

Because now it is possible to import 3D models only with Ab3d.PowerToys library, the question arises if we still need Ab3d.Reader3ds library to read 3ds files. The following are the main differences between obj and 3ds file format:
obj is a text file; 3ds is a binary file,

  • 3ds file can define hierarchy of 3D objects with object transformations; obj file does not support hierarchies and transformation,
  • obj file does not support animations,
  • 3ds file is not capable of storing texture file names that exceed the 8.3 format; file names in obj file can be in any length.



The main difference is that animations and object’s hierarchies are supported only by 3ds files. For example if you need to create 3D objects similar to that used in Robotarm sample where rotating one part of the robot also rotates all child objects, you will need to use 3ds files to store the hierarchies.
Anyway obj files are still very common to store simple 3D models.

I would also like to mention that the code that is used to read obj files is highly optimized to parse the values from text files very fast. Also when common methods like Split and Regex are used to parse large text files in .Net with the memory usage can be very high – many string instances can be created. The code in ReaderObj class has been optimized also in regard to memory usage to minimize the creation of many string instances.

The version also has the following new features and bug fixes:

  • Fixed performance of LinesUpdater when the camera or other property is not changed (before lines were recreated every time, now only when they need to),
  • Added additional override of Dumper.Dump with Model3D as paramter to write Model3D info to Visual Studio output or immediate window.


The new version also comes with a new very interesting arrows sample that animate the arrows in a very nice way. The following screenshot show the sample:
Arrows sample screenshot

You can also see the new sample in a new video that also shows some other samples.

Tags:

Ab3d.PowerToys

New major release of Ab3d.PowerToys library available

by abenedik 22. October 2013 21:04

I am really happy to announce that the v4.0 of Ab3d.PowerToys is now available. It brings tons of new features and updates. The most important new features are:
-    Added polygon triangulation, creating extruded and lathe 3D objects,
-    Improved EventManager3D for even simpler usage of mouse events on 3D objects,
-    Added support for upcoming Ab3d.DXEngine library that will be able to render WPF 3D graphics with full DirectX 11 hardware acceleration.
-    Many new very interesting samples that show how easy is to create amazing 3D applications.

Polygon triangulation is a technique that converts a 2D polygon into triangles that can be used to define a 3D object. This makes it easy to create extruded objects – object that are created with extruding a 2D shape into a 3D world. The following image shows a screenshot from a sample that demonstrates those two techniques. The 2D shape is defined on the left side. It is the base for the 3D object that is shown on the right.

Ab3d.PowerToys Extrude

Lathe 3D objects are objects that are created be rotating the shape around an axis. The following image screenshot is taken from the sample that demonstrates how to create lathe objects. On the rights side the shape is defined by drawing the red lines. It is then rotated around up axis and the 3D object shown on the left is created. As seen on the 3D object it is also possible to define which edges are hard and which are soft.

Ab3d.PowerToys Lathe creator

Because we can now easily create lathe objects, we can also easily create 3D arrows. They can be created with the new ArrowMesh3D, ArrowVisual3D or ArrowUIElement3D objects. The following image shows many 3D arrows with different colors (screenshot from the new sample - still under development).

Ab3d.PowerToys Arrows sample

As mentioned before, another big improvement in this library was made with EventManager3D. EventManager3D can be used to simply subscribe to 3D objects just as they were normal FrameworkElements. For example the following code subscribes to some mouse events:

var eventSource3D = new Ab3d.Utilities.VisualEventSource3D(MyBoxVisual3D);
eventSource3D.MouseEnter += OnBoxMouseEnter;
eventSource3D.MouseLeave += OnBoxMouseLeave;
eventSource3D.MouseClick += OnBoxMouseClick;

var eventManager = new Ab3d.Utilities.EventManager3D(MyViewport3D);
eventManager.RegisterEventSource3D(eventSource3D);

The new version of Ab3d.PowerToys adds the following additional functionality to the EventManager3D:

 

  • Added RegisterExcludedVisual3D and RemoveExcludedVisual3D methods to EventManager3D – used to define Visual3D objects that are excluded from hit testing.
  • Added CustomEventsSourceElement property to EventManager3D - it can be set to any FrameworkElement that will be used as source of mouse events instead of TargetViewport3D.
  • Added MouseMove event to EventManager3D.
  • Added FinalPointHit to all EventArgs used in EventManager3D event handlers - it gets the transformed 3D point that was hit by the mouse (if Visual3D uses Transformation, than HitPoint will be wrong, but FinalHitPoint will be transformed).

Ab3d.PowerToys can help you in all stages of development – also during debugging. In the Ab3d.Utilities.Dumper there are many methods that can be used to get nicely formatted info about MeshGeometry3D, Model3D, Transform3D, Material or Matrix. With the new version it is now possible to specify the format string used to format the values (this allows control of the number of displayed decimals). The new version also adds two new methods to Dumper class: DumpMeshInitializationCode and GetMeshInitializationCode. They can be used to generate the complete c# source code that can be used to create the MeshGeometry3D with all the Position, TriangleIndices, etc.

This is not all. The following are the additional new features and fixes:

  • Added CreateMouseRay3D to BaseCamera - it can be use used to calculate the 3D ray that goes from the mouse position into the 3D scene.
  • Improved Refresh method in LinesUpdater - calling this method now forces to redraw all visible lines.
  • Added MaxLineArrowLength and LineArrowAngle to LinesUpdater to better control the size and shape of the arrows on 3D lines.
  • Fixed LineWithTextVisual3D when it was created in code behind and the properties were set without using BeginInit and EndInit methods.
  • Fixed recreating the content of 3D objects derived from Visual3D (if initially IsVisible was set to false and was then set to true the object was not shown under some circumstances).
  • Added many possibilities to change the CameraAxisPanel with overriding CreateAxisVisual, SetAxisLength, SetAxisColors or EnsureAxisTextBlocks (the later also existed before)
  • Improved performance of Box3D geometry mesh creation when X, Y and Z segments count is 1 (simple box with 2 triangles for one plane) - the mesh is now created 10 times faster.
  • Moved initialization of RotationCursor in MouseCameaController from constructor to OnLoad event handler - this prevented calling virtual method in constructor.

Besides new features in Ab3d.PowerToys there are also some new very interesting samples that demonstrate the use of the library. Extrude and Lathe samples were already mentioned. I would also like to show the screenshot of the new “Distance measurement” sample:

Ab3d.PowerToys 3D distance measurement sample

The sample uses HeightMap (also part of Ab3d.PowerToys), 3D lines and custom hit testing (uses CreateMouseRay3D method on camera) to show the distance between two points in 3D world.

Another interesting new sample is Objects inspector. It can display many information about the selected object – shows individual triangles with TriangleIndice index, normals, all positions, XAML text and other data. The following is the screenshot of the sample:

Ab3d.PowerToys Objects inspector

Lastly, the new version of Ab3d.PowerToys adds support for the upcoming Ab3d.DXEngine.

The Ab3d.DXEngine is a brand new 3D rendering engine that can render WPF 3D graphics in hardware accelerated DirectX 11. This means a huge performance boost and what is more it allows many customizations and tweaks of the displayed graphics. Do not get me wrong – I still think that WPF 3D is great for business applications that need 3D graphics. But it has its limits. When it comes to very complex 3D objects, the existing rendering engine based on DirectX 9 just cannot use the full power of the GPU. Another limitation is that the current WPF 3D engine is a closed box – you cannot extend it in any way. If you would like to use some other shading technique, this is not possible. Even simple task as showing 3D lines is kind of a hack in WPF 3D. What is more, the new engine can be used with just very minimal change in the code.

The new engine will be soon ready for the first alpha version. But before going public with the new engine, I would like to test it with some of our partners. I already have a few interested Ab3d.PowerToys customers that would like to try the new engine. If you are interested in that, please contact me to our email or with using Feedback page.

Tags:

Ab3d.PowerToys

New maintenance release for almost all products published

by abenedik 15. October 2013 23:02

After quite a long time I am happy to announce that a maintenance release for the following products has been released:

  • Ab2d.ReaderSvg with ViewerSvg,
  • Ab2d.ReaderWmf with Paste2Xaml,
  • Ab2d.ZoomPanel,
  • Ab3d.Reader3ds with Viewer3ds.

 

New version mainily include some bug fixes and improvements that were created based on users feedback.

The following is the what's new list:

 

Ab2d.ReaderSvg

  • Fixed reading text with gradient fill or stroke brush.
  • Prevent throwing exception when incorrect number text was used for numbers.
  • Invisible objects (Visibility != Visible) are not exported to geometry any more.
  • Shapes with Opacity set (Opacity < 1.0) are now correctly exported as geometries.

 

Ab2d.ReaderWmf

  • Added reading images from EMR_ALPHABLEND records. Note that usually those images are not rendered correctly because the blend dwRop operations are not supported by WPF, but at least user can get the image and convert it manually to a transparent image that could be used to achieve correct results.
  • Added ResolveBitmapOperation that is called in processing EMR_ALPHABLEND record - here the user can change the bitmap to get correct results - for example convert black to transparent.
  • Invisible objects (Visibility != Visible) are not exported to geometry any more.
  • Shapes with Opacity set (Opacity < 1.0) are now correctly exported as geometries.

 

Ab2d.ZoomPanel

  • Fixed using ZoomPanel under some circumstances when viewbox limits is set.

 

Ab3d.Reader3ds

  • Small fix for a problem that can occure when one object has multiple materials assigned.
  • Improved reading broken files - no exception is thrown when the animation data for camera is broken.

 

You could say that this is not much for quite a long time since last update. And you would be right.

The reason for that is that I am preparing a new major release of Ab3d.PowerToys which will be hopefully ready until beginning of the next week. It will have much much more to show.

And that is not all. With the release of the new version of Ab3d.PowerToys I will also announce a brand new project that I have been working on for almost a year. I am very excited about that project and I am sure you will also like it.

Tags: , , ,

Reader3ds | ReaderSvg | ReaderWmf | ZoomPanel

TrueTransform added to ReaderSvg and ReaderWmf

by abenedik 21. June 2013 10:16

For quite some time it was possible to transform the read objects in ViewerSvg and Paste2Xaml. I am not talking about simply adding a transformation to read objects but to actually change all coordinates, sizes and other values with the specified transformation.

For example after reading a svg file we get the following xaml (some common properties were removed to simplify the xaml):

<Canvas Width="422.425" Height="208.895">
    <TextBlock Text="text1" FontSize="10" Canvas.Left="68.571" Canvas.Top="103.145"/>
    <Path Stroke="Black" StrokeThickness="3" StrokeMiterLimit="2" 
          Data="M366.43,67.029C358.951,54.888 368.807,24.872 384.677,34.264 394.346,39.986 389.365,72.847 384.677,80.68 384.384,71.342 374.133,66.51 366.43,67.029z"/>

In Export dialog in ViewerSvg it was possible to transform this with specifying custom width (instead of 422.425) we could set the width to 100. After transformation the xaml is:

<Canvas Width="100" Height="49.5">
    <TextBlock Text="text1" FontSize="2.368" Canvas.Left="16.233" Canvas.Top="24.441"/>
    <Path Stroke="Black" StrokeThickness="0.711" StrokeMiterLimit="2" 
          Data="M86.744,15.883C84.974,13.006 87.307,5.894 91.064,8.119 93.353,9.475 92.174,17.262 91.064,19.118 90.995,16.905 88.568,15.76 86.744,15.883z"/>

 
As seen from xaml, the transformation changed the FontSize, position in canvas, StrokeThickness and also path data. ViewerSvg and Paste2Xaml used an internal TrueTransform class that performed the transformation.

This can be very useful in many cases:

  • When creating graphics for WPF, Silverlight or WinRT the graphics elements can be created in a drawing application and can have any possible dimension. But if your application needs graphics element that would have size 100 x 100, it is very convenient to transform the graphics into the required dimensions.
  • Some drawing applications (for example Inkscape) allow users to draw in real units (in mm), but when the drawing is saved into svg file, all the units are converted to pixels. With using TrueTransform it is possible to convert the coordinates and other data back to mm units.


Now this functionally is available in Ab2d.ReaderSvg and Ab2d.ReaderWmf libraries also. This means that you can now also use TrueTransform in your applications.

The simplest way to use TrueTransform is to use Transform or TransformFromPixelsToMM methods on ReaderSvg or ReaderWmf class. The Transform needs two parameters: the first one is a Transform object (can be ScaleTransform, TranslateTransform, TransformGroup, or any other Transform); the second is a Boolean that specifies if the LastReadViewbox (property of ReaderSvg and ReaderWmf) is also changed – if true this means that GetXaml method will return the xaml of the transformed objects. The TransformFromPixelsToMM method can be used to transform from pixel to real units.

It is not only possible to transform the objects that are read from svg or metafiles but also almost any other objects – this can be done with Ab2d.Common.ReaderSvg.TrueTransform (or Ab2d.Common.ReaderWmf.TrueTransform) class.
 

ReaderSvg also got a new property – SvgCreator. It is an enum that is set after reading svg file and specifies the application that was used to create svg file. Currently the following applications are recognized: Microsoft Visio, CorelDraw, Adobe Illustrator and Inkscape.

 

There is also a new sample that come with ReaderSvg that demonstrates the new transformations.


As always if you are new to our tools, you are most welcome to download a 60-day trial from the Download page. Existing customers can get the updated versions from their User Account page.

Tags: ,

ReaderSvg | ReaderWmf