Get weather info using PHP and Yahoo

Some time ago, I searched for a quick and simple way of getting a weather info for any place and putting it onto webpage. There is a lot of commercial services, which give you great data, but I wanted a completely free solution. After a lot of trying and testing, I decided to use Yahoo services for that -
using Yahoo Weather API, it's very easy to get detailed weather data for almost every place on Earth.

To get the weather data, first we need a WOEID identificator for the place we need the data for. To get it, we can use YQL to query the Yahoo's "geo.places":

Example:

$address = "Brooklyn, New York, USA";
$f = file_get_contents("http://query.yahooapis.com/v1/public/yql?q=".urlencode('select * from geo.places where text="'.$address.'"')."&format=xml");
preg_match("~<woeid>([0-9]+)<\/woeid>~i", $f, $r);
$woeid = intval($r[1]);

Now we have $woeid for address "Brooklyn, New York, USA". To get the weather data, we use it like this:

$f = file_get_contents("http://weather.yahooapis.com/forecastrss?w=".$woeid);
preg_match("~<description><!\[CDATA\[(.*?)\]\]><\/description>~is", $f, $r);
$weather = trim($r[1]);
echo $weather;

The weather data is pre-formatted with illustrative weather icon etc., but it's sufficient for most needs.

Demo

See the demo here.

Source code

See the source code here.

Dynamic PHP watermarking with ImageMagick

In one of our previous articles, we covered a very basic technique to add watermark to image using PHP and GD. This technique will add a transparent watermark to target image - disadvantage being that the watermark is a part of the final image "for good". That means, if you need to change the watermark on already watermarked images, you will need the original images to re-watermark them, and that means more disk space used and generally more data to handle.

In this article, we will show how to make a flexible watermarking routine which enables to change the watermark anytime without the need to store both the original and watermarked images (although the watermarked images ARE in fact stored on disk, but only for caching). The watermarking itself will be done using ImageMagick, but it can be done using basic GD too (but that is not covered in this article).

Let's have a folder with the source images "source_images". Then, we have the watermark image, "watermark.png" and the folder to store the watermarked images, "output_images". The routine looks like this:

$photo = $_GET['photo'];
 
$src = 'source_images/'.$photo;
$dst = 'output_images/'.$photo;
 
$watermark_image = 'watermark.png';
 
$create_watermark = false;
 
if(file_exists($dst)) {
   $t_img = filemtime($dst);
   $t_wm = filemtime($watermark_image);
   if($t_wm > $t_img) $create_watermark = true;
}
 
if(!file_exists($dst) || $create_watermark) {
	$cmd = "composite -dissolve 50% -gravity south-east ".$watermark_image." ".$src." ".$dst;
	exec($cmd);
}
 
header("Content-type: image/jpeg");
$f = file_get_contents($dst);
echo $f;

Note that this code does not cover security issues - in a production environment, you will have to sanitize the $_GET['photo'] variable in order to disallow access to other folders:

$photo = $_GET['photo'];  // Just a very simple and basic protection...
$photo = str_replace('..', '', $photo);
$photo = str_replace('/', '', $photo);
$photo = str_replace('\\', '', $photo);

The routine creates an image with the watermark when needed. The watermark will be placed in the bottom - right corner (the parameter -gravity south-east in the ImageMagick command line), but you can place it anywhere (see documentation). If the image already exists, it is used without needing to re-create the watermark again. But, if the watermark image itself is updated, all images will be updated too when needed.

The routine is to be called like this (let's pretend we saved the source as watermark.php):

<img src="watermark.php?photo=my_image.jpg" />

PHP Image Watermarking

This is a very simple technique we are using to watermark images when needed. Some time ago, we built a project which involved a lot of high-quality photos and we didn't want them to get stolen by anyone. The watermarking must meet the following criteria:

• the watermark image must be large enough and placed well to make the retouch of photos very difficult, if not impossible
• the watermark must consist of various colors to make the retouch even more difficult
• the watermark must be soft and transparent enough not to ruin the viewing experience

Based on point 1, we decided that the watermark must be in the center of the image, and large enough to make the cropping (and using only portions of the image without the watermark) difficult.

Point 2 can be solved by “bevelling” the watermark to add shadows and highlights. This way, we get many shades of gray and such watermark will be much harder to retouch or remove from the picture.

Point 3 just means that we need to find a good balance between visibility (alpha) of the watermark and the softness of it's colors and edges not to ruin the viewing experience.

The code

We use simple GD functions to draw the watermark. For the watermark itself, we use a transparent PNG image. To paint the watermark into the output image, we use imageline() function to draw a single-pixel line to the centre of the image.

<?php
  $source = “source.jpg”;
  $watermark = “watermark.png”;
  $output = “output.jpg”;
 
  $pic = imagecreatefromjpeg($source);
  $wm = imagecreatefrompng($watermark);
 
  imagesetbrush($pic, $wm);
  $siz = getimagesize($source);
  $xp = $siz[0] / 2 ;
  $yp = $siz[1] / 2 ;
  imageline($pic, $xp, $yp, $xp, $yp, IMG_COLOR_BRUSHED );
 
  imagejpeg($output, 90);
 
  imagedestroy($wm);
  imagedestroy($pic);
?>

Download

Download source files

Intelligent image cropping

Some web applications need to have an automatic thumbnail generation system, which makes nice thumbnails of bigger pictures uploaded by its visitors, registered users or whomever else. Most of the time a simple aspect-ratio-keeping resizing is enough:

Simple and nice. But this is of course an ideal case - basically square picture resized to square thumbnail. That won't be the case every time. Most of the time, the source images would be too wide or too tall to fit nicely into the desired thumbnail size:

Doesn't look too good, does it?. Especially when thumbnails of various wide or tall photos are next to each other, out of whack:

Intelligent image cropping

One of the solutions to this problem, which we use a lot, is what we call „intelligent image cropping“. The idea is based on two simple rules:

1. the thumbnail should always be fully filled with the image, no empty borders
2. the image must be resized with aspect-ratio preserved

Because of these two rules, it is clear that most of the time, the source image will have to be cropped to some extent. And why not? The purpose of thumbnails is not to show the whole image, but to give the visitor a rough idea, what the big picture is about.

The code

Here is the whole thing:

  static function cropTo($pic, $dest, $dw, $dh)
  {
      $siz = getimagesize($pic);
      if($siz[0] >= $siz[1]) {
        $fact = $dh / $siz[1];
      } else {
        $fact = $dw / $siz[0];
      }
      $new_w = $siz[0] * $fact;
      $new_h = $siz[1] * $fact;
 
      switch ($siz[2]) {
          case 1: $src_img = imagecreatefromgif($pic); break;
          case 2: $src_img = imagecreatefromjpeg($pic); break;
          case 3: $src_img = imagecreatefrompng($pic); break;
          default: return false;
      }
      if (!$src_img) return false;
 
      $xp = $dw/2 - $siz[0]/2;
      $yp = $dh/2 - $siz[1]/2;
 
      $tmp_img = imagecreatetruecolor($new_w, $new_h);
      $dst_img = imagecreatetruecolor($dw, $dh);
 
      $xp = $new_w/2 - $dw/2;
      $yp = $new_h/2 - $dh/2;
 
     	imagecopyresampled($tmp_img, $src_img, 0, 0, 0, 0, $new_w, $new_h, $siz[0], $siz[1]);
       imagecopyresampled($dst_img, $tmp_img, 0, 0, $xp, $yp, $dw, $dh, $dw, $dh);
 
      imagejpeg($dst_img, $dest, 99); 
 
      imagedestroy($dst_img);
      imagedestroy($tmp_img);
      imagedestroy($src_img);
 
  }

No need for long explanations here - just a set of basic PHP functions along with some calculations. Use the function and see for yourself

Caching

It's obvious that this function can be quite resource-demanding, especially when generating large numbers of thumbnails. Re-using already generated thumbnails would be a nice idea. We just add a couple of lines to the source code:

  static function cropTo($pic, $dest, $dw, $dh)
  {
 
      // new code - caching:
 
      if(file_exists($dest)) {
        $ti = filemtime($pic);
        $to = filemtime($dest);
        if($to > $ti) return;
      }
 
      // old code continues...
 
      $siz = getimagesize($pic);
      if($siz[0] >= $siz[1]) {
	 ...

This code allows us to reuse already generated thumbnails when needed - or in other words it prevents the regeneration of already existing thumbnails. It compares the modification time of the source and destination files (destination file = the generated thumbnail) and only generates a new thumbnail when the source file is newer than the stored thumbnail.

Download

Download source files