imagehelper.cs

破解的飞信源代码

                return null;
            }
        }

        public static Image TryGetThumbnailImage(Image image, int width, int height)
        {
            if (image == null)
            {
                return null;
            }
            try
            {
                return GetThumbnailImage(image, width, height, false);
            }
            catch
            {
                return image;
            }
        }

        public static Image TryGetThumbnailImage(string path, int width, int height)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            try
            {
                return GetThumbnailImage(Image.FromFile(path), width, height);
            }
            catch
            {
                return null;
            }
        }

        public static Image TryGetThumbnailImage(Image image, int width, int height, bool keepRatio)
        {
            if (image == null)
            {
                return null;
            }
            try
            {
                ImpScaleTransform tf = new ImpScaleTransform(width, height, keepRatio);
                return Transform(image, tf);
            }
            catch
            {
                return image;
            }
        }

        public static Image TryGetTransparentImage(Image image, float percentage)
        {
            if (image == null)
            {
                return null;
            }
            try
            {
                ImpAlphaBlendingTransform tf = new ImpAlphaBlendingTransform(percentage);
                return Transform(image, tf);
            }
            catch
            {
                return image;
            }
        }

        public static Image TryGetTransparentImage(string path, float percentage)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            try
            {
                return GetTransparentImage(Image.FromFile(path), percentage);
            }
            catch
            {
                return null;
            }
        }

        public static Image TryImage2Jpg(Image input)
        {
            return TryImage2Jpg(input, input.Width);
        }

        public static Image TryImage2Jpg(Image input, int size)
        {
            return TryGetSquareThumbnailImage(input, size);
        }

        public static MemoryStream TryImage2JpgStream(Image input)
        {
            return TryImage2JpgStream(input, input.Width);
        }

        public static MemoryStream TryImage2JpgStream(Image input, int size)
        {
            MemoryStream stream = null;
            try
            {
                stream = new MemoryStream();
                Image2Jpg(input, size).Save(stream, ImageFormat.Jpeg);
            }
            catch
            {
            }
            return stream;
        }

        public static Image TryRotateImage(Image image, RotateFlipType rotateFlipType)
        {
            if (image == null)
            {
                return null;
            }
            try
            {
                image.RotateFlip(rotateFlipType);
                return image;
            }
            catch
            {
                return null;
            }
        }

        public static Image TryRotateImage(Image image, float angle)
        {
            if (image == null)
            {
                return null;
            }
            return null;
        }

        public static Image TryRotateImage(string path, float angle)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            try
            {
                return RotateImage(Image.FromFile(path), angle);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImage(Image orignalImage, string overlapPath, int x, int y)
        {
            if (orignalImage == null)
            {
                return null;
            }
            if (!File.Exists(overlapPath))
            {
                return null;
            }
            try
            {
                Image overlapImage = Image.FromFile(overlapPath);
                return SetOverlapImage(orignalImage, overlapImage, x, y, overlapImage.Width, overlapImage.Height);
            }
            catch
            {
                return orignalImage;
            }
        }

        public static Image TrySetOverlapImage(string path, Image overlapImage, int x, int y)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                return SetOverlapImage(Image.FromFile(path), overlapImage, x, y, overlapImage.Width, overlapImage.Height);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImage(string path, string overlapPath, int x, int y)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            if (!File.Exists(overlapPath))
            {
                return null;
            }
            try
            {
                Image overlapImage = Image.FromFile(overlapPath);
                return SetOverlapImage(Image.FromFile(path), overlapImage, x, y, overlapImage.Width, overlapImage.Height);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImage(Image image, Image overlapImage, int x, int y, int width, int height)
        {
            if (image == null)
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                ImpOverlayTranform tf = new ImpOverlayTranform(overlapImage, x, y, width, height);
                return Transform(image, tf);
            }
            catch
            {
                return image;
            }
        }

        public static Image TrySetOverlapImage(Image orignalImage, string overlapPath, int x, int y, int width, int height)
        {
            if (orignalImage == null)
            {
                return null;
            }
            if (!File.Exists(overlapPath))
            {
                return null;
            }
            try
            {
                return SetOverlapImage(orignalImage, Image.FromFile(overlapPath), x, y, width, height);
            }
            catch
            {
                return orignalImage;
            }
        }

        public static Image TrySetOverlapImage(string path, Image overlapImage, int x, int y, int width, int height)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                return SetOverlapImage(Image.FromFile(path), overlapImage, x, y, width, height);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImage(string path, string overlapPath, int x, int y, int width, int height)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            if (!File.Exists(overlapPath))
            {
                return null;
            }
            try
            {
                return SetOverlapImage(Image.FromFile(path), Image.FromFile(overlapPath), x, y, width, height);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImageEx(Image originalImage, Image overlapImage, int x, int y)
        {
            if (originalImage == null)
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                return SetOverlapImageEx(originalImage, overlapImage, x, y, overlapImage.Width, overlapImage.Height);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImageEx(Image originalImage, string overlapPath, int x, int y)
        {
            if (originalImage == null)
            {
                return null;
            }
            if (!File.Exists(overlapPath))
            {
                return null;
            }
            try
            {
                return SetOverlapImageEx(originalImage, Image.FromFile(overlapPath), x, y);
            }
            catch
            {
                return originalImage;
            }
        }

        public static Image TrySetOverlapImageEx(string path, Image overlapImage, int x, int y)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                return SetOverlapImageEx(Image.FromFile(path), overlapImage, x, y);
            }
            catch
            {
                return null;
            }
        }

        public static Image TrySetOverlapImageEx(Image image, Image overlapImage, int x, int y, int width, int height)
        {
            if (image == null)
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                ImpOverlayTranformEx tf = new ImpOverlayTranformEx(overlapImage, x, y, width, height);
                return Transform(image, tf);
            }
            catch
            {
                return image;
            }
        }

        public static Image TrySetOverlapImageEx(string path, Image overlapImage, int x, int y, int width, int height)
        {
            if (!File.Exists(path))
            {
                return null;
            }
            if (overlapImage == null)
            {
                return null;
            }
            try
            {
                return SetOverlapImageEx(Image.FromFile(path), overlapImage, x, y, width, height);
            }
            catch
            {
                return null;
            }
        }
    }
}