/adei/trunk

<?php

    header("Content-type: image/jpeg");

    header("Cache-control: no-cache, must-revalidate");

    header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");

    

    clearstatcache();

    

    //abstract class that all imageservices should extend

    //at the moment this wouldn't be necessary but in the future all common functionality 

    //should be in this class

    abstract class ImageService

    {

        var $start;

        var $n;

    

        public function __construct($start, $n)

        {

            $this->start = $start;

            $this->n = $n;

        }

    }

    

    //class for the cloud cameras image processing

    class CloudCameraImageService extends ImageService

    {

        var $bg_width;//the initial width for the main graphs background image, further adjusted by code in $this::GetBackgroundImage()

        var $dir;//directory containing the cloud camera images

        var $window;//window made out of two timestamps

        

        public function __construct($start, $n, $window = NULL)

        {

            parent::__construct($start, $n);

            

            //these should be placed in some configuration file

            $this->dir = "/home/riku/small/";//the directory containing the cloud camera images

            $this->bg_width = 400;

            

            if($window && $window !== 0 && strstr($window, "-"))//if the window property is in the querystring and it's not 0

            {

                $this->window = $window;//we use the window to determine which images to include in the cropped image returned as the main graph bg

            }

        }

        

        //function to construct a timestamp for each cloud camera image out of their filenames

        function ConstructTimestamp($string)

        {

            $string = substr($string, 1);//get rid of the '2' from cc2

            $y = substr($string, 0, 4);//<YYYY> MMDDhhmmss

            $m = substr($string, 4, 2);//YYYY <MM> DDhhmmss

            $d = substr($string, 6, 2);//YYYYMM <DD> hhmmss

            $h = substr($string, 8, 2);//YYYYMMDD <hh> mmss

            $min = substr($string, 10, 2);//YYYYMMDDhh <mm> ss

            $sec = substr($string, 12, 2);//YYYYMMDDhhmm <ss>

 

            $stamp = mktime($h, $min, $sec, $m, $d, $y);

 

            return intval($stamp);

        }

        

        //function reading the required images' timestamps in an array, contructing the background from the images and retuning them in an array

        //also possibly returns an array with 'error' field if something goes wrong

        function GetBackgroundImage()

        {

            $dir = $this->dir;

 

            $timestamps = array();

            

            $data_amount = 0;

            

            if (is_dir($dir)) //read through the folder of images

            {

                if ($handle = opendir($dir)) {

                    $filenames = array();

                    while (false !== ($file = readdir($handle))) {

                        if(strstr($file, "kitcube"))

                        {

                            $string = preg_replace("/[^0-9]/", "", $file);

                            $ts = $this::ConstructTimestamp($string);

                            $filenames[$ts] = $file;

                            array_push($timestamps, $ts);

                            $data_amount++;

                        }

                    }

                }

            }

            ksort($filenames);//sort the images by their timestamp

            asort($timestamps);

            $timestamps = array_values($timestamps);

 

            if($this->window)//if the window property was not 0 we use it to determine the required data

            {

                $start = intval(substr($this->window, 0, strpos($this->window, "-")));

                $end = intval(substr($this->window, strpos($this->window, "-") + 1));

            }

            else//if window property was 0 we use the user control values (start and zoom) to determine the required data

            {

                $start_slider_max = 1;

                $data_dummy = $data_amount;

                while($data_dummy > 100)

                {

                    $data_dummy = floor($data_dummy / 10);

                    $start_slider_max = $start_slider_max * 10;

                }

                

                $start_index = (floor(count($timestamps) / $start_slider_max) * ($this->start - 1));

                $start = $timestamps[$start_index];

                if(count($timestamps) >= 200)

                {

                    $end = $timestamps[$start_index + (30 * $this->n)];

                }

                else

                {

                    $end = $timestamps[count($timestamps) - 1];

                }

            }

            

            if($start > $end)//if the start timestamp is after the end timestamp

            {

                $return = array(

                        "error" => "End point can't be before start!"

                        );

                return $return;

            }

            

            end($timestamps);

            $array_end = current($timestamps);

            reset($timestamps);

            $array_start = current($timestamps);

            

            $array_center = $timestamps[count($timestamps) / 2];

            

            if($start < $array_start)

            {

                $start = $array_start;

            }

            elseif($end > $array_end)

            {

                $end = $array_end;

            }

            elseif($start > $array_end || $end < $array_start)//if the start is after the last cloud image or the end is before the first one

            {

                $return = array(

                        "error" => "No data found!"

                        );

                return $return;

            }

            

            //this divides the timestamps array (which is quite big...) in half 4 times in a row to make it more managable to go through

            for($i = 0 ; $i < 4 ; $i++)//TODO: better condition here, this just narrows down the timestamps array to go through 4 times (what if its got some millions of stamps?)

            {

                if($array_center < $start)

                {

                    $timestamps = array_slice($timestamps, (count($timestamps) / 2));

                    reset($timestamps);

                    $array_start = current($timestamps);

                }

                else if($array_center > $start)

                {

                    $timestamps = array_slice($timestamps, 0, (count($timestamps) / 2));

                    end($timestamps);

                    $array_end = current($timestamps);

                }

                $array_center = $timestamps[count($timestamps) / 2];

            }

            reset($timestamps);

            

            $stamps = array();//stamps array contains the timestamps of the images to be displayed

            

            foreach($timestamps as $ts)

            {

                if(empty($stamps))

                {

                    if($prev_ts < $start && $ts >= $start)

                    {

                        array_push($stamps, $ts);

                    }

                    $prev_ts = $ts;

                }

                else

                {

                    if($ts <= $end)

                    {

                        array_push($stamps, $ts);

                    }

                    $prev_ts = $ts;

                }

            }

 

            //here we find out the original images' width and height

            $file = $filenames[$stamps[0]];

            $file_handle = fopen(($dir . $file), "r");

            $binary = fread($file_handle, filesize($dir . $file));

            

            $tmp = imagecreatefromstring($binary);

            

            $size = array(imagesx($tmp), imagesy($tmp));

            

            fclose($file_handle);

            imagedestroy($tmp);

            

            

            $width = $this->bg_width;

        

            $crop_width = floor($width / count($stamps));//the width of the slices to be taken from the images depends on the number of images

            $width = count($stamps) * $crop_width;//adjust the width of the return image based on the crop width

 

            $canvas = imagecreatetruecolor( $width, $size[1]/3 );//create the image to be returned by the function

 

            //go through the required images and copy a slice of them to the return image

            foreach($stamps as $key => $stamp)

            {

                $file = $filenames[$stamp];

                $file_handle = fopen(($dir . $file), "r");

                $binary = fread($file_handle, filesize($dir . $file));

                

                $cropped = imagecreatefromstring($binary);

 

                // Prepare image  crop - center the crop on the image

                $cropLeft = ( $size[0]/2 )  - ( $crop_width/2 );

                $cropHeight = 0;

                // Generate the cropped image

                imagecopyresized( $canvas, $cropped, $key * $crop_width, 0, $cropLeft, $cropHeight, $crop_width, $size[1]/3, $crop_width, $size[1] );

            }

 

            imagedestroy($cropped);//destroy the temporary image

        

            $return = array(

                    "background" => $canvas,

                    "timestamps" => $stamps

                    );

    

            return $return;

        }

        

        //function to get the main graph

        public function GetMainImage()

        {

            //requiring the needed jpgraph files

            require_once("/usr/share/php5/jpgraph/jpgraph.php");

            require_once("/usr/share/php5/jpgraph/jpgraph_bar.php");

            require_once("/usr/share/php5/jpgraph/jpgraph_date.php" );

 

            $n = $this->n;

        

            $bg_array = $this::GetBackgroundImage();//get the background image for the graph

            

            if($bg_array['error'])//if the background array contains the error field we return an error image

            {

                $error = new ErrorService();

                $image = $error->ShowError($bg_array['error']);

                return $image;

            }

            

            $background = $bg_array["background"];

            $timestamps = $bg_array["timestamps"];

            

            $filename = tempnam('/tmp/adei/', 'cc_') . ".jpg";//create a temporary file out of the background (needed to set the image as jpgraph bg)

 

            imagejpeg( $background, $filename, 100);

            

            $array = array();//array of 0 values for the graph needed to set the x-axis tick labels correctly

  

            for($i = 0 ; $i < count($timestamps) ; $i++)

            {

                array_push($array, 0);

            }

 

            //here we contruct the subtitle telling the current day shown on the graph

            $stamp_from = $timestamps[0];

            $stamp_to = $timestamps[count($timestamps) - 1];

 

            if(date("d.m.Y", $stamp_from) === date("d.m.Y", $stamp_to))

            {

                $subtitle = date("d.m.Y", $stamp_from);

            }

            else

            {

                $subtitle = date("d.m.Y", $stamp_from) . " - " . date("d.m.Y", $stamp_to);

            }

 

            foreach($timestamps as &$stamp)

            {

                $stamp = date("H:i:s", $stamp);

            }

 

            //create the graph

            $graph = new Graph(530, 400);

            $graph->SetScale('textint', 0, 0, 0, count($timestamps));

            $graph->xscale->ticks->Set((count($timestamps) / 5));

            

            $graph->SetBackgroundImage(($filename), BGIMG_FILLPLOT);

            $graph->SetBackgroundImageMix(100);

            $graph->SetMargin(50, 20, 50, 20);

            $graph->SetMarginColor("#DDDDDD");

 

            $graph->title->Set("Cloud graph");

            $graph->subtitle->Set($subtitle);

 

            $plot = new BarPlot($array);

            $graph->Add($plot);

 

            $graph->yaxis->Hide();

 

            $graph->xaxis->SetTitle("Time", "middle");

            $graph->xaxis->SetTickSide(SIDE_DOWN);

            $graph->xaxis->SetTickLabels($timestamps);

            $graph->xaxis->SetLabelAlign('right');

            $graph->xaxis->HideLastTickLabel(); 

 

            imagedestroy( $background );

    

            return $graph;//return the graph handle

        }

        

        //this function gets the full cloud camera image from one specific time to be shown in the secondary image slot of the module

        public function GetSecondaryImage($id)

        {

            $dir = $this->dir;

            

            if (is_dir($dir)) 

            {

                if ($handle = opendir($dir)) {

                    $filenames = array();

                    while (false !== ($file = readdir($handle))) {

                        if(strstr($file, "kitcube"))

                        {

                            array_push($filenames, $file);

                        }

                    }

                }

            }

            asort($filenames);

            

            $filenames = array_values($filenames);

            

            $file = $filenames[$id];

            $file_handle = fopen(($dir . $file), "r");

            $image = fread($file_handle, filesize($dir . $file));

            fclose($file_handle);

            

            return $image;

        }

    }

    

    //error service is used to show errors to the user in case something goes wrong

    class ErrorService extends ImageService

    {

        var $error;

        

        public function __construct($start, $n)

        {

            parent::__construct($start, $n);

        }

        

        function ShowError($string)

        {

            $font_size = 5;

            $width = 600;

            $height = 400;

            $img = imagecreate($width, $height);

            $bg = imagecolorallocate($img, 225, 225, 225);

            $black = imagecolorallocate($img, 0, 0, 0);

            $len = strlen($string);

            

            for($i = 0 ; $i < $len ; $i++)

            {

                $xpos = $i * imagefontwidth($font_size);

                $ypos = $height / 4;

                imagechar($img, $font_size, $xpos, $ypos, $string, $black);

                $string = substr($string, 1);

            }

            

            return $img;

        }

    }

    

    //here we create a service based on the query string's target property and pass the other properties to the service

    if(isset($_GET["target"]))

    {

        $target = $_GET["target"];

        

        if(isset($_GET["window"]))

        {

            $window = $_GET["window"];

        }

        switch($target)

        {

            case "cloud_main":

                if(isset($_GET["start"]))

                {

                    $start = $_GET["start"];

                }

                else 

                {

                    $start = 1;

                }

                if(isset($_GET["n"]))

                {

                    $n = 6 - $_GET["n"];

                }

                else

                {

                    $n = 5;

                }

                $service = new CloudCameraImageService($start, $n, $window);

                $image = $service->GetMainImage();

                break;

            case "cloud_sec":

                if(isset($_GET["id"]))

                {

                    $id = $_GET["id"];

                }

                else

                {

                    $id = 1;

                }

                $service = new CloudCameraImageService($start, $n, $window);

                $image = $service->GetSecondaryImage($id);

                break;

            case "ceilo_main":

                $service = new ErrorService();

                $image = $service->ShowError("Not implemented");

                break;

            case "ceilo_sec":

                $service = new ErrorService();

                $image = $service->ShowError("Not implemented");

                break;

            case "temp_main":

                $service = new ErrorService();

                $image = $service->ShowError("Not implemented");

                break;

            case "temp_sec":

                $service = new ErrorService();

                $image = $service->ShowError("Not implemented");

                break;

            default:

                $service = new ErrorService();

                $image = $service->ShowError("Target not valid");

                break;

        }

    }

    else

    {

        $service = new ErrorService();

        $image = $service->ShowError("No target");

    }

 

    if(!isset($image))

    {

        $service = new ErrorService();

        $image = $service->ShowError("Image creation failed!");

    }

    

    //here we handle the outputting of the image

    if($image instanceof Graph)

    {

        $image->Stroke();

    }

    else if(is_resource($image))

    {

        if(get_resource_type($image) === "gd")

            imagejpeg($image);

    }

    else

        echo $image;

 

?>