[5961] | 1 | <?php |
---|
| 2 | /* ----------------------------------------------------------------------------- |
---|
| 3 | Plugin : ColorStat |
---|
| 4 | Author : Grum |
---|
| 5 | email : grum@grum.fr |
---|
| 6 | website : http://photos.grum.fr |
---|
| 7 | PWG user : http://forum.piwigo.org/profile.php?id=3706 |
---|
| 8 | |
---|
| 9 | << May the Little SpaceFrog be with you ! >> |
---|
| 10 | ------------------------------------------------------------------------------ |
---|
| 11 | See main.inc.php for release information |
---|
| 12 | |
---|
| 13 | Provided classes : |
---|
| 14 | * RGB |
---|
| 15 | public functions : |
---|
| 16 | __construct($R, $G, $B) |
---|
| 17 | set($R, $G, $B) |
---|
| 18 | setInt($value) |
---|
| 19 | get($floatValue=false) |
---|
| 20 | getHexString() |
---|
| 21 | getInt() |
---|
| 22 | getHSV() |
---|
| 23 | setHSV(HSV $hsv) |
---|
| 24 | private functions : |
---|
| 25 | setProperty($property, $value) |
---|
| 26 | |
---|
| 27 | * HSV |
---|
| 28 | public functions : |
---|
| 29 | __construct($H, $S, $V) |
---|
| 30 | set($H, $S, $V) |
---|
| 31 | get() |
---|
| 32 | getRGB() |
---|
| 33 | setRGB(RGB $rgb) |
---|
| 34 | private functions : |
---|
| 35 | setProperty($property, $value) |
---|
| 36 | |
---|
| 37 | * ColorStat |
---|
| 38 | public functions : |
---|
| 39 | static getFileColors($fileName, $colorTable, $quality=1) |
---|
| 40 | static RGBtoHSV(RGB $RGB) |
---|
| 41 | static HSVtoRGB(HSV $HSV) |
---|
| 42 | static IntToRGB($rgb) |
---|
| 43 | static getColorTable($huePrec=10, $prec=10, $returnedType='HSV') |
---|
| 44 | static getColorFromTable(HSV $hsvObject, $colorTable) |
---|
| 45 | |
---|
| 46 | --------------------------------------------------------------------------- */ |
---|
| 47 | |
---|
[6176] | 48 | if(!defined('PHPWG_ROOT_PATH')) die('Hacking attempt!'); |
---|
[6107] | 49 | |
---|
[5961] | 50 | /** |
---|
[6176] | 51 | * if DEBUG_MODE is set to true, the getFileColors function save a jpg file of |
---|
| 52 | * the 'viewed' image : |
---|
| 53 | * - resampled file |
---|
| 54 | * - color from the color table |
---|
| 55 | * |
---|
| 56 | * use it only for debug, or if you are curious about what the function really |
---|
| 57 | * see |
---|
| 58 | */ |
---|
| 59 | define('DEBUG_MODE', false); |
---|
| 60 | |
---|
| 61 | |
---|
| 62 | |
---|
| 63 | /** |
---|
[5961] | 64 | * The RGB class allows to read & write a RGB value |
---|
| 65 | */ |
---|
| 66 | class RGB { |
---|
| 67 | protected $RGB = Array('R' => 0, 'G' => 0, 'B' => 0); |
---|
| 68 | |
---|
| 69 | public function __construct($R=0, $G=0, $B=0) |
---|
| 70 | { |
---|
| 71 | $this->set($R, $G, $B); |
---|
| 72 | } |
---|
| 73 | |
---|
[6176] | 74 | /** |
---|
| 75 | * set the R,G and B values |
---|
| 76 | * |
---|
| 77 | * @param Byte $R : the red value, between [0..255] |
---|
| 78 | * @param Byte $G : the green value, between [0..255] |
---|
| 79 | * @param Byte $B : the blue value, between [0..255] |
---|
| 80 | * @return Array('R'=>$R, 'G'=>$G, 'B'=>$B) |
---|
| 81 | */ |
---|
[5961] | 82 | public function set($R, $G, $B) |
---|
| 83 | { |
---|
| 84 | $this->setProperty('R', $R); |
---|
| 85 | $this->setProperty('G', $G); |
---|
| 86 | $this->setProperty('B', $B); |
---|
| 87 | return($this->get()); |
---|
| 88 | } |
---|
| 89 | |
---|
[6176] | 90 | /** |
---|
| 91 | * set RGB values from an Integer (0xFFFFFF : white value) |
---|
| 92 | * |
---|
| 93 | * @param Integer $value : the RGB value |
---|
| 94 | * @return Array('R'=>$R, 'G'=>$G, 'B'=>$B) |
---|
| 95 | */ |
---|
[5961] | 96 | public function setInt($value) |
---|
| 97 | { |
---|
| 98 | $tmp=ColorStat::IntToRGB($value); |
---|
| 99 | $tmp2=$tmp->get(); |
---|
| 100 | $this->set($tmp2['R'], $tmp2['G'], $tmp2['B']); |
---|
| 101 | unset($tmp2); |
---|
| 102 | unset($tmp); |
---|
| 103 | } |
---|
| 104 | |
---|
[6176] | 105 | /** |
---|
| 106 | * returns the current RGB values as array |
---|
| 107 | * |
---|
| 108 | * @param Boolean $floatValue : if set to true, values are returned as float |
---|
| 109 | * values between [0..1] otherwise values are |
---|
| 110 | * returned as integer between [0..255] |
---|
| 111 | * @return Array('R'=>$R, 'G'=>$G, 'B'=>$B) |
---|
| 112 | */ |
---|
[5961] | 113 | public function get($floatValue=false) |
---|
| 114 | { |
---|
| 115 | if($floatValue) |
---|
| 116 | { |
---|
| 117 | return( |
---|
| 118 | Array( |
---|
| 119 | 'R' => $this->RGB['R']/255, |
---|
| 120 | 'G' => $this->RGB['G']/255, |
---|
| 121 | 'B' => $this->RGB['B']/255, |
---|
| 122 | ) |
---|
| 123 | ); |
---|
| 124 | } |
---|
| 125 | else |
---|
| 126 | { |
---|
| 127 | return($this->RGB); |
---|
| 128 | } |
---|
| 129 | } |
---|
| 130 | |
---|
[6176] | 131 | |
---|
| 132 | /** |
---|
| 133 | * returns the current RGB values as hex string ('FFFFFF' : white) |
---|
| 134 | * |
---|
| 135 | * @return String |
---|
| 136 | */ |
---|
[5961] | 137 | public function getHexString() |
---|
| 138 | { |
---|
| 139 | return(sprintf('%02x%02x%02x', $this->RGB['R'], $this->RGB['G'], $this->RGB['B'])); |
---|
| 140 | } |
---|
| 141 | |
---|
[6176] | 142 | /** |
---|
| 143 | * returns the current RGB values as integer (0xFFFFFF : white) |
---|
| 144 | * |
---|
| 145 | * @return Integer |
---|
| 146 | */ |
---|
[5961] | 147 | public function getInt() |
---|
| 148 | { |
---|
| 149 | return( $this->RGB['R']<<16 + $this->RGB['G']<<8 + $this->RGB['B']); |
---|
| 150 | } |
---|
| 151 | |
---|
[6176] | 152 | |
---|
| 153 | /** |
---|
| 154 | * returns the current RGB values as a HSV object |
---|
| 155 | * |
---|
| 156 | * @return HSV |
---|
| 157 | */ |
---|
[5961] | 158 | public function getHSV() |
---|
| 159 | { |
---|
| 160 | return(ColorStat::RGBtoHSV($this)); |
---|
| 161 | } |
---|
| 162 | |
---|
[6176] | 163 | /** |
---|
| 164 | * set the RGB values from a HSV ojbect |
---|
| 165 | * |
---|
| 166 | * @param HSV $hsv : a HSV object |
---|
| 167 | */ |
---|
[5961] | 168 | public function setHSV(HSV $hsv) |
---|
| 169 | { |
---|
| 170 | $tmp=ColorStat::HSVtoRGB($hsv); |
---|
| 171 | $tmp2=$tmp->get(); |
---|
| 172 | $this->set($tmp2['R'], $tmp2['G'], $tmp2['B']); |
---|
| 173 | unset($tmp2); |
---|
| 174 | unset($tmp); |
---|
| 175 | } |
---|
| 176 | |
---|
[6176] | 177 | /** |
---|
| 178 | * set the RGB property |
---|
| 179 | * |
---|
| 180 | * @param String $property : 'R', 'G', 'B' |
---|
| 181 | * @param Integer $value : value between [0..255] |
---|
| 182 | * @return Integer : value of the property |
---|
| 183 | */ |
---|
[5961] | 184 | private function setProperty($property, $value) |
---|
| 185 | { |
---|
| 186 | if($property=='R' or $property=='G' or $property=='B') |
---|
| 187 | { |
---|
| 188 | if($value<0) $value=0; |
---|
| 189 | if($value>255) $value=255; |
---|
| 190 | |
---|
| 191 | $this->RGB[$property]=$value; |
---|
| 192 | return($this->RGB[$property]); |
---|
| 193 | } |
---|
| 194 | } |
---|
| 195 | } |
---|
| 196 | |
---|
| 197 | |
---|
| 198 | /** |
---|
| 199 | * The HSV class allows to read & write a HSV value |
---|
| 200 | */ |
---|
| 201 | class HSV { |
---|
| 202 | protected $HSV = Array('H' => 0, 'S' => 0, 'V' => 0); |
---|
| 203 | |
---|
| 204 | public function __construct($H=0, $S=0, $V=0) |
---|
| 205 | { |
---|
| 206 | $this->set($H, $S, $V); |
---|
| 207 | } |
---|
| 208 | |
---|
[6176] | 209 | /** |
---|
| 210 | * set the H, S and V values |
---|
| 211 | * |
---|
| 212 | * @param Integer $H : the hue value, between [0..360] |
---|
| 213 | * @param Byte $S : the saturation value, between [0..100] |
---|
| 214 | * @param Byte $V : the value value, between [0..100] |
---|
| 215 | * @return Array('H'=>$H, 'S'=>$S, 'V'=>$V) |
---|
| 216 | */ |
---|
[5961] | 217 | public function set($H, $S, $V) |
---|
| 218 | { |
---|
| 219 | $this->setProperty('H', $H); |
---|
| 220 | $this->setProperty('S', $S); |
---|
| 221 | $this->setProperty('V', $V); |
---|
| 222 | return($this->get()); |
---|
| 223 | } |
---|
| 224 | |
---|
[6176] | 225 | /** |
---|
| 226 | * returns the current HSV values as array |
---|
| 227 | * |
---|
| 228 | * @return Array('H'=>$H, 'S'=>$S, 'V'=>$V) |
---|
| 229 | */ |
---|
[5961] | 230 | public function get() |
---|
| 231 | { |
---|
| 232 | return($this->HSV); |
---|
| 233 | } |
---|
| 234 | |
---|
[6176] | 235 | /** |
---|
| 236 | * returns the current HSV values as a RGB object |
---|
| 237 | * |
---|
| 238 | * @return RGB |
---|
| 239 | */ |
---|
[5961] | 240 | public function getRGB() |
---|
| 241 | { |
---|
| 242 | return(ColorStat::HSVtoRGB($this)); |
---|
| 243 | } |
---|
| 244 | |
---|
[6176] | 245 | |
---|
| 246 | |
---|
| 247 | /** |
---|
| 248 | * set the HSV values from a RGB ojbect |
---|
| 249 | * |
---|
| 250 | * @param RGB $rgb : a RGB object |
---|
| 251 | */ |
---|
[5961] | 252 | public function setRGB(RGB $rgb) |
---|
| 253 | { |
---|
| 254 | $tmp=ColorStat::RGBtoHSV($rgb); |
---|
| 255 | $tmp2=$tmp->get(); |
---|
| 256 | $this->set($tmp2['H'], $tmp2['S'], $tmp2['V']); |
---|
| 257 | unset($tmp2); |
---|
| 258 | unset($tmp); |
---|
| 259 | } |
---|
| 260 | |
---|
[6176] | 261 | /** |
---|
| 262 | * set the HSV property |
---|
| 263 | * |
---|
| 264 | * @param String $property : 'H', 'S', 'V' |
---|
| 265 | * @param Integer $value : value between [0..255] |
---|
| 266 | * @return Integer : value of the property |
---|
| 267 | */ |
---|
[5961] | 268 | private function setProperty($property, $value) |
---|
| 269 | { |
---|
| 270 | if($property=='H') |
---|
| 271 | { |
---|
| 272 | $this->HSV['H']=$value%360; |
---|
| 273 | return($this->HSV['H']); |
---|
| 274 | } |
---|
| 275 | elseif($property=='S' or $property=='V') |
---|
| 276 | { |
---|
| 277 | if($value<0) $value=0; |
---|
| 278 | if($value>100) $value=100; |
---|
| 279 | |
---|
| 280 | $this->HSV[$property]=$value; |
---|
| 281 | return($this->HSV[$property]); |
---|
| 282 | } |
---|
| 283 | return(false); |
---|
| 284 | } |
---|
| 285 | } |
---|
| 286 | |
---|
| 287 | |
---|
| 288 | |
---|
| 289 | |
---|
| 290 | class ColorStat { |
---|
| 291 | static public $fileColorsStat = Array( |
---|
| 292 | 'pixels' => 0, |
---|
| 293 | 'analyzed' => 0, |
---|
| 294 | 'time' => 0, |
---|
| 295 | 'colors' =>0, |
---|
| 296 | 'fileName' => "", |
---|
| 297 | 'quality' => 0, |
---|
| 298 | ); |
---|
| 299 | |
---|
| 300 | /** |
---|
[6176] | 301 | * returns colors of an image file |
---|
[5961] | 302 | * |
---|
[6176] | 303 | * return : |
---|
| 304 | * |
---|
| 305 | * |
---|
| 306 | * |
---|
[5961] | 307 | * @param String $fileName : the name of picture to scan |
---|
| 308 | * @param String $colorTable : the color table model |
---|
| 309 | * @param String $options : Array of options |
---|
| 310 | * 'quality' : set the quality for analyze |
---|
| 311 | * 'maxTime' : set the maximum time for analyze |
---|
| 312 | * 'pps' : pixel per second analyzed |
---|
| 313 | * if 'maxTime' and 'pps' are greater than zero, the |
---|
| 314 | * quality parameter is computed automatically |
---|
[6176] | 315 | * @return : -1 if file doesn't exist |
---|
| 316 | * -2 if file is not a PNG, a JPEG or a GIF file |
---|
| 317 | * -3 if a fatal error occurs |
---|
| 318 | * array of HSV objects if everthing is Ok |
---|
[5961] | 319 | */ |
---|
| 320 | static function getFileColors($fileName, $colorTable, $options=array()) |
---|
| 321 | { |
---|
| 322 | $options=self::checkOptions($options); |
---|
| 323 | |
---|
| 324 | self::$fileColorsStat=Array( |
---|
| 325 | 'pixels' => 0, |
---|
| 326 | 'analyzed' => 0, |
---|
| 327 | 'time' => 0, |
---|
| 328 | 'pps' =>0, |
---|
| 329 | ); |
---|
| 330 | |
---|
| 331 | if(file_exists($fileName)) |
---|
| 332 | { |
---|
| 333 | $time=microtime(true); |
---|
| 334 | |
---|
[6176] | 335 | try |
---|
[5961] | 336 | { |
---|
[6176] | 337 | if(preg_match('/.*\.gif$/i', $fileName)) |
---|
| 338 | { |
---|
| 339 | $image = imagecreatefromgif($fileName); |
---|
| 340 | } |
---|
| 341 | elseif(preg_match('/.*\.(jpg|jpeg)$/i', $fileName)) |
---|
| 342 | { |
---|
| 343 | $image = imagecreatefromjpeg($fileName); |
---|
| 344 | } |
---|
| 345 | elseif(preg_match('/.*\.png$/i', $fileName)) |
---|
| 346 | { |
---|
| 347 | $image = imagecreatefrompng($fileName); |
---|
| 348 | } |
---|
| 349 | else |
---|
| 350 | { |
---|
| 351 | return(-2); |
---|
| 352 | } |
---|
[5961] | 353 | |
---|
| 354 | |
---|
[6176] | 355 | $imageWidth=imagesx($image); |
---|
| 356 | $imageHeight=imagesy($image); |
---|
[5961] | 357 | |
---|
[6210] | 358 | if($options['mode']=='numAnalyzed') |
---|
[6176] | 359 | { |
---|
[6210] | 360 | $quality=round(sqrt($imageWidth*$imageHeight/$options['numAnalyzed']), 0); |
---|
| 361 | } |
---|
| 362 | elseif($options['mode']=='maxTime') |
---|
| 363 | { |
---|
[6176] | 364 | $quality=round(sqrt($imageWidth*$imageHeight/($options['pps']*$options['maxTime'])), 0); |
---|
| 365 | } |
---|
| 366 | else |
---|
| 367 | { |
---|
| 368 | $quality=$options['quality']; |
---|
| 369 | } |
---|
[5961] | 370 | |
---|
[6176] | 371 | $imageWorkWidth=round($imageWidth/$quality,0); |
---|
| 372 | $imageWorkHeight=round($imageHeight/$quality,0); |
---|
| 373 | $imageWork=imagecreatetruecolor($imageWorkWidth,$imageWorkHeight); |
---|
| 374 | imagecopyresampled($imageWork, $image, 0, 0, 0, 0, $imageWorkWidth, $imageWorkHeight, $imageWidth, $imageHeight); |
---|
| 375 | //imagecopyresized($imageWork, $image, 0, 0, 0, 0, $imageWorkWidth, $imageWorkHeight, $imageWidth, $imageHeight); |
---|
| 376 | imagedestroy($image); |
---|
[5961] | 377 | |
---|
[6176] | 378 | $returned=Array(); |
---|
| 379 | |
---|
| 380 | $i=0; |
---|
| 381 | for($px=0;$px<$imageWorkWidth;$px++) |
---|
[5961] | 382 | { |
---|
[6176] | 383 | for($py=0;$py<$imageWorkHeight;$py++) |
---|
| 384 | { |
---|
| 385 | $i++; |
---|
| 386 | $value=imagecolorat($imageWork, $px, $py); |
---|
[5961] | 387 | |
---|
[6176] | 388 | $rgb=self::IntToRGB($value); |
---|
| 389 | //echo sprintf("%06x", $value)." => ".$rgb->getHexString(); |
---|
[5961] | 390 | |
---|
| 391 | |
---|
[6176] | 392 | //echo " ($i) ".$color->getHexString()."<br>"; |
---|
| 393 | |
---|
| 394 | if(DEBUG_MODE) |
---|
| 395 | { |
---|
| 396 | $color=self::getColorFromTable($rgb->getHSV(), $colorTable); |
---|
| 397 | $newRGB=$color->get(); |
---|
| 398 | $col=imagecolorallocate($imageWork, $newRGB['R'], $newRGB['G'], $newRGB['B']); |
---|
| 399 | imagesetpixel($imageWork, $px, $py, $col); |
---|
| 400 | imagecolordeallocate($imageWork, $col); |
---|
| 401 | $color=$color->getHexString(); |
---|
| 402 | unset($newRGB); |
---|
| 403 | } |
---|
| 404 | else |
---|
| 405 | { |
---|
| 406 | $color=self::getColorFromTable($rgb->getHSV(), $colorTable)->getHexString(); |
---|
| 407 | } |
---|
| 408 | |
---|
| 409 | |
---|
| 410 | if(array_key_exists($color, $returned)) |
---|
| 411 | { |
---|
| 412 | $returned[$color]['num']++; |
---|
| 413 | } |
---|
| 414 | else |
---|
| 415 | { |
---|
| 416 | $returned[$color]=Array( |
---|
| 417 | 'hsv' => $rgb->getHSV()->get(), |
---|
| 418 | 'num' => 1, |
---|
| 419 | 'pct' => 0, |
---|
| 420 | ); |
---|
| 421 | } |
---|
| 422 | unset($rgb); |
---|
[5961] | 423 | } |
---|
[6176] | 424 | } |
---|
| 425 | |
---|
| 426 | |
---|
| 427 | if(DEBUG_MODE) |
---|
| 428 | { |
---|
| 429 | $fName="q".$quality."_c".$options['numColors']."_nb".count($returned)."_".$fileName.".png"; |
---|
| 430 | imagepng($imageWork, $fName); |
---|
| 431 | } |
---|
| 432 | |
---|
| 433 | |
---|
| 434 | imagedestroy($imageWork); |
---|
| 435 | uasort($returned, Array('ColorStat', 'sortTones')); |
---|
| 436 | |
---|
| 437 | if($options['numColors']>0) |
---|
| 438 | { |
---|
| 439 | foreach($returned as $key=>$val) |
---|
[5961] | 440 | { |
---|
[6176] | 441 | $returnedColors[$key]=$val; |
---|
| 442 | $options['numColors']--; |
---|
| 443 | if($options['numColors']<=0) break; |
---|
[5961] | 444 | } |
---|
| 445 | } |
---|
[6176] | 446 | else |
---|
| 447 | { |
---|
| 448 | $returnedColors=$returned; |
---|
| 449 | } |
---|
[5961] | 450 | |
---|
[6176] | 451 | self::$fileColorsStat=Array( |
---|
| 452 | 'pixels' => $imageWidth*$imageHeight, |
---|
| 453 | 'analyzed' => $i, |
---|
| 454 | 'time' => microtime(true)-$time, |
---|
| 455 | 'colors' => count($returned), |
---|
| 456 | 'pps' => $i/(microtime(true)-$time), |
---|
| 457 | 'quality' => $quality, |
---|
| 458 | ); |
---|
[5961] | 459 | |
---|
[6176] | 460 | if(DEBUG_MODE) |
---|
[5961] | 461 | { |
---|
[6176] | 462 | self::$fileColorsStat['fileName']=$fName; |
---|
[5961] | 463 | } |
---|
| 464 | |
---|
[6176] | 465 | unset($returned); |
---|
[5961] | 466 | |
---|
[6176] | 467 | foreach($returnedColors as $key => $val) |
---|
| 468 | { |
---|
| 469 | $returnedColors[$key]['pct']=round(100*$val['num']/self::$fileColorsStat['analyzed'],2); |
---|
| 470 | } |
---|
[5961] | 471 | |
---|
[6176] | 472 | return($returnedColors); |
---|
| 473 | } |
---|
| 474 | catch (Exception $e) |
---|
[5961] | 475 | { |
---|
[6176] | 476 | echo "ERROR!<br>".print_r($e, true); |
---|
| 477 | return(-3); |
---|
[5961] | 478 | } |
---|
| 479 | |
---|
| 480 | } |
---|
| 481 | else |
---|
| 482 | { |
---|
| 483 | return(-1); |
---|
| 484 | } |
---|
| 485 | } |
---|
| 486 | |
---|
| 487 | /** |
---|
| 488 | * Calculate the HSV value from a RGB value |
---|
| 489 | * |
---|
| 490 | * @param RGB $RGB : RGB object |
---|
| 491 | * @return HSV : new HSV object |
---|
| 492 | */ |
---|
| 493 | static public function RGBtoHSV(RGB $RGB) |
---|
| 494 | { |
---|
| 495 | $rgbValues=$RGB->get(true); |
---|
| 496 | $max=self::max($rgbValues); |
---|
| 497 | $min=self::min($rgbValues); |
---|
| 498 | |
---|
| 499 | if($max['value']==$min['value']) |
---|
| 500 | { |
---|
| 501 | $H=0; |
---|
| 502 | } |
---|
| 503 | elseif($max['key']=='R') |
---|
| 504 | { |
---|
| 505 | $H=(60*($rgbValues['G']-$rgbValues['B'])/($max['value']-$min['value'])+360)%360; |
---|
| 506 | } |
---|
| 507 | elseif($max['key']=='G') |
---|
| 508 | { |
---|
| 509 | $H=(60*($rgbValues['B']-$rgbValues['R'])/($max['value']-$min['value'])+120); |
---|
| 510 | } |
---|
| 511 | elseif($max['key']=='B') |
---|
| 512 | { |
---|
| 513 | $H=(60*($rgbValues['R']-$rgbValues['G'])/($max['value']-$min['value'])+240); |
---|
| 514 | } |
---|
| 515 | |
---|
| 516 | $S=round(100*(($max['value']==0)?0:1-$min['value']/$max['value']),0); |
---|
| 517 | $V=round(100*$max['value'],0); |
---|
| 518 | |
---|
| 519 | return(new HSV($H, $S, $V)); |
---|
| 520 | } |
---|
| 521 | |
---|
| 522 | /** |
---|
| 523 | * Calculate the RGB value from a HSV value |
---|
| 524 | * |
---|
| 525 | * @param HSV $HSV : HSV object |
---|
| 526 | * @return RGB : new RGB object |
---|
| 527 | */ |
---|
| 528 | static public function HSVtoRGB(HSV $HSV) |
---|
| 529 | { |
---|
| 530 | $hsvValues=$HSV->get(); |
---|
| 531 | |
---|
| 532 | $h=abs($hsvValues['H']/60)%6; |
---|
| 533 | $f=$hsvValues['H']/60-$h; |
---|
| 534 | $l=round(2.55*$hsvValues['V']*(1-$hsvValues['S']/100),0); |
---|
| 535 | $m=round(2.55*$hsvValues['V']*(1-$f*$hsvValues['S']/100),0); |
---|
| 536 | $n=round(2.55*$hsvValues['V']*(1-(1-$f)*$hsvValues['S']/100),0); |
---|
| 537 | |
---|
| 538 | $v=round(2.55*$hsvValues['V'],0); |
---|
| 539 | |
---|
| 540 | switch($h) |
---|
| 541 | { |
---|
| 542 | case 0: |
---|
| 543 | return(new RGB($v, $n, $l)); |
---|
| 544 | break; |
---|
| 545 | case 1: |
---|
| 546 | return(new RGB($m, $v, $l)); |
---|
| 547 | break; |
---|
| 548 | case 2: |
---|
| 549 | return(new RGB($l, $v, $n)); |
---|
| 550 | break; |
---|
| 551 | case 3: |
---|
| 552 | return(new RGB($l, $m, $v)); |
---|
| 553 | break; |
---|
| 554 | case 4: |
---|
| 555 | return(new RGB($n, $l, $v)); |
---|
| 556 | break; |
---|
| 557 | case 5: |
---|
| 558 | return(new RGB($v, $l, $m)); |
---|
| 559 | break; |
---|
| 560 | } |
---|
| 561 | } |
---|
| 562 | |
---|
| 563 | /** |
---|
| 564 | * |
---|
| 565 | * @param Int $rgb : an integer &hRRGGBB |
---|
| 566 | * @return RGB : a RGB object |
---|
| 567 | */ |
---|
| 568 | static public function IntToRGB($rgb) |
---|
| 569 | { |
---|
| 570 | return(new RGB(($rgb >> 16) & 0xFF, ($rgb >> 8) & 0xFF, $rgb & 0xFF, true)); |
---|
| 571 | } |
---|
| 572 | |
---|
| 573 | /** |
---|
| 574 | * return a color table |
---|
[6176] | 575 | * $table[h][s][v] => HSV object or string 'RRGGBB' |
---|
[5961] | 576 | * |
---|
| 577 | * @param Int $huePrec : degree of precision for hue [1..360] |
---|
| 578 | * @param Float $prec : precision step for saturation & value [1..100] |
---|
| 579 | * @param String $returnedType : 'HSV' => return a HSV object |
---|
[6176] | 580 | * 'color' => return a color string 'RRGGBB' |
---|
[5961] | 581 | * @return Array : the color table |
---|
| 582 | */ |
---|
| 583 | static public function getColorTable($huePrec=10, $prec=10, $returnedType='HSV') |
---|
| 584 | { |
---|
| 585 | $returned=Array(); |
---|
[6176] | 586 | for($hue=0;$hue<360;$hue+=$huePrec) |
---|
[5961] | 587 | { |
---|
| 588 | $hueValues=Array(); |
---|
| 589 | |
---|
[6176] | 590 | for($saturation=0;$saturation<=100;$saturation+=$prec) |
---|
[5961] | 591 | { |
---|
[6176] | 592 | $saturationValues=Array(); |
---|
[5961] | 593 | |
---|
[6176] | 594 | for($value=0;$value<=100;$value+=$prec) |
---|
[5961] | 595 | { |
---|
[6176] | 596 | $hsv=new HSV($hue, $saturation, $value); |
---|
| 597 | if($returnedType=='HSV') |
---|
| 598 | { |
---|
| 599 | $saturationValues[$value]=$hsv; |
---|
| 600 | } |
---|
| 601 | else |
---|
| 602 | { |
---|
| 603 | $saturationValues[$value]=$hsv->getRGB()->getHexString(); |
---|
| 604 | } |
---|
| 605 | unset($hsv); |
---|
[5961] | 606 | } |
---|
| 607 | |
---|
[6176] | 608 | $hueValues[$saturation]=$saturationValues; |
---|
| 609 | unset($saturationValues); |
---|
[5961] | 610 | } |
---|
[6176] | 611 | $returned[$hue]=$hueValues; |
---|
[5961] | 612 | unset($hueValues); |
---|
| 613 | } |
---|
| 614 | |
---|
| 615 | |
---|
| 616 | return($returned); |
---|
| 617 | } |
---|
| 618 | |
---|
| 619 | /** |
---|
| 620 | * @param Array : an array |
---|
| 621 | * @return Array : an array, giving the minimum value and the related key |
---|
| 622 | */ |
---|
| 623 | static protected function min($values) |
---|
| 624 | { |
---|
| 625 | $minKey=""; |
---|
| 626 | $minValue=0; |
---|
| 627 | foreach($values as $key => $val) |
---|
| 628 | { |
---|
| 629 | if($minKey=='' or $val<$minValue) |
---|
| 630 | { |
---|
| 631 | $minKey=$key; |
---|
| 632 | $minValue=$val; |
---|
| 633 | } |
---|
| 634 | } |
---|
| 635 | return(Array('key' => $minKey, 'value' => $minValue)); |
---|
| 636 | } |
---|
| 637 | |
---|
| 638 | /** |
---|
| 639 | * reverted sort color |
---|
| 640 | * |
---|
| 641 | */ |
---|
| 642 | static protected function sortTones($a, $b) |
---|
| 643 | { |
---|
| 644 | if($a['num'] == $b['num']) |
---|
| 645 | { |
---|
| 646 | return(0); |
---|
| 647 | } |
---|
| 648 | return ($a['num'] > $b['num']) ? -1 : 1; |
---|
| 649 | } |
---|
| 650 | |
---|
| 651 | /** |
---|
| 652 | * @param Array : an array |
---|
| 653 | * @return Array : an array, giving the maximum value and the related key |
---|
| 654 | */ |
---|
| 655 | static protected function max($values) |
---|
| 656 | { |
---|
| 657 | $maxKey=""; |
---|
| 658 | $maxValue=0; |
---|
| 659 | foreach($values as $key => $val) |
---|
| 660 | { |
---|
| 661 | if($maxKey=='' or $val>$maxValue) |
---|
| 662 | { |
---|
| 663 | $maxKey=$key; |
---|
| 664 | $maxValue=$val; |
---|
| 665 | } |
---|
| 666 | } |
---|
| 667 | return(Array('key' => $maxKey, 'value' => $maxValue)); |
---|
| 668 | } |
---|
| 669 | |
---|
| 670 | /** |
---|
| 671 | * check the validity for getFileColors() options |
---|
| 672 | * if no parameters are given, return the default options values |
---|
| 673 | * |
---|
| 674 | * @param Array $options : an array with given options values |
---|
| 675 | * @return Array : an array with valid options values |
---|
| 676 | */ |
---|
| 677 | static protected function checkOptions($options=Array()) |
---|
| 678 | { |
---|
| 679 | if(!is_array($options)) |
---|
| 680 | { |
---|
| 681 | $options=Array(); |
---|
| 682 | } |
---|
| 683 | |
---|
| 684 | if(!array_key_exists('quality', $options)) $options['quality']=1; |
---|
[6210] | 685 | if(!array_key_exists('maxTime', $options)) $options['maxTime']=0.5; |
---|
| 686 | if(!array_key_exists('pps', $options)) $options['pps']=1; |
---|
| 687 | if(!array_key_exists('numAnalyzed', $options)) $options['numAnalyzed']=600; |
---|
[5961] | 688 | if(!array_key_exists('numColors', $options)) $options['numColors']=0; |
---|
[6210] | 689 | if(!array_key_exists('mode', $options)) $options['mode']='quality'; |
---|
[5961] | 690 | |
---|
| 691 | if($options['quality']<=0) $options['quality']=1; |
---|
| 692 | if($options['quality']>20) $options['quality']=20; |
---|
[6210] | 693 | if($options['maxTime']<0) $options['maxTime']=0.5; |
---|
| 694 | if($options['pps']<0) $options['pps']=1; |
---|
| 695 | if($options['numAnalyzed']<0) $options['numAnalyzed']=600; |
---|
| 696 | if($options['numColors']<0) $options['numColors']=16; |
---|
[5961] | 697 | |
---|
[6210] | 698 | if($options['mode']!='quality' and |
---|
| 699 | $options['mode']!='numAnalyzed' and |
---|
| 700 | $options['mode']!='maxTime') $options['mode']='quality'; |
---|
| 701 | |
---|
[5961] | 702 | return($options); |
---|
| 703 | } |
---|
| 704 | |
---|
[6176] | 705 | /** |
---|
| 706 | * for the given color, return the nearest color of the color table |
---|
| 707 | * |
---|
| 708 | * @param HSV $hsvObject : the color, as HSV object |
---|
| 709 | * @param Array $colorTable : the colorTable |
---|
| 710 | * @param String $mode : 'HSV' or 'RGB' to define the returned object |
---|
| 711 | * @return HSV or RGB : the color |
---|
| 712 | */ |
---|
| 713 | static public function getColorFromTable(HSV $hsvObject, $colorTable, $mode='RGB') |
---|
[5961] | 714 | { |
---|
| 715 | $hsv=$hsvObject->get(); |
---|
[6176] | 716 | //echo "*H:".$hsv['H']." "; |
---|
| 717 | //echo "*S:".$hsv['S']." "; |
---|
| 718 | //echo "*V:".$hsv['V']."<br>"; |
---|
[5961] | 719 | |
---|
[6176] | 720 | $hue=360/count($colorTable); |
---|
[5961] | 721 | $hueNumber=round($hsv['H']/$hue,0); |
---|
[6176] | 722 | $step=100/(count($colorTable[0])-1); |
---|
| 723 | //echo "*H_Step:$hue<br>"; |
---|
| 724 | //echo "*SV_Step:$step<br>"; |
---|
[5961] | 725 | |
---|
[6176] | 726 | $hsv['S']=round((100/$step)*$hsv['S']/100,0)*$step; |
---|
| 727 | $hsv['V']=round((100/$step)*$hsv['V']/100,0)*$step; |
---|
| 728 | $hsv['H']=($hueNumber*$hue)%360; |
---|
| 729 | //echo "*H:".$hsv['H']." "; |
---|
| 730 | //echo "*S:".$hsv['S']." "; |
---|
[5961] | 731 | //echo "*V:".$hsv['V']."<br>"; |
---|
| 732 | |
---|
[6176] | 733 | if($mode=='RGB') |
---|
[5961] | 734 | { |
---|
[6176] | 735 | return($colorTable[$hsv['H']][$hsv['S']][$hsv['V']]->getRGB()); |
---|
[5961] | 736 | } |
---|
[6176] | 737 | else |
---|
[5961] | 738 | { |
---|
[6176] | 739 | return($colorTable[$hsv['H']][$hsv['S']][$hsv['V']]); |
---|
[5961] | 740 | } |
---|
| 741 | } |
---|
| 742 | |
---|
| 743 | } |
---|
| 744 | |
---|
| 745 | |
---|
| 746 | |
---|
| 747 | |
---|
| 748 | |
---|
| 749 | |
---|
| 750 | ?> |
---|