//TODO: there is more into this now in part 18 2016 version, reference section 6.1.1.5 and 6.1.1.6
//exact method to tp determine "SelectedMediaType" is detailed in 6.1.1.7
protected virtual List <MediaTypeHeaderValue> GetRequestedMimeType(IWadoUriRequest request)
{
List <MediaTypeHeaderValue> acceptTypes = new List <MediaTypeHeaderValue>();
bool acceptAll = request.AcceptHeader.Contains(AllMimeType, new MediaTypeHeaderComparer( ));
if (!string.IsNullOrEmpty(request.ContentType))
{
string[] mimeTypes = request.ContentType.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string mime in mimeTypes)
{
MediaTypeWithQualityHeaderValue mediaType;
if (MediaTypeWithQualityHeaderValue.TryParse(mime, out mediaType))
{
if (acceptAll || request.AcceptHeader.Contains(mediaType, new MediaTypeHeaderComparer()))
{
acceptTypes.Add(mediaType);
}
}
else
{
//TODO: throw excpetion?
}
}
}
return(acceptTypes);
}
public virtual HttpResponseMessage GetInstance(IWadoUriRequest request)
{
//validation code should go in here
if (null == request || string.Compare(request.RequestType, "WADO", true) != 0)
{
throw new DCloudException("Request Type must be set to WADO");
}
List <MediaTypeHeaderValue> mediaTypeHeader = GetRequestedMimeType(request);
string currentTransfer = null;
foreach (MediaTypeHeaderValue mediaType in mediaTypeHeader)
{
IStorageLocation dcmLocation;
currentTransfer = GetRequestedMediaTransferSyntax(request, mediaType);
dcmLocation = GetLocation(request, currentTransfer, mediaType);
if (null != dcmLocation && dcmLocation.Exists( ))
{
StreamContent sc = new StreamContent(dcmLocation.GetReadStream( ));
sc.Headers.ContentType = new MediaTypeHeaderValue(mediaType.MediaType);
HttpResponseMessage msg = new HttpResponseMessage(HttpStatusCode.OK);
msg.Content = sc;
return(msg);
}
}
HttpResponseMessage responseMessage;
if (TryOnDemandTransform(request, mediaTypeHeader, out responseMessage))
{
return(responseMessage);
}
if (mediaTypeHeader.Where(n => n.MediaType == MimeMediaTypes.DICOM).FirstOrDefault( ) != null)
{
return(new HttpResponseMessage(HttpStatusCode.NotFound)
{
Content = new StringContent("Image not found")
});
}
else
{
//6.3.2 Body of Non-DICOM Media Type Response
//The HTTP behavior is that an error (406 - Not Acceptable) is returned if the required media type cannot be served.
return(new HttpResponseMessage(HttpStatusCode.NotAcceptable));
}
}
protected override WadoResponse DoProcess(IWadoUriRequest request, string mimeType)
{
fo.DicomFile df = fo.DicomFile.Open(Location.GetReadStream( ));//TODO: check how the toolkit loads the image in memory or not. we do not need to load it
WadoResponse response = new WadoResponse( );
//df.Load ( Location.GetReadStream ( ), null, DicomReadOptions.DoNotStorePixelDataInDataSet);
response.Content = GenerateStreamFromString(df.ToString( ));
response.MimeType = mimeType;
return(response);
}
protected override WadoResponse DoProcess(IWadoUriRequest request, string mimeType)
{
DicomFile df = new DicomFile( );
WadoResponse response = new WadoResponse( );
df.Load(Location.GetReadStream( ), null, DicomReadOptions.DoNotStorePixelDataInDataSet);
response.Content = GenerateStreamFromString(df.DataSet.Dump());
response.MimeType = mimeType;
return(response);
}
public HttpResponseMessage Get
(
[ModelBinder(typeof(UriRequestModelBinder))]
IWadoUriRequest request
)
{
if (null == request)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
return(ServiceHandler.GetInstance(request));
}
protected override WadoResponse DoProcess(IWadoUriRequest request, string mimeType)
{
var dcmLocation = MediaStorage.GetLocation(MediaFactory.Create(request, new DicomMediaProperties {
MediaType = MimeMediaTypes.DICOM,
TransferSyntax = (request.ImageRequestInfo != null) ? request.ImageRequestInfo.TransferSyntax : ""
}));
if (!dcmLocation.Exists( ))
{
throw new ApplicationException("Object Not Found - return proper wado error ");
}
//if (string.Compare(mimeType, MimeMediaTypes.DICOM, true) == 0)
{
return(new WadoResponse(Location.GetReadStream( ), mimeType));
}
}
public IWadoRsResponse Process(IWadoUriRequest request, string mimeType)
{
//base class that has the logic to get the DICOM file
Location = MediaStorage.GetLocation(new DicomMediaId(request, mimeType));
if (Location.Exists( ))
{
WadoResponse response = new WadoResponse(Location, mimeType);
return(response);
}
else
{
//TODO: in case mime not storedmethod to create on
return(DoProcess(request, mimeType));
}
}
public virtual IWadoRsResponse Process(IWadoUriRequest request, string mimeType)
{
Location = MediaStorage.GetLocation(MediaFactory.Create(request,
GetMediaProperties(request, mimeType,
GetTransferSyntax(request))));
if (Location != null && Location.Exists( ))
{
WadoResponse response = new WadoResponse(Location.GetReadStream( ), mimeType);
return(response);
}
else
{
//TODO: in case mime not storedmethod to create on
return(DoProcess(request, mimeType));
}
}
private static string GetRequestedMediaTransferSyntax(IWadoUriRequest request, MediaTypeHeaderValue mediaType)
{
string currentTransfer;
if (null != request.ImageRequestInfo && !string.IsNullOrWhiteSpace(request.ImageRequestInfo.TransferSyntax))
{
currentTransfer = request.ImageRequestInfo.TransferSyntax;
}
else
{
string transferString;
DefaultMediaTransferSyntax.Instance.TryGetValue(mediaType.MediaType, out transferString);
currentTransfer = !string.IsNullOrWhiteSpace(transferString) ? transferString : "";
}
return(currentTransfer);
}
public bool TryParse(HttpRequestMessage request, out IWadoUriRequest result)
{
WadoUriRequest wadoReq = new WadoUriRequest( );
wadoReq.AcceptHeader = request.Headers.Accept;
wadoReq.AcceptCharsetHeader = request.Headers.AcceptCharset;
var query = request.RequestUri.ParseQueryString( );
wadoReq.RequestType = query[WadoRequestKeys.RequestType];
wadoReq.StudyInstanceUID = query[WadoRequestKeys.StudyUID];
wadoReq.SeriesInstanceUID = query[WadoRequestKeys.SeriesUID];
wadoReq.SopInstanceUID = query[WadoRequestKeys.ObjectUID];
wadoReq.ContentType = query[WadoRequestKeys.ContentType];
wadoReq.Charset = query[WadoRequestKeys.Charset];
wadoReq.Anonymize = string.Compare(query[WadoRequestKeys.Anonymize], "yes", true) == 0;
wadoReq.ImageRequestInfo = new WadoUriImageRequestParams( );
wadoReq.ImageRequestInfo.BurnAnnotation = ParseAnnotation(query[WadoRequestKeys.Annotation]);
wadoReq.ImageRequestInfo.Rows = GetIntValue(query[WadoRequestKeys.Rows]);
wadoReq.ImageRequestInfo.Columns = GetIntValue(query[WadoRequestKeys.Columns]);
wadoReq.ImageRequestInfo.Region = query[WadoRequestKeys.Region];
wadoReq.ImageRequestInfo.WindowWidth = query[WadoRequestKeys.WindowWidth];
wadoReq.ImageRequestInfo.WindowCenter = query[WadoRequestKeys.WindowCenter];
wadoReq.Frame = wadoReq.ImageRequestInfo.FrameNumber = GetIntValue(query[WadoRequestKeys.FrameNumber]);
wadoReq.ImageRequestInfo.ImageQuality = GetIntValue(query[WadoRequestKeys.ImageQuality]);
wadoReq.ImageRequestInfo.PresentationUID = query[WadoRequestKeys.PresentationUID];
wadoReq.ImageRequestInfo.presentationSeriesUID = query[WadoRequestKeys.PresentationSeriesUID];
wadoReq.ImageRequestInfo.TransferSyntax = query[WadoRequestKeys.TransferSyntax];
result = wadoReq;
return(true);
}
protected virtual bool TryOnDemandTransform
(
IWadoUriRequest request,
List <MediaTypeHeaderValue> mediaTypeHeaderList,
out HttpResponseMessage responseMessage
)
{
string defaultDicomTransfer;
DefaultMediaTransferSyntax.Instance.TryGetValue(MimeMediaTypes.DICOM, out defaultDicomTransfer);
foreach (var mediaTypeHeader in mediaTypeHeaderList)
{
string transferSyntax;
transferSyntax = GetRequestedMediaTransferSyntax(request, mediaTypeHeader);
//should return only one for URI service
foreach (var result in RetrieveService.GetTransformedSopInstances(request, MimeMediaTypes.DICOM, defaultDicomTransfer, mediaTypeHeader.MediaType, transferSyntax))
{
StreamContent sc = new StreamContent(result.Location.GetReadStream( ));
sc.Headers.ContentType = new MediaTypeHeaderValue(mediaTypeHeader.MediaType);
responseMessage = new HttpResponseMessage(HttpStatusCode.OK);
responseMessage.Content = sc;
return(true);
}
}
responseMessage = null;
return(false);
}
public HttpResponseMessage GetInstance(IWadoUriRequest request)
{
//validation code should go in here
if (null == request || string.Compare(request.RequestType, "WADO", true) != 0)
{
throw new Exception("Request Type must be set to WADO");//TODO
}
List <MediaTypeHeaderValue> mimeType = GetRequestedMimeType(request);
foreach (MediaTypeHeaderValue mediaType in mimeType)
{
var dcmLocation = RetrieveService.RetrieveSopInstance(request, mediaType.MediaType);
if (null != dcmLocation && dcmLocation.Exists( ))
{
//TODO: use this for on the fly generation
//IWadoRsResponse response = imageHandler.Process ( request, mediaType.MediaType ) ;
StreamContent sc = new StreamContent(dcmLocation.GetReadStream( ));
sc.Headers.ContentType = new MediaTypeHeaderValue(mediaType.MediaType);
HttpResponseMessage msg = new HttpResponseMessage(HttpStatusCode.OK);
msg.Content = sc;
return(msg);
}
return(new HttpResponseMessage(HttpStatusCode.NotFound));
}
return(null);
}
protected abstract WadoResponse DoProcess(IWadoUriRequest request, string mimeType);
protected virtual DicomMediaProperties GetMediaProperties(IWadoUriRequest request, string mimeType, string transferSyntax)
{
return(new DicomMediaProperties {
MediaType = mimeType, TransferSyntax = transferSyntax
});
}
protected virtual string GetTransferSyntax(IWadoUriRequest request)
{
return((request.ImageRequestInfo != null) ? request.ImageRequestInfo.TransferSyntax : "");
}
//TODO: I should be able to replace this with the media readers now
protected override WadoResponse DoProcess(IWadoUriRequest request, string mimeType)
{
var dcmLocation = MediaStorage.GetLocation(new DicomMediaId(request, MimeMediaTypes.DICOM));
//var dcmLocation = RetrieveService.RetrieveSopInstances ( request, mimeType ).FirstOrDefault();
if (!dcmLocation.Exists( ))
{
throw new ApplicationException("Object Not Found - return proper wado error ");
}
//if (string.Compare(mimeType, MimeMediaTypes.DICOM, true) == 0)
{
return(new WadoResponse(Location, mimeType));
}
DicomFile file = new DicomFile( );
var frameIndex = request.ImageRequestInfo.FrameNumber - 1 ?? 0;
frameIndex = Math.Max(frameIndex, 0);
file.Load(dcmLocation.GetReadStream());
if (string.Compare(mimeType, MimeMediaTypes.Jpeg, true) == 0)
{
WadoResponse response = new WadoResponse();
if (file.TransferSyntax == TransferSyntax.JpegBaselineProcess1)
{
//ClearCanvas.Dicom.Codec.Jpeg.Jpeg8Codec codec = new ClearCanvas.Dicom.Codec.Jpeg.Jpeg8Codec (ClearCanvas.Dicom.Codec.Jpeg.JpegMode.Baseline, 0, 0 )
//codec.Encode ()
DicomCompressedPixelData pd = DicomPixelData.CreateFrom(file) as DicomCompressedPixelData;
byte[] buffer = pd.GetFrameFragmentData(frameIndex);
response.Content = new MemoryStream(buffer);
response.MimeType = mimeType;
return(response);
}
else
{
}
}
if (string.Compare(mimeType, MimeMediaTypes.UncompressedData) == 0)
{
WadoResponse response = null;
DicomPixelData pd = null;
byte[] buffer = null;
response = new WadoResponse( );
pd = DicomPixelData.CreateFrom(file);
buffer = pd.GetFrame(frameIndex);
//********* TEST CODE***************
//System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap (pd.ImageWidth, pd.ImageHeight, System.Drawing.Imaging.PixelFormat.Format8bppIndexed ) ;
//System.Drawing.Imaging.ColorPalette ncp = bitmap.Palette;
// for (int i = 0; i < 256; i++)
// ncp.Entries[i] = System.Drawing.Color.FromArgb(255, i, i, i);
// bitmap.Palette = ncp;
// System.Drawing.Imaging.BitmapData data = bitmap.LockBits (new System.Drawing.Rectangle ( 0,0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
//IntPtr ptr = data.Scan0 ;
//System.Runtime.InteropServices.Marshal.Copy (buffer, 0, ptr, buffer.Length ) ;
//string fileName = @"C:\Users\zalsafadi_p.SPX\Downloads\libwebp-master\Output\release-static\x86\bin\Samples\uncompressed.raw" ;
//bitmap.UnlockBits (data);
//bitmap.Save ( fileName);
//File.WriteAllBytes(fileName, buffer) ;
//********* TEST CODE***************
response.Content = new MemoryStream(buffer);
response.MimeType = mimeType;
return(response);
}
//if ( string.Compare(mimeType, MimeMediaTypes.WebP) == 0)
//{
// WadoResponse response = new WadoResponse ( ) ;
// byte[] buffer = File.ReadAllBytes(Location) ;
// response.Content = new MemoryStream(buffer);
// response.MimeType = mimeType ;
// return response ;
//}
return(null);
}
public IWadoRsResponse Process(IWadoUriRequest request, string mimeType)
{
throw new NotImplementedException();
}
protected virtual IStorageLocation GetLocation(IWadoUriRequest request, string currentTransfer, MediaTypeHeaderValue mediaType)
{
return(RetrieveService.RetrieveSopInstance(request,
new DicomMediaProperties(mediaType.MediaType, currentTransfer)));
}
