private IEnumerator <ITask> StreamImage(HttpListenerContext context, Bitmap bitmap)
{
HttpListenerResponse response = context.Response;
using (MemoryStream stream = new MemoryStream())
{
bitmap.Save(stream, ImageFormat.Png);
stream.Position = 0;
response.AddHeader("Cache-Control", "No-cache");
WriteResponseFromStream write = new WriteResponseFromStream(
context, stream, "image/png"
);
_utilitiesPort.Post(write);
yield return(Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
));
}
}
/// <summary>
/// Handlers http query request for raw binary format.
/// </summary>
/// <param name="query">The http query</param>
/// <param name="state">Depth camera state</param>
/// <param name="transform"> XSLT transform to be applied</param>
/// <param name="utilitiesPort">Utitilise port to post the response</param>
/// <returns>CCR Task Chunk</returns>
private static IEnumerator <ITask> HttpQueryHelperRawFormat(
HttpQuery query,
DepthCamSensorState state,
string transform,
DsspHttpUtilitiesPort utilitiesPort)
{
var type = query.Body.Query[QueryType];
byte[] imageByteArray = null;
switch (type.ToLowerInvariant())
{
case DepthPlusRgb:
imageByteArray =
ConvertVisibleAndDepthToByteArray(
state.VisibleImage,
state.DepthImage);
break;
case Rgb:
imageByteArray = state.VisibleImage;
break;
case Depth:
imageByteArray = new byte[state.DepthImage.Length * sizeof(short)];
Buffer.BlockCopy(state.DepthImage, 0, imageByteArray, 0, imageByteArray.Length);
break;
case Ir:
imageByteArray = state.VisibleImage;
break;
}
if (imageByteArray == null)
{
query.ResponsePort.Post(
new HttpResponseType(
HttpStatusCode.OK,
state,
transform));
}
else
{
using (var mem = new MemoryStream(imageByteArray))
{
var response = new WriteResponseFromStream(
query.Body.Context,
mem,
OctetStream);
utilitiesPort.Post(response);
yield return(response.ResultPort.Choice());
}
}
}
private PortSet <Stream, Exception> WriteImageToHttpResponse(HttpListenerContext context, string type, Stream stream)
{
var response = context.Response;
response.AddHeader("Cache-Control", "No-cache");
WriteResponseFromStream write = new WriteResponseFromStream(
context, stream, type
);
_utilitiesPort.Post(write);
return(write.ResultPort);
}
private void SendJpeg(HttpListenerContext context, Stream stream)
{
WriteResponseFromStream write = new WriteResponseFromStream(context, stream, MediaTypeNames.Image.Jpeg);
_httpUtilities.Post(write);
Activate(
Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
)
);
}
private void SendJpeg(HttpListenerContext context, Stream stream)
{
WriteResponseFromStream write = new WriteResponseFromStream(context, stream, MediaTypeNames.Image.Jpeg);
_httpUtilities.Post(write);
Activate(
Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
)
);
}
IEnumerator <ITask> HttpHandler(HttpListenerContext context, PortSet <HttpResponseType, Fault> responsePort)
{
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
bool alternate = false;
string path = request.Url.AbsolutePath.ToLowerInvariant();
if (path.StartsWith(_alternatePrefix))
{
alternate = true;
path = path.Substring(_alternatePrefix.Length);
}
else if (path.StartsWith(_prefix))
{
path = path.Substring(_prefix.Length);
}
string type;
ImageFormat format;
switch (path)
{
case "/jpeg":
case "/jpg":
type = MediaTypeNames.Image.Jpeg;
format = ImageFormat.Jpeg;
break;
case "/bmp":
type = "image/bmp";
format = ImageFormat.Bmp;
break;
case "/png":
type = "image/png";
format = ImageFormat.Png;
break;
case "/tif":
case "/tiff":
type = "image/tiff";
format = ImageFormat.Tiff;
break;
case "/gif":
type = MediaTypeNames.Image.Gif;
format = ImageFormat.Gif;
break;
default:
if (alternate)
{
responsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state.Clone(), _transform));
}
else
{
responsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state, _transform));
}
yield break;
}
if (_state.Frame == null)
{
if (alternate)
{
responsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state.Clone(), _transform));
}
else
{
responsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state, _transform));
}
yield break;
}
using (MemoryStream stream = new MemoryStream())
{
_state.Frame.Save(stream, format);
stream.Position = 0;
response.AddHeader("Cache-Control", "No-cache");
WriteResponseFromStream write = new WriteResponseFromStream(
context, stream, type
);
_utilitiesPort.Post(write);
yield return(Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
));
}
}
/// <summary>
/// Provides a standard implementation of HttpQuery
/// </summary>
/// <param name="query">The HttpQuery message to process</param>
/// <param name="state">The webcam state</param>
/// <param name="transform">The embedded resource to use as the XSLT transform</param>
/// <param name="utilitiesPort">The utilities port used to stream images</param>
/// <returns>Stanard CCR iterator</returns>
public IEnumerator <ITask> HttpQueryHelper(HttpQuery query, WebCamSensorState state, string transform, DsspHttpUtilitiesPort utilitiesPort)
{
var type = query.Body.Query[QueryType];
var mediaType = string.Empty;
var format = default(sdi.ImageFormat);
switch (type.ToLowerInvariant())
{
case Jpeg:
format = sdi.ImageFormat.Jpeg;
mediaType = MediaTypeNames.Image.Jpeg;
break;
case Gif:
format = sdi.ImageFormat.Gif;
mediaType = MediaTypeNames.Image.Gif;
break;
case Png:
format = sdi.ImageFormat.Png;
mediaType = MediaPng;
break;
case Bmp:
format = sdi.ImageFormat.Bmp;
mediaType = MediaBmp;
break;
default:
var copy = state.Clone() as WebCamSensorState;
copy.Data = null;
query.ResponsePort.Post(
new HttpResponseType(
HttpStatusCode.OK,
copy,
transform));
yield break;
}
if (state.Data == null || state.Data.Length == 0)
{
query.ResponsePort.Post(
new HttpResponseType(
HttpStatusCode.OK,
state,
transform));
yield break;
}
using (var image = state.Bitmap)
{
using (var mem = new MemoryStream())
{
image.Save(mem, format);
mem.Position = 0;
var response = new WriteResponseFromStream(
query.Body.Context,
mem,
mediaType);
utilitiesPort.Post(response);
yield return(response.ResultPort.Choice());
}
}
}
/// <summary>
/// Handlers http query request for bitmap source format.
/// </summary>
/// <param name="query">The http query</param>
/// <param name="state">Depth camera state</param>
/// <param name="transform"> XSLT transform to be applied</param>
/// <param name="utilitiesPort">Utitilise port to post the response</param>
/// <param name="visibleWidth">Width of a visible image - needed to blend depth and rgb pictures for a visual represenation</param>
/// <param name="visibleHeight">Height of a visible image - needed to blend depth and rgb pictures for a visual represenation</param>
/// <returns>CCR Task Chunk</returns>
private static IEnumerator <ITask> HttpQueryHelperBitmapSource(
HttpQuery query,
DepthCamSensorState state,
string transform,
DsspHttpUtilitiesPort utilitiesPort,
int visibleWidth,
int visibleHeight)
{
var type = query.Body.Query[QueryType];
BitmapSource bitmapSource = null;
try
{
switch (type.ToLowerInvariant())
{
case DepthPlusRgb:
// we must downscale visible image to match the resolution of depth image - in order to merge the
// two pictures. Its an expensive call - but we do it only here, where it was explicitly requested
byte[] resizedVisibleImage = ResizeVisibleImageToMatchDepthImageDimentions(
state.VisibleImage,
visibleWidth,
visibleHeight,
state.DepthImageSize.Width,
state.DepthImageSize.Height);
bitmapSource = CreateBitmapSourceFromByteArray(
ConvertVisibleAndDepthTo32bppByteArray(resizedVisibleImage, state.DepthImage),
state.DepthImageSize.Width,
state.DepthImageSize.Height,
swm.PixelFormats.Bgra32);
break;
case Rgb:
bitmapSource = CreateBitmapSourceFromByteArray(
state.VisibleImage,
visibleWidth,
visibleHeight,
swm.PixelFormats.Bgr24);
break;
case Depth:
bitmapSource = CreateBitmapSourceFromShortPixelArray(
state.DepthImage,
state.DepthImageSize.Width,
state.DepthImageSize.Height,
(int)(state.MaximumRange * 1000),
state.DepthImage.Clone() as short[]);
break;
case Ir:
bitmapSource = CreateBitmapSourceFromInfraredArray(
state.VisibleImage,
state.DepthImageSize.Width,
state.DepthImageSize.Height,
swm.PixelFormats.Gray16);
break;
}
}
catch
{
// We do not attempt to synchronize the HTTP view with
// state switching, so we might switch to RGB but still
// have data from IR mode
var width = state.DepthImageSize.Width;
var height = state.DepthImageSize.Height;
var zeroData = new byte[3 * width * height];
bitmapSource = BitmapSource.Create(
width,
height,
96,
96,
swm.PixelFormats.Bgr24,
null,
zeroData,
state.DepthImageSize.Width * 3);
}
if (bitmapSource == null)
{
query.ResponsePort.Post(
new HttpResponseType(
HttpStatusCode.OK,
state,
transform));
}
else
{
using (var mem = new MemoryStream())
{
BitmapEncoder encoder = null;
PngBitmapEncoder pngEncoder = new PngBitmapEncoder();
pngEncoder.Interlace = PngInterlaceOption.Off;
encoder = pngEncoder;
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
encoder.Save(mem);
mem.Position = 0;
var response = new WriteResponseFromStream(
query.Body.Context,
mem,
MediaPng);
utilitiesPort.Post(response);
yield return(response.ResultPort.Choice());
}
}
}
IEnumerator <ITask> HttpGetHandler(HttpGet get)
{
HttpListenerRequest request = get.Body.Context.Request;
HttpListenerResponse response = get.Body.Context.Response;
string path = request.Url.AbsolutePath;
string type;
ImageFormat format;
switch (path)
{
case "/camera/jpeg":
case "/camera/jpg":
type = MediaTypeNames.Image.Jpeg;
format = ImageFormat.Jpeg;
break;
case "/camera/bmp":
type = "image/bmp";
format = ImageFormat.Bmp;
break;
case "/camera/png":
type = "image/png";
format = ImageFormat.Png;
break;
case "/camera/tif":
case "/camera/tiff":
type = "image/tiff";
format = ImageFormat.Tiff;
break;
case "/camera/gif":
type = MediaTypeNames.Image.Gif;
format = ImageFormat.Gif;
break;
case "/camera/live":
get.ResponsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state, _transform));
yield break;
default:
get.ResponsePort.Post(new HttpResponseType(_state));
yield break;
}
if (_state.Image == null)
{
get.ResponsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state, _transform));
yield break;
}
using (MemoryStream stream = new MemoryStream())
{
_state.Image.Save(stream, format);
stream.Position = 0;
get.Body.Context.Response.AddHeader("Cache-Control", "No-cache");
WriteResponseFromStream write = new WriteResponseFromStream(
get.Body.Context, stream, type
);
_utilitiesPort.Post(write);
yield return(Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
));
}
}
private void SendHttp(HttpListenerContext context, Stream stream, string mediaType)
{
//lock (lockStatusGraphics)
{
WriteResponseFromStream write = new WriteResponseFromStream(context, stream, mediaType);
_httpUtilities.Post(write);
Activate(
Arbiter.Choice(
write.ResultPort,
delegate(Stream res)
{
stream.Close();
},
delegate(Exception e)
{
stream.Close();
LogError(e);
}
)
);
}
}
