void UpdatePixelsFromVolumeResampled(UniformImageVolumeDataContract ivdc,
Orientation orientation, int slice,
int windowCenter, int windowWidth,
ImageDataContract idc)
{
var inHandle = ivdc.PixelBuffer.GetHandle();
var outHandle = idc.PixelBuffer.GetHandle();
for (int nAtRow = 0; nAtRow < idc.Height; nAtRow++)
{
for (int nAtCol = 0; nAtCol < idc.Width; nAtCol++)
{
int srcOffset = 0;
switch (orientation)
{
case Orientation.Transverse:
srcOffset = slice;
srcOffset *= ivdc.Height;
srcOffset += nAtRow;
srcOffset *= ivdc.Width;
srcOffset += nAtCol;
break;
case Orientation.Coronal:
srcOffset = nAtRow;
srcOffset *= ivdc.Height;
srcOffset += slice;
srcOffset *= ivdc.Width;
srcOffset += nAtCol;
break;
case Orientation.Sagittal:
srcOffset = nAtRow;
srcOffset *= ivdc.Height;
srcOffset += nAtCol;
srcOffset *= ivdc.Width;
srcOffset += slice;
break;
}
ulong byteOffset = (ulong)srcOffset * sizeof(ushort);
if (byteOffset < inHandle.ByteLength)
{
int dstOffset = nAtRow;
dstOffset *= idc.Width;
dstOffset += nAtCol;
int val = inHandle.Read <ushort>(byteOffset);
val = (val - windowCenter) * (int)ushort.MaxValue / 2
/ windowWidth + (int)ushort.MaxValue / 4;
val *= 2;
val = Math.Max(0, val);
val = Math.Min(ushort.MaxValue, val);
outHandle.Write <ushort>((ulong)(dstOffset * sizeof(ushort)), (ushort)val);
}
}
}
idc.PixelBuffer.ReleaseHandle();
ivdc.PixelBuffer.ReleaseHandle();
}
public void GenerateMpr(MprGenerationRequestV1 request)
{
var responseContext =
OperationContext.Current.IncomingMessageHeaders.GetHeader <ResponseContext>(
"ResponseContext", "ServiceModelEx");
System.Diagnostics.Trace.Assert(responseContext.MethodId.CompareTo(Guid.Empty.ToString()) != 0);
LocalImageResourceManagerClient lirm =
new LocalImageResourceManagerClient();
lirm.Open();
UniformImageVolumeDataContract ivdc = null;
ivdc = lirm.GetImageVolume(request.ImageVolumeId);
int[] size = CalculateSize(ivdc, request.Orientation);
ImageDataContract idc = null;
_cacheResultImages.TryGetValue(responseContext.MethodId, out idc);
if (idc == null ||
idc.Width != size[0] ||
idc.Height != size[1])
{
idc = new ImageDataContract();
idc.Width = size[0];
idc.Height = size[1];
idc = lirm.AddImage(idc);
_cacheResultImages.TryAdd(responseContext.MethodId, idc);
}
lirm.Close();
UpdatePixelsFromVolumeResampled(ivdc,
request.Orientation, request.SlicePosition,
request.WindowCenter, request.WindowWidth,
idc);
MessageHeader <ResponseContext> responseHeader = new MessageHeader <ResponseContext>(responseContext);
NetMsmqBinding binding = new NetMsmqBinding("NoMsmqSecurity");
MprGenerationResponseProxy proxy = new MprGenerationResponseProxy(binding,
new EndpointAddress(responseContext.ResponseAddress));
using (OperationContextScope scope = new OperationContextScope(proxy.InnerChannel))
{
OperationContext.Current.OutgoingMessageHeaders.Add(
responseHeader.GetUntypedHeader("ResponseContext", "ServiceModelEx"));
proxy.OnMprDone(idc, request.RequestTime);
}
proxy.Close();
}
/// <summary>
/// create for the series for an image volume
/// </summary>
/// <param name="ivdc">the image volume data contract</param>
/// <returns>the new view model</returns>
public static ImageSeriesViewModel Create(UniformImageVolumeDataContract ivdc)
{
var isvm = new ImageSeriesViewModel()
{
SeriesInstanceUID = ivdc.Identity.SeriesInstanceUID,
FrameOfReferenceUID = ivdc.FrameOfReferenceUID,
SeriesLabel = ivdc.Identity.Label,
};
return(isvm);
}
/// <summary>
///
/// </summary>
/// <param name="ivdc"></param>
/// <returns></returns>
public UniformImageVolumeDataContract AddImageVolume(UniformImageVolumeDataContract ivdc)
{
// assert that GUID was not already assigned
System.Diagnostics.Trace.Assert(ivdc.Identity.Guid.CompareTo(Guid.Empty) == 0);
ivdc.Identity.Guid = Guid.NewGuid();
ivdc.PixelBuffer =
BufferRepository.CreateBuffer(ivdc.Identity.Guid, typeof(ushort),
ivdc.Width * ivdc.Height * ivdc.Depth);
try
{
_cacheImageVolumes.Add(ivdc.Identity.Guid, ivdc);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(ivdc);
}
int[] CalculateSize(UniformImageVolumeDataContract ivdc, Orientation orientation)
{
int[] size = new int[2];
switch (orientation)
{
case Orientation.Transverse:
size[0] = ivdc.Width;
size[1] = ivdc.Height;
break;
case Orientation.Coronal:
size[0] = ivdc.Width;
size[1] = ivdc.Depth;
break;
case Orientation.Sagittal:
size[0] = ivdc.Height;
size[1] = ivdc.Depth;
break;
}
return(size);
}
byte[] CreateStreamFromVolumeResampled(UniformImageVolumeDataContract ivdc,
Orientation orientation, int slice,
int windowCenter, int windowWidth, int[] size)
{
var inHandle = ivdc.PixelBuffer.GetHandle();
ushort[] outPixels = new ushort[size[0] * size[1]];
for (int nAtRow = 0; nAtRow < size[1]; nAtRow++)
{
for (int nAtCol = 0; nAtCol < size[0]; nAtCol++)
{
int srcOffset = 0;
switch (orientation)
{
case Orientation.Transverse:
srcOffset = slice;
srcOffset *= ivdc.Height;
srcOffset += nAtRow;
srcOffset *= ivdc.Width;
srcOffset += nAtCol;
break;
case Orientation.Coronal:
srcOffset = nAtRow;
srcOffset *= ivdc.Height;
srcOffset += slice;
srcOffset *= ivdc.Width;
srcOffset += nAtCol;
break;
case Orientation.Sagittal:
srcOffset = nAtRow;
srcOffset *= ivdc.Height;
srcOffset += nAtCol;
srcOffset *= ivdc.Width;
srcOffset += slice;
break;
}
ulong byteOffset = (ulong)srcOffset * sizeof(ushort);
if (byteOffset < inHandle.ByteLength)
{
int dstOffset = nAtRow;
dstOffset *= size[0];
dstOffset += nAtCol;
int val = inHandle.Read <ushort>(byteOffset);
val = (val - windowCenter) * (int)ushort.MaxValue / 2
/ windowWidth + (int)ushort.MaxValue / 4;
val *= 2;
val = Math.Max(0, val);
val = Math.Min(ushort.MaxValue, val);
outPixels[dstOffset] = (ushort)val;
}
}
}
ivdc.PixelBuffer.ReleaseHandle();
BitmapSource outBitmap = BitmapSource.Create(size[0], size[1], 96.0, 96.0,
PixelFormats.Gray16, null, outPixels, size[0] * sizeof(ushort));
var encoder = new BmpBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(outBitmap));
var stream = new MemoryStream();
encoder.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
return(stream.GetBuffer());
}
/// <summary>
/// TODO: return response, not contract
/// </summary>
/// <param name="seriesInstanceUID"></param>
/// <returns></returns>
public ImageVolumeResampleResponse ResampleImageVolume(ImageVolumeResampleRequest request)
{
LocalImageResourceManagerClient cmsc1 =
new LocalImageResourceManagerClient();
var imageIds = cmsc1.GetImageIdsBySeries(request.SeriesInstanceUID);
if (imageIds.Count() == 0)
{
return(null);
}
var imagesInSeries = (from guid in imageIds
select cmsc1.GetImage(guid)
).OrderBy(idc => - idc.ImagePosition.Z);
var ivdc = new UniformImageVolumeDataContract();
ivdc.Identity.SeriesInstanceUID = request.SeriesInstanceUID;
ivdc.Identity.Label = imagesInSeries.First().Label;
ivdc.Identity.PatientId = imagesInSeries.First().PatientId;
ivdc.FrameOfReferenceUID = imagesInSeries.First().FrameOfReferenceUID;
ivdc.Width = imagesInSeries.First().Width;
ivdc.Height = imagesInSeries.First().Height;
ivdc.Depth = imagesInSeries.Count();
var imageOrientation = imagesInSeries.First().ImageOrientation;
ivdc.VolumeOrientation = new VolumeOrientation()
{
Row = imageOrientation.Row,
Column = imageOrientation.Column,
};
var voxelSpacing = new VoxelSize()
{
X = imagesInSeries.First().PixelSpacing.X,
Y = imagesInSeries.First().PixelSpacing.Y,
Z = Math.Abs(imagesInSeries.First().ImagePosition.Z
- imagesInSeries.Last().ImagePosition.Z) / imagesInSeries.Count()
};
ivdc.VoxelSpacing = voxelSpacing;
// take cross product
// ivdc.DirectionZ =
ivdc = cmsc1.AddImageVolume(ivdc);
var outVoxelHandle = ivdc.PixelBuffer.GetHandle();
ushort[] frame = new ushort[imagesInSeries.First().PixelBuffer.ElementCount];
ulong currentVoxelOffset = 0;
foreach (var idc in imagesInSeries)
{
// get access to the buffer
var inPixelHandle = idc.PixelBuffer.GetHandle();
inPixelHandle.ReadArray <ushort>(0, frame, 0, frame.Length);
outVoxelHandle.WriteArray <ushort>(currentVoxelOffset,
frame, 0, frame.Length);
idc.PixelBuffer.ReleaseHandle();
idc.PixelBuffer.CloseMapping();
currentVoxelOffset += (ulong)(idc.PixelBuffer.ElementCount * sizeof(ushort));
}
ivdc.PixelBuffer.ReleaseHandle();
ivdc.PixelBuffer.CloseMapping();
cmsc1.Close();
System.Diagnostics.Trace.Assert(ivdc != null);
System.Diagnostics.Trace.Assert(ivdc.Identity != null);
System.Diagnostics.Trace.Assert(ivdc.Identity.Guid.CompareTo(Guid.Empty) != 0);
return(new ImageVolumeResampleResponse()
{
SeriesInstanceUID = request.SeriesInstanceUID,
ResampledImageVolumeGuid = ivdc.Identity.Guid
});
}
