/// <summary>
/// 获取区域截图
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public static Image GetScreenByRegion(int x, int y, int width, int height)
{
GraphicsPath regionFillPath = new GraphicsPath {
FillMode = FillMode.Winding
};
Rectangle rectangle = new Rectangle(x, y, width, height);
regionFillPath.AddRectangle(rectangle);
Rectangle screenRectangle = ScreenToClient(SystemInformation.VirtualScreen);
Rectangle resultArea = Rectangle.Intersect(rectangle, screenRectangle);
if (resultArea.IsValid())
{
Image img = GetFullScreen();
using (Bitmap bmp = img.CreateEmptyBitmap())
using (Graphics g = Graphics.FromImage(bmp))
using (TextureBrush brush = new TextureBrush(img))
{
g.PixelOffsetMode = PixelOffsetMode.Half;
g.SmoothingMode = SmoothingMode.HighQuality;
g.FillPath(brush, regionFillPath);
return(ImageHelpers.CropBitmap(bmp, resultArea));
}
}
return(null);
}
public static Image ApplyRegionPathToImage(Image img, GraphicsPath gp)
{
if (img != null && gp != null)
{
Rectangle regionArea = Rectangle.Round(gp.GetBounds());
Rectangle screenRectangle = CaptureHelpers.GetScreenBounds0Based();
regionArea = Rectangle.Intersect(regionArea, screenRectangle);
if (regionArea.IsValid())
{
using (Bitmap bmp = img.CreateEmptyBitmap())
using (Graphics g = Graphics.FromImage(bmp))
using (TextureBrush brush = new TextureBrush(img))
{
g.PixelOffsetMode = PixelOffsetMode.Half;
g.SmoothingMode = SmoothingMode.HighQuality;
g.FillPath(brush, gp);
return(ImageHelpers.CropBitmap(bmp, regionArea));
}
}
}
return(null);
}
private static Bitmap TrimTransparent(Bitmap bitmap)
{
Rectangle source = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
Rectangle rect = source;
using (UnsafeBitmap unsafeBitmap = new UnsafeBitmap(bitmap, true, ImageLockMode.ReadOnly))
{
rect = TrimTransparentFindX(unsafeBitmap, rect);
rect = TrimTransparentFindY(unsafeBitmap, rect);
rect = TrimTransparentFindWidth(unsafeBitmap, rect);
rect = TrimTransparentFindHeight(unsafeBitmap, rect);
}
if (source != rect)
{
Bitmap croppedBitmap = ImageHelpers.CropBitmap(bitmap, rect);
if (croppedBitmap != null)
{
bitmap.Dispose();
return(croppedBitmap);
}
}
return(bitmap);
}
public static Bitmap ApplyRegionPathToImage(Bitmap bmp, GraphicsPath gp, out Rectangle resultArea)
{
if (bmp != null && gp != null)
{
Rectangle regionArea = Rectangle.Round(gp.GetBounds());
Rectangle screenRectangle = CaptureHelpers.GetScreenBounds();
resultArea = Rectangle.Intersect(regionArea, new Rectangle(0, 0, screenRectangle.Width, screenRectangle.Height));
if (resultArea.IsValid())
{
using (Bitmap bmpResult = bmp.CreateEmptyBitmap())
using (Graphics g = Graphics.FromImage(bmpResult))
using (TextureBrush brush = new TextureBrush(bmp))
{
g.PixelOffsetMode = PixelOffsetMode.Half;
g.SmoothingMode = SmoothingMode.HighQuality;
g.FillPath(brush, gp);
return(ImageHelpers.CropBitmap(bmpResult, resultArea));
}
}
}
resultArea = Rectangle.Empty;
return(null);
}
private static Bitmap QuickTrimTransparent(Bitmap bitmap)
{
Rectangle source = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
Rectangle rect = source;
using (UnsafeBitmap unsafeBitmap = new UnsafeBitmap(bitmap, true, ImageLockMode.ReadOnly))
{
int middleX = rect.Width / 2;
int middleY = rect.Height / 2;
// Find X
for (int x = rect.X; x < rect.Width; x++)
{
if (unsafeBitmap.GetPixel(x, middleY).Alpha > 0)
{
rect.X = x;
break;
}
}
// Find Y
for (int y = rect.Y; y < rect.Height; y++)
{
if (unsafeBitmap.GetPixel(middleX, y).Alpha > 0)
{
rect.Y = y;
break;
}
}
// Find Width
for (int x = rect.Width - 1; x >= rect.X; x--)
{
if (unsafeBitmap.GetPixel(x, middleY).Alpha > 0)
{
rect.Width = x - rect.X + 1;
break;
}
}
// Find Height
for (int y = rect.Height - 1; y >= rect.Y; y--)
{
if (unsafeBitmap.GetPixel(middleX, y).Alpha > 0)
{
rect.Height = y - rect.Y + 1;
break;
}
}
}
if (source != rect)
{
return(ImageHelpers.CropBitmap(bitmap, rect));
}
return(bitmap);
}
public override Bitmap Apply(Bitmap bmp)
{
if (Margin.All == 0)
{
return(bmp);
}
return(ImageHelpers.CropBitmap(bmp, new Rectangle(Margin.Left, Margin.Top, bmp.Width - Margin.Horizontal, bmp.Height - Margin.Vertical)));
}
public override void OnDrawFinal(Graphics g, Bitmap bmp)
{
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, Rectangle))
{
ImageHelpers.HighlightImage(croppedImage, HighlightColor);
g.DrawImage(croppedImage, Rectangle);
}
}
public override Image Apply(Image img)
{
if (Margin.All == 0)
{
return(img);
}
return(ImageHelpers.CropBitmap((Bitmap)img, new Rectangle(Margin.Left, Margin.Top, img.Width - Margin.Horizontal, img.Height - Margin.Vertical)));
}
public override void OnDrawFinal(Graphics g, Bitmap bmp)
{
if (PixelSize > 1)
{
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, Rectangle))
using (Bitmap pixelatedImage = ImageHelpers.Pixelate(croppedImage, PixelSize))
{
g.DrawImage(pixelatedImage, Rectangle);
}
}
}
public override void OnDrawFinal(Graphics g, Bitmap bmp)
{
if (BlurRadius > 1)
{
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, Rectangle))
{
ImageHelpers.Blur(croppedImage, BlurRadius);
g.DrawImage(croppedImage, Rectangle);
}
}
}
public override void OnDrawFinal(Graphics g, Bitmap bmp)
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
rect.Intersect(Rectangle);
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, rect))
{
ImageHelpers.HighlightImage(croppedImage, HighlightColor);
g.DrawImage(croppedImage, rect);
}
}
public virtual void OnDrawFinal(Graphics g, Bitmap bmp)
{
Rectangle rect = Rectangle.Intersect(new Rectangle(0, 0, bmp.Width, bmp.Height), Rectangle);
if (!rect.IsEmpty)
{
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, rect))
{
ApplyEffect(croppedImage);
g.DrawImage(croppedImage, rect);
}
}
}
public override void OnDrawFinal(Graphics g, Bitmap bmp)
{
if (PixelSize > 1)
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
rect.Intersect(Rectangle);
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, rect))
using (Bitmap pixelatedImage = ImageHelpers.Pixelate(croppedImage, PixelSize))
{
g.DrawImage(pixelatedImage, rect);
}
}
}
public override void OnDrawFinal(Graphics g, Bitmap bmp)
{
if (BlurRadius > 1)
{
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
rect.Intersect(Rectangle);
using (Bitmap croppedImage = ImageHelpers.CropBitmap(bmp, rect))
{
ImageHelpers.FastBoxBlur(croppedImage, BlurRadius);
g.DrawImage(croppedImage, rect);
}
}
}
protected override TaskMetadata Execute(TaskSettings taskSettings)
{
switch (lastRegionCaptureType)
{
default:
case RegionCaptureType.Default:
if (RegionCaptureForm.LastRegionFillPath != null)
{
using (Bitmap screenshot = TaskHelpers.GetScreenshot(taskSettings).CaptureFullscreen())
{
Bitmap bmp = RegionCaptureTasks.ApplyRegionPathToImage(screenshot, RegionCaptureForm.LastRegionFillPath, out _);
return(new TaskMetadata(bmp));
}
}
else
{
return(ExecuteRegionCapture(taskSettings));
}
case RegionCaptureType.Light:
if (!RegionCaptureLightForm.LastSelectionRectangle0Based.IsEmpty)
{
using (Bitmap screenshot = TaskHelpers.GetScreenshot(taskSettings).CaptureFullscreen())
{
Bitmap bmp = ImageHelpers.CropBitmap(screenshot, RegionCaptureLightForm.LastSelectionRectangle0Based);
return(new TaskMetadata(bmp));
}
}
else
{
return(ExecuteRegionCaptureLight(taskSettings));
}
case RegionCaptureType.Transparent:
if (!RegionCaptureTransparentForm.LastSelectionRectangle0Based.IsEmpty)
{
using (Bitmap screenshot = TaskHelpers.GetScreenshot(taskSettings).CaptureFullscreen())
{
Bitmap bmp = ImageHelpers.CropBitmap(screenshot, RegionCaptureTransparentForm.LastSelectionRectangle0Based);
return(new TaskMetadata(bmp));
}
}
else
{
return(ExecuteRegionCaptureTransparent(taskSettings));
}
}
}
public Bitmap GetAreaImage()
{
Rectangle rect = SelectionRectangle0Based;
if (rect.Width > 0 && rect.Height > 0)
{
if (rect.X == 0 && rect.Y == 0 && rect.Width == backgroundImage.Width && rect.Height == backgroundImage.Height)
{
return((Bitmap)backgroundImage.Clone());
}
return(ImageHelpers.CropBitmap(backgroundImage, rect));
}
return(null);
}
public Image CropImage(Rectangle rect, bool onlyIfSizeDifferent = false)
{
rect = CaptureHelpers.ScreenToClient(rect);
Point offset = CaptureHelpers.ScreenToClient(Form.CanvasRectangle.Location);
rect.X -= offset.X;
rect.Y -= offset.Y;
rect.Intersect(new Rectangle(0, 0, Form.Canvas.Width, Form.Canvas.Height));
if (rect.IsValid() && (!onlyIfSizeDifferent || rect.Size != Form.Canvas.Size))
{
return(ImageHelpers.CropBitmap((Bitmap)Form.Canvas, rect));
}
return(null);
}
public override Bitmap Apply(Bitmap bmp)
{
float currentRatio = bmp.Width / (float)bmp.Height;
float targetRatio = proportionalWidth / (float)proportionalHeight;
bool isTargetWider = targetRatio > currentRatio;
int targetWidth = bmp.Width;
int targetHeight = bmp.Height;
int marginLeft = 0;
int marginTop = 0;
if (Method == ForceProportionsMethod.Crop)
{
if (isTargetWider)
{
targetHeight = (int)Math.Round(bmp.Width / targetRatio);
marginTop = (bmp.Height - targetHeight) / 2;
}
else
{
targetWidth = (int)Math.Round(bmp.Height * targetRatio);
marginLeft = (bmp.Width - targetWidth) / 2;
}
return(ImageHelpers.CropBitmap(bmp, new Rectangle(marginLeft, marginTop, targetWidth, targetHeight)));
}
else if (Method == ForceProportionsMethod.Grow)
{
if (isTargetWider)
{
targetWidth = (int)Math.Round(bmp.Height * targetRatio);
}
else
{
targetHeight = (int)Math.Round(bmp.Width / targetRatio);
}
return(ImageHelpers.ResizeImage(bmp, targetWidth, targetHeight, false, true, GrowFillColor));
}
return(bmp);
}
private Bitmap CombineImages()
{
if (images == null || images.Count == 0)
{
return(null);
}
if (images.Count == 1)
{
return((Bitmap)images[0].Clone());
}
List <Bitmap> output = new List <Bitmap>();
for (int i = 0; i < images.Count - Options.IgnoreLast; i++)
{
Bitmap newImage;
Bitmap image = images[i];
if (Options.TrimLeftEdge > 0 || Options.TrimTopEdge > 0 || Options.TrimRightEdge > 0 || Options.TrimBottomEdge > 0 ||
Options.CombineAdjustmentVertical > 0 || Options.CombineAdjustmentLastVertical > 0)
{
Rectangle rect = new Rectangle(Options.TrimLeftEdge, Options.TrimTopEdge, image.Width - Options.TrimLeftEdge - Options.TrimRightEdge,
image.Height - Options.TrimTopEdge - Options.TrimBottomEdge);
if (i == images.Count - 1)
{
rect.Y += Options.CombineAdjustmentLastVertical;
rect.Height -= Options.CombineAdjustmentLastVertical;
}
else if (i > 0)
{
rect.Y += Options.CombineAdjustmentVertical;
rect.Height -= Options.CombineAdjustmentVertical;
}
newImage = ImageHelpers.CropBitmap(image, rect);
if (newImage == null)
{
continue;
}
}
else
{
newImage = (Bitmap)image.Clone();
}
output.Add(newImage);
}
Bitmap bmpResult = ImageHelpers.CombineImages(output);
foreach (Bitmap image in output)
{
if (image != null)
{
image.Dispose();
}
}
output.Clear();
return(bmpResult);
}
