Amadiere.com

Fourteen and a half crazy frog burpers

15th March 2010

Good Quality Image Resizing in C#

Filed under: C# — Tags: , , , — Alex Holt @ 8:40 pm

I encountered a little bit of a problem the other day with some image resizing code from within an ASP.NET MVC application that was misbehaving. The issue was just a general C# and ASP.NET one, not related to MVC or Webforms, but it was that for some reason the images were losing a significant amount of quality when resizing. I’m talking a pixel sharp 2000 x 2000 picture that when resized to 300 x 300, was woefully blurry. Initially, the code was simply using the GetThumbnailImage() method to produce it’s resizes, this turned out to be the mistake!

While GetThumbnailImage() is fine for small thumbnail images (the clue I guess, was in the name), it somewhat struggled on the larger versions. To fix the issue, I had to convert the image to a bitmap, faff about with it like that, then export it back to a Jpeg once I was done.

For future me (and anyone else this might help), here is the code I eventually settled on:

EncoderParameters encodingParameters = new EncoderParameters(1);
encodingParameters.Param[0] = new EncoderParameter(Encoder.Quality, 90L); // Set the JPG Quality percentage to 90%.
 
ImageCodecInfo jpgEncoder = GetEncoderInfo("image/jpeg");
 
// Incoming! This is the original image. This line can effectively be anything, but in this example it's coming from a stream.
var image = Image.FromStream(new System.IO.MemoryStream(Picture));
 
// Creating two blank canvas. One that the original image is placed into, the other for the resized version.
Bitmap originalImage = new Bitmap(image);
Bitmap newImage = new Bitmap(originalImage, 300, (image.Height * 300 / image.Width));  // Width of 300 & maintain aspect ratio (let it be as high as it needs to be).
 
// We then do some funky voodoo with the newImage. Changing it to a graphic to allow us to set the HighQualityBilinear property and resize nicely.
Graphics g = Graphics.FromImage(newImage);
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBilinear;
g.DrawImage(originalImage, 0, 0, newImage.Width, newImage.Height);
 
var streamLarge = new System.IO.MemoryStream();
newImage.Save(streamLarge, jpgEncoder, encodingParameters);
 
// This is the line that returns the picture to the relevant part of the model.
_event.Picture = streamLarge.ToArray();
 
// No need for all that drama for the thumbnail, the loss of quality isn't noticable.
var thumbnail = image.GetThumbnailImage(80, (image.Height*80/image.Width), null, new IntPtr(0));
var streamThumbnail = new System.IO.MemoryStream();
 
thumbnail.Save(streamThumbnail, jpgEncoder, encodingParameters);
 _event.ThumbnailPicture = streamThumbnail.ToArray();
 
// Good boy's tidy-up after themselves! :O
originalImage.Dispose();
newImage.Dispose();
thumbnail.Dispose();
streamLarge.Dispose();
streamThumbnail.Dispose();

9th November 2009

BEHOLD! The coming of ASP.NET 4.0!

Filed under: ASP.NET,C#,MVC — Tags: , , — Alex Holt @ 8:30 pm

‘Tis a day of reconing upon us! The mighty that hath enjoyed the fruits of our labour shall become our lesser kin. ASP.NET#3.5 is being bumped up A WHOLE HALF VERSION! When you’ve regained your breath (have a cup of tea, if it helps) – read on for a breakdown of the glory that shall shine bright in all that is sparky, shiny and new!

First, for me, the major feature has to be something that is already available: ASP.NET MVC – now part of the ‘Out Of The Box’ experience and no longer required to be a separate download (though, still will be for ASP.NET 3.5). This in itself is worthy of a good cold shower, but get this… it’s version 2! Oh yeah, sweetness itself.

MVC 2.0 isn’t actually available as a release version at the moment and is in fact just a preview version. However, well worthy of look if you are at all interested in the original MVC. If you’ve been unable to see the new features in 2.0, then I seriously do not understand how you can sleep at night. In my bid to cure your insomnia, here are a few of the highlights, though, I could go on!

  • Areas are being introduced to allow you to easily spread your code apart into logical parts. E.g. You can have an area for your User / Account management stuff, and an area for your Product Listings. This allows you to keep the MVC pattern but in segmented way. Your User Area would have a directory for Controllers, Models and Views, and your Product Area would have separate areas too.
  • DataAnnotation Validation is voodoo. A black magic that makes you sit back and go: “WTF, is that it”? It allows you to declare the requirements of a field in a single place within your application, then any time something attempts to update it, the validation must be passed.
  • Default Values are easier to declare now.
    // something old
    public ActionResult Browse(string category, [DefaultValue(1)] int page)
    {
    }
    // something new
    public ActionResult Browse(string category, int page = 1)
    {
    }
  • They have shortened the attribute [HttpPost] . I know, I saved the best until last!
    // out with the old
    [AcceptVerbs(HttpVerbs.Post)]
    public ActionResult Create(Product product)
    {
    }
    // in with the new!
    [HttpPost]
    public ActionResult Create(Product product)
    {
    }

As for the rest of ASP.NET 4.0, what can you look forward to? Well!

  • The superbly sweet…
    <%:productDescription%>

    Did you see it? The shorthand response.write alternative which was the equals sign has a rival. But not a dark nemesis with fire-breathing tentacles, nope, a bright white halo-toting angel rival. Simply replace the equal sign with a colon and you have a HTML Encoded Response.Write alternative. Finally, what seems to be a simple solution to reduce considerably, the risk of XSS attacks.

  • URL Routing (or of course, URL Rowwting if you are from the US) in much the same way that MVC has it. If you’re familiar with MVC 1, you’ll know the awesomeness that is the friendly URLs that they can produce. With ASP.NET4, this gesture is extended to the general Webforms environment.
  • Auto-Starting Web Applications are here! No longer do you need to set up a cron job to make sure that a random visitor doesn’t have to wait for 20 seconds while your application reloads itself into memory. A few tweaks and bliss is yours (and your customers).
  • Web.config has been on a diet. It’s shredded almost all of its weight. The only things that need to appear within this now are config settings that you actually want to change from their default. Genius!
    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    <?xml version="1.0"?>
    <configuration>
      <system.web>
        <compilation debug="true" targetFramework="4.0" />
      </system.web>
      <system.webServer>
        <modules runAllManagedModulesForAllRequests="true" />
      </system.webServer>
    </configuration>
  • The Entity Framework has become so awesome, it’s skipped a version or two to become EF4.0, and some of the upgrades make it strong and compelling contender for your model structuring! It contains considerably less suck than the first version.

All this ‘win’ makes you nervous? How can the world not implode? That my friend, I do not know – I think it may be like the Y2K Doomsday predictions – its the .NET4 DOOM! Either way, it’s looking good in the ASP.NET world at the moment and I can’t wait for it to land on my desktop!

12th July 2009

Nerd Dinner

Filed under: C#,MVC,Reviews — Tags: , , , — Alex Holt @ 12:30 pm

I was going to write a review on a great book I read over the last month or two called Professional ASP.NET MVC 1.0 which is published by Wrox and written collaboratively by Scott Hanselman, Scott Guthrie, Phil Haack and Rob Conery. Then I decided that one of the main things I really liked about the book was the first chapter “NerdDinner” which is a great tutorial on ASP.NET MVC 1.0.

I will first of all prefix this review with the very relevant disclaimer that I am (at this moment) a novice when it comes to MVC, which my background strongly in Classic ASP and PHP. I have a fair understanding and beginners comprehension of a lot of the core elements – but I’m still almost always looking up answers to very simple and run-of-the-mill problems.

The chapter is available online, free of charge, from ScottGu’s blog and the entire project has been added to version control at NerdDinner @ Codeplex (a useful tool when typing large amounts of text!).

The chapter covers a number of topics in addition to the core functionality of MVC, this includes things such as LINQ, Unit Testing, AJAX, Memberships & Roles and mapping software. Starting off with an empty Visual Studio, you can have a fully working NerdDinner website within an afternoons worth of work (or if you are me, a couple of nights worth).

I would highly recommend making some time to do this chapter if you are a ASP.NET developer. It will help show you the benefits and disadvantages of MVC. However, there are a few pitfalls as you are progressing through the chapter and I feel that the testing of the chapter could have been improved as there were errors and omissions scattered around as I was trying to complete it. There weren’t lots and errors were mostly ones which could be guessed and fixed without too much stress. Even in instances where you are unable to find the mistake, a look through the CodePlex site would give you a good indication as to what you were doing wrong.

I found the most frequent errors were that of ensuring the using statements were made, or a variable named differently on one page to the pages preceding. It takes me back to the good ol’ days of copying BASIC code from the back of computer magazines to make a spider walk across the screen and go up on a string from its web. Ahh, that’s classy stuff.

The book and the chapter do a great job of letting you know the key advantages and disadvantages of using MVC, outlining some of the core differences and changes to the ways in which applications are designed/developed. I particularly liked the way the application was grown and improved, simulating actual software development. Instead of the application being coded to the full application, it is initially built very basic and as the chapter goes on, layers of complexity are added bit by bit. This served for a greater understanding of how you might approach such development.

Overall, it’s one of my favourite and relevant tutorials and I highly advise finding the time to have a go at it. I’d also go so far as to say it’s very much worth spending the pennies and getting yourself a copy of the book too. It’s even sticks to the age old tradition of having funny pictures of developers on the cover and that alone is worth the dosh! :)

« Newer PostsOlder Posts »

Theme designed & built for Amadiere.com by Alex Holt. Powered by WordPress