Source for file EllipseIterator.class.php

Documentation is available at EllipseIterator.class.php

  1. <?php
  2. /**
  3.  * @author Takács Ákos (Rimelek), programmer [at] rimelek [dot] hu
  4.  * @copyright Copyright (C) 2009, Takács Ákos
  5.  * @package REPHPGraph
  6.  */
  7.  
  8. /**
  9.  * Elipszis iterátor
  10.  * 
  11.  * Ez az osztály segítséget nyújt az elipszis formában történő iterációhoz.<br />
  12.  * Csupán a kezdő és befejező szögelfordulás fokát kell megadni,
  13.  * valamint hol legyen az elipszis centruma, mi legyen a szélessége és magassága,
  14.  * végül hogy hány fokonként iteráljon. Ezek után az iterátor kiszámolja az X és Y
  15.  * koordinátákat minden ciklusban, és visszaadja azt.
  16.  * 
  17.  * {@example ../examples/ellipseIterator.php}
  18.  * 
  19.  * @author Takács Ákos (Rimelek), programmer [at] rimelek [dot] hu
  20.  * @copyright Copyright (C) 2009, Takács Ákos
  21.  * @version 1.0
  22.  * @package REPHPGraph
  23.  */
  24. class EllipseIterator implements Iterator, ArrayAccess 
  25. {
  26.     /**
  27.      * Iterátor centrumának X koordinátája
  28.      * 
  29.      * @var int 
  30.      */
  31.     protected $cx = 0;
  32.     /**
  33.      * Iterátor centrumának Y koordinátája
  34.      * 
  35.      * @var int 
  36.      */
  37.     protected $cy = 0;
  38.     /**
  39.      * Az iteráció aktuális szöge
  40.      * 
  41.      * CSak olvasható (readonly)
  42.      * 
  43.      * @var int 
  44.      */
  45.     protected $_i = 1;
  46.     /**
  47.      * Elipszis magassága
  48.      * @var int 
  49.      */
  50.     protected $height = 100;
  51.     /**
  52.      * Elipszis szélessége
  53.      * @var int 
  54.      */
  55.     protected $width = 100;
  56.     /**
  57.      * Kezdő szög
  58.      * @var int 
  59.      */
  60.     protected $start = 0;
  61.     /**
  62.      * Befejező szög
  63.      * @var int 
  64.      */
  65.     protected $end = 360;
  66.     /**
  67.      * Iteráció lépésköze fok-ban számítva
  68.      * @var int 
  69.      */
  70.     protected $add = 1;
  71.             
  72.     protected $key = 0;
  73.     protected $valid=true;
  74.     /**
  75.     * Tulajdonságok értékeinek lekérdezésekor lefutó metódus
  76.     * 
  77.     * @param string $var 
  78.     * @return mixed 
  79.     */
  80.     function __get($var) 
  81.     {    
  82.         return $this->$var;
  83.     }
  84.     
  85.     /**
  86.     * Tulajdonságok értékeinek beállításakor lefutó metódus
  87.     * 
  88.     * @param string $var 
  89.     * @param mixed $value 
  90.     */
  91.     function __set($var,$value)
  92.     {
  93.         $value = (int)$value;
  94.         switch ($var)
  95.         {
  96.             case 'height': case 'width': case 'end': case 'key':
  97.                 $this->$var = $value; 
  98.                 break;
  99.             case 'start':
  100.                 $this->_i = $value;
  101.                 $this->start = $value;
  102.                 break;
  103.             case 'add':
  104.                 $this->add = ($value <= 0) ? 1 : $value;
  105.                 break;                          
  106.         }
  107.         $this->$var = $value;
  108.     }
  109.     /**
  110.     * EllipseIterator konstruktor
  111.     * 
  112.     * Csak értékeket állít be, amit majd az iterációkor hazsnál
  113.     * 
  114.     * @param int $cx Elipszis centrumának X koordinátája
  115.     * @param int $cy Elipszis centrumának Y koordinátája
  116.     * @param int $width Elipszis szélessége
  117.     * @param int $height Elipszis magassága
  118.     */
  119.     function __construct($cx,$cy,$width,$height)
  120.     {       
  121.         $this->_i = 0;
  122.         $this->width = $width;
  123.         $this->height = $height;
  124.         $this->cx = $cx;
  125.         $this->cy = $cy;
  126.  
  127.     }
  128.     
  129.     /**
  130.      * Iteráció alaphelyzetbe állítása
  131.      *
  132.      */
  133.     public function rewind() 
  134.     { 
  135.         $this->_i = $this->start;
  136.         $this->key=0;
  137.         $this->valid=true;
  138.     }
  139.     
  140.     /**
  141.      * Aktuális elemek visszaadása
  142.      *
  143.      * @return array 
  144.      */
  145.     public function current() 
  146.     { 
  147.         $x = $this->cx + (cos(deg2rad($this->_i)) * ceil($this->width / 2));
  148.         $y = $this->cy + (sin(deg2rad($this->_i)) * ceil($this->height / 2));  
  149.         return array('x'=>$x,'y'=>$y);
  150.     }
  151.     
  152.     /**
  153.      * Következő elem előállítása
  154.      *
  155.      */
  156.     public function next() 
  157.     { 
  158.         $this->key++;
  159.         if ($this->start <= $this->end) {
  160.             $this->_i += $this->add;
  161.             if ($this->_i <= $this->end) {
  162.                 $this->valid = true;
  163.                 return;
  164.             } 
  165.             $this->_i = 1;
  166.             $this->valid = false;
  167.         } else {
  168.             $this->_i -= $this->add;
  169.             if ($this->_i >= $this->end) {
  170.                 $this->valid = true;
  171.                 return;
  172.             } 
  173.             $this->_i = 1;
  174.             $this->valid = false;      
  175.         } 
  176.     }
  177.     
  178.     /**
  179.      * Aktuális index visszaadása
  180.      *
  181.      * @return int 
  182.      */
  183.     public function key() 
  184.     {
  185.         return $this->key;        
  186.     }
  187.     
  188.     /**
  189.      * Van-e még több elem
  190.      *
  191.      * @return boolean 
  192.      */
  193.     public function valid() 
  194.     {   
  195.         return $this->valid;
  196.     }
  197.     
  198.     /**
  199.      * Létezik-e egy $offset indexű elem
  200.      *
  201.      * @param int $offset 
  202.      * @return boolean 
  203.      */
  204.     public function offsetExists($offset) 
  205.     {
  206.         return (abs(abs($this->start) - abs($this->end)) / $this->add) >= $offset;
  207.     }
  208.     
  209.     /**
  210.      * Konkrét elem elérése index alapján
  211.      *
  212.      * @param int $offset 
  213.      * @return array 
  214.      */
  215.     public function offsetGet($offset) 
  216.     {
  217.         $x='';
  218.         $y='';
  219.         if ($this->offsetExists($offset)) {
  220.             $i = $this->start+$offset*$this->add;
  221.             $x = $this->cx + (cos(deg2rad($i)) * ceil($this->width / 2));
  222.             $y = $this->cy + (sin(deg2rad($i)) * ceil($this->height / 2)); 
  223.         }
  224.         return array('x'=>$x,'y'=>$y);
  225.     }
  226.     
  227.     /**
  228.      * $offset indexű elem beállítása
  229.      *
  230.      * A beállítás nem lehetséges!
  231.      * Csak az adott indexű elem x és y koordinátájának megváltoztatása
  232.      * 
  233.      * @param int $offset 
  234.      * @param mixed $value 
  235.      */
  236.     public function offsetSet($offset,$value) 
  237.     {
  238.         throw new Exception("Az értékek nem állíthatók be közvetlenül az iterátorokban!");    
  239.     }
  240.     
  241.     /**
  242.      * Elem megszüntetése
  243.      *
  244.      * Nem lehetséges!
  245.      * 
  246.      * @param mixed $offset 
  247.      */
  248.     public function offsetUnset($offset)
  249.     {
  250.         throw new Exception("Az iterátor elemei nem szüntethetők meg!");    
  251.     }
  252. }
  253. ?>

Documentation generated on Tue, 09 Feb 2010 01:17:47 +0100 by phpDocumentor 1.4.1