Run your Maven applications with TomEE plugin

If you are coding JEE applications you will probably need a server which allows you to quickly run and test your code.  If you are looking for a painless solution then TomEE might be your favorite choice. In particular if you are working with Maven projects.

At the moment the current version of TomEE is 1.7 which is based on Tomcat 7 and supports JEE6. The only thing you have to do is to include and configure the tomee-maven-plugin in your pom.xml:

<plugin>
   <groupId>org.apache.openejb.maven</groupId>
   <artifactId>tomee-maven-plugin</artifactId>
   <version>1.7.1</version>
   <configuration>
      <tomeeVersion>1.7.1</tomeeVersion>
      <tomeeClassifier>plus</tomeeClassifier>
      <synchronization>
         <extensions>
            <extension>.class</extension>
         </extensions>
      </synchronization>
      <reloadOnUpdate>true</reloadOnUpdate>
   </configuration>
</plugin>

Depending on the features you need TomEE supports different profiles. To start a TomEE server and run your application simply type

mvn clean install tomee:run

The synchronization block in the configuration is optional and allows you to redeploy your application automatically after each mvn clean install of your application.

Get images from a webcam and do some face recognition

Today I show you a simple way to get images of your webcam and do some fancy face recognition. To glue it together I use a small JavaFX application and display the video stream as well as the recognized faces. You can download or checkout the complete project from: https://github.com/tobiasdenzler/face-recognition.

Before we start you should have a quick look at the webcam-capture library we will use. It is a really cool project and offers lot more features than we are investigating now. If you are interested in image capture/recognition stuff you might also like to dive into OpenIMAJ, a quite extensive set of image analysis tools. The webcam-capture library partly depends on this toolset.

The webcam-capture library is available on maven-central. The classes from OpenIMAJ which we will need to recognize some faces you can get from http://maven.openimaj.org repository. Check the pom.xml for details.

<dependency>
    <groupId>com.github.sarxos</groupId>
    <artifactId>webcam-capture</artifactId>
    <version>0.3.9</version>
<dependency>
    <groupId>org.openimaj</groupId>
    <artifactId>faces</artifactId>
    <version>1.1</version>
</dependency>

It is quite easy to access the stream from your webcam and get an image from there. First, get your default camera, then set your view size and open the webcam. You will find some great examples on how to use the webcam-capture library on their Github site here. To get an image from the webcam you simply call getImage().

Webcam webcam = Webcam.getDefault();
webcam.setViewSize(new Dimension(640, 480));
webcam.open();

BufferedImage capture = webcam.getImage();

For face detection tasks you can use different detectors from the openimaj package. Here we use a very basic one which returns a list of the recognized face patches.

HaarCascadeDetector detector = new HaarCascadeDetector();
Lisz<DetectedFace> faces = detector.detectFaces(ImageUtilities.createFImage(capture));

That's all the magic. To use it inside a JavaFX application you start a new thread in which you read your webcam stream and do the recognition tasks. See my sample project on Github for more details.

JavaFX: Pie chart using dynamic data

The JavaFX SDK contains some pretty nice charts which you can use without much configuration. The documentation from JavaFX provides tutorials for each of the 6 chart types plus a section about styling the charts using CSS.

In the following examples we use a PieChart and feed it with dynamically changing data. We will count each distinct character of an input text field and display the new values while the user changes the input value.

package sample;

import javafx.application.Application;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.Scene;
import javafx.scene.chart.PieChart;
import javafx.scene.control.TextField;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class PieChartExample extends Application {

    // list that holds the values you want to display on the chart
    private static ObservableList<PieChart.Data> list = FXCollections.observableList(new ArrayList<PieChart.Data>());

    @Override
    public void start(Stage primaryStage) throws Exception {

        VBox root = new VBox();
        Scene scene = new Scene(root, 1024, 768);

        // text field for user input
        final TextField textField1 = new TextField();
        textField1.setPrefWidth(1000);

        // listener will be invoked whenever the user changes the value
        textField1.textProperty().addListener(new ChangeListener<String>() {

            @Override
            public void changed(ObservableValue<? extends String> observable, String oldValue, String newValue) {

                list.clear();
                
                // fill the list containing data for the chart with the values from the map
                for(Map.Entry<String, Integer> entry : countCharactersOfString(newValue).entrySet()) {
                    list.add(new PieChart.Data(entry.getKey(), entry.getValue()));
                }
            }
        });

        // set up the pie chart
        PieChart pieChart = new PieChart();
        pieChart.setData(list);
        pieChart.setLegendVisible(false);
        pieChart.setPrefHeight(900);

        root.getChildren().addAll(textField1, pieChart);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    /**
     * Count all distinct characters of a string an put them in a map.
     * 
     * @param input String from user input
     * @return map with character as key and occurrence as value
     */
    private Map<String, Integer> countCharactersOfString(String input) {

        Map<String, Integer> countMap = new HashMap<String, Integer>();
        char[] charArray = input.toCharArray();

        for (char currentChar : charArray) {
            String current = String.valueOf(currentChar);
            if (countMap.containsKey(current)) {
                countMap.replace(current, countMap.get(current) + 1);
            } else {
                countMap.put(current, 1);
            }
        }

        return countMap;
    }
}

If you enter some characters in the textfield at the top you will see that the pie chart dynamically changes its values. We listen to changes in the input text field and count the entered characters and the ObservableList reflects every manipulation we do in the list also to the chart.

Twitter4J: Read public sample stream from Twitter

Today I am going to show you how to use Twitter4J to read a public sample stream of tweets from Twitter. Twitter4J is an unofficial Java library for the Twitter API and you can use it easily to integrate Twitter services in your application. Besides reading streams you can do a lot more like post or search Tweets. Twitter itself provides a bunch of documentation for developers and also a chapter on their Streaming API. This API gives you low latency access to Twitter's global stream of Tweet data.

You can get twitter4j-core from Maven central repository. For the streaming functionality you also need the twitter4j-stream library:

<dependency>
   <groupid>org.twitter4j</groupid>
   <artifactid>twitter4j-core</artifactid>
   <version>[3.0,)</version>
<dependency>
<dependency>
    <groupid>org.twitter4j</groupid>
    <artifactid>twitter4j-stream</artifactid>    
    <version>[3.0,)</version>
</dependency> 

Access to Twitters Streaming API is done by OAuth and you have to register your application first to get the needed set of credentials. After signing in with your regular Twitter account you can generate the following credentials and write it down in a twitter4j.properties file.

oauth.consumerKey=************
oauth.consumerSecret=************
oauth.accessToken=************
oauth.accessTokenSecret=************

To read the stream you can get a TwitterStream from the TwitterStreamFactory. Then you implement a Listener called StatusListener with a bunch of methods and your almost done. In the end you start streaming by calling the sample() method (that will stream from the Twitter sample stream).

import twitter4j.*;

public class TwitterStreamingClient {

   public static void main(String[] args) {

      TwitterStream stream = new TwitterStreamFactory().getInstance();
      stream.addListener(new StatusListener() {

         @Override
         public void onStatus(Status status) {
             System.out.println(status.getText());
         }

         @Override
         public void onDeletionNotice(StatusDeletionNotice statusDeletionNotice) {}

         @Override
         public void onTrackLimitationNotice(int i) {}

         @Override
         public void onScrubGeo(long l, long l2) {}

         @Override
         public void onStallWarning(StallWarning stallWarning) {}

         @Override
         public void onException(Exception e) {}
      });
      stream.sample();
   }
}

The Status object gives you all information about a Tweet like content, user, geolocation and many others. Check the Twitter4J documentation for more details.

See also

• Twitter4J
• Twitter Developers
• OAuth on Wikipedia