/**
 * Uses Google Maps Geocoder (V3) to get postal code for an address.  Uses first address match.
 * @param String Address - Make sure to include at least the street address, city and state.
 * @return String - Zip code on success, blank if a zip code is failed to be retrieved.
 */
function zip_code_from_address($address)
{
   $ura = rawurlencode($address);
   $rurl = "http://maps.googleapis.com/maps/api/geocode/xml?sensor=false&address=$ura";
   $dom = new DOMDocument();
   $res = $dom->loadXML(file_get_contents($rurl));
   if($res)
   {
      if($status = $dom->getElementsByTagName('status')->item(0))
      {
         if($status->nodeValue == 'OK')
         {
            //If status is OK, then at least one result should be here.
            $result = $dom->getElementsByTagName('result')->item(0);
            $postalcode = '';
            foreach($result->getElementsByTagName('address_component') as $comp)
            {
               if($comp->getElementsByTagName('type')->item(0)->nodeValue == 'postal_code')
               {
                  $postalcode = $comp->getElementsByTagName('short_name')->item(0)->nodeValue;
               }
            }
            return $postalcode;
         }
         else
         {
            return '';
         }
      }
   }
   else
   {
      return '';
   }
}

<?php
 
/**
 * Determines the bounding box of a specific path, rectangle, polygon, or ellipses
 * in an SVG.  Accepts the SVG's DOM, and the node specifically desired to be checked.
 * Assumes convert is at /usr/bin/convert unless a global called $convertpath is set.
 *
 * @param DOMDocument $svg SVG DOMDocument to use to find this item's bounding box.
 * @param DOMDocument $object Node that we want to find the bounding box for.
 * @param Float $precision Precision desired, 1 is rougly pixel-accurate, between 0.1 and 1 is less than pixel accurate
 *   and anything above 1 should be sub-pixel accurate.  (Max is 3)
 * @return Mixed Boolean false on failure, Array with topleft-x, topleft-y, bottomright-x, bottomright-y in percentages
 */
function discover_bounding_box($svg, $object, $precision = 1)
{
   global $convertpath;
   $convert = isset($convertpath) ? $convertpath : '/usr/bin/convert';
   // We assume density 72 is the pixel-size accurate 
   $density = 72;
   if($precision >= 0.1 && $precision <= 3)
   {
       $density = floor(72*$precision);
   }
 
   $singlesvg = create_single_object_svg($svg, $object);
 
 
   //Now that we've got the SVG in hand, let's pass it on to process image.
   ob_start();
   process_image($singlesvg, '-trim', 'svg', 'info', "-density $density");
   $info = trim(ob_get_clean());
 
   //Tokenize the fragments of text from our friend, ImageMagick.
   $fragments = explode(' ', $info);
 
   list($trimmed_width, $trimmed_height) = explode('x', $fragments[2]);
   //If both intval'd are not 0, then we can assume that all when well.
   if( ($trimmed_width = intval($trimmed_width)) > 0 && ($trimmed_height = intval($trimmed_height)) > 0)
   {
      //Now get the original width, original height, clip offsetx and clip offsety
      list($original_width, $original_height, $clip_offsetx, $clip_offsety) = 
         array_map('_intval', explode('+', str_replace('x', '+', $fragments[3])));
 
      $bounding_top_left_x = $clip_offsetx/$original_width;
      $bounding_top_left_y = $clip_offsety/$original_height;
      $bounding_bottom_right_x = ($clip_offsetx+$trimmed_width)/$original_width;
      $bounding_bottom_right_y = ($clip_offsety+$trimmed_height)/$original_height;
 
      return array($bounding_top_left_x, $bounding_top_left_y, 
         $bounding_bottom_right_x, $bounding_bottom_right_y);
   }
 
   return false;
}
 
 
/**
 * Creates an extract from an SVG based on an input DOM and desired object.
 * @param DOMDocument $svg A fully loaded DOMDocument for the SVG.
 * @param DOMNode $object Target node to extract.
 * @return String Returns an SVG file containing only the desired object.  At present
 * this function also removes patterns and gradients which may be a notable problem in 
 * cases where you want to find the visible bounding box of an object, not necessarily
 * it's exact box.
 */
function create_single_object_svg($svg, $object)
{
   //Get the width and height of the current document.
   $root = $svg->getElementsByTagName('svg')->item(0);
   $width = htmlspecialchars($root->getAttribute('width'));
   $height = htmlspecialchars($root->getAttribute('height'));
 
   //It's best if you have a solid color set in the style or fill attribute
   //but it shouldn't be that big a deal.   
 
   //Get an transforms from group nodes.
   $transforms = array();
   $current = $object;
   while($current->parentNode) //Continue climbing until there's no where else to climb to.
   {
      $current = $current->parentNode;
      if($current->nodeName == 'g')
      {
         $transforms[] = $current->getAttribute('transform');
      }
   }
 
 
/**
 * Run stuff through image_magick uses the global convert path settings.  Outputs image on success (and sets header)
 * @param String $imgdata Raw image file data to pipe to image magick.
 * @param String $processing_instruction Command line options to pass to image magick's convert program.
 * @param String $inputtype Default: jpg Input image format.
 * @param String $outputtype Default: jpg Output image format.
 * @param String $preload_instructions Add instructions that go before the file to load.
 * @return void
 */
function process_image($imgdata, $processing_instruction, $inputtype = 'jpg', $outputtype = 'jpg', $preload_instructions = '')
{
   global $convertpath;
 
   if(function_exists('proc_open'))
   {
      //Let's just pipe to imagemagick to handle our graphics transform shall we?
      $descriptors = array(
         '0' => array("pipe", 'r'),
         '1' => array("pipe", 'w'),
         '2' => array("file", "/dev/null", "w")
      );
 
      $pipes = array();
      $process = proc_open($command = "$convertpath $preload_instructions {$inputtype}:- $processing_instruction {$outputtype}:-", $descriptors, $pipes, NULL, NULL, array('binary_pipes' => true));
      //die($command);
      if($process)
      {
         fwrite($pipes[0], $imgdata);
         //fwrite($pipes[0], EOF);
         fclose($pipes[0]);
         $contents = stream_get_contents($pipes[1]);
         proc_close($process);
 
         if(strlen($contents) > 50 || $outputtype == 'info')
         {
            echo $contents;
         }
         else
         {
            header('HTTP/1.1 500 Internal Error');
            header('content-type: text/plain');
            echo 'Failed to process image.';
         }
      }
      else
      {
         //Poor process died.  Should we do something?
         header('HTTP/1.1 500 Internal Error');
         header('content-type: text/plain');
         echo 'Failed to process image.';               
      }
   }
}
 
?>

<?php
/**
 * img_resize_crop
 * Resizes an image to a specific size, cropping if necessary, allows center-weighting.
 *
 * @param Resource $src - GD Resource Image to use.
 * @param Integer $twidth - Thumbnail width
 * @param Integer $theight - Thumbnail height
 * @param Integer $center_x - The x value of the target center location, leaving it at -1 autocalculates. [Default: -1]
 * @param Integer $center_y - The y value of the target center location, leaving it at -1 autocalculates. [Default: -1]
 * @param String $method - Method to use for the resize.  [Default:suggest]
 *   'suggest' (provided center coordinate is only guaranteed to be in the picture.)
 *   'force' (The provided coordinate is forced into being the center, additional data is trimmed to ensure this.)
 *   'onlycrop' (Not sure why you would use this, but only performs cropping.)
 * @param Boolean $sharpen - Specify whether or not to sharpen the resultant thumbnail [Default:true]
 * @param Int $evil_threshold - Maximum thumbnail width/height to prevent attempts at evil. [Default:1024]
 */
function img_resize_crop($src, $twidth, $theight, $center_x = -1, 
    $center_y = -1, $method = 'suggest', $sharpen = true, $evil_threshold = 1024)
{
   /*Set defaults if they are not provided.*/
   if($center_x == -1 || ($method == 'force' && $center_x == 0))
   {
      $center_x = floor(imagesx($src)/2);
   }
 
   if($center_y == -1 || ($method == 'force' && $center_y == 0))
   {
      $center_y = floor(imagesy($src)/2);
   }
 
   /* Prevent evil */
   if($twidth > $evil_threshold) $twidth = $evil_threshold;
   if($theight > $evil_threshold) $theight = $evil_threshold;
 
 
   /*  The ratio of the thumbnail and the ratio 
    of the original image.*/
   $t_ratio = $twidth / $theight;
   $o_ratio = imagesx($src) / imagesy($src);
   $new = imagecreatetruecolor($twidth, $theight);
 
   /*Ideally, we'll want to grab as much of 
     the source image as possible.
 
     So we need to figure out how much to grab based on 
     the ratios of the desired thumbnail and the original
     image.*/
   if($t_ratio > $o_ratio)
   {
      $i_width = imagesx($src);
      $i_height = floor($i_width / $t_ratio);
   }
   else
   {
      $i_height = imagesy($src);
      $i_width = floor($i_height * $t_ratio);
   }
 
   /*Calculate the upper-left corner of the 
     source image grab area.  These will be 
     adjusted differently based on the method selected.*/
   $s_x = $center_x - floor($i_width/2);
   $s_y = $center_y - floor($i_height/2);
 
 
 
   switch($method)
   {
      case 'onlycrop':  
         $i_width = (imagesx($src) > $twidth) ? $twidth : imagesx($src);
         $i_height = (imagesy($src) > $theight) ? $theight : imagesy($src);
         $s_x = $center_x - floor($i_width/2);
         $s_y = $center_y - floor($i_height/2);   
 
         /*Make sure we're inside the left and top boundaries.*/
         $s_x = ($s_x < 0) ? 0 : $s_x;
         $s_y = ($s_y < 0) ? 0 : $s_y;
 
         /*Make sure we're inside the bottom and right boundaries.*/
         $s_x = ($center_x + ceil($i_width/2) > imagesx($src)) ? imagesx($src) - $i_width : $s_x;
         $s_y = ($center_y + ceil($i_height/2) > imagesy($src)) ? imagesy($src) - $i_height : $s_y;  
 
         break;      
      default:
      case 'suggest':
         /*Condition: Crop is thinner (ratio-wise) than the original image.*/
         if($t_ratio <= $o_ratio)
         {
            $s_y = 0;
            $s_x = ($s_x < 0) ? 0 : $s_x;
            $s_x = ($center_x + ceil($i_width/2) > imagesx($src)) ? imagesx($src) - $i_width : $s_x;
         }
         else /*Condition: Crop is wider (ratio-wise) than the original image.*/
         {
            $s_x = 0;
            $s_y = ($s_y < 0) ? 0 : $s_y;
            $s_y = ($center_y + ceil($i_height/2) > imagesy($src)) ? imagesy($src) - $i_height : $s_y;   
         }
         break;
      case 'force':
         /*Condition: Crop is thinner (ratio-wise) than the original image.*/
         if($t_ratio <= $o_ratio)
         {
            /*Find the maximum possible height with the requested center_y.*/
            $i_height = ($center_y > floor(imagesy($src)/2)) ? (imagesy($src) - $center_y) * 2 : $center_y * 2;
            $i_width = floor($i_height * $t_ratio); /*Height for said width.*/
 
            /*If that puts the source box out of bounds, we'll need to proportionally scale down.*/
            if($center_x - floor($i_width/2) < 0 || $center_x + floor($i_width/2) > imagesx($src))
            {
               /*Minimum width.*/
               $i_width = ($center_x > floor(imagesx($src)/2)) ? (imagesx($src) - $center_x) * 2 : $center_x * 2;
               $i_height = floor($i_width / $t_ratio);
            }
            /*Recalculate source x and y*/
            $s_x = $center_x - floor($i_width/2);
            $s_y = $center_y - floor($i_height/2);            
         }
         else /*Condition: Crop is wider (ratio-wise) than the original image.*/
         {
            /*Find the maximum possible width with the requested center_x.*/
            $i_width = ($center_x > floor(imagesx($src)/2)) ? (imagesx($src) - $center_x) * 2 : $center_x * 2;
            $i_height = floor($i_width / $t_ratio); /*Height for said width.*/
 
            /*If that puts the source box out of bounds, we'll need to proportionally scale down.*/
            if($center_y - floor($i_height/2) < 0 || $center_y + floor($i_height/2) > imagesy($src))
            {
               /*Minimum height.*/
               $i_height = ($center_y > floor(imagesy($src)/2)) ? (imagesy($src) - $center_y) * 2 : $center_y * 2;
               $i_width = $i_height * $t_ratio;
            }
            /*Recalculate source x and y*/
            $s_x = $center_x - floor($i_width/2);
            $s_y = $center_y - floor($i_height/2);
         }
 
         break;
   }
 
   imagecopyresampled($new, $src, 
     /*Destination Coords*/
     0,0,
     /*Source Coords*/
     $s_x,$s_y,
     /*Destination Geometry*/
     $twidth, $theight,
     /*Source Geometry*/
     $i_width, $i_height
     );
 
   if($sharpen)
   {
      $sharpen_matrix = array(array(-1,-1,-1),array(-1,16,-1),array(-1,-1,-1));
      $divisor = 8;
      $offset = 0;
 
      imageconvolution($new, $sharpen_matrix, $divisor, $offset);
   }
 
   return $new;
}