Updates for Timepoint assocation (LT-60) and Conformance Checks (LT-92, LT-93, LT-94)

2016-02-08 19:59:39 +01:00
1 parent 6c4eae3699
commit beaa56c0b3
@@ -0,0 +1,675 @@
+PDU = function() {
+    this.fields = [];
+    this.lengthBytes = 4;  
+};
+
+PDU.prototype.length = function(fields) {
+    var len = 0;
+    fields.forEach(function(f) {
+        len += !f.getFields ? f.length() : f.length(f.getFields());
+    });
+    return len;
+};
+
+PDU.prototype.is = function(type) {
+    return this.type == type;
+};
+
+PDU.prototype.getFields = function(fields) {
+    var len = this.lengthField(fields);
+    fields.unshift(len);
+    if (this.type !== null) {
+        fields.unshift(new ReservedField());
+        fields.unshift(new HexField(this.type));
+    }
+    
+    return fields;
+};
+
+PDU.prototype.lengthField = function(fields) {
+    if (this.lengthBytes == 4) {
+        return new UInt32Field(this.length(fields));
+    } else if (this.lengthBytes == 2) {
+        return new UInt16Field(this.length(fields));
+    } else {
+        throw 'Invalid length bytes';
+    }
+};  
+
+PDU.prototype.read = function(stream) {
+    stream.read(C.TYPE_HEX, 1);
+    var length = stream.read(C.TYPE_UINT32);
+    this.readBytes(stream, length);
+};
+
+PDU.prototype.load = function(stream) {
+    return pduByStream(stream);
+};
+
+PDU.prototype.loadPDV = function(stream, length) {
+    if (stream.end()) return false;
+    var bytesRead = 0, pdvs = [];
+    while (bytesRead < length) {
+        var plength = stream.read(C.TYPE_UINT32), 
+            pdv = new PresentationDataValueItem();
+        pdv.readBytes(stream, plength);
+        bytesRead += plength + 4;
+
+        pdvs.push(pdv);
+    }
+
+    return pdvs;
+};
+
+PDU.prototype.loadDicomMessage = function(stream, isCommand, isLast) {
+    var message = readMessage(stream, isCommand, isLast);
+    return message;
+};
+
+PDU.prototype.stream = function() {
+    var stream = new WriteStream(), 
+        fields = this.getFields();
+
+    // writing to buffer
+    fields.forEach(function(field) {
+        field.write(stream);
+    });
+
+    return stream;
+};
+
+PDU.prototype.buffer = function() {
+    return this.stream().buffer();
+};
+
+var interpretCommand = function(stream, isLast) {
+    parseDicomMessage(stream);
+};
+
+mergePDVs = function(pdvs) {
+    var merges = [], count = pdvs.length, i = 0;
+    while (i < count) {console.log(pdvs[i].isLast, pdvs[i].type);
+        if (!pdvs[i].isLast) {
+            var j = i;
+            while (!pdvs[j++].isLast && j < count) {
+                pdvs[i].messageStream.concat(pdvs[j].messageStream);
+            }
+
+            merges.push(pdvs[i]);
+            i = j;
+        } else {
+            merges.push(pdvs[i++]);
+        }
+    }
+
+    return merges;
+};
+
+pduByStream = function(stream) {
+    if (stream.end()) return null;
+
+    var pduType = stream.read(C.TYPE_HEX, 1), typeNum = parseInt(pduType, 16), pdu = null;
+    //console.log("RECEIVED PDU-TYPE ", pduType);
+    switch (typeNum) {
+        case 0x01 : pdu = new AssociateRQ(); break;
+        case 0x02 : pdu = new AssociateAC(); break;
+        case 0x04 : pdu = new PDataTF(); break;
+        case 0x06 : pdu = new ReleaseRP(); break;
+        case 0x07 : pdu = new AssociateAbort(); break;
+        case 0x10 : pdu = new ApplicationContextItem(); break;
+        case 0x20 : pdu = new PresentationContextItem(); break;
+        case 0x21 : pdu = new PresentationContextItemAC(); break;
+        case 0x30 : pdu = new AbstractSyntaxItem(); break;
+        case 0x40 : pdu = new TransferSyntaxItem(); break;
+        case 0x50 : pdu = new UserInformationItem(); break;
+        case 0x51 : pdu = new MaximumLengthItem(); break;
+        case 0x52 : pdu = new ImplementationClassUIDItem(); break;
+        case 0x55 : pdu = new ImplementationVersionNameItem(); break;
+        default : throw 'Unrecoginized pdu type ' + pduType; break;
+    }
+    if (pdu)
+      pdu.read(stream);
+
+    return pdu;
+};
+
+var nextItemIs = function(stream, pduType) {
+    if (stream.end()) return false;
+
+    var nextType = stream.read(C.TYPE_HEX, 1);
+    stream.increment(-1);
+    return pduType == nextType;
+};
+
+AssociateRQ = function() {
+    PDU.call(this);
+    this.type = C.ITEM_TYPE_PDU_ASSOCIATE_RQ;
+    this.protocolVersion = 1;  
+};
+
+util.inherits(AssociateRQ, PDU);
+
+AssociateRQ.prototype.setProtocolVersion = function(version) {
+    this.protocolVersion = version;
+};
+
+AssociateRQ.prototype.setCalledAETitle = function(title) {
+    this.calledAETitle = title;
+};
+
+AssociateRQ.prototype.setCallingAETitle = function(title) {
+    this.callingAETitle = title;
+};
+
+AssociateRQ.prototype.setApplicationContextItem = function(item) {
+    this.applicationContextItem = item;
+};
+
+AssociateRQ.prototype.setPresentationContextItems = function(items) {
+    this.presentationContextItems = items;
+};
+
+AssociateRQ.prototype.setUserInformationItem = function(item) {
+    this.userInformationItem = item;
+};
+
+AssociateRQ.prototype.allAccepted = function() {
+    for (var i in this.presentationContextItems) {
+        var item = this.presentationContextItems[i];
+        if (!item.accepted()) return false;
+    }
+
+    return true;
+};
+
+AssociateRQ.prototype.getFields = function() {
+    var f = [
+      new UInt16Field(this.protocolVersion), new ReservedField(2),
+      new FilledField(this.calledAETitle, 16), new FilledField(this.callingAETitle, 16),
+      new ReservedField(32), this.applicationContextItem
+    ];
+    this.presentationContextItems.forEach(function(context) {
+        f.push(context);
+    });
+    f.push(this.userInformationItem);
+    return AssociateRQ.super_.prototype.getFields.call(this, f);
+};
+
+AssociateRQ.prototype.readBytes = function(stream, length) {
+    this.type = C.ITEM_TYPE_PDU_ASSOCIATE_RQ;
+    var version = stream.read(C.TYPE_UINT16);
+    this.setProtocolVersion(version);
+    stream.increment(2);
+    var calledAE = stream.read(C.TYPE_ASCII, 16);
+    this.setCalledAETitle(calledAE);
+    var callingAE = stream.read(C.TYPE_ASCII, 16);
+    this.setCallingAETitle(callingAE);
+    stream.increment(32);
+  
+    var appContext = this.load(stream);
+    this.setApplicationContextItem(appContext);
+
+    var presContexts = [];
+    do {
+        presContexts.push(this.load(stream));
+    } while (nextItemIs(stream, C.ITEM_TYPE_PRESENTATION_CONTEXT_AC));
+    this.setPresentationContextItems(presContexts);
+
+    var userItem = this.load(stream);
+    this.setUserInformationItem(userItem);
+};
+
+AssociateRQ.prototype.buffer = function() {
+    return AssociateRQ.super_.prototype.buffer.call(this);
+};
+
+AssociateAC = function() {
+    AssociateRQ.call(this);
+};
+
+util.inherits(AssociateAC, AssociateRQ);
+
+AssociateAC.prototype.readBytes = function(stream, length) {
+    this.type = C.ITEM_TYPE_PDU_ASSOCIATE_AC;
+    var version = stream.read(C.TYPE_UINT16);
+    this.setProtocolVersion(version);
+    stream.increment(66);
+  
+    var appContext = this.load(stream);
+    this.setApplicationContextItem(appContext);
+
+    var presContexts = [];
+    do {
+        presContexts.push(this.load(stream));
+    } while (nextItemIs(stream, C.ITEM_TYPE_PRESENTATION_CONTEXT_AC));
+    this.setPresentationContextItems(presContexts);
+
+    var userItem = this.load(stream);
+    this.setUserInformationItem(userItem);
+};
+
+AssociateAbort = function() {
+    this.type = C.ITEM_TYPE_PDU_AABORT;
+    this.source = 1;
+    this.reason = 0;
+    PDU.call(this);  
+};
+
+util.inherits(AssociateAbort, PDU);
+
+AssociateAbort.prototype.setSource = function(src) {
+    this.source = src;
+};
+
+AssociateAbort.prototype.setReason = function(reason) {
+    this.reason = reason;
+};
+
+AssociateAbort.prototype.readBytes = function(stream, length) {
+    stream.increment(2);
+
+    var source = stream.read(C.TYPE_UINT8);
+    this.setSource(source);
+
+    var reason = stream.read(C.TYPE_UINT8);
+    this.setReason(reason);
+};
+
+AssociateAbort.prototype.getFields = function() {
+    return AssociateAbort.super_.prototype.getFields.call(this, [
+      new ReservedField(), new ReservedField(), 
+      new UInt8Field(this.source), new UInt8Field(this.reason)
+    ]);
+};
+
+ReleaseRQ = function() {
+    this.type = C.ITEM_TYPE_PDU_RELEASE_RQ;
+    PDU.call(this);
+};
+
+util.inherits(ReleaseRQ, PDU);
+
+ReleaseRQ.prototype.getFields = function() {
+    return ReleaseRQ.super_.prototype.getFields.call(this, [ new ReservedField(4) ]);
+};
+
+ReleaseRP = function() {
+    this.type = C.ITEM_TYPE_PDU_RELEASE_RP;
+    PDU.call(this);
+};
+
+util.inherits(ReleaseRP, PDU);
+
+ReleaseRP.prototype.readBytes = function(stream, length) {
+    stream.increment(4);
+};
+
+ReleaseRP.prototype.getFields = function() {
+    return ReleaseRP.super_.prototype.getFields.call(this, [ new ReservedField(4) ]);
+};
+
+PDataTF = function() {
+    this.type = C.ITEM_TYPE_PDU_PDATA;
+    this.presentationDataValueItems = [];
+    PDU.call(this);
+};
+
+util.inherits(PDataTF, PDU);
+
+PDataTF.prototype.setPresentationDataValueItems = function(items) {
+    this.presentationDataValueItems = items ? items : [];
+};
+
+PDataTF.prototype.getFields = function() {
+    var fields = this.presentationDataValueItems;
+
+    return PDataTF.super_.prototype.getFields.call(this, fields);
+};
+
+PDataTF.prototype.readBytes = function(stream, length) {
+    var pdvs = this.loadPDV(stream, length);
+    //let merges = mergePDVs(pdvs);
+
+    this.setPresentationDataValueItems(pdvs);
+};
+
+Item = function() {
+    PDU.call(this);
+    this.lengthBytes = 2;
+};
+
+util.inherits(Item, PDU);
+
+Item.prototype.read = function(stream) {
+    stream.read(C.TYPE_HEX, 1);
+    var length = stream.read(C.TYPE_UINT16);
+    this.readBytes(stream, length);
+};  
+
+Item.prototype.write = function(stream) {
+    stream.concat(this.stream());
+};
+
+Item.prototype.getFields = function(fields) {
+    return Item.super_.prototype.getFields.call(this, fields);
+};
+
+PresentationDataValueItem = function(context) {
+    this.type = null;
+    this.isLast = true;
+    this.dataFragment = null;
+    this.contextId = context;
+    this.messageStream = null;
+    Item.call(this);
+
+    this.lengthBytes = 4;
+};
+
+util.inherits(PresentationDataValueItem, Item);
+
+PresentationDataValueItem.prototype.setContextId = function(id) {
+    this.contextId = id;
+};
+
+PresentationDataValueItem.prototype.setFlag = function(flag) {
+    this.flag = flag;
+};
+
+PresentationDataValueItem.prototype.setPresentationDataValue = function(pdv) {
+    this.pdv = pdv;
+};
+
+PresentationDataValueItem.prototype.setMessage = function(msg) {
+    this.dataFragment = msg;
+};
+
+PresentationDataValueItem.prototype.getMessage = function() {
+    return this.dataFragment;
+};
+
+PresentationDataValueItem.prototype.readBytes = function(stream, length) {
+    this.contextId = stream.read(C.TYPE_UINT8);
+    var messageHeader = stream.read(C.TYPE_UINT8);
+    this.isLast = messageHeader >> 1;
+    this.type = messageHeader & 1 ? C.DATA_TYPE_COMMAND : C.DATA_TYPE_DATA;
+
+    //load dicom messages
+    this.messageStream = stream.more(length - 2);
+};
+
+PresentationDataValueItem.prototype.getFields = function() {
+    var fields = [ new UInt8Field(this.contextId) ];
+    //define header
+    var messageHeader = (1 & this.dataFragment.type) | ((this.isLast ? 1 : 0) << 1);
+    fields.push(new UInt8Field(messageHeader));
+
+    fields.push(this.dataFragment);
+    /*var stream = new WriteStream();this.dataFragment.write(stream);
+    //var f = this.dataFragment.getFields();
+    //var wr = new WriteStream();f[0].setSyntax(this.dataFragment.syntax);f[0].write(wr);
+    var rst = stream.toReadBuffer();
+    rst.setEndian(C.LITTLE_ENDIAN);
+      var group = rst.read(C.TYPE_UINT16), 
+          element = rst.read(C.TYPE_UINT16),
+          tag = tagFromNumbers(group, element);
+
+          console.log(tag.toString(), rst.read(C.TYPE_UINT32));*/
+    return PresentationDataValueItem.super_.prototype.getFields.call(this, fields);
+};  
+
+ApplicationContextItem = function() {
+    this.type = C.ITEM_TYPE_APPLICATION_CONTEXT;
+    this.applicationContextName = C.APPLICATION_CONTEXT_NAME;
+    Item.call(this);  
+};
+
+util.inherits(ApplicationContextItem, Item);
+
+ApplicationContextItem.prototype.setApplicationContextName = function(name) {
+    this.applicationContextName = name;
+};
+
+ApplicationContextItem.prototype.getFields = function() {
+    return ApplicationContextItem.super_.prototype.getFields.call(this, [ new StringField(this.applicationContextName) ]);
+};
+
+ApplicationContextItem.prototype.readBytes = function(stream, length) {
+    var appContext = stream.read(C.TYPE_ASCII, length);
+    this.setApplicationContextName(appContext);
+};
+
+ApplicationContextItem.prototype.buffer = function() {
+    return ApplicationContextItem.super_.prototype.buffer.call(this);
+};
+
+PresentationContextItem = function() {
+    this.type = C.ITEM_TYPE_PRESENTATION_CONTEXT;
+    Item.call(this);
+};
+
+util.inherits(PresentationContextItem, Item);
+
+PresentationContextItem.prototype.setPresentationContextID = function(id) {
+    this.presentationContextID = id;
+};
+
+PresentationContextItem.prototype.setAbstractSyntaxItem = function(item) {
+    this.abstractSyntaxItem = item;
+};
+
+PresentationContextItem.prototype.setTransferSyntaxesItems = function(items) {
+    this.transferSyntaxesItems = items;
+};
+
+PresentationContextItem.prototype.setResultReason = function(reason) {
+    this.resultReason = reason;
+};
+
+PresentationContextItem.prototype.accepted = function() {
+    return this.resultReason == 0;
+};
+
+PresentationContextItem.prototype.readBytes = function(stream, length) {
+    var contextId = stream.read(C.TYPE_UINT8);
+    this.setPresentationContextID(contextId);
+    stream.increment(1);
+    stream.increment(1);
+    stream.increment(1);
+
+    var abstractItem = this.load(stream);
+    this.setAbstractSyntaxItem(abstractItem);
+
+    var transContexts = [];
+    do {
+        transContexts.push(this.load(stream));
+    } while (nextItemIs(stream, C.ITEM_TYPE_TRANSFER_CONTEXT));
+    this.setTransferSyntaxesItems(transContexts);
+};
+
+PresentationContextItem.prototype.getFields = function() {
+    var f = [
+      new UInt8Field(this.presentationContextID), 
+      new ReservedField(), new ReservedField(), new ReservedField(), this.abstractSyntaxItem
+    ];
+    this.transferSyntaxesItems.forEach(function(syntaxItem) {
+        f.push(syntaxItem);
+    });
+    return PresentationContextItem.super_.prototype.getFields.call(this, f);  
+};
+
+PresentationContextItem.prototype.buffer = function() {
+    return PresentationContextItem.super_.prototype.buffer.call(this);
+};
+
+PresentationContextItemAC = function() {
+    this.type = C.ITEM_TYPE_PRESENTATION_CONTEXT_AC;
+    Item.call(this);
+};
+
+util.inherits(PresentationContextItemAC, PresentationContextItem);
+
+PresentationContextItemAC.prototype.readBytes = function(stream, length) {
+    var contextId = stream.read(C.TYPE_UINT8);
+    this.setPresentationContextID(contextId);
+    stream.increment(1);
+    var resultReason = stream.read(C.TYPE_UINT8);
+    this.setResultReason(resultReason);
+    stream.increment(1);
+
+    var transItem = this.load(stream);
+    this.setTransferSyntaxesItems([ transItem ]);
+};
+
+AbstractSyntaxItem = function() {
+    this.type = C.ITEM_TYPE_ABSTRACT_CONTEXT;
+    Item.call(this);  
+};
+
+util.inherits(AbstractSyntaxItem, Item);
+
+AbstractSyntaxItem.prototype.setAbstractSyntaxName = function(name) {
+    this.abstractSyntaxName = name;
+};
+
+AbstractSyntaxItem.prototype.getFields = function() {
+    return AbstractSyntaxItem.super_.prototype.getFields.call(this, [ new StringField(this.abstractSyntaxName) ]);
+};  
+
+AbstractSyntaxItem.prototype.buffer = function() {
+    return AbstractSyntaxItem.super_.prototype.buffer.call(this);
+};
+
+AbstractSyntaxItem.prototype.readBytes = function(stream, length) {
+    var name = stream.read(C.TYPE_ASCII, length);
+    this.setAbstractSyntaxName(name);
+};
+
+TransferSyntaxItem = function() {
+    this.type = C.ITEM_TYPE_TRANSFER_CONTEXT;
+    Item.call(this);
+};
+
+util.inherits(TransferSyntaxItem, Item);
+
+TransferSyntaxItem.prototype.setTransferSyntaxName = function(name) {
+    this.transferSyntaxName = name;
+};
+
+TransferSyntaxItem.prototype.readBytes = function(stream, length) {
+    var transfer = stream.read(C.TYPE_ASCII, length);
+    this.setTransferSyntaxName(transfer);
+};
+
+TransferSyntaxItem.prototype.getFields = function() {
+    return TransferSyntaxItem.super_.prototype.getFields.call(this, [ new StringField(this.transferSyntaxName) ]);
+};
+
+TransferSyntaxItem.prototype.buffer = function() {
+    return TransferSyntaxItem.super_.prototype.buffer.call(this);
+};
+
+UserInformationItem = function() {
+    this.type = C.ITEM_TYPE_USER_INFORMATION;
+    Item.call(this);
+};
+
+util.inherits(UserInformationItem, Item);
+
+UserInformationItem.prototype.setUserDataItems = function(items) {
+    this.userDataItems = items;
+};
+
+UserInformationItem.prototype.readBytes = function(stream, length) {
+    var items = [], pdu = this.load(stream);
+
+    do {
+        items.push(pdu);
+    } while (pdu = this.load(stream));
+    this.setUserDataItems(items);
+};
+
+UserInformationItem.prototype.getFields = function() {
+    var f = [];
+    this.userDataItems.forEach(function(userData) {
+        f.push(userData);
+    });
+    return UserInformationItem.super_.prototype.getFields.call(this, f);
+};
+
+UserInformationItem.prototype.buffer = function() {
+    return UserInformationItem.super_.prototype.buffer.call(this);
+};
+
+ImplementationClassUIDItem = function() {
+    this.type = C.ITEM_TYPE_IMPLEMENTATION_UID;
+    Item.call(this);  
+};
+
+util.inherits(ImplementationClassUIDItem, Item);
+
+ImplementationClassUIDItem.prototype.setImplementationClassUID = function(id) {
+    this.implementationClassUID = id;
+};
+
+ImplementationClassUIDItem.prototype.readBytes = function(stream, length) {
+    var uid = stream.read(C.TYPE_ASCII, length);
+    this.setImplementationClassUID(uid);
+};
+
+ImplementationClassUIDItem.prototype.getFields = function() {
+    return ImplementationClassUIDItem.super_.prototype.getFields.call(this, [ new StringField(this.implementationClassUID) ]);
+};
+
+ImplementationClassUIDItem.prototype.buffer = function() {
+    return ImplementationClassUIDItem.super_.prototype.buffer.call(this);
+};
+
+ImplementationVersionNameItem = function() {
+    this.type = C.ITEM_TYPE_IMPLEMENTATION_VERSION;
+    Item.call(this);  
+};
+
+util.inherits(ImplementationVersionNameItem, Item);
+
+ImplementationVersionNameItem.prototype.setImplementationVersionName = function(name) {
+    this.implementationVersionName = name;
+};
+
+ImplementationVersionNameItem.prototype.readBytes = function(stream, length) {
+    var name = stream.read(C.TYPE_ASCII, length);
+    this.setImplementationVersionName(name);
+};
+
+ImplementationVersionNameItem.prototype.getFields = function() {
+    return ImplementationVersionNameItem.super_.prototype.getFields.call(this, [ new StringField(this.implementationVersionName) ]);
+};
+
+ImplementationVersionNameItem.prototype.buffer = function() {
+    return ImplementationVersionNameItem.super_.prototype.buffer.call(this);
+};
+
+MaximumLengthItem = function() {
+    this.type = C.ITEM_TYPE_MAXIMUM_LENGTH;
+    this.maximumLengthReceived = 32768;
+    Item.call(this);  
+};
+
+util.inherits(MaximumLengthItem, Item);
+
+MaximumLengthItem.prototype.setMaximumLengthReceived = function(length) {
+    this.maximumLengthReceived = length;
+};
+
+MaximumLengthItem.prototype.readBytes = function(stream, length) {
+    var l = stream.read(C.TYPE_UINT32);
+    this.setMaximumLengthReceived(l);
+};
+
+MaximumLengthItem.prototype.getFields = function() {
+    return MaximumLengthItem.super_.prototype.getFields.call(this, [ new UInt32Field(this.maximumLengthReceived) ]);
+};
+
+MaximumLengthItem.prototype.buffer = function() {
+    return MaximumLengthItem.super_.prototype.buffer.call(this);
+};
+