Monday, 30 September 2013

A synchronized method or block works on a given monitor. Synchronized non-static methods all synchronize on the Java instance of a class. Each instance has a lock monitor. For the case of static methods, what object does static synchronized methods use for locking? The static synchronized statements obtain a lock on the Class object. The following example show you few ways to access the class object:

The JVM creates a Class object when the class is loaded (When it is used for the first time). Once a class is loaded into a JVM, the same class will not be loaded again. The JVM creates one instance of Class for each class that is loaded, The Class instances are Objects and can be synchronized via static synchronized methods.

In some situatios, you need to protect access static variables, the locking an object instance does not automatically protect access to static variables, because there may have more than one instances and all of them use the same static variables. You have to obtain a lock on the Class vs an instance of the class. A static synchronized block can be use to protect access to static varibales, a lock on a static method has no effect on any instances of that class (see the Java Language Specification). For example,

Static variables, like static methods, are not inherited, but are accessible from within the body of the class definition and through an explicit reference to the defining class's name. Adding a new static synchronized method in a subclass cannot protect other threads to access static variables defined in its superclass nor should you use synchronized(this.getClass()) which locks the actual Class might be the subclass. An explicit block synchronization with "none-instance way to get Class" is the preferred way.

synchronized Methods

A synchronized method acquires a monitor before it executes. For a class (static) method, the monitor associated with the Class object for the method's class is used. For an instance method, the monitor associated with this (the object for which the method was invoked) is used.

This article describes how to embed Swing components in JavaFX applications. It discusses the threading restrictions and provides working applications that illustrate Swing buttons with HTML content embedded in a JavaFX application and interoperability between Swing and JavaFX buttons.

The ability to embed JavaFX content in Swing applications has existed since the JavaFX 2.0 release. To enhance the interoperability of JavaFX and Swing, JavaFX 8 introduces a new class that provides reverse integration and enables developers to embed Swing components in JavaFX applications.

Before you run any code from this article, install JDK 8 on your computer.

SwingNode Class

JavaFX 8 introduces the SwingNode class, which is located in the javafx.embed.swing package. This class enables you to embed Swing content in a JavaFX application. To specify the content of the SwingNode object, call the setContent method, which accepts an instance of thejavax.swing.JComponent class. You can call the setContent method on either the JavaFX application thread or event dispatch thread (EDT). However, to access the Swing content, ensure that your code runs on EDT, because the standard Swing threading restrictions apply.

The code shown in Example 1 illustrates the general pattern of using the SwingNode class.

Embedding Swing Content and Handling Events

The ButtonHtmlDemo in the Swing tutorial adds font, color, and other formatting to three buttons shown in Example 2 and Example 3. The buttons respond to mouse and keyboard events as shown in Example 5 and Example 6. Figure 2 shows the three buttons created using Swing in theButtonHtmlDemo now embedded in a JavaFX Application (SwingNodeSample). You will create theSwingNodeSample application and ensure that all events are delivered to an appropriate Swing button and get processed.

The simple format of middle button does not require HTML, so it is initialized with a string label and an image as shown in Example 3.

Example 3

b2 = new JButton("middle button", middleButtonIcon);

All three buttons have the tooltips and mnemonic characters as shown in Example 4.

Example 4

b1.setToolTipText("Click this button to disable the middle button.");
b2.setToolTipText("This middle button does nothing when you click it.");
b3.setToolTipText("Click this button to enable the middle button.");
b1.setMnemonic(KeyEvent.VK_D);
b2.setMnemonic(KeyEvent.VK_M);
b3.setMnemonic(KeyEvent.VK_E);

The left and right buttons are used to disable and enable the middle button respectively. To enable the application to detect and respond to user action on these buttons, attach action listeners and set action commands as shown in Example 5.

Adding Interoperability Between Swing and JavaFX Components

You can provide interoperability between JavaFX buttons and Swing buttons. For example, theEnableFXButton application shown in Figure 3 enables a user to click Swing buttons to disable or enable a JavaFX button. Conversely, the EnableButtons application shown in Figure 4 enables a user to click a JavaFX button to activate a Swing button.

The EnableFXButton application is created by modifying the SwingNodeSample application and making the middle button an instance of the javafx.scene.control.Button class. In the modified application, the Swing buttons (Disable FX button) and (Enable FX button) are used to disable and enable a JavaFX button (FX Button). Figure 3 shows the EnableFXButton application.

Modify the actionPerformed method to implement the disabling and enabling of fxbuttonas shown in Example 16. Note that the disabling and enabling of the JavaFX button must happen on the JavaFX application thread.

Run the application and click the Swing buttons to disable and enable the JavaFX button, as shown in Figure 3.

Using a JavaFX Button to Operate a Swing Button

You can further modify the EnableFXButton application and implement the setOnAction method for the JavaFX button so that clicking the JavaFX button activates the Swing button. The modified application (EnableButtons) is shown in Figure 4.

Conclusion

In this article you learned how to embed existing Swing components in JavaFX applications and provide interoperability between Swing and JavaFX objects. The ability to embed Swing content into JavaFX applications enables developers to migrate Swing applications that use complex third-party Swing components for which they do not have source code or applications that have legacy modules that exist only in maintenance mode.

ServletConfig is implemented by the servlet containerto initialize a single servletusing init(). That is, you can pass initialization parameters to the servlet using the web.xml deployment descriptor. For understanding, this is similar to a constructor in a java class.

Example code:<servlet><servlet-name>ServletConfigTest</servlet-name><servlet-class>com.javapapers.ServletConfigTest</servlet-class><init-param><param-name>topic</param-name><param-value>Difference between ServletConfig and ServletContext</param-value></init-param></servlet>

ServletContext

Signature: public interface ServletContext

ServletContext is implemented by the servlet container for all servletto communicate with its servlet container, for example, to get the MIME type of a file, to get dispatch requests, or to write to a log file. That is to get detail about its execution environment.

It is applicable only within a single Java Virtual Machine. If a web applicationa is distributed between multiple JVM this will not work. For understanding, this is like a application global variable mechanism for a single web application deployed in only one JVM.

The ServletContext object is contained within the ServletConfig object. That is, the ServletContext can be accessed using the ServletConfig object within a servlet. You can specify param-value pairs for ServletContext object in <context-param> tags in web.xml file.

Information on how to interpret the location of CT and MR images within a patient coordinate system is also included.

********************************************************************

What does the patient coordinate system look like?

HEAD +Z(H)

POSTERIOR | / +Y(P)

() | /

RIGHT -/\- LEFT |/

|| -X(R) ------+------ +X(L)

ANTERIOR /|

FEET / |

/ |

-Y(A) -Z(F)

In this diagram the patient is facing forward. Anteriorrefers to the front of the patient. Posterior refers to the back of the patient. The origin of the patient coordinate system is arbitrary, and selected by the imaging modality. I assume that the modality is free to choose a different origin for each series of images, but the origin is fixed for a given series.

If you wish to annotate images when displayed with notations such as (L) or (R) to indicate which side of the 2D image is considered the patient's left or right side, you need the Patient Position (0018, 5100) Attribute from the General Series module.

This attribute contains the position of the patient relative to the imaging equipment space.Valid values are:

Basically, a direction cosine is the cosine of the angle which is created between a unit vector which starts at the origin with some direction, and a unit vector coincident with one of the axis of the coordinate system.

To fully define the point in space at the end of a vector it requires nine direction cosines. Since in a right handed cartesian coordinate system the cross product of two unit vectors defines the third, you can fully describe the location using only six direction cosines. The other three may be calculated.

********************************************************************

Where can I learn about direction cosines?

The following references may be of help in understanding what a direction cosine is.

Mathematical Methods for Physicists. Arfken. Academic Press, 1996.

pp 3-5. pp 143-160.

Computer Graphics Principles and Practice, 2nd Edition. Foley, van

Dam, Feiner, Hughes. Addison Wesley, 1987. pp 213-222, 1103-1105.

Vector Mechanics for Engineers, STATICS and DYNAMICS, 3rd Edition.

Beer, Johnston jr. McGraw Hill, 1977. pp 43-46.

********************************************

How do I orient a single image in the patient coordinate system?

In order to orient a single image plane in the patient coordinate system a 4x4 transform matrix must be defined. This matrix is derived as follows:

Given:

xr = x row direction cosine

yr = y row direction cosine

zr = z row direction cosine

xc = x column direction cosine

yc = y column direction cosine

zc = z column direction cosine

First calculate the slice direction cosine values for x, y, and z. This is the cross-product of the row and column direction cosines.

xs = (yr * zc) - (zr * yc)

ys = (zr * xc) - (xc * zc)

zs = (xr * yc) - (yr * xc)

Then, the 4x4 matrix is as follows:

[ xr yr zr 1 ]

M = [ xc yc zc 1 ]

[ xs ys zs 1 ]

[ 0 0 0 1 ]

The image plane is then transformed from the origin to the proper location in the patient coordinate system as follows:

It really is a piece of cake to derive what you want ... for example in the following code assume "vector" is either a Row vector or Column vector from Image Orientation (Patient) and "orientation" becomes what you want by picking out the "most significant" axis sequentially, and noting the sign. The DICOM convention is Left Posterior Head +ve.