protected override MaybeTask<IImageProvider> GetEffectInternalAsync(IImageProvider source, Size sourceSize, Size renderSize)
{
m_radialGradient.CenterPoint = new Point(m_centerX, m_centerY);
m_radialGradient.EllipseRadius = new EllipseRadius(m_radiusX, m_radiusY);
return new MaybeTask<IImageProvider>(m_gradientImageSource);
}
protected override MaybeTask<IImageProvider> GetEffectInternalAsync(IImageProvider source, Size sourceSize, Size renderSize)
{
((IImageConsumer)Effect).Source = source;
((SpotlightEffect)Effect).Position = new Windows.Foundation.Point(sourceSize.Width / 2, sourceSize.Height / 2);
return new MaybeTask<IImageProvider>(Effect);
}
public GameViewModel(int totalQuestions, IImageProvider imageProvider, IStorageProvider storageProvider)
{
_imageProvider = imageProvider;
_storageProvider = storageProvider;
// register all the events
CommandEvents.ContinueButtonPressed += new EventHandler(ContinueButtonPressed);
CommandEvents.AnswerButtonPressed += new EventHandler(AnswerButtonPressed);
CommandEvents.HighScoreContinueButtonPressed += new EventHandler(HighScoreContinueButtonPressed);
DisplayHighScore += new EventHandler(DisplayScore);
// check to see whether any game state is already loaded
if (_storageProvider.GameStateExists())
{
_game = _storageProvider.LoadGameState();
// check if the player was in the middle of a question
if (_game.CurrentQuestion.Answered)
{
DisplayQuestion();
ContinueButtonPressed(this, new EventArgs());
}
else
{
DisplayQuestion();
}
}
else
{
_game = new Game(totalQuestions);
ContinueButtonPressed(this, new EventArgs());
}
}
public ColorAdjustEffect(IImageProvider source, double red = 0, double green = 0, double blue = 0)
: base(source)
{
m_RedPercentage = red;
m_GreenPercentage = green;
m_BluePercentage = blue;
}
private List<IImageProvider> GetChain(IImageProvider tail)
{
List<IImageProvider> chain = new List<IImageProvider>();
if (tail == null)
return chain;
chain.Add(tail);
var imageConsumer = tail as IImageConsumer;
while (imageConsumer != null)
{
var imageProvider = imageConsumer.Source;
if (imageProvider == null)
break;
chain.Add(imageProvider);
imageConsumer = imageProvider as IImageConsumer;
}
chain.Reverse();
return chain;
}
public RecipeCSharpEffect(IImageProvider source, double factor)
: base(source)
{
effect = new CSharp.MyEffect(source, factor);
SetPipelineBeginEnd(effect, effect);
}
protected sealed override IImageProvider PrepareGroup(IImageProvider groupSource)
{
m_mustGetNewSize = true;
var blurCanBeApplied = TryPrepareLensBlurProperties();
if (!blurCanBeApplied)
{
return Source;
}
LensBlurEffect.Source = groupSource;
LensBlurEffect.KernelMap = KernelMapSource;
LensBlurEffect.BlendKernelWidth = LensBlurEffect.Kernels.Max(w => w.Size) / 2;
switch (Quality)
{
case DepthOfFieldQuality.Preview:
LensBlurEffect.Quality = GetQualityForPreview();
break;
case DepthOfFieldQuality.Full:
LensBlurEffect.Quality = GetQualityForFull();
break;
default:
throw new NotImplementedException(String.Format("Quality {0} currently unsupported", Quality.ToString()));
}
m_quality.Reset();
return LensBlurEffect;
}
/// <summary>
/// Creates a square image and attaches an event handler to the layout changed event that
/// adds the the square in the upper right-hand corner of the TextView via the adornment layer
/// </summary>
/// <param name="view">The <see cref="IWpfTextView"/> upon which the adornment will be drawn</param>
/// <param name="imageProvider">The <see cref="IImageProvider"/> which provides bitmaps to draw</param>
/// <param name="setting">The <see cref="Setting"/> contains user image preferences</param>
public ClaudiaIDE(IWpfTextView view, IImageProvider imageProvider, Setting setting)
{
try
{
_dispacher = Dispatcher.CurrentDispatcher;
_imageProvider = imageProvider;
_view = view;
_positionHorizon = setting.PositionHorizon;
_positionVertical = setting.PositionVertical;
_imageOpacity = setting.Opacity;
_fadeTime = setting.ImageFadeAnimationInterval;
_image = new Image
{
Opacity = setting.Opacity,
IsHitTestVisible = false
};
_adornmentLayer = view.GetAdornmentLayer("ClaudiaIDE");
_view.ViewportHeightChanged += delegate { RepositionImage(); };
_view.ViewportWidthChanged += delegate { RepositionImage(); };
_view.ViewportLeftChanged += delegate { RepositionImage(); };
_imageProvider.NewImageAvaliable += delegate { _dispacher.Invoke(ChangeImage); };
ChangeImage();
}
catch (Exception)
{
}
}
/// <summary>
/// Initializes the WallpaperComposerParameters with a set of properties
/// </summary>
/// <param name="imageProvider">ImageProvider to be used by the WallpaperComposer</param>
/// <param name="imageResizer">ImageResizer to be used by the WallpaperComposer</param>
/// <param name="wallpaperProcessor">WallpaperProcessor to be used by the WallpaperComposer</param>
public WallpaperComposerParameters(IImageProvider imageProvider,
IImageResizer imageResizer, IWallpaperProcessor wallpaperProcessor)
{
this.ImageProvider = imageProvider;
this.ImageResizer = imageResizer;
this.WallpaperProcessor = wallpaperProcessor;
}
/// <summary>
/// Creates and initializes a new lens tilt depth-of-field effect.
/// </summary>
/// <param name="source">The source image to be blurred.</param>
/// <param name="focusBand">The band that represents the focus area in the image. Pixels within this band won't be blurred.
/// Areas outside of the area will be progressively more blurred as the distance from the focus band increases..</param>
/// <param name="blurStrengthAtEdge1">Strength of the blur on the Edge1 side of the focus band.</param>
/// <param name="blurStrengthAtEdge2">Strength of the blur on the Edge2 side of the focus band.</param>
public LensTiltDepthOfFieldEffect(IImageProvider source, FocusBand focusBand, double strengthAtEdge1, double strengthAtEdge2, DepthOfFieldQuality quality)
: base(source, quality)
{
FocusBand = focusBand;
StrengthAtEdge1 = strengthAtEdge1;
StrengthAtEdge2 = strengthAtEdge2;
}
/// <summary>
/// Creates a square image and attaches an event handler to the layout changed event that
/// adds the the square in the upper right-hand corner of the TextView via the adornment layer
/// </summary>
/// <param name="view">The <see cref="IWpfTextView"/> upon which the adornment will be drawn</param>
/// <param name="imageProvider">The <see cref="IImageProvider"/> which provides bitmaps to draw</param>
/// <param name="setting">The <see cref="Setting"/> contains user image preferences</param>
public ClaudiaIDE(IWpfTextView view, List<IImageProvider> imageProvider, Setting setting)
{
try
{
_dispacher = Dispatcher.CurrentDispatcher;
_imageProviders = imageProvider;
_imageProvider = imageProvider.FirstOrDefault(x=>x.ProviderType == setting.ImageBackgroundType);
_setting = setting;
if (_imageProvider == null)
{
_imageProvider = new SingleImageProvider(_setting);
}
_view = view;
_image = new Image
{
Opacity = setting.Opacity,
IsHitTestVisible = false
};
_adornmentLayer = view.GetAdornmentLayer("ClaudiaIDE");
_view.ViewportHeightChanged += delegate { RepositionImage(); };
_view.ViewportWidthChanged += delegate { RepositionImage(); };
_view.ViewportLeftChanged += delegate { RepositionImage(); };
_setting.OnChanged += delegate { ReloadSettings(); };
_imageProviders.ForEach(x => x.NewImageAvaliable += delegate { InvokeChangeImage(); });
ChangeImage();
}
catch
{
}
}
private LayerContext CreateFakeLayerContext(Layer backgroundLayer, IImageProvider backgroundImage, Layer layer)
{
var invariants = new LayerContext.Invariants(backgroundLayer, new MaybeTask<IImageProvider>(backgroundImage), new Size(0, 0));
var layerContext = new LayerContext(invariants, backgroundLayer, layer, 1);
layerContext.PreviousImage = layerContext.BackgroundImage;
return layerContext;
}
public ComponentManager(IComponentConfiguration configuration, IImageProvider imageProvider,
ICameraDevice cameraDevice)
{
device = cameraDevice;
provider = imageProvider;
componentConfiguration = configuration;
}
protected override MaybeTask<IImageProvider> GetEffectInternalAsync(IImageProvider source, Size sourceSize, Size renderSize)
{
m_linearGradient.StartPoint = new Point(m_startX, m_startY);
m_linearGradient.EndPoint = new Point(m_endX, m_endY);
return new MaybeTask<IImageProvider>(m_gradientImageSource);
}
public CustomEffectViewModel(IImageProvider effect)
{
Effect = effect;
m_writeableBitmap = new WriteableBitmap(100, 100);
m_renderer = new WriteableBitmapRenderer(Effect, m_writeableBitmap);
MinValue = 0;
MaxValue = 1;
}
public QuadTransformation(IImageProvider source, Size size, QuadDirection direction, EdgePoints edgePoints)
: base(source)
{
Direction = direction;
Size = size;
EdgePoints = edgePoints;
}
private async Task FinishRenderAsync(IImageProvider effect, IImageProcessor processor)
{
m_bitmapRenderer.Source = effect;
var thumbnailTargetBitmap = await m_bitmapRenderer.RenderAsync().AsTask().ConfigureAwait(false);
m_thumbnailCompleteAction(processor, thumbnailTargetBitmap);
}
protected override MaybeTask<IImageProvider> GetEffectInternalAsync(IImageProvider source, Windows.Foundation.Size sourceSize, Windows.Foundation.Size renderSize)
{
m_RgbMixerEffect.Source = source;
return new MaybeTask<IImageProvider>(m_RgbMixerEffect);
}
public GrayscaleNegativeEffect(IImageProvider source, double red = 0.2126, double green = 0.7152, double blue = 0.0722)
: base(source)
{
// Self correct negative percentages to just zero them out and ensure no percentage goes above 1.0 (100%)
m_RedPercentage = (red < 0.00) ? 0.00 : (red > 1.00) ? 1.00 : red;
m_GreenPercentage = (green < 0.00) ? 0.00 : (green > 1.00) ? 1.00 : green;
m_BluePercentage = (blue < 0.00) ? 0.00 : (blue > 1.00) ? 1.00 : blue;
}
public RecipeCSharpFilter(IImageProvider source, double factor)
: base(source)
{
effect = new FilterEffect(source);
effect.Filters = new IFilter[]{new CSharp.MyFilter (factor)};
SetPipelineBeginEnd(effect, effect);
}
public EffectProcessor(string name, IImageProvider effect, bool canRenderAtPreviewSize = true, bool useCustomRangeEditor = false)
{
m_useCustomRangeEditor = useCustomRangeEditor;
CanRenderAtPreviewSize = canRenderAtPreviewSize;
Name = name;
Effect = effect;
AddEditors();
}
public RecipeCPPEffect(IImageProvider source, double factor)
: base(source)
{
effect = new CPP.MyEffect( factor);
delegatingEffect = new DelegatingEffect(source, effect);
SetPipelineBeginEnd(delegatingEffect, delegatingEffect);
}
public QuantizeColorEffect(IImageProvider source, ref Dictionary<uint, uint> assignedColorCache,
List<uint> targetColors = null, ColorPalette colorPalette = ColorPalette.Color16)
: base(source)
{
m_ColorPalette = colorPalette;
TargetColors = (targetColors == null) ? TargetColors : targetColors; // Initialize TargetColors
m_Cache = (assignedColorCache != null); // If color cache object passed in, then we will cache
m_AssignedColorCache = assignedColorCache;
}
/// <summary>
/// Creates and initializes a new focus object depth-of-field effect.
/// </summary>
/// <param name="source">The image source to apply the effect to</param>
/// <param name="objectMaskSource">A grayscale mask that represents the object in the image that shall be kept in focus.</param>
/// <param name="horizonPoint1">The first point defining the horizon line.</param>
/// <param name="horizonPoint2">The second point defining the horizon line.</param>
/// <param name="strengthBelowHorizon">The strength of the blur effect below the horizon line.</param>
/// <param name="strengthAboveHorizon">The strength of the blur effect above the horizon line.</param>
public FocusObjectDepthOfFieldEffect(IImageProvider source, IImageProvider objectMaskSource, Point horizonPoint1, Point horizonPoint2, double strengthBelowHorizon, double strengthAboveHorizon, DepthOfFieldQuality quality)
: base(source, quality)
{
ObjectMaskSource = objectMaskSource;
HorizonPoint1 = horizonPoint1;
HorizonPoint2 = horizonPoint2;
StrengthBelowHorizon = strengthBelowHorizon;
StrengthAboveHorizon = strengthAboveHorizon;
}
public CameraPageViewModel(IImageProvider imageProvider, IImageConverter imageConverter)
{
converter = imageConverter;
var timer = new Timer(UpdateFpsLabel);
timer.Change(0, 1000);
provider = imageProvider;
provider.NewImage += OnNewImage;
}
void Init(int numberOfDecks, int bankRoll)
{
_bankRoll = bankRoll;
_numberOfDecks = numberOfDecks;
_game = Game.Game.GetBuilder().BankRollIs(bankRoll).NumberOfDecksIs(numberOfDecks).Build();
_image = ImageProvider.GetImageProvider();
SetCardsList();
ResetLabels(numberOfDecks, bankRoll);
}
public CustomEffectViewModel(IImageProvider effect, string propertyName, double minValue, double maxValue)
{
m_propertyName = propertyName;
Effect = effect;
m_writeableBitmap = new WriteableBitmap(100, 100);
m_renderer = new WriteableBitmapRenderer(Effect, m_writeableBitmap);
MinValue = minValue;
MaxValue = maxValue;
}
public BlendEffectProcessor(IImageProvider source)
{
SetDefaultParameters();
m_blendEffect = new BlendEffect();
// SetupEffectCategory(m_blendEffect);
m_blendEffect.Source = source;
AddEditors();
}
public MaybeTask<IImageProvider> GetEffectAsync(IImageProvider source, Size sourceSize, Size renderSize)
{
if (source == null)
{
throw new NullReferenceException("source");
}
return GetEffectInternalAsync(source, sourceSize, renderSize);
}
public IImageProvider CreatePipeline(IImageProvider source)
{
var value = 0.5 + 3 * Param;
//return new FilterEffect(source) { Filters = new IFilter[] { new GrayscaleFilter() } };
//return new RecipeCSharpEffect(source, value); //Recipe with C# custom effect
//return new RecipeCSharpFilter(source, value);//Recipe with C# custom Filter
//return new RecipeCPPEffect(source, value); //Recipe with CPP custom effect
//return new RecipeCPPFilter(source, value); //Recipe with CPP custom effect
return new RecipeDaisyChain(source, value); //Recipe Daisy chain
}
async void Dispose(bool TerminateRecord)
{
if (_disposed)
{
return;
}
_disposed = true;
_cancellationTokenSource.Cancel();
// Resume record loop if paused so it can exit
_continueCapturing.Set();
// Ensure all threads exit before disposing resources.
if (TerminateRecord)
{
_recordTask.Wait();
}
try
{
if (_frameWriteTask != null)
{
await _frameWriteTask;
}
}
catch { }
try
{
if (_audioWriteTask != null)
{
await _audioWriteTask;
}
}
catch { }
if (_audioProvider != null)
{
_audioProvider.Stop();
_audioProvider.Dispose();
_audioProvider = null;
}
_imageProvider?.Dispose();
_imageProvider = null;
_videoWriter.Dispose();
_videoWriter = null;
_audioBuffer = _silenceBuffer = null;
_continueCapturing.Dispose();
}
public UsersService(
IMapper mapper,
IImageProvider imageProvider,
IOptions <ImageFileOptions> fileOptions,
UserManager <User> userManager)
{
_mapper = mapper;
_imageProvider = imageProvider;
_userManager = userManager;
_fileOptions = fileOptions.Value;
}
private async void LoadAsync()
{
cacheFolder = ApplicationData.Current.LocalCacheFolder;
imageProvider = new WallDashProvider();
// Get first batch of images
await LoadMoreAsync();
// Start cycling through images
CycleImagesAsync();
}
public TexturePreviewViewModel(
DomainActionBuilder actionBuilder,
IEventPublisher eventPublisher,
ITextureManagementViewModel viewModel,
IImageProvider emptyImageProvider)
{
_actionBuilder = actionBuilder;
_eventPublisher = eventPublisher;
_emptyImageProvider = emptyImageProvider;
_viewModel = viewModel;
}
public SiteGenerator(IImageProvider imageProvider)
{
_imageProvider = imageProvider;
_razor = new RazorLightEngineBuilder()
.UseFilesystemProject(Path.Combine(Environment.CurrentDirectory, "Views"))
.UseMemoryCachingProvider()
.Build();
_assetsProvider = new PhysicalFileProvider(Path.Combine(Environment.CurrentDirectory, "Assets"));
}
IVideoFileWriter GetVideoFileWriterWithPreview(IImageProvider ImgProvider, IAudioProvider AudioProvider)
{
if (_videoViewModel.SelectedVideoSourceKind is NoVideoSourceProvider)
{
return(null);
}
_previewWindow.Init(ImgProvider.Width, ImgProvider.Height);
return(new WithPreviewWriter(GetVideoFileWriter(ImgProvider, AudioProvider, FileSavePath), _previewWindow));
}
public void StartRecoding(String savePath)
{
FileSavePath = savePath + "BAR-" + DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss") + ".avi";
//图像
IImageProvider imgProvider = null;
try
{
imgProvider = GetImageProvider();
}
catch (Exception e)
{
MessageBox.Show(e.Message);
imgProvider?.Dispose();
return;
}
//声音
IAudioProvider audioProvider = null;
try
{
Settings.Audio.Enabled = true;
if (Settings.Audio.Enabled && !Settings.Audio.SeparateFilePerSource)
{
audioProvider = _audioSource.GetMixedAudioProvider();
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
_audioSource?.Dispose();
return;
}
//视频写入
IVideoFileWriter videoEncoder;
try
{
videoEncoder = GetVideoFileWriterWithPreview(imgProvider, audioProvider);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
imgProvider?.Dispose();
audioProvider?.Dispose();
return;
}
_recorder = new Recorder(videoEncoder, imgProvider, Settings.Video.FrameRate, audioProvider);
_recorder.Start();
}
protected override MaybeTask <IImageProvider> GetEffectInternalAsync(IImageProvider source, Size sourceSize, Size renderSize)
{
var current = source;
var gradientImageSource = new GradientImageSource(sourceSize, new RadialGradient(new Point(0.5, 0.3), new EllipseRadius(1.0, 0),
new[] {
new GradientStop()
{
Color = Color.FromArgb(255, 255, 255, 255), Offset = 0
},
new GradientStop()
{
Color = Color.FromArgb(255, 255, 255, 255), Offset = 0.1
},
new GradientStop()
{
Color = Color.FromArgb(255, 0, 0, 0), Offset = 0.101
},
new GradientStop()
{
Color = Color.FromArgb(255, 16, 16, 16), Offset = 0.8
},
}
));
var lensblur = new LensBlurEffect(source, gradientImageSource,
new ILensBlurKernel[]
{
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 1),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 2),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 3),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 4),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 5),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 6),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 7),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 8),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 9),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 10),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 11),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 12),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 13),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 14),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 15),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 20),
new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Hexagon, 25),
});
lensblur.BlendKernelWidth = 10;
lensblur.FocusAreaEdgeMirroring = LensBlurFocusAreaEdgeMirroring.Off;
// TODO lower quality in preview mode.
lensblur.Quality = 1.0;
return(new MaybeTask <IImageProvider>(lensblur));
}
protected virtual void Dispose(bool disposing)
{
var disposable = m_imageProvider as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
m_imageProvider = null;
}
/// <summary>
/// Creates a new instance of <see cref="RotatedImageProvider"/>.
/// </summary>
/// <param name="Source">The source <see cref="IImageProvider"/>.</param>
/// <param name="RotateFlipType">Rotation and/or Flipping options.</param>
/// <exception cref="ArgumentNullException"><paramref name="Source"/> is null.</exception>
public RotatedImageProvider(IImageProvider Source, RotateFlipType RotateFlipType)
{
_sourceImageProvider = Source ?? throw new ArgumentNullException(nameof(Source));
_rotateFlipType = RotateFlipType;
var flipDimensions = (int)RotateFlipType % 2 != 0;
Width = flipDimensions ? Source.Height : Source.Width;
Height = flipDimensions ? Source.Width : Source.Height;
}
private static IImageProvider Bind(IImageProvider currentImage, IImageProvider previousImage)
{
var imageConsumer = currentImage as IImageConsumer;
if (imageConsumer != null)
{
imageConsumer.Source = previousImage;
}
return(currentImage);
}
/// <summary>
/// Gets the order.
/// </summary>
/// <param name="provider">The provider.</param>
/// <returns>System.Int32.</returns>
private int GetOrder(IImageProvider provider)
{
var hasOrder = provider as IHasOrder;
if (hasOrder == null)
{
return(0);
}
return(hasOrder.Order);
}
public AdminController(ILoginProvider loginProvider, IImageProvider imageProvider,
IPostRepository postRepository, ICategoryRepository categoryRepository, ITagRepository tagRepository,
IViewModelFactory viewModelFactory)
{
this.loginProvider = loginProvider;
this.imageProvider = imageProvider;
this.postRepository = postRepository;
this.categoryRepository = categoryRepository;
this.tagRepository = tagRepository;
this.viewModelFactory = viewModelFactory;
}
/// <summary>
/// Renders the IImageProvider into a Bitmap. If the passed Bitmap is non-null, and it matches the passed size and color mode, it will be reused. Otherwise this method creates a new Bitmap.
/// </summary>
/// <param name="imageProvider">The image provider to render the image content of.</param>
/// <param name="bitmap">The Bitmap to reuse, if possible. If null is passed, a new Bitmap is created.</param>
/// <param name="size">The desired size of the rendered image.</param>
/// <param name="outputOption">Specifies how to fit the image into the rendered rectangle, if the aspect ratio differs.</param>
/// <returns>A task resulting in either the reused Bitmap, or a new one if necessary.</returns>
public static async Task <Bitmap> GetBitmapAsync(this IImageProvider imageProvider, Bitmap bitmap, Size size, ColorMode colorMode, OutputOption outputOption)
{
if (bitmap == null || bitmap.Dimensions != size || bitmap.ColorMode != colorMode)
{
bitmap = new Bitmap(size, colorMode);
}
using (var renderer = new BitmapRenderer(imageProvider, bitmap, outputOption))
{
return(await renderer.RenderAsync().AsTask().ConfigureAwait(false));
}
}
public ChatService(UserManager <User> userManager, IDateTimeHelper dateTimeHelper, IMapper mapper,
IRoomRepository roomRepository, IMessageRepository messageRepository, IImageProvider imageProvider, IUserInRoomRepository userInRoomRepository, IMessageInRoomRepository messageInRoomRepository)
{
_roomRepository = roomRepository;
_userInRoomRepository = userInRoomRepository;
_messageRepository = messageRepository;
_imageProvider = imageProvider;
_messageInRoomRepository = messageInRoomRepository;
_mapper = mapper;
_userManager = userManager;
_dateTimeHelper = dateTimeHelper;
}
/// <inheritdoc />
public void Dispose()
{
_imageProvider.Dispose();
foreach (var overlay in _overlays)
{
overlay?.Dispose();
}
_imageProvider = null;
_overlays = null;
}
private async Task <IImageProvider> GetEffectTaskAsync(IImageProvider source, Size sourceSize, Size renderSize)
{
var file = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///images/LensBlurMask.jpg"));
StorageFileImageSource mapSource = new StorageFileImageSource(file);
var lensBlurEffect = new LensBlurEffect(source, mapSource);
lensBlurEffect.FocusAreaEdgeMirroring = LensBlurFocusAreaEdgeMirroring.Off;
lensBlurEffect.PointLightStrength = 10;
lensBlurEffect.Kernels = new LensBlurPredefinedKernel[] { new LensBlurPredefinedKernel(LensBlurPredefinedKernelShape.Heart, 15) };
return(lensBlurEffect);
}
public void Initialize(IEventAggregator eventAggregator,
[Dependency("LocalImageProvider")] IImageProvider imageProvider)
{
_eventAggregator = eventAggregator;
_imageProvider = imageProvider;
_eventAggregator.GetEvent <OpenedImageEvent>().Subscribe(LoadImages, ThreadOption.UIThread);
ThumbnailCollection = new CollectionViewSource();
_thumbnailCollection = new ObservableCollection <Thumbnail>();
ThumbnailCollection.Source = _thumbnailCollection;
ImageLeftCommand = new DelegateCommand(ImageLeftExecuted);
ImageRightCommand = new DelegateCommand(ImageRightExecuted);
}
private async void SelectFile_Tapped(object sender, TappedRoutedEventArgs e)
{
var picker = new FileOpenPicker();
picker.FileTypeFilter.Add(".jpg");
var selectedFile = await picker.PickSingleFileAsync();
originalSource = await ImageResourceProvider.CreateImageSourceFromFile(selectedFile);
ImageElement.Source = originalSource;
}
public AlbumLookupEntryViewModel(AlbumLookupEntry model, IImageProvider imageProvider)
{
_model = model;
Uri uri = model.ArtworkUrl100 ?? model.ArtworkUrl60 ?? model.ArtworkUrl30;
Artwork = new LazyProperty <BitmapImage>(
async cancelToken => await imageProvider
.GetImage(uri, cancelToken)
.ConfigureAwait(true),
new BitmapImage());
}
public PointCaptcha(
ImageDriver driver,
IOptions <PointOptions> options,
IImageProvider imageProvider,
CaptchaImageBuilder builder
)
{
_driver = driver;
_imageProvider = imageProvider;
_options = options.Value;
_captchaImageBuilder = builder;
}
public FeedbackService(IFeedbackRepository feedbackRepository, IStudentAttendanceService studentAttendanceService, IStudentBehaviorService studentBehaviorService, IStudentCourseGradesService studentCourseGradesService, IImageProvider imageProvider, IStudentAssignmentService studentAssignmentService, ICustomParametersProvider customParametersProvider, ICommunicationsService communicationsService, IMessagingProvider messagingProvider)
{
_feedbackRepository = feedbackRepository;
_studentAttendanceService = studentAttendanceService;
_studentBehaviorService = studentBehaviorService;
_studentCourseGradesService = studentCourseGradesService;
_imageProvider = imageProvider;
_studentAssignmentService = studentAssignmentService;
_customParametersProvider = customParametersProvider;
_communicationsService = communicationsService;
_messagingProvider = messagingProvider;
}
private async Task RenderAsync()
{
IImageProvider effect = null;
WriteableBitmap writeableBitmap = new WriteableBitmap(800, 800);
for (var i = 0; i < _effectChain.Count; i++)
{
effect = _effectChain.Values[i].AddEffect(effect);
}
Image.Source = await new WriteableBitmapRenderer(effect, writeableBitmap).RenderAsync();
}
public ProfileController(IOrderService orderService, IMappingService mappingService, IImageProvider imageProvider, IIdentityProvider identityProvider)
{
Validator.ValidateNullArgument(orderService, "orderService");
Validator.ValidateNullArgument(mappingService, "mappingService");
Validator.ValidateNullArgument(imageProvider, "imageProvider");
Validator.ValidateNullArgument(identityProvider, "identityProvider");
this.identityProvider = identityProvider;
this.orderService = orderService;
this.mappingService = mappingService;
this.imageProvider = imageProvider;
}
async Task <Uri> Contrast(int EffectPercentage)
{
using (var source = new StorageFileImageSource(imageStorageFile))
using (var sharpnessEffect = new ContrastEffect(source)
{
Level = (EffectPercentage / 100)
})
{
LastEffect = sharpnessEffect;
return(await SaveToImage());
}
}
void Dispose(bool TerminateRecord)
{
if (_disposed)
{
return;
}
_disposed = true;
if (_audioProvider != null)
{
_audioProvider.DataAvailable -= AudioProvider_DataAvailable;
_audioProvider.Stop();
_audioProvider.Dispose();
_audioProvider = null;
}
if (_videoWriter != null)
{
_cancellationTokenSource.Cancel();
// Resume record loop if paused so it can exit
_continueCapturing.Set();
if (TerminateRecord)
{
_recordTask.Wait();
}
try
{
if (_task != null && !_task.IsCompleted)
{
_task.GetAwaiter().GetResult();
}
}
catch { }
_imageProvider?.Dispose();
_imageProvider = null;
_videoWriter.Dispose();
_videoWriter = null;
_continueCapturing.Dispose();
}
else
{
_audioWriter.Dispose();
_audioWriter = null;
}
}
private void BlendTileToCanvas(Point blendPosition)
{
var blendEffect = new BlendEffect();
m_disposables.Add(blendEffect);
blendEffect.Source = m_imageProvider;
blendEffect.ForegroundSource = m_tileSource;
blendEffect.TargetArea = new Rect(blendPosition, m_relativeTileSize);
blendEffect.TargetOutputOption = OutputOption.Stretch;
m_imageProvider = blendEffect;
}
private void CreateProvider(double width, double height, ImageProvider provider)
{
switch (provider)
{
case ImageProvider.AdorableAvatars:
imageProvider = new AdorableAvatarsProvider(width);
break;
case ImageProvider.LoremPixel:
imageProvider = new LoremPixelProvider(width, height);
break;
}
}
private async Task ColorizeImageInternalAsync(/*Lumia.Imaging.*/ IImageProvider inputImage, WriteableBitmap output)
{
using (var colorizationEffect = new ColorizationEffect(inputImage, new global::Windows.UI.Color()
{
R = 255, G = 0, B = 255
}, 1.0, 1.0)) // Create effect with the source stream
using (var renderer = new WriteableBitmapRenderer(colorizationEffect, output))
{
await renderer.RenderAsync();
output.Invalidate();
}
}
async Task <Uri> Fog()
{
using (var source = new StorageFileImageSource(imageStorageFile))
{
var inf = await source.GetInfoAsync();
using (var sharpnessEffect = new FogEffect(source))
{
LastEffect = sharpnessEffect;
return(await SaveToImage());
}
}
}
