public async Task <ImageSummary> PutImage(byte[] fileContent, string fileName, string contentType, string folder)
{
_log.LogInformation($"PutImage {fileName} size {fileContent.Length} bytes, contentType {contentType}, folder {folder}");
using (var stream = new MemoryStream(fileContent))
{
var summary = ImageTransform.CreateImageSummary(fileName, stream);
var request = new PutObjectRequest
{
BucketName = _options.FullImage,
Key = summary.Id,
ContentType = contentType,
InputStream = stream
};
_log.LogInformation("begin put image");
PutObjectResponse response = await _s3client.PutObjectAsync(request);
_log.LogInformation("put image completes");
//TODO can probably reuse stream
using (var outStream = new MemoryStream(fileContent))
{
await PutThumbnail(summary, outStream);
}
return(summary);
}
}
/// <summary>
/// 画像データ格納フォルダ選択エリアのドラッグEnterイベント
/// </summary>
/// <param name="sender">センダーオブジェクト</param>
/// <param name="e">イベントデータ</param>
private void ImageDirectory_DragEnter(object sender, DragEventArgs e)
{
// ドラッグされているデータが単一のフォルダかチェック
bool checkResult = IsSingleFolder(e.Data, out string path);
// ドラッグされているフォルダに画像データが存在するかチェック
if (checkResult)
{
try
{
checkResult = Directory.GetFiles(path).Any(filePath
=> ImageTransform.CanImageLoad(filePath));
}
catch (Exception ex)
when(ex is UnauthorizedAccessException ||
ex is IOException)
{
// 下記の例外が発生した場合はチェック：NGにする
// UnauthorizedAccessException
// ・呼び出し元に、必要なアクセス許可がない場合
// IOException
// ・IOエラーが発生した場合
checkResult = false;
}
}
// チェックが正常の場合ドロップを受け入れる
e.Effect = checkResult ? DragDropEffects.Move : DragDropEffects.None;
}
public static Bitmap ApplyImageModificationsToOriginal(Bitmap bitmap, List <ImageMod> mods)
{
if (bitmap == null)
{
throw new ArgumentNullException(nameof(bitmap));
}
if (mods == null)
{
throw new ArgumentNullException(nameof(mods));
}
Bitmap result = new Bitmap(bitmap);
foreach (var mod in mods)
{
// TODO: This is a little awkward
ImageModType modType;
int val1, val2, val3, val4;
mod.Get(out modType, out val1, out val2, out val3, out val4);
switch (mod.Op)
{
case ImageModType.IMG_flip:
result.RotateFlip(RotateFlipType.RotateNoneFlipX);
break;
case ImageModType.IMG_rotate90cw:
result.RotateFlip(RotateFlipType.Rotate90FlipNone);
break;
case ImageModType.IMG_rotate90ccw:
result.RotateFlip(RotateFlipType.Rotate270FlipNone);
break;
case ImageModType.IMG_brighten:
result = result.AlterBrightness(val1);
break;
case ImageModType.IMG_contrast:
result = result.EnhanceContrastMinMax((byte)val1, (byte)val2);
break;
case ImageModType.IMG_contrast2:
result = result.EnhanceContrast(val1);
break;
case ImageModType.IMG_crop:
var cropRect = new System.Drawing.Rectangle(val1, val2, val3 - val1, val4 - val2);
result = ImageTransform.CropBitmap(result, cropRect);
break;
default:
throw new NotImplementedException();
}
}
return(result);
}
/// <summary>
/// 画像データ格納フォルダ選択の選択ボタンを押下
/// </summary>
/// <param name="sender">センダーオブジェクト</param>
/// <param name="e">イベントデータ</param>
private void BtImageDirectorySelect_Click(object sender, EventArgs e)
{
// フォルダ選択ダイアログを開き、画像データが格納してあるフォルダを選択する
FolderBrowserDialog dialog;
using (dialog = new FolderBrowserDialog())
{
dialog.Description = Resources.CombineImagesDirectorySelectDialogTitle;
dialog.ShowNewFolderButton = false;
if (Directory.Exists(TxtImageDirectory.Text))
{
dialog.SelectedPath = TxtImageDirectory.Text;
}
// ダイアログを表示
if (dialog.ShowDialog() == DialogResult.OK)
{
// フォルダ選択でOKが押された場合、選択したファイルパスを取得
string folderPath = dialog.SelectedPath;
// 選択されたフォルダに画像データが存在するかチェック
try
{
if (Directory.GetFiles(folderPath).Any(filePath
=> ImageTransform.CanImageLoad(filePath)))
{
// チェックOKの場合、選択したフォルダのパスを設定する
TxtImageDirectory.Text = folderPath;
// 実行エリアを使用可能とする
PlRun.Enabled = true;
}
else
{
// チェックNGの場合、エラーメッセージを表示する
MessageBox.ShowAttention(this, Resources.CombineImagesDirectoryErrorNotImage);
}
}
catch (Exception ex)
when(ex is UnauthorizedAccessException ||
ex is IOException)
{
// 下記の例外が発生した場合はメッセージを表示する
// UnauthorizedAccessException
// ・呼び出し元に、必要なアクセス許可がない場合
// IOException
// ・IOエラーが発生した場合
string message = Resources.CombineImagesDirectoryErrorNotAccess
+ "\r\n" + ex.Message;
MessageBox.ShowAttention(this, message);
}
}
}
// 画面の表示設定を行う
SetControlDisplaySetting();
}
public void CreateThumbnail(ImageSummary summary)
{
_log.LogInformation($"Create thumbnail for {summary.Id}");
using (var inStream = File.OpenRead(GetPath(ImageType.FullImage, summary.Id)))
using (var outStream = File.OpenWrite(GetPath(ImageType.Thumbnail, summary.Id)))
{
ImageTransform.WriteThumbnail(inStream, outStream);
}
}
private void button2_Click(object sender, EventArgs e)
{
dm.SaveInMask = cbUseMask.Checked;
dm.FindPixels((int)m.Value, (double)n.Value, (double)k.Value, color.Checked);
pictureBox2.Image = ImageTransform.BoolToBitmap(dm.PollutedMask);
savedMask2 = Tools.ArrayTools.CopyArray <bool>(dm.PollutedMask);
tbLog.Text += Tools.Metrics.MatrixDifference(savedMask, savedMask2, MetricsMode.Simple);
}
/// <summary>
/// Creates and fills instance of <see cref="ImageTransformQuery"/> from URL query string values collection.
/// </summary>
/// <param name="queryString">The URL query string values collection.</param>
/// <param name="defaultTransform">The default transform.</param>
/// <returns>
/// The query instance.
/// </returns>
public static ImageTransformQuery FromQueryString(NameValueCollection queryString, ImageTransform defaultTransform)
{
var instance = new ImageTransformQuery
{
Width = (int)SmartConvert.ChangeType<uint>(queryString["width"]),
Height = (int)SmartConvert.ChangeType<uint>(queryString["height"]),
Transform = SmartConvert.ChangeType(queryString["transform"], defaultTransform)
};
return instance;
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenWaveRestApiEncoder" /> class.
/// </summary>
/// <param name="imageTransformService">The image transform service.</param>
/// <param name="imageTransformationBuilderFactory">The image transformation builder factory.</param>
/// <param name="defaultImageTransform">The image transform type that should be used if not specified in query.</param>
/// <param name="queryAuthorizer">The image transformation query authorizer.</param>
public OpenWaveRestApiEncoder(
IWebImageTransformationService imageTransformService = null,
IImageTransformationBuilderFactory imageTransformationBuilderFactory = null,
ImageTransform? defaultImageTransform = null,
IQueryAuthorizer queryAuthorizer = null)
{
ImageTransformationService = imageTransformService ?? OpenWaves.ServiceLocator.Resolve<IWebImageTransformationService>();
ImageTransformationBuilderFactory = imageTransformationBuilderFactory ?? OpenWaves.ServiceLocator.Resolve<IImageTransformationBuilderFactory>();
DefaultImageTransform = defaultImageTransform ?? Config.DefaultTransform;
QueryAuthorizer = queryAuthorizer ?? OpenWaves.ServiceLocator.Resolve<IQueryAuthorizer>();
}
public async Task <IActionResult> Get(int width = 300, int height = 300)
{
var dogApi = RestService.For <IDogApi>(Constants.BaseUrl);
var image = await dogApi.Search();
if (image.Any())
{
var imgTrans = ImageTransform.Transform(width, height, image.FirstOrDefault().url);
return(Ok(imgTrans));
}
return(Ok());
}
/// <summary>
/// キャンパスの変更設定を適用させた回転処理の元となる画像データを生成する機能を取得する
/// </summary>
/// <param name="isChangeCanvasSize">
/// キャンパスサイズを変更するかのフラグ
/// </param>
/// <param name="changeSize">
/// 変更するキャンパスサイズ（NULLを指定した場合は対角線の長さに拡大）
/// </param>
/// <param name="changeCenterPoint">
/// 変更する中心位置（NULLを指定した場合は中心位置の変更はしない）
/// </param>
/// <returns>
/// キャンパスの変更設定を適用させた回転処理の元となる画像データを生成する機能
/// </returns>
public static Func <Image, Image> GetCreateBaceImageFunc(
bool isChangeCanvasSize, Size?changeSize, Point?changeCenterPoint)
{
// 回転させる画像の元データを生成するためのファンクションを生成
Func <Image, Image> createBaceImage;
if (isChangeCanvasSize && changeCenterPoint.HasValue)
{
// サイズ変更：有、中心位置変更：有の場合
// ⇒キャンパスサイズ、中心位置を変更した画像データを使用
if (changeSize.HasValue)
{
createBaceImage = (image)
=> ImageTransform.ChangeCanvas(image, changeSize.Value, changeCenterPoint.Value);
}
else
{
// 変更するサイズに指定がない場合は、中心点を考慮した対角線の長さに拡大する
createBaceImage = (image)
=> ImageTransform.ChangeCanvasToDiagonalSize(image, changeCenterPoint.Value);
}
}
else if (isChangeCanvasSize && !changeCenterPoint.HasValue)
{
// サイズ変更：有、中心位置変更：無の場合
// ⇒キャンパスサイズのみを変更した画像データを使用
if (changeSize.HasValue)
{
createBaceImage = (image) => ImageTransform.ChangeCanvas(image, changeSize.Value);
}
else
{
// 変更するサイズに指定がない場合は対角線の長さに拡大する
createBaceImage = (image) => ImageTransform.ChangeCanvasToDiagonalSize(image);
}
}
else if (!isChangeCanvasSize && changeCenterPoint.HasValue)
{
// サイズ変更：無、中心位置変更：有の場合
// ⇒中心位置のみを変更した画像データを使用
createBaceImage = (image) => ImageTransform.ChangeCanvas(image, changeCenterPoint.Value);
}
else
{
// サイズ変更：無、中心位置変更：無の場合
// ⇒引数の画像データをそのまま使用
createBaceImage = (image) => new Bitmap(image, image.Size);
}
// 生成したファンクションを返す
return(createBaceImage);
}
/// <summary>
/// 実行時に行う、画像データ格納フォルダに画像データが存在するかチェックする
/// </summary>
/// <param name="filePaths">画像データ格納フォルダのファイルリスト</param>
/// <returns>チェック結果、チェックOK：True、NG：False</returns>
private bool RunCheckImageFileExists(string[] filePaths)
{
// 画像データ格納フォルダに画像データが存在するかチェックする
try
{
if (!filePaths.Any(imageFilePath
=> ImageTransform.CanImageLoad(imageFilePath)))
{
// チェックNGの場合、エラーメッセージを表示し処理をしない
MessageBox.ShowAttention(this, Resources.CombineImagesDirectoryErrorNotImage);
return(false);
}
return(true);
}
catch (Exception ex)
{
// 下記のエラーの場合はメッセージを表示して処理をしない
if (ex is ArgumentException ||
ex is PathTooLongException)
{
// 下記のパスが不正の場合の例外の場合は、その旨のメッセージを表示し処理しない
// ArgumentException
// ・パスとして正しくない文字を含んで入る場合
// PathTooLongException
// ・指定したパスがシステム定義の最大長を超えている場合
string message = Resources.CombineImagesDirectoryErrorIncorrectPath
+ "\r\n" + ex.Message;
MessageBox.ShowAttention(this, message);
return(false);
}
else if (ex is DirectoryNotFoundException ||
ex is UnauthorizedAccessException ||
ex is IOException)
{
// 下記のアクセスに関する例外の場合は、その旨のメッセージを表示し処理しない
// DirectoryNotFoundException:
// ・指定したディレクトリが見つからない場合
// UnauthorizedAccessException
// ・呼び出し元に、必要なアクセス許可がない場合
// IOException
// ・IOエラーが発生した場合
string message = Resources.CombineImagesDirectoryErrorNotAccess
+ "\r\n" + ex.Message;
MessageBox.ShowAttention(this, message);
return(false);
}
// 上記以外の例外の場合はそのままスローする
throw;
}
}
public string GetBase64ImageUrl(string originalUrl, ImageTransform transform = null)
{
var url = GetCachedImageUrl(originalUrl, transform);
if (url.Contains("?"))
{
return($"{url}&encoding=base64");
}
else
{
return($"{url}?encoding=base64");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenWaveRestApiEncoder" /> class.
/// </summary>
/// <param name="imageTransformService">The image transform service.</param>
/// <param name="imageTransformationBuilderFactory">The image transformation builder factory.</param>
/// <param name="defaultImageTransform">The image transform type that should be used if not specified in query.</param>
/// <param name="imageTransformationParser">The image transformation parser.</param>
public OpenWaveRestApiEncoder(
IWebImageTransformationService imageTransformService = null,
IImageTransformationBuilderFactory imageTransformationBuilderFactory = null,
ImageTransform? defaultImageTransform = null,
IImageTransformationParser imageTransformationParser = null)
{
ImageTransformationService = imageTransformService ?? OpenWaves.ServiceLocator.Resolve<IWebImageTransformationService>();
ImageTransformationBuilderFactory = imageTransformationBuilderFactory ?? OpenWaves.ServiceLocator.Resolve<IImageTransformationBuilderFactory>();
DefaultImageTransform = defaultImageTransform ?? Config.DefaultTransform;
var wrapResolver = new WrapResolver(ServiceLocatorUtils.GetCurrentResolver());
wrapResolver.Register<IImageTransformationParser>(imageTransformationParser ?? new UniversalImageTransformationParser());
ServiceLocator.SetResolver(wrapResolver);
}
/// <summary>
/// Computes a SHA1 hash for provided image transformation parameters.
/// </summary>
/// <param name="privateKey">Private key received from the image service administrator.</param>
/// <param name="width">Image width.</param>
/// <param name="height">Image height.</param>
/// <param name="transform">Image transformation mode.</param>
public string ComputeHash(string privateKey, int width, int height, ImageTransform transform)
{
var values = new[]
{
privateKey.ToLower(),
width.ToString(),
height.ToString(),
transform.ToString().ToLower()
};
var bytes = Encoding.ASCII.GetBytes(string.Join(":", values));
var sha1 = SHA1.Create();
sha1.ComputeHash(bytes);
return BitConverter.ToString(sha1.Hash).Replace("-", "").ToLower();
}
/// <summary>
/// Creates the image transform.
/// </summary>
/// <param name="typeName">Name of the type.</param>
/// <returns>An instance of the image tranform</returns>
internal static ImageTransform Create(string typeName)
{
if (string.IsNullOrEmpty(typeName))
{
throw new ArgumentNullException("typeName");
}
ImageTransform retVal = null;
ConstructorInfo constructorInfo = null;
readerWriterLockSlim.EnterUpgradeableReadLock();
try {
if (!imageTransformCache.TryGetValue(typeName, out constructorInfo))
{
Type connectorType = Type.GetType(typeName, false, true);
if (connectorType != null && connectorType.IsSubclassOf(typeof(ImageTransform)))
{
constructorInfo = connectorType.GetConstructor(Type.EmptyTypes);
if (constructorInfo == null)
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, "The given type: '{0}' does not contain a constructor that takes no arguments.", typeName);
throw new ArgumentException(errorMessage, "typeName");
}
readerWriterLockSlim.EnterWriteLock();
try {
imageTransformCache.Add(typeName, constructorInfo);
} finally {
readerWriterLockSlim.ExitWriteLock();
}
}
else
{
string errorMessage = string.Format(CultureInfo.InvariantCulture, "The given type: '{0}' can not be found or does not implement the abstract ImageTransform class.", typeName);
throw new ArgumentException(errorMessage, "typeName");
}
}
} finally {
readerWriterLockSlim.ExitUpgradeableReadLock();
}
retVal = constructorInfo.Invoke(null) as ImageTransform;
return(retVal);
}
/// <summary>
/// Shared routine to spawn UI image objects.
/// </summary>
/// <param name="parent">The parent object for the image.</param>
/// <param name="sprite">The sprite to display.</param>
/// <param name="rotate">How to rotate or flip the sprite.</param>
/// <param name="imageSize">The size to which to scale the sprite.</param>
/// <returns>The child image object.</returns>
protected static Image ImageChildHelper(GameObject parent, Sprite sprite,
ImageTransform rotate = ImageTransform.None, Vector2 imageSize = default)
{
var imageChild = PUIElements.CreateUI(parent, "Image", true,
PUIAnchoring.Beginning, PUIAnchoring.Beginning);
var rt = imageChild.rectTransform();
// The pivot is important here
rt.pivot = CENTER;
var img = imageChild.AddComponent <Image>();
img.sprite = sprite;
img.preserveAspect = true;
// Set up transform
var scale = Vector3.one;
float rot = 0.0f;
if ((rotate & ImageTransform.FlipHorizontal) != ImageTransform.None)
{
scale.x = -1.0f;
}
if ((rotate & ImageTransform.FlipVertical) != ImageTransform.None)
{
scale.y = -1.0f;
}
if ((rotate & ImageTransform.Rotate90) != ImageTransform.None)
{
rot = 90.0f;
}
if ((rotate & ImageTransform.Rotate180) != ImageTransform.None)
{
rot += 180.0f;
}
// Update transform
var transform = imageChild.rectTransform();
transform.localScale = scale;
transform.Rotate(new Vector3(0.0f, 0.0f, rot));
// Limit size if needed
if (imageSize.x > 0.0f && imageSize.y > 0.0f)
{
imageChild.SetUISize(imageSize, true);
}
return(img);
}
public async Task ReIndex()
{
foreach (var item in await BuildImageSummariesFromS3(new FilterCriteria()))
{
try
{
using (var imageStream = await GetImageStream(ImageType.FullImage, item))
{
var summary = ImageTransform.CreateImageSummary(item, imageStream);
imageStream.Position = 0;
await PutThumbnail(summary, imageStream);
}
}
catch (Exception ex)
{
_log.LogError(ex, $"Error building thumbnail for item {item}");
}
}
}
/// <summary>
/// Shared routine to spawn UI image objects.
/// </summary>
/// <param name="parent">The parent object for the image.</param>
/// <param name="sprite">The sprite to display.</param>
/// <param name="rotate">How to rotate or flip the sprite.</param>
/// <param name="imageSize">The size to which to scale the sprite.</param>
/// <returns>The child image object.</returns>
protected static Image ImageChildHelper(GameObject parent, Sprite sprite,
ImageTransform rotate = ImageTransform.None, Vector2 imageSize = default)
{
var imageChild = PUIElements.CreateUI("Image");
var img = imageChild.AddComponent <Image>();
PUIElements.SetParent(imageChild, parent);
img.sprite = sprite;
img.preserveAspect = true;
// Set up transform
var scale = Vector3.one;
float rot = 0.0f;
if ((rotate & ImageTransform.FlipHorizontal) != ImageTransform.None)
{
scale.x = -1.0f;
}
if ((rotate & ImageTransform.FlipVertical) != ImageTransform.None)
{
scale.y = -1.0f;
}
if ((rotate & ImageTransform.Rotate90) != ImageTransform.None)
{
rot = 90.0f;
}
if ((rotate & ImageTransform.Rotate180) != ImageTransform.None)
{
rot += 180.0f;
}
// Update transform
var transform = imageChild.rectTransform();
transform.localScale = scale;
transform.Rotate(new Vector3(0.0f, 0.0f, rot));
// Limit size if needed
if (imageSize.x > 0.0f && imageSize.y > 0.0f)
{
PUIElements.SetSizeImmediate(imageChild, imageSize);
}
return(img);
}
private void ApplyButton_Click(object sender, EventArgs e)
{
float[] transParam;
transParam = new float[5];
transParam[0] = float.Parse(ScaleXTB.Text);
transParam[1] = float.Parse(ScaleYTB.Text);
transParam[2] = float.Parse(RotateTB.Text);
transParam[3] = float.Parse(ShearXTB.Text);
transParam[4] = float.Parse(ShearYTB.Text);
ImageTransform IT = new ImageTransform(transParam);
try
{
Bitmap B = IT.GeometricLinearTransform(sourceBitmap);
AfterBox.Image = B;
}
catch
{
MessageBox.Show("Image can't be Transformed !", "Error", MessageBoxButtons.OK);
}
}
/// <summary>
/// Debug code to make sure our unit warps work as expected.
/// </summary>
private static void testWarps()
{
Console.WriteLine("Start testWarps()");
List <Bitmap> imgs = Congeal.Util.getBitmaps(m_dirDevin, m_bmPattern);
Bitmap bm = imgs[0];
ImageTransform it = new ImageTransform(bm);
//AvgImage ai = new AvgImage(
string output = @"C:\Users\sketchers\Documents\Trunk\Code\Util\TestCongealing\TestCongealing\bin\Debug\WarpTests\";
it.writeImage(output + "original.bmp");
// UnitWarps warps = new UnitWarps(bm.Width, bm.Height);
UnitWarps warps = new UnitWarps(bm.Width, bm.Height, 16, (float)1.25, (float).8, 30);
ImageTransform test = new ImageTransform(bm);
//it.append(warps.warps[2]);
//it.append(warps.warps[4]);
//it.writeImage(output + "scaleShear.bmp");
//test.append(warps.warps[4]);
//test.append(warps.warps[2]);
//test.writeImage(output + "shearScale.bmp");
for (int i = 0; i < warps.warps.Length; i++)
{
it.append(warps.warps[i]);
it.writeImage(output + i + "warp.bmp");
it.undoAppend();
it.append(warps.warps[i].Inverse);
it.writeImage(output + i + "InverseWarp.bmp");
it.undoAppend();
}
Console.WriteLine("End testWarps()");
}
// data:[<media type>][;charset=<character set>][;base64],<data>
// data:image/jpeg;charset=utf-8;base64,
public async Task <string> GetBase64ImageContentAsync(string originalUrl, ImageTransform transform = null)
{
var url = GetCachedImageUrl(originalUrl, transform);
if (!String.IsNullOrEmpty(url))
{
return(await Cache.GetOrCreate("IMAGE_BASE64_" + url, async (c) =>
{
var response = await _Client.GetAsync(url).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
byte[] imageArray = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
if (imageArray.Length > 0)
{
string base64ImageRepresentation = Convert.ToBase64String(imageArray);
var medaType = "image/jpeg";
if (originalUrl.Contains(".png"))
{
medaType = "image/png";
}
else if (originalUrl.Contains(".gif"))
{
medaType = "image/gif";
}
// Cache in memory for up to a month
c.AbsoluteExpiration = DateTimeOffset.Now.AddDays(30);
return $"data:{medaType};charset=utf-8;base64,{base64ImageRepresentation}";
}
}
// Don't cache failed responses
c.AbsoluteExpiration = DateTimeOffset.Now;
return "";
}));
}
return("");
}
private async Task PutThumbnail(ImageSummary item, MemoryStream imageStream)
{
_log.LogInformation($"PutThumbnail {item.Id}");
using (var outStream = new MemoryStream())
{
_log.LogInformation($"Create thumbnail");
ImageTransform.WriteThumbnail(imageStream, outStream);
var request = new PutObjectRequest
{
BucketName = _options.ThumbNail,
Key = item.Id,
ContentType = "image/jpeg",
InputStream = outStream
};
_log.LogInformation($"Begin S3 Put operation");
PutObjectResponse response = await _s3client.PutObjectAsync(request);
_log.LogInformation($"S3 Put operation completes");
}
await PutImageRecord(item);
}
private void UpdateCanvas()
{
Bitmap dstImage = new Bitmap(srcImage.Width, srcImage.Height);
ImageTransform it = new ImageTransform();
Effect e = new Effect();
if (support == SupportMethod.Rotate)
{
dstImage = it.Rotate((Bitmap)srcImage.Clone(), this.Angle);
this.srcImage = dstImage;
return;
}
switch (support)
{
case SupportMethod.RadialBlur:
dstImage = e.RadialBlur((Bitmap)srcImage.Clone(), this.Angle);
break;
case SupportMethod.Emboss:
dstImage = e.Emboss((Bitmap)srcImage.Clone(), this.Angle);
break;
case SupportMethod.Relief:
dstImage = e.Relief((Bitmap)srcImage.Clone(), this.Angle);
break;
case SupportMethod.FindEdge:
dstImage = e.FindEdge((Bitmap)srcImage.Clone(), this.Angle);
break;
default:
break;
}
this.panel1.BackgroundImage = dstImage;
this.FinalImage = (Bitmap)dstImage.Clone();
}
static void Main(string[] args)
{
if (args.Count() == 0)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
else
{
var myImage = new MyImage();
myImage.Bitmap = new Bitmap(args[0]);
var dataMining = new DataMining();
//string log = string.Format("Файл: {0}\nМетод: {1}\nШаблон: {2}\nОбрезать пиксели: {3}\nДостоверность, %: {4}\nДлина шаблона: {5}\nПроцент загрязнения: {6}\nИспользование маски: {7}\n", args);
dataMining.CollectionMethod = int.Parse(args[1]);
dataMining.Template = int.Parse(args[2]);
dataMining.CropPixels = int.Parse(args[3]) == 1;
dataMining.MaxAccuracy = int.Parse(args[4]);
dataMining.MaxDepth = int.Parse(args[5]);
int pollutedPercent = 0;
if (int.TryParse(args[6], out pollutedPercent))
{
dataMining.PollutePercent = pollutedPercent;
}
else
{
dataMining.PollutePercent = -1;
}
dataMining.UseMask = int.Parse(args[7]) == 1;
dataMining.WSM = int.Parse(args[8]) == 1;
dataMining.UseLimit = int.Parse(args[9]) == 1;
dataMining.MyImage = myImage;
//dataMining.UpdateLog += (o, eo) =>
//{
// log += eo.Object;
//};
string metricsOrig = dataMining.GetMetricsText(MetricsMode.CSVSimple);
if (dataMining.PollutePercent != -1)
{
dataMining.Pollute(int.Parse(args[10]) == 1);
dataMining.MyImage.Bitmap.Save(args[0] + "_polluted.png", ImageFormat.Png);
}
else
{
var pollutedImage = new MyImage();
pollutedImage.Bitmap = new Bitmap(args[6]);
for (int i = 0; i < pollutedImage.ImageWidth; i++)
{
for (int j = 0; j < pollutedImage.ImageHeight; j++)
{
dataMining.MyImage.ImageBytes[i, j] = pollutedImage.ImageBytes[i, j];
}
}
dataMining.PollutedImage = Tools.ArrayTools.CopyArray <int>(pollutedImage.ImageBytes);
dataMining.PollutedMask = new bool[pollutedImage.ImageWidth, pollutedImage.ImageHeight];
dataMining.PollutedMaskOriginal = new bool[pollutedImage.ImageWidth, pollutedImage.ImageHeight];
}
string metricsPolluted = dataMining.GetMetricsText(MetricsMode.CSVSimple);
dataMining.CreatePairs();
if (!dataMining.UseMask)
{
dataMining.FindPixels();
}
bool[,] maskOriginal;
bool[,] maskStatistics;
dataMining.GetMasks(out maskOriginal, out maskStatistics);
bool[,] maskMiss = new bool[maskOriginal.GetLength(0), maskOriginal.GetLength(1)];
bool[,] maskFalse = new bool[maskOriginal.GetLength(0), maskOriginal.GetLength(1)];
if (maskStatistics != null)
{
for (int i = 0; i < maskOriginal.GetLength(0); i++)
{
for (int j = 0; j < maskOriginal.GetLength(1); j++)
{
maskMiss[i, j] = maskOriginal[i, j] && !maskStatistics[i, j];
maskFalse[i, j] = !maskOriginal[i, j] && maskStatistics[i, j];
}
}
}
if (maskStatistics != null)
{
ImageTransform.BoolToBitmap(maskStatistics).Save(args[0] + "_maskStatistics.png", ImageFormat.Png);
}
ImageTransform.BoolToBitmap(maskOriginal).Save(args[0] + "_maskOriginal.png", ImageFormat.Png);
ImageTransform.BoolToBitmap(maskMiss).Save(args[0] + "_maskMiss.png", ImageFormat.Png);
ImageTransform.BoolToBitmap(maskFalse).Save(args[0] + "_maskFalse.png", ImageFormat.Png);
dataMining.RestoreImage();
dataMining.MyImage.Bitmap.Save(args[0] + "_restored.png", ImageFormat.Png);
string metricsRestored = dataMining.GetMetricsText(MetricsMode.CSVSimple);
string log = string.Empty;
if (!File.Exists("Statistics.csv"))
{
log += string.Join(Tools.Consts.CSVDivider, "File", "Method", "Template", "Crop pixels", "Accuracy", "Transaction length", "Pollution percent", "Use mask", "WSM", "Limit", "SP") + Tools.Consts.CSVDivider;
log += string.Join(Tools.Consts.CSVDivider, "MM Orig", "MSE Orig", "DON Orig", "MM Pollute", "MSE Pollute", "DON Pollute", "MM Restored", "MSE Restored", "DON Restored", "Polluted count", "Find", "Miss", "False") + "\n";
}
log += string.Join(Tools.Consts.CSVDivider, args) + Tools.Consts.CSVDivider;
log += string.Join(Tools.Consts.CSVDivider, metricsOrig, metricsPolluted, metricsRestored) + Tools.Consts.CSVDivider;
log += dataMining.GetPollutionStatistics();
StreamWriter fs = new StreamWriter("Statistics.csv", true);
fs.WriteLine(log);
fs.Close();
//StreamWriter fs = new StreamWriter(args[0] + "_log.txt", false);
//fs.WriteLine(log);
//fs.Close();
}
}
private async Task PerformImageTransition(Image currentImage, Image nextImage, ImageViewApplicationSettings.ChangeImageAnimation animation, int animationTime)
{
const int sleepTime = 1;
_imageTransitionRunning = true;
await Task.Run(() =>
{
var stopwatch = new Stopwatch();
stopwatch.Start();
while (stopwatch.ElapsedMilliseconds <= animationTime)
{
long elapsedTime = stopwatch.ElapsedMilliseconds;
float factor = stopwatch.ElapsedMilliseconds / (float)animationTime;
Image transitionImage;
switch (animation)
{
case ImageViewApplicationSettings.ChangeImageAnimation.SlideLeft:
transitionImage = ImageTransform.OffsetImagesHorizontal(currentImage, nextImage,
new Size(pictureBox1.Width, pictureBox1.Height), factor, false);
break;
case ImageViewApplicationSettings.ChangeImageAnimation.SlideRight:
transitionImage = ImageTransform.OffsetImagesHorizontal(nextImage, currentImage,
new Size(pictureBox1.Width, pictureBox1.Height), factor, true);
break;
case ImageViewApplicationSettings.ChangeImageAnimation.SlideDown:
transitionImage = ImageTransform.OffsetImagesVertical(nextImage, currentImage,
new Size(nextImage.Width, nextImage.Height), factor, true);
break;
case ImageViewApplicationSettings.ChangeImageAnimation.SlideUp:
transitionImage = ImageTransform.OffsetImagesVertical(currentImage, nextImage,
new Size(Math.Max(nextImage.Width, currentImage.Width), nextImage.Height), factor, false);
break;
case ImageViewApplicationSettings.ChangeImageAnimation.FadeIn:
int width = nextImage.Width;
int height = nextImage.Height;
var nextImageBitmap = new Bitmap(nextImage, new Size(width, height));
transitionImage = ImageTransform.SetImageOpacity(nextImageBitmap, factor);
break;
default:
return;
}
if (!Visible)
{
return;
}
try
{
pictureBox1.Image = transitionImage.Clone() as Image;
}
catch (Exception ex)
{
Log.Error(ex, Resources.Failed_to_set_transition_image_over_current_image_);
MessageBox.Show(Resources.Failed_to_set_transition_image_over_current_image_,
Resources.Error_loading_new_image, MessageBoxButtons.OK, MessageBoxIcon.Error);
_imageTransitionRunning = false;
return;
}
finally
{
transitionImage.Dispose();
}
elapsedTime = stopwatch.ElapsedMilliseconds - elapsedTime;
if (sleepTime - elapsedTime > 0)
{
Thread.Sleep(Convert.ToInt32(sleepTime - elapsedTime));
}
}
stopwatch.Stop();
Log.Verbose("Image transition finished after " + stopwatch.ElapsedMilliseconds + " ms");
Invoke(new EventHandler(OnImageLoadComplete), this, new EventArgs());
});
pictureBox1.Image = nextImage.Clone() as Image;
_imageTransitionRunning = false;
}
public string GetCachedImageUrl(string originalUrl, ImageTransform transform = null)
{
if (!string.IsNullOrEmpty(originalUrl))
{
var sanityQueryParams = new List <string>();
var cacheQueryParams = new List <string>();
if (transform != null)
{
if (transform.Width.HasValue && transform.Width.Value > 0)
{
sanityQueryParams.Add($"w={transform.Width.Value}");
cacheQueryParams.Add($"width={transform.Width.Value}");
}
if (transform.Height.HasValue && transform.Height.Value > 0)
{
sanityQueryParams.Add($"h={transform.Height.Value}");
cacheQueryParams.Add($"height={transform.Height.Value}");
}
if (transform.MaxWidth.HasValue && transform.MaxWidth.Value > 0)
{
sanityQueryParams.Add($"max-w={transform.MaxWidth.Value}");
cacheQueryParams.Add($"maxwidth={transform.MaxWidth.Value}");
}
if (transform.MaxHeight.HasValue && transform.MaxHeight.Value > 0)
{
sanityQueryParams.Add($"max-h={transform.MaxHeight.Value}");
cacheQueryParams.Add($"maxheight={transform.MaxHeight.Value}");
}
if (transform.MinWidth.HasValue && transform.MinWidth.Value > 0)
{
sanityQueryParams.Add($"min-w={transform.MinWidth.Value}");
cacheQueryParams.Add($"minwidth={transform.MinWidth.Value}");
}
if (transform.MinHeight.HasValue && transform.MinHeight.Value > 0)
{
sanityQueryParams.Add($"min-h={transform.MinHeight.Value}");
cacheQueryParams.Add($"minheight={transform.MinHeight.Value}");
}
if (transform.Blur.HasValue)
{
sanityQueryParams.Add($"blur={transform.Blur.Value}");
}
if (!string.IsNullOrEmpty(transform.BackgroundColor))
{
sanityQueryParams.Add($"bg={Uri.EscapeDataString(transform.BackgroundColor.TrimStart('#'))}");
cacheQueryParams.Add($"bgcolor={Uri.EscapeDataString(transform.BackgroundColor.TrimStart('#'))}");
}
switch (transform.Mode)
{
case ImageTransformMode.Crop:
{
sanityQueryParams.Add($"fit=crop");
cacheQueryParams.Add($"mode=crop");
break;
}
case ImageTransformMode.Pad: //clip
{
if (!string.IsNullOrEmpty(transform.BackgroundColor))
{
sanityQueryParams.Add($"fit=clip");
}
else
{
sanityQueryParams.Add($"fit=fill");
}
cacheQueryParams.Add($"mode=pad");
break;
}
case ImageTransformMode.Max:
{
sanityQueryParams.Add($"fit=fillmax");
cacheQueryParams.Add($"mode=max");
break;
}
case ImageTransformMode.Carve:
{
sanityQueryParams.Add($"crop=entropy"); //Sort of...
cacheQueryParams.Add($"mode=carve");
break;
}
case ImageTransformMode.Stretch:
{
sanityQueryParams.Add($"fit=scale");
cacheQueryParams.Add($"mode=stretch");
break;
}
}
}
var isSanityImage = originalUrl.IndexOf("sanity.io") != -1;
var sourceUrl = originalUrl;
if (isSanityImage)
{
// Pass parameters to sanity
if (sanityQueryParams.Count > 0)
{
sourceUrl += (sourceUrl.Contains("?") ? "&" : "?") + sanityQueryParams.Aggregate((c, n) => c + "&" + n);
}
}
var cacheUrl = Options.CacheServerPath + "?image=" + Uri.EscapeDataString(sourceUrl);
if ((!isSanityImage || (transform != null && transform.Mode == ImageTransformMode.Carve)) && cacheQueryParams.Count > 0)
{
cacheUrl += "&" + cacheQueryParams.Aggregate((c, n) => c + "&" + n);
}
return(cacheUrl);
}
return(originalUrl);
}
/// <summary>
/// Does all the setup, creates a Designation class from a list of gates, and calls Designation.train();
/// </summary>
/// <param name="dirs"></param>
/// <param name="testSymbols"></param>
/// <returns></returns>
private static List <Designation> doTraining(List <string> dirs, out List <Sketch.Sketch> testSymbols)
{
string symbolType;
List <Designation> designations = new List <Designation>();
testSymbols = new List <Sketch.Sketch>(dirs.Count);
//For partial gate recog
// List<Sketch.Sketch> nandGates = Congeal.Util.getSketches(m_NandDir, m_xmlPattern);
foreach (string dir in dirs)
{
List <Sketch.Sketch> sketches = Congeal.Util.getSketches(dir, m_xmlPattern);
//The 3rd sketch gets pulled out later as a testing sketch.
List <Sketch.Sketch> two = new List <Sketch.Sketch>();
for (int i = 0; i < 7; i++)
{
two.Add(sketches[i]);
}
//sketches = two;
//sketches.AddRange(nandGates);
// List<Sketch.Sketch> sketches = Congeal.Util.getSketches(dir, "*.jnt");
//List<Bitmap> bitmaps = Util.getBitmaps(dir, m_bmPattern);
//Get the name of the folder containing that set of training data
//Which will usually serve as a decent name for the designation.
symbolType = dir.Substring(dir.LastIndexOf('\\') + 1);
//DEBUG
// write input bitmaps to file
List <Bitmap> bitmaps = Util.sketchToBitmap(64, 64, sketches);
for (int i = 0; i < bitmaps.Count; i++)
{
Bitmap bm = new Bitmap(bitmaps[i], 128, 128);
ImageTransform it = new ImageTransform(bm);
it.writeImage(String.Format("inputs\\input_{0}{1}.bmp", symbolType, i));
}
if (sketches != null && sketches.Count > 0)
{
//Pull out the last sketch for testing
Sketch.Sketch s = sketches[sketches.Count - 1];
testSymbols.Add(s);
sketches.RemoveAt(sketches.Count - 1);
Designation d = new Congeal.Designation(width, height, sketches, symbolType);
System.Console.WriteLine("training: " + symbolType);
d.train();
designations.Add(d);
}
}
return(designations);
}
/// <summary>
/// 指定されたパスの画像を連結し、Gifを生成する処理を開始する
/// </summary>
/// <param name="imageFilePaths">
/// 画像ファイルのパス配列
/// （配列の順番で連結する、
/// 指定されたパスのファイルが画像ファイルでない場合、そのファイルは無視する）
/// </param>
/// <param name="frameRate">
/// 生成するGifのフレームレート
/// </param>
/// <exception cref="ArgumentNullException">
/// 引数の画像ファイルのパス配列（<paramref name="imageFilePaths"/>）がNULLの場合に発生
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// 引数のフレームレート（<paramref name="frameRate"/>）が 0以下の値の場合に発生
/// </exception>
/// <exception cref="ArgumentException">
/// 変換処理で生成したGifファイルの保存先パス（<see cref="SavePath"/>）に
/// <see cref="Path.GetInvalidPathChars"/> で定義される無効な文字が含まれている場合に発生
/// </exception>
/// <exception cref="NotSupportedException">
/// 変換処理で生成したGifファイルの保存先パス（<see cref="SavePath"/>）に
/// ドライブラベル（C:\）の一部ではないコロン文字（:）が含まれている場合
/// </exception>
/// <exception cref="IOException">
/// 変換処理で生成したGifファイルの保存先パス（<see cref="SavePath"/>）が以下の場合に発生する
/// ・保存先パスがシステム定義の最大長を超えている場合
/// （Windowsでは、パスは 248 文字未満、ファイル名は 260 文字未満にする必要がある）
/// [<see cref="PathTooLongException"/>]
/// ・保存先パスが示すディレクトリが正しくない場合
/// (マップされていないドライブ名が指定されている場合等)
/// [<see cref="DirectoryNotFoundException"/>]
/// ・I/O エラーが発生した場合
/// [<see cref="IOException"/>]
/// </exception>
/// <exception cref="UnauthorizedAccessException">
/// 変換処理で生成したGifファイルの保存先パス（<see cref="SavePath"/>）において、
/// 隠しファイル等のアクセスできないファイルが既に存在している場合に発生
/// </exception>
/// <exception cref="System.Security.SecurityException">
/// 呼び出し元に、必要なアクセス許可がない場合に発生
/// </exception>
/// <exception cref="GifEncoderException">
/// Gifデータへのエンコードに失敗した場合に発生
/// </exception>
/// <returns>処理が正常終了した場合 True、中断した場合 False</returns>
public bool StartCombineImages(string[] imageFilePaths, decimal frameRate)
{
// 引数チェック
if (imageFilePaths == null)
{
throw new ArgumentNullException(nameof(imageFilePaths));
}
else if (frameRate < 0)
{
throw new ArgumentOutOfRangeException(
paramName: nameof(frameRate),
actualValue: frameRate,
message: string.Format(
CultureInfo.InvariantCulture,
CommonMessage.ArgumentOutOfRangeExceptionMessageFormatOrLess,
0));
}
// 変換処理を実行する
try
{
// 実行中フラグを ON にする
IsRunningCombineImages = true;
// Gifエンコーダー生成
GifEncoder gifEncoder;
using (gifEncoder = new GifEncoder(SavePath, true, 0))
{
// 都度都度保存する
gifEncoder.IsEachTimeSave = true;
// 設定するディレイ用のパラメータの初期値を設定
int remainder = 0;
int delay;
// イメージデータを読み込みGifエンコーダに追加していく
int count = 1;
foreach (string imagePath in imageFilePaths)
{
// 実行中でない場合、処理を中断する
if (!IsRunningCombineImages)
{
return(false);
}
// 読み込み可能な画像データのみ追加していく
Image image = null;
try
{
if (ImageTransform.TryImageLoad(imagePath, out image))
{
// 設定するディレイを計算
delay = decimal.ToInt32((GifEncoder.GifDelayUnit + remainder) / frameRate);
remainder = decimal.ToInt32((GifEncoder.GifDelayUnit + remainder) % frameRate);
// 画像データをGifに追加
try
{
gifEncoder.AddImage(image, (short)delay);
}
catch (ExternalException)
{
// 画像データ不正のエラーの場合は無視する
}
}
}
finally
{
// 読み込んだ画像リソースの解放
image?.Dispose();
}
// 進捗を進める
int progressRate = count * 100 / imageFilePaths.Length;
ProgressAction?.Invoke(progressRate);
count++;
}
// 生成したGifを保存する
gifEncoder.Save();
}
// 正常終了：True を返す
return(true);
}
finally
{
// 実行中フラグを OFF にする
IsRunningCombineImages = false;
}
}
/// <summary>
/// 回転させた画像データのGifファイルを作成する
/// </summary>
/// <param name="baceImage">
/// 回転させる元となる画像データ
/// </param>
/// <param name="rotateInfos">
/// 回転情報リスト
/// </param>
/// <param name="isRoop">
/// ループするかのフラグ
/// </param>
/// <param name="roopCount">
/// ループする場合のループ回数（0以下場合は無限にループする）
/// </param>
/// <param name="isPreview">
/// プレビューモードかのフラグ
/// </param>
/// <param name="isOutputPng">
/// Gifを作成する過程で生成したPngファイルを保存するかのフラグ
/// </param>
/// <param name="savePath">
/// 生成したGifの保存先のパス
/// </param>
/// <param name="pngDirectoryPath">
/// Gifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// </param>
/// <param name="previewAction">
/// プレビュー表示処理を行うメソッド
/// </param>
/// <param name="progressAction">
/// 進捗率の表示を行うメソッド（当メソッドでは0～100%の値を設定する）
/// </param>
/// <exception cref="ArgumentNullException">
/// 引数が以下の場合に発生する
/// ・引数の回転させる元となる画像データ（<paramref name="baceImage"/>）がNULLの場合
/// ・引数の回転情報リスト（<paramref name="rotateInfos"/>）がNULLの場合
/// ・Gifファイルを保存する場合（※1）で、引数の生成したGifの保存先のパス
/// （<paramref name="savePath"/>）がNULLの場合
/// ・Gifを作成する過程で生成したPngファイルを保存する場合（※2）で、
/// 引数のGifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// （<paramref name="pngDirectoryPath"/>）がNULLの場合
/// ※1：引数のプレビューモードかのフラグ（<paramref name="isPreview"/>）が False の場合
/// ※2：引数のプレビューモードかのフラグ（<paramref name="isPreview"/>）が False の場合
/// かつ、引数のGifを作成する過程で生成したPngファイルを保存するかのフラグ
/// （<paramref name="isOutputPng"/>）が True の場合
/// </exception>
/// <exception cref="ArgumentException">
/// 以下の引数が空文字 または、<see cref="Path.GetInvalidPathChars"/> で定義される
/// 無効な文字が含まれている場合に発生
/// ・生成したGifの保存先のパス（<paramref name="savePath"/>）
/// ・Gifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// （<paramref name="pngDirectoryPath"/>）
/// </exception>
/// <exception cref="NotSupportedException">
/// 以下の引数にドライブラベル（C:\）の一部ではないコロン文字（:）が含まれている場合
/// ・生成したGifの保存先のパス（<paramref name="savePath"/>）
/// ・Gifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// （<paramref name="pngDirectoryPath"/>）
/// </exception>
/// <exception cref="IOException">
/// 下記の場合に発生
/// 1. 以下の引数が示すディレクトリが正しくない場合
/// （マップされていないドライブ名が指定されている場合等）
/// ・生成したGifの保存先のパス（<paramref name="savePath"/>）
/// ・Gifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// （<paramref name="pngDirectoryPath"/>）
/// [<see cref="DirectoryNotFoundException"/>]
/// 2. 以下の引数がシステム定義の最大長を超えている場合
/// （Windowsでは、パスは248文字以下、ファイル名は260文字以下にする必要がある）
/// ・生成したGifの保存先のパス（<paramref name="savePath"/>）
/// ・Gifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// （<paramref name="pngDirectoryPath"/>）
/// [<see cref="PathTooLongException"/>]
/// 3. 以下の場合に発生する
/// ・Gifを作成する過程で生成したPngファイルを保存するディレクトリパス
/// （<paramref name="pngDirectoryPath"/>）がファイル名となっている または、
/// 指定されているネットワーク名が不明の場合
/// ・I/O エラーが発生した場合
/// [<see cref="IOException"/>]
/// </exception>
/// <exception cref="UnauthorizedAccessException">
/// 以下の場合に発生する
/// ・生成したGifの保存先のパス（<paramref name="savePath"/>）において、
/// 隠しファイル等のアクセスできないファイルが既に存在している場合に発生
/// ・呼び出し元に、必要なアクセス許可がない場合に発生
/// </exception>
/// <exception cref="System.Security.SecurityException">
/// 呼び出し元に、必要なアクセス許可がない場合に発生
/// </exception>
/// <exception cref="System.Runtime.InteropServices.ExternalException">
/// 引数の回転させる元となる画像データ（<paramref name="baceImage"/>）を回転させた画像データが、
/// 正しくないイメージ形式の場合に発生
/// </exception>
/// <exception cref="Exception">
/// 引数の回転させる元となる画像データ（<paramref name="baceImage"/>）から
/// <see cref="Bitmap"/> オブジェクトが生成できない場合に発生
/// （インデックス付きピクセル形式かの形式が定義されていない場合等）
/// </exception>
/// <exception cref="MisaCommon.Exceptions.GifEncoderException">
/// Gifデータへのエンコードに失敗した場合に発生
/// </exception>
private static void CreateRotateGifFile(
Image baceImage,
IList <RotateInfo> rotateInfos,
bool isRoop,
short roopCount,
bool isPreview,
bool isOutputPng,
string savePath,
string pngDirectoryPath,
Action <Image> previewAction,
Action <int> progressAction)
{
// NULLチェック
if (baceImage == null)
{
throw new ArgumentNullException(nameof(baceImage));
}
else if (rotateInfos == null)
{
throw new ArgumentNullException(nameof(rotateInfos));
}
else if (!isPreview && savePath == null)
{
throw new ArgumentNullException(nameof(savePath));
}
else if (!isPreview && isOutputPng && pngDirectoryPath == null)
{
throw new ArgumentNullException(nameof(pngDirectoryPath));
}
// Gifファイルの保存先のファイルパスを設定する
string saveGifFilePath = savePath;
// プレビューモードでない場合
// 拡張子が gif か判定し、gif でなければ .gif を追加する
if (!isPreview)
{
string extension = Path.GetExtension(savePath);
if (!extension.ToUpperInvariant().Equals(".gif".ToUpperInvariant(), StringComparison.Ordinal))
{
// 拡張子がGifの形式でない場合、
// Gifの保存先のパスに「.gif」の拡張子を追加する
saveGifFilePath = savePath + ".gif";
}
}
// Gifエンコーダーを宣言
GifEncoder gifEncoder = null;
try
{
// プレビューモードでない場合、Gifエンコーダーを生成する
if (!isPreview)
{
gifEncoder = new GifEncoder(saveGifFilePath, isRoop, roopCount)
{
// メモリ節約のため都度保存モードを ON にする
IsEachTimeSave = true
};
}
// ループ処理で使用するストップウォッチオブジェクトを生成
Stopwatch stopwatch = new Stopwatch();
// 回転情報リストでループを行い回転させた画像を作成し、
// Gif形式にエンコードしていく
int count = 1;
foreach (RotateInfo rotateInfo in rotateInfos)
{
// 中断しているか判定
if (IsStop)
{
// 処理を中断する
return;
}
// ストップウオッチをスタート
stopwatch.Start();
// 回転した画像データを生成
using (Image rotateImage = ImageTransform.RotateImage(baceImage, rotateInfo.Angle))
{
// 画像を表示
previewAction?.Invoke(rotateImage);
// プレビュー処理でない場合、ファイルの生成に関する処理を行う
if (!isPreview)
{
// Gifエンコーダにデータを追加する
short delay = rotateInfo.Delay < 0 ? (short)0 : rotateInfo.Delay;
gifEncoder.AddImage(rotateImage, delay);
// Gifを作成する過程で生成したPngファイルを保存する場合、保存処理を行う
if (isOutputPng)
{
SavePng(rotateImage, pngDirectoryPath, savePath, count);
}
}
}
// ストップウオッチをストップ
stopwatch.Stop();
// 経過時間がディレイ（10ミリ秒単位）に満たない場合はその分待つ
int sleepTime = (rotateInfo.Delay * 10) - (int)stopwatch.ElapsedMilliseconds;
if (sleepTime > 0)
{
Thread.Sleep(sleepTime);
}
// ストップウオッチをリセット
stopwatch.Reset();
// 進捗を進める
// （ループ前後の処理で20％とっているため、ループ処理では残りの80％に対する進捗率を出す）
int progressRate = (int)Math.Truncate(count / (decimal)rotateInfos.Count * 80);
// 進捗を表示
progressAction?.Invoke(progressRate + 10);
// カウントをインクリメント
count++;
}
// 進捗を90％
progressAction?.Invoke(90);
// 生成したGifデータの保存を行う
gifEncoder?.Save();
}
finally
{
// Gifエンコーダを破棄する
gifEncoder?.Dispose();
}
}
public Keyframe(long tick, float opacity, Vector2 position, AngleF rotation, Vector2 scale)
{
Tick = tick;
Opacity = opacity;
_transform = new ImageTransform(position, rotation, scale);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
else
{
if (args[0] == "/s")
{
var myImage = new MyImage();
myImage.Bitmap = new Bitmap(args[1]);
var dm = new DecisionMethods(myImage);
dm.SaveInMask = true;
dm.Pollute(decimal.Parse(args[2]), false);
var savedMask = Tools.ArrayTools.CopyArray <bool>(dm.PollutedMask);
dm.FindPixels(int.Parse(args[3]), double.Parse(args[4].Replace(".", ",")), double.Parse(args[5].Replace(".", ",")), int.Parse(args[6]) == 1);
var savedMask2 = Tools.ArrayTools.CopyArray <bool>(dm.PollutedMask);
bool addHeader = !File.Exists("Statistics_Mask.csv");
string log = string.Empty;
StreamWriter fs = new StreamWriter("Statistics_Mask.csv", true);
if (addHeader)
{
log += string.Join(Tools.Consts.CSVDivider, "File", "Pollution percent", "M", "N", "K", "Use color", "Use mask", "MR", "NR", "Broken", "Found", "Match", "Not found", "Wrong found", "MM Orig", "MSE Orig", "DON Orig", "MM Pollute", "MSE Pollute", "DON Pollute", "MM Restored", "MSE Restored", "DON Restored") + "\n";
}
log += string.Join(Tools.Consts.CSVDivider, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]) + Tools.Consts.CSVDivider;
log += string.Join(Tools.Consts.CSVDivider, Tools.Metrics.MatrixDifference(savedMask, savedMask2, MetricsMode.CSVSimple));
fs.WriteLine(log);
fs.Close();
}
else if (args[0] == "/r")
{
// Initialize
var myImage = new MyImage();
myImage.Bitmap = new Bitmap(args[1]);
var dm = new DecisionMethods(myImage);
var metricsOrig = dm.GetMetrics(MetricsMode.CSVSimple);
// Pollute
dm.SaveInMask = true;
dm.Pollute(decimal.Parse(args[2]), false);
var savedMask = Tools.ArrayTools.CopyArray <bool>(dm.PollutedMask);
dm.MyImage.Bitmap.Save(args[1] + "_polluted.png", ImageFormat.Png);
var metricsPolluted = dm.GetMetrics(MetricsMode.CSVSimple);
// Find Pixels
dm.SaveInMask = int.Parse(args[7]) == 1;
dm.FindPixels(int.Parse(args[3]), double.Parse(args[4].Replace(".", ",")), double.Parse(args[5].Replace(".", ",")), int.Parse(args[6]) == 1);
var savedMask2 = Tools.ArrayTools.CopyArray <bool>(dm.PollutedMask);
ImageTransform.BoolToBitmap(dm.PollutedMask).Save(args[1] + "_mask.png", ImageFormat.Png);
// Restore
var restoredImage = dm.RestorePixels(int.Parse(args[8]), int.Parse(args[9]));
var metricsRestored = Tools.Metrics.GetUnifiedMetrics(restoredImage, MetricsMode.CSVSimple);
restoredImage.Bitmap.Save(args[1] + "_restore.png", ImageFormat.Png);
var restoredImageOld = dm.RestorePixelsOld(4);
var metricsRestoredOld = Tools.Metrics.GetUnifiedMetrics(restoredImage, MetricsMode.CSVSimple);
restoredImageOld.Bitmap.Save(args[1] + "_restoreOld.png", ImageFormat.Png);
bool addHeader = !File.Exists("Statistics_Restore.csv");
string log = string.Empty;
StreamWriter fs = new StreamWriter("Statistics_Restore.csv", true);
if (addHeader)
{
log += string.Join(Tools.Consts.CSVDivider, "File", "Pollution percent", "M", "N", "K", "Use color", "Use mask", "MR", "NR", "Broken", "Found", "Match", "Not found", "Wrong found", "MM Orig", "MSE Orig", "DON Orig", "MM Pollute", "MSE Pollute", "DON Pollute", "MM Restored", "MSE Restored", "DON Restored", "MM Restored Old", "MSE Restored Old", "DON Restored Old") + "\n";
}
log += string.Join(Tools.Consts.CSVDivider, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]) + Tools.Consts.CSVDivider;
log += string.Join(Tools.Consts.CSVDivider, Tools.Metrics.MatrixDifference(savedMask, savedMask2, MetricsMode.CSVSimple)) + Tools.Consts.CSVDivider;
log += metricsOrig + Tools.Consts.CSVDivider;
log += metricsPolluted + Tools.Consts.CSVDivider;
log += metricsRestored + Tools.Consts.CSVDivider;
log += metricsRestoredOld;
fs.WriteLine(log);
fs.Close();
}
}
}
public Keyframe(long tick, float opacity = 1.0f, ImageTransform transform = null)
{
Tick = tick;
Opacity = opacity;
_transform = transform;
}
public ImageTransform RemoveTransform(ImageTransform transform, IEnumerable<TransformedImage> images)
{
foreach(TransformedImage image in images)
{
image.RemoveTransform(transform);
//image.skipPosAnimation();
}
SelectionChanged();
//EDIT: Call transforms.Remove(transform); for all transforms that aren't needed anymore
//EDIT: Call transform.Dispose(); for all transforms that aren't needed anymore
return transform;
}
public ImageTransform RemoveTransform(ImageTransform transform)
{
transforms.Remove(transform);
foreach(TransformedImage image in images)
{
image.RemoveTransform(transform);
//image.skipPosAnimation();
}
transform.OnCameraMoved(freeview);
transform.Dispose();
return transform;
}
public ImageTransform AddTransform(ImageTransform transform)
{
transforms.Add(transform);
transform.OnCameraMoved(freeview);
return transform;
}
private void ProcessFullRequest(HttpResponse response)
{
using (MemoryStream memoryStream = new MemoryStream()) {
ImageTransformer imageTransformer = new ImageTransformer();
imageTransformer.GraphicsQuality = ImageSettings.GraphicsQuality;
imageTransformer.Copyright = ImageSettings.Copyright;
imageTransformer.CopyrightSize = ImageSettings.CopyrightSize;
imageTransformer.MaxWidth = ImageSettings.MaxWidth;
imageTransformer.MaxHeight = ImageSettings.MaxHeight;
imageTransformer.Grayscale = ImageSettings.Grayscale;
imageTransformer.Negative = ImageSettings.Negative;
imageTransformer.Sepia = ImageSettings.Sepia;
imageTransformer.Clip = ImageSettings.Clip;
imageTransformer.Quantize = ImageSettings.Quantize;
imageTransformer.MaintainPalette = ImageSettings.MaintainPalette;
imageTransformer.Brightness = ImageSettings.Brightness;
imageTransformer.Contrast = ImageSettings.Contrast;
imageTransformer.Opacity = ImageSettings.Opacity;
string customTransform = ImageSettings.CustomTransform;
if (!string.IsNullOrEmpty(customTransform))
{
string customTransformClassName = config.GetImageTransformClassName(customTransform);
ImageTransform customTransformClass = ImageTransformFactory.Create(customTransformClassName);
ICustomDataConsumer customTransFormClassAsCustomDataConsumer = customTransformClass as ICustomDataConsumer;
if (customTransFormClassAsCustomDataConsumer != null)
{
customTransFormClassAsCustomDataConsumer.SetCustomData(ImageSettings.CustomData);
}
imageTransformer.CustomTransforms.Add(customTransformClass);
}
ImageRetriever.EnsureImage();
using (Image originalImage = ImageRetriever.GetImage())
using (Image resizedBitmap = imageTransformer.Transform(originalImage)) {
long outputQuality = ImageSettings.OutputQuality;
ImageFormat imageFormat = ImageMetadata.ImageFormat;
resizedBitmap.SaveToMemoryStream(memoryStream, imageFormat, outputQuality);
}
memoryStream.Capacity = (int)memoryStream.Position;
if (memoryStream.Capacity > 0)
{
if (ImageSettings.ServerCacheTimeout > 0)
{
ImageCacheBroker.AddImageBytes(memoryStream.ToArray());
}
response.ContentType = ImageMetadata.ContentType;
response.AppendHeader("Content-Disposition", string.Concat("inline; filename=\"", ImageMetadata.SaveName, "\""));
response.AppendHeader("Content-Length", memoryStream.Capacity.ToString(CultureInfo.InvariantCulture));
response.Cache.SetCacheability(HttpCacheability.Public);
response.Cache.SetAllowResponseInBrowserHistory(true);
response.Cache.SetLastModified(ImageMetadata.LastModifiedDate);
response.Cache.SetValidUntilExpires(true);
response.Cache.SetExpires(DateTime.UtcNow.AddMinutes(ImageSettings.ClientCacheTimeout));
memoryStream.WriteTo(response.OutputStream);
}
}
}
/// <summary>
/// 画像データ連結する処理を実行する
/// </summary>
/// <param name="imageFilePaths">
/// 画面から指定された画像データが格納されているフォルダ内のファイルパスの配列
/// （少なくとも１つ以上は画像データを含んでいるが、画像データ以外も含まれている可能性がある
/// 画像データの読み込み処理を重複的に行うのは無駄であるため、連結処理にてファイルの判定を行う）
/// </param>
/// <param name="gifFilePath">
/// 作成するGifファイルの保存先パス
/// （追記をする場合（引数の <paramref name="isAppendGif"/> が True の場合）は
/// 既に存在するGifファイルのパスであり、そのファイルに追記する）
/// </param>
/// <param name="isAppendGif">
/// 追記フラグ
/// 追記する場合：True、追記しない場合：False
/// </param>
/// <returns>処理が正常終了した場合 True、中断した場合 False</returns>
private bool Run(string[] imageFilePaths, string gifFilePath, bool isAppendGif)
{
try
{
// 中断フラグを OFF にする
IsStop = false;
// ループ回数のパラメータ設定
bool isRoop = false;
short roopCount = 1;
if (!isAppendGif)
{
// Gifに追記しない場合のみループ設定を使用する
isRoop = ChkRoop.Checked;
roopCount = ChkRoopInfinite.Checked ? (short)0 : decimal.ToInt16(TxtRoopCount.Value);
}
// Gifエンコーダー生成
GifEncoder gifEncoder;
using (gifEncoder = new GifEncoder(gifFilePath, isAppendGif, isRoop, roopCount))
{
// 都度都度保存する
gifEncoder.IsEachTimeSave = true;
// 設定するディレイ用のパラメータの初期値を設定
int frameRate = decimal.ToInt32(TxtFrameRate.Value);
int remainder = 0;
int delay;
// イメージデータを読み込みGifエンコーダに追加していく
int count = 1;
foreach (string imagePath in imageFilePaths)
{
// 中断しているか判定
if (IsStop)
{
// 処理を中断する
return(false);
}
// 読み込み可能な画像データのみ追加していく
Image image = null;
try
{
if (ImageTransform.TryImageLoad(imagePath, out image))
{
// 設定するディレイを計算
delay = (GifEncoder.GifDelayUnit + remainder) / frameRate;
remainder = (GifEncoder.GifDelayUnit + remainder) % frameRate;
// 画像データをGifに追加
gifEncoder.AddImage(image, (short)delay);
}
}
finally
{
image?.Dispose();
}
// 進捗を進める
int progressRate = count * 100 / imageFilePaths.Length;
Invoke((MethodInvoker)(() => StepProgressBar(progressRate)));
count++;
}
// 生成したGifを保存する
gifEncoder.Save();
}
// 正常終了：True を返す）
return(true);
}
catch (Exception ex)
{
// 下記の例外が発生する可能性がある
// UnauthorizedAccessException
// ・Gifの保存先のパスと同名の隠しファイル等のアクセスできないファイルが
// 既に存在している場合に発生
// ・呼び出し元に、必要なアクセス許可がない場合に発生
// SecurityException
// ・呼び出し元に、必要なアクセス許可がない場合に発生
// IOException
// ・I/O エラーが発生した場合に発生
// GifEncoderException
// ・Gifデータへのエンコードに失敗した場合に発生
if (ex is UnauthorizedAccessException ||
ex is SecurityException ||
ex is IOException ||
ex is GifEncoderException)
{
// 共通のエラー処理を行う
ExceptionHandling.Error(ex);
// 異常終了した場合 False を返却
return(false);
}
// 上記以外の例外の場合はそのままスローする（バグの場合）
throw;
}
}
