Pixelating An Image With ColdFusion

<cffunction
	name="imagePixelate"
	access="public"
	returntype="void"
	output="false"
	hint="I take a ColdFusion image object and pixelate it with the given pixel size. NOTE: To keep inline with the exisitng image functions, this will work directly on the existing image (rather than creating a new image).">

	<!--- Define arguments. --->
	<cfargument
		name="image"
		type="any"
		required="true"
		hint="I am the image being pixelated."
		/>

	<cfargument
		name="pixelSize"
		type="numeric"
		required="false"
		default="20"
		hint="I am size of the pixels to use in the effect."
		/>

	<!--- Define the local scope. --->
	<cfset var local = {} />

	<!---
		Get the underlying buffered image. This is going to give
		us access to the individual pixels that make up the image.
	--->
	<cfset local.bufferedImage = imageGetBufferedImage(
		arguments.image
		) />

	<!---
		Store the image dimensions - these will be referenced a
		lot, so let's create a short hand.
	--->
	<cfset local.imageWidth = imageGetWidth( arguments.image ) />
	<cfset local.imageHeight = imageGetHeight( arguments.image ) />

	<!---
		Loop over the image, examining a pixel chunk at a time.
		Each chunk will be the NxN pixel area size.
	--->
	<cfloop
		index="local.x"
		from="0"
		to="#(local.imageWidth - 1)#"
		step="#arguments.pixelSize#">

		<cfloop
			index="local.y"
			from="0"
			to="#(local.imageHeight - 1)#"
			step="#arguments.pixelSize#">


			<!---
				When grabbing the given area of pixels, we have
				to be sure not to go out of bounds on the image.
				As such, we cannot rely on the pixelSize to be
				available (this becomes likely only the last
				row and / or column).
			--->
			<cfset local.pixelWidth = min(
				arguments.pixelSize,
				(local.imageWidth - local.x)
				) />

			<cfset local.pixelHeight = min(
				arguments.pixelSize,
				(local.imageHeight - local.y)
				) />

			<!---
				Grab the collection of pixels from the
				underlying buffered image. This will return a
				single-dimension array of pixel values.
			--->
			<cfset local.pixelBuffer = local.bufferedImage.getRGB(
				javaCast( "int", local.x ),
				javaCast( "int", local.y ),
				javaCast( "int", local.pixelWidth ),
				javaCast( "int", local.pixelHeight ),
				javaCast( "null", "" ),
				javaCast( "int", 0 ),
				javaCast( "int", local.pixelWidth )
				) />

			<!---
				Now that we have the colors, we want to average
				them together. However, we can't simply use the
				integer to average; rather, we have to pick out
				the individual R,G,B channels and average them
				seperately.
			--->
			<cfset local.red = 0 />
			<cfset local.green = 0 />
			<cfset local.blue = 0 />

			<!---
				Loop over each pixel color value in our current
				pixel buffer.
			--->
			<cfloop
				index="local.pixelColor"
				array="#local.pixelBuffer#">

				<!---
					Using Bit-wise SHIFTing and ANDing, get
					each of the color channels and add it to
					the running sum.

					NOTE: I am not taking into account the ALPHA
					channel which would require another 24 bit
					right-shift.
				--->

				<!--- Red. --->
				<cfset local.red += bitAnd(
					bitSHRN( local.pixelColor, 16 ),
					255
					) />

				<!--- Green. --->
				<cfset local.green += bitAnd(
					bitSHRN( local.pixelColor, 8 ),
					255
					) />

				<!--- Blue. --->
				<cfset local.blue += bitAnd(
					local.pixelColor,
					255
					) />

			</cfloop>

			<!---
				Now that we have summed the R,G,B channels, we can
				average them together.
			--->

			<!--- Red. --->
			<cfset local.redAverage = fix(
				local.red / arrayLen( local.pixelBuffer )
				) />

			<!--- Green. --->
			<cfset local.greenAverage = fix(
				local.green / arrayLen( local.pixelBuffer )
				) />

			<!--- Blue. --->
			<cfset local.blueAverage = fix(
				local.blue / arrayLen( local.pixelBuffer )
				) />

			<!---
				Now that we have averaged the individual colors,
				we need to merge them together to create a full,
				RGB integer value.

				NOTE: Again, I am not taking the ALPHA channel
				into account.
			--->
			<cfset local.pixelAverage = bitOr(
				bitOr(
					bitSHLN( local.redAverage, 16 ),
					bitSHLN( local.greenAverage, 8 )
					),
				local.blueAverage
				) />

			<!---
				Now that we have the average, we want to
				overwrite every array value in the pixel buffer
				with the given, average color. However, since
				ColdFusion doesn't play nicely with true Java
				arrays, we'll create our own arrray.
			--->
			<cfset local.averagePixelBuffer = [] />

			<!---
				Set NxN indicies of the ColdFusion array with the
				pixel color average (we will convert it to a Java
				array in the succeeding step).
			--->
			<cfset arraySet(
				local.averagePixelBuffer,
				1,
				(local.pixelWidth * local.pixelHeight),
				local.pixelAverage
				) />

			<!---
				Now that we have our new average RGB color array,
				let's write it back to the buffered image.

				NOTE: We are casting our ColdFusion array to a
				Java int array.
			--->
			<cfset local.bufferedImage.setRGB(
				javaCast( "int", local.x ),
				javaCast( "int", local.y ),
				javaCast( "int", local.pixelWidth ),
				javaCast( "int", local.pixelHeight ),
				javaCast( "int[]", local.averagePixelBuffer ),
				javaCast( "int", 0 ),
				javaCast( "int", local.pixelWidth )
				) />

			<!---
				NOTE: Editing the buffered image has a direct
				affect on the image from which we retrieved the
				buffered image. It is passed by REFERENCE!

				As such, we don't need to explicitly move the
				updated buffered image data "back" into the
				image for the changes to take place.
			--->

		</cfloop>

	</cfloop>

	<!---
		Return out. No need to return the original image since
		it is be altered directly.... I don't really care for this
		strategy, but it keeps in line with the exisitng image
		functions provided by ColdFusion.
	--->
	<cfreturn />
</cffunction>

<!--- Read in the image. --->
<cfimage
	name="muscle"
	action="read"
	source="./muscle2.jpg"
	/>

<cfoutput>

	<div align="center">

		<h3>
			Original Image
		</h3>

		<p>
			<cfimage
				action="writetobrowser"
				source="#muscle#"
				/>
		</p>


		<!---
			Now, let's loop over a few different pixel sizes and
			apply each to the *original* image.
		--->
		<cfloop
			index="pixelSize"
			from="5"
			to="30"
			step="5">

			<!---
				Copy the original image since the pixelation is
				applied directly to the image passed-in.
			--->
			<cfset testMuscle = imageCopy(
				muscle,
				0,
				0,
				imageGetWidth( muscle ),
				imageGetHeight( muscle )
				) />

			<!---
				Pixelate the image using the given pixel size of
				this iteration.
			--->
			<cfset imagePixelate( testMuscle, pixelSize ) />

			<!--- Output the image. --->
			<h3>
				Pixel Size: #pixelSize#
			</h3>

			<p>
				<cfimage
					action="writetobrowser"
					source="#testMuscle#"
					/>
			</p>

		</cfloop>

	</div>

</cfoutput>