Matrix = Input {

Value = LookUpTable {

NumEntries = 54,
Type = 10,
Offset = 0,
Minimum = 0,
Maximum = 1,
MinimumValue = 0,
MaximumValue = 1,
StartSlope = 1,
EndSlope = 1,
StartIn = 0,
EndIn = 1,
Table = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, },

},

},

But the real stinker is that there isn’t any modifiers for LookUpTables.  So you can’t animate, or publish, or connect, or add an expression, et cetera.  This makes it really hard to use for anything where you don’t know the color matrix ahead of time, and useless if the color matrix changes over time.   

What’s great with Fusion, though, is that it’s not too hard to make Fuses that contain the functionality you want and present everything neatly and cleanly and still be quite fast.

Download Suck Less Color Matrix 1.0

So this tool implements a RGB colormatrix, not an RGBA one.  It would be pretty trivial to add RGBA, but it would be a bit too crowded in the control panel and frankly, I don’t know why you would ever do an RGBA color matrix operation unless you were intentionally working on 4D data or if you wanted to do channel swizzling.  But hey, if you really need it, drop me a line.

You can choose to work in RGB or BGR order.  The original Color Matrix is RGB, but internally, Fusion does BGR, so I provide conversion for convenience as well as handy labels so it’s less intimidating.

There’s also an option to output ONLY a LUT image, which will make an itty bitty image representing the 8 corners of the color cube.  And you can optionally toggle application to the canvas color.

If you stretch out the tool control panel, you will have access to some sliders labeled n11 through n43.

Of course this raises the prospect of a “Suck Less Custom Filter” no?  Might have to see about that…

Here are the three APKs for Android.

• The cloth colliding with a ball while undergoing deformation from some wind force. 
  Download Flag 1.0.
  Vertices = 961, Triangles = 1800, Colliders = 2, Updates – 50/sec.
• A small game that demonstrates cloth tearing. 
  Download Hammock 1.0. 
  Vertices = 670, Triangles = 1259, Colliders = 6, Updates – 50/sec.
• A comparison of the performance of our cloth to Unity cloth. 
  Download Jelly 1.0. 
  Vertices = 1300, Triangles = 3170, Colliders = 9. Updates = 25/sec. (For Each Jelly)

 
The ‘Updates’ represent the number of times the cloth simulation gets solved in a second. This value is different from the framerate, which is shown in each game as ‘FPS’.

The We're Hiring page is back because we’re taking on some new and exciting projects.  Maybe you could help with that?  Don’t worry, Arun and Sven are still here, we just want to take on even more challenges.

We’re looking to immediately hire both permanent and contract developers to help us make some new mobile and web platform applications with some pretty advanced simulation and interactivity components.

This informative tutorial formed the basis of our cloth model. Some of our results are shown below. We are planning to make this tool available in the Unity's Asset Store, soon. So, if you’re a Unity developer and you like our results, stay tuned and check it out!

So here are some demos of our implementation:

1. The cloth colliding with a ball, while undergoing deformation from some wind force.

2. A small game that demonstrates the cloth tearing.

3. And finally here’s a comparison of our cloth implementation with Unity's implementation. On some machines (that’re CPU challenged), you should see that our version performs better than Unity’s (FPS-wise). Of course, Unity’s cloth supports a much larger feature set including two-way collisions, thickness and pressure, all of which are not supported in our version. So all the extra tests that they have to do might account for some of slowness in Unity’s version.

Note: You’ll need the latest web player plugin for Unity 3.5 for your browser. If you already have a previous version of the web-player installed, the update is supposed to happen automatically. But if you’re having any trouble, click on this link. Once the player has loaded you should see your runtime version displayed as 3.5. You will also see a spinning Unity cube on fire.

Both methods can be applied to transform or reduce 2-4 input channels to 1-4 output channels, for a single image or a range of images. A secondary image input can be used to supply a weighting mask that determines the influence of each pixel during the color reduction algorithm. Afterwards, the output channels can be normalized and optionally, the color transformation can be encoded in a Fusion 3D LUT.

Download Color Reduction 1.0

Description of methods

The results of PCA and LPP are not necessarily the same since the optimization is based on different criteria. PCA determines the principle components that account for most of the contrast in color space, e.g. if the contrast in the red and green channels is much higher then the contrast in the blue channel, the first channel returned by PCA will be a linear combination of the red and green channel.

In addition, LPP considers the proximity of colors in the image space, e.g. if many yellow pixels are neighbors of green pixels in image space, green and yellow pixels may get the same color in the first channel of LPP. In constrast, red and yellow pixels may get different colors although their distance in the color space is the same (see details on the effect of the LPP weighting factor below).

Comparison of PCA and LPP

The following video shows the effect of PCA and LPP for color to grayscale conversion. The results are compared to simply using the lightness channel of the LAB color space. For better visibility, only the 2D histogram for the red and blue color channels is shown.

In the first step, the color space of the input image is projected onto a line. The orientation of the line and the direction of projection are different for all three methods and result in a different distribution of contrast. In the second step, the line is mapped to the grayscale range and normalized.





While PCA will always find the axis of highest contrast in the color space and is independent of any parameters, the results of LPP depend on a weighting factor.

Effect of the LPP weighting factor

The image below helps to understand the effect of the LPP weighting factor. Internally, the weighting factor is applied to the color space distances of neighboring pixels, so that a higher factor will lower the chance of pixels with different colors to be recognized as neighbors. The example shows the input image which contains dark green, light green, yellow and orange pixels and a simplified red-green histogram.

Although the color space distance in vertical direction is smaller than the distance in horizontal direction, LPP will recognize the neighborhood between light green and yellow pixels as well as the neighborhood between dark green and orange pixels in image space. Therefore, LPP with a low weighting factor will project light green and yellow to the same color as well as dark green and orange to another color. However, after increasing the weighting factor, the color space distances will become more important than the spatial neighborhoods again and the result will be the same as for PCA.

Download RGBtoLAB 1.03

Ok, this Fuse started off as a really tiny one.  Fusion already has a CSConvert() that does Lab.  So all I have to do is…

if mode == 0 then

out:CSConvert("RGB", "LAB")

else

out:CSConvert("LAB", "RGB")

end

Simple and fast.  But the results were a bit… unexpected. So we added a little tweak which has no basis in known color science, it just makes is so that a linear RGB input returns what I think is a linear L output.

So why doesn’t ColorSpace have an Lab button?  I don’t know.  You can see LAB color in action in the Wand tool, though.

Other options include output a LUT Image only, as if it were a Source tool.  Same as the new option on ColorMatrixTransform.  You can also choose whether to affect the canvas color or not.

VolumeFog now includes a Schlick single-scattering lighting model.

Download Particle Voxelization for VolumeFog A01

You can render in OpenCL, or fallback to CPU if you need to render a larger volume dataset than you have memory on your OpenCL device.   It works nicely, but definitely shows the interface issues with representing 4D data as X,Y,Time,Time.  We use Quilt for 4D data, but we’ll have to see if there’s an easy way to get that translated over to VolumeFog.  Of course, getting a proper 3D fog texture can be handled nicely by Simbiont.

AlphaDivide and AlphaMultiply provide dead simple color operations, but they’re no faster than our own tool.  And unlike the new built-in tools, AlphaDivideMultiply allows you to affect the canvas color, too.

LUT Fuses allow you to analyze and apply LUT images to your footage to simplify various color operations, as well as provide simple interoperability with other applications.  They’re also operate in OpenCL if available.  We’ve updated ColorMatrixTransform to produce these images.  Just 8 pixels can represent all of the possible corrections you can apply with a Color Matrix.  We’ll be adding this to more tools soon.

This new version of Fusion also fixes some annoying bugs.  It’s now possible to create an interactive LUT macro.  Previously, interactivity was limited, you just set the LUT up once and left it.  Polylines are now able to evaluate properly at multiple image sizes without randomly evaluating the wrong reference.  And a longstanding issue with spline view redraw has apparently been fixed, making it much easier to use in real-world comps.

Daniel Koch made a ViewShader a while back that does a proper checker underlay for images with straight color, but with this ViewShader, you can go back to using the standard checker underlay if you so choose.

Download AlphaMultiplyDivideVS 1.0

This week, we present six interactive turntables for you to spin. Each one was rendered from a volumetric dataset and can be blended between two views by dragging the mouse vertically. MRI, CT, 3D microscopy and cryomacrotome imaging modalities are all represented here. Check out the bottom right corner for an aptly rendered Bruce Gooch brain.

Each turntable is defined in an XML file that is parsed at run-time to determine the render properties and image asset paths. These assets are streamed in and displayed as needed so the initial download is only about 100KB.

Please view the full post to see the Unity content.

Make sure to right-click on the player and select “Go Fullscreen”.

Example XML: