Joerg Plewe's Blog

WYLIWYT - where you look is where you type in NetBeans

In my latest blog I wrote about the TrackIR device and my Java binding JTrackIR. The device allows to track the users head position and attitude in front of the screen using infrared reflecting strips on a basecap the user has to wear.

Now what to do with it? What about controlling the IDE with the head? Activating different areas (editor, properties, output ...) by just looking at them. So that the keyboard focus is always in the window I am looking at.

A good opportunity for an excercise of NetBeans module development that I did not do for quite a time now (NB5 or so...).

Creating the infrastructure for the module was surprisingly easy. Just calling some wizards for a library module wrapping my jtrackir.jar, a module that does the actual work and a module suite sueing everything together. Finally I created a TopComponent that can control the TrackIR device. I configured the suite to be a standalone application and added some IDE modules to have some more windows for testing. Very easy.
The TopComponent is meant to visualize where the user is looking at. For that, a scheme of the current Mode layout - that's how NetBeans calls the different areas of a GUI application - is rendered as it can be seen at the bottom left of the screenshot. The red dot is the place I'm currently looking at.

To code the functionality I needed some help from the web, but as soon as somebody guide me to WindowManager the rest was quite easy.

Using the module requires a bit of practise and fine tuning the 'sensitivity' value. After that, it is possible to have the focus really in the window I am looking at. I admit the module is of low practical value, but at least it was fun to create the module and get acquainted with some NetBeans APIs e.g. like NbPreferences used to save the sensitivity value.
It was my first time creating, starting and debugging an appplication with the NetBeans RCP and I have to say: very easy, very cool, it just worked! I was suprised how fast the edit-compile-debug cycle was (that has to launch a full copy of the NetBeans framework) even on my poor notebook. I can encourage everybody to try it out.

Head banging...

TrackIR is a headtracking device that currently is quite popular amongst gamers, especially in the simulation community.
It consists of a small device to be placed on top of the monitor and a prepared base cap with three IR reflecting strips.
JTrackIR is my Java binding. Not a big thing, but maybe useful to somebody.

TrackIR shows an impressive resolution and supports all 6 axes (x,y,z,yaw,pitch,roll). So it not only detects the heads attitude but also the translational position and even the heads distance from the screen.

The device is not cheap but also not extraordinary expensive and definitely worth the money if you have a good use-case.

As with all parts of the Distributed RealTime Simulation project on SourceForge, the source is available from cvs.
The Java source code is free while I'm not allowed to opensource the C/C++ code accessing the TrackIR DLL because it is covered under an NDA. So you have to refer to the compiled binary located in the bin directory.

The API is stupid simple. For there can only be a single device, the API layout is completely static. Here are parts of it:


public static void setDeveloperID( int id );
public static void update();
public static boolean isOperational();
public static float getRoll();
public static float getPitch();
public static float getYaw();
public static float getX();
public static float getY();
public static float getZ();
...

The jar file in the bin folder there also contains a simple test UI that paints the values as it is delivered by the device.

Currently, JTrackIR is not yet embodied to FlyingGuns. My own architecture placed the camera far away from the input system, so they are hard to connect :). But there is still some hope.

If you think controlling something with your head and you like to use your head not only for its mental power, JTrackIR allows you to do that easily and your application might proudly show a new logo:

A simple physics/dynamics stack

Are you doing engineering using Java? Or even science? Than you sometimes might need to calculate how objects move under the impression of forces and torques. The following might be for you then...

Maybe somebody of you, dear reader, has already tried out my flight simulator FlyingGuns which is part of the Distributed RealTime Simulation project on SourceForge. The flight model of motion is very simple. I call it physically motivated instead of physical because it relies on some heuristics that are not modeled using forces and torques. That is appropriate for a game but not for a true simulator.

There is no framework to plug in forces that are then correctly treated. This is the main reason why the airplane cannot land, because there is just no mean to model the forces caused by the undercarriage on the ground.

In order to change this, I started to develop a simple dynamics framework. It currently is located in the projects sandbox because the API is not fully settled yet. With this package, it is easy to define bodies that behave physically correct. This is a piece of sample code to setup a 5kg body with gravity G and a Spring:

Body body = new Body();
body.setMass(5.0);

KinematicState state = new KinematicState();
state.attitude(QuatUtil.ONEd);		

CompositeForce f = new CompositeForce();
f.addForce(new G(body));

Vector3d springcenter = new Vector3d(0,0,5);
Spring s = new Spring(springcenter, 5 );
f.addForce( s );

Dynamic dynbody = new Dynamic(body, state, f);

I call it dynamics stack to keep it apart from a physics engine like ODEJava or JOODE. A physics engine is a far more complex beast dealing a lot with collision detection and - as a main task - computing the appropriate forces. But any physics engine needs some kind of dynamics code under the hood.

There is no secret in how to do that. The math is known for hundreds of years meanwhile. Yet some aspects, esp. those concerning rotational motion are highly unintuitive (it took me 2 years to develop kind of mental image). Having this thoroughly solved makes the value of this package.

Stack

Why is it a stack? Because on each level of the stack there is a set of classes implementing the interface of the next lower level. Each level of the stack can be used on its own, omitting higher levels as desired. These are the stacked components:

intergrator
kinematics
dynamics
physics
application, e.g. flight model

Integration

Integration has the task to solve ordinary differential equations (ODE). It gets some initial values and an object that can calculate the resp. derivatives in time d/dt. The integrator has no idea what the values do mean - it has no notion of e.g. position or speed.
There are several well-known ways to do that with different quality and performance. My package implements Euler and RungeKutta. While the algorithms are not easy to understand, the resp. code is quite simple because the algorithms are very well described in various textbooks and there are many samples on the net. Cash-Karp (see Numerical Recipes in C) is currently under development.

The Euler integrator is the most simple one basically perfoming:

x_new = x_old + v*dt

Thats very fast, but only works if forces are small and do hardly ever change. A common spring already may blow that approach. RungeKutta is much more advanced but also takes (at least) four times more CPU power.

Kinematics

Kinematics gives a meaning to terms like position or speed and can transform them to the array of values needed by the integrator. It also respects that we are dealing with second order differential equations (eg. position is order 0, velocity is order 1, acceleration is order 2) and transforms them into a system of equations of first order:
One second order equation

			position = f( velocity, acceleration )

makes 2x first order equation:

			position = f(velocity)
			velocity = f(acceleration)

On the kinematics level, the interface Acceleration plays the key role. On this level, there still is no notion of a phyical body having mass properties.

Dynamics

Dynamics introduces the phyical body having mass and inertia. A class implementing the kinematics interface Acceleration converts forces and torques acting on a physical body into acceleration. While this is trivial for translational properties (just divide by mass - F=ma - remember?), the rotational parts needs some consideration concerning world- and body-fixed coordinate systems and the transforms between them. On the dynamics level, the interface Force plays the key role.

Physics

On this level, forces and torques are defined. It is not truely a level in the stack, but more a collection of utilities. There are predefined forces like gravity G or a spring. Conceptually harder is a class called RotatingPart which allows to model parts within a body that do rotate themselves. Think of propellers or turbines as an example. Again, this rotational things are not easy to deal with on an intuitive level.

Tests

Now how to test dynamics? I took two approaches. One is the classical unit test comparing the results of the integration with a know analytical solution. Here is one taken from a textbook:

	
// problem 10-32 in my edition of Classical Dynamics by Marion+Thornton
@Test
public void spinningPlate() 
{
    Body b = new Body();

    // I1 = 1, I2 = 2*I1, I3 = I1 + I2
    b.setInertia(new Matrix3d(1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0));

    KinematicState state = new KinematicState();
    state.omega(new Vector3d(Math.sqrt(3), 0, 1));

    // with no forces and torques, w_body_y(t) should be |w| cos(a) tanh(|w| t sin(a)).
    // a = 30 degrees, so cos(a) = sqrt(3)/2 and sin(a) = 1/2.  the expected result is
    // thus sqrt(3) * tanh(t).		

    Dynamic d = new Dynamic(b, state, Force.NONE );

    double dt = 1.0/1000.0;
    double t = 0;
    for( int i = 0; i < 300; i++ )
    {
        d.progress((long)t, dt);
        t += dt;
//		System.out.println(i + " " + Math.sqrt(3)*Math.tanh(t) + " " +  state.omega().y);
        assertEquals(Math.sqrt(3)*Math.tanh(t), state.omega().y, 0.05 );
    }
}

The other approach is piecewise comparison with a human judging from the visuals. E.g. assuming euler integration works, I run the system with a RungeKutta integration. The results have to be comparable. The same can be done to show that the calculation of acceleration from forces work correct or that a rotating body behaves like one that does not rotate, but has a rotating part with same inertia.

Things to come (besides an application for a new flight model for FlyingGuns) is some kind of exception handling in case of overstress. Sometime, forces may go beyond their limits that e.g. may destroy the structure. This could be implemented using exceptions.

Little helpers for the editor

The NetBeans source code editor is not known the be the ultimate one these days. From what I heard and saw, IDEA seems to be #1 in this respect today. But sometimes even small things have big effects and make work more enjoyable. Sandip Chitale created a set of linetools as a NetBeans module that nobody should miss. It gives a liteweight way to work with lines. It's very easy to move lines around or duplicate them (and then move around). The same works with multiline selections. Very handy, for it avoids prior selection of text in many cases.

Working with that reminded me of an editor feature I created in the glorious times when I was allowed to work in the Forth programming language (my all-time favorite).

Those days I had a line- and a character stack. A single keystroke allowed to swallow or copy lines or characters to the stack and spit them out at another place. This was one of the features you'll never miss again once getting used to it. Much better than the common cut/copy/paste based on selections.

Sandip, please, can you help me (again)?

My first CVS checkin 2007

This is my first CVS checkin 2007!

Happy coding to everybody in the new year.

C with NetBeans on Linux ... check it out!

My current project is something with C on Linux. This is no fun, believe me. Especially when you are used to the rich development environment in the Java world.

What do we have on Linux? vi, emacs, make, kdevelop, gdb. Ouch.

Fortunately, Java tools reach out to that foreign, hostile world. First I tried Eclipse/CDT which works pretty well and I use it for my daily development. By far the best thing I could get hold of. The C/C++ module for NetBeans, which was at beta3 those days, was not in a productive state.

Today, I gave it a second try with all the brand new stuff. JDK6, NetBeans 5.5 and the new C/C++ development pack - surprise, surprise! It looks pretty polished and works like a charm.

NB/C wraps very nicely around existing Makefiles. This allowed me to browse a real complex project (>1mio LOC) within the IDE very soon. It also recognized the SVN structure immediately and guided me smoothly to checkin the NB projects just created. Another big plus is that it was very easy to create the NB projects completely separated from the source directories. I missed that in Eclipse (maybe it's my fault). And no more switching between 'perspectives' which I always found annoying. A matter of taste. Also, NetBeans 5.5 runs very smooth even on an X terminal.

So I had 2 lucky hours today exploring my new toy. Everything was so easy. Maybe tomorrow I will run into the issues. But thats OK for a first release. I'll just post the issues to the NB bug tracker. Typically they do respond quickly.

What I love about NetBeans is the speed of improvement. Subversion, UML, C/C++ and much more ... all that has been added just recently. So I'm really excited to see what comes next....

What people consider interesting...

Recently I reviewed my blogs access statistics and was quite puzzled why my latest blog about 3D cloud rendering attracted only very few readers. Only about 10% of what I usually have. My expectations have been quite the opposite. I though that an unusual topic (not dealing with creation of web pages) is what makes people curious. About what people do with Java besides creating web pages? About something colourful, animated? People are ten times more fascinated about my thoughts of why I cannot use groovy. How is that possible? What's wrong?

MS FlightX, FlyingGuns and clouds in the sky

Cloud rendering in 3D games, esp. flight simulators, is not easy. Upcoming Microsoft FlightX does a brilliant job for its clouds (amongst many other brillant things) and I assume there has been more than one developer working on it for ... hours at least.

For the FlyingGuns project there are so many things to do that I never even started to think about cloud rendering. Fortunately, IndieTechnologies offers its famous particle system GenesisFX. Using genesisfx.jar, a couple of lines of code are sufficient to create clouds that look quite impressive.

There still is long way towards true clouds, but the ratio of effect/lines_of_code makes the value.
Additionally I used GenesisFX to replace some of my own fire/smoke effects for burning planes. Again, very few lines of code - very impressive result.

Now if someone out there feels inspired to create cool graphical effects in a rich environment, just drop me a line. The FlyingGuns project is constantly looking for support. All other sources can be found in the projects CVS.

/*
 * Clouds.java
 */

package de.hardcode.threed.terrain;

import com.indie.genesis.j3d.CloudPuff;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.vecmath.Color3f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;

/**
 *
 * @author Herkules
 */
public class Clouds extends TransformGroup
{
	private final static double		RADIUS			= 250.0;
	private final static double		GROUPRADIUS		= RADIUS*12.0;
	private final static float		MIN_BRIGHTNESS	= 0.5f;
	private final static float		MAX_BRIGHTNESS	= 0.8f;
	private final static int		NUM_PUFFS		= 40;
	
	private class Cloud extends TransformGroup
	{
		Cloud()
		{
			CloudPuff cloud = new CloudPuff( (float)RADIUS, getCloudColor() );
			cloud.setAlignmentMode( CloudPuff.ROTATE_ABOUT_AXIS );
			cloud.setAlignmentAxis( 0,1,0 );

			Transform3D tx = new Transform3D();
			tx.setTranslation( new Vector3d(	(Math.random()-0.5)*GROUPRADIUS,
												Math.random()*RADIUS, 
												(Math.random()-0.5)*GROUPRADIUS ) );
			setTransform(tx);
			
			addChild(cloud);
		}
		
		Color3f getCloudColor()
		{
			float c = ((float)Math.random() * (MAX_BRIGHTNESS - MIN_BRIGHTNESS)) + MIN_BRIGHTNESS;
			return new Color3f( c,c,c );
		}
	}
	
	/**
	 * Creates a new instance of Clouds
	 */
	public Clouds( float x, float z, float baseheight )
	{
		Transform3D tx = new Transform3D();
		tx.setTranslation(new Vector3f(x, baseheight + (float)RADIUS/2.0f, z));
		setTransform(tx);
		
		for( int i =0; i


Links


FlyingGuns
Distributed  realtime simulation - FlyingGuns' parent project
Indie Technologies

Why I don't use Groovy: I just cannot.

Groovy is a cool language and I'd like to use it. But how to?

Whenever I start editing a Groovy script with my favorite IDE, I notice that I really don't know all the Java APIs by heart. Hands up who can setup BufferedReader/Reader/InputStream/whatever chain without code completion and parameter help in the IDE? Ok, Coyote offers some basic support like syntax coloring, but this doesn't help very much.

What I always need to do is to open a dummy Java class in parallel and edit all my Java-related expressions there using the full-blown IDE support. When the statement is fine, copy&paste to the Groovy script. But the easy-of-use promised by a sweet syntax is complete compromised by that.

I'd love to do sketches or API experiments using a scripting language, but for the lack of IDE support this is much easier using Java itself. That's a pitty.
From what I here from Eclipse people, the situation over there is pretty much the same.

So what do you do?

NetBeans, Eclipse, IDEA ... pah! VS2003!

There are many discussions around: which is the best IDE?
From my current point of view: take any of these and be happy! Really.

When still working in the Java area, I was used to NetBeans. Many of my collegues used Eclipse, the rich ones used IDEA. Of course, we flamed and discussed a lot about it. IDE is religion.

Nowadays, I have to work with C#/C++ on .NET1.1. The tool of choice: Visual Studio 2003.

What a contrast!

Although I worked with Visual Studio for years in the past and felt quite comfortable with it - today I miss everything! Visual Studio is Notepad.exe plus some small extra features. But most of the features we got used to and that make our daily work so enjoyable are missing:

no usable code completion worth mentioning
no suggestions about exception handling, redundant using or namespace qualifiers, types,...
no good VCS integration (beside good'ol SourceSafe, which is not used here)
no refactorings
no 'where used'
no unit testcase generation (TestDriven helps a bit)
no (insert any point you like about your IDE here)
no (insert any point you like about your IDE here)
no (insert any point you like about your IDE here)
no (insert any point you like about your IDE here)

It feels like being kicked back to stoneage. Not even talking about these ugly, cluttered toolbars, these always-too-small, not resizable dialogs,...

Conclusion: if you can use any of the leading Java IDEs, be happy with it. Really happy. Know that you are far ahead us poor VS guys.

db4o and it's queries

I mentioned the lightweight OODB db4o in some earlier blog entries and I admit that I really like that piece of software.
For that, I like to guide your attention to another blog, giving a nice overview about the various approaches for queries, esp. the native queries introduced with db4o V5.0. I feel it is worth reading.

'Close' icons on a JTabbedPane w/o UI interference

Many apps require a 'close' icon on a tab of a JTabbedPane. The solutions I've seen so far all require manipulation of the L&F classes which can be considered bad in many respects.

There is another option that works without interference with the UI classes. It relies on a special implementation of Icon that is sensitive to the mouse itself. Such an icon can be set for each tab (setIconAt()). This solution is far from perfect. E.g. the close icon always appears on the left side of the tabs text. But it is simple, easy to use and works with all L&Fs. The schema might be useful in other areas of icon usage as well.

How does it work?

The implementation of CloseTabIcon uses are common Icon and delegates all method calls to it. Just, during paintIcon(), it remembers the last position the icon has been painted and additionally adds a MouseListener to the resp. Component. This mouselistener can test wether the mouse button has been pressed above the icon and perform the appropriate action then.

In order not to loose the possibility to set an icon to the tab that does not close it, I provide another utility class CombinedIcon. It implements Icon and delegates to two Icons given to its constructor. Using CombinedIcon and CloseTabIcon can create JTabbedPanes like this:


/*
 * TabCloseIcon.java
 */

package de.hardcode.util.swing;

import java.awt.Component;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JTabbedPane;

/**
 *
 * @author Herkules
 */
public class TabCloseIcon implements Icon
{
	private final Icon mIcon;
	private JTabbedPane mTabbedPane = null;
	private transient Rectangle mPosition = null;
	
	/**
	 * Creates a new instance of TabCloseIcon.
	 */
	public TabCloseIcon( Icon icon )
	{
		mIcon = icon;
	}
	
	
	/**
	 * Creates a new instance of TabCloseIcon.
	 */
	public TabCloseIcon()
	{
		this( new ImageIcon( TabCloseIcon.class.getResource("icons/closeTab.gif")) );
	}
	
	
	/**
	 * when painting, remember last position painted.
	 */
	public void paintIcon(Component c, Graphics g, int x, int y)
	{
		if( null==mTabbedPane )
		{
			mTabbedPane = (JTabbedPane)c;
			mTabbedPane.addMouseListener( new MouseAdapter()
			{
				@Override public void mouseReleased( MouseEvent e )
				{
					// asking for isConsumed is *very* important, otherwise more than one tab might get closed!
					if ( !e.isConsumed()  &&   mPosition.contains( e.getX(), e.getY() ) )
					{
						final int index = mTabbedPane.getSelectedIndex();
						mTabbedPane.remove( index );
						e.consume();
					}
				}
			});
		}
		
		mPosition = new Rectangle( x,y, getIconWidth(), getIconHeight() );
		mIcon.paintIcon(c, g, x, y );
	}
	
	
	/**
	 * just delegate
	 */
	public int getIconWidth()
	{
		return mIcon.getIconWidth();
	}
	
	/**
	 * just delegate
	 */
	public int getIconHeight()
	{
		return mIcon.getIconHeight();
	}
	
}

Find the sourcecode here and a usage sample here.

L&F getting active! Substantially!

Surprise, surprise! L&Fs today don't just look nice. Some add new features to the GUI:

When I started the daily build of NetBeans with my preferred configuration I noticed a small new button in the menubar. I tried it out. It allows to find and activate any menu item that contains a certain text. For each menuitem a small button with a descriptive tooltip is added. Pushing it drops down the resp. menu. How cool! These NetBeans guys .... ts ts ts.... :)

A moment later I figured out that not NetBeans was doing the magic ... jEdit suddenly had the same feature.

In fact, the Substance L&F is responsible for that new feature. IMHO thats new: a L&F not only dealing with the L&F but also adding extended GUI features.
I'm really keen to see what's coming next, go ahead kirillcool!

Quick tabbedpane switching w/o sacrifying mnemonics

Having JTabbedPanes with many tabs can be awkward concerning keyboard usage. Per-tab mnemonics are not really an option because they really limit the number of available mnemonics for the tabs own valuable content!

Facing this problem, I created the TabSwitcher utility applicable to any JTabbedPane:

new TabSwitcher(tabbedpane, KeyStroke.getKeyStroke(KeyEvent.VK_T, KeyEvent.ALT_DOWN_MASK));

TabSwitcher will automatically pop up when the given KeyStroke occurs on the JTabbedPane. It reflects the current number of tabs with their resp. titles and icons, computes a reasonable set of mnemonics and offers them as a JPopupMenu right at the position of the currently selected tab.

For the usage is mnemonic-like, I suggest to use an ALT-combination for the KeyStroke (Alt-T in my sample above).

Find the sourcecode here and a usage sample here.

Pressing F5 all the day.... waiting for NetBeans 4.1

These days I tend to press F5 in my favorite browser every couple of minutes. I'm visiting the NetBeans page and cannot wait the delivery of NetBeans 4.1 since the release branch is known to be taken.

Sure, 4.0 has been a big step in the development of NetBeans, but from my point of view (J2SE) introduced a lot of difficulties. I cannot judge how the benefits have been to the J2EE world, but I severely suffered from the new project system. It took huge efforts to create a NetBeans-compatible and usable project structure for the FlyingGuns project.
Ok, there have been 1 or 2 refactoring methods but that project system...
It brought me close to switching to Eclipse.

For I use to work with the 4.1 daily builds I can say there are huge improvements on that side. So I'm just too eager seeing 4.1 released so that I can convert my 4.0 projects into a much more usable form. For me, 4.0 could have been skipped. 4.1 now is the truely renewed NetBeans!

But there is more to look forward to:

multi-sourcedirectory projects (yeah!)
nice editor features (some not very obvious, like treatment of import) and more annotations
Ant debugger
the nice and completely new Navigator
import of Eclipse projects
direct usage of Maven projects
...

Just around the corner, the integrated profiler, improved version control and unit tests and much more is already waiting. The future is bright.

Seems today the release won't come any more. So I go home now. But tomorrow, maybe, I'll start pressing F5 again...