With the aim of meeting five learning objectives from the foundation degree in building services at Grimsby college, we came up with the idea of showing as many of the concepts in one environment. The piece was built as both a standalone application and a web-ready version so that both lecturers and students could explorer the concepts as a group or in their own time.

The piece allows the user to:- look at the construction of an underfloor heating system; look at the different properties of an insulated external wall construction; examine the parts of a combi condensing boiler, see the condensing and heat transfer take place, examine the flow of hot water through both underfloor and radiator based heating systems; examine electrical supply, fuseboxes and different circuits and much more.

The hardest part of the project was both modelling and showing the flow of heat from  the boiler, but after 12-14 weeks of work all was complete and the project deemed a success.

Covering concepts such as the bernoulli principle, dynamic rollover, bladeflapping, conning and the disymmetry of lift the project was well recieved, and gave us some enourmous technical challanges such as being able to see the different effects on lift at different airspeeds, and how it effected blade angles at different parts of their cycle thorugh 360 degrees.

Working closely with our collegues, we have identified a number of key areas/curriculum that would be better understood, taught and concieved by having bespoke interactive training media created. The aim of these projects (and the list is still growing) would be to benefit not only staff and students but attract interest from external companies and other academic/training establishments.

Some of screen grabs above are from the construction site health and safety training application.

Although I created a standalone Windows based (.dll) webcam plugin for Unity3d in May, 2009 utilising Theodore Watson’s – VideoInput library along with some Open CV functions, trying to get a working cross platform Unity3d solution for augmented reality was still heavy on my mind. Knowing of the many existing ARToolkit based examples, working flash AS3 libraries and the various SIFT and SURF algorithms scattered across the web, I really wanted to create a Unity based non platform specific solution, where I could obtain the webcam feed directly into unity and start to utilise C# code for the algorithms.

When a collegue came across the Honeyway Train augmented reality game from Boffswana for Cheerios, I was blown away with the fact that they had appeared to take a webcam directly into Unity utilising either Adobe Flash Player and/or the Unity3d Webplayer itself. Although how they achieved this is still not quite clear, Unity has disclosed that Boffswana made a custom web player based upon agreements made with Unity itself (more info here.)

So after realising no further information on this would be disclosed, I thought I’d have a stab at getting a webcam image from flash to unity3d myself, this seemed to be a valid method/idea at the moment as most people have flash player installed, this accesses a webcam on all platforms, and the Unity3d webplayer is also multiplatform but does not support hardware access to any platforms webcam and will not allow the embedding custom DLL’s (by default).

Solution

Ideally I would have liked to get the memory address/pointer of the webcam image/bitmap  from flash, access the pointer in unity3d and copy across the bytes to my Unity Texture Pointer, this would have been as fast as any .DLL and exactly how I had done it in C++ however with sandboxes and webplayer securities to deal with I never found a method of making this possible.

My first attempt was rather sad and tried to utilise javascript to send the data via a BYTE64 encoded string from flash to Unity, the results were not good and there were limits on string length. I then decided to use Sockets and the results started to come through although my threading in Unity was a little messy, in a standalone build everything was fine however when trying to make this work from my website nothing seemed to happen, and this is when I came across flash policy files.

Realising that I needed to send a valid policy response to flash to unblock the port I continued and finally got a workable first solution, the project is now something that needs to grow and obviously everything at the moment is at an embryonic stage, but I intend to create both a Unity and Flash Class based library for this for release later in the year, unless beaten to it.

The Initial Demo

Although I intend to move the demo over to this site later next week you can find a link to the demo below. You will need both Flash Player and Unity3D Player installed, also a Webcam plugged into your machine. Please bear in mind that this is a very user unfriendly release and that the demo may not work if using a proxy server (not sure about this, please let me know of your experience as feedback is what we require). The demo does not include any augmented reality as of yet, but serves as a proof of concept awaiting feedback. There may be a slight delay of around 8 seconds whilst Unity resolves Flash connection.

The “working” demo can currently be found by ‘clicking here’

Please give positive or constructive feedback below, many thanks Jon.

On YouTube we have our Channel where you can find most of videos in HD resolution from our applications.

FusedWorks had the pleasure of visiting and hosting a workshop on 3d learning applications at this years Yorkshire and Humberside e-Learning Conference organised by the JISC Regional Support Centre and hosted at the Rosebowl in Leeds.

This year’s JISC RSC YH e-Learning Conference was focused on active and interactive Learning with the use of a variety of tools and technologies.  The event explored which tools and technologies are effective in facilitating collaborative learning, simulating ideas and concepts, assessing learning, inspiring learners, reflecting on learning and enhancing mobile and distance learning.

The day was split into four workshop sessions with a variety workshop choices for the delegates to attend with subjects ranging from cloud computing, mobile learning, digital copyright, console platform learning to interactive 3d learning.

Aim:

To visualise a product “Water Pump” in an engineering/illustrative format, showing the various parts of the water pump and visualising the assembly and disassembly process in a visual and guided manner. The concept was to present a method that could replace regular paper based manuals/instructions with an interactive and easy to use 3D application that could transcend multiple platforms and be easily accessed by a wide user base, in this case the versatile and widely used Adobe PDF format.

Source data:

The project start with reusing 3D CAD data of the product. The CAD system used for modelling this product was CATIA V5.

The procedure of disassembly base only on designers imagination but present the area of use this kind of applications.

Engineering illustrations:

Short movie with the disassembly procedure:

www.youtube.com/watch?v=3tRTlIEKszI

Interactive 3D PDF:

An Adobe Reader 8.1 or higher is required to use this application. To download the latest version of the software please click here IMPORTANT FOR MAC USERS: Please make sure that you open this pdf with Adobe Reader not Preview software. Otherwise the 3D content will not be visible.

In the 4DSmile project, FusedWorks teamed with Finnish partners Keski-Pohjanmaan koulutusyhtyma / Kokkolai szakképzo iskola, as part of the Leonardo da Vinci / Transfer of Innovation scheme.

The project focused on creating an support tool that would aid with teaching the different stages of bag manufacture – from cutting material patterns to visualizing different design schemes. Particular attention was focused on visualising the setup of the sewing machine and overlocker machine in a way that was clear and intuitive for students.

The final product took the form of a non-linear interactive application for display on a stereo projection system run by a teacher in a classroom scenario.

Example videos from the final application:

Bag variant with textures and colours

www.youtube.com/watch?v=TcW70RPtfoU

Standard sewing machine setup

www.youtube.com/watch?v=XazdDHPNev8

Overlock machine setup

www.youtube.com/watch?v=F9vb7lWPIxU

An interactive web application of that part is available here:

The script below creates a simple procedural grid based mesh with height data taken from a procedural perlin noise map, it is a simple combination of two of the scripts supplied in the Unity3d procedural examples found here. For the script to run you will also need a copy of the perlin.cs plugin script file also found in the Unity3d procedural examples and to place it in a folder named PlugIns in your project assets directory.

A Unity3d asset package of the script below and the required perlin noise script can be downloaded here.

//procedural grid mesh based on perlin noise.

var material : Material;
var size = Vector3(200, 30, 200);

var tsize = 50;
var lacunarity = 2.404;
var h = 0.354;
var gain = 1.0;
var octaves = 2.315;
var offset = 0.245;
var scale = 0.053;
var offsetPos = 0.0;
var timeaddx:float=0.005;
var timeaddy:float=0;

private var mytimex:float=0.0;
private var mytimey:float=0.0;
var heighttexture : Texture2D;
private var perlin : Perlin;
private var fractal : FractalNoise;

function Start ()
{
gameObject.AddComponent(MeshFilter);
gameObject.AddComponent(“MeshRenderer”);
heighttexture = new Texture2D(tsize,tsize, TextureFormat.RGB24, false);
Calculate();
GenerateHeightmap();
}

function Update() {
Calculate();
GenerateHeightmap();
}

function Calculate()
{
mytimex=mytimex+timeaddx;
mytimey=mytimey+timeaddy;

if (perlin == null) {
perlin = new Perlin();
}
fractal = new FractalNoise(h, lacunarity, octaves, perlin);
for (var y = 0;y<tsize;y++) {
for (var x = 0;x<tsize;x++) {
var value:float = fractal.HybridMultifractal(x*scale + mytimex, y * scale + mytimey, offset);
heighttexture.SetPixel(x, y, Color (value, value, value, 1));
}
}
heighttexture.Apply();
}

function GenerateHeightmap ()
{
// Create the game object containing the renderer

if (material)
renderer.material = material;
else
renderer.material.color = Color.white;

// Retrieve a mesh instance
var mesh : Mesh = GetComponent(MeshFilter).mesh;

var width : int = Mathf.Min(heighttexture.width, 255);
var height : int = Mathf.Min(heighttexture.height, 255);
var y = 0;
var x = 0;

// Build vertices and UVs
var vertices = new Vector3[height * width];
var uv = new Vector2[height * width];
var tangents = new Vector4[height * width];

var uvScale = Vector2 (1.0 / (width – 1), 1.0 / (height – 1));
var sizeScale = Vector3 (size.x / (width – 1), size.y, size.z / (height – 1));

for (y=0;y<height;y++)
{
for (x=0;x<width;x++)
{
var pixelHeight = heighttexture.GetPixel(x, y).grayscale;
var vertex = Vector3 (x, pixelHeight, y);
vertices[y*width + x] = Vector3.Scale(sizeScale, vertex);
uv[y*width + x] = Vector2.Scale(Vector2 (x, y), uvScale);

// Calculate tangent vector: a vector that goes from previous vertex
// to next along X direction. We need tangents if we intend to
// use bumpmap shaders on the mesh.
var vertexL = Vector3( x-1, heighttexture.GetPixel(x-1, y).grayscale, y );
var vertexR = Vector3( x+1, heighttexture.GetPixel(x+1, y).grayscale, y );
var tan = Vector3.Scale( sizeScale, vertexR – vertexL ).normalized;
tangents[y*width + x] = Vector4( tan.x, tan.y, tan.z, -1.0 );
}
}

// Assign them to the mesh
mesh.vertices = vertices;
mesh.uv = uv;

// Build triangle indices: 3 indices into vertex array for each triangle
var triangles = new int[(height - 1) * (width - 1) * 6];
var index = 0;
for (y=0;y<height-1;y++)
{
for (x=0;x<width-1;x++)
{
// For each grid cell output two triangles
triangles[index++] = (y * width) + x;
triangles[index++] = ((y+1) * width) + x;
triangles[index++] = (y * width) + x + 1;

triangles[index++] = ((y+1) * width) + x;
triangles[index++] = ((y+1) * width) + x + 1;
triangles[index++] = (y * width) + x + 1;
}
}
// And assign them to the mesh
mesh.triangles = triangles;

// Auto-calculate vertex normals from the mesh
mesh.RecalculateNormals();

// Assign tangents after recalculating normals
mesh.tangents = tangents;
}