Digital Imaging and Communications in Medicine (DICOM) is a standard for storing, handling, printing, and transmitting information in medical imaging. DICOM internally defines network communications protocol that uses TCP/IP to communicate between systems. DICOM files can be exchanged between two systems that are capable of receiving image and patient data in DICOM format. Proposed by National Electrical Manufacturers Association (NEMA) (www.nema.org)

A DICOM file contains a header and the image data. The header stores information about the patient’s name, the type of scan, position and dimension of image and lots of other data. The image data part contains all the image information.

DICOM IMAGE HIERARCHY

SPLITTING DICOM Image:

We can split the DICOM image in to header(Demographics) and data(Image) parts using java with the help of dcm4che API.

HEADER PART:

Ø First we have to open the DICOM image for reading using IOStream.

Ø Create a DICOM Object from the stream we opened for reading.

Ø Remove the Pixel Data from the DICOM Object. Now this DICOM Object only containing header information.

Ø Write the DICOM Object in to a separate file.

Splitting Header(Demographics) from DICOM file.

DATA PART:

Ø First we have to open the DICOM image for reading using streams.

Ø Create a DICOM Object from the stream we opened for reading.

Ø Read only Pixel Data from the DICOM Object and store in DICOM Element and write it in another file using byte array.

Extracting Image from DICOM file.

Let’s have a look at the TIMEDIFF() function in MySQL:

TIMEDIFF(expr1,expr2) - TIMEDIFF() returns expr1 – expr2 expressed as a time value. expr1 and expr2 are time or date-and-time expressions, but both must be of the same type.

It seems that when TimeDiff is performed on 2 dates that exceed 36 days then a warning is thrown, and the resulting value is always capped to 838.

For example:

select time_format(timediff(‘2009-02-05 00:00:00′,’2009-01-01 00:00:00′),’%H’) as TimeDifference

If you execute the above query MySQL will return 838 instead of returning 840 (35 X 24 = 840).

The reason is precisely because TIME type in MySQL has an upper bound of 838:59:59. TIME values may range from ‘-838:59:59′ to ‘838:59:59′.

By using TIMESTAMPDIFF() function you can get around with this problem.

Let’s have a look at the TIMESTAMPDIFF() function in MySQL:

TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2) – Returns datetime_expr2 - datetime_expr1, where datetime_expr1 and datetime_expr2 are date or datetime expressions. One expression may be a date and the other a datetime; a date value is treated as a datetime having the time part '00:00:00' where necessary. The unit for the result (an integer) is given by the unit argument. The legal values for unit are FRAC_SECOND (microseconds), SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, or YEAR.

It is bit confusing timediff and timestampdiff expects the times in opposite order.

Now let’s try timestampdiff() with same dates

select timestampdiff(hour,’2009-01-01 00:00:00′,’2009-02-05 00:00:00′) as TimeDifference

If you execute the above query MySQL will return 840. Even if the difference is more than 840 it will not throw any exceptions or any warning. Hence we can use TIMESTAMPDIFF() function where the difference is more than 838 and can get the output in any of FRAC_SECOND (microseconds), SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, or YEAR.

There you have it … I hope you enjoyed this article. Please leave comments / suggestions / questions if you have.

I had a requirement to generate reports as PDF file which will also includes the charts and download them at client’s system. For creating charts, I was using Chart FX 6.5 (Product of Software FX).

And as a part of framework I created a JAVA class which will create the Charts images and return path of the Chart images.(This JAVA class was called by controller, a SERVLET).

There are two constructors for creating ChartServer object. This object is used to design the Chart and assign the values of charts. Lately Chart can be generated by this object.

1) ChartServer chart = new ChartServer();

2) ChartServer chart = new ChartServer(servletContext, request, response);

Initially I used the first option to create Charts.

I saved a path of a creating image in a String variable.

path = chart.getHtmlTag(“1070″, “500″, “PNG”);

and returned this path back to Controller. After all these CONTROLLER will call a method which will create the report with charts in PDF and send the PDF file to the client.

When application is running and I try to download a PDF file, sometimes it was downloading PDF and sometimes it was giving following error.

NullPointerException

chart.getHtmlTag(Unknown source)

I had a feeling that ChartFX was not finding the context path to generate the Charts. Finally came out know that at many places ChartServer internally uses Application context.

So I decided to go to second constructor of ChartServer.

ChartServer chart = new ChartServer(servletContext, request, response);

For sending PDF to client browser I created a method in controller which is the end point of the request.

private void doDownload(final HttpServletResponse resp,

final String filename, final String originalFilename, final String reportType)

throws IOException {

File f = new File(filename);

int length = Constants.ZER0;

ServletOutputStream op = resp.getOutputStream();

resp.setContentType(“application/PDF;charset=UTF-8″);

resp.setContentLength((int) f.length());

resp.setHeader(“Content-Disposition”, “attachment; filename=”" + originalFilename + “”");

byte[] bbuf = new byte[Constants.FIVE_HUNDRED];

DataInputStream in = new DataInputStream(new FileInputStream(f));

while ((in != null) && ((length = in.read(bbuf)) != -1)) {

op.write(bbuf, Constants.ZER0, length);

}

in.close();

op.flush();

op.close();

if (f.exists()) {

f.delete();

}

}

By doing this, I faced another awesome problem.

java.lang.IllegalStateException: getWriter() has already been called for this response

org.apache.catalina.connector.Response.getOutputStream(Response.java:576)

org.apache.catalina.connector.ResponseFacade.getOutputStream(ResponseFacade.java:181)

javax.servlet.http.HttpServlet.service(HttpServlet.java:627)

javax.servlet.http.HttpServlet.service(HttpServlet.java:729)

Oops !! Another exception in developer’s life.

I debugged it and found that everything is going fine before the following line which responsible for generating the Chart image.

path = chart.getHtmlTag(“1070″, “500″, “PNG”);

Exception is coming on this line. So, I believed that ChartServer internally calls getWriter() of ServletResponse.

Now I wanted to know whether Response has been committed or not. I used isCommitted method of Servlet Response (Used it in Controller, separate java class and in doDownload method before ServletOutputStream was being opened) to find it out whether response has been committed or not. But no luck every where I got it as false.

I tried something different this time, I used JSP instead of java class, because in JSP no need to pass context as a parameter. So, I wrote chart code in JSP to create Charts and forwarded the request to another controller which will create the PDF file.

My flow was

Controller ——> JSP ——–> Controller

But these time also no luck. Same old exception.

java.lang.IllegalStateException: getWriter() has already been called for this response

After a lots of trial and error, I decided to reset buffer of the Servlet Response, Following method I used response.resetBuffer() from Servlet Response before I generate the PDF file.

But exception was luckier then me and came all over again.

Then I tried to reset the Servlet Response too using reset() method of Servlet Response.

This time I didn’t get any error/exception and my PDF was generating with appropriate charts and I was able to download it from my Browser too.

So my final PDF creation and downloading method is

public void doDownloadPDF(HttpServletResponse response,

String jasperFilename, String PDFFilename,

Map reportParams, JRDataSource dataSource) throws IOException {

InputStream jasperStream = this.getClass().getClassLoader().getResourceAsStream(

jasperFilename + “.jasper”);

response.reset();

response.resetBuffer(); //This may not required but I feel good to have this.

response.setContentType(“application/PDF;charset=UTF-8″); response.setHeader(“Content-Disposition”, “attachment; filename=”" + PDFFilename + “.PDF” + “”");

//getting jasperReport by loading jasper file

JasperReport jasperReport;

try {

jasperReport = (JasperReport) JRLoader.loadObject(jasperStream);

//getting jasper Print by filling the report

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, reportParams, dataSource);

JasperExportManager.exportReportToPDFStream(jasperPrint, response.getOutputStream());

response.getOutputStream().flush();

response.getOutputStream().close();

} catch (JRException ex) {

Logger.getLogger(JasperReportController.class.getName()).log(Level.SEVERE, null, ex);

}

}

Now my PDFs are generating without any problem. I am using JRE 1.5 and Tomcat 5.5.27.

A battle of a Developer has been appreciated by the Exception and Exception is now demolished!!

JasperReport is report generation tool used to create reports in Java. And also used to include Charts, Images, and Tables into the report. It can produce the reports in multiple formats like PDF, CSV, HTML, XLS etc. In this article, first we discussed about creation of PDF file using jasper report.

Tools required to generate Jasper reports are JRE 1.5 or above, jasperreport-3.0.0.jar, itext-1.2.3.jar.

Jasper uses JRXML files to generate report. For easy to generate JRXML, we can use iReport-2.0.4 or later. IReports is a tool which is used to generate JRXML. It provides GUI to design the report elements such as titles, fields, variables, parameters, charts etc.

The generated JRXML file contains report design information like title, page footers, page headers, page size, margins etc.

The JRXML file needs to be compiled to generate the JASPER file, which will be used by JasperReport classes to generate the actual report. JRXML can be compiled using method compileReport() of net.sf.jasperreports.engine.JasperCompileManager class. The compiled binary file will have extension “.jasper”. Also we can use iReports to compile the JRXML file.

For example to create report in form of PDF the code is given below.

JasperReport jasperReport = null;

JasperPrint jasperPrint = null;

InputStream jasperStream = null;

try {

jasperStream = this.getClass().getClassLoader().getResourceAsStream(

“fileName.jasper”);———————————————————(1)

jasperReport = (JasperReport) JRLoader.loadObject(jasperStream);————–(2)

jasperPrint = JasperFillManager.fillReport(jasperReport, reportParams, dataSource);——————————————————————————–(3)

//exporting the PDF file

JasperExportManager.exportReportToPdfFile(jasperPrint, fileName);———–(4)

} catch (Exception e) {

e.printStackTrace();

}

}

In above code JasperReport is instance of net.sf.jasperreports.engine.JasperReport and holds the jasper file stream. We are loading the jasper stream at step (1, 2). Here we are using the JRLoader.loadObject() method to load the jasper stream into jasperReport. Now jasperReport instance contains the compiled “.jasper”. The “.jasper” is nothing but the compiled JRXML which holds the design and information about where the different data should fit.

JasperFillManager.fillReport(…..) method will returns a instance of JasperPrint class and that can be used to export the data into PDF, CSV, XLS etc. In above example at step(3) we are creating JasperPrint instance. It takes the parameters

· jasperReport having the compiled .jasper file,

· reportParams is actually a java.util.Map. We can set any parameters and their values as key value pairs in map. And then passed as parameter for method fillReport(…..). This contains the certain static data to be displayed in report.

· dataSource is a instance of JRDataSource. Whatever the data we want to show in report can be send as dataSource. This contains the DataSource which will be iterated by JASPER report and shown the data in a table.

Now the jasperPrint instance is created, which actually holds the data viewed in PDF page. Finally the exportreportToPdfFile() method of JasperExportManger is used to export the report object into the PDF file and stored with the specified file name. We already know that jasperPrint instance has the report object to export on the page. This object will be sent as a parameter to JasperExportManager.exportReportToPdfFile() method. Finally it returns binary content as bite[] array. This array is nothing but the PDF file.

Up to now creation of PDF is completed. Now we discussed about creating charts and insert them into PDF file.

ChartFx for Java 6.5 Development is a tool to develop charts and maps in the form of JPEG, PNG etc. This provides APIs which are required to develop charts. These APIs are used to set charts title, labels, size, background color, axis labels, chart type etc. Charts which are developed using chartFx are stored in temporary directory. So we can capture them from temp location and display in PDF.

For example see the given code.

String path= null;

ChartServer chart1 = new ChartServer(context, request, response);

……………………….

……………………….

path = chart1.getHtmlTag(“1560″, “2000”, “PNG”);

new ChartServer(context, request, response) will create chartServer object. This object is the actual chart object which will be used to create a chart image. Here the parameter context is of type javax.servlet.ServletContext, request is of type javax.servlet.http.HttpServletRequest and response is of type javax.servlet.http.HttpServletResponse. One more default constructor is also available to create chart server is ChartServer(). There are many more methods are available in this class to set the title of chart, x-axis title, y-axis title, background color, font color, font size, font style etc. In our example we skipped the code of designing part of chart. Any one can design as per their requirement. At the end method getHtmlTag(“1560″, “2000”, “PNG”), will return html image tag(<img …. />) which will have “src” attribute and this attribute has path of chart image file. Also the <img /> element will have the width and height attributes which will hold 1560 and 2000 respectively.

For our example, think that charts are already created and placed in location “C:images flower.jpeg”. Now we display generated charts into PDF report. For that, first create parameter in the JRXML file using the iReport.

In iReports goto File–>view–>parameters and then select “parameters” tab, and then click “new” button. Give a name for that parameter and type as String. Later we assign value for this parameter from our java code using java.util.Map.

And then add image element in our JRXML. Right click on image element and open properties and click on “Image Tab” then add “Image Expression” for that element.

And then design report as per your requirement and compile to generate “.Jasper”. Now we have to send path for this image to display in PDF from our java code. The java code given below uses the image available at “C:images flower.jpeg” location.

Map reportParameters = new Hashmap();

reportParameters.put(“chartPath”,” C:\images \flower.jpeg”);

jasperPrint = JasperFillManager.fillReport(jasperReport, reportParameters,datasource);

Then pass this map as parameter at the time of creating jasperPrint object. Now the path for the image is known for jasperFillManager. So it creates jasperPrint object including this image.

Problem when inserting chart in PDF

Some times the inserting chart will have the size that may not be fit into actual size set in JRXML file for that image. In this situation while creating the chart, we can divide original chart into number of charts.

For example, in JRXML we designed the report like it can show chart of 500 pixels height. The chart having 20 bars only perfectly fit in this image element. Now what we have to do is, while creating chart, create two or more charts depending on the result and display them one by one in report.

For example, we want to display bar chart for students’ percentages. There are 55 students in class room. As per our design only chart contains bars for 20 students will fit perfectly in image element. Now what we have to do is, while creating chart split it into three charts contains students’ percentage bars of 20, 20, and 15 each. Now display these images into the PDF and they will be displayed perfectly.

Wow! Finally we get the charts into PDF with the combination of ChartFX and Jasper Reports. I hope this will help anyone to develop reports in the form of PDF.

I wonder why you want to use Java logging API when you can use log4j. Well if you want to or have to use Java’s bundled API for logging, it is not that bad. There are several good articles on the web that go it much more details on this topic then what I am going to cover her. So, look at the articles at the end of this article for links to some of those detailed articles.

So, what am I going to be covering in this article? Just few tricks that I found intriguing and somewhat hard to understand. First of all the logging.properties file. This file resides in the JRE directory as lib/logging.properties (/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/lib for Mac OS users). You can edit this file to control the behavior of the default loggers that get installed when JVM starts. This is definitely is not a good idea. You can copy this file to a user space and then can edit the copy to your liking and load this file as part of your program to control the logging. As I am working on a Mac I will copy the system properties file to my space as /Users/user/LogApi/mylogging.properties. Now, I would like to have two types of handlers, the standard Console Handler and a File Handler. I edit the file to install the two handlers. So, make sure that the following line is uncommented in your properties file

handlers= java.util.logging.FileHandler, java.util.logging.ConsoleHandler

I would like to log everything to a file but only the SEVERE and above log entries to my log console. By default, the FileHandler logs everything to the file, so we don’t have to do anything here. To make the ConsoleHandler log only entries higher thatn SEVERE, add line similar to:

java.util.logging.ConsoleHandler.level = SEVERE

Configure the FIleHandler handler with the following properties.

java.util.logging.FileHandler.pattern = /Users/user/LogApi/build/classes/javaapi%u.log

java.util.logging.FileHandler.limit = 50000

java.util.logging.FileHandler.count = 1

java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter

java.util.logging.FileHandler.append = true

The first line specifies where the logging file is to be placed. Please see (http://java.sun.com/j2se/1.4.2/docs/api/java/util/logging/FileHandler.html) for other options and detials. The “%u” in the above line basically makes the log file rotate through “javaapi0.log” and “javaapi1.log”. The “count” option controls how many of these files the logger cycles through. Also don’t forget to set the append mode to true as the default this set to false. You are done. A simple program to exercise this is given below:

package logapi;

import java.util.logging.*;

/**

* A simple Java program, to understand the Java logging API

*/

public class Main {

private Logger theLogger = null;

public static void main(String[] args) {

Main hello = new Main("Hello world!");

hello.sayHello();

}

private String theMessage;

public Main(String message) {

theMessage = message;

}

public void sayHello() {

try {

//get my logger for this class.

theLogger = Logger.getLogger(Main.class.getName());

// log a message at INFO level

theLogger.info(“info message...");

// log a message at SEVERE level

theLogger.severe("severe message...");

} catch(Exception e){

// caught exception, lets log it

theLogger.log(Level.SEVERE,"Caught excepttion, ",e);

}

}

}

Once you compile this program using javac to Main.class, you will execute this program with the following command:

java -Djava.util.logging.config.file=/Users/user/LogApi/mylogging.properties Main

You are asking the jvm to load your own logger.properties file with the “-D” switch. This is the output of this program:

localhost:classes user$ java -Djava.util.logging.config.file=/Users/user/LogApi/mylogging.properties Main

Dec 21, 2008 8:55:08 PM logapi.Main sayHello

SEVERE: severe message...

localhost:classes user$

The program after execution also wrote a file called “javaapi0.log” and the contents of this file are:

localhost:classes user$ more javaapi0.log

Dec 21, 2008 8:59:32 PM logapi.Main sayHello

INFO: info message...

Dec 21, 2008 8:59:32 PM logapi.Main sayHello

SEVERE: severe message...

localhost:classes user$

Notice that on the console we only saw the “SEVERE” message but the log file has both the info and the sever messages.

If you don’t want to mess around with the properties files but rather want to control the logging programmatically, we can do that also. Although I advise not doing this as you have no control over the logging once the program is rolled out to the filed except re-compiling. However, I will show you how we can do this programmatically just for understanding sake. I hope you have read the other detail tutorial on the web and know the hierarchy of the loggers and their default behaviour. The basic behavior of the logger is when the message comes to it for logging, it checks with its filter and if the message passes the filter the message is handed over to the installed handlers and then the message is also passed on to the parent logger. The parent logger does the same thing till we hit the “root” logger. The root logger handlers are installed at the start of the JVM through the properties file sitting under JRE/lib directory. What we will do is install our own Console and File handlers and then disable the use of the parent handlers by calling the method “theLogger.setUseParentHandlers(false)”. That way we make sure that the only handlers the message passes through are the handlers we install. Here is the code for this:

import java.util.logging.*;

/**

* A simple Java program, to understand the Java logging API

*/

public class Main {

private Logger theLogger = null;

public static void main(String[] args) {

Main hello = new Main("Hello world!");

hello.sayHello();

}

private String theMessage;

public Main(String message) {

theMessage = message;

}

public void sayHello() {

boolean append = true;

try {

// create my own Handlers for file and console

FileHandler fh = new FileHandler("/Users/user/LogApi/build/classes/javaapi%u.log", 50000, 2, append);

//ConsoleHandler only if we need to log to Console

ConsoleHandler ch = new ConsoleHandler();

//get my logger for this class.

theLogger = Logger.getLogger(Main.class.getName());

// the logging gets bubbled up to the parent and the parent default

// handlers are used. Lets disable the use of the parent Handlers.

theLogger.setUseParentHandlers(false);

// set the formatting for the log file to the simple

fh.setFormatter(new java.util.logging.SimpleFormatter());

// install our own handlers in to the logger.

theLogger.addHandler(fh);

// ConsoleHandler Seetings only if we want to log to console.

ch.setLevel(Level.SEVERE);

theLogger.addHandler(ch);

// log a message at INFO level

theLogger.info("info message...");

// log a message at SEVERE level

theLogger.severe("severe message...");

} catch(Exception e){

// caught exception, lets log it

theLogger.log(Level.SEVERE,"Caught excepttion, ",e);

}

}

}

Compile this to Main.class and execute to get the same effect as the previous program.

Finally, the reason I had to deal with this is, we were working on a Java program to parse some files on a regular interval (every 2 minutes). This program got installed under cron. As you know, under cron anything that is written to the stdout or stderr gets emailed to the user under which the program is running. If you start logging a lot of messages to stdout/stderr (the console) you will get a lots of messages flooding your inbox. Worst yet, the /var/mail/user file may continue to grow and fill up the whole space if the program is left running for a long time without cleaning the messages. If we selectively log messages to the console, then you get an e-mail message for the critical messages that you want to see any ways.

http://www.onjava.com/pub/a/onjava/2002/06/19/log.html

http://www.crazysquirrel.com/computing/java/logging.jspx

http://java.sun.com/j2se/1.4.2/docs/guide/util/logging/overview.html

]]> http://blogs.circlesource.com/2008/12/22/logging-with-%e2%80%9cjava-logging-api%e2%80%9d/feed/ 1 http://blogs.circlesource.com/2008/07/17/generating-random-datetime-between-2-different-datestimestamps-in-java/ http://blogs.circlesource.com/2008/07/17/generating-random-datetime-between-2-different-datestimestamps-in-java/#comments Thu, 17 Jul 2008 13:34:10 +0000 Nivasini http://blogs.circlesource.com/?p=8 It is common to find a random number between 2 given numbers… In our java application that we are working on, We had a need to find a random time between two given timestamp.. We felt it little challenging in the beginning… But later figured out a simple solution for the same… The steps for generating a random time between 2 timestamps really turned out to be very simple & this article is about how we achieved that…

If min and max are the 2 variables that are holding minimum and maximum values, & random is the random number that is to be generated, in java the random number is calculated in this way…

random = (Math.random() * (max - min) ) + min


Here Math.random() is a function in java that generates any random value between 0 & 1… We multiply that with the difference between max & min values and finally add the obtained result with the min value to get a random number between 2 given numbers.. This idea was set as the basement for our requirement too… Wondering how?? This is how it goes…

We use Calendar object which defaults to current date and time. We then set Hour, minute & second in the same object(If required we can set the year, month & date too).. Now we have the Calendar object with the date what we set or current date and time. Calendar class has a method named getTimeInMillis which will convert this timeStamp to a long value. This long value serves as the first min variable as in the example where we generate a random number between 2 different numbers.

Now in the same way we get the long value of the second timestamp too which is the max variable value. Using a similar calculation as above we get a random long number between 2 different long numbers which are the long time. Finally we construct the date object with the long value that we obtained.. This date object’s value is the random time stamp between 2 different Calendar objects and hence the we can generate random date/time between two different Calendar objects!!!!

Here goes the code for that..

//code to generate random timestamp between morning 6 to evening 8 pm
public static void main(String args[]){
Calendar cdr = Calendar.getInstance();
cdr.set(Calendar.HOUR_OF_DAY, 6);
cdr.set(Calendar.MINUTE, 0);
cdr.set(Calendar.SECOND, 0);
long val1=cdr.getTimeInMillis();



Random r=new Random();
long randomTS=(long)(r.nextDouble()*(val2-val1))+val1;
Date d=new Date(randomTS);
System.out.println(d.toString());
}

PS: This will work even for generating random date between two different dates which can be a month/year gap.