class _imce_watermark in IMCE Watermark 7

Hierarchy

• class \_imce_watermark

File

./imce_watermark.module, line 406

Adding watermark at IMCE image uploading.

class _imce_watermark {

  /**
   * Watermarking image type
   *
   * @var string
   */
  var $image_type = "jpg";

  # given two images, return a blended watermarked image
  function create_watermark($filepath, $watermark_filepath, $watermark_setting) {
    $main_img_obj = $this
      ->create_image($filepath, TRUE);
    if (!$main_img_obj) {
      form_set_error(NULL, t('Creating image object failed, please refer to site administrator...'));
      return FALSE;
    }
    $watermark_img_obj = $this
      ->create_image($watermark_filepath);
    if (!$watermark_img_obj) {
      form_set_error(NULL, t('Creating watermark image object failed, please refer to site administrator...'));
      return FALSE;
    }
    $alpha_level = $watermark_setting['imce_watermark_alpha'] / 100;

    # convert 0-100 (%) alpha to decimal

    # calculate our images dimensions
    $main_img_obj_w = imagesx($main_img_obj);
    $main_img_obj_h = imagesy($main_img_obj);
    $watermark_img_obj_w = imagesx($watermark_img_obj);
    $watermark_img_obj_h = imagesy($watermark_img_obj);
    $vm = $watermark_setting['imce_watermark_vertical_margin'];
    $hm = $watermark_setting['imce_watermark_horizontal_margin'];
    switch ($watermark_setting['imce_watermark_horizontal_position']) {
      case 0:
        $main_img_obj_min_x = $hm;
        $main_img_obj_max_x = $watermark_img_obj_w + $hm;
        break;
      case 1:

        # determine center position coordinates
        $main_img_obj_min_x = floor($main_img_obj_w / 2 - $watermark_img_obj_w / 2) + $hm;
        $main_img_obj_max_x = ceil($main_img_obj_w / 2 + $watermark_img_obj_w / 2) + $hm;
        break;
      case 2:
        $main_img_obj_min_x = $main_img_obj_w - $watermark_img_obj_w + $hm;
        $main_img_obj_max_x = $main_img_obj_w + $hm;
        break;
    }
    switch ($watermark_setting['imce_watermark_vertical_position']) {
      case 0:
        $main_img_obj_min_y = $vm;
        $main_img_obj_max_y = $watermark_img_obj_h + $hm;
        break;
      case 1:
        $main_img_obj_min_y = floor($main_img_obj_h / 2 - $watermark_img_obj_h / 2) + $hm;
        $main_img_obj_max_y = ceil($main_img_obj_h / 2 + $watermark_img_obj_h / 2) + $hm;
        break;
      case 2:
        $main_img_obj_min_y = $main_img_obj_h - $watermark_img_obj_h + $vm;
        $main_img_obj_max_y = $main_img_obj_h + $hm;
        break;
    }

    # create new image to hold merged changes
    $return_img = imagecreatetruecolor($main_img_obj_w, $main_img_obj_h);

    # walk through main image
    for ($y = 0; $y < $main_img_obj_h; $y++) {
      for ($x = 0; $x < $main_img_obj_w; $x++) {
        $return_color = NULL;

        # determine the correct pixel location within our watermark
        $watermark_x = $x - $main_img_obj_min_x;
        $watermark_y = $y - $main_img_obj_min_y;

        # fetch color information for both of our images
        $main_rgb = imagecolorsforindex($main_img_obj, imagecolorat($main_img_obj, $x, $y));

        # if our watermark has a non-transparent value at this pixel intersection

        # and we're still within the bounds of the watermark image
        if ($watermark_x >= 0 && $watermark_x < $watermark_img_obj_w && $watermark_y >= 0 && $watermark_y < $watermark_img_obj_h) {
          $watermark_rbg = imagecolorsforindex($watermark_img_obj, imagecolorat($watermark_img_obj, $watermark_x, $watermark_y));

          # using image alpha, and user specified alpha, calculate average
          $watermark_alpha = round((127 - $watermark_rbg['alpha']) / 127, 2);
          $watermark_alpha = $watermark_alpha * $alpha_level;

          # calculate the color 'average' between the two - taking into account the specified 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);

          # calculate a color index value using the average RGB values we've determined
          $return_color = $this
            ->_get_image_color($return_img, $avg_red, $avg_green, $avg_blue);

          # if we're not dealing with an average color here, then let's just copy over the main color
        }
        else {
          $return_color = imagecolorat($main_img_obj, $x, $y);
        }

        # END if watermark

        # draw the appropriate color onto the return image
        imagesetpixel($return_img, $x, $y, $return_color);
      }

      # END for each X pixel
    }

    # END for each Y pixel

    # return the resulting, watermarked image for display

    //return $return_img;

    // Overwrite existing with current and certain file type.
    switch ($this->image_type) {
      case 'gif':
        return imagegif($return_img, $filepath);
      case 'png':
        return imagepng($return_img, $filepath);
      case 'bmp':
        return image2wbmp($return_img, $filepath);
      default:
        return imagejpeg($return_img, $filepath);
    }
    return FALSE;
  }

  # END create_watermark()

  # average two colors given an alpha
  function _get_ave_color($color_a, $color_b, $alpha_level) {
    return round($color_a * (1 - $alpha_level) + $color_b * $alpha_level);
  }

  # END _get_ave_color()

  # return closest pallette-color match for RGB values
  function _get_image_color($im, $r, $g, $b) {
    $c = imagecolorexact($im, $r, $g, $b);
    if ($c != -1) {
      return $c;
    }
    $c = imagecolorallocate($im, $r, $g, $b);
    if ($c != -1) {
      return $c;
    }
    return imagecolorclosest($im, $r, $g, $b);
  }

  /**
   * This little function allows you to create an image based on the popular image types without worrying about what it is:
   * http://www.php.net/manual/ru/function.imagecreatefromjpeg.php#110547
   * @param type $filepath
   * @return boolean
   */
  function create_image($filepath, $set_image_type = FALSE) {
    $img_type = $this->image_type;
    $type = exif_imagetype($filepath);

    // [] if you don't have exif you could use getImageSize()
    $allowedTypes = array(
      1,
      // [] gif
      2,
      // [] jpg
      3,
      // [] png
      6,
    );
    if (!in_array($type, $allowedTypes)) {
      return false;
    }
    switch ($type) {
      case 1:
        $img_type = 'gif';
        $im = imageCreateFromGif($filepath);
        break;
      case 2:
        $img_type = 'jpg';
        $im = imageCreateFromJpeg($filepath);
        break;
      case 3:
        $img_type = 'png';
        $im = imageCreateFromPng($filepath);
        break;
      case 6:
        $img_type = 'bmp';
        $im = imageCreateFromBmp($filepath);
        break;
    }
    if ($set_image_type) {
      $this->image_type = $img_type;
    }
    return $im;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
_imce_watermark::$image_type		property	Watermarking image type
_imce_watermark::create_image		function	This little function allows you to create an image based on the popular image types without worrying about what it is: http://www.php.net/manual/ru/function.imagecreatefromjpeg.php#110547
_imce_watermark::create_watermark		function
_imce_watermark::_get_ave_color		function
_imce_watermark::_get_image_color		function