function watermark::create_watermark in ImageCache Actions 6.2

Same name and namespace in other branches

1. 8 watermark.inc \watermark::create_watermark()
2. 5.3 watermark.inc \watermark::create_watermark()
3. 5.2 watermark.inc \watermark::create_watermark()
4. 6 watermark.inc \watermark::create_watermark()
5. 7 watermark.inc \watermark::create_watermark()

File

./watermark.inc, line 18

routine for image layering

Class

watermark

Code

function create_watermark($main_img_obj, $watermark_img_obj, $x_ins, $y_ins, $alpha_level = 100) {
  $alpha_level /= 100;
  $base_img_obj_w = imagesx($main_img_obj);
  $base_img_obj_h = imagesy($main_img_obj);

  # Should this change to match both images?
  $main_img_obj_w = max($base_img_obj_w, imagesx($watermark_img_obj));
  $main_img_obj_h = max($base_img_obj_h, imagesy($watermark_img_obj));

  // dman: start with the MAX dimensions,
  // then let the caller crop it later according to its own logic.
  $watermark_img_obj_w = imagesx($watermark_img_obj);
  $watermark_img_obj_h = imagesy($watermark_img_obj);
  $main_img_obj_min_x = $x_ins;
  $main_img_obj_min_y = $y_ins;
  $return_img = imagecreatetruecolor($main_img_obj_w, $main_img_obj_h);
  imagesavealpha($return_img, TRUE);
  imagealphablending($return_img, FALSE);

  // Support indexed color (gif) if I have to
  $transparent_ix = imagecolortransparent($main_img_obj);
  if ($transparent_ix >= 0) {
    $transparent = imagecolorsforindex($main_img_obj, $transparent_ix);

    // Allocate the values to the new image and get new color.
    $transparent = imagecolorallocatealpha($return_img, $transparent['red'], $transparent['green'], $transparent['blue'], $transparent['alpha']);
    imagecolortransparent($return_img, $transparent);
  }
  $watermark_transparent_ix = imagecolortransparent($watermark_img_obj);
  if ($watermark_transparent_ix >= 0) {
    $watermark_transparent = imagecolorsforindex($watermark_img_obj, $watermark_transparent_ix);
  }
  for ($y = 0; $y < $main_img_obj_h; $y++) {
    for ($x = 0; $x < $main_img_obj_w; $x++) {
      $return_color = NULL;
      $watermark_x = $x - $main_img_obj_min_x;
      $watermark_y = $y - $main_img_obj_min_y;
      if ($x < $base_img_obj_w && $y < $base_img_obj_h) {

        // try not to go out of bounds when looking for color.
        $main_rgb = imagecolorsforindex($main_img_obj, imagecolorat($main_img_obj, $x, $y));
      }
      else {
        $main_rgb = array(
          'red' => 255,
          'green' => 255,
          'blue' => 255,
          'alpha' => 127,
        );
      }
      if ($watermark_x >= 0 && $watermark_x < $watermark_img_obj_w && $watermark_y >= 0 && $watermark_y < $watermark_img_obj_h) {
        $color_ix = imagecolorat($watermark_img_obj, $watermark_x, $watermark_y);
        $watermark_rbg = imagecolorsforindex($watermark_img_obj, $color_ix);

        // Gif indexed color ?
        if ($color_ix == $watermark_transparent_ix) {
          $watermark_rbg['alpha'] = 127;
        }
        $watermark_alpha = round((127 - $watermark_rbg['alpha']) / 127, 2);
        $watermark_alpha = $watermark_alpha * $alpha_level;
        $avg_red = $this
          ->_get_ave_color($main_rgb['red'], $watermark_rbg['red'], $watermark_alpha);
        $avg_green = $this
          ->_get_ave_color($main_rgb['green'], $watermark_rbg['green'], $watermark_alpha);
        $avg_blue = $this
          ->_get_ave_color($main_rgb['blue'], $watermark_rbg['blue'], $watermark_alpha);

        // TODO figure out the maths for merging two transparent images
        $new_alpha = min($watermark_rbg['alpha'], $main_rgb['alpha']);

        #$new_alpha = $main_rgb['alpha'];

        #$new_alpha = 0;
        $return_color = $this
          ->_get_image_color($return_img, $avg_red, $avg_green, $avg_blue, $new_alpha);
      }
      else {

        // Point is out of bounds from the watermark. Return the normal image color
        // allow watermark to overflow from the image. Rare, but could be useful
        if ($x > imagesx($main_img_obj) || $y > imagesy($main_img_obj)) {

          // Point is out of bounds from the main image too. Return transparent
          $watermark_rbg = imagecolorsforindex($watermark_img_obj, imagecolorat($watermark_img_obj, $watermark_x, $watermark_y));
          $watermark_alpha = 0;

          #round(((127 - $watermark_rbg['alpha']) / 127), 2);
          $return_color = $this
            ->_get_image_color($return_img, $watermark_rbg['red'], $watermark_rbg['green'], $watermark_rbg['blue'], $watermark_alpha);
        }
        else {
          $return_color = imagecolorat($main_img_obj, $x, $y);
        }
      }
      if ($return_color == $transparent_ix) {
        $return_color = $transparent;
      }
      imagesetpixel($return_img, $x, $y, $return_color);
    }
  }
  return $return_img;
}