.Net Core Image Manipulation (Crop & Resize) / Fil

问题:

I have spent the last 5 hours trying to find a feasible way to accomplish what seems to me quite an easy task if it was a previous version of the .NET family that I was working with:

1. Uploading a picture
2. Resizing & Cropping the picture
3. Saving the new picture into a directory

I have come accross to couple of libraries that are either in pre-release stage or in a not-complete stage.

Has anyone at all accomplished the above tasks without specifically including the System.Drawing namespace and/or adding a dependency for an earlier version of the .NET framework?

UPDATE on 08 / 08 / 2016

I ended up using System.Drawing something which is very annoying and disappointing. If you are developing a software used by thousands of developers, and if all these developers are relying on the components of this software, I believe, one cannot just come up with a new version, "sweet talk" about it during the conferences to show off your public speaking skills rather than giving a shit about your work and on one hand proudly hold in high esteem of it, and on the other, strip away the mostly used and demanded portions of it.

I do understand and appreciate with great excitement myself - of the new era of .net with the core framework - being a loyal asp dev since the first days of classic asp - however, to me, it is just an uncomplete product causing more frustrations and dissappointment than pleasure. When there are millions of websites in today's content-driven world, completely relying on content management, you can't just come up and say, "Hey, I have this brilliant, techonology, leaner, faster blah blah" but errr, you will have some problems with "managing" your content..

It should not be forgotten that, although, MS (and us) is very excited about this new core framework, with now being open source etc, there are other languages and frameworks out there that are doing what MS is promising to do, for a very very long time now.

回答1:

ImageSharp

ImageSharp is a new, fully featured, fully managed, cross-platform, 2D graphics API.

Designed to democratize image processing, ImageSharp brings you an incredibly powerful yet beautifully simple API.

Compared to System.Drawing we have been able to develop something much more flexible, easier to code against, and much, much less prone to memory leaks. Gone are system-wide process-locks; ImageSharp images are thread-safe and fully supported in web environments.

Built against .Net Standard 1.1 ImageSharp can be used in device, cloud, and embedded/IoT scenarios.

回答2:

You can use the Microsoft ASP.NET Core JavaScript Services to invoke arbitrary NPM packages at runtime from .NET code which means you can choose any npm package that provide image scaling and invoke it.

The following example shows how to use JavaScriptServices to resize image https://github.com/aspnet/JavaScriptServices/tree/dev/samples/misc/NodeServicesExamples

Hope that Helps

回答3:

To complete the @Hossam Barakat answer, you can use the Microsoft ASP.NET Core JavaScript Services to invoke arbitrary NPM packages at runtime from .NET code which means you can choose any npm package that provide image scaling and invoke it.
The sample use the sharp module, which has a lot of dependecies. If you prefere, like me, to use jimp which is pure javascript:

Startup.cs

public class Startup
{
 ...
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        // Enable Node Services
        services.AddNodeServices();
...
    }
...
}

ImageController.cs

using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.NodeServices;
using Microsoft.AspNetCore.StaticFiles;
using System.Security.Cryptography;
using System.Text;

namespace NodeServicesExamples.Controllers
{
    public class ResizeImageController : Controller
    {
        private const int MaxDimension = 1000;
        private static string[] AllowedMimeTypes = new[] { "image/jpeg", "image/png", "image/gif" };

        private IHostingEnvironment _environment;
        private INodeServices _nodeServices;

        public ResizeImageController(IHostingEnvironment environment, INodeServices nodeServices)
        {
            _environment = environment;
            _nodeServices = nodeServices;
        }

        [Route("resize/{*imagePath}")]
        [ResponseCache(Duration = 3600)]
        public async Task<IActionResult> Index(string imagePath, double maxWidth, double maxHeight)
        {
            // Validate incoming params
            if (maxWidth < 0 || maxHeight < 0 || maxWidth > MaxDimension || maxHeight > MaxDimension
                || (maxWidth + maxHeight) == 0)
            {
                return BadRequest("Invalid dimensions");
            }

            var mimeType = GetContentType(imagePath);
            if (Array.IndexOf(AllowedMimeTypes, mimeType) < 0)
            {
                return BadRequest("Disallowed image format");
            }

            // Locate source image on disk
            var fileInfo = _environment.WebRootFileProvider.GetFileInfo(imagePath);
            if (!fileInfo.Exists)
            {
                return NotFound();
            }

            var eTag = GenerateETag(Encoding.UTF8.GetBytes($"{fileInfo.LastModified.ToString("s")}-{fileInfo.Length}"));
            HttpContext.Response.Headers["ETag"] = eTag;

            var match = HttpContext.Request.Headers["If-None-Match"].FirstOrDefault();
            if (eTag == match)
            {
                return StatusCode(304);
            }

            // Invoke Node and pipe the result to the response
            var imageStream = await _nodeServices.InvokeAsync<Stream>(
                "./Node/resizeImage",
                fileInfo.PhysicalPath,
                mimeType,
                maxWidth,
                maxHeight);

            return File(imageStream, mimeType, fileInfo.Name);
        }

        private string GetContentType(string path)
        {
            string result;
            return new FileExtensionContentTypeProvider().TryGetContentType(path, out result) ? result : null;
        }

        private string GenerateETag(byte[] data)
        {
            string ret = string.Empty;

            using (var md5 = MD5.Create())
            {
                var hash = md5.ComputeHash(data);
                string hex = BitConverter.ToString(hash);
                ret = hex.Replace("-", "");
            }

            return ret;
        }

    }
}

Node\resizeImage.js

var jimp = require("jimp");

module.exports = function (result, physicalPath, mimeType, maxWidth, maxHeight) {
    // Invoke the 'jimp' NPM module, and have it pipe the resulting image data back to .NET
    jimp.read(physicalPath).then(function (file) {
        var width = maxWidth || jimp.AUTO;
        var height = maxHeight || jimp.AUTO;
        file.resize(maxWidth, height)
             .getBuffer(mimeType, function (err, buffer) {
                 var stream = result.stream;
                 stream.write(buffer);
                 stream.end();
             });
    }).catch(function (err) {
        console.error(err);
    });
};

install jimp: npm install jimp --save

回答4:

.NET Core Image Processing blog post (January 19, 2017) compares 6 libraries:

• CoreCompat.System.Drawing
• ImageSharp
• Magick.NET (Win only)
• SkiaSharp
• FreeImage-dotnet-core
• MagicScaler

Feb 26 update: post was updated, two new packages added

回答5:

Short answer is no, not yet. Most if not all current libraries rely on System.Drawing. If you need this now, I would go that route and add System.Drawing.

The .NET team is currently working through the features that are missing on the Core 1.0 stack, but this one isn't high enough on their priority list: Link

This is a library to watch as they're getting very close to a releasable API without System.Drawing. : ImageSharp