public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(Activity, nameof(Activity));
// Identify minimum horizontal offset im source images
var minOffset = Activity.Registrations.Select(p => p.OffsetX).Min();
TargetImage = NewTargetImage(minOffset);
_logger.LogInformation("Output image size: {width} x {height} px", TargetImage.Width, TargetImage.Height);
// Composite all images. Images will have their horizontal offsets pre-calculated and overlaps
// blended, so compositing just involves combining them in the correct stacking order.
TargetImage.Mutate(imageContext =>
{
// Render all images in correct stacking order
foreach (var registration in Activity.Registrations.OrderByDescending(p => p.OffsetX))
{
using (registration)
{
var projectionImage = registration.Image;
// Identify horizontal offset of each image
var location = new Point(registration.OffsetX - minOffset, 0);
imageContext.DrawImage(projectionImage, location, PixelColorBlendingMode.Normal, 1.0f);
}
}
});
return(ExecutionResult.Next());
}
private bool CanExecute_ImageExists(TargetImage args)
{
if (!CanExecute_ViewModelLoaded())
return false;
switch (args)
{
case TargetImage.Top:
return ViewModel.Textures.Top.Exists;
case TargetImage.Bottom:
return ViewModel.Textures.Bottom.Exists;
case TargetImage.FileLarge:
return ViewModel.Textures.FileLarge.Exists;
case TargetImage.FileSmall:
return ViewModel.Textures.FileSmall.Exists;
case TargetImage.FolderOpen:
return ViewModel.Textures.FolderOpen.Exists;
case TargetImage.FolderClosed:
return ViewModel.Textures.FolderClosed.Exists;
case TargetImage.TopAlt:
return ViewModel.Textures.TopAlt.Exists;
default:
throw new ArgumentOutOfRangeException();
}
}
private void TargetImage_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var position = e.GetPosition(TargetImage);
_drawStartPoint.X = (int)Math.Ceiling(position.X);
_drawStartPoint.Y = (int)Math.Ceiling(position.Y);
if (_drawStartPoint.X > 0)
{
_drawStartPoint.X--;
}
if (_drawStartPoint.Y > 0)
{
_drawStartPoint.Y--;
}
if (_drawingTool == DrawingTool.TextTool)
{
InsertTextToImage();
return;
}
if (_drawingTool == DrawingTool.PickerTool)
{
DrawingInfo.CurrentColor = System.Windows.Media.Color.FromArgb(255, _pickedColor.R, _pickedColor.G, _pickedColor.B);
DrawingInfo.LeftSliderValue = _pickedColor.A;
return;
}
_mouseCaptured = TargetImage.CaptureMouse();
if (_drawingTool == DrawingTool.PenTool || _drawingTool == DrawingTool.EraserTool)
{
_linePoints.Clear();
_linePoints.Add(new Point(_drawStartPoint.X, _drawStartPoint.Y));
TargetImage_MouseMove(sender, e);//画点
}
}
public virtual void Dispose()
{
TargetImage?.Dispose();
Activity?.Dispose();
Registration?.Dispose();
ProgressBar?.Dispose();
}
// Use this for initialization
void Start()
{
eventsManager = FindObjectOfType <CustomEventsManager>();
eventsManager.OnMouseModeChanged += OnMouseModeChanged;
eventsManager.OnDiggingChanged += OnDiggingChanged;
target = GetComponentInChildren <TargetImage>();
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(_options.GeostationaryRender !.Longitude, nameof(GeostationaryRenderOptions.Longitude));
Guard.Against.Null(Activity, nameof(Activity));
Guard.Against.Null(TargetImage, nameof(TargetImage));
var longitudeRange = Activity.GetVisibleLongitudeRange();
// Determine visible range of all satellite imagery
var longitudeDegrees = _options.GeostationaryRender !.Longitude !.Value;
_logger.LogInformation("Reprojecting to geostationary with longitude {longitudeDegrees} degrees", longitudeDegrees);
// Adjust longitude based on the underlay wrapping for visible satellites
var adjustedLongitude = -Math.PI - longitudeRange.Start + Angle.FromDegrees(longitudeDegrees).Radians;
// Render geostationary image
using (var sourceImage = TargetImage.Clone())
{
TargetImage = sourceImage.ToGeostationaryProjection(adjustedLongitude, Constants.Satellite.DefaultHeight, _options);
// Apply haze if required
var hazeAmount = _options.GeostationaryRender.HazeAmount;
if (hazeAmount > 0 && !_options.NoUnderlay)
{
TargetImage.ApplyHaze(_options.Tint, hazeAmount);
}
}
return(ExecutionResult.Next());
}
public void Ended(ManipulationCompletedEventArgs e)
{
Apply(e.ManipulationOrigin);
Element = null;
RaiseElementChanged();
TargetImage.Invalidate();
}
public bool RemoveSetOrUpdateValue(string attributeName)
{
if (TargetImage == null)
{
throw new InvalidPluginExecutionException("No target image to remove value from");
}
return(TargetImage.RemoveAttribute(attributeName));
}
private void updateUV()
{
if (TargetImage.texture == null)
{
return;
}
//テクスチャサイズ
float tw = TargetImage.texture.width;
float th = TargetImage.texture.height;
//float tw_half = tw * 0.5f;
float th_half = th * 0.5f;
//オブジェクト位置
RectTransform rectObjTrans = GetComponent <RectTransform>();
Vector2 o_pos = RectTransformUtility.WorldToScreenPoint(MainCamera, rectObjTrans.position);
//オブジェクトサイズ
float ow = rectObjTrans.sizeDelta.x;
float oh = rectObjTrans.sizeDelta.y;
float ow_half = ow * 0.5f;
float oh_half = oh * 0.5f;
//スクリーンサイズ
float sw = MainCamera.pixelWidth;
float sh = MainCamera.pixelHeight;
//float sw_half = sw * 0.5f;
float sh_half = sh * 0.5f;
CanvasSetting canvasSetting = MainCanvas.GetComponent <CanvasSetting>();
if (!canvasSetting.IsHeightReference)
{
float rate = DefaultCanvasSizeX / sw;
o_pos *= rate;
float tmp0 = (sh_half * rate) - th_half;
Vector2 o_pos_lu = new Vector2(o_pos.x - ow_half, o_pos.y - oh_half - tmp0);
TargetImage.uvRect = new Rect(o_pos_lu.x / tw, o_pos_lu.y / th, ow / tw, oh / th);
}
else
{
float rate = DefaultCanvasSizeY / sh;
o_pos *= rate;
float tmp0 = (sh_half * rate) - th_half;
Vector2 o_pos_lu = new Vector2(o_pos.x - ow_half, o_pos.y - oh_half - tmp0);
TargetImage.uvRect = new Rect((o_pos_lu.x + (canvasSetting.GetAddWidth() * 0.5f)) / tw, o_pos_lu.y / th, ow / tw, oh / th);
}
#if UNITY_EDITOR
TargetImage.OnRebuildRequested();
#endif
}
private void Start()
{
var rect = GetComponent <RectTransform>();
var X = rect.position.x - rect.rect.width * rect.pivot.x;
var Y = rect.position.y - rect.rect.height * rect.pivot.y;
var rectP = new Rect(X, Y, rect.rect.width, rect.rect.height);
TargetImage = new TargetImage(rectP);
TargetImage.Image = rect.GetComponent <Image>();
}
private void TargetImage_MouseMove(object sender, MouseEventArgs e)
{
mousePos = new Point(e.X, e.Y);
if (TargetImage.Capture && mousePos.X <= targetImgWidth &&
mousePos.X >= 0 && mousePos.Y <= targetImgHeight &&
mousePos.Y >= 0)
{
string tmp = "X: " + e.X.ToString() + "\nY:" + e.Y.ToString();
MousePos.Text = tmp;
TargetImage.Invalidate();
}
}
private void RemoveImage_Execute(TargetImage args)
{
switch (args)
{
case TargetImage.Top:
ViewModel.Textures.Top.ClearTexture();
break;
case TargetImage.Bottom:
ViewModel.Textures.Bottom.ClearTexture();
break;
case TargetImage.FileLarge:
ViewModel.Textures.FileLarge.ClearTexture();
break;
case TargetImage.FileSmall:
ViewModel.Textures.FileSmall.ClearTexture();
break;
case TargetImage.FolderOpen:
ViewModel.Textures.FolderOpen.ClearTexture();
break;
case TargetImage.FolderClosed:
ViewModel.Textures.FolderClosed.ClearTexture();
break;
case TargetImage.TopAlt:
ViewModel.Textures.TopAlt.ClearTexture();
break;
case TargetImage.SmallIcon:
{
var icex = new IconExtension(@"/ThemeEditor.WPF;component/Resources/Icons/app_icn.ico", 24);
var large = ((BitmapSource)icex.ProvideValue(null)).CreateResizedImage(24, 24);
ViewModel.Info.SmallIcon.EncodeTexture(large, RawTexture.DataFormat.Bgr565);
break;
}
case TargetImage.LargeIcon:
{
var icex = new IconExtension(@"/ThemeEditor.WPF;component/Resources/Icons/app_icn.ico", 48);
var large = ((BitmapSource)icex.ProvideValue(null)).CreateResizedImage(48, 48);
ViewModel.Info.LargeIcon.EncodeTexture(large, RawTexture.DataFormat.Bgr565);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
private void TargetImage_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (_mouseCaptured)
{
TargetImage.ReleaseMouseCapture();
_mouseCaptured = false;
}
if (!_drawingChanged)
{
return;
}
_drawingChanged = false;
_drawingManager.Record();
}
public override async Task <ExecutionResult> RunAsync(IStepExecutionContext context)
{
Guard.Against.Null(Activity, nameof(Activity));
Guard.Against.Null(TargetImage, nameof(TargetImage));
Activity.GetCropRange(out var latitudeRange, out var longitudeRange);
// Load underlay
if (_options.NoUnderlay)
{
// Draw stitched image over black background for non-PNG files because otherwise alpha can look odd
TargetImage = !Path.GetExtension(_options.OutputPath).CompareOrdinalIgnoreCase(".png") ? TargetImage.AddBackgroundColour(Color.Black) : TargetImage;
return(ExecutionResult.Next());
}
_logger.LogInformation("Tinting and normalising IR imagery");
TargetImage.Mutate(imageContext =>
{
using var clone = TargetImage !.Clone();
clone.AdjustLevels(_options.AdaptiveLevelAdjustment);
TargetImage.Tint(_options.Tint);
imageContext.DrawImage(clone, PixelColorBlendingMode.HardLight, 0.5f);
});
var underlayOptions = new UnderlayProjectionData(
ProjectionType.Equirectangular,
_options.InterpolationType,
_options.UnderlayPath,
_options.ImageSize,
TargetImage !.Size(),
latitudeRange,
longitudeRange.Start,
_options.EquirectangularRender?.NoCrop == true || _options.EquirectangularRender?.ExplicitCrop == true);
_logger.LogInformation("Retrieving underlay");
var underlay = await _underlayService.GetUnderlayAsync(underlayOptions);
// Render target image onto underlay
using (TargetImage)
{
_logger.LogInformation("Blending with underlay");
underlay.Mutate(ctx => ctx.DrawImage(TargetImage, PixelColorBlendingMode.Screen, 1.0f));
}
TargetImage = underlay;
return(ExecutionResult.Next());
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(TargetImage, nameof(TargetImage));
Guard.Against.Null(Activity, nameof(Activity));
// Crop if required
var equirectangularOptions = _options.EquirectangularRender !;
if (!equirectangularOptions.NoCrop && CropBounds != null)
{
_logger.LogDebug("Crop bounds: {Bounds}", CropBounds);
TargetImage.Mutate(ctx => ctx.Crop(CropBounds.Value));
}
return(ExecutionResult.Next());
}
private Task <LoadImageResults> DropImage_Execute(DragEventArgs args, TargetImage target)
{
var task = new Task <LoadImageResults>(() =>
{
var results = new LoadImageResults()
{
Loaded = false,
Target = target
};
if (args.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[])args.Data.GetData(DataFormats.FileDrop);
var file = files[0];
try
{
using (var fs = File.OpenRead(file))
{
BitmapImage bmp = new BitmapImage();
bmp.BeginInit();
bmp.StreamSource = fs;
bmp.CacheOption = BitmapCacheOption.OnLoad;
bmp.EndInit();
bmp.Freeze();
results.OriginalWidth = bmp.PixelWidth;
results.OriginalHeight = bmp.PixelHeight;
var potBmp = bmp.CreateResizedNextPot();
potBmp.Freeze();
results.Loaded = true;
results.Image = potBmp;
}
}
catch
{
// ignored
}
}
return(results);
});
task.Start();
args.Handled = true;
return(task);
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(Longitude, nameof(Longitude));
Guard.Against.Null(Activity, nameof(Activity));
Guard.Against.Null(TargetImage, nameof(TargetImage));
// Determine visible range of all satellite imagery
_logger.LogInformation("Reprojecting to geostationary with longitude {longitude} degrees", Angle.FromRadians(Longitude !.Value).Degrees);
// Render geostationary image
using (var sourceImage = TargetImage.Clone())
{
TargetImage = sourceImage.ToGeostationaryProjection(Longitude.Value, Constants.Satellite.DefaultHeight, _options);
}
return(ExecutionResult.Next());
}
private bool CanExecute_ImageExists(TargetImage args)
{
if (!CanExecute_ViewModelLoaded())
{
return(false);
}
switch (args)
{
case TargetImage.Top:
return(ViewModel.Textures.Top.Exists);
case TargetImage.Bottom:
return(ViewModel.Textures.Bottom.Exists);
case TargetImage.FileLarge:
return(ViewModel.Textures.FileLarge.Exists);
case TargetImage.FileSmall:
return(ViewModel.Textures.FileSmall.Exists);
case TargetImage.FolderOpen:
return(ViewModel.Textures.FolderOpen.Exists);
case TargetImage.FolderClosed:
return(ViewModel.Textures.FolderClosed.Exists);
case TargetImage.TopAlt:
return(ViewModel.Textures.TopAlt.Exists);
case TargetImage.SmallIcon:
return(ViewModel.Info.SmallIcon.Exists);
case TargetImage.LargeIcon:
return(ViewModel.Info.LargeIcon.Exists);
default:
throw new ArgumentOutOfRangeException();
}
}
private Task<LoadImageResults> DropImage_Execute(DragEventArgs args, TargetImage target)
{
var task = new Task<LoadImageResults>(() =>
{
var results = new LoadImageResults()
{
Loaded = false,
Target = target
};
if (args.Data.GetDataPresent(DataFormats.FileDrop))
{
string[] files = (string[]) args.Data.GetData(DataFormats.FileDrop);
var file = files[0];
try
{
using (var fs = File.OpenRead(file))
{
BitmapImage bmp = new BitmapImage();
bmp.BeginInit();
bmp.StreamSource = fs;
bmp.CacheOption = BitmapCacheOption.OnLoad;
bmp.EndInit();
bmp.Freeze();
results.Loaded = true;
results.Image = bmp;
}
}
catch
{
// ignored
}
}
return results;
});
task.Start();
args.Handled = true;
return task;
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(Longitude, nameof(Longitude));
Guard.Against.Null(Activity, nameof(Activity));
Guard.Against.Null(TargetImage, nameof(TargetImage));
var longitudeRange = Activity.GetVisibleLongitudeRange();
// Determine visible range of all satellite imagery
_logger.LogInformation("Reprojecting to geostationary with longitude {longitude} degrees", Angle.FromRadians(Longitude !.Value).Degrees);
// Adjust longitude based on the underlay wrapping for visible satellites
var adjustedLongitude = -Math.PI - longitudeRange.Start + Longitude !.Value;
// Render geostationary image
using (var sourceImage = TargetImage.Clone())
{
TargetImage = sourceImage.ToGeostationaryProjection(adjustedLongitude, Constants.Satellite.DefaultHeight, _options);
}
return(ExecutionResult.Next());
}
public void SetAlgorithm()
{
switch ((AlgorithmEnum)algorithmSelectMenu.SelectedItem)
{
case AlgorithmEnum.SingleDeleteChangeInsert:
Algorithm = new SingleDeleteChangeInsert(PictureMutationAlgorithm.ScoringMethodEnum.FullEvaluationScoring);
break;
case AlgorithmEnum.SinglePolygonFullSpace:
Algorithm = new SinglePolygonFullSpace(PictureMutationAlgorithm.ScoringMethodEnum.FullEvaluationScoring);
break;
case AlgorithmEnum.ConstantPointCount:
Algorithm = new ConstantPointCount(PictureMutationAlgorithm.ScoringMethodEnum.FullEvaluationScoring);
break;
}
TargetImage.Maybe(() =>
{
Algorithm.SetImage(TargetImage);
Algorithm.SetInitial();
});
AlgorithmChanged();
}
private void TargetImage_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (e.LeftButton != MouseButtonState.Pressed)
{
return;
}
var position = e.GetPosition(TargetImage);
var x = (int)position.X;
var y = (int)position.Y;
_startPoint.X = x;
_startPoint.Y = y;
CropRect.Width = 0;
CropRect.Height = 0;
TopValueLbl.Content = 0;
LeftValueLbl.Content = 0;
WidthValueLbl.Content = 0;
HeightValueLbl.Content = 0;
TargetImage.CaptureMouse();
_isMousePressed = true;
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(TargetImage, nameof(TargetImage));
var autoCrop = _options.EquirectangularRender?.AutoCrop ?? false;
var extents = _options.EquirectangularRender?.Extents;
if (!autoCrop && extents == null)
{
return(ExecutionResult.Next());
}
if (autoCrop)
{
CropBounds = TargetImage.GetAutoCropBounds();
if (CropBounds == null)
{
_logger.LogError("Unable to determine autocrop bounds");
}
else
{
_logger.LogInformation("Cropped image size: {width} x {height} px", CropBounds.Value.Width, CropBounds.Value.Height);
}
}
else
{
var xPixelRange = extents !.Value.Longitude.UnwrapLongitude().ToPixelRangeX(TargetImage.Width);
var yPixelRange = extents !.Value.Latitude.ToPixelRangeY(TargetImage.Height);
_logger.LogInformation("Cropped image size: {width} x {height} px", xPixelRange.Range, yPixelRange.Range);
CropBounds = new Rectangle(0, xPixelRange.Range, yPixelRange.Start, yPixelRange.Range);
}
return(ExecutionResult.Next());
}
private Task<LoadImageResults> LoadImage_Execute(TargetImage targetImage)
{
var busyPickingFile = MainResources.Busy_PickingFile;
var busyOpeningImage = MainResources.Busy_OpeningImage;
var task = new Task<LoadImageResults>(() =>
{
BusyText = busyPickingFile;
var opfl = new OpenFileDialog
{
Filter = "Image Files|*.jpg;*.jpeg;*.png;*.bmp",
Multiselect = false
};
var dlg = opfl.ShowDialog();
LoadImageResults results = new LoadImageResults
{
Loaded = false,
Target = targetImage
};
if (!dlg.HasValue || dlg.Value)
{
BusyText = busyOpeningImage;
try
{
using (var fs = File.OpenRead(opfl.FileName))
{
BitmapImage bmp = new BitmapImage();
bmp.BeginInit();
bmp.StreamSource = fs;
bmp.CacheOption = BitmapCacheOption.OnLoad;
bmp.EndInit();
bmp.Freeze();
BitmapSource bmpSrc;
switch (targetImage)
{
case TargetImage.Bottom:
case TargetImage.Top:
case TargetImage.FileLarge:
case TargetImage.FileSmall:
case TargetImage.FolderOpen:
case TargetImage.FolderClosed:
case TargetImage.TopAlt:
bmpSrc = bmp.CreateResizedNextPot();
bmpSrc.Freeze();
break;
case TargetImage.SmallIcon:
case TargetImage.LargeIcon:
default:
bmpSrc = bmp;
break;
}
results.Loaded = true;
results.Image = bmpSrc;
}
}
catch
{
// ignored
}
}
return results;
});
task.Start();
return task;
}
private void RemoveImage_Execute(TargetImage args)
{
switch (args)
{
case TargetImage.Top:
ViewModel.Textures.Top.ClearTexture();
break;
case TargetImage.Bottom:
ViewModel.Textures.Bottom.ClearTexture();
break;
case TargetImage.FileLarge:
ViewModel.Textures.FileLarge.ClearTexture();
break;
case TargetImage.FileSmall:
ViewModel.Textures.FileSmall.ClearTexture();
break;
case TargetImage.FolderOpen:
ViewModel.Textures.FolderOpen.ClearTexture();
break;
case TargetImage.FolderClosed:
ViewModel.Textures.FolderClosed.ClearTexture();
break;
case TargetImage.TopAlt:
ViewModel.Textures.TopAlt.ClearTexture();
break;
case TargetImage.SmallIcon:
{
var icex = new IconExtension(@"/ThemeEditor.WPF;component/Resources/Icons/app_icn.ico", 24);
var large = ((BitmapSource) icex.ProvideValue(null)).CreateResizedImage(24, 24);
ViewModel.Info.SmallIcon.EncodeTexture( large, RawTexture.DataFormat.Bgr565);
break;
}
case TargetImage.LargeIcon:
{
var icex = new IconExtension(@"/ThemeEditor.WPF;component/Resources/Icons/app_icn.ico", 48);
var large = ((BitmapSource) icex.ProvideValue(null)).CreateResizedImage(48, 48);
ViewModel.Info.LargeIcon.EncodeTexture(large, RawTexture.DataFormat.Bgr565);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
private Task <LoadImageResults> LoadImage_Execute(TargetImage targetImage)
{
var busyPickingFile = MainResources.Busy_PickingFile;
var busyOpeningImage = MainResources.Busy_OpeningImage;
var task = new Task <LoadImageResults>(() =>
{
BusyText = busyPickingFile;
var opfl = new OpenFileDialog
{
Filter = "Image Files|*.jpg;*.jpeg;*.png;*.bmp",
Multiselect = false
};
var dlg = opfl.ShowDialog();
LoadImageResults results = new LoadImageResults
{
Loaded = false,
Target = targetImage
};
if (!dlg.HasValue || dlg.Value)
{
BusyText = busyOpeningImage;
try
{
using (var fs = File.OpenRead(opfl.FileName))
{
BitmapImage bmp = new BitmapImage();
bmp.BeginInit();
bmp.StreamSource = fs;
bmp.CacheOption = BitmapCacheOption.OnLoad;
bmp.EndInit();
bmp.Freeze();
BitmapSource bmpSrc;
switch (targetImage)
{
case TargetImage.Bottom:
case TargetImage.Top:
case TargetImage.FileLarge:
case TargetImage.FileSmall:
case TargetImage.FolderOpen:
case TargetImage.FolderClosed:
case TargetImage.TopAlt:
bmpSrc = bmp.CreateResizedNextPot();
bmpSrc.Freeze();
break;
case TargetImage.SmallIcon:
case TargetImage.LargeIcon:
default:
bmpSrc = bmp;
break;
}
results.Loaded = true;
results.Image = bmpSrc;
}
}
catch
{
// ignored
}
}
return(results);
});
task.Start();
return(task);
}
private Task <SaveImageResults> ExportImage_Execute(TargetImage targetImage)
{
var busyPickingFile = MainResources.Busy_PickingFile;
var busySavingImage = MainResources.Busy_SavingImage;
BitmapSource target;
switch (targetImage)
{
case TargetImage.Top:
target = ViewModel.Textures.Top.Bitmap;
break;
case TargetImage.Bottom:
target = ViewModel.Textures.Bottom.Bitmap;
break;
case TargetImage.FileLarge:
target = ViewModel.Textures.FileLarge.Bitmap;
break;
case TargetImage.FileSmall:
target = ViewModel.Textures.FileSmall.Bitmap;
break;
case TargetImage.FolderOpen:
target = ViewModel.Textures.FolderOpen.Bitmap;
break;
case TargetImage.FolderClosed:
target = ViewModel.Textures.FolderClosed.Bitmap;
break;
case TargetImage.TopAlt:
target = ViewModel.Textures.TopAlt.Bitmap;
break;
case TargetImage.SmallIcon:
target = ViewModel.Info.SmallIcon.Bitmap;
break;
case TargetImage.LargeIcon:
target = ViewModel.Info.LargeIcon.Bitmap;
break;
default:
throw new IndexOutOfRangeException();
}
var task = new Task <SaveImageResults>(() =>
{
BusyText = busyPickingFile;
var svfl = new SaveFileDialog
{
Filter = "PNG Files|*.png",
FileName = targetImage.ToString().ToLower()
};
var dlg = svfl.ShowDialog();
SaveImageResults results = new SaveImageResults
{
Saved = false,
Target = targetImage,
Path = svfl.FileName
};
if (!dlg.HasValue || dlg.Value)
{
BusyText = busySavingImage;
try
{
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(target));
using (var fs = File.Open(results.Path, FileMode.Create))
{
encoder.Save(fs);
results.Saved = true;
}
}
catch
{
// Ignore;
}
}
return(results);
});
task.Start();
return(task);
}
public override ExecutionResult Run(IStepExecutionContext context)
{
Guard.Against.Null(TargetImage, nameof(TargetImage));
Guard.Against.Null(Activity, nameof(Activity));
var autoCrop = _options.EquirectangularRender?.AutoCrop ?? false;
var explicitCrop = _options.EquirectangularRender?.ExplicitCrop ?? false;
// TODO document all of this - entire class really
// Also, refactor. It's a mess.
if (!autoCrop && !explicitCrop)
{
CropBounds = !FullEarthCoverage?GetPartialCoverageBounds(Activity, TargetImage) : TargetImage.Bounds();
return(ExecutionResult.Next());
}
CropBounds = autoCrop ? GetAutoCropBounds(TargetImage) : GetExplicitCropBounds(TargetImage);
_logger.LogInformation("Cropped image size: {Width} x {Height} px", CropBounds.Width, CropBounds.Height);
return(ExecutionResult.Next());
}
private void RemoveImage_Execute(TargetImage args)
{
switch (args)
{
case TargetImage.Top:
ViewModel.Textures.Top.ClearTexture();
break;
case TargetImage.Bottom:
ViewModel.Textures.Bottom.ClearTexture();
break;
case TargetImage.FileLarge:
ViewModel.Textures.FileLarge.ClearTexture();
break;
case TargetImage.FileSmall:
ViewModel.Textures.FileSmall.ClearTexture();
break;
case TargetImage.FolderOpen:
ViewModel.Textures.FolderOpen.ClearTexture();
break;
case TargetImage.FolderClosed:
ViewModel.Textures.FolderClosed.ClearTexture();
break;
case TargetImage.TopAlt:
ViewModel.Textures.TopAlt.ClearTexture();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private Task<LoadImageResults> LoadImage_Execute(TargetImage targetImage)
{
var busyPickingFile = MainResources.Busy_PickingFile;
var busyOpeningImage = MainResources.Busy_OpeningImage;
var task = new Task<LoadImageResults>(() =>
{
BusyText = busyPickingFile;
var opfl = new OpenFileDialog
{
Filter = "Image Files|*.jpg;*.jpeg;*.png;*.bmp",
Multiselect = false
};
var dlg = opfl.ShowDialog();
LoadImageResults results = new LoadImageResults
{
Loaded = false,
Target = targetImage
};
if (!dlg.HasValue || dlg.Value)
{
BusyText = busyOpeningImage;
try
{
using (var fs = File.OpenRead(opfl.FileName))
{
BitmapImage bmp = new BitmapImage();
bmp.BeginInit();
bmp.StreamSource = fs;
bmp.CacheOption = BitmapCacheOption.OnLoad;
bmp.EndInit();
bmp.Freeze();
results.Loaded = true;
results.Image = bmp;
}
}
catch
{
// ignored
}
}
return results;
});
task.Start();
return task;
}
private Task<SaveImageResults> ExportImage_Execute(TargetImage targetImage)
{
var busyPickingFile = MainResources.Busy_PickingFile;
var busySavingImage = MainResources.Busy_SavingImage;
BitmapSource target;
switch (targetImage)
{
case TargetImage.Top:
target = ViewModel.Textures.Top.Bitmap;
break;
case TargetImage.Bottom:
target = ViewModel.Textures.Bottom.Bitmap;
break;
case TargetImage.FileLarge:
target = ViewModel.Textures.FileLarge.Bitmap;
break;
case TargetImage.FileSmall:
target = ViewModel.Textures.FileSmall.Bitmap;
break;
case TargetImage.FolderOpen:
target = ViewModel.Textures.FolderOpen.Bitmap;
break;
case TargetImage.FolderClosed:
target = ViewModel.Textures.FolderClosed.Bitmap;
break;
case TargetImage.TopAlt:
target = ViewModel.Textures.TopAlt.Bitmap;
break;
default:
throw new IndexOutOfRangeException();
}
var task = new Task<SaveImageResults>(() =>
{
BusyText = busyPickingFile;
var svfl = new SaveFileDialog
{
Filter = "PNG Files|*.png",
FileName = targetImage.ToString().ToLower()
};
var dlg = svfl.ShowDialog();
SaveImageResults results = new SaveImageResults
{
Saved = false,
Target = targetImage,
Path = svfl.FileName
};
if (!dlg.HasValue || dlg.Value)
{
BusyText = busySavingImage;
try
{
PngBitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(target));
using (var fs = File.Open(results.Path, FileMode.Create))
{
encoder.Save(fs);
results.Saved = true;
}
}
catch
{
// Ignore;
}
}
return results;
});
task.Start();
return task;
}
private void TargetImage_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
_isMousePressed = false;
TargetImage.ReleaseMouseCapture();
}
public bool IsBeingSetOrUpdated(string attributeName)
{
return(TargetImage != null && TargetImage.Contains(attributeName));
}
