This demo opens a Full Screen Exclusive Mode Window and displays one line of text and two images on an otherwise entirely blank (black) screen.

• HelloPsychophysicist.java is pure Java version
• HelloPsychophysicist.m is Matlab version.
• XX is Mathematica version. (coming soon!)
• fechner.png and psychophysik.png are necessary image files for all versions.

Make sure that you have installed psychWithJava package and configured your environment.
• Pure Java version
Download the necessary files in your local drive. Open a terminal/command window and change to the directory where you saved the files. To compile type

javac HelloPsychophysicist.java

and press enter. If there were no errors, type

java HelloPsychophysicist

and press enter to run the program. For more information on command line development and development with Eclipse see the instructions on Building projects using psychWithJava to compile and run Java programs.
• Matlab version
Download the above listed necessary files in your current working directory and type (on Matlab command window)

HelloPsychophysicist

and press enter. See Building projects using psychWithJava for more information
• Matematica version
Coming soon!

Pure Java version
Matlab version
Mathematica version

Precompiled program is in HelloPsychophysicist.jar, which is a self running jar file. You can either run it directly from your browser or download the file on your local disk and run it with a double click.

FullScreen manual pages,
NormalWindow version of HelloPsychophysicist.

Pure Java version is in HelloPsychophysicist.java file.
First seven common steps
1. Import the necessary classes/packages
First place import lines in the beginning of your Java code, including the necessary classes from psychWithJava package.

import java.awt.image.BufferedImage;
import java.io.IOException;
import javax.imageio.ImageIO;

import psychWithJava.FullScreen;

Alternatively you can import all classes from a package

import psychWithJava.*;

After importing classes you will no more need to explicitly type the full path of these classes in your code.

Declare a public class and create a main method The name of the public class must be the same as the first part (the part before .java) of the file name

public class HelloPsychophysicist extends FullScreen implements Runnable {

  public static void main(String[] args) {

To execute a Java file, you must have a main method in a public class, placed in a file of the same name as the class. For example definition of HelloPsychophysicist class is placed in HelloPsychophysicist.java The syntax of the main method is important, it has to be exactly as shown above. extends and implements keywords are used for inheritance. This syntax means that HelloPsychophysicist is a class which inherits from another class called FullScreen. FullScreen is the class, which provides many of the methods needed for the Psychophysics experiments. By inheriting from that class HelloPsychophysicist becomes a FullScreen class and more. That is, it has all the methods of FullScreen available. HelloPsychophysicist also inherits from an interface (a sort of class with no method definitions) called Runnable. We do this because a new Thread can be created by using a Runnable object. Threads are useful because multiple of them can run concurrently by the CPU.
2. Create an instance of the HelloPsychophysicist class
In the main method, create a HelloPsychophysicist object fs as follows

HelloPsychophysicist fs = new HelloPsychophysicist();

Recall that HelloPsychophysicist is FullScreen, therefore constructing a HelloPsychophysicist is nearly equivalent to constructing a FullScreen object. For more information on the constructor of FullScreen see Chapter 2: Hello Psychophysicist and Chapter 10: Managing (multiple) displays.
3. Initialize certain aspects of your object.
Here set the number of video buffers to 2. By default the number of video buffers is 1.

fs.setNBuffers(2);

4. Create a new Thread and start it

Thread experiment = new Thread(fs);
experiment.start();

Threads are explained in the Guide in Chapter 3 and in Chapter 5 (coming soon!). You can construct a Thread with a Runnable object. Remember that HelloPsychophysicist is a Runnable object, as well as a FullScreen object. A class that implements Runnable interface must have a public method called run(). This method is automatically invoked when you start your Thread.
5. Provide the run() method

public void run()

the method should be declared exactly as above.
6. Place the experiment/animation inside run(), use try-catch-finally

public void run(){
  
  try{
    \\your methods for animation 
  } catch(){
    \\catch the exceptions, that is, if something goes wrong
  } finally {
    \\in the end clean up and return the resources used
    closeScreen();
  }

Always invoke closeScreen() method inside finally{}. See Chapter 2: Hello Psychophysicist and Chapter 10: Managing (multiple) displays for the details of closeScreen() method.

Above 7 steps are going to be nearly identical in all demos, except the names of files and corresponding public classes. If you use an IDE, such as Eclipse, it will assist you with most of the steps. For instance you won't need to remember which classes to import. IDEs usually determine your import needs and place them in the beginning of your file. They will also warn you that you should have a public method called run() since your class inherits from Runnable interface. They will assist for catching the Exceptions, as well.

The experiment/animation, inside the run() method
This is the part, which will vary depending on your experiment.
• Display text, wait for a while
Display some text, draw it actually on the screen and wait for 2 seconds without doing anything

try{
  displayText("Hello Psychophysicist (pure Java)");
  updateScreen();
  Thread.sleep(2000);

displayText(String) method displays the text stored in a String object at the center of the video buffer. It is overloaded, you can define the position where you want to place the upper left corner of the text on your screen by invoking displayText(int,int,String). See Chapter 2: Hello Psychophysicist for more on displayText() method. Next you have to invoke updateScreen() method. Because although you invoked displayText() method, you only painted the text on a back video buffer. To actually display on the computer screen this back buffer should be brought to front by updateScreen(). You can find more information on double video buffering and updateScreen() method in Chapter 2: Hello Psychophysicist. sleep(long) is a static method of Thread class. It causes the thread stop execution for the given amount of time (in milliseconds). However this method throws an InterruptedException, which means that something may go wrong. You have to take care of this, you have to catch that exception and preferably do something

catch (InterruptedException e) {
  Thread.currentThread().interrupt();
}

this will clear the interrupted status of the thread. You could just catch the exception and not do anything, but never do that. Instead invoke the interrupt() method to clear the interrupted status.
• Blank the screen, hide the cursor

blankScreen();
hideCursor();

If you don't blank the screen (back buffer), you will paint over the existing screen. This is useful for animations when you want to update only a portion of the screen. But in this example we need to clean it first. (try and see what happens if you don't do that.)
• Read in and display an image

BufferedImage bi1 = ImageIO.read(
    HelloPsychophysicist.class.getResource("psychophysik.png"));
displayImage(bi1);
updateScreen();

There are many ways of reading an image from a file. The way shown above is useful because it works when you package your applications in a single jar file. If you don't have to prepare jar files then you can use the following simpler version

BufferedImage bi1 = ImageIO.read(new File("psychophysik.png"));

Currently Java Core API can read png, jpeg and gif image types. But you can find/implement non-standard classes which extends this capability. ImageIO.read() method throws an IOException, you have to catch it and decide what to do

catch (IOException e) {
  System.err.println("Image File not found");
  e.printStackTrace();
}

this will only warn the client but not prevent the termination of the program. displayImage(BufferedImage) method displays an image at the center of the screen. As before, you should invoke updateScreen() method to actually bring the back buffer front. displayImage() is overloaded

displayImage(0,0,bi2);

displays the image at the upper left corner.

See the entire code of HelloPsychophysicist.java

Matlab version is in HelloPsychophysicist.m file.
Common steps
1. Import psychWithJava and other packages
Normally you would have to write the entire path to a class in your code, but instead you can import the classes you need and eliminate the long names. Place the following line near the top of your program

import psychWithJava.*;

Alternatively you could import only a single class from a package

import psychWithJava.FullScreen;

Note that psychWithJava must be in your javaclasspath. See instructions on setting up the system for Matlab.
2. Create a Java object from within Matlab

fs = FullScreen();

place this inside HelloPsychophysicist.m file, don't try to directly execute it, your system may hang (press ESC if it does). Once a java object is created, one can use methods (functions) of that java object just as one would do in a normal pure java program. See below how to invoke methods of java objects.
3. Place your code inside try-catch clause
Matlab has an error handling mechanism, similar to Java. It only lacks the finally{} part. This causes minor inconvenience.

try
  fs = FullScreen();
  % Your animation here
  % ....
  fs.closeScreen();
catch
  fs.closeScreen();
  rethrow(lasterror);
end

Always put closeScreen() both at the end of try and inside the catch part. This way if your program crashes it is less likely to hang your entire system. rethrow(lasterror) prints out a report from the exception.
4. Use the methods of FullScreen
You can invoke any of the FullScreen methods, the syntax is as follows

fs.setNBuffers(2);

fs.displayText(...
    'Hello Psychophysicist (from within Matlab)');
fs.updateScreen();
pause(2);

fs.blankScreen();
fs.hideCursor();

Note how pause() replaced Thread.sleep() of pure java version. pause() is a Matlab function, but of course you could invoke the Thread.sleep() method instead. setNBuffers(2) sets the total number of video buffers to 2 (one back, one front buffer), displayText() method displays a text at the center of the back video buffer, updateScreen() brings the back buffer front. blankScreen() clears the screen so that new images do not paint over the old screen. hideCursor() hides the cursor.

Reading in images and converting them to Java format

bi1 = im2java2d(imread('psychophysik.png','PNG'));

Matlab has a built-in image reading function imread(). Matlab also offers a function called im2java2d(), which converts the matlab image into a Java image (BufferedImage). Alternatively you can use the Java methods to read in images as follows

bi1 = ImageIO.read(File('psychophysik.png'));

In case you are reading the image from a file I recommend using the Java method. If you are numerically generating your stimulus, for example a Gabor patch, then using im2java2d can be the better option. See GaborDetection demo for an example. Once you created a BufferedImage you can display it on the screen using displayImage() method

fs.displayImage(bi1);

Both displayImage() and displayText() methods are overloaded, you can invoke them with additional parameters in order to place your text or image at a location other then the center of the screen.

See the entire lising of HelloPsychophysicist.m.