Reading RGB Info from Images on the iPhone using MonoTouch

MonoTouch is an intriguing new software development kit from Novell. It utilizes the open source Mono project to allow developers to write code in C# that can then be statically compiled into native iPhone applications and deployed to devices or even to the App Store. A free evaluation version is available if the product interests you.



I downloaded the evaluation version and decided to take this new development kit for a spin by using it to read RGB color information from all pixels in an image saved on the device. I ended up creating a CGBitmapContext to do this and then marshaling the results into a byte array. Please see the code below for more details:

//_selectedImage refers to the UIImage object of interest
int width = _selectedImage.CGImage.Width;
int height = _selectedImage.CGImage.Height;
//4 color settings for every pixel (RGBA)
int pixelDataCount = width * height * 4;
IntPtr data = Marshal.AllocHGlobal(pixelDataCount);
int bitsPerComponent = 8;
int bytesPerPixel = 4;
int bytesPerRow = bytesPerPixel * width;
//Draw image to an RGB bitmap context
CGBitmapContext imgContext = new CGBitmapContext(data, 
  width, height, bitsPerComponent, bytesPerRow, 
  CGColorSpace.CreateDeviceRGB(), CGImageAlphaInfo.PremultipliedLast);
imgContext.DrawImage(new RectangleF(0.0F, 0.0F, width, height), 
  _selectedImage.CGImage);    
byte[] pixelData = new byte[pixelDataCount];
Marshal.Copy(data, pixelData, 0, pixelDataCount);
    
//Milk the color settings for each pixel in the image
int red;
int green;
int blue;
int currentPixelIndex = 0;                  
for (int countHeight = 0; countHeight < height; countHeight++)
{
  for (int countWidth = 0; countWidth < width; countWidth++)
  { 
    red = pixelData[currentPixelIndex];
    currentPixelIndex++;
    green = pixelData[currentPixelIndex];
    currentPixelIndex++;      
    blue = pixelData[currentPixelIndex];
    currentPixelIndex++;

    //Currently ignoring the alpha byte
    currentPixelIndex++;

    //Probably will want to Cache RGB values here for later use
  }
}

Closures in PHP 5.3

If early releases are any indication, PHP is scheduled to receive some pretty significant updates in version 5.3. In addition to namespaces, I'm particularly interested in the addition of closures.

According to object-oriented programming expert Martin Fowler, closures are defined as a block of code that can be passed to a function. However, delegates (C#), anonymous classes (Java) and function pointers (C) don't quite qualify because the following also needs to be true:

1. Closures need to be able to refer to variables already present in scope at the time they're defined.


2. Closures shouldn't require complex syntax (I personally think this point is a tad subjective).

As you can imagine this capability might be helpful when writing a function that repeatedly executes a block of code specific to the function. It wouldn't make sense to refactor this block of code to the class level if it doesn't get used anywhere outside the function. With closures, the block of code distinct to the function may be defined and repeatedly called upon without having to bloat your classes.

PHP's upcoming syntax for closures is shaping up to be comparable to the C# 2.0 implementation. In the .NET world closures first arrived as anonymous methods in C# 2.0 (these were later simplified into lambda expressions in C# 3.0).

For comparison's sake C# anonymous methods look something like this:

/* Returns true if tOne and tTwo are  both evenly 
   divisible by the denominator (denom) */
public bool EvenlyDivisible(int denom, int tOne, int tTwo)
{           
  //Define the closure
  Predicate evenlyDivisible = delegate(int testNum)
  {
    //Note that denom is defined outside closure scope
    if ((testNum % denom) == 0)
    {
      return true;
    }
    else
    {
      return false;
    }
  };

  //Use the closure as necessary
  if (evenlyDivisible(tOne) && (evenlyDivisible(tTwo)))
  {
      return true;
  }
  else
  {
      return false;
  }
}

When released, a comparable implementation in PHP 5.3 will probably look something like the following:

/* Returns true if $tOne and $tTwo are  both evenly 
   divisible by the denominator ($denom) */
function EvenlyDivisible($denom, $tOne, $tTwo)
{
  $evenlyDivisible = function ($testNum) use ($denom) {
    //Note that $denom is defined outside closure scope
    if (($testNum % $denom) == 0)
    {
      return true;
    }
    else
    {
      return false;
    }
  };

  //Use the closure as necessary
  if ($evenlyDivisible($tOne) && ($evenlyDivisible($tTwo)))
  {
      return true;
  }
  else
  {
      return false;
  }
}

For additional information please check out the closure proposal on php.net.

The ref and out Keywords in C#

In C# all value type parameters (objects that inherit from System.ValueType) are allocated to the stack and passed by value. This means that a copy of these variables is created and passed into the method being called. Since the parameter is a local copy its scope is limited to that method. See the following example below:

protected void Sample()
{
    int x = 5;
    //Writes 5 to the console
    Console.WriteLine(x.ToString());
    //Send a copy of x
    Increment(x);
    //Writes 5 to the console
    Console.WriteLine(x.ToString());
}

protected void Increment(int incoming)
{
    incoming++;
}

Note that the variable x is not changed by the Increment method. In most cases this behavior is desired. However, there are occasions when we may want to persist changes to a value type parameter beyond the scope of the method. This is where the ref and out keywords come into play. Here's our sample again but with the ref keyword used in the Increment method:

protected void Sample()
{
    int x = 5;
    //Writes 5 to the console
    Console.WriteLine(x.ToString());
    //Send a reference of x
    Increment(ref x);
    //Writes 6 to the console
    Console.WriteLine(x.ToString());
}

protected void Increment(ref int incoming)
{
    incoming++;
}

Note that this time around x is 6 after the Increment method is executed.

The ref and out keywords operate identically except that ref parameters must be initialized before being passed into the method while out parameters must be initialized by the time the method returns.