public void Delete(ImageRequest request)
{
var image = this.session.Query<Image>().FirstOrDefault(i => i.ImageId == request.Image.ImageId);
this.session.Delete(image);
this.session.SaveChanges();
}
public List<Image> Post(ImageRequest request)
{
Console.WriteLine("Saving image");
this.session.Store(request.Image);
this.session.SaveChanges();
var user = (User)Request.Items[RequestItem.User];
return this.session.Query<Image>().Where(u => u.UserId == user.UserId).ToList();
}
public async Task<CreateResponse> CreateAsync(string path)
{
var request = new ImageRequest
{
Content = File.ReadAllBytes(path),
ContentType = "image/jpg",
FileName = Path.GetFileName(path),
ThumbnailOption = new ThumbnailOption
{
Width = 300
}
};
var client = new ImageServiceClient();
var response = await client.CreateAsync(new CreateRequest(request));
return response;
}
public void CreateImageByFileAsBytes_Succeeds()
{
var imageFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "AdminAPI", "sample_image.jpeg");
var randomImageName = Guid.NewGuid().ToString();
var expectedPost = new ImageRequest(File.ReadAllBytes(imageFilePath), $"{randomImageName}.jpeg", ImageType.JPEG)
{
Purpose = ImagePurpose.Image,
Reference = "sample"
};
var actualImage = auth.UploadImage(expectedPost);
Assert.AreEqual($"{Host}content/images/{DateTime.Now.ToString("yyyy/MM")}/{randomImageName}.jpeg", actualImage.Url);
Assert.IsNull(actualImage.Reference); // why isn't this working?
}
public async Task JPEGImageSizeAsync()
{
var imageRequest = new ImageRequest(apiKey, signingKey, new Size(640, 640))
{
Place = "Alexandria, VA"
};
var image = await cache
.LoadAsync(jpegDecoder, imageRequest)
.ConfigureAwait(false);
var info = image.Info;
Assert.AreEqual(640, info.Dimensions.Width);
Assert.AreEqual(640, info.Dimensions.Height);
}
private async void FetchDecodedImage()
{
try
{
Uri uri = MainPage.GenerateImageUri();
WriteableBitmap bitmap = await _imagePipeline.FetchDecodedBitmapImageAsync(
ImageRequest.FromUri(uri));
UpdateImageGrid(bitmap);
}
catch (Exception)
{
// Invalid uri, try again
FetchDecodedImage();
}
}
public async Task RegisterFaceAsync(string faceId, ImageRequest request)
{
var client = new FaceServiceClient(subscriptionKey: Secrets.CongnitiveServiceFaceApiKey, apiRoot: Consts.CognitiveServiceFaceApiEndPoint);
try
{
await client.GetFaceListAsync(faceId);
}
catch (FaceAPIException)
{
// not found
await client.CreateFaceListAsync(faceListId : faceId, name : faceId);
}
await client.AddFaceToFaceListAsync(faceListId : faceId, imageStream : new MemoryStream(request.Image));
}
public async Task <Guid> CreateFaceAsync(ImageRequest request)
{
var personListId = await this.PersonListIdRepository.GetIdAsync();
var client = new FaceServiceClient(subscriptionKey: Secrets.CongnitiveServiceFaceApiKey, apiRoot: Consts.CognitiveServiceFaceApiEndPoint);
await this.CreatePersonGroupIsNotExist(client, personListId);
var r = await client.CreatePersonAsync(personGroupId : personListId, name : "noname");
await client.AddPersonFaceAsync(personGroupId : personListId, personId : r.PersonId, imageStream : new MemoryStream(request.Image));
await this.TrainPersonGroupAsync(client, personListId);
return(r.PersonId);
}
public void ChangeImage(byte[] pixeldata, byte[] bmiInfoHeader)
{
if (!IsConnected() && !_priorityClearing)
{
return;
}
if (!_isSending)
{
_isSending = true;
// Hyperion expects the bytestring to be the size of 3*width*height.
// So 3 bytes per pixel, as in RGB.
// Given pixeldata however is 4 bytes per pixel, as in RGBA.
// So we need to remove the last byte per pixel.
byte[] newpixeldata = new byte[coreObject.GetCaptureHeight() * coreObject.GetCaptureWidth() * 3];
int x = 0;
int i = 0;
while (i <= (newpixeldata.GetLength(0) - 2))
{
newpixeldata[i] = pixeldata[i + x + 2];
newpixeldata[i + 1] = pixeldata[i + x + 1];
newpixeldata[i + 2] = pixeldata[i + x];
i += 3;
x++;
}
ImageRequest imageRequest = ImageRequest.CreateBuilder()
.SetImagedata(Google.ProtocolBuffers.ByteString.CopyFrom(newpixeldata))
.SetImageheight(coreObject.GetCaptureHeight())
.SetImagewidth(coreObject.GetCaptureWidth())
.SetPriority(coreObject.hyperionPriority)
.SetDuration(-1)
.Build();
HyperionRequest request = HyperionRequest.CreateBuilder()
.SetCommand(HyperionRequest.Types.Command.IMAGE)
.SetExtension(ImageRequest.ImageRequest_, imageRequest)
.Build();
Thread t = new Thread(() => SendRequest(request))
{
IsBackground = true
};
t.Start();
}
}
/// <summary>
/// Request an image from the camera server
/// </summary>
/// <param name="body"></param>
/// <returns>True for success</returns>
private ImageReply RequestImage(ImageRequest body)
{
bool succeeded = false;
try
{
EnsureConnection();
ImageReply result = grpcClient.RequestImage(body);
if (result.Error != string.Empty)
{
Console.WriteLine($"Error returned from CameraServer: {result.Error}");
return(null);
}
else
{
succeeded = true;
return(result);
}
}
catch (Grpc.Core.RpcException ex)
{
if (ex.StatusCode == StatusCode.Unavailable)
{
Console.WriteLine($"Error sending grpc message: CameraServer gRPC is unavailable");
return(null);
}
else
{
Console.WriteLine($"Error sending CameraServer gRPC message");
Console.WriteLine(ex);
return(null);
}
}
catch (Exception ex)
{
Console.WriteLine($"Error sending CameraServer gRPC message");
Console.WriteLine(ex);
return(null);
}
finally
{
if (!succeeded)
{
((IImageSource)this).Disconnect();
}
}
}
public async Task <IEnumerable <ImageDetectionResponse> > GetDetection(ImageRequest request, SystemSession session)
{
var serviceRequest = new Elif {
FileId = request.FileId, Username = request.UserName
};
var response = await Task.Factory.StartNew(() => Client.ElifService.getDetection(serviceRequest, session.GetSession())).ConfigureAwait(false);
var result = response.Select(x => new ImageDetectionResponse
{
X = x.X,
Y = x.Y,
Height = x.Height,
Width = x.Width
});
return(result);
}
/// <summary>
/// Returns whether the image is stored in the disk cache.
/// Performs disk cache check synchronously. It is not
/// recommended to use this unless you know what exactly
/// you are doing. Disk cache check is a costly operation,
/// the call will block the caller thread until the cache
/// check is completed.
/// </summary>
/// <param name="imageRequest">
/// The image request to be looked up.
/// </param>
/// <returns>
/// true if the image was found in the disk cache,
/// false otherwise.
/// </returns>
public bool IsInDiskCacheSync(ImageRequest imageRequest)
{
ICacheKey cacheKey = _cacheKeyFactory.GetEncodedCacheKey(imageRequest, null);
CacheChoice cacheChoice = imageRequest.CacheChoice;
switch (cacheChoice)
{
case CacheChoice.DEFAULT:
return(_mainBufferedDiskCache.DiskCheckSync(cacheKey));
case CacheChoice.SMALL:
return(_smallImageBufferedDiskCache.DiskCheckSync(cacheKey));
default:
return(false);
}
}
/// <summary>
/// Fetches the decoded WriteableBitmap.
/// </summary>
/// <param name="imageRequest">The image request.</param>
/// <param name="token">The cancellation token.</param>
/// <param name="dispatcher">
/// The current view's dispatcher, used to create WriteableBitmap.
/// </param>
/// <returns>The decoded WriteableBitmap.</returns>
/// <exception cref="IOException">
/// If the image request isn't valid.
/// </exception>
public Task <WriteableBitmap> FetchDecodedBitmapImageAsync(
ImageRequest imageRequest,
CancellationToken token = default(CancellationToken),
CoreDispatcher dispatcher = null)
{
var taskCompletionSource = new TaskCompletionSource <WriteableBitmap>();
var dataSource = FetchDecodedImage(imageRequest, null);
var dataSubscriber = new BaseBitmapDataSubscriberImpl(
async bitmap =>
{
if (bitmap != null)
{
await DispatcherHelpers.RunOnDispatcherAsync(() =>
{
try
{
var writeableBitmap = new WriteableBitmap(bitmap.PixelWidth, bitmap.PixelHeight);
bitmap.CopyToBuffer(writeableBitmap.PixelBuffer);
taskCompletionSource.SetResult(writeableBitmap);
}
catch (Exception e)
{
taskCompletionSource.SetException(e);
}
},
dispatcher).ConfigureAwait(false);
}
else
{
taskCompletionSource.SetResult(null);
}
},
response =>
{
taskCompletionSource.SetException(response.GetFailureCause());
});
dataSource.Subscribe(dataSubscriber, _handleResultExecutor);
token.Register(() =>
{
dataSource.Close();
taskCompletionSource.TrySetCanceled();
});
return(taskCompletionSource.Task);
}
public async Task PNGImageSizeAsync()
{
var imageRequest = new ImageRequest(apiKey, signingKey, new Size(640, 640))
{
Place = "Alexandria, VA"
};
var rawImg = await cache
.LoadAsync(jpegDecoder, imageRequest)
.ConfigureAwait(false);
var data = pngDecoder.Serialize(rawImg);
var info = ImageInfo.ReadPNG(data);
Assert.AreEqual(640, info.Dimensions.Width);
Assert.AreEqual(640, info.Dimensions.Height);
}
public void SendImageToServer(byte[] pixeldata, int width, int height)
{
var imageRequest = ImageRequest.CreateBuilder()
.SetImagedata(ByteString.CopyFrom(pixeldata))
.SetImageheight(height)
.SetImagewidth(width)
.SetPriority(_priority)
.SetDuration(_messageDuration)
.Build();
var request = HyperionRequest.CreateBuilder()
.SetCommand(HyperionRequest.Types.Command.IMAGE)
.SetExtension(ImageRequest.ImageRequest_, imageRequest)
.Build();
SendRequest(request);
}
public async Task <IActionResult> RemoveImage(string id)
{
try
{
var iReq = new ImageRequest(id);
var iResp = await Mediator.Send(iReq);
var req = new ImageDeletionRequest(iResp);
await Mediator.Send(req);
return(NoContent());
}
catch (Diagnostics.ImageNotFoundException ex)
{
return(StatusCode(410, ex.Message));
}
}
public void SendPicture(byte[] data)
{
if (!tcpClient.Connected)
{
tcpClient.Connect("localhost", 52200);
}
var stream = tcpClient.GetStream();
Request request = new EmptyRequest();
switch (response.Type)
{
case Response.MessageType.Start:
request = new ImageRequest(data);
break;
case Response.MessageType.Control:
request = new ImageRequest(data);
break;
case Response.MessageType.Result:
request = new ScoreRequest(score);
break;
case Response.MessageType.Finish:
SceneManager.LoadScene(0);
SeriesNumber++;
break;
case Response.MessageType.End:
Application.Quit();
break;
default:
break;
}
var reqBytes = reqSerializer.Serialize(request);
stream.Write(reqBytes, 0, reqBytes.Length);
var receiveBytes = new byte[9];
stream.Read(receiveBytes, 0, receiveBytes.Length);
response = respSerializer.Deserialize(receiveBytes);
Debug.Log(string.Format("{0:0.000} {1:0.000}", response.DeltaAngle, response.DeltaVelocity));
}
private IProducer <CloseableReference <CloseableImage> > GetBasicDecodedImageSequence(
ImageRequest imageRequest)
{
Preconditions.CheckNotNull(imageRequest);
Uri uri = imageRequest.SourceUri;
Preconditions.CheckNotNull(uri, "Uri is null.");
if (UriUtil.IsNetworkUri(uri))
{
return(GetNetworkFetchSequence());
}
else if (UriUtil.IsAppDataUri(uri))
{
if (MediaUtils.IsVideo(MediaUtils.ExtractMime(uri.ToString())))
{
return(GetLocalVideoFileFetchSequence());
}
else
{
return(GetLocalImageFileFetchSequence());
}
}
else if (UriUtil.IsAppPackageUri(uri))
{
return(GetLocalAssetFetchSequence());
}
else if (UriUtil.IsAppResourceUri(uri))
{
return(GetLocalResourceFetchSequence());
}
else if (UriUtil.IsDataUri(uri))
{
return(GetDataFetchSequence());
}
else
{
string uriString = uri.ToString();
if (uriString.Length > 30)
{
uriString = uriString.Substring(0, 30) + "...";
}
throw new Exception("Unsupported uri scheme! Uri is: " + uriString);
}
}
public void CreateImageByFileName_Succeeds()
{
var imageFilePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "AdminAPI", "sample_image.jpeg");
var expectedPost = new ImageRequest(imageFilePath)
{
Purpose = ImagePurpose.Image,
Reference = "sample"
};
var actualImage = auth.UploadImage(expectedPost);
var imageFilePattern = Regex.Escape($"{Host}content/images/{DateTime.Now:yyyy/MM}/{Path.GetFileNameWithoutExtension(imageFilePath)}") + @"-?\d*" + Regex.Escape(".jpeg");
Assert.IsTrue(Regex.IsMatch(actualImage.Url, imageFilePattern));
Assert.IsNull(actualImage.Reference); // Why isn't this working? https://ghost.org/docs/api/v3/admin/#the-image-object
}
ImageRequest GetRequestInfo()
{
// Get the Json from the POST.
string strJson = String.Empty;
HttpContext context = HttpContext.Current;
context.Request.InputStream.Position = 0;
using (StreamReader inputStream = new StreamReader(context.Request.InputStream))
{
strJson = inputStream.ReadToEnd();
}
// Deserialize the Json.
ImageRequest request = JsonConvert.DeserializeObject <ImageRequest>(strJson);
return(request);
}
private static int GetRotationAngle(ImageRequest imageRequest, EncodedImage encodedImage)
{
if (!imageRequest.IsAutoRotateEnabled)
{
return(0);
}
int rotationAngle = encodedImage.RotationAngle;
Preconditions.CheckArgument(
rotationAngle == 0 ||
rotationAngle == 90 ||
rotationAngle == 180 ||
rotationAngle == 270);
return(rotationAngle);
}
public async Task <IEnumerable <FaceDetectionResult> > DetectFacesAsync(ImageRequest request)
{
try
{
// .NET の FaceAPI を呼ぶためのクラスを生成
var client = new FaceServiceClient(subscriptionKey: Secrets.CongnitiveServiceFaceApiKey, apiRoot: Consts.CognitiveServiceFaceApiEndPoint);
// DetectAsync で、画像のどこに顔があって、その顔は何歳か、という情報を取得している
var results = await client.DetectAsync(imageStream : new MemoryStream(request.Image), returnFaceAttributes : new[]
{
FaceAttributeType.Age,
});
var personListId = await this.PersonListIdRepository.GetIdAsync();
// 取得した顔が誰の顔かを認識している
var identifyResults = (await client.IdentifyAsync(personListId, results.Select(x => x.FaceId).ToArray()))
.ToDictionary(x => x.FaceId);
var l = new List <FaceDetectionResult>();
foreach (var r in results)
{
IdentifyResult identifyResult = null;
identifyResults.TryGetValue(r.FaceId, out identifyResult);
var faceDetectionResult = new FaceDetectionResult
{
FaceId = identifyResult?.Candidates.FirstOrDefault()?.PersonId.ToString() ?? new Guid().ToString(),
Age = (int)r.FaceAttributes.Age,
Rectangle = new BusinessObjects.FaceRectangle
{
Top = r.FaceRectangle.Top,
Left = r.FaceRectangle.Left,
Width = r.FaceRectangle.Width,
Height = r.FaceRectangle.Height,
}
};
l.Add(faceDetectionResult);
}
return(l);
}
catch (FaceAPIException)
{
return(Enumerable.Empty <FaceDetectionResult>());
}
}
private void ProcessRequests()
{
while (true)
{
iEvent.WaitOne();
Monitor.Enter(iLockObject);
if (iPendingRequests.Count > 0 && IsRunning)
{
ImageRequest request = iPendingRequests[0];
IImageLoader <ImageType> loader = iImageLoader;
iPendingRequests.Remove(request);
iExecutingRequests.Add(request);
Monitor.Exit(iLockObject);
try
{
IImage <ImageType> img = loader.LoadImage(new Uri(request.Uri), iDownscaleImageSize);
img.IncrementReferenceCount();
lock (iLockObject)
{
Add(request.Uri, img);
iExecutingRequests.Remove(request);
}
OnEventImageAdded(request, img);
img.DecrementReferenceCount();
}
catch (Exception ex)
{
UserLog.WriteLine("Error downloading image: " + request.Uri + ", " + ex.ToString());
lock (iLockObject)
{
iImageCacheFailures.Add(request.Uri);
iExecutingRequests.Remove(request);
}
OnEventRequestFailed(request.Uri);
}
}
else
{
iEvent.Reset();
Monitor.Exit(iLockObject);
}
}
}
/// <summary>
/// It Add Or Update the Image of the Notes
/// </summary>
/// <param name="NoteId">Note Id</param>
/// <param name="imageRequest">Image Path Data</param>
/// <param name="userId">User Id</param>
/// <returns>Note Response Model</returns>
public async Task <NoteResponseModel> AddUpdateImage(int NoteId, ImageRequest imageRequest, int userId)
{
try
{
if (imageRequest == null || NoteId <= 0 || userId <= 0)
{
return(null);
}
else
{
return(await _notesRepository.AddUpdateImage(NoteId, imageRequest, userId));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// Called after successful completion of the request
/// (all producers completed successfully).
/// </summary>
/// <param name="request">Which triggered the event.</param>
/// <param name="requestId">
/// Unique id generated automatically for each request submission.
/// </param>
/// <param name="isPrefetch">
/// Whether the request is a prefetch or not.
/// </param>
public void OnRequestSuccess(
ImageRequest request,
string requestId,
bool isPrefetch)
{
lock (_gate)
{
long?startTime = default(long?);
if (_requestStartTimeMap.TryGetValue(requestId, out startTime))
{
_requestStartTimeMap.Remove(requestId);
}
long currentTime = GetTime();
Debug.WriteLine(
$"time { currentTime }: OnRequestSuccess: {{requestId: { requestId }, elapsedTime: { GetElapsedTime(startTime, currentTime) } ms}}");
}
}
/// <summary>
/// Upload an image to the site
/// </summary>
/// <returns>Returns location from which the image can be fetched, and reference string if any.</returns>
public Image UploadImage(ImageRequest image)
{
var request = new RestRequest("images/upload/", Method.POST);
if (image.FilePath != null)
{
request.AddFile("file", image.FilePath, GetMimeType(image.ImageType));
}
else
{
request.AddFile("file", image.File, image.FileName, GetMimeType(image.ImageType));
}
request.AddParameter("purpose", image.Purpose.ToString().ToLower());
request.AddParameter("ref", image.Reference);
return(Execute <ImageResponse>(request).Images[0]);
}
public IActionResult UpdateImageProduct(ImageRequest imageRequest)
{
try
{
if (_logic.UpdateImageProduct(imageRequest.id, imageRequest.url))
{
return(Ok("Insert Success"));
}
else
{
return(NotFound("There are no Products"));
}
}
catch (Exception)
{
return(BadRequest("System Error:\n "));
}
}
protected override void OnNewResultImpl(EncodedImage newResult, bool isLast)
{
ImageRequest request = _producerContext.ImageRequest;
bool isGoodEnough =
ThumbnailSizeChecker.IsImageBigEnough(newResult, request.ResizeOptions);
if (newResult != null && (isGoodEnough || request.IsLocalThumbnailPreviewsEnabled))
{
Consumer.OnNewResult(newResult, isLast && isGoodEnough);
}
if (isLast && !isGoodEnough)
{
EncodedImage.CloseSafely(newResult);
_inputProducer2.ProduceResults(Consumer, _producerContext);
}
}
private static TriState ShouldTransform(
ImageRequest request,
EncodedImage encodedImage)
{
if (encodedImage == null || encodedImage.Format == ImageFormat.UNKNOWN)
{
return(TriState.UNSET);
}
if (encodedImage.Format != ImageFormat.JPEG)
{
return(TriState.NO);
}
return(TriStateHelper.ValueOf(
GetRotationAngle(request, encodedImage) != 0 ||
ShouldResize(GetScaleNumerator(request, encodedImage))));
}
public ActionResult <ImageModel> Insert(ImageRequest request)
{
if (string.IsNullOrEmpty(request.ContentBase64))
{
throw new ArgumentNullException("No content of the image was provided");
}
var id = _dbImageRepository.Insert(request.Model, request.ContentBase64);
if (id != default)
{
return(CreatedAtAction("GetOne", _dbImageRepository.FindOne(id)));
}
else
{
return(BadRequest());
}
}
public void TestFetchDecodedImageSuccess()
{
var completion = new ManualResetEvent(false);
var dataSource = _imagePipeline.FetchDecodedImage(ImageRequest.FromUri(IMAGE_URL), null);
var dataSubscriber = new BaseDataSubscriberImpl <CloseableReference <CloseableImage> >(
async response =>
{
CloseableReference <CloseableImage> reference = response.GetResult();
if (reference != null)
{
SoftwareBitmap bitmap = ((CloseableBitmap)reference.Get()).UnderlyingBitmap;
try
{
Assert.IsTrue(bitmap.PixelWidth != 0);
Assert.IsTrue(bitmap.PixelHeight != 0);
Assert.IsTrue(_imagePipeline.IsInBitmapMemoryCache(ImageRequest.FromUri(IMAGE_URL)));
Assert.IsTrue(await _imagePipeline.IsInDiskCacheAsync(IMAGE_URL).ConfigureAwait(false));
}
catch (Exception)
{
Assert.Fail();
}
finally
{
CloseableReference <CloseableImage> .CloseSafely(reference);
completion.Set();
}
}
else
{
Assert.Fail();
completion.Set();
}
},
response =>
{
Assert.Fail();
completion.Set();
});
dataSource.Subscribe(dataSubscriber, CallerThreadExecutor.Instance);
completion.WaitOne();
}
/// <summary>
/// Returns whether the image is stored in the bitmap memory cache.
/// </summary>
/// <param name="imageRequest">
/// The imageRequest for the image to be looked up.
/// </param>
/// <returns>
/// true if the image was found in the bitmap memory cache,
/// false otherwise.
/// </returns>
public bool IsInBitmapMemoryCache(ImageRequest imageRequest)
{
if (imageRequest == null)
{
return(false);
}
ICacheKey cacheKey = _cacheKeyFactory.GetBitmapCacheKey(imageRequest, null);
CloseableReference <CloseableImage> reference = _bitmapMemoryCache.Get(cacheKey);
try
{
return(CloseableReference <CloseableImage> .IsValid(reference));
}
finally
{
CloseableReference <CloseableImage> .CloseSafely(reference);
}
}
public async Task <IActionResult> DeleteImageToProperty([FromBody] ImageRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var propertyImage = await _dataContext.PropertyImages.FindAsync(request.Id);
if (propertyImage == null)
{
return(BadRequest("Property image doesn't exist."));
}
_dataContext.PropertyImages.Remove(propertyImage);
await _dataContext.SaveChangesAsync();
return(Ok(propertyImage));
}
/// <summary>
/// Fills either of the stock image or temporary image parameters with the initial image to use (before any alterations are made).
/// </summary>
/// <param name="imageRequest"></param>
/// <param name="args"></param>
/// <param name="stockImage"></param>
/// <param name="tempImage"></param>
/// <returns></returns>
private bool BuildInitialImage(ImageRequest imageRequest, RequestReceivedEventArgs args, ref Image stockImage, ref Image tempImage)
{
bool result = true;
switch(imageRequest.ImageName) {
case "AIRPLANE": stockImage = Images.Marker_Airplane; break;
case "AIRPLANESELECTED": stockImage = Images.Marker_AirplaneSelected; break;
case "BLANK": tempImage = CreateBlankImage(imageRequest.Width.GetValueOrDefault(), imageRequest.Height.GetValueOrDefault()); break;
case "CHEVRONBLUECIRCLE": stockImage = Images.ChevronBlueCircle; break;
case "CHEVRONGREENCIRCLE": stockImage = Images.ChevronGreenCircle; break;
case "CHEVRONREDCIRCLE": stockImage = Images.ChevronRedCircle; break;
case "CLOSESLIDER": stockImage = Images.CloseSlider; break;
case "COMPASS": stockImage = Images.Compass; break;
case "CORNER-TL": stockImage = Images.Corner_TopLeft; break;
case "CORNER-TR": stockImage = Images.Corner_TopRight; break;
case "CORNER-BL": stockImage = Images.Corner_BottomLeft; break;
case "CORNER-BR": stockImage = Images.Corner_BottomRight; break;
case "CROSSHAIR": stockImage = Images.Crosshair; break;
case "GOTOCURRENTLOCATION": stockImage = Images.GotoCurrentLocation; break;
case "HEADING": stockImage = Images.SmallPlaneNorth; break;
case "HIDELIST": stockImage = Images.HideList; break;
case "IPHONEBACKBUTTON": stockImage = Images.IPhoneBackButton; break;
case "IPHONEBLUEBUTTON": stockImage = Images.IPhoneBlueButton; break;
case "IPHONECHEVRON": stockImage = Images.IPhoneChevron; break;
case "IPHONEGRAYBUTTON": stockImage = Images.IPhoneGrayButton; break;
case "IPHONEICON": stockImage = Images.IPhoneIcon; break;
case "IPHONELISTGROUP": stockImage = Images.IPhoneListGroup; break;
case "IPHONEONOFF": stockImage = Images.IPhoneOnOff; break;
case "IPHONEPINSTRIPES": stockImage = Images.IPhonePinstripes; break;
case "IPHONESELECTEDTICK": stockImage = Images.IPhoneSelectedTick; break;
case "IPHONESELECTION": stockImage = Images.IPhoneSelection; break;
case "IPHONESPLASH": tempImage = CreateIPhoneSplash(args.WebSite, args.IsIPad, args.PathParts); break;
case "IPHONETOOLBAR": stockImage = Images.IPhoneToolbar; break;
case "IPHONETOOLBUTTON": stockImage = Images.IPhoneToolButton; break;
case "IPHONEWHITEBUTTON": stockImage = Images.IPhoneWhiteButton; break;
case "MINUS": stockImage = Images.Collapse; break;
case "MOVINGMAPCHECKED": stockImage = Images.MovingMapChecked; break;
case "MOVINGMAPUNCHECKED": stockImage = Images.MovingMapUnchecked; break;
case "OPENSLIDER": stockImage = Images.OpenSlider; break;
case "OPFLAG": tempImage = CreateLogoImage(imageRequest.File, _OperatorFlagFolder); break;
case "PICTURE": tempImage = CreateAirplanePicture(imageRequest.File, imageRequest.Size, args.IsInternetRequest); break;
case "PLUS": stockImage = Images.Expand; break;
case "ROWHEADER": stockImage = Images.RowHeader; break;
case "ROWHEADERSELECTED": stockImage = Images.RowHeaderSelected; break;
case "SHOWLIST": stockImage = Images.ShowList; break;
case "TESTSQUARE": stockImage = Images.TestSquare;break;
case "TRANSPARENT-25": stockImage = Images.Transparent_25; break;
case "TRANSPARENT-50": stockImage = Images.Transparent_50; break;
case "TYPE": tempImage = CreateLogoImage(imageRequest.File, _SilhouetteFolder); break;
case "VOLUME0": stockImage = Images.Volume0; break;
case "VOLUME25": stockImage = Images.Volume25; break;
case "VOLUME50": stockImage = Images.Volume50; break;
case "VOLUME75": stockImage = Images.Volume75; break;
case "VOLUME100": stockImage = Images.Volume100; break;
case "VOLUMEDOWN": stockImage = Images.VolumeDown; break;
case "VOLUMEMUTE": stockImage = Images.VolumeMute; break;
case "VOLUMEUP": stockImage = Images.VolumeUp; break;
case "YOUAREHERE": stockImage = Images.BlueBall; break;
default: result = false; break;
}
if(result) result = stockImage != null || tempImage != null;
return result;
}
/// <summary>
/// Extracts information about the required image from the URL.
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
private ImageRequest ExtractImageRequest(RequestReceivedEventArgs args)
{
bool isValid = true;
ImageRequest result = new ImageRequest() {
ImageName = Path.GetFileNameWithoutExtension(args.File).ToUpper(),
};
switch(Path.GetExtension(args.File).ToUpper()) {
case ".PNG": result.ImageFormat = ImageFormat.Png; break;
case ".GIF": result.ImageFormat = ImageFormat.Gif; break;
case ".BMP": result.ImageFormat = ImageFormat.Bmp; break;
default: isValid = false; break;
}
foreach(var pathPart in args.PathParts) {
var caselessPart = pathPart.ToUpper();
if(caselessPart.StartsWith("ALT-")) result.ShowAltitudeStalk = true;
if(caselessPart.StartsWith("ROTATE-")) result.RotateDegrees = ParseDouble(pathPart.Substring(7), 0.0, 359.99);
else if(caselessPart.StartsWith("HGHT-")) result.Height = ParseInt(pathPart.Substring(5), 0, 4096);
else if(caselessPart.StartsWith("WDTH-")) result.Width = ParseInt(pathPart.Substring(5), 0, 4096);
else if(caselessPart.StartsWith("CENX-")) result.CentreX = ParseInt(pathPart.Substring(5), 0, 4096);
else if(caselessPart.StartsWith("FILE-")) result.File = pathPart.Substring(5).Replace("\\", "");
else if(caselessPart.StartsWith("SIZE-")) result.Size = ParseStandardSize(pathPart.Substring(5));
else if(caselessPart.StartsWith("PL1-")) result.TextLines[0] = pathPart.Substring(4);
else if(caselessPart.StartsWith("PL2-")) result.TextLines[1] = pathPart.Substring(4);
else if(caselessPart.StartsWith("PL3-")) result.TextLines[2] = pathPart.Substring(4);
}
switch(result.ImageName) {
case "AIRPLANE":
case "AIRPLANESELECTED": result.CentreImageVertically = false; break;
}
return isValid ? result : null;
}
static string ServiceStackTextSerialize(ImageRequest obj)
{
return ServiceStack.Text.JsonSerializer.SerializeToString(obj);
}
static string JsonNetSerialize(ImageRequest obj)
{
return Newtonsoft.Json.JsonConvert.SerializeObject(obj);
}
static string SimpleJsonSerialize(ImageRequest obj)
{
return Simple.Json.JsonSerializer.Default.ToJson(obj, typeof(ImageRequest), false);
}
private void RequestImageDownload(Uri imageUri, WeakReference imageSourceRef)
{
if (imageUri == null || imageSourceRef == null || imageSourceRef.Target == null)
{
return;
}
lock (_pendingRequests)
{
PrunePendingRequests();
if (_pendingRequests.ContainsKey(imageUri))
{
ImageRequest request = _pendingRequests[imageUri];
lock (request)
{
_pendingRequests[imageUri].SourceRefs.Add(imageSourceRef);
}
}
else
{
ImageRequest request = new ImageRequest(imageUri);
request.Completed += OnImageRequestCompleted;
request.SourceRefs.Add(imageSourceRef);
_pendingRequests[imageUri] = request;
try
{
request.Start();
}
catch (Exception)
{
_pendingRequests.Remove(imageUri);
}
}
}
}
public static AbstractRequest GetRequestEntity(XDocument doc)
{
RequestMsgType msgType = MsgTypeHelper.GetMsgType(doc);
AbstractRequest entity = null;
switch (msgType)
{
case RequestMsgType.Text:
entity = new TextRequest();
break;
case RequestMsgType.Image:
entity = new ImageRequest();
break;
case RequestMsgType.Voice:
entity = new VoiceRequest();
break;
case RequestMsgType.Video:
entity = new VideoRequest();
break;
case RequestMsgType.Location:
entity = new LocationRequest();
break;
case RequestMsgType.Link:
entity = new LinkRequest();
break;
case RequestMsgType.Event:
switch (EventTypeHelper.GetEventType(doc))
{
case RequestEventType.Subscribe:
entity = new SubscribeEventRequest();
goto Label_00C5;
case RequestEventType.UnSubscribe:
entity = new UnSubscribeEventRequest();
goto Label_00C5;
case RequestEventType.Scan:
entity = new ScanEventRequest();
goto Label_00C5;
case RequestEventType.Location:
entity = new LocationEventRequest();
goto Label_00C5;
case RequestEventType.Click:
entity = new ClickEventRequest();
goto Label_00C5;
}
throw new ArgumentOutOfRangeException();
default:
throw new ArgumentOutOfRangeException();
}
Label_00C5:
EntityHelper.FillEntityWithXml<AbstractRequest>(entity, doc);
return entity;
}
public virtual AbstractResponse OnImageRequest(ImageRequest imageRequest)
{
return this.DefaultResponse(imageRequest);
}
