Search:

CWIS Developers Documentation

  • Main Page
  • Classes
  • Files
  • File List
  • File Members

SPTImage.php

Go to the documentation of this file.
00001 <?PHP
00002 #
00003 #   FILE:  SPTImage.php
00004 #
00005 #   METHODS PROVIDED:
00006 #       SPTImage($ImageIdOrFileNameOrImageObj,
00007 #                   $MaxPreviewWidth = NULL, $MaxPreviewHeight = NULL,
00008 #                   $MaxThumbnailWidth = NULL, $MaxThumbnailHeight = NULL)
00009 #           - object constructor
00010 #       Delete()
00011 #           - delete image and associated files and data
00012 #       AltText($NewValue = NULL)
00013 #           - get/set alt text attribute
00014 #       Id()
00015 #       Url()
00016 #       PreviewUrl()
00017 #       ThumbnailUrl()
00018 #       Format()
00019 #       Height()
00020 #       Width()
00021 #       PreviewHeight()
00022 #       PreviewWidth()
00023 #       ThumbnailHeight()
00024 #       ThumbnailWidth()
00025 #           - get attributes
00026 #
00027 #   AUTHOR:  Edward Almasy
00028 #
00029 #   Part of CWIS
00030 #   Copyright 2002-2011 Internet Scout Project
00031 #   http://scout.wisc.edu
00032 #
00033 
00034 class SPTImage {
00035 
00036     # ---- PUBLIC INTERFACE --------------------------------------------------
00037 
00043     const IMAGE_PATH = "ImageStorage/";
00044     const PREVIEW_PATH = "ImageStorage/Previews/";
00045     const THUMBNAIL_PATH = "ImageStorage/Thumbnails/";
00046 
00047     # object constructor
00048     function SPTImage($ImageIdOrFileNameOrImageObj,
00049                       $MaxWidth = NULL, $MaxHeight = NULL,
00050                       $MaxPreviewWidth = NULL, $MaxPreviewHeight = NULL,
00051                       $MaxThumbnailWidth = NULL, $MaxThumbnailHeight = NULL)
00052     {
00053         # clear error status (0 = AI_OKAY)
00054         $this->ErrorStatus = 0;
00055 
00056         # trigger the Image class file to be autoloaded since some parts of this
00057         # class (SPTImage) use constants defined in it but don't construct Image
00058         # objects
00059         new Image(NULL);
00060 
00061         # create and save a database handle for our use
00062         $this->DB = new SPTDatabase();
00063 
00064         # if image object was passed in
00065         if (is_object($ImageIdOrFileNameOrImageObj)
00066                 && method_exists($ImageIdOrFileNameOrImageObj, "SPTImage"))
00067         {
00068             # create copy of image passed in
00069             $this->CreateCopyOfImage($ImageIdOrFileNameOrImageObj);
00070         }
00071         # else if image ID was passed in
00072         elseif (($ImageIdOrFileNameOrImageObj > 0)
00073                 && preg_match("/[0-9]+/", $ImageIdOrFileNameOrImageObj))
00074         {
00075             # load info on existing image
00076             $this->LoadImageInfo($ImageIdOrFileNameOrImageObj);
00077         }
00078         # else assume that value passed in is file name
00079         else
00080         {
00081             # create new image from named file
00082             $this->CreateNewImage($ImageIdOrFileNameOrImageObj,
00083                                   $MaxWidth, $MaxHeight,
00084                                   $MaxPreviewWidth, $MaxPreviewHeight,
00085                                   $MaxThumbnailWidth, $MaxThumbnailHeight);
00086         }
00087     }
00088 
00089     # get attributes
00090     function Id() {  return $this->Id;  }
00091     function Url() {  return $this->FileName;  }
00092     function PreviewUrl() {  return $this->PreviewFileName;  }
00093     function ThumbnailUrl() {  return $this->ThumbnailFileName;  }
00094     function Format() {  return $this->Format;  }
00095     function Height() {  return $this->Height;  }
00096     function Width() {  return $this->Width;  }
00097     function PreviewHeight() {  return $this->PreviewHeight;  }
00098     function PreviewWidth() {  return $this->PreviewWidth;  }
00099     function ThumbnailHeight() {  return $this->ThumbnailHeight;  }
00100     function ThumbnailWidth() {  return $this->ThumbnailWidth;  }
00101     function ImageStorageDirectory() {  return self::IMAGE_PATH;  }
00102     function PreviewStorageDirectory() {  return self::PREVIEW_PATH;  }
00103     function ThumbnailStorageDirectory() {  return self::THUMBNAIL_PATH;  }
00104     function GetLink() {  return $this->FileName;  }
00105 
00106     # get/set attributes
00107     function AltText($NewValue = NULL)
00108     {
00109         # if new value supplied and new value differs from existing value
00110         if (($NewValue !== NULL) && ($NewValue != $this->AltText))
00111         {
00112             # save new value to database
00113             $this->DB->Query("UPDATE Images SET"
00114                              ." AltText = '".addslashes($NewValue)."'"
00115                              ." WHERE ImageId = ".$this->Id);
00116 
00117             # save new value locally
00118             $this->AltText = $NewValue;
00119         }
00120 
00121         # return attribute value to caller
00122         return $this->AltText;
00123     }
00124 
00125     # delete image and associated files and data
00126     function Delete()
00127     {
00128         # delete base image file
00129         if (file_exists($this->FileName)) {  unlink($this->FileName);  }
00130 
00131         # delete preview image file
00132         if (file_exists($this->PreviewFileName)) {  unlink($this->PreviewFileName);  }
00133 
00134         # delete thumbnail image file
00135         if (file_exists($this->ThumbnailFileName)) {  unlink($this->ThumbnailFileName);  }
00136 
00137         # delete image info record in database
00138         $this->DB->Query("DELETE FROM Images WHERE ImageId = ".$this->Id);
00139     }
00140 
00141     # return error status set by the constructor
00142     function Status()
00143     {
00144         return $this->ErrorStatus;
00145     }
00146 
00147     # check to make sure image storage directories are available
00148     # (returns array of error codes or NULL if no errors found)
00149     static function CheckDirectories()
00150     {
00151         # determine paths
00152         $ImagePath = self::IMAGE_PATH;
00153         $PreviewPath = self::PREVIEW_PATH;
00154         $ThumbnailPath = self::THUMBNAIL_PATH;
00155 
00156         # assume everything will be okay
00157         $ErrorsFound = NULL;
00158 
00159         # check base image directory
00160         if (!is_dir($ImagePath) || !is_writable($ImagePath))
00161         {
00162             if (!is_dir($ImagePath))
00163             {
00164                 @mkdir($ImagePath, 0755);
00165             }
00166             else
00167             {
00168                 @chmod($ImagePath, 0755);
00169             }
00170             if (!is_dir($ImagePath))
00171             {
00172                 $ErrorsFound[] = "Image Storage Directory Not Found";
00173             }
00174             elseif (!is_writable($ImagePath))
00175             {
00176                 $ErrorsFound[] = "Image Storage Directory Not Writable";
00177             }
00178         }
00179 
00180         # check preview directory
00181         if (!is_dir($PreviewPath) || !is_writable($PreviewPath))
00182         {
00183             if (!is_dir($PreviewPath))
00184             {
00185                 @mkdir($PreviewPath, 0755);
00186             }
00187             else
00188             {
00189                 @chmod($PreviewPath, 0755);
00190             }
00191             if (!is_dir($PreviewPath))
00192             {
00193                 $ErrorsFound[] = "Preview Storage Directory Not Found";
00194             }
00195             elseif (!is_writable($PreviewPath))
00196             {
00197                 $ErrorsFound[] = "Preview Storage Directory Not Writable";
00198             }
00199         }
00200 
00201         # check thumbnail directory
00202         if (!is_dir($ThumbnailPath) || !is_writable($ThumbnailPath))
00203         {
00204             if (!is_dir($ThumbnailPath))
00205             {
00206                 @mkdir($ThumbnailPath, 0755);
00207             }
00208             else
00209             {
00210                 @chmod($ThumbnailPath, 0755);
00211             }
00212             if (!is_dir($ThumbnailPath))
00213             {
00214                 $ErrorsFound[] = "Thumbnail Storage Directory Not Found";
00215             }
00216             elseif (!is_writable($ThumbnailPath))
00217             {
00218                 $ErrorsFound[] = "Thumbnail Storage Directory Not Writable";
00219             }
00220         }
00221 
00222         # return any errors found to caller
00223         return $ErrorsFound;
00224     }
00225 
00226     public function Resize($MaxWidth, $MaxHeight,
00227                            $MaxPreviewWidth, $MaxPreviewHeight,
00228                            $MaxThumbnailWidth, $MaxThumbnailHeight)
00229     {
00230         $SrcImage = new Image($this->FileName);
00231 
00232         # scale the original image if necessary
00233         $MaxWidth = min($MaxWidth, $SrcImage->XSize());
00234         $MaxHeight = min($MaxHeight, $SrcImage->YSize());
00235         $SrcImage->ScaleTo($MaxWidth, $MaxHeight, TRUE);
00236 
00237         # save and reload image info
00238         $SrcImage->SaveAs($this->FileName);
00239         $SrcImage = new Image($this->FileName);
00240 
00241         # retrieve image width and height
00242         $this->Height = $SrcImage->YSize();
00243         $this->Width = $SrcImage->XSize();
00244 
00245         # generate preview image and calculate width and height
00246         $MaxPreviewWidth = min($MaxPreviewWidth, $this->Width);
00247         $MaxPreviewHeight = min($MaxPreviewHeight, $this->Height);
00248         $SrcImage->ScaleTo($MaxPreviewWidth, $MaxPreviewHeight, TRUE);
00249         $SrcImage->SaveAs($this->PreviewFileName, IMGTYPE_JPEG);
00250         if (($this->Width * $MaxPreviewHeight)
00251                 > ($this->Height * $MaxPreviewWidth))
00252         {
00253             $this->PreviewWidth = $MaxPreviewWidth;
00254             $this->PreviewHeight =
00255                     ($MaxPreviewWidth * $SrcImage->YSize()) / $SrcImage->XSize();
00256         }
00257         else
00258         {
00259             $this->PreviewWidth =
00260                     ($MaxPreviewHeight * $SrcImage->XSize()) / $SrcImage->YSize();
00261             $this->PreviewHeight = $MaxPreviewHeight;
00262         }
00263 
00264         # generate thumbnail image and calculate width and height
00265         $MaxThumbnailWidth = min($MaxThumbnailWidth, $this->Width);
00266         $MaxThumbnailHeight = min($MaxThumbnailHeight, $this->Height);
00267         $SrcImage->ScaleTo($MaxThumbnailWidth, $MaxThumbnailHeight, TRUE);
00268         $SrcImage->SaveAs($this->ThumbnailFileName, IMGTYPE_JPEG);
00269         if (($this->Width * $MaxThumbnailHeight)
00270                 > ($this->Height * $MaxThumbnailWidth))
00271         {
00272             $this->ThumbnailWidth = $MaxThumbnailWidth;
00273             $this->ThumbnailHeight =
00274                     ($MaxThumbnailWidth * $SrcImage->YSize()) / $SrcImage->XSize();
00275         }
00276         else
00277         {
00278             $this->ThumbnailWidth = ($MaxThumbnailHeight * $SrcImage->XSize()) / $SrcImage->YSize();
00279             $this->ThumbnailHeight = $MaxThumbnailHeight;
00280         }
00281 
00282         # save image attributes to database
00283         $this->SaveImageInfo();
00284     }
00285 
00286     # ---- PRIVATE INTERFACE -------------------------------------------------
00287 
00288     var $Id;
00289     var $FileName;
00290     var $PreviewFileName;
00291     var $ThumbnailFileName;
00292     var $Format;
00293     var $AltText;
00294     var $Url;
00295     var $PreviewUrl;
00296     var $ThumbnailUrl;
00297     var $Height;
00298     var $Width;
00299     var $PreviewHeight;
00300     var $PreviewWidth;
00301     var $ThumbnailHeight;
00302     var $ThumbnailWidth;
00303     var $DB;
00304     var $ErrorStatus;
00305 
00306     function CreateNewImage($FileName, $MaxWidth, $MaxHeight,
00307                             $MaxPreviewWidth, $MaxPreviewHeight,
00308                             $MaxThumbnailWidth, $MaxThumbnailHeight)
00309     {
00310         # if file does not exist or is not readable
00311         if (!is_readable($FileName))
00312         {
00313             # set error status
00314             $this->ErrorStatus = AI_FILEUNREADABLE;
00315         }
00316         else
00317         {
00318             # if image is invalid or unsupported type
00319             $SrcImage = new Image($FileName);
00320             if ($SrcImage->Status() != AI_OKAY)
00321             {
00322                 # set error status
00323                 $this->ErrorStatus = $SrcImage->Status();
00324             }
00325             else
00326             {
00327                 # retrieve image type
00328                 $this->Format = $SrcImage->Type();
00329 
00330                 # generate new image ID
00331                 $this->Id = $this->GenerateNewImageId();
00332 
00333                 # generate and set file names
00334                 $this->SetFileNames();
00335 
00336                 # if our image file name differs from file name passed in
00337                 if (realpath($this->FileName) != realpath($FileName))
00338                 {
00339                     # create image file
00340                     $SrcImage->SaveAs($this->FileName);
00341 
00342                     # if create failed set error status and bail out
00343                     if ($SrcImage->Status() != AI_OKAY)
00344                     {
00345                         echo "create failed<br>";
00346                         echo "Status: ".$SrcImage->Status()."<br>";
00347                         echo "Failed Command: ".$SrcImage->FailedExternalCommand()."<br>";
00348                         echo "Missing External Executables: ";
00349                         print_r(Image::MissingExternalExecutables());
00350                         echo "<br>";
00351                         $this->ErrorStatus = $SrcImage->Status();
00352                         return;
00353                     }
00354                 }
00355 
00356                 # scale the original image if necessary
00357                 $MaxWidth = min($MaxWidth, $SrcImage->XSize());
00358                 $MaxHeight = min($MaxHeight, $SrcImage->YSize());
00359                 $SrcImage->ScaleTo($MaxWidth, $MaxHeight, TRUE);
00360 
00361                 # save and reload image info
00362                 $SrcImage->SaveAs($this->FileName);
00363                 $SrcImage = new Image($this->FileName);
00364 
00365                 # retrieve image width and height
00366                 $this->Height = $SrcImage->YSize();
00367                 $this->Width = $SrcImage->XSize();
00368 
00369                 # generate preview image and calculate width and height
00370                 $MaxPreviewWidth = min($MaxPreviewWidth, $this->Width);
00371                 $MaxPreviewHeight = min($MaxPreviewHeight, $this->Height);
00372                 $SrcImage->ScaleTo($MaxPreviewWidth, $MaxPreviewHeight, TRUE);
00373                 $SrcImage->SaveAs($this->PreviewFileName, IMGTYPE_JPEG);
00374                 if ($SrcImage->Status() != AI_OKAY)
00375                 {
00376                     echo "preview save as failed<br>";
00377                     $this->ErrorStatus = $SrcImage->Status();
00378                     return;
00379                 }
00380                 if (($this->Width * $MaxPreviewHeight)
00381                         > ($this->Height * $MaxPreviewWidth))
00382                 {
00383                     $this->PreviewWidth = $MaxPreviewWidth;
00384                     $this->PreviewHeight =
00385                             ($MaxPreviewWidth * $SrcImage->YSize()) / $SrcImage->XSize();
00386                 }
00387                 else
00388                 {
00389                     $this->PreviewWidth =
00390                             ($MaxPreviewHeight * $SrcImage->XSize()) / $SrcImage->YSize();
00391                     $this->PreviewHeight = $MaxPreviewHeight;
00392                 }
00393 
00394                 # generate thumbnail image and calculate width and height
00395                 $MaxThumbnailWidth = min($MaxThumbnailWidth, $this->Width);
00396                 $MaxThumbnailHeight = min($MaxThumbnailHeight, $this->Height);
00397                 $SrcImage->ScaleTo($MaxThumbnailWidth, $MaxThumbnailHeight, TRUE);
00398                 $SrcImage->SaveAs($this->ThumbnailFileName, IMGTYPE_JPEG);
00399                 if ($SrcImage->Status() != AI_OKAY)
00400                 {
00401                     echo "thumbnail SaveAs failed.<br>";
00402                     $this->ErrorStatus = $SrcImage->Status();
00403                     return;
00404                 }
00405                 if (($this->Width * $MaxThumbnailHeight)
00406                         > ($this->Height * $MaxThumbnailWidth))
00407                 {
00408                     $this->ThumbnailWidth = $MaxThumbnailWidth;
00409                     $this->ThumbnailHeight =
00410                             ($MaxThumbnailWidth * $SrcImage->YSize()) / $SrcImage->XSize();
00411                 }
00412                 else
00413                 {
00414                     $this->ThumbnailWidth = ($MaxThumbnailHeight * $SrcImage->XSize()) / $SrcImage->YSize();
00415                     $this->ThumbnailHeight = $MaxThumbnailHeight;
00416                 }
00417 
00418                 # save image attributes to database
00419                 $this->SaveImageInfo();
00420             }
00421         }
00422     }
00423 
00424     function LoadImageInfo($ImageId)
00425     {
00426         # save image ID
00427         $this->Id = $ImageId;
00428 
00429         # load image record from database
00430         $this->DB->Query("SELECT * FROM Images WHERE ImageId = ".$ImageId);
00431 
00432         # if the ID is invalid
00433         if (!$this->DB->NumRowsSelected())
00434         {
00435             $this->ErrorStatus = AI_INTERNALERROR;
00436             return;
00437         }
00438 
00439         $Record = $this->DB->FetchRow();
00440 
00441         # load in values from record
00442         $this->Format          = $Record["Format"];
00443         $this->AltText         = $Record["AltText"];
00444         $this->Height          = $Record["Height"];
00445         $this->Width           = $Record["Width"];
00446         $this->PreviewHeight   = $Record["PreviewHeight"];
00447         $this->PreviewWidth    = $Record["PreviewWidth"];
00448         $this->ThumbnailHeight = $Record["ThumbnailHeight"];
00449         $this->ThumbnailWidth  = $Record["ThumbnailWidth"];
00450 
00451         # generate file names
00452         $this->SetFileNames();
00453     }
00454 
00455     function CreateCopyOfImage($SrcImage)
00456     {
00457         $Image = new Image($SrcImage->Url());
00458         if ($Image->Status() != AI_OKAY)
00459         {
00460             # set error status
00461             $this->ErrorStatus = $Image->Status();
00462             return;
00463         }
00464 
00465         # generate new image ID
00466         $this->Id = $this->GenerateNewImageId();
00467 
00468         # generate file names
00469         $this->SetFileNames();
00470 
00471         # copy attributes from source image
00472         $this->Format = $SrcImage->Format();
00473         $this->AltText = $SrcImage->AltText();
00474         $this->Width = $SrcImage->Width();
00475         $this->Height = $SrcImage->Height();
00476         $this->PreviewWidth = $SrcImage->PreviewWidth();
00477         $this->PreviewHeight = $SrcImage->PreviewHeight();
00478         $this->ThumbnailWidth = $SrcImage->ThumbnailWidth();
00479         $this->ThumbnailHeight = $SrcImage->ThumbnailHeight();
00480 
00481         # copy source image files
00482         copy($SrcImage->Url(), $this->FileName);
00483         copy($SrcImage->PreviewUrl(), $this->PreviewFileName);
00484         copy($SrcImage->ThumbnailUrl(), $this->ThumbnailFileName);
00485 
00486         # save image attributes to database
00487         $this->SaveImageInfo();
00488     }
00489 
00490     # generate and save image, preview, and thumnail file names
00491     # (requires image ID and format to be set beforehand)
00492     function SetFileNames()
00493     {
00494         if (Image::Extension($this->Format))
00495         {
00496             $FileExtension = Image::Extension($this->Format);
00497         }
00498         else
00499         {
00500             $FileExtension = "";
00501         }
00502 
00503         $this->FileName = self::IMAGE_PATH . "Img--"
00504                 .sprintf("%08d.", $this->Id).$FileExtension;
00505         $this->PreviewFileName = self::PREVIEW_PATH . "Preview--"
00506                 .sprintf("%08d.", $this->Id).$FileExtension;
00507         $this->ThumbnailFileName = self::THUMBNAIL_PATH . "Thumb--"
00508                 .sprintf("%08d.", $this->Id).$FileExtension;
00509     }
00510 
00511     # retrieve next image ID
00512     function GenerateNewImageId()
00513     {
00514         # look up highest image ID in database
00515         $CurrentHighestId = $this->DB->Query("SELECT ImageId FROM Images"
00516                                              ." ORDER BY ImageId DESC LIMIT 1",
00517                                              "ImageId");
00518 
00519         # return next highest ID or 1 if no ID yet used
00520         return ($CurrentHighestId > 0) ? ($CurrentHighestId + 1) : 1;
00521     }
00522 
00523     # store image attributes to database
00524     function SaveImageInfo()
00525     {
00526         # look for existing image record with matching ID
00527         $RecordCount = $this->DB->Query("SELECT COUNT(*) AS RecordCount FROM Images"
00528                                         ." WHERE ImageId = ".$this->Id,
00529                                         "RecordCount");
00530 
00531         # if matching ID found
00532         if ($RecordCount > 0)
00533         {
00534             # update existing image record
00535             $this->DB->Query("UPDATE Images SET"
00536                              ." Format = '"         .$this->Format."',"
00537                              ." AltText = '"        .addslashes($this->AltText)."',"
00538                              ." Height = '"         .$this->Height."',"
00539                              ." Width = '"          .$this->Width."',"
00540                              ." PreviewHeight = '"  .$this->PreviewHeight."',"
00541                              ." PreviewWidth = '"   .$this->PreviewWidth."',"
00542                              ." ThumbnailHeight = '".$this->ThumbnailHeight."',"
00543                              ." ThumbnailWidth = '" .$this->ThumbnailWidth."'"
00544                              ." WHERE ImageId = ".$this->Id);
00545         }
00546         else
00547         {
00548             # add new image record
00549             $this->DB->Query("INSERT INTO Images SET"
00550                              ." ImageId = '"        .$this->Id."',"
00551                              ." Format = '"         .$this->Format."',"
00552                              ." AltText = '"        .addslashes($this->AltText)."',"
00553                              ." Height = '"         .$this->Height."',"
00554                              ." Width = '"          .$this->Width."',"
00555                              ." PreviewHeight = '"  .$this->PreviewHeight."',"
00556                              ." PreviewWidth = '"   .$this->PreviewWidth."',"
00557                              ." ThumbnailHeight = '".$this->ThumbnailHeight."',"
00558                              ." ThumbnailWidth = '" .$this->ThumbnailWidth."'");
00559         }
00560     }
00561 }

CWIS logo doxygen
Copyright 2010 Internet Scout