111

pom.xml

@@ -65,6 +65,26 @@
            <artifactId>mail</artifactId>
            <version>1.4</version>
        </dependency>
        		<dependency>
			<groupId>org.dcm4che</groupId>
			<artifactId>dcm4che-core</artifactId>
			<version>5.16.0</version>
		</dependency>
		<dependency>
			<groupId>org.dcm4che</groupId>
			<artifactId>dcm4che-net</artifactId>
			<version>5.16.0</version>
		</dependency>
		<dependency>
			<groupId>org.dcm4che</groupId>
			<artifactId>dcm4che-dict</artifactId>
			<version>5.16.0</version>
		</dependency>
		<dependency>
			<groupId>org.dcm4che.tool</groupId>
			<artifactId>dcm4che-tool-common</artifactId>
			<version>5.16.0</version>
		</dependency>
<!-- 		<dependency>
			<groupId>org.apache.hadoop</groupId>
			<artifactId>hadoop-hdfs</artifactId>

src/main/java/com/ekexiu/project/storage/dicom/DicomBase.java

@@ -0,0 +1,118 @@
package com.ekexiu.project.storage.dicom;
import java.util.concurrent.atomic.AtomicInteger;
import org.dcm4che3.data.Attributes;
import org.dcm4che3.data.ElementDictionary;
import org.dcm4che3.data.Tag;
import org.dcm4che3.data.UID;
import org.dcm4che3.data.VR;
import org.dcm4che3.net.ApplicationEntity;
import org.dcm4che3.net.Association;
import org.dcm4che3.net.Connection;
import org.dcm4che3.net.Device;
import org.dcm4che3.net.pdu.AAssociateRQ;
import org.dcm4che3.net.pdu.PresentationContext;
public class DicomBase {
	
    protected static String[] IVR_LE_FIRST = {
            UID.ImplicitVRLittleEndian,
            UID.ExplicitVRLittleEndian,
            UID.ExplicitVRBigEndianRetired
        };
    protected final Device device;
    protected final ApplicationEntity ae;
    protected final Connection conn;
    protected final Connection remote;
    protected final AAssociateRQ rq;
    protected Attributes keys = new Attributes();
    protected Association as;
    protected AtomicInteger totNumMatches = new AtomicInteger();
	protected DicomBase(String title) {
		device = new Device(title);
		ae = new ApplicationEntity(title);
		conn = new Connection();
		remote = new Connection();
		rq = new AAssociateRQ();
        device.addConnection(conn);
        device.addApplicationEntity(ae);
        ae.addConnection(conn);
	}
	
	
	public void setRemote(String title,String hostname,int port){
        rq.setCalledAET(title);
        remote.setHostname(hostname);
        remote.setPort(port);
        conn.setReceivePDULength(Connection.DEF_MAX_PDU_LENGTH);
        conn.setSendPDULength(Connection.DEF_MAX_PDU_LENGTH);
        conn.setMaxOpsInvoked(0);
        conn.setMaxOpsPerformed(0);
        
        conn.setPackPDV(true);
        conn.setConnectTimeout( 0);
        conn.setRequestTimeout(0);
        conn.setAcceptTimeout(0);
        conn.setReleaseTimeout(0);
        conn.setResponseTimeout(0);
        conn.setIdleTimeout(0);
        conn.setSocketCloseDelay(Connection.DEF_SOCKETDELAY);
        conn.setSendBufferSize( 0);
        conn.setReceiveBufferSize( 0);
        conn.setTcpNoDelay(true);
	}
	
	public String getLevel(){
		return "STUDY";
	}
	
	
	public void addAttribute(int tag, String value) {
		VR vr = ElementDictionary.vrOf(tag, keys.getPrivateCreator(tag));
		if (value == null) {
			if (vr == VR.SQ)
				keys.newSequence(tag, 1).add(new Attributes(0));
			else
				keys.setNull(tag, vr);
		} else {
			keys.setString(tag, vr, value);
		}
	}
	
    public void configureServiceClass()  {
    	rq.addPresentationContext(new PresentationContext(1,UID.StudyRootQueryRetrieveInformationModelFIND, IVR_LE_FIRST));
    	keys.setString(Tag.QueryRetrieveLevel, VR.CS, "STUDY");
    	
    	
//    	this.addAttribute(PatientID, null);
//    	
//
//    	
//		 "PatientID",
//         "IssuerOfPatientID",
//         "PatientSex", 
//         "PatientBirthDate",
//         "StudyInstanceUID",
//         "StudyInstanceUID",
//         "SeriesInstanceUID",
//         "StudyID",
//         "AccessionNumber",
//         "StudyDate",
//         "StudyTime",
//         "StudyDescription",
//         "NumberOfStudyRelatedSeries",
//         "NumberOfStudyRelatedInstances"
    }
	
	
}

src/main/java/com/ekexiu/project/storage/dicom/DicomGetImage.java

@@ -0,0 +1,190 @@
package com.ekexiu.project.storage.dicom;
import java.io.File;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import org.dcm4che3.data.Attributes;
import org.dcm4che3.data.Tag;
import org.dcm4che3.data.UID;
import org.dcm4che3.data.VR;
import org.dcm4che3.io.DicomOutputStream;
import org.dcm4che3.net.Association;
import org.dcm4che3.net.DimseRSPHandler;
import org.dcm4che3.net.IncompatibleConnectionException;
import org.dcm4che3.net.PDVInputStream;
import org.dcm4che3.net.Priority;
import org.dcm4che3.net.Status;
import org.dcm4che3.net.pdu.PresentationContext;
import org.dcm4che3.net.pdu.RoleSelection;
import org.dcm4che3.net.service.BasicCStoreSCP;
import org.dcm4che3.net.service.DicomServiceException;
import org.dcm4che3.net.service.DicomServiceRegistry;
import org.dcm4che3.util.SafeClose;
public class DicomGetImage extends DicomBase {
	private File storageDir;
	private String fn;
	private File dstFile;
	private BasicCStoreSCP storageSCP = new BasicCStoreSCP("*") {
		@Override
		protected void store(Association as, PresentationContext pc, Attributes rq, PDVInputStream data, Attributes rsp)
				throws IOException {
			if (storageDir == null)
				return;
			if(dstFile != null){
				return;
			}
			String iuid = rq.getString(Tag.AffectedSOPInstanceUID);
			String cuid = rq.getString(Tag.AffectedSOPClassUID);
			String tsuid = pc.getTransferSyntax();
			File file = new File(storageDir, fn);
			try {
				storeTo(as, as.createFileMetaInformation(iuid, cuid, tsuid), data, file);
				dstFile = file;
			} catch (Exception e) {
				throw new DicomServiceException(Status.ProcessingFailure, e);
			}
		}
	};
	private void storeTo(Association as, Attributes fmi, PDVInputStream data, File file) throws IOException {
		file.getParentFile().mkdirs();
		DicomOutputStream out = new DicomOutputStream(file);
		try {
			out.writeFileMetaInformation(fmi);
			data.copyTo(out);
		} finally {
			SafeClose.close(out);
		}
	}
	protected DicomGetImage(String title) {
		super(title);
		DicomServiceRegistry serviceRegistry = new DicomServiceRegistry();
		serviceRegistry.addDicomService(storageSCP);
		device.setDimseRQHandler(serviceRegistry);
	}
	private void download() throws IOException, InterruptedException {
		DimseRSPHandler rspHandler = new DimseRSPHandler(as.nextMessageID()) {
			@Override
			public void onDimseRSP(Association as, Attributes cmd, Attributes data) {
				super.onDimseRSP(as, cmd, data);
			}
		};
		as.cget(UID.StudyRootQueryRetrieveInformationModelGET, Priority.NORMAL, keys, null, rspHandler);
	}
	public static String toUID(String uid) {
		uid = uid.trim();
		return (uid.equals("*") || Character.isDigit(uid.charAt(0))) ? uid : UID.forName(uid);
	}
	private void configureStorageSOPClass(String cuid, String tsuid) {
		if (!rq.containsPresentationContextFor(cuid))
			rq.addRoleSelection(new RoleSelection(cuid, false, true));
		rq.addPresentationContext(new PresentationContext(2 * rq.getNumberOfPresentationContexts() + 1, cuid, tsuid));
	}
	public File download(String title, String hostname, int port, String imageId, File path, String fn)
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		this.setRemote(title, hostname, port);
		this.rq.addPresentationContext(
				new PresentationContext(1, UID.StudyRootQueryRetrieveInformationModelGET, IVR_LE_FIRST));
		configureStorageSOPClass(UID.GrayscaleSoftcopyPresentationStateStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.GrayscaleSoftcopyPresentationStateStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.SecondaryCaptureImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.SecondaryCaptureImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.EncapsulatedPDFStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.EncapsulatedPDFStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.UltrasoundMultiFrameImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.UltrasoundMultiFrameImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalXRayImageStorageForPresentation, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalXRayImageStorageForPresentation, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.BasicTextSRStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.BasicTextSRStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.CTImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.CTImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.ComputedRadiographyImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.ComputedRadiographyImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.EnhancedSRStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.EnhancedSRStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.XRayRadiofluoroscopicImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.XRayRadiofluoroscopicImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalXRayImageStorageForProcessing, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalXRayImageStorageForProcessing, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.VLPhotographicImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.VLPhotographicImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.VLPhotographicImageStorage, UID.JPEGBaseline1);
		configureStorageSOPClass(UID.KeyObjectSelectionDocumentStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.KeyObjectSelectionDocumentStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.UltrasoundImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.KeyObjectSelectionDocumentStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.VideoPhotographicImageStorage, UID.JPEGBaseline1);
		configureStorageSOPClass(UID.VideoPhotographicImageStorage, UID.MPEG2);
		configureStorageSOPClass(UID.PositronEmissionTomographyImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.PositronEmissionTomographyImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.XRayAngiographicImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.XRayAngiographicImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalMammographyXRayImageStorageForProcessing, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalMammographyXRayImageStorageForProcessing, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.XRayRadiationDoseSRStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.XRayRadiationDoseSRStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.NuclearMedicineImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.NuclearMedicineImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.VLWholeSlideMicroscopyImageStorage, UID.JPEGBaseline1);
		configureStorageSOPClass(UID.VLWholeSlideMicroscopyImageStorage, UID.JPEG2000LosslessOnly);
		configureStorageSOPClass(UID.VLWholeSlideMicroscopyImageStorage, UID.JPEG2000);
		configureStorageSOPClass(UID.MRImageStorage, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.MRImageStorage, UID.ExplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalMammographyXRayImageStorageForPresentation, UID.ImplicitVRLittleEndian);
		configureStorageSOPClass(UID.DigitalMammographyXRayImageStorageForPresentation, UID.ExplicitVRLittleEndian);
		this.keys.setString(Tag.QueryRetrieveLevel, VR.CS, "IMAGE");
		this.addAttribute(Tag.SOPInstanceUID, imageId);
		this.storageDir = path;
		this.fn = fn;
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
		this.device.setExecutor(executorService);
		this.device.setScheduledExecutor(scheduledExecutorService);
		try {
			as = ae.connect(conn, remote, rq);
			download();
		} finally {
			if (as != null && as.isReadyForDataTransfer()) {
				as.waitForOutstandingRSP();
				as.release();
			}
			executorService.shutdown();
			scheduledExecutorService.shutdown();
		}
		return this.dstFile;
	}
	public static void main(String args[])
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		DicomGetImage q = new DicomGetImage("GETSCU");
		q.download("DCM4CHEE", "192.168.3.97", 11112, "1.2.840.113663.1500.1.434945515.3.6.20180902.100711.313",
				new File("D:\\test\\GETSCU"), "2.dcm");
	}
}

src/main/java/com/ekexiu/project/storage/dicom/DicomQueryImage.java

@@ -0,0 +1,115 @@
package com.ekexiu.project.storage.dicom;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import org.dcm4che3.data.Attributes;
import org.dcm4che3.data.Tag;
import org.dcm4che3.data.UID;
import org.dcm4che3.data.VR;
import org.dcm4che3.net.Association;
import org.dcm4che3.net.DimseRSPHandler;
import org.dcm4che3.net.IncompatibleConnectionException;
import org.dcm4che3.net.Priority;
import org.dcm4che3.net.Status;
import org.dcm4che3.net.pdu.PresentationContext;
import org.jfw.util.json.JsonService;
public class DicomQueryImage extends DicomBase {
	private List<SeriesImage> result = new LinkedList<SeriesImage>();
	private SeriesImage image;
	private StringBuilder sb = new StringBuilder();
	private Attributes.Visitor visitor = new Attributes.Visitor() {
		public boolean visit(Attributes attrs, int tag, VR vr, Object value) throws Exception {
			if (value != null) {
				sb.setLength(0);
				if(vr.prompt(value, attrs.bigEndian(), attrs.getSpecificCharacterSet(vr),
		               100000, sb)){
					if(sb.length()<1){
						return true;
					}
					
					if(tag == Tag.SOPInstanceUID){
						image.setId(sb.toString());
					}else if(tag == Tag.InstanceNumber){
						image.setNum(sb.toString());
					}
				}
			}
			return true;
		}
	};
	protected DicomQueryImage(String title) {
		super(title);
	}
	private void query() throws IOException, InterruptedException {
		DimseRSPHandler rspHandler = new DimseRSPHandler(as.nextMessageID()) {
			@Override
			public void onDimseRSP(Association as, Attributes cmd, Attributes data) {
				super.onDimseRSP(as, cmd, data);
				int status = cmd.getInt(Tag.Status, -1);
				if (Status.isPending(status)) {
					image = new SeriesImage();
					result.add(image);
					try {
						data.accept(visitor, false);
					} catch (Exception e) {
					}
				}
			}
		};
		as.cfind(UID.StudyRootQueryRetrieveInformationModelFIND, Priority.NORMAL, keys, null, rspHandler);
	}
	public List<SeriesImage> query(String title, String hostname, int port, String studyUid,String seriesUid)
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		this.setRemote(title, hostname, port);
		this.rq.addPresentationContext(
				new PresentationContext(1, UID.StudyRootQueryRetrieveInformationModelFIND, IVR_LE_FIRST));
		this.keys.setString(Tag.QueryRetrieveLevel, VR.CS, "IMAGE");
		
		
		this.addAttribute(Tag.StudyInstanceUID, studyUid);
		this.addAttribute(Tag.SeriesInstanceUID, seriesUid);
		this.addAttribute(Tag.SOPInstanceUID,null);
		this.addAttribute(Tag.InstanceNumber,null);
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
		this.device.setExecutor(executorService);
		this.device.setScheduledExecutor(scheduledExecutorService);
		try {
			as = ae.connect(conn, remote, rq);
			query();
		} finally {
			if (as != null && as.isReadyForDataTransfer()) {
				as.waitForOutstandingRSP();
				as.release();
			}
			executorService.shutdown();
			scheduledExecutorService.shutdown();
		}
		return this.result;
	}
	public static void main(String args[])
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		DicomQueryImage q = new DicomQueryImage("findscu");
		q.query("DCM4CHEE", "192.168.3.97", 11112, "1.2.840.113663.1500.1.434945515.1.1.20180902.100500.537","1.2.840.113663.1500.1.434945515.2.1.20180902.100500.539");
		
		for(SeriesImage s:q.result){
			System.out.println(JsonService.toJson(s));
		}
	}
}

src/main/java/com/ekexiu/project/storage/dicom/DicomQuerySeries.java

@@ -0,0 +1,130 @@
package com.ekexiu.project.storage.dicom;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import org.dcm4che3.data.Attributes;
import org.dcm4che3.data.Tag;
import org.dcm4che3.data.UID;
import org.dcm4che3.data.VR;
import org.dcm4che3.net.Association;
import org.dcm4che3.net.DimseRSPHandler;
import org.dcm4che3.net.IncompatibleConnectionException;
import org.dcm4che3.net.Priority;
import org.dcm4che3.net.Status;
import org.dcm4che3.net.pdu.PresentationContext;
import org.jfw.util.json.JsonService;
public class DicomQuerySeries extends DicomBase {
	private List<StudySeries> result = new LinkedList<StudySeries>();
	private StudySeries series;
	private StringBuilder sb = new StringBuilder();
	private Attributes.Visitor visitor = new Attributes.Visitor() {
		public boolean visit(Attributes attrs, int tag, VR vr, Object value) throws Exception {
			if (value != null) {
				sb.setLength(0);
				if(vr.prompt(value, attrs.bigEndian(), attrs.getSpecificCharacterSet(vr),
		               100000, sb)){
					if(sb.length()<1){
						return true;
					}
					
					if(tag == Tag.SeriesDate){
						series.setSeriesDate(sb.toString());
					}else if(tag == Tag.SeriesTime){
						series.setSeriesTime(sb.toString());
					}else if(tag == Tag.Modality){
						series.setSeriesType(sb.toString());
					}else if(tag == Tag.SeriesDescription){
						series.setSeriesDescription(sb.toString());
					}else if(tag == Tag.SeriesInstanceUID){
						series.setId(sb.toString());
					}else if(tag == Tag.SeriesNumber){
						series.setNumOfStudy(sb.toString());
					}else if(tag == Tag.NumberOfStudyRelatedInstances){
						series.setNumberOfSeriesRelatedInstances(sb.toString());
					}
				}
			}
			return true;
		}
	};
	protected DicomQuerySeries(String title) {
		super(title);
	}
	private void query() throws IOException, InterruptedException {
		DimseRSPHandler rspHandler = new DimseRSPHandler(as.nextMessageID()) {
			@Override
			public void onDimseRSP(Association as, Attributes cmd, Attributes data) {
				super.onDimseRSP(as, cmd, data);
				int status = cmd.getInt(Tag.Status, -1);
				if (Status.isPending(status)) {
					series = new StudySeries();
					result.add(series);
					try {
						data.accept(visitor, false);
					} catch (Exception e) {
					}
				}
			}
		};
		as.cfind(UID.StudyRootQueryRetrieveInformationModelFIND, Priority.NORMAL, keys, null, rspHandler);
	}
	public List<StudySeries> query(String title, String hostname, int port, String studyUid)
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		this.setRemote(title, hostname, port);
		this.rq.addPresentationContext(
				new PresentationContext(1, UID.StudyRootQueryRetrieveInformationModelFIND, IVR_LE_FIRST));
		this.keys.setString(Tag.QueryRetrieveLevel, VR.CS, "SERIES");
		
		
		this.addAttribute(Tag.StudyInstanceUID, studyUid);
		
		this.addAttribute(Tag.SeriesDate,null);
		this.addAttribute(Tag.SeriesTime,null);
		this.addAttribute(Tag.Modality,null);
		this.addAttribute(Tag.SeriesDescription,null);
		this.addAttribute(Tag.SeriesInstanceUID,null);
	    this.addAttribute(Tag.SeriesNumber,null);
		this.addAttribute(Tag.NumberOfStudyRelatedInstances,null);
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
		this.device.setExecutor(executorService);
		this.device.setScheduledExecutor(scheduledExecutorService);
		try {
			as = ae.connect(conn, remote, rq);
			query();
		} finally {
			if (as != null && as.isReadyForDataTransfer()) {
				as.waitForOutstandingRSP();
				as.release();
			}
			executorService.shutdown();
			scheduledExecutorService.shutdown();
		}
		return this.result;
	}
	public static void main(String args[])
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		DicomQuerySeries q = new DicomQuerySeries("findscu");
		q.query("DCM4CHEE", "192.168.3.97", 11112, "1.2.840.113663.1500.1.434945515.1.1.20180902.100500.537");
		
		for(StudySeries s:q.result){
			System.out.println(JsonService.toJson(s));
		}
	}
}

src/main/java/com/ekexiu/project/storage/dicom/DicomQueryStudy.java

@@ -0,0 +1,143 @@
package com.ekexiu.project.storage.dicom;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import org.dcm4che3.data.Attributes;
import org.dcm4che3.data.ElementDictionary;
import org.dcm4che3.data.Tag;
import org.dcm4che3.data.UID;
import org.dcm4che3.data.VR;
import org.dcm4che3.net.Association;
import org.dcm4che3.net.DimseRSPHandler;
import org.dcm4che3.net.IncompatibleConnectionException;
import org.dcm4che3.net.Priority;
import org.dcm4che3.net.Status;
import org.dcm4che3.net.pdu.PresentationContext;
import org.jfw.util.json.JsonService;
public class DicomQueryStudy extends DicomBase {
	private List<PatientStudy> result = new LinkedList<PatientStudy>();
	private PatientStudy study;
	private StringBuilder sb = new StringBuilder();
	private Attributes.Visitor visitor = new Attributes.Visitor() {
		public boolean visit(Attributes attrs, int tag, VR vr, Object value) throws Exception {
			if (value != null) {
				sb.setLength(0);
				if(vr.prompt(value, attrs.bigEndian(), attrs.getSpecificCharacterSet(vr),
		               100000, sb)){
					if(sb.length()<1){
						return true;
					}
					if(tag == Tag.PatientName){
						study.setPatientName(sb.toString());
					}else if(tag == Tag.PatientID){
						study.setPatientId(sb.toString());
					}else if(tag == Tag.PatientSex){
						study.setSex(sb.toString());
					}else if(tag == Tag.PatientBirthDate){
						study.setBirth(sb.toString());
					}else if(tag == Tag.StudyInstanceUID){
						study.setStudyUid(sb.toString());
					}else if(tag == Tag.StudyID){
						study.setStudyId(sb.toString());
					}else if(tag == Tag.StudyDate){
						study.setStudyDate(sb.toString());
					}else if(tag == Tag.StudyTime){
						study.setStudyTime(sb.toString());
					}else if(tag == Tag.StudyDescription){
						study.setDescription(sb.toString());
					}else if(tag == Tag.NumberOfStudyRelatedSeries){
						study.setNumOfStudyRelatedSeries(sb.toString());
					}else if(tag == Tag.NumberOfStudyRelatedInstances){
						study.setNumOfstudyRelatedInstances(sb.toString());
					}
				}
			}
			return true;
		}
	};
	protected DicomQueryStudy(String title) {
		super(title);
	}
	private void query() throws IOException, InterruptedException {
		DimseRSPHandler rspHandler = new DimseRSPHandler(as.nextMessageID()) {
			@Override
			public void onDimseRSP(Association as, Attributes cmd, Attributes data) {
				super.onDimseRSP(as, cmd, data);
				int status = cmd.getInt(Tag.Status, -1);
				if (Status.isPending(status)) {
					study = new PatientStudy();
					result.add(study);
					try {
						data.accept(visitor, false);
					} catch (Exception e) {
					}
				}
			}
		};
		as.cfind(UID.StudyRootQueryRetrieveInformationModelFIND, Priority.NORMAL, keys, null, rspHandler);
	}
	public List<PatientStudy> query(String title, String hostname, int port, String patientName, String patientId)
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		this.setRemote(title, hostname, port);
		this.rq.addPresentationContext(
				new PresentationContext(1, UID.StudyRootQueryRetrieveInformationModelFIND, IVR_LE_FIRST));
		this.keys.setString(Tag.QueryRetrieveLevel, VR.CS, "STUDY");
		this.addAttribute(Tag.PatientID, patientId);
		this.addAttribute(Tag.PatientName, patientName);
		this.addAttribute(Tag.IssuerOfPatientID, null);
		this.addAttribute(Tag.PatientSex, null);
		this.addAttribute(Tag.PatientBirthDate, null);
		this.addAttribute(Tag.StudyInstanceUID, null);
		this.addAttribute(Tag.StudyInstanceUID, null);
		this.addAttribute(Tag.SeriesInstanceUID, null);
		this.addAttribute(Tag.StudyID, null);
		this.addAttribute(Tag.AccessionNumber, null);
		this.addAttribute(Tag.StudyDate, null);
		this.addAttribute(Tag.StudyTime, null);
		this.addAttribute(Tag.StudyDescription, null);
		this.addAttribute(Tag.NumberOfStudyRelatedSeries, null);
		this.addAttribute(Tag.NumberOfStudyRelatedInstances, null);
		ExecutorService executorService = Executors.newSingleThreadExecutor();
		ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
		this.device.setExecutor(executorService);
		this.device.setScheduledExecutor(scheduledExecutorService);
		try {
			as = ae.connect(conn, remote, rq);
			query();
		} finally {
			if (as != null && as.isReadyForDataTransfer()) {
				as.waitForOutstandingRSP();
				as.release();
			}
			executorService.shutdown();
			scheduledExecutorService.shutdown();
		}
		return this.result;
	}
	public static void main(String args[])
			throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException {
		DicomQueryStudy q = new DicomQueryStudy("findscu");
		q.query("DCM4CHEE", "192.168.3.97", 11112, "759417ASD", null);
		
		for(PatientStudy s:q.result){
			System.out.println(JsonService.toJson(s));
		}
	}
}

src/main/java/com/ekexiu/project/storage/dicom/DicomService.java

@@ -0,0 +1,94 @@
package com.ekexiu.project.storage.dicom;
import java.io.File;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;
import org.dcm4che3.net.IncompatibleConnectionException;
import org.jfw.apt.annotation.Nullable;
import org.jfw.apt.web.annotation.Path;
import org.jfw.apt.web.annotation.operate.Get;
@Path("/dicom")
public class DicomService {
	private String localTitle="AIADS";
	private String remoteTitle="STPACS";
	private String remoteHostName ="133.0.14.150";
	private int remotePort = 104;
	private File storagePath = new File("/ekexiu/storage_asd/download");
	
	
	public String getLocalTitle() {
		return localTitle;
	}
	public void setLocalTitle(String localTitle) {
		this.localTitle = localTitle;
	}
	public String getRemoteTitle() {
		return remoteTitle;
	}
	public void setRemoteTitle(String remoteTitle) {
		this.remoteTitle = remoteTitle;
	}
	public String getRemoteHostName() {
		return remoteHostName;
	}
	public void setRemoteHostName(String remoteHostName) {
		this.remoteHostName = remoteHostName;
	}
	public int getRemotePort() {
		return remotePort;
	}
	public void setRemotePort(int remotePort) {
		this.remotePort = remotePort;
	}
	public File getStoragePath() {
		return storagePath;
	}
	public void setStoragePath(File storagePath) {
		this.storagePath = storagePath;
	}
	
	@Get
	@Path("/study")
	public List<PatientStudy> queryStudy(@Nullable String name,@Nullable String id) throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException{
		if(name != null || id !=null){
			DicomQueryStudy query = new DicomQueryStudy(this.localTitle);
			return query.query(this.remoteTitle, remoteHostName, remotePort,name,id);
		}else{
			return Collections.emptyList();
		}
	} 
	@Get
	@Path("/series")
	public List<StudySeries> querySeries(String id) throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException{
			DicomQuerySeries query = new DicomQuerySeries(this.localTitle);
			return query.query(this.remoteTitle, remoteHostName, remotePort,id);
	} 
	
	@Get
	@Path("/image")
	public List<SeriesImage> queryImage(String study,String series) throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException{
			DicomQueryImage query = new DicomQueryImage(this.localTitle);
			return query.query(this.remoteTitle, remoteHostName, remotePort,study,series);
	} 
	
	@Get
	@Path("/download")
	public boolean download(String id) throws IOException, InterruptedException, IncompatibleConnectionException, GeneralSecurityException{
		DicomGetImage q = new DicomGetImage(this.localTitle);
		return null !=q.download(this.remoteTitle, remoteHostName, remotePort,id,this.storagePath,id+".dcm");
	}
	
	
	
	
	
	
	
	
	
}

src/main/java/com/ekexiu/project/storage/dicom/PatientStudy.java

@@ -0,0 +1,87 @@
package com.ekexiu.project.storage.dicom;
public class PatientStudy {
	
	private String	 patientName;
	private String   patientId;
	private String   sex;
	private String   birth;
	private String   studyUid;
	private String   studyId;
	private String 	 studyDate;
	private String   studyTime;
	private String   description;
	private String 	 numOfStudyRelatedSeries;
	private String	 numOfstudyRelatedInstances;
	
	
	public String getPatientName() {
		return patientName;
	}
	public void setPatientName(String patientName) {
		this.patientName = patientName;
	}
	public String getPatientId() {
		return patientId;
	}
	public void setPatientId(String patientId) {
		this.patientId = patientId;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getBirth() {
		return birth;
	}
	public void setBirth(String birth) {
		this.birth = birth;
	}
	public String getStudyUid() {
		return studyUid;
	}
	public void setStudyUid(String studyUid) {
		this.studyUid = studyUid;
	}
	public String getStudyId() {
		return studyId;
	}
	public void setStudyId(String studyId) {
		this.studyId = studyId;
	}
	public String getStudyDate() {
		return studyDate;
	}
	public void setStudyDate(String studyDate) {
		this.studyDate = studyDate;
	}
	public String getStudyTime() {
		return studyTime;
	}
	public void setStudyTime(String studyTime) {
		this.studyTime = studyTime;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	public String getNumOfStudyRelatedSeries() {
		return numOfStudyRelatedSeries;
	}
	public void setNumOfStudyRelatedSeries(String numOfStudyRelatedSeries) {
		this.numOfStudyRelatedSeries = numOfStudyRelatedSeries;
	}
	public String getNumOfstudyRelatedInstances() {
		return numOfstudyRelatedInstances;
	}
	public void setNumOfstudyRelatedInstances(String numOfstudyRelatedInstances) {
		this.numOfstudyRelatedInstances = numOfstudyRelatedInstances;
	}
	
	
}

src/main/java/com/ekexiu/project/storage/dicom/SeriesImage.java

@@ -0,0 +1,20 @@
package com.ekexiu.project.storage.dicom;
public class SeriesImage {
	private String id;
	private String num;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getNum() {
		return num;
	}
	public void setNum(String num) {
		this.num = num;
	}
	
}

src/main/java/com/ekexiu/project/storage/dicom/StudySeries.java

@@ -0,0 +1,57 @@
package com.ekexiu.project.storage.dicom;
public class StudySeries {
	private String seriesDate;
	private String seriesTime;
	private String seriesType;
	private String seriesDescription;
	private String id;
	private String numOfStudy;
	private String numberOfSeriesRelatedInstances;
	
	
	public String getSeriesDate() {
		return seriesDate;
	}
	public void setSeriesDate(String seriesDate) {
		this.seriesDate = seriesDate;
	}
	public String getSeriesTime() {
		return seriesTime;
	}
	public void setSeriesTime(String seriesTime) {
		this.seriesTime = seriesTime;
	}
	public String getSeriesType() {
		return seriesType;
	}
	public void setSeriesType(String seriesType) {
		this.seriesType = seriesType;
	}
	public String getSeriesDescription() {
		return seriesDescription;
	}
	public void setSeriesDescription(String seriesDescription) {
		this.seriesDescription = seriesDescription;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getNumOfStudy() {
		return numOfStudy;
	}
	public void setNumOfStudy(String numOfStudy) {
		this.numOfStudy = numOfStudy;
	}
	public String getNumberOfSeriesRelatedInstances() {
		return numberOfSeriesRelatedInstances;
	}
	public void setNumberOfSeriesRelatedInstances(String numberOfSeriesRelatedInstances) {
		this.numberOfSeriesRelatedInstances = numberOfSeriesRelatedInstances;
	}
	
	
}