If you want an excellent introduction into Java 3D, look no further than here. I was following the tutorial I found there to get started with what looked to me as the perfect way of spending a Friday evening, when, somewhere at the end, it told me that:

(…) it does not mix very well with Sun.s swing user interface components. These components are called “lightweight” Lightweight components can be hidden by a Canvas3D even if they are supposed to be at the front.

Obviously, I had been planning on embedding hugely impressive 3D animations into a NetBeans Platform Application, and I was not going to be disappointed, so I fired up NetBeans and did it anyway. Here’s how.

Preconditions: The j3dcore JAR files are downloaded and unpacked. You can find them here. I never trust generic Linux installers, because I have no idea what distro those people had in mind when creating them. So I chose one from the zip binaries and ignored the installers. Select the appropriate one for your machine. Unpack the zip file. There’s a second zip file inside. Unpack it too. Put the JAR files and the .so file somewhere where you want to keep them.

There appears to exist a NetBeans plugin for java-3d, but my NetBeans (7.0.1) didn’t find it, and at least one user comment indicates massive issues, so I didn’t bother with it.

1. Create a new Application: File -> New Project. In the Wizard, under Choose Project, select NetBeans Modules -> NetBeans Platform Application and click Next. Enter the name of the application. I called it Test3D. Click Finish.
2. The j3dcore JAR files have to be wrapped into a Module. Expand the Test3D project node, right click Modules and select Add New. Use j3dcore as your project name and click Next.  Use net.java.j3dcore as the Module’s code name base.
3. Right click the j3dcore module node and choose Properties. Under Libraries, click the Wrapped JARs tab and click Add JAR. Navigate to the j3dcore JAR files, select them all (hold shift or ctrl) and click OK.
4. You now have a library wrapper module, but you lack the shared object file that will allow them to use you graphics adapter. In Test3D, expand the Important Files node. Open the Project Properties file, and add the following line:

   run.args.extra=-J-Djava.library.path=<the path to the location of your .so file>

   Do not include the name of the file itself. Be sure to add this to the Project Properties file of your main project, Test3D, and not the wrapper module. It has its own Project Properties file.

5. Add a new module that creates and displays your 3D scene. Right click Modules under Test3D and click Add New. Enter a name. I chose Universe. Enter your code name base and click Finish.
6. Add a new TopComponent. Right click the Universe node and click New -> Other. In the New File wizard, select Module Development -> Window. Select Editor as Window Placement and select Open on Application Start. Click Next. Enter UniverseTopComponent after Class Name Prefix and click Finish.
7. Open UniverseTopComponent. In the Design View, add a JPanel that fully covers the TopComponent. Right click it, select Change Variable Name and enter myUniverse. Right click it again, choose Set Layout -> Border Layout.
8. Switch to the Source Editor, and change the constructor into this:

    public UniverseTopComponent() {

        initComponents();
        setName(NbBundle.getMessage(UniverseTopComponent.class,
                "CTL_UniverseTopComponent"));
        setToolTipText(NbBundle.getMessage(UniverseTopComponent.class,
                "HINT_UniverseTopComponent"));

        GraphicsConfiguration config = SimpleUniverse.getPreferredConfiguration();
        Canvas3D canvas = new Canvas3D(config);
        myUniverse.add(canvas, BorderLayout.CENTER);        

        BranchGroup group = new BranchGroup();

        Sphere sphere = new Sphere(0.2f);
        group.addChild(sphere);

        Color3f lightColor = new Color3f(1.8f, 0.1f, 0.1f);
        BoundingSphere bounds =
                new BoundingSphere(new Point3d(0.0, 0.0, 0.0), 100.0);

        Vector3f lightDirection = new Vector3f(4.0f, -7.0f, -12.0f);
        DirectionalLight light = new DirectionalLight(lightColor, lightDirection);
        light.setInfluencingBounds(bounds);
        group.addChild(light);

        SimpleUniverse universe = new SimpleUniverse(canvas);
        universe.getViewingPlatform().setNominalViewingTransform();
        universe.addBranchGraph(group);

    }

9. Right click the editor window and select Fix Imports from the popup menu. Then build and run the project. Your output should look like this:

Test3D with Universe Window

Conclusion: it is possible to embed a Java 3D scene into a NetBeans Platform Application.

This one is not really an eye-opener, but I use this blog to record and archive stuff I find out at some point, so here’s a post about getting NetBeans Platform Applications use GTK instead of Metal.

Since the Swing Application Framework (SAF) has been deprecated and developing NetBeans Platform Applications (NPA) is the new and better way to do these things, I’ve bought a good book on the subject, and am quite satisfied with the way Java desktop applications are to be developed these days.

However, under Linux, Swing applications default to the ugly Metal widget set:

Metal widget set. Click to zoom.

On the command line and using SAF it is in fact pretty easy to make Swing use the GTK widgets. This way Java applications get a native look and feel under Linux. With NPA however, there is no right place to insert a few lines of code to do this at startup.

To make NetBeans itself use the GTK widgets, I always start the IDE like this:

# netbeans --laf com.sun.java.swing.plaf.gtk.GTKLookAndFeel

Since NetBeans is itself an NPA,  I figured the trick would be to specify this option somewhere in the application’s configuration. I googled around a bit and found the answer here. The trick is to add a single line to the project.properties file, which can be found inside the Important Files folder within the NPA project. That line is:

run.args.extra=--laf com.sun.java.swing.plaf.gtk.GTKLookAndFeel

And now, under KDE4, my application looks like this:

GTK widget set. Click to zoom.

Not exactly a KDE4 look-and-feel, but I have lots of applications (Gimp, GQView,  LibreOffice) that use GTK so it still looks native on my desktop, and GTK is a lot prettier than Metal.

Now why it is a good idea to write desktop applications instead of web applications, especially in Java, is something that Geertjan Wielenga talks about on his blog. Well worth the read.

Today, I found this in my mail:

The “success kit” included a lifetime membership card for

(…) an elite group of Oracle Certified Professionals (…)

And I had hoped for a coffee pack

But still. Excellent.

I’m currently learning Enterprise Java Beans 3 using Debu Panda et al.’s book EJB3 in Action. The material is not very hard but there’s lots of stuff to memorize, and the best way to do that is by running the code examples and trying to change it (and break it). The easiest way to do that is by using an IDE, but the book isn’t very helpful in that area, and I didn’t find it really transparent or straightforward, so here’s a write up of what I did to make the code examples of the first chapter work in NetBeans.

You’ll need a NetBeans installation with most of the trimmings for this to work. Make sure GlassFish Server 3 and JavaDB are working.

The first chapter is about a simple Hello World application. To deploy it, we need an EJB3 module and a Web Application Module. The latter will be the client, replacing the client application provided by the book.

1. In NetBeans, create a new project: Java EE -> Enterprise Application (click Next).
2. Enter HelloUser as project name and click Next.
3. Click Enable Context and Dependency Injection and click Finish.
4. Download and unzip the example sources.
5. Within the newly created directory, locate the directory glassfish/chapter1/src/ejb/bean/ejb3inaction, and copy it to HelloUser/HelloUser-ejb/src/java/ within your NetBeans project directory.
6. From the example sources directory,  locate the directory glassfish/chapter1/src/ejb/client/ejb3inaction, and copy it to HelloUser/HelloUser-war/src/java/ within your NetBeans project directory.

The client class provided by the book is a very simple illustration of what has been explained so far:

package ejb3inaction.buslogic;

import ejb3inaction.example.HelloUser;

import javax.ejb.EJB;

public class HelloUserClient {

    @EJB
    private static HelloUser helloUser;

    public static void main(String[] args) {
        helloUser.sayHello("Curious George");
        System.out.println("Invoked EJB successfully .. see server console for output");
    }
}

This is not something that I could run from inside NetBeans, so I wrote a servlet that contains the same code.

1. In the Projects frame, expand HelloUser-war -> Source Packages -> ejb3inaction.example. This package was created when we copied the files to HelloUser-war, back in step 6.
2. Right click the package node and click New Servlet…
3. Use HelloUserServlet as class name and select Add information to deployment descriptor (web.xml). Click Finish.
4. Replace everything between the import statements and the HttpServlet methods (they’re folded) with the following:

import javax.ejb.EJB;

public class HelloUserServlet extends HttpServlet {

    @EJB
    private HelloUser bean;

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");

        bean.sayHello("Curious George");

        PrintWriter out = response.getWriter();
        try {
            out.println("<html>");
            out.println("<head>");
            out.println("<title>Servlet HelloUserServlet</title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<p>Invoked EJB successfully .. see server console for output</p>");
            out.println("</body>");
            out.println("</html>");
        } finally {
            out.close();
        }
    } 

As you can see, it is very easy to create a servlet that does what the main method in the client class from the book does, by simply copying a few lines and removing a few unneeded ones from the default servlet created by NetBeans.

When you run the project, your web browser will come up but you won’t see the output yet. Direct it to http://localhost:8080/HelloUser-war/HelloUserServlet. You should see a single line of text. In NetBeans, go to the output window and select the GlassFish Server 3 tab. There should be a line starting with the word INFO, followed by the text from HelloUserBean.sayHello().

Now let’s see if this approach will work equally well for the rest of the examples in the book.

Since the start of this month I have been looking for a new job, because my current position at the Research and Documentation Centre of the Dutch Ministry of Justice will end January 31st next year. Barely a day after leaving my resume at nationalevacaturebank.nl, I got a few dozen calls from recuiting agencies and other companies, interested in getting to know me. One of those companies was Sogyo, a smallish company in De Bilt, specialised in software architecture,  development and integration.

(Promotional video in Dutch)

When I arrived at Sogyo for my first interview, I was a little early, so I was offered a cup of coffee and  asked to wait a few moments. While enjoying the coffee, I looked at the books in a book case, and was pleasantly surprised to find Noami Klein’s The Shock Doctrine. It appears I’ll be feeling quite at home there.

I’ll start working there February first.

The weirdest thing happened while I was programming with my favorite IDE, Netbeans 6.8, today. When I work on big applications, I usually split them in two or three projects (usually model, view, controller). Then I import the projects in the main application project. At some point Netbeans suddenly told me it couldn’t find a class in an imported project to which I referred, even though nothing was wrong with it, and everything compiled perfectly using Ant. Netbeans however insisted the class wasn’t there and produced error messages and enough red warning lines to make it unworkable.

I googled around a bit, but found nothing. So before trying to find the actual problem, I made a copy of the class that Netbeans couldn’t find, deleted the old one, and renamed the copy to the original. And then the problem was gone.

What gives?

UPDATE (2009-05-09): The ‘laf’ option to the Netbeans executable should be preceeded by a double dash (–laf) instead of a single one. Corrected.

From the first moment that I used Linux, some 9 years ago, I was a KDE user. When KDE 4 came, I switched to Gnome, because I found KDE 4 unstable and slow. I like eye-candy, but not at the expense of speed.

However, I’ve been trying out Kubuntu 9.04 for a few days now, and I must say I like it. It is faster than Gnome with Compiz, just as stable and it looks way better than Gnome. That, and the one complaint I have about Gnome, its lack of functionality to protect users for getting confused, is slowly converting me back to KDE again.

But since Java is my language of choice whenever databases are concerned, I write my desktop applications for personal use in Swing. I hate the default Metal look and feel, so I’m happy to report that I have found out how to give Swing applications a QT4 look.

First, you have to install a gtk qt4 engine. On Kubuntu, you do that like this:


# sudo apt-get install gtk-qt-engine-kde4


In your swing application, insert this piece of code into the main method:

try {
    UIManager.setLookAndFeel
        ("com.sun.java.swing.plaf.gtk.GTKLookAndFeel");
} catch (Exception ex) {
    System.out.println (ex);
}

If you’re using the Netbeans Application Framework, insert it in the constructor of xView.java, where x is usually the name of your project.

In addition, if you want Netbeans to look QT4 as well, start it like this:


# /opt/netbeans-6.5.1/bin/netbeans --laf com.sun.java.swing.plaf.gtk.GTKLookAndFeel


For a small msx adventure game I’m creating, I needed a map with three islands. A big one and two smaller ones. I’m not going to tell you what kind of game it is and if  I will ever finish it (because chances are I won’t), but that’s not the point here. The point it, how did I create the maps.

Using a small Java program called Fractalzoom, which I wrote yesterday evening. Fractalzoom is a small cli tool that takes a square gif image and randomly replaces its pixels with their neighbours. The function (I always call static java methods functions, because that’s what they really are) that does the work is really simple:

public static void process(Gif gif, Options options) throws Exception {
  if (options.isVerbose())
  System.out.print ("Processing: ");

  for (int n = 0; n < options.getIterations(); n++) {
    if (options.isVerbose())
    System.out.print (".");
    for (int i = 1; i < gif.getHeight()-1; i++) {
      for (int j = 1; j < gif.getWidth()-1; j++) {

        int[] choices = new int[4];

        choices[0] = gif.getPaletteIndex(gif.getPixel(i, j-1)); // left
        choices[1] = gif.getPaletteIndex(gif.getPixel(i, j+1)); // right
        choices[2] = gif.getPaletteIndex(gif.getPixel(i-1, j)); // up
        choices[3] = gif.getPaletteIndex(gif.getPixel(i+1, j)); // down

        int choice = (int)Math.round(Math.random()*(choices.length-1));
        gif.setPixel(i, j, gif.getColour(choices[choice]));
      }
    }
  }
}

Gif is a wrapper class I created to facilitate using Wen Yu’s gifcodec, which lets me edit gif files. You should know that the gif format stores 256 colours in a palette and then uses their indexes throughout the rest of the file for each pixel. (Actually, it uses compression, but that’s not important here). What the code above does is visit every pixel in the file, find out the indexes of its neighbouring pixels, and then replaces it with one of them.

To use it, I create an image of for example 10 x 10 pixels. I use the Gimp. I fill it entirely with a dark blue colour, and then make a few pixels green, so that I have the rough outlines of my three islands. Then I scale it to 1000 percent, using no interpolation (that is important: I want 10×10 squares for each original pixel, and no anti-aliasing).

UPDATE: Instead of using Gimp for scaling, you can use ImageMagick to do it from a shell, which is nice if you have a lot of tiles:

# convert infile.gif -scale 1000% outfile.gif

# mogrify -scale 1000% *.gif

The resulting image is this:

The original 10x10 pixels image, scaled up ten times.

Then I unleash Fractalzoom:

# fractalzoom stage1.gif

I get an image just as big, but with rigged coastlines:

stage1-zoomed: the scaled up version of the original image, after one run through fractalzoom.

After that, I open it again in the Gimp, scaled it up 10 times again (again: no interpolation), and add elevated terrain using brown and white:

stage2 with elevated terrain, scaled up.

Next, I use Fractalzoom again, same as before. The image is larger, so it does more iterations. The result is this:

stage2-zoomed: the final version of my map, with rigged elevated terrain.

The result is a usable and realistic looking map (well, at least for my purposes). My islands have rigged coastal lines, bays, lakes, small islands of their coasts  and mountains with snow caps. If you think you can use it, you can download fractalzoom here. It should work on any machine with java 6.

UPDATE: After creating the map, I needed to divide it into tiles. The easiest way of doing this is using ImageMagick again:

# convert -crop 100x100 infile.gif outfile-%d.gif

The above results in tiles of 100 by 100 pixels each with the same name as the original file, appended with a number. The number of each individual tile designates where the tile is when ordered from left to right, top to bottom.