dcm4che-3.2.1을 사용하여 JPG 이미지를 DICOM 파일로 변환하는 방법은 무엇입니까?

Question

속성을 설정하고 dicom 파일을 만들 수 있지만 이미지를 dicom 파일에 쓸 수 없습니까?

Answer 1

나는 가지고있는 이미지로 해봤지만 작동하지만 RGB 이미지에서는 작동하지 않을 것이라고 기대한다. 나는 당신의 이미지를 가정 한

BufferedImage jpg = ImageIO.read(new File("myjpg.jpg")); 

    //Convert the image to a byte array 
    DataBufferUShort buff = (DataBufferUShort) jpg.getData().getDataBuffer(); 
    short[] data = buff.getData(); 
    ByteBuffer byteBuf = ByteBuffer.allocate(2*data.length); 
    int i = 0; 
    while (data.length > i) { 
     byteBuf.putShort(data[i]); 
     i++; 
    } 

    //Copy a header 
    DicomInputStream dis = new DicomInputStream(new File("fileToCopyheaderFrom.dcm")); 
    Attributes meta = dis.readFileMetaInformation(); 
    Attributes attribs = dis.readDataset(-1, Tag.PixelData); 
    dis.close(); 

    //Change the rows and columns 
    attribs.setInt(Tag.Rows, VR.US, jpg.getHeight()); 
    attribs.setInt(Tag.Columns, VR.US, jpg.getWidth()); 
    System.out.println(byteBuf.array().length); 
    //Attributes attribs = new Attributes(); 

    //Write the file 
    attribs.setBytes(Tag.PixelData, VR.OW, byteBuf.array()); 
    DicomOutputStream dcmo = new DicomOutputStream(new File("myDicom.dcm")); 
    dcmo.writeFileMetaInformation(meta); 
    attribs.writeTo(dcmo); 
    dcmo.close(); 

편집 한

하지만 이런 식으로 뭔가가 여기에 서명되지 않은 짧은 데이터 버퍼를 가지고있다.

DataBufferUShort buff = (DataBufferUShort) jpg.getData().getDataBuffer(); 

다른 데이터 버퍼를 처리하려면 형식을 확인하고 그에 따라 캐스트 한 다음 바이트 배열로 변환해야합니다. 바이트 버퍼가 용이해야한다

DataBufferByte buff = (DataBufferByte) jpg.getData().getDataBuffer(); 

다음 numOfBank가 0

buff.getData(numOfBank) 

하면 이미지

바이트 배열을

Answer 2

찾기 반환해야합니다 :

public jpgdcm(File file, File fileOutput) { 
    try { 
      jpgLen = (int) file.length(); 



    BufferedImage jpegImage = ImageIO.read(file); 
    /* 
    * We open a try block and then read our Jpeg into a BufferedImage through ImageIO.read() method. If this results in an invalid image so we may throw a new exception. 
    * Else, we’ve got a valid image and therefore valuable information about it. 
    * The BufferedImage class has a lot of useful methods for retrieving image data, then let’s save the number of color components (samples per pixel) of our image, the bits 
    * per pixel and the bits allocated: 

    */ 

     if (jpegImage == null) throw new Exception("Invalid file."); 
    /* We open a try block and then read our Jpeg into a BufferedImage through ImageIO.read() method. 
     * If this results in an invalid image so we may throw a new exception. 
     * Else, we’ve got a valid image and therefore valuable information about it. 
     * The BufferedImage class has a lot of useful methods for retrieving image data, 
     * then let’s save the number of color components (samples per pixel) of our image, 
     * the bits per pixel and the bits allocated: */ 

     int colorComponents = jpegImage.getColorModel().getNumColorComponents(); 
     int bitsPerPixel = jpegImage.getColorModel().getPixelSize(); 
     int bitsAllocated = (bitsPerPixel/colorComponents); 
     int samplesPerPixel = colorComponents; 
    /*It’s time to start building our Dicom dataset:*/ 

     Attributes dicom = new Attributes(); 
     dicom.setString(Tag.SpecificCharacterSet, VR.CS, "ISO_IR 100"); 
     dicom.setString(Tag.PhotometricInterpretation, VR.CS, samplesPerPixel == 3 ? "YBR_FULL_422" : "MONOCHROME2"); 

    /*The first line creates a new basic Dicom object defined by dcm4che2 toolkit. 
     *The next one puts header information for Specific Character Set: ISO_IR 100 – it’s the same for ISO-8859-1 – the code for Latin alphabet. 
     *Finally, the last line puts header information for photometric interpretation (read with or without colors). 
     *So if our image has samples per pixel equals to 3, it has colors (YBR_FULL_422), else it’s a grayscale image (MONOCHROME2). 
     The following lines add integer values to our Dicom header. Note that all of them comes from BufferedImage methods. 
     These values are mandatory when encapsulating. For more information you can check Part 3.5 of Dicom Standard. */ 

     dicom.setInt(Tag.SamplesPerPixel, VR.US, samplesPerPixel);   
     dicom.setInt(Tag.Rows, VR.US, jpegImage.getHeight()); 
     dicom.setInt(Tag.Columns, VR.US, jpegImage.getWidth()); 
     dicom.setInt(Tag.BitsAllocated, VR.US, bitsAllocated); 
     dicom.setInt(Tag.BitsStored, VR.US, bitsAllocated); 
     dicom.setInt(Tag.HighBit, VR.US, bitsAllocated-1); 
     dicom.setInt(Tag.PixelRepresentation, VR.US, 0); 
     /*Also, our Dicom header needs information about date and time of creation:*/ 
     dicom.setDate(Tag.InstanceCreationDate, VR.DA, new Date()); 
     dicom.setDate(Tag.InstanceCreationTime, VR.TM, new Date()); 
     /* Every Dicom file has a unique identifier. 
      * Here we’re generating study, series and Sop instances UIDs. 
      * You may want to modify these values, but you should to care about their uniqueness. 
      */ 
     dicom.setString(Tag.StudyInstanceUID, VR.UI, UIDUtils.createUID()); 
     dicom.setString(Tag.SeriesInstanceUID, VR.UI, UIDUtils.createUID()); 
     dicom.setString(Tag.SOPInstanceUID, VR.UI, UIDUtils.createUID()); 
     dicom.setString(Tag.StudyInstanceUID, VR.UI, UIDUtils.createUID()); 
      dicom.setString(Tag.SeriesInstanceUID, VR.UI, UIDUtils.createUID()); 
      dicom.setString(Tag.SOPInstanceUID, VR.UI, UIDUtils.createUID()); 
     /*Our Dicom header is almost done. 
      * The following command initiates Dicom metafile information considering JPEGBaseline1 as transfer syntax. 
      * This means this file has Jpeg data encapsulated instead common medical image pixel data. 
      * The most common Jpeg files use a subset of the Jpeg standard called baseline Jpeg. 
      * A baseline Jpeg file contains a single image compressed with the baseline discrete cosine transformation (DCT) and Huffman encoding. 
      */ 
     // dicom.initFileMetaInformation(UID.JPEGBaseline1); 
     /*After initiate the header we can open an output stream for saving our Dicom dataset as follows:*/ 

       Attributes fmi = new Attributes(); 

       fmi.setString(Tag.ImplementationVersionName, VR.SH, "DCM4CHE3"); 
        fmi.setString(Tag.ImplementationClassUID, VR.UI, UIDUtils.createUID()); 
        fmi.setString(Tag.TransferSyntaxUID, VR.UI, transferSyntax); 
        fmi.setString(Tag.MediaStorageSOPClassUID, VR.UI, transferSyntax); 
        fmi.setString(Tag.MediaStorageSOPInstanceUID, VR.UI,UIDUtils.createUID()); 
        fmi.setString(Tag.FileMetaInformationVersion, VR.OB, "1"); 
        fmi.setInt(Tag.FileMetaInformationGroupLength, VR.UL, dicom.size()+fmi.size()); 



     DicomOutputStream dos = new DicomOutputStream(fileOutput); 
     dos.writeDataset(fmi, dicom); 
     dos.writeHeader(Tag.PixelData, VR.OB, -1); 

     /* 
      * The Item Tag (FFFE,E000) is followed by a 4 byte item length field encoding the explicit number of bytes of the item. 
      * The first item in the sequence of items before the encoded pixel data stream shall be a basic item with length equals to zero: 
      */ 
     dos.writeHeader(Tag.Item, null, 0); 
     /*The next Item then keeps the length of our Jpeg file. */ 
     /* 
     According to Gunter from dcm4che team we have to take care that 
     the pixel data fragment length containing the JPEG stream has 
     an even length. 
     */ 

     dos.writeHeader(Tag.Item, null, (jpgLen+1)&~1); 
     /* Now all we have to do is to fill this item with bytes taken from our Jpeg file*/ 
     FileInputStream fis = new FileInputStream(file); 
     BufferedInputStream bis = new BufferedInputStream(fis); 
     DataInputStream dis = new DataInputStream(bis); 

     byte[] buffer = new byte[65536];   
     int b; 
     while ((b = dis.read(buffer)) > 0) { 
      dos.write(buffer, 0, b); 
     } 
     /*Finally, the Dicom Standard tells that we have to put a last Tag: 
      * a Sequence Delimiter Item (FFFE,E0DD) with length equals to zero.*/ 


     if ((jpgLen&1) != 0) dos.write(0); 
      dos.writeHeader(Tag.SequenceDelimitationItem, null, 0); 
      dos.close(); 


    } catch (Exception e) { 

    e.printStackTrace(); 
      } 

    } 

을

Answer 3

이 코드는

org.dcm4che3 이하로 포함 할 수

import java.io.BufferedInputStream; 
import java.io.BufferedOutputStream; 
import java.io.DataInputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.Date; 
import java.util.Enumeration; 
import java.util.List; 
import java.util.Properties; 

import org.apache.commons.cli.CommandLine; 
import org.apache.commons.cli.HelpFormatter; 
import org.apache.commons.cli.OptionBuilder; 
import org.apache.commons.cli.Options; 
import org.apache.commons.cli.ParseException; 
import org.apache.commons.cli.PosixParser; 
import org.dcm4che2.data.BasicDicomObject; 
import org.dcm4che2.data.DicomObject; 
import org.dcm4che2.data.Tag; 
import org.dcm4che2.data.UID; 
import org.dcm4che2.data.VR; 
import org.dcm4che2.io.DicomOutputStream; 
import org.dcm4che2.util.UIDUtils; 


public class Jpg2Dcm { 

    private static final String USAGE = 
     "jpg2dcm [Options] <jpgfile> <dcmfile>"; 

    private static final String DESCRIPTION = 
     "Encapsulate JPEG Image into DICOM Object.\nOptions:"; 

    private static final String EXAMPLE = 
     "--\nExample 1: Encapulate JPEG Image verbatim with default values " + 
     "for mandatory DICOM attributes into DICOM Secondary Capture Image:" + 
     "\n$ jpg2dcm image.jpg image.dcm" + 
     "\n--\nExample 2: Encapulate JPEG Image without application segments " + 
     "and additional DICOM attributes to mandatory defaults into DICOM " + 
     "Image Object:" + 
     "\n$ jpg2dcm --no-appn -c patattrs.cfg homer.jpg image.dcm" + 
     "\n--\nExample 3: Encapulate MPEG2 Video with specified DICOM " + 
     "attributes into DICOM Video Object:" + 
     "\n$ jpg2dcm --mpeg -C mpg2dcm.cfg video.mpg video.dcm"; 

    private static final String LONG_OPT_CHARSET = "charset"; 

    private static final String OPT_CHARSET_DESC = 
     "Specific Character Set code string, ISO_IR 100 by default"; 

    private static final String OPT_AUGMENT_CONFIG_DESC = 
     "Specifies DICOM attributes included additional to mandatory defaults"; 

    private static final String OPT_REPLACE_CONFIG_DESC = 
     "Specifies DICOM attributes included instead of mandatory defaults"; 

    private static final String LONG_OPT_TRANSFER_SYNTAX = "transfer-syntax"; 

    private static final String OPT_TRANSFER_SYNTAX_DESC = 
     "Transfer Syntax; 1.2.840.10008.1.2.4.50 (JPEG Baseline) by default."; 

    private static final String LONG_OPT_MPEG = "mpeg"; 

    private static final String OPT_MPEG_DESC = 
     "Same as --transfer-syntax 1.2.840.10008.1.2.4.100 (MPEG2)."; 

    private static final String LONG_OPT_UID_PREFIX = "uid-prefix"; 

    private static final String OPT_UID_PREFIX_DESC = 
     "Generate UIDs with given prefix, 1.2.40.0.13.1.<host-ip> by default."; 

    private static final String LONG_OPT_NO_APPN = "no-appn"; 

    private static final String OPT_NO_APPN_DESC = 
     "Exclude application segments APPn from JPEG stream; " + 
     "encapsulate JPEG stream verbatim by default."; 

    private static final String OPT_HELP_DESC = 
     "Print this message"; 

    private static final String OPT_VERSION_DESC = 
     "Print the version information and exit"; 

    private static int FF = 0xff; 

    private static int SOF = 0xc0; 

    private static int DHT = 0xc4; 

    private static int DAC = 0xcc; 

    private static int SOI = 0xd8; 

    private static int SOS = 0xda; 

    private static int APP = 0xe0;  

    private String charset = "ISO_IR 100"; 

    private String transferSyntax = UID.JPEGBaseline1; 

    private byte[] buffer = new byte[8192]; 

    private int jpgHeaderLen; 

    private int jpgLen; 

    private boolean noAPPn = false; 

    private Properties cfg = new Properties(); 

    public Jpg2Dcm() { 
     try { 
      cfg.load(Jpg2Dcm.class.getResourceAsStream("jpg2dcm.cfg")); 
     } catch (Exception e) { 
      throw new RuntimeException(e); 
     } 
    } 

    public final void setCharset(String charset) { 
     this.charset = charset; 
    } 

    private final void setTransferSyntax(String uid) { 
     this.transferSyntax = uid; 
    } 


    private final void setNoAPPn(boolean noAPPn) { 
     this.noAPPn = noAPPn; 
    } 

    private void loadConfiguration(File cfgFile, boolean augment) 
      throws IOException { 
     Properties tmp = augment ? new Properties(cfg) : new Properties(); 
     InputStream in = new BufferedInputStream(new FileInputStream(cfgFile)); 
     try { 
      tmp.load(in); 
     } finally { 
      in.close(); 
     } 
     cfg = tmp; 
    } 

    public void convert(File jpgFile, File dcmFile) throws IOException { 
     jpgHeaderLen = 0; 
     jpgLen = (int) jpgFile.length(); 
     DataInputStream jpgInput = new DataInputStream(
       new BufferedInputStream(new FileInputStream(jpgFile))); 
     try { 
      DicomObject attrs = new BasicDicomObject(); 
      attrs.putString(Tag.SpecificCharacterSet, VR.CS, charset); 
      for (Enumeration en = cfg.propertyNames(); en.hasMoreElements();) { 
       String key = (String) en.nextElement(); 
       int[] tagPath = Tag.toTagPath(key);     
       int last = tagPath.length-1; 
       VR vr = attrs.vrOf(tagPath[last]); 
       if (vr == VR.SQ) { 
        attrs.putSequence(tagPath); 
       } else { 
        attrs.putString(tagPath, vr, cfg.getProperty(key)); 
       } 
      } 
      if (noAPPn || missingRowsColumnsSamplesPMI(attrs)) { 
       readHeader(attrs, jpgInput); 
      } 
      ensureUS(attrs, Tag.BitsAllocated, 8); 
      ensureUS(attrs, Tag.BitsStored, attrs.getInt(Tag.BitsAllocated)); 
      ensureUS(attrs, Tag.HighBit, attrs.getInt(Tag.BitsStored) - 1); 
      ensureUS(attrs, Tag.PixelRepresentation, 0); 
      ensureUID(attrs, Tag.StudyInstanceUID); 
      ensureUID(attrs, Tag.SeriesInstanceUID); 
      ensureUID(attrs, Tag.SOPInstanceUID); 
      Date now = new Date(); 
      attrs.putDate(Tag.InstanceCreationDate, VR.DA, now); 
      attrs.putDate(Tag.InstanceCreationTime, VR.TM, now); 
      attrs.initFileMetaInformation(transferSyntax); 
      FileOutputStream fos = new FileOutputStream(dcmFile); 
      BufferedOutputStream bos = new BufferedOutputStream(fos); 
      DicomOutputStream dos = new DicomOutputStream(bos); 
      try { 
       dos.writeDicomFile(attrs); 
       dos.writeHeader(Tag.PixelData, VR.OB, -1); 
       dos.writeHeader(Tag.Item, null, 0); 
       dos.writeHeader(Tag.Item, null, (jpgLen+1)&~1); 
       dos.write(buffer, 0, jpgHeaderLen); 
       int r; 
       while ((r = jpgInput.read(buffer)) > 0) { 
        dos.write(buffer, 0, r); 
       } 
       if ((jpgLen&1) != 0) { 
        dos.write(0); 
       } 
       dos.writeHeader(Tag.SequenceDelimitationItem, null, 0); 
      } finally { 
       dos.close(); 
      } 
     } finally { 
      jpgInput.close();    
     } 
    }  

    private boolean missingRowsColumnsSamplesPMI(DicomObject attrs) { 
     return !(attrs.containsValue(Tag.Rows) 
       && attrs.containsValue(Tag.Columns) 
       && attrs.containsValue(Tag.SamplesPerPixel) 
       && attrs.containsValue(Tag.PhotometricInterpretation) 
       ); 
    } 

    private void readHeader(DicomObject attrs, DataInputStream jpgInput) 
      throws IOException { 
     if (jpgInput.read() != FF || jpgInput.read() != SOI 
       || jpgInput.read() != FF) { 
      throw new IOException(
        "JPEG stream does not start with FF D8 FF"); 
     } 
     int marker = jpgInput.read(); 
     int segmLen; 
     boolean seenSOF = false; 
     buffer[0] = (byte) FF; 
     buffer[1] = (byte) SOI; 
     buffer[2] = (byte) FF; 
     buffer[3] = (byte) marker; 
     jpgHeaderLen = 4; 
     while (marker != SOS) { 
      segmLen = jpgInput.readUnsignedShort(); 
      if (buffer.length < jpgHeaderLen + segmLen + 2) { 
       growBuffer(jpgHeaderLen + segmLen + 2); 
      } 
      buffer[jpgHeaderLen++] = (byte) (segmLen >>> 8); 
      buffer[jpgHeaderLen++] = (byte) segmLen; 
      jpgInput.readFully(buffer, jpgHeaderLen, segmLen - 2); 
      if ((marker & 0xf0) == SOF && marker != DHT && marker != DAC) { 
       seenSOF = true; 
       int p = buffer[jpgHeaderLen] & 0xff; 
       int y = ((buffer[jpgHeaderLen+1] & 0xff) << 8) 
         | (buffer[jpgHeaderLen+2] & 0xff); 
       int x = ((buffer[jpgHeaderLen+3] & 0xff) << 8) 
         | (buffer[jpgHeaderLen+4] & 0xff); 
       int nf = buffer[jpgHeaderLen+5] & 0xff; 
       attrs.putInt(Tag.SamplesPerPixel, VR.US, nf); 
       if (nf == 3) { 
        attrs.putString(Tag.PhotometricInterpretation, VR.CS, 
          "YBR_FULL_422"); 
        attrs.putInt(Tag.PlanarConfiguration, VR.US, 0); 
       } else { 
        attrs.putString(Tag.PhotometricInterpretation, VR.CS, 
          "MONOCHROME2"); 
       } 
       attrs.putInt(Tag.Rows, VR.US, y); 
       attrs.putInt(Tag.Columns, VR.US, x); 
       attrs.putInt(Tag.BitsAllocated, VR.US, p > 8 ? 16 : 8); 
       attrs.putInt(Tag.BitsStored, VR.US, p); 
       attrs.putInt(Tag.HighBit, VR.US, p-1); 
       attrs.putInt(Tag.PixelRepresentation, VR.US, 0); 
      } 
      if (noAPPn & (marker & 0xf0) == APP) { 
       jpgLen -= segmLen + 2; 
       jpgHeaderLen -= 4; 
      } else { 
       jpgHeaderLen += segmLen - 2; 
      } 
      if (jpgInput.read() != FF) { 
       throw new IOException("Missing SOS segment in JPEG stream"); 
      } 
      marker = jpgInput.read(); 
      buffer[jpgHeaderLen++] = (byte) FF; 
      buffer[jpgHeaderLen++] = (byte) marker; 
     } 
     if (!seenSOF) { 
      throw new IOException("Missing SOF segment in JPEG stream"); 
     } 
    } 

    private void growBuffer(int minSize) { 
     int newSize = buffer.length << 1; 
     while (newSize < minSize) { 
      newSize <<= 1; 
     } 
     byte[] tmp = new byte[newSize]; 
     System.arraycopy(buffer, 0, tmp, 0, jpgHeaderLen); 
     buffer = tmp; 
    } 

    private void ensureUID(DicomObject attrs, int tag) { 
     if (!attrs.containsValue(tag)) { 
      attrs.putString(tag, VR.UI, UIDUtils.createUID()); 
     }   
    } 

    private void ensureUS(DicomObject attrs, int tag, int val) { 
     if (!attrs.containsValue(tag)) { 
      attrs.putInt(tag, VR.US, val); 
     }   
    }  
    public static void main(String[] args) { 
     try { 
      CommandLine cl = parse(args); 
      Jpg2Dcm jpg2Dcm = new Jpg2Dcm(); 
      if (cl.hasOption(LONG_OPT_CHARSET)) { 
       jpg2Dcm.setCharset(cl.getOptionValue(LONG_OPT_CHARSET)); 
      } 
      if (cl.hasOption("c")) { 
       jpg2Dcm.loadConfiguration(new File(cl.getOptionValue("c")), true); 
      } 
      if (cl.hasOption("C")) { 
       jpg2Dcm.loadConfiguration(new File(cl.getOptionValue("C")), false); 
      } 
      if (cl.hasOption(LONG_OPT_UID_PREFIX)) { 
       UIDUtils.setRoot(cl.getOptionValue(LONG_OPT_UID_PREFIX)); 
      } 
      if (cl.hasOption(LONG_OPT_MPEG)) { 
       jpg2Dcm.setTransferSyntax(UID.MPEG2); 
      } 
      if (cl.hasOption(LONG_OPT_TRANSFER_SYNTAX)) { 
       jpg2Dcm.setTransferSyntax(
         cl.getOptionValue(LONG_OPT_TRANSFER_SYNTAX)); 
      } 
      jpg2Dcm.setNoAPPn(cl.hasOption(LONG_OPT_NO_APPN)); 

      List argList = cl.getArgList(); 
      File jpgFile = new File("d:\\VIPUL.jpg"); 
      File dcmFile = new File("d:\\aa.dcm"); 
      long start = System.currentTimeMillis(); 
      jpg2Dcm.convert(jpgFile, dcmFile); 
      long fin = System.currentTimeMillis(); 
      System.out.println("Encapsulated " + jpgFile + " to " 
        + dcmFile + " in " + (fin - start) + "ms."); 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 
    } 

    private static CommandLine parse(String[] args) { 
     Options opts = new Options(); 

     OptionBuilder.withArgName("code"); 
     OptionBuilder.hasArg(); 
     OptionBuilder.withDescription(OPT_CHARSET_DESC); 
     OptionBuilder.withLongOpt(LONG_OPT_CHARSET); 
     opts.addOption(OptionBuilder.create()); 

     OptionBuilder.withArgName("file"); 
     OptionBuilder.hasArg(); 
     OptionBuilder.withDescription(OPT_AUGMENT_CONFIG_DESC); 
     opts.addOption(OptionBuilder.create("c")); 

     OptionBuilder.withArgName("file"); 
     OptionBuilder.hasArg(); 
     OptionBuilder.withDescription(OPT_REPLACE_CONFIG_DESC); 
     opts.addOption(OptionBuilder.create("C")); 

     OptionBuilder.withArgName("prefix"); 
     OptionBuilder.hasArg(); 
     OptionBuilder.withDescription(OPT_UID_PREFIX_DESC); 
     OptionBuilder.withLongOpt(LONG_OPT_UID_PREFIX); 
     opts.addOption(OptionBuilder.create()); 

     OptionBuilder.withArgName("uid"); 
     OptionBuilder.hasArg(); 
     OptionBuilder.withDescription(OPT_TRANSFER_SYNTAX_DESC); 
     OptionBuilder.withLongOpt(LONG_OPT_TRANSFER_SYNTAX); 
     opts.addOption(OptionBuilder.create()); 

     opts.addOption(null, LONG_OPT_MPEG, false, OPT_MPEG_DESC); 

     opts.addOption(null, LONG_OPT_NO_APPN, false, OPT_NO_APPN_DESC); 

     opts.addOption("h", "help", false, OPT_HELP_DESC); 
     opts.addOption("V", "version", false, OPT_VERSION_DESC); 

     CommandLine cl = null; 
     try { 
      cl = new PosixParser().parse(opts, args); 
     } catch (ParseException e) { 
      exit("jpg2dcm: " + e.getMessage()); 
      throw new RuntimeException("unreachable"); 
     } 
     if (cl.hasOption('V')) { 
      Package p = Jpg2Dcm.class.getPackage(); 
      System.out.println("jpg2dcm v" + p.getImplementationVersion()); 
      System.exit(0); 
     } 
     if (cl.hasOption('h') || cl.getArgList().size() != 2) { 
      HelpFormatter formatter = new HelpFormatter(); 
      formatter.printHelp(USAGE, DESCRIPTION, opts, EXAMPLE); 
      System.exit(0); 
     } 

     return cl; 
    } 

    private static void exit(String msg) { 
     System.err.println(msg); 
     System.err.println("Try 'jpg2dcm -h' for more information."); 
     System.exit(1); 
    } 

} 

Jpg2Dcm.java 파일 사용 파일 DICOM 파일

import java.io.BufferedOutputStream; 
import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileNotFoundException; 
import java.io.FileOutputStream; 
import java.io.IOException; 

import org.dcm4che2.data.DicomObject; 
import org.dcm4che2.data.Tag; 
import org.dcm4che2.data.VR; 
import org.dcm4che2.io.DicomInputStream; 
import org.dcm4che2.io.DicomOutputStream; 

public class JPG_TO_DCM { 
    public static void main(String a[]) throws FileNotFoundException, IOException 
    { 
    // System.out.println("JPG2DCM_Convert.main()"); 
     String patientID="123"; // Enter Patient ID 
     String patientName="DCM IMAGE"; // Enter Pantient Name 
     String studyID="123"; // Enter Study ID 
     Jpg2Dcm jpg2Dcm = new Jpg2Dcm(); // 
     File jpgFileOS = new File("D:\\AA.jpg"); 
     File dcmFileOS = new File("D:\\AA.dcm"); 

     try { 
      jpg2Dcm.convert(jpgFileOS, dcmFileOS); // Only Convert Jpg to Dicom without seting any dicom tag (without DicomHeader) 
     } catch (IOException e) { 
      e.printStackTrace(); 
     } 


     try { 
      anonymizeDicom(new File("D:\\AA.dcm"),new File("D:\\AA_FIANAL.dcm"),patientID,studyID,patientName); // Set the DICOM Header 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 



    } 
    public static final int[] TAGS = { 
     Tag.PatientID, 
     Tag.StudyID, 
     Tag.PatientName 
    }; 
    public static void anonymizeDicom(File fileInput, File fileOutput, String patientIDForUpdate, String studyIDForUpdate,String patientNameForUpdate) throws FileNotFoundException, IOException 
    { 
     int patientID = 1048608; 
     int studyID = 2097168; 
     int patientName=1048592; 
     try 
     { 
      FileInputStream fis = new FileInputStream(fileInput); 
      DicomInputStream dis = new DicomInputStream(fis); 
      DicomObject obj = dis.readDicomObject(); 
      for (int tag : TAGS) 
      { 
       if (tag == patientID) { 
        replaceTag(obj, tag, patientIDForUpdate); 
       } 
       if (tag == studyID) { 
        replaceTag(obj, tag, studyIDForUpdate); 
       } 

       if (tag == patientName) { 
        replaceTag(obj, tag, patientNameForUpdate); 
       } 

      } 
      fis.close(); 
      dis.close(); 
      writeDicomFile(obj, fileOutput); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

    @SuppressWarnings("unused") 
    private static String[] getValue(DicomObject object, int[] PATIENT_ADDITIONAL_TAGS) 
    { 
     String [] value = new String [PATIENT_ADDITIONAL_TAGS.length]; 
     int i =0; 
     while (i<PATIENT_ADDITIONAL_TAGS.length) 
     { 
      for (int tag : PATIENT_ADDITIONAL_TAGS) 
      { 
         value[i]=object.getString(tag); 
         i++; 
      } 
     } 
     return value; 
    } 

    public static void replaceTag(DicomObject dObj, int tag, String newValue) { 
     if (tag != 0 && dObj.contains(tag)) { 
      VR vr = dObj.vrOf(tag); 
      try 
      { 
       dObj.putString(tag, vr, newValue); 
      } catch (Exception e) { 
      // System.err.println("Error replacing Tag: " + tag+ " with new value: " + newValue); 
      } 
     } 
    } 

    public static void writeDicomFile(DicomObject dObj, File f) { 
     FileOutputStream fos; 
     try 
     { 
      fos = new FileOutputStream(f); 
     } 
     catch (FileNotFoundException e) 
     { 
      e.printStackTrace(); 
      return; 
     } 
     BufferedOutputStream bos = new BufferedOutputStream(fos); 
     DicomOutputStream dos = new DicomOutputStream(bos); 
     try { 
      dos.writeDicomFile(dObj); 
     } catch (IOException e) { 
      e.printStackTrace(); 
      return; 
     } finally { 
      try { 
       dos.close(); 
      } catch (IOException ignore) { 
      } 
     } 
    } 
    static int count1 = 0; 
    public static void getFile(String dirPath, String destdirPath,String patientID, String studyID,String patientNameForUpdate) throws FileNotFoundException,IOException 
    { 
     File f = new File(dirPath); 
     File[] files = f.listFiles(); 
     if (files != null) 
      for (int i = 0; i < files.length; i++) { 
       File file = files[i]; 
       if (file.isDirectory()) { 
        getFile(file.getAbsolutePath(), destdirPath, patientID,studyID,patientNameForUpdate); 
       } else { 
        count1++; 
        String name = file.getAbsolutePath(); 
       // test7 test = new test7(); 
        anonymizeDicom(new File(name), new File(destdirPath+ "/" + file.getName()), patientID, studyID,patientNameForUpdate); 
       } 
      } 
    } 

} 

Jpg2Dcm.java에 JPG 파일을 변환합니다. tool.dcm2jpg.Dcm2Jpg.java 파일

dcm4che-공구 dcm2jpg-3.3.7.jar

또한 포함 이것도

1. 몬즈 CLI-1.2.jar
2. dcm4che 코어-2.0.26.jar
3. log4j에-boot.jar
4. SLF4J-API-1.5.0.jar
5. SLF4J-log4j12-1.5.0.jar