private static HttpResponseMessage CreateMultipartResponse(IQidoRequestModel request, IEnumerable <DicomDataset> results)
{
HttpResponseMessage response;
if (MultipartResponseHelper.GetSubMediaType(request.AcceptHeader.FirstOrDefault( )) == MimeMediaTypes.xmlDicom)
{
MultipartContent multiContent;
response = new HttpResponseMessage( );
multiContent = new MultipartContent("related", MultipartResponseHelper.DicomDataBoundary);
response.Content = multiContent;
foreach (var result in results)
{
XmlDicomConverter converter = new XmlDicomConverter( );
MultipartResponseHelper.AddMultipartContent(multiContent,
new WadoResponse(new MemoryStream(Encoding.ASCII.GetBytes(converter.Convert(result))),
MimeMediaTypes.xmlDicom));
}
multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type",
"\"" + MimeMediaTypes.xmlDicom + "\""));
}
else
{
response = new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest);
}
return(response);
}
public async Task <HttpResponseMessage> ProcessRequest
(
IWebStoreRequest request,
string studyInstanceUID
)
{
DicomAttributeCollection bodyContent = null;
switch (request.MediaType)
{
//TODO: build the response here, { Successes.Add(objectMetadata), Failures.Add(objectMetadata), Create
case MimeMediaTypes.DICOM:
{
bodyContent = await GetResponseDataset(request, studyInstanceUID);
}
break;
case MimeMediaTypes.xmlDicom:
{
}
break;
case MimeMediaTypes.Json:
{
}
break;
default:
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
}
if (null != bodyContent)
{
var result = new HttpResponseMessage(HttpStatusCode.OK);
if (new MimeMediaType(MimeMediaTypes.Json).IsIn(request.AcceptHeader)) //this is not taking the "q" parameter
{
JsonDicomConverter converter = new JsonDicomConverter( );
result.Content = new StringContent(converter.Convert(bodyContent), System.Text.Encoding.UTF8, MimeMediaTypes.Json);
}
else
{
XmlDicomConverter xmlConverter = new XmlDicomConverter( );
result.Content = new StringContent(xmlConverter.Convert(bodyContent), System.Text.Encoding.UTF8, MimeMediaTypes.xmlDicom);
}
return(result);
}
else
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
public void ConvertFromXml(string sourceXmlFile, string destinationDicomFile)
{
XmlDicomConverter xmlConverter = new XmlDicomConverter( );
string xmlDataset = System.IO.File.ReadAllText(sourceXmlFile);
DicomDataset dataset = xmlConverter.Convert(xmlDataset);
DicomFile dsF = new DicomFile(dataset);
dsF.Save(destinationDicomFile);
}
public void ConvertToXml(string sourceDicomFile, string destinationXmlFile)
{
XmlDicomConverter xmlConverter = new XmlDicomConverter( )
{
WriteInlineBinary = true
};
DicomDataset sourceDS = DicomFile.Open(sourceDicomFile).Dataset;
string sourceXmlDicom = xmlConverter.Convert(sourceDS);
System.IO.File.WriteAllText(destinationXmlFile, sourceXmlDicom);
}
public void ConvertToXml( )
{
var testDir = Path.Combine(TestDirPath, "convertToXml");
var xmlConverter = new XmlDicomConverter( )
{
WriteInlineBinary = true
};
Directory.CreateDirectory(testDir);
//fo.DicomDataset sourceDS = Helper.GetDicomDataset ( 10 ).Clone ( fo.DicomTransferSyntax.ExplicitVRLittleEndian ) ;
foreach (string file in Directory.GetFiles(DicomHelpers.GetSampleImagesFolder( )))
{
string fullPath = Path.Combine(testDir, Path.GetFileName(file));
fo.DicomDataset sourceDS = fo.DicomFile.Open(file).Dataset;
var sourceXmlDicom = xmlConverter.Convert(sourceDS);
System.IO.File.WriteAllText(fullPath + ".xml", sourceXmlDicom);
fo.DicomDataset targetDs = xmlConverter.Convert(sourceXmlDicom);
var dsF = new fo.DicomFile(targetDs);
dsF.FileMetaInfo.TransferSyntax = fo.DicomTransferSyntax.Parse(targetDs.Get(fo.DicomTag.TransferSyntaxUID, targetDs.InternalTransferSyntax.ToString( )));
dsF.Save(fullPath + ".gen.dcm");
var destXmlDicom = xmlConverter.Convert(targetDs);
System.IO.File.WriteAllText(fullPath + ".gen.xml", destXmlDicom);
//private tags with private creator will cause this to fail
//VR for OW change to OB
Assert.AreEqual(sourceXmlDicom, destXmlDicom);
}
}
public ResponseContent Convert(ConverterData data)
{
List <ConvertedFileInfo> convertedDcm = new List <ConvertedFileInfo>();
ResponseContent responseContent = new ResponseContent( );
if (data.Files.Count == 0)
{
responseContent.Status = System.Net.HttpStatusCode.NoContent;
return(responseContent);
}
switch (data.Format)
{
case KnownFormats.JSON:
{
foreach (var file in data.Files)
{
var converter = new JsonDicomConverter();
var dcmFile = Dicom.DicomFile.Open(new MemoryStream(file.Data));
converter.WriteInlineBinary = true;
convertedDcm.Add(new ConvertedFileInfo( )
{
FileName = Path.ChangeExtension(file.FileName, KnownFormats.JSON),
Data = Encoding.UTF8.GetBytes(converter.Convert(dcmFile.Dataset))
});
}
}
break;
case KnownFormats.XML:
{
foreach (var file in data.Files)
{
var converter = new XmlDicomConverter();
var dcmFile = Dicom.DicomFile.Open(new MemoryStream(file.Data));
converter.WriteInlineBinary = true;
convertedDcm.Add(new ConvertedFileInfo( )
{
FileName = Path.ChangeExtension(file.FileName, KnownFormats.XML),
Data = Encoding.UTF8.GetBytes(converter.Convert(dcmFile.Dataset))
});
}
}
break;
case KnownFormats.JPG:
{
foreach (var file in data.Files)
{
FileStorageService storageService = new FileStorageService(Path.GetTempPath());
DicomMediaIdFactory mediaIdFactory = new DicomMediaIdFactory();
JpegMediaWriter writers = new JpegMediaWriter(storageService, mediaIdFactory);
var dcmFile = Dicom.DicomFile.Open(new MemoryStream(file.Data));
var locations = writers.CreateMedia(new DicomMediaWriterParameters()
{
Dataset = dcmFile.Dataset,
MediaInfo = new DicomMediaProperties()
{
MediaType = writers.MediaType
}
});
int count = 1;
foreach (var location in locations)
{
var fileName = locations.Count > 1 ? Path.ChangeExtension((Path.GetFileNameWithoutExtension(file.FileName) + count++), KnownFormats.JPG):
Path.ChangeExtension(file.FileName, KnownFormats.JPG);
using (var stream = location.Download())
{
convertedDcm.Add(new ConvertedFileInfo( )
{
Data = stream.ReadAllBytes(), FileName = fileName
});
}
location.Delete();
}
}
}
break;
default:
{
responseContent.Status = System.Net.HttpStatusCode.UnsupportedMediaType;
}
break;
}
responseContent.FileName = Path.ChangeExtension(convertedDcm.First().FileName, "zip");
responseContent.Content = new ByteArrayContent(ZippingService.CreateZipData(convertedDcm));
responseContent.Status = System.Net.HttpStatusCode.OK;
return(responseContent);
}
private HttpResponseMessage SearchForDicomEntity
(
IQidoRequestModel request,
fo.DicomDataset dicomSource,
DoQueryDelegate doQuery
)
{
if (null != request.Query)
{
var matchingParams = request.Query.MatchingElements;
var includeParams = request.Query.IncludeElements;
foreach (var returnParam in includeParams)
{
InsertDicomElement(dicomSource, returnParam, "");
}
foreach (var queryParam in matchingParams)
{
string paramValue = queryParam.Value;
InsertDicomElement(dicomSource, queryParam.Key, paramValue);
}
ICollection <fo.DicomDataset> results = doQuery(QueryService, dicomSource, request); //TODO: move configuration params into their own object
if (MultipartResponseHelper.IsMultiPartRequest(request))
{
if (MultipartResponseHelper.GetSubMediaType(request.AcceptHeader.FirstOrDefault( )) == MimeMediaTypes.xmlDicom)
{
HttpResponseMessage response;
MultipartContent multiContent;
response = new HttpResponseMessage( );
multiContent = new MultipartContent("related", MultipartResponseHelper.DicomDataBoundary);
response.Content = multiContent;
foreach (var result in results)
{
XmlDicomConverter converter = new XmlDicomConverter( );
MultipartResponseHelper.AddMultipartContent(multiContent,
new WadoResponse(new MemoryStream(Encoding.ASCII.GetBytes(converter.Convert(result))),
MimeMediaTypes.xmlDicom));
}
multiContent.Headers.ContentType.Parameters.Add(new System.Net.Http.Headers.NameValueHeaderValue("type",
"\"" + MimeMediaTypes.xmlDicom + "\""));
return(response);
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest));
}
}
else
{
StringBuilder jsonReturn = new StringBuilder("[");
JsonDicomConverter converter = new JsonDicomConverter( )
{
IncludeEmptyElements = true
};
foreach (var response in results)
{
jsonReturn.AppendLine(converter.Convert(response));
jsonReturn.Append(",");
}
if (results.Count > 0)
{
jsonReturn.Remove(jsonReturn.Length - 1, 1);
}
jsonReturn.Append("]");
return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = new StringContent(jsonReturn.ToString( ),
Encoding.UTF8,
MimeMediaTypes.Json)
});
}
}
return(null);
}
