But as distressing as that was for some, it was also followed by the good news, in 2015, that part of Mantle’s DNA would be used as a basis for a new API, Vulkan, which was recently released, and which promises to do even greater things, and sustain a flexibility of use never-before seen.

To convince yourself of Vulkan’s capacity, I’ve made a list of some of its most surprising features. Let’s check them out:

1. It is a close to metal API for 3D graphics designed by AMD

First of all, what you need to know about Vulkan is that it is a low-overhead API intended for compute applications and 3D graphics. One of the things that makes it different, some would say superior, to its predecessors, is that it’s designed to run across different platforms and OSs.

As such, you’ll be able to use it on desktops, gaming consoles, tablets, and mobiles as well. Not only that, but it is be compatible with all major operating systems.

2. It ensures lower CPU load

The smart guys from Khronos did a swell job of making their new API as lean as possible, and less driver usage is just one of them. In order to deliver on low-overhead efficiency and cross-vendor portability (that’s right, you read that well: Vulkan is no longer limited to AMD GCN hardware), it uses simple drivers.

It features layered architecture, which makes validation and debug layers much easier to unload. Thus, the application is in charge of memory allocation and thread management. Vulkan has direct GPU control, and is a unified API to run on all types of platforms.

3. It has an ecosystem with three accessible layers

Some of you may have worried that although drivers will run smoother thanks to reduced error management, it will translate into more man-hours of work. That’s why Vulkan features three different levels that developers can access according to their different needs.

They are as follows:

• Direct use of Vulkan ensuring optimal control
• Access to libraries and layers that can make development faster
• Use fully optimized game engines over Vulkan

4. SPIR-V will replace GLSL

Vulkan will run on the SPIR-V intermediate language, which means it uses a translator to make the cross from GLSL. But this releases Vulkan from older OpenGL luggage and enables more flexible and reliable front-end language.

Game developers will be able to use OpenCL C kernels, and Vulkan back-ends. But thanks to the use of SPIR-V, Vulkan will be available across different platforms and devices, from mobile to high-end desktop.

5. It promises to make developer life easy

As you’ve already gathered, Vulkan is intended to streamline a lot of developer work. Besides suggesting the development of experimental languages, Khronos also promises a future of device-specific languages, shared tools and frameworks. Another bonus is the possibility for a lot more of processing to be done offline, more optimizations executed offline, and multiple source shaders.

6. It empowers independent devs and freelancers

This is primarily because Vulkan enables cross-platform programming. So if you’re working at home on your spare time, or as a freelancer, or work out of your own office as an independent, you will no longer need to use the same software as your employers or clients.

Moreover, it will be easier to develop your own projects. And here are just a few more benefits: kernel compilation time is reduced, and so is runtime shader. You will have complete control and visibility of memory allocation, and thus be able to tweak memory allocation. No more issues with cross-vendor portability.

7. The Vulkan is still growing strong

Instead of feeling disappointed that Vulkan still has a ways to go before it’s completed, you should be happy it looks and works so great already, and be excited that improvements and upgrades are yet to come.

Now you can really allow your imagination to run free with what you can already do with Vulkan, but with what Vulkan will be able to do in the future. 3D graphics and game programming have just become a whole lot easier and streamlined. Work that looks great, and runs great.

8. It still has a few weak points

I haven’t been trying to sell you on Vulkan just to reveal its disadvantages now, but I think there are sides to it that could still be improved. You should get the full picture of what the new API is, so that if you’re looking to start on a new project, you can weigh the pros (many, I believe) and cons (few, as you’ll see). For some of you, these may not even be concerns.

However, I think that many developers will find it a downside that Vulkan is less compatible with legacy hardware, and may be less effective on desktops. Since it’s a relatively new product, it doesn’t benefit from the same support as other APIs, and certain scenarios may lead to increased complexity of code.

Takeaways

Well, there you have it, folks! We may have to wait by the end of the year when Vulkan is released (or perhaps even longer until it starts to gain wider adoption), to see whether it will make a significant change in development, but I feel like Khronos are going in the right direction and sooner or later, this is the kind of API we’ll be wanting to use.

Even though I suspect Vulkan will catch on much faster and easier with mobile, I see that as advantage marketing-wise and product development-wise.

The post 8 Things You Need to Know About the Vulkan API appeared first on CAD Culture.

Computer-aided design software and computer-aided design hardware have been becoming more and more popular as time has gone on. Don’t recognise those long-winded names? We bet you’ve heard of the 3D printers making their mark in the manufacturing business.

CAD software like Rhino 3D is used in a wide range of industries, from interior and fashion design right through to architecture and vehicle structures. But why is it so popular? And why has the ever-popular jewellery industry jumped on the bandwagon?

The answer is that CAD has a versatility and number of benefits that cannot be seen in the traditional methods of design. Both traditional and contemporary methods are used by jewellery designers today, yet it’s fair to say that in many cases, CAD saves a lot of time…

A brief history of jewellery making

Before CAD and CAM existed, the traditional and most-used process to design and create jewellery required not only great skill, but a lot of patience.

Starting with a piece of paper and a pencil, the designer would sketch, rub out and re-sketch a design until it was completely perfect and accurate so it could be used to hand make the jewellery out of metal, or carve it out of wax to use in the metal casting process.

Once carved out of wax, it would go into the investment process before being placed in an oven. When the wax burned away, the preferred metal was poured into the cavity left by the wax – and voila!

If the designer or manufacturer wants to create duplicates of the original model, they would use rubber moulds. However, if they want a slight variation on the original, an entirely new model would have to be created.

The benefits of CAD in jewellery design

As we said, sounds quite time-consuming, right? Which is where both CAD software and CAM hardware steps in with its advantages when it comes to jewellery making, including:

• The steps of the process can be completed significantly quicker, depending on the design
  
• In many cases, CAD aids the accuracy of design and minimises time taken for ‘trial and error’
  
• Replications can be made more easily benefiting mass production
  
• Significantly cuts the cost on amount of materials used in previous methods
  
• Relatively easy to create variations, giving you a chance to express your creativity
  
• In many cases motifs can be ‘copied and pasted’ into other projects
  
• Aids in the design of smaller and more intricate features with zoom feature
  
• Can create photo-realistic images to give an idea of how the finished item will look
  

With CAD, changes can be made at the click of the mouse, and your project – with more detail than ever before – can be left to the incredibly intelligent CAM systems like 3D printers to become a reality.

Large replicated amounts, designs with variations and complex designs can be tackled by experienced designers using this software and hardware. Their precise and time-saving qualities just prove how technology has revolutionised the jewellery industry, among many other industries too.

Of course, design and engineering skills are necessary for both traditional methods and the contemporary method of CAD, which is why we offer specialist training in how to use CAD software, Rhino 3D to design jewellery.

Take a look at our Level 1 and Level 2 training courses, or to find out more, please don’t hesitate to get in touch.

The post How jewellery design has improved with technology appeared first on CAD Culture.

But as soon as we’ve solved all these complex differential equations another problems comes up. How do we understand and interpret the huge amounts of data coming out of these simulations? How do we visualize potential gigabytes of data, such as data with millions of grid points within a large simulation?

During my work on similar problems for my Master’s Thesis, I came into contact with the Visualization Toolkit, or VTK – a powerful graphics library specialized for data visualization.

In this tutorial I will give a quick introduction to VTK and its pipeline architecture, and go on to discuss a real-life 3D visualization example using data from a simulated fluid in an impeller pump. Finally I’ll list the strong points of the library, as well as the weak spots I encountered.

Data Visualization and The VTK Pipeline

The open source library VTK contains a solid processing and rendering pipeline with many sophisticated visualization algorithms. It’s capabilities, however, don’t stop there, as over time image and mesh processing algorithms have been added as well. In my current project with a dental research company, I’m utilizing VTK for mesh based processing tasks within a Qt-based, CAD-like application. The VTK case studies show the wide range of suitable applications.

The architecture of VTK revolves around a powerful pipeline concept. The basic outline of this concept is shown here:

• Sources are at the very beginning of the pipeline and create “something out of nothing”. For example, a vtkConeSource creates a 3D cone, and a vtkSTLReader reads *.stl 3D geometry files.
• Filters transform the output of either sources or other filters to something new. For example a vtkCutter cuts the output of the previous object in the algorithms using an implicit function, e.g., a plane. All the processing algrithms that come with VTK are implemented as filters and can be freely chained together.
• Mappers transform data into graphics primitives. For example, they can be used to specify a look-up table for coloring scientific data. They are an abstract way to specify what to display.
• Actors represent an object (geometry plus display properties) within the scene. Things like color, opacity, shading, or orientation are specified here.
• Renderers & Windows finally describe the rendering onto the screen in a platform-independent way.

A typical VTK rendering pipeline starts with one or more sources, processes them using various filters into several output objects, which are then rendered separately using mappers and actors. The power behind this concept is the update mechanism. If settings of filters or sources are changed, all dependent filters, mappers, actors and render windows are automatically updated. If, on the other hand, an object further down the pipeline needs information in order to perform its tasks, it can easily obtain it.

In addition, there is no need to deal with rendering systems like OpenGL directly. VTK encapsulates all the low level task in a platform- and (partially) rendering system-independent way; the developer works on a much higher level.

Code Example with a Rotor Pump Dataset

Let’s look at a data visualization example using this dataset of fluid flow in a rotating impeller pump from the IEEE Visualization Contest 2011. The data itself is the result of a computational fluid dynamics simulation, much like the one described in Charles Cook’s article.

The zipped simulation data of the featured pump is over 30 GB in size. It contains multiple parts and multiple time steps, hence the large size. In this guide, we’ll play around with the rotor part of one of these timesteps, which has a compressed size of about 150 MB.

My language of choice for using VTK is C++, but there are mappings for several other languages like Tcl/Tk, Java, and Python. If the target is just the visualization of a single data-set, one doesn’t need to write code at all and can instead utilize Paraview, a graphical front-end for most of VTK’s functionality.

The Dataset and Why 64-bit is Necessary

I extracted the rotor dataset from the 30 GB dataset provided above, by opening one timestep in Paraview and extracting the rotor part into a separate file. It is an unstructured grid file, i.e., a 3D volume consisting of points and 3D cells, like hexahedra, tetrahedra, and so on. Each of the 3D points has associated values. Sometimes the cells have associated values as well, but not in this case. This training will concentrate on pressure and velocity at the points and try to visualize these in their 3D context.

The compressed file size is about 150 MB and the in-memory size is about 280 MB when loaded with VTK. However, by processing it in VTK, the dataset is cached multiple times within the VTK pipeline and we quickly reach the 2 GB memory limit for 32bit programs. There are ways to save memory when using VTK, but to keep it simple we’ll just compile and run the example in 64bit.

Acknowledgements: The dataset is made available courtesy of the Institute of Applied Mechanics, Clausthal University, Germany (Dipl. Wirtsch.-Ing. Andreas Lucius).

The Target

What we will achieve using VTK as a tool is the visualization shown in the image below. As a 3D context the outline of the dataset is shown using a partially transparent wireframe rendering. The left part of the dataset is then used to display the pressure using simple color coding of the surfaces. (We’ll skip the more complex volume rendering for this example). In order to visualize the velocity field, the right part of the dataset is filled with streamlines, which are color-coded by the magnitude of their velocity. This visualization choice is technically not ideal, but I wanted to keep the VTK code as simple as possible. In addition, there is a reason for this example to be part of a visualization challenge, i.e., lots of turbulence in the flow.

Step by Step

I will discuss the VTK code step by step, showing how the rendering output would look at each stage. The full source code can be downloaded at the end of the training.

Let’s starts by including everything we need from VTK and open the main function.

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

int main(int argc, char** argv)
{

Next, we setup the renderer and the render window in order to display our results. We set the background color and the render window size.

// Setup the renderer
vtkNew renderer;
renderer->SetBackground(0.9, 0.9, 0.9);

// Setup the render window
vtkNew renWin;
renWin->AddRenderer(renderer.Get());
renWin->SetSize(500, 500);

With this code we could already display a static render window. Instead, we opt to add a vtkRenderWindowInteractor in order to interactively rotate, zoom and pan the scene.

// Setup the render window interactor
vtkNew interact;
vtkNew style;
interact->SetRenderWindow(renWin.Get());
interact->SetInteractorStyle(style.Get());

Now we have a running example showing a gray, empty render window.

Next, we load the dataset using one of the many readers that come with VTK.

// Read the file
vtkSmartPointer pumpReader = vtkSmartPointer::New();
pumpReader->SetFileName(“rotor.vtu”);

Short excursion into VTK memory management: VTK uses a convenient automatic memory management concept revolving around reference counting. Different from most other implementations however, the reference count is kept within the VTK objects themselves, instead of the smart pointer class. This has the advantage that the reference count can be increased, even if the VTK object is passed around as a raw pointer. There are two major ways to create managed VTK objects. vtkNew and vtkSmartPointer::New(), with the main difference being that a vtkSmartPointer is implicit cast-able to the raw pointer T*, and can be returned from a function. For instances of vtkNew we’ll have to call .Get() to obtain a raw pointer and we can only return it by wrapping it into a vtkSmartPointer. Within our example, we never return from functions and all objects live the whole time, therefore we’ll use the short vtkNew, with only the above exception for demonstration purposes.

At this point, nothing has been read from the file yet. We or a filter further down the chain would have to call Update() for the file reading to actually happen. It is usually the best approach to let the VTK classes handle the updates themselves. However, sometimes we want to access the result of a filter directly, for example to get the range of pressures in this dataset. Then we need to call Update() manually. (We don’t lose performance by calling Update() multiple times, as the results are cached.)

// Get the pressure range
pumpReader->Update();
double pressureRange[2];
pumpReader->GetOutput()->GetPointData()->GetArray(“Pressure”)->GetRange(pressureRange);
Next, we need to extract the left half of the dataset, using vtkClipDataSet. To achieve this we first define a vtkPlane that defines the split. Then, we’ll see for the first time how the VTK pipeline is connected together: successor->SetInputConnection(predecessor->GetOutputPort()). Whenever we request an update from clipperLeft this connection will now ensure that all preceding filters are also up to date.

// Clip the left part from the input
vtkNew planeLeft;
planeLeft->SetOrigin(0.0, 0.0, 0.0);
planeLeft->SetNormal(-1.0, 0.0, 0.0);

vtkNew clipperLeft;
clipperLeft->SetInputConnection(pumpReader->GetOutputPort());
clipperLeft->SetClipFunction(planeLeft.Get());
Finally, we create our first actors and mappers to display the wireframe rendering of the left half. Notice, that the mapper is connected to its filter in exactly the same way as the filters to each other. Most of the time, the renderer itself is triggering the updates of all actors, mappers and the underlying filter chains!

The only line that is not self-explanatory is probably leftWireMapper->ScalarVisibilityOff(); – it prohibits the coloring of the wireframe by pressure values, which are set as the currently active array.

// Create the wireframe representation for the left part
vtkNew leftWireMapper;
leftWireMapper->SetInputConnection(clipperLeft->GetOutputPort());
leftWireMapper->ScalarVisibilityOff();

vtkNew leftWireActor;
leftWireActor->SetMapper(leftWireMapper.Get());
leftWireActor->GetProperty()->SetRepresentationToWireframe();
leftWireActor->GetProperty()->SetColor(0.8, 0.8, 0.8);
leftWireActor->GetProperty()->SetLineWidth(0.5);
leftWireActor->GetProperty()->SetOpacity(0.8);
renderer->AddActor(leftWireActor.Get());
At this point, the render window is finally showing something, i.e., the wireframe for the left part.

The wireframe rendering for the right part is created in a similar way, by switching the plane normal of a (newly created) vtkClipDataSet to the opposite direction and slightly changing the color and opacity of the (newly created) mapper and actor. Notice, that here our VTK pipeline splits into two directions (right and left) from the same input dataset.

// Clip the right part from the input
vtkNew planeRight;
planeRight->SetOrigin(0.0, 0.0, 0.0);
planeRight->SetNormal(1.0, 0.0, 0.0);

vtkNew clipperRight;
clipperRight->SetInputConnection(pumpReader->GetOutputPort());
clipperRight->SetClipFunction(planeRight.Get());

// Create the wireframe representation for the right part
vtkNew rightWireMapper;
rightWireMapper->SetInputConnection(clipperRight->GetOutputPort());
rightWireMapper->ScalarVisibilityOff();

vtkNew rightWireActor;
rightWireActor->SetMapper(rightWireMapper.Get());
rightWireActor->GetProperty()->SetRepresentationToWireframe();
rightWireActor->GetProperty()->SetColor(0.2, 0.2, 0.2);
rightWireActor->GetProperty()->SetLineWidth(0.5);
rightWireActor->GetProperty()->SetOpacity(0.1);
renderer->AddActor(rightWireActor.Get());
The output window now shows both wireframe parts, as expected.

Now we are ready to visualize some useful data! For adding the pressure visualization to the left part, we don’t need to do much. We create a new mapper and connect it to clipperLeft as well, but this time we color by the pressure array. It is also here, that we finally utilize the pressureRange we have derived above.

// Create the pressure representation for the left part
vtkNew pressureColorMapper;
pressureColorMapper->SetInputConnection(clipperLeft->GetOutputPort());
pressureColorMapper->SelectColorArray(“Pressure”);
pressureColorMapper->SetScalarRange(pressureRange);

vtkNew pressureColorActor;
pressureColorActor->SetMapper(pressureColorMapper.Get());
pressureColorActor->GetProperty()->SetOpacity(0.5);
renderer->AddActor(pressureColorActor.Get());
The output now looks like the image shown below. The pressure at the middle is very low, sucking material into the pump. Then, this material is transported to the outside, rapidly gaining pressure. (Of course there should be a color map legend with the actual values, but I left it out to keep the example shorter.)

Now the trickier part starts. We want to draw velocity streamlines in the right part. Streamlines are generated by integration within a vector field from source points. The vector field is already part of the dataset in the form of the “Velocities” vector-array. So we only need to generate the source points. vtkPointSource generates a sphere of random points. We’ll generate 1500 source points, because most of them won’t lie within the dataset anyways and will be ignored by the stream tracer.

// Create the source points for the streamlines
vtkNew pointSource;
pointSource->SetCenter(0.0, 0.0, 0.015);
pointSource->SetRadius(0.2);
pointSource->SetDistributionToUniform();
pointSource->SetNumberOfPoints(1500);
Next we create the streamtracer and set its input connections. “Wait, multiple connections?”, you might say. Yes – this is the first VTK filter with multiple inputs we encounter. The normal input connection is used for the vector field, and the source connection is used for the seed points. Since “Velocities” is the “active” vector array in clipperRight, we don’t need to specify it here explicitly. Finally we specify that the integration should be performed to both directions from the seed points, and set the integration method to Runge-Kutta-4.5.

vtkNew tracer;
tracer->SetInputConnection(clipperRight->GetOutputPort());
tracer->SetSourceConnection(pointSource->GetOutputPort());
tracer->SetIntegrationDirectionToBoth();
tracer->SetIntegratorTypeToRungeKutta45();

Our next problem is coloring the streamlines by velocity magnitude. Since there is no array for the magnitudes of the vectors, we will simply compute the magnitudes into a new scalar array. As you have guessed, there is a VTK filter for this task as well: vtkArrayCalculator. It takes a dataset and outputs it unchanged, but adds exactly one array that is computed from one or more of the existing ones. We configure this array calculator to take the magnitude of the “Velocity” vector and output it as “MagVelocity”. Finally, we call Update() manually again, in order to derive the range of the new array.

// Compute the velocity magnitudes and create the ribbons
vtkNew magCalc;
magCalc->SetInputConnection(tracer->GetOutputPort());
magCalc->AddVectorArrayName(“Velocity”);
magCalc->SetResultArrayName(“MagVelocity”);
magCalc->SetFunction(“mag(Velocity)”);

magCalc->Update();
double magVelocityRange[2];
magCalc->GetOutput()->GetPointData()->GetArray(“MagVelocity”)->GetRange(magVelocityRange);
vtkStreamTracer directly outputs polylines and vtkArrayCalculator passes them on unchanged. Therefore we could just display the output of magCalc directly using a new mapper and actor.

Instead, in this training we opt to make the output a little nicer, by displaying ribbons instead. vtkRibbonFilter generates 2D cells to display ribbons for all polylines of its input.

// Create and render the ribbons
vtkNew ribbonFilter;
ribbonFilter->SetInputConnection(magCalc->GetOutputPort());
ribbonFilter->SetWidth(0.0005);

vtkNew streamlineMapper;
streamlineMapper->SetInputConnection(ribbonFilter->GetOutputPort());
streamlineMapper->SelectColorArray(“MagVelocity”);
streamlineMapper->SetScalarRange(magVelocityRange);

vtkNew streamlineActor;
streamlineActor->SetMapper(streamlineMapper.Get());
renderer->AddActor(streamlineActor.Get());
What is now still missing, and is actually needed to produce the intermediate renderings as well, are the last five lines to actually render the scene and initialize the interactor.

// Render and show interactive window
renWin->Render();
interact->Initialize();
interact->Start();
return 0;
}
Finally, we arrive at the finished visualization, which I will present once again here:

The full source code for the above visualization can be found here

The Good, the Bad, and the Ugly

I will close this article with a list of my personal pros and cons of the VTK framework.

• Pro: Active development: VTK is under active development from several contributors, mainly from within the research community. This means that some cutting-edge algorithms are available, many 3D-formats can be imported and exported, bugs are actively fixed, and problems usually have a ready-made solution in the discussion boards.
• Con: Reliability: Coupling many algorithms from different contributors with the open pipeline design of VTK however, can lead to problems with unusual filter combinations. I have had to go into the VTK source code a few times in order to figure out why my complex filter chain is not producing the desired results. I would strongly recommend setting up VTK in a way that permits debugging.
• Pro: Software Architecture: The pipeline design and general architecture of VTK seems well thought out and is a pleasure to work with. A few code lines can produce amazing results. The built-in data structures are easy to understand and use.
• Con: Micro Architecture: Some micro-architectural design decisions escape my understanding. Const-correctness is almost non-existent, arrays are passed around as inputs and outputs with no clear distinction. I alleviated this for my own algorithms by giving up some performance and using my own wrapper for vtkMath which utilizes custom 3D types like typedef std::array Pnt3d;.
• Pro: Micro Documentation: The Doxygen documentation of all classes and filters is extensive and usable, the examples and test cases on the wiki are also a great help to understand how filters are used.

Con: Macro Documentation: There are several good tutorials for and introductions to VTK on the web. However as far as I know, there is no big reference documentation that explains how specific things are done. If you want to do something new, expect to search for how to do it for some time. In addition it is hard to find the specific filter for a task. Once you’ve found it however, the Doxygen documentation will usually suffice. A good way to explore the VTK framework is to download and experiment with Paraview.

• Pro: Implicit Parallelization Support: If your sources can be split into several parts that can be processed independently, parallelization is as simple as creating a separate filter chain within each thread that processes a single part. Most large visualization problems usually fall into this category.
• Con: No Explicit Parallelization Support: If you are not blessed with large, dividable problems, but you want to utilize multiple cores, you are on your own. You’ll have to figure out which classes are thread-safe, or even re-entrant by trial-and-error or by reading the source. I once tracked down a parallelization problem to a VTK filter that used a static global variable in order to call some C library.
• Pro: Buildsystem CMake: The multi-platform meta-build-system CMake is also developed by Kitware (the makers of VTK) and used in many projects outside of Kitware. It integrates very nicely with VTK and makes setting up a build system for multiple platforms much less painful.
• Pro: Platform Independence, License, and Longevity: VTK is platform independent out of the box, and is licensed under a very permissive BSD-style license. In addition, professional support is available for those important projects that require it. Kitware is backed by many research entities and other companies and will be around for some time.

Last Word

Overall, VTK is the best data visualization tool for the kinds of problems I love. If you ever come across a project that requires visualization, mesh processing, image processing or similar tasks, try firing up Paraview with an input example and evaluate if VTK could be the tool for you.

For more information or to read the original article please click here

The post 3D Data Visualization with Open Source Tools: A Tutorial Using VTK appeared first on CAD Culture.

DirectX, introduced and maintained by Microsoft, is a technology specific to the Windows platform. On the other hand, OpenGL is a cross-platform API for the 3D graphics arena whose specification is maintained by the Khronos Group.

In this introduction to OpenGL, I will explain how to write a very simple application to render 3D text models. We will be using Qt/Qt Creator to implement the UI, making it easy to compile and run this application on multiple platforms. The source code of the prototype built for this article is available on GitHub.

The goal of this simple application is to generate 3D models, save them to a file with a simple format, and to open and render them on screen. The 3D model in the rendered scene will be rotatable and zoomable, to give a better sense of depth and dimension.

Prerequisites

Before getting started, we will need to prepare our development environment with some useful tools for this project. The very first thing we need is the Qt framework and relevant utilities, which can be downloaded from www.qt.io. It may also be available through your operating system’s standard package manager; if that is the case, you might want to try with it first. This article requires some familiarity with the Qt framework. However, if you are not familiar with the framework, please do not feel discouraged to follow along, as the prototype relies on some fairly trivial features of the framework.

You can also use Microsoft Visual Studio 2013 on Windows. In that case, please make sure you are using the appropriate Qt Addin for Visual Studio.

At this point, you might want to clone the repository from GitHub and follow it as you read through this article.

OpenGL Overview

We will begin by creating a simple Qt application project with a single document widget. Since it is a bare-bones widget, compiling and running it will not produce anything useful. With Qt designer, we will add a “File” menu with four items: “New…”, “Open…”, “Close”, and “Exit”. You can find the code that binds these menu items to their corresponding actions in the repository.

Clicking on “New…” should popup a dialog that will look something like this:

Here, the user may enter some text, choose a font, tweak the resulting model height, and generate a 3D model. Clicking on “Create” should save the model, and should also open it if the user chooses the appropriate option from the lower-left corner. As you can tell, the goal here is to convert some user inputted text into a 3D model and render it on the display.

The project will have a simple structure, and the components will be broken down into a handful of C++ and header files:

createcharmodeldlg.h/cpp

Files contain QDialog derived object. This implements the dialog widget which allows the user to type text, select font, and choose whether to save the result into a file and/or display it in 3D.

gl_widget.h/cpp

Contains implementation of QOpenGLWidget derived object. This widget is used to render the 3D scene.

mainwindow.h/cpp

Contains implementation of the main application widget. These files were left unchanged since they were created by Qt Creator wizard.

main.cpp

Contains the main(…) function, which creates the main application widget and shows it on screen.

model2d_processing.h/cpp

Contains functionality of creation of 2D scene.

model3d.h/cpp

Contains structures which store 3D model objects and allow operations to work on them (save, load etc.).

model_creator.h/cpp

Contains implementation of class which allows creation of 3D scene model object.

OpenGL Implementation

For brevity, we will skip the obvious details of implementing the user interface with Qt Designer, and the code defining the behaviors of the interactive elements. There are certainly some more interesting aspects of this prototype application, ones that are not only important but also relevant to 3D model encoding and rendering that we want to cover. For example, the first step of converting text to a 3D model in this prototype involves converting the text to a 2D monochrome image. Once this image is generated, it is possible to know which pixel of the image forms the text, and which ones are just “empty” space. There are some simpler ways of rendering basic text using OpenGL, but we are taking this approach in order to cover some nitty-gritty details of 3D rendering with OpenGL.

To generate this image, we instantiate a QImage object with the QImage::Format_Mono flag. Since all we need to know is which pixels are part of the text and which ones are not, a monochrome image should work just fine. When the user enters some text, we synchronously update this QImage object. Based on the font size and image width, we try our best to fit the text within the user defined height.

Next, we enumerate all the pixels which are part of the text – in this case, the black pixels. Each pixel here is treated as separate square-ish units. Based on this, we can generate a list of triangles, computing the coordinates of their vertices, and store them in our 3D model file.

Now that we have our own simple 3D model file format, we can start focusing on rendering it. For OpenGL based 3D rendering, Qt provides a widget called QOpenGLWidget. To use this widget, three functions may be overridden:

• initializeGl() – this is where the initialization code goes
• paintGl() – this method is called everytime the widget is redrawn
• resizeGl(int w, int h) – this method is called with the widget’s width and height every time it is resized

We will initialize the widget by setting the appropriate shader configuration in the initializeGl method.

glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);
glDisable(GL_CULL_FACE);

The first line makes the program show only those rendered pixels that are closer to us, rather than the ones that are behind other pixels and out of sight. The second line specifies the flat shading technique. The third line makes the program render triangles regardless of which direction their normals point to.

Once initialized, we render the model on the display every time paintGl is called. Before we override the paintGl method, we must prepare the buffer. To do that, we first create a buffer handle. We then bind the handle to one of the binding points, copy the source data into the buffer, and finally we tell the program to unbind the buffer:

// Get the Qt object which allows to operate with buffers
QOpenGLFunctions funcs(QOpenGLContext::currentContext());
// Create the buffer handle
funcs.glGenBuffers(1, &handle);
// Select buffer by its handle (so we’ll use this buffer
// further)
funcs.glBindBuffer(GL_ARRAY_BUFFER, handle);
// Copy data into the buffer. Being copied,
// source data is not used any more and can be released
funcs.glBufferData(GL_ARRAY_BUFFER,
size_in_bytes,
src_data,
GL_STATIC_DRAW);
// Tell the program we’ve finished with the handle
funcs.glBindBuffer(GL_ARRAY_BUFFER, 0);

Inside the overriding paintGl method, we use an array of vertices and an array of normal data to draw the triangles for each frame:

QOpenGLFunctions funcs(QOpenGLContext::currentContext());
// Vertex data
glEnableClientState(GL_VERTEX_ARRAY);// Work with VERTEX buffer
funcs.glBindBuffer(GL_ARRAY_BUFFER, m_hVertexes); // Use this one
glVertexPointer(3, GL_FLOAT, 0, 0); // Data format
funcs.glVertexAttribPointer(m_coordVertex, 3, GL_FLOAT,
GL_FALSE, 0, 0); // Provide into shader program

// Normal data
glEnableClientState(GL_NORMAL_ARRAY);// Work with NORMAL buffer
funcs.glBindBuffer(GL_ARRAY_BUFFER, m_hNormals);// Use this one
glNormalPointer(GL_FLOAT, 0, 0); // Data format
funcs.glEnableVertexAttribArray(m_coordNormal); // Shader attribute
funcs.glVertexAttribPointer(m_coordNormal, 3, GL_FLOAT,
GL_FALSE, 0, 0); // Provide into shader program

// Draw frame
glDrawArrays(GL_TRIANGLES, 0, (3 * m_model.GetTriangleCount()));

// Rendering finished, buffers are not in use now
funcs.glDisableVertexAttribArray(m_coordNormal);
funcs.glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
For improved performance, we used Vertex Buffer Object (VBO) in our prototype application. This lets us store data in video memory and use it directly for rendering. An alternate method to this involves providing the data (vertex coordinates, normals and colors) from the rendering code:

glBegin(GL_TRIANGLES);
// Provide coordinates of triangle #1
glVertex3f( x[0], y[0], z[0]);
glVertex3f( x[1], y[1], z[1]);
glVertex3f( x[2], y[2], z[2]);
// Provide coordinates of other triangles
…
glEnd();
This may seem like a simpler solution; however, it has serious performance implications, as this requires the data to travel through the video memory bus – a relatively slower process. After implementing the paintGl method, we must pay attention to shaders:

m_shaderProgram.addShaderFromSourceCode(QOpenGLShader::Vertex,
QString::fromUtf8(
“#version 400\r\n”
“\r\n”
“layout (location = 0) in vec3 coordVertexes;\r\n”
“layout (location = 1) in vec3 coordNormals;\r\n”
“flat out float lightIntensity;\r\n”
“\r\n”
“uniform mat4 matrixVertex;\r\n”
“uniform mat4 matrixNormal;\r\n”
“\r\n”
“void main()\r\n”
“{\r\n”
” gl_Position = matrixVertex * vec4(coordVertexes, 1.0);\r\n”
” lightIntensity = abs((matrixNormal * vec4(coordNormals, 1.0)).z);\r\n”
“}”));
m_shaderProgram.addShaderFromSourceCode(QOpenGLShader::Fragment,
QString::fromUtf8(
“#version 400\r\n”
“\r\n”
“flat in float lightIntensity;\r\n”
“\r\n”
“layout (location = 0) out vec4 FragColor;\r\n”
“uniform vec3 fragmentColor;\r\n”
“\r\n”
“void main()\r\n”
“{\r\n”
” FragColor = vec4(fragmentColor * lightIntensity, 1.0);\r\n”
“}”));
m_shaderProgram.link();
m_shaderProgram.bind();

m_coordVertex =
m_shaderProgram.attributeLocation(QString::fromUtf8(“coordVertexes”));
m_coordNormal =
m_shaderProgram.attributeLocation(QString::fromUtf8(“coordNormals”));
m_matrixVertex =
m_shaderProgram.uniformLocation(QString::fromUtf8(“matrixVertex”));
m_matrixNormal =
m_shaderProgram.uniformLocation(QString::fromUtf8(“matrixNormal”));
m_colorFragment =
m_shaderProgram.uniformLocation(QString::fromUtf8(“fragmentColor”));
With OpenGL, shaders are implemented using a language known as GLSL. The language is designed to make it easy to manipulate 3D data before it is rendered. Here, we will need two shaders: vertex shader and fragment shader. In vertex shader, we will transform the coordinates with the transformation matrix to apply rotation and zoom, and to calculate color. In fragment shader, we will assign color to the fragment. These shader programs must then be compiled and linked with the context. OpenGL provides simple ways of bridging the two environments so that parameters inside the program may be accessed or assigned from outside:

// Get model transformation matrix
QMatrix4x4 matrixVertex;
… // Calculate the matrix here
// Set Shader Program object’ parameters
m_shaderProgram.setUniformValue(m_matrixVertex, matrixVertex);
In the vertex shader code, we calculate the new vertex position by applying the transformation matrix on the original vertices:

gl_Position = matrixVertex * vec4(coordVertexes, 1.0);
To compute this transformation matrix, we compute a few separate matrices: screen scale, translate scene, scale, rotate, and center. We then find the product of these matrices in order to compute the final transformation matrix. Start by translating the model center to the origin (0, 0, 0), which is the center of the screen as well. Rotation is determined by the user’s interaction with the scene using some pointing device. The user can click on the scene and drag around to rotate. When the user clicks, we store the cursor position, and after a movement we have the second cursor position. Using these two coordinates, along with the scene center, we form a triangle. Following some simple calculations we can determine the rotation angle, and we can update our rotation matrix to reflect this change. For scaling, we simply rely on the mouse wheel to modify the scaling factor of the X and Y axes of the OpenGL widget. The model is translated back by 0.5 to keep it behind the plane from which the scene is rendered. Finally, to maintain the natural aspect ratio we need to adjust the decrease of the model expansion along the longer side (unlike the OpenGL scene, the widget where it is rendered may have different physical dimensions along either axes). Combining all these, we calculate the final transformation matrix as follows:

void GlWidget::GetMatrixTransform(QMatrix4x4& matrixVertex,
const Model3DEx& model)
{
matrixVertex.setToIdentity();

QMatrix4x4 matrixScaleScreen;
double dimMin = static_cast(qMin(width(), height()));
float scaleScreenVert = static_cast(dimMin /
static_cast(height()));
float scaleScreenHorz = static_cast(dimMin /
static_cast(width()));
matrixScaleScreen.scale(scaleScreenHorz, scaleScreenVert, 1.0f);

QMatrix4x4 matrixCenter;
float centerX, centerY, centerZ;
model.GetCenter(centerX, centerY, centerZ);
matrixCenter.translate(-centerX, -centerY, -centerZ);

QMatrix4x4 matrixScale;
float radius = 1.0;
model.GetRadius(radius);
float scale = static_cast(m_scaleCoeff / radius);
matrixScale.scale(scale, scale, 0.5f / radius);

QMatrix4x4 matrixTranslateScene;
matrixTranslateScene.translate(0.0f, 0.0f, -0.5f);

matrixVertex = matrixScaleScreen * matrixTranslateScene * matrixScale * m_matrixRotate * matrixCenter;
}

Conclusion

In this introduction to OpenGL 3D rendering, we explored one of the technologies that allow ud to utilize our video card to render a 3D model. This is much more efficient than using CPU cycles for the same purpose. We used a very simple shading technique, and made the scene interactive through the handling of user inputs from the mouse. We avoided using the video memory bus to pass data back-and-forth between the video memory and the program. Even though we just rendered a single line of text in 3D, more complicated scenes can be rendered in very similar ways.

To be fair, this tutorial has barely scratched the surface of 3D modeling and rendering. This is a vast topic, and this OpenGL tutorial can’t claim this is all you need to know to be able to build 3D games or modeling softwares. However, the purpose of this article is to give you a peek into this realm, and show how easily you can get started with OpenGL to build 3D applications.

View the original article here https://www.toptal.com/opengl/introduction-to-opengl-a-quick-tutorial

The post Introduction to OpenGL: A 3D Text Rendering Tutorial appeared first on CAD Culture.

A fellow Toptaler asked me this a couple of weeks ago, because I used to cover 3D printing for a couple of publications. I had no clear answer. I couldn’t just list business opportunities because this is a niche industry with a limited upside and mass market appeal. What’s more, 3D printing is still not a mature technology, which means there is not a lot in the way of standardisation and online resources for designers and developers willing to take the plunge.

However, this does not mean there are no business opportunities; they’re out there, but they are limited. In this post, I will try to explain what makes the 3D printing industry different, and what freelancers can expect moving forward.

3D Printing For Hobbyists And Businesses

First of all, I think we need to distinguish between two very different niches in the 3D printing, or additive manufacturing industry.

On one end of the spectrum, you have countless hardware enthusiasts, software developers and designers working on open-source projects. The RepRap project embodies this lean and open approach better than any similar initiative in the industry. RepRap stands for Replicating Rapid Prototyper and it’s basically an initiative to develop inexpensive printers based on fused filament fabrication (FFF) technology. Essentially, that is Fused Deposition Modelling (FDM) technology, but RepRap can’t use that name because it was commercialised by Stratasys. When the company’s patent on FDM expired, FDM was embraced by the open-source community, albeit under a different name.

3D printing is not a new technology, but recent advances in several fields have made it more accessible to hobbyists and businesses.

RepRap turned ten this year, with the first printers showing up a few years after launch. By 2010, the RepRap project was on its third generation design, and the RepRap community saw a lot of growth over the next few years.

One noteworthy feature to come out of the RepRap initiative is self-replication; the ultimate goal of the project is to create a 3D printer that will eventually replicate itself. We are not there yet, but some RepRap designs allow users to print three quarters of the printer. You still can’t print extruders and electric servos, but it’s a start.

However, RepRap was never supposed to be a commercial success. It was created as a tech-first initiative, so it was never consumer-centric. It was all about pioneering various technologies and bringing them to the hobbyist market at low cost. RepRap was never supposed to be a cash cow.

So what about big business? A number of industry pioneers have already become 3D printing heavyweights. These include Stratasys, 3D Systems, Ultimaker and Printbot. RepRap printers still command a big market share, and they’re not being squeezed out by proprietary platforms. In fact, most vendors have no choice but to embrace some RepRap standards in order to guarantee compatibility.

However, simply listing 3D printing companies and their respective market share does not paint the full picture. For example, RepRap is limited to FFF technology, which is the most widespread 3D printing technology today. The problem is that FFF printers have a lot of limitations, which means they cannot be used in many industries.

Different Technologies For Different Applications

To get a better idea of what’s out there, we need to take a look at currently available 3D printing technologies. This might not seem interesting if you’re not a hardware geek, but it’s important to understand the difference between various printing technologies (and I will try to keep this section as brief as possible).

Although hobbyist FFF printers are relatively inexpensive, certain types of professional 3D printers can cost as much as your home.

• FFF/FDM usually relies on thermoplastic “filament” heated by the printer extruder prior to being deposited on the print bed. Most FFF printers rely on ABS and PLA plastic filament, but the latest models also use polycarbonate (PC), high-density polyethylene (HDPE), high-impact polystyrene (HIPS) filament. Some even use metal wire instead of plastic, while others use sawdust to create quasi-wood objects. Some can even print food, chocolate, pasta and so on.
• Granular printers are different beasts since their material is not filament but, usually, powdered metal. These printers tend to be based on laser technology (although they don’t have much in common with your office laser printer). They use a powerful laser to selectively fuse granular materials. There are several ways of doing this: Selective laser sintering (SLS) printers fuse small metal particles by the process of “sintering,” while selective laser melting (SLM) printers melt the powder. Electron beam melting (EBM) printers hits metal powder with an electron beam in a vacuum environment
• Stereolithography (SLA) printers transform liquid raw material into solids using light. These printers have a number of advantages, in terms of accuracy and the ability to produce complex objects in a single pass, because SLA prints don’t require struts or supports, in most cases. The downside is that the choice of materials is very limited. They are usually exotic liquid polymers, and can’t be used to print metal or chocolate.

There are a few more 3D printing technologies out there, but I see no point in covering all of them for the purposes of this blog post.

The Challenge

So why aren’t we all playing around with 3D printers in our homes and offices? Why can’t we print objects the same way we print invoices, sheets and emails? 3D printing is not going mainstream any time soon, and here are some challenges and issues that need to be addressed first.

• Prohibitively expensive hardware
• Limited user base (compared to traditional printers)
• Immature technology
• Speed
• Price/performance, ROI
• Running costs
• Energy efficiency

With each new generation, entry-level 3D printers become a bit cheaper, but they are still too expensive for most potential users. It’s one thing to buy a $200 printer for your home or office, you’ll probably end up using it a lot, but the same isn’t necessarily true of 3D printers. How many people need to print documents, and how many need to print 3D objects?

Technology is improving, but serious limitations persist. 3D printers are still slow, are sensitive to all sorts of adverse conditions, their “printbeds” tend to be small (especially on inexpensive models), the choice of materials is limited and filament can be expensive.

The reason why businesses aren’t lining up to buy 3D printers is simple: ROI. 3D printers still can’t come close to traditional manufacturing methods in terms of speed, cost and energy efficiency. This does not mean industry isn’t going to shift to 3D printing in the future; we are already seeing some pioneering developments, but 3D printers won’t render traditional manufacturing techniques obsolete soon.

Still, there are some noteworthy exceptions. A couple of years ago, General Electric set out to design and build a new fuel injection nozzle for its next generation CFM LEAP turbofan engine, which is bound to end up in hundreds of airliners. GE eventually settled on 3D-printed titanium nozzles. The reason? The new 3D printed nozzle ended up 25 percent lighter than the previous design and consisted of a single part instead of 18 on the old nozzle. Durability is expected to be five times better. These nozzles will be used in engines manufactured in 2016 and beyond. GE hopes to produce more than 100,000 3D-printed parts by the end of the decade.

A team of GE engineers decided to create a working replica of one of the company’s engines, using a new granular printing technique dubbed “metal laser melting.”

Long story short, no, you won’t buy 3D-printed toys for $2 anytime soon, but you will fly on airliners powered by more efficient and reliable engines, made possible by 3D printing. There won’t be any 3D-printed chocolate in your local mall, at least not yet, but your dentist will tell you it’s probably not a good idea to eat chocolate anyway, right after you get your 3D-printed prosthetic.

There Is Another Way: 3D Printing Fulfilment Services

So, you have a great idea for a product, but first you need a small series of prototypes. Who do you call? Do you buy a bunch of 3D printers? Or do you simply send the design to a fulfilment service that will ship you the completed models in a matter of days?

Fulfilment services allow consumers and small businesses to take advantage of sophisticated 3D printing infrastructure without burning capital.

A 3D printing fulfilment service seems like a hassle-free choice, and that’s the direction the industry seems to be taking. Many 3D printing outfits have launched similar services and are collaborating with other industry leaders. One example of this symbiotic relationship is Stratasys Direct Express, which recently partnered with Adobe and enabled Photoshop CC integration, offering colour 3D printing for professional designers.

Google and Motorola didn’t invest billions in their own 3D printing facilities when they unveiled the Ara modular smartphone concept. They outsourced module manufacturing to 3D Systems. This example also underscores the potential flexibility of additive manufacturing: Ara is based around an alloy exoskeleton filled with various standardised modules that could be 3D printed. Since the modules have to connect to the exoskeleton, 3D Systems developed a new technique of depositing conductive materials within the printed components, which is a far cry from traditional 3D printer prototyping.

3D fulfilment services usually offer several different printing technologies, cutting-edge hardware and support. Why bother getting a $2,000 printer when you can simply send your designs to professionals and use any of a variety of professional printers, some of which cost more than your home? And let’s not forget about economy of scale; big services can and should offer a superior price/performance ratio compared to in-house printing.

In my opinion, this is the way to go. This straightforward business model has a lot going for it, and it’s hard to see how individuals and small businesses could compete on an even playing field. In terms of price, size and energy consumption, a professional 3D printer has more in common with a printing press than your LaserJet, and how many people need a printing press in their home or office?

(One of my pet peeves is the name itself. When you mention a “printer” in conversation, most people think of their home inkjet printer, or office printer. While it’s true that 3D printers are printers, they don’t have much in common with traditional printers, and this distinction is often lost on laymen. If we just kept calling them additive manufacturing machines, this wouldn’t be an issue.)

Article Courtesy of BY NERMIN HAJDARBEGOVIC – TECHNICAL EDITOR @ TOPTAL
view the original article here https://www.toptal.com/designers/print/3d-printing-for-developers

The post 3d Printing for Designers and Developers appeared first on CAD Culture.

1. Have a basic design

When you start the process, it’s a good idea to ask yourself if you have a clear vision of what you want the ring to look like. It will help you if you make some preliminary sketches to take to your jewellery designer.

If you’re not sure what you want, have a look in jewellery stores and online, for ideas on settings, filigrees, mixed metals, organic lines and gemstones. Note down anything that catches your eye, and let your jeweller know the elements of ring design you like, as this will help them design something you want.

2. Choose the right designer

After you’ve come up with a vague design, you will need to find the right jewellery designer. Many jewellers have in-house designers who specialise in custom pieces. When it comes to jewellery designers, take note of any recommendations from family and friends, as this should give you an idea of the quality of their work.

When you’re talking to a jewellery designer, make sure you view their portfolio of other work. As an artist, their style will influence your design, and you should make sure that their style will suit your dream ring.

3. Communicate

Once you’ve found the right jewellery designer and talked about what you want, they should be able to mock up a digital version of the jewellery, using a CAD software programme, such as Rhino 3D. This will allow you to make sure the designer has followed your ideas, and whether the idea works. By using CAD software to make a digital version of the ring, you can make changes before the ring has actually been made, saving you time and money.

You should ask to see all the elements that’ll make up the ring in person, prior to the ring being made. This way, you can inspect the gemstones and precious metals that’ll build your engagement ring.

4. Warranties and guarantees

When it comes to custom ring design, you will need to take extra care regarding warranties and guarantees. Ensure you get everything in writing, from everything (metals, gemstones and so on) included in the ring, to a final appraisal that specifies the designer and custom design. You should also remember to insure your ring to give it an extra layer of protection.

It’s quite common to feel intimidated when talking through your ideas with an experience jewellery designer. Whilst they may have experience and knowledge, along with passion and artistic skill with jewellery design, remember that it isn’t the designer’s ring, it’s yours. Make sure your designer gives you what you’ve asked for.

The post Everything You Need to Know About Custom Designing an Engagement Ring appeared first on CAD Culture.

Breaking down NURBS

You know what NURBS stands for, but what does it mean?
• Non-uniform- the portions of a curve, affected by individual control points, aren’t necessarily evenly distributed along the curve.
• Rational- the pull of each control can be adjusted.
• Basis-Spline- functions define how much control each point will influence the curve at any parameter value.

NURBS curves and surfaces are largely controlled by two factors:

• number of control points
• degree

NURBS curves and surfaces all have control points that act like magnets, pulling the curve to themselves. Rhino is a great piece of design software as all you need to do to draw a curve, is plot the point exactly where you want them. Then, if you wish to change the shape of the curve, you simply move these control points.

The degree of a curve determines the influence each control point has the curve. To give a curve less local influence and a higher global influence, you need a higher degree curve.

NURBS surfaces

The best and easiest way to think of a NURBS surface is like a rubber sheet that can be almost infinitely deformed.

For example, you can collapse one edge into a single point by placing all the control points of the edge at the same place.

Modelling tips

When you’re playing around with NURBS, there are two tips we find really help you create models easily and simply:

1. Use as little data as possible to describe the shape

This will leave you with a smoother model, whilst giving you greater control of curvatures. You will also find the model a lot easier to edit.

• Only introduce new points if they describe new features in the curves.
• New points or curves should only be introduced if they describe new features in surfaces.
• Avoid using multiple small patches if one large surface can describe the shape

2. Wherever possible, use oversized surfaces with four corners

• Rather than collapsing edges or squeezing edges into continuous lines, it is better to have surfaces with four corners.
• You can always trim any surplus surface to create your final shape.

However, if you need precision for the dimensions of the edge itself, you’re better to use the true surface edge as the final boundary. You will also need to take this approach if you need to match the surface edge to another surface.

The post A Simple Introduction to the Use of NURBS in Rhino appeared first on CAD Culture.

Interior Design

Through detailed digital designs, interior designers use CAD software to bring their ideas to life. CAD allows designers to show their clients what rooms will look like upon completion, right down to paint colour.

Landscaping

CAD software allows landscapers to conceptualise breathtaking creations, and figure out where best to place landscaping components such as patios, gardens, trees and fences.

Fashion

Most high-end designers will make an initial design for a collection by hand, using CAD software later on in the design process. This software can determine the most efficient cut of fabric, as well as adjusting the scale for different clothing sizes. The software can then demonstrate how the clothing will look and move on a body, by placing it on a virtual model, allowing designers to make any changes if they don’t like the initial result.

Cartography

No longer are maps charted by hand. Instead, modern cartographers use CAD software to record road maps, topographic maps and even climate.

Architecture

Buildings are one of the most expensive investments many people make, so it’s essential that all initial plans are flawless. Architects utilise CAD to work alongside 2D floor plans and 3D schematics of commercial or residential structures. Not only is CAD used to design the actual architecture and layout of a new structure, it determines specifications such as measurements, volumes and weights prior to beginning construction.

Civil engineering

CAD is used by civil engineers to design and plan urban infrastructure, such as office complexes, parks, industrial units and bridges.

Aerospace

The price of any single aerospace product can be in the billions, with the industry making aircraft, missiles, satellites and space vehicles. CAD software plays a fundamental role throughout the initial design process to meticulously calculate everything before the product is built.

Automotive

CAD software is used in all parts of the design process to create prototypes of vehicle body styles, engines, tyres, upholstery, and circuitry boards.

If you want to learn how to utilise CAD software to design gorgeous and unique pieces of jewellery, nut don’t know where to start, take a look at our Rhino 3D Level 01 and Level 02 jewellery design courses. For more information, contact us. You can alternatively call our South African office on +27 82 864 8589 or our Australian office on +61 405 786 874.

The post Industries that rely on CAD appeared first on CAD Culture.

Silver

Silver is a much softer metal compared to gold and platinum, making it less resilient. For this reason, and the fact it tarnishes easily, means it is rarely used for wedding or engagement rings. Silver is also prone to oxidisation, which can sometimes turn the metal black. If you care for your silver jewellery, it can easily be kept looking new.

Gold

Gold is historically the classic colour of wedding bands and jewellery. All gold jewellery is made up of an alloy between gold and other metals. This is measured in Carats, and the more Carats a piece of jewellery has, the more valuable it is. 18 ct gold tends to be a lot more durable than 9ct gold, as well as maintaining a better appearance. The gold alloy will affect the resistance of the jewellery to scratching and also influence the colour of the piece.

Yellow gold – Yellow, or ‘original’ gold is made from an alloy usually including zinc, silver and copper, to give it extra strength and enhance the shine. If you’re after a traditional look to your jewellery, or tend to wear warm colours, yellow gold is your best option. It provides a great contrast for gemstones and other metals.

White gold – White gold mixes yellow gold with silver or palladium to give it its distinct colour. When made with silver, the result is a creamy colour, with a hint of yellow. Palladium offers a richer, darker white colour, as well as making the metal more durable. White gold is often then coated in Rhodium to produce a stunning white finish and extra lustre.

Platinum
Platinum is one of the rarest and most precious metals available, making it increasingly popular for wedding bands. It has an immense level of durability and resistance to everyday tarnishing and scratching, polishing up well. This beautiful white metal is very dense and heavy, so you will feel the weight of a platinum piece of jewellery a lot more than an equivalent gold or silver piece. Unlike gold, which is always as an alloy, platinum jewellery is almost entirely pure, being an average of 95% pure.

The post A Guide to Different Jewellery Metals appeared first on CAD Culture.

Fathers of CAD

In 1957, Patrick Hanratty developed the first commercial computerised numerical control (CNC) programming system called Program for Numerical Tooling Operations (or PRONTO), whilst working for General Electric. Five years later, Ivan Sutherland presented his Ph.D thesis at MIT, “Sketchpad, A Man-Machine Graphical Communication System. Some of the features included the first ever graphical user interface, with a light pen to manipulate the objects displayed on a cathode ray tube (CRT).

The 1960s saw further developments, such as the first digitizer and DAC-1, the original production interactive graphics manufacturing system. By the end of the 1960s, Computervision, M&S Computing, Applicon, SDRC and Evans & Sutherland were all created to commercialise CAD programs.

The 1970s saw Ken Versprille’s major breakthrough of NURBD for his Ph.D project that allowed the formation of the modern 3D curve and surface modelling. Alan Greyer, Charles Lang and Ian Braid were developing the Part and Assembly Description Language (PADL) solid modeller.

CAD Revolution

By the 1980s, commercial CAD systems such as CATIA began being used in aerospace and automotive industries, amongst others. The first IBM PC in 1981 really set the path for large-scale adoption of CAD in industry. By 1982, Autodesk was formed and the following year saw the release of AutoCAD, the first CAD program for IBM PCs.

The 1990s saw PCs powerful enough to support computations required by CAD, seeing SolidWorks released in 1995, the first solid modeller designed for Windows. It was quickly followed by Solid Edge and Inventor.

CAD today and tomorrow

Modern CAD programs are characterised by their improvements in levels of analysis and management of products, including modelling, engineering, and manufacturing and maintenance.

Companies such as Siemens are developing technology to combine the precision and control of feature-based design, with the speed and flexibility of explicit modelling. This would allow for designers to spend less time on construction, design changes and importing new data. Additionally, CAD developers are making use of Cloud storage to offer immense design power to a range of mobile devices as well as computers.

The post A Brief History of Computer Aided Design (CAD) appeared first on CAD Culture.