Analiza zdjęcia pod wzgledem kolorystyki Opcje

[mhs]

Witam,

chciałbym przygotować mechanizm, który automatycznie poddajcie analizie określone zdjęcia i następnie generuje dla niego 5-6 podstawowych kolorów które najtrafniej określają kolorystykę dane zdjęcia.

Coś podobne załóżmy jak tutaj (http://freszki.pl) np http://freszki.pl/freszka/548,videoegg czy http://www.dreamstime.com/royalty-free-sto...rs-image9781689 (dominant colors) czyli dla zdjęcia określone są podstawowe kolory i na bazie przypisanych tych wszystkich kolorów możliwe jest przygotowanie wyszukiwarki która znajdzie określone zdjęcia w podobnej kolorystyce.

Spotkał się ktoś z Was z takimi mechanizmami (jakimiś gotowymi bibliotekami) i ma pomysł jak "szybko" i sprawnie coś takiego przygotować?

Pozdrawiam, mhs.

[kiler129]

Ja właśnie walczę z identycznym zagadnieniem
Kolor można określać na 2 sposoby - albo jako RGB (lub CMYK) albo jako wartość jasności, odcienia i nasycenia.
Myślę, że najskuteczniej będzie zbadać przy dodawaniu odcień i nasycenie; przy wybieraniu zakres +/- 30 dla odcienia (wartości możliwe od -180 do +180) oraz doświadczalnie jasność.
Wybieranie tego po RGB czy CMYK jest strasznie karkołomne - tam trudno zobaczyć które kolory są podobne.

Jeśli chcesz się pobawić i zobaczyć jak te wartości wpływają na kolor ściągnij GIMP`a (http://gimp.org), zrób nowy obrazek i kliknij w górnej belce Color > Hue-saturation a następnie baw sie suwakami.

Jak implementować to w php? Na razie nie wiem

[Mephistofeles]

Określić "odległość" koloru od środka zakresu kolorów, a potem posortować i wziąć najmniejszą?

[kiler129]

Określić "odległość" koloru od środka zakresu kolorów, a potem posortować i wziąć najmniejszą?

Moglbys dokladniej opisac metode znalezienia podobnych?

Zauwaz ze biorac odleglosc od srodka uwzgledniasz chyba tylko zmiane jasnosci ale nie juz odcienia wiec rozowy tym sposobem nie bedzie podobny do czerwonego, hmmmmm


EDIT:
Napisałem taką klasę:

[PHP] pobierz, plaintext 
<?php
class avgColor {
 var $pixProbX = 10; //Eg. if img is 120x120 script probe for pixel #0, 10, 20 etc
 var $pixProbY = 10; //See above
 private $imgRes; //Loaded GD2 resource image
 private $imgResY; //Img height [axis Y]
 private $imgResX; //Img width [axis X]
 private $colorMap; //Table of color in image
 private $totalProbPix; //Total probbed pixels - used for % calculation
 
 function __construct($imgPath) {
  if(!is_file($imgPath) || !is_readable($imgPath)) {
   trigger_error("Cannot open $imgPath", E_USER_ERROR);
   return false;
  }
 
  $imgInfo = getimagesize($imgPath);
  $this->imgResY = $imgInfo[1];
  $this->imgResX = $imgInfo[0]; 
 
  switch($imgInfo["mime"]) {
   case "image/jpeg": $this->imgRes = imagecreatefromjpeg($imgPath); break;
   case "image/png": $this->imgRes = imagecreatefrompng($imgPath); break;
   case "image/gif": $this->imgRes = imagecreatefromgif($imgPath); break;
   case "image/jpeg": $this->imgRes = imagecreatefromjpeg($imgPath); break;
  }
 }
 
 function trcArr(&$arr, $elements=10) {
  $i=1;
  foreach($arr as $key=>$val) {
   if($i<=$elements) $ret[$key] = $val;
   $i++;
  }
  $arr=$ret;
 }
 
 function mapColors($el=10) { //Make colors map in image with counter.
  if($this->imgResY < $this->pixProbY) $this->pixProbY = $this->imgResY; //If Y axis is smaller than defined probing use maximum value
  if($this->imgResX < $this->pixProbX) $this->pixProbX = $this->imgResX; //Same as above for X axis
 
  $loopsY = (int)($this->imgResY/$this->pixProbY); //Number of samples, cutted to int, Y axis
  $loopsX = (int)($this->imgResX/$this->pixProbX); //Same as above for X axis
   if($loopsY==0 || $loopsX==0) { trigger_error("Cannot make colormap for $imgPath - loops for X/Y axis == 0", E_USER_ERROR); return; } //Check psblt.
  $this->totalProbPix = $loopsY+$loopsX; 
 
        //echo "Y=".$this->imgResY." | X=".$this->imgResX." | prbY=".$this->pixProbY." | prbX=".$this->pixProbX."\n\n";
  //if($loopsX > $loopsY) { //If image contain more "rows" than "columns" typed to parsing parse by columns
 
   for($y=0;$y<$loopsY;$y++) { //Loop for columns
    for($x=0;$x<$loopsX;$x++) { //Loop for pixels in column
     $rgb = imagecolorat($this->imgRes, ($x*$this->pixProbX), ($y*$this->pixProbY));
     @$this->colorMap[(($rgb >> 16) & 0xFF).".".(($rgb >> 8) & 0xFF).".".($rgb & 0xFF)]++;
    }
   }
  //} else { //...or if image contain more "cols" than "rows" typed to parsing parse row-by-row and then probe every pixel in row
 
  //}
 
  arsort($this->colorMap); //Sort arr
  $this->trcArr($this->colorMap, $el); //Strip array
  return $this->colorMap;
 }
 
 function mostUsedColor(&$map) {
  reset($map);
  $muc = each($map);
  $muc["key"] = explode(".", $muc["key"]);
   $ret["color"] = dechex($muc["key"][0]).dechex($muc["key"][1]).dechex($muc["key"][2]); //Make hex notation of color
   $ret["percent"] = round((($muc["value"]/$this->totalProbPix)*100),2); //Calculate percen value
 
  return $ret; 
 }
}
?>
[PHP] pobierz, plaintext 

Przykład użycia:

[PHP] pobierz, plaintext 
<?php
 error_reporting(E_ALL);
 ini_set('display_errors', '1');
 
 require_once("sim.class.php");
 $_sim = new avgColor("imgs/647636.jpg");
 var_dump($_sim->mostUsedColor($_sim->mapColors())); 
?>
[PHP] pobierz, plaintext 

Klasa ładnie wygciąga najczęściej występujący kolor ale dla tapety 1280x1024 jest dość wolna gdy analizuje się każdy pixel ($pixProbX oraz $pixProbY na 1), jeśli natomiast zmniejszy się dokładność o 10x to działa szybko no ale....
Ma ktoś inny pomysł? Dodatkowo pozostaje kwestia porównania.

EDIT2:
Wracam z nowym kodem Dodałem metodę avgColor która jest o 2-2.5x szybsza ale ciągle dla 4k x 3k trwa to blisko 20sekund

[PHP] pobierz, plaintext 
<?php
class avgColor {
 var $pixProbX = 1; //Eg. if img is 120x120 script probe for pixel #0, 10, 20 etc
 var $pixProbY = 1; //See above
 private $imgRes; //Loaded GD2 resource image
 private $imgResY; //Img height [axis Y]
 private $imgResX; //Img width [axis X]
 private $colorMap; //Table of color in image
 private $totalProbPix; //Total probbed pixels - used for % calculation | value for most used color
 private $totalPixAvg; //Similar to above but for avg color calculation
 
 function __construct($imgPath) {
  if(!is_file($imgPath) || !is_readable($imgPath)) {
   trigger_error("Cannot open $imgPath", E_USER_ERROR);
   return false;
  }
 
  $imgInfo = getimagesize($imgPath);
  $this->imgResY = $imgInfo[1];
  $this->imgResX = $imgInfo[0]; 
 
  switch($imgInfo["mime"]) {
   case "image/jpeg": $this->imgRes = imagecreatefromjpeg($imgPath); break;
   case "image/png": $this->imgRes = imagecreatefrompng($imgPath); break;
   case "image/gif": $this->imgRes = imagecreatefromgif($imgPath); break;
   case "image/jpeg": $this->imgRes = imagecreatefromjpeg($imgPath); break;
  }
 }
 
 function trcArr(&$arr, $elements=10) {
  $i=1;
  foreach($arr as $key=>$val) {
   if($i<=$elements) $ret[$key] = $val;
   $i++;
  }
  $arr=$ret;
 }
 
 private function mapColors($el=10) { //Make colors map in image with counter.
  if($this->imgResY < $this->pixProbY) $this->pixProbY = $this->imgResY; //If Y axis is smaller than defined probing use maximum value
  if($this->imgResX < $this->pixProbX) $this->pixProbX = $this->imgResX; //Same as above for X axis
 
  $loopsY = (int)($this->imgResY/$this->pixProbY); //Number of samples, cutted to int, Y axis
  $loopsX = (int)($this->imgResX/$this->pixProbX); //Same as above for X axis
   if($loopsY==0 || $loopsX==0) { trigger_error("Cannot make colormap for $imgPath - loops for X/Y axis == 0", E_USER_ERROR); return; } //Check psblt.
  $this->totalProbPix = $loopsY+$loopsX; 
 
        //echo "Y=".$this->imgResY." | X=".$this->imgResX." | prbY=".$this->pixProbY." | prbX=".$this->pixProbX."\n\n";
  //if($loopsX > $loopsY) { //If image contain more "rows" than "columns" typed to parsing parse by columns
 
   for($y=0;$y<$loopsY;$y++) { //Loop for columns
    for($x=0;$x<$loopsX;$x++) { //Loop for pixels in column
     $rgb = imagecolorat($this->imgRes, ($x*$this->pixProbX), ($y*$this->pixProbY));
     @$this->colorMap[(($rgb >> 16) & 0xFF).".".(($rgb >> 8) & 0xFF).".".($rgb & 0xFF)]++;
    }
   }
  //} else { //...or if image contain more "cols" than "rows" typed to parsing parse row-by-row and then probe every pixel in row
 
  //}
 
  arsort($this->colorMap); //Sort arr
  $this->trcArr($this->colorMap, $el); //Strip array
  return $this->colorMap;
 }
 
 function mostUsedColor() {
  $this->mapColors(1); //Make color map
  reset($this->colorMap);
  $muc = each($this->colorMap);
  $muc["key"] = explode(".", $muc["key"]);
   $ret["color"] = dechex($muc["key"][0]).dechex($muc["key"][1]).dechex($muc["key"][2]); //Make hex notation of color
   $ret["percent"] = round((($muc["value"]/$this->totalProbPix)*100),2); //Calculate percen value
 
  return $ret; 
 }
 
 function avgColor() { //Analyze every pixel and return avg color
  $this->totalPixAvg=0;
  $color=array("r"=>0,"g"=>0,"b"=>0,"rgb"=>"fff");
  for ($x=0;$x<imagesx($this->imgRes);$x++) {
   for ($y=0;$y<imagesy($this->imgRes);$y++) {
    $rgb = imagecolorat($this->imgRes, $x, $y);
    $color["r"] += (($rgb >> 16) & 0xFF);
    $color["g"] += (($rgb >> 8) & 0xFF);
    $color["b"] += $rgb & 0xFF;
    $this->totalPixAvg++;
   }
  }
 
 
  $color["r"] = round($color["r"]/$this->totalPixAvg);
  $color["g"] = round($color["g"]/$this->totalPixAvg);
  $color["b"] = round($color["b"]/$this->totalPixAvg);
  $color["rgb"] = dechex($color["r"]).dechex($color["g"]).dechex($color["b"]);
 
  return $color;
 }
 
}
?>
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
<?php
/********************************************************************************
*/
function _st() { 
 $mtime = explode(" ", microtime()); 
 return $mtime[1] + $mtime[0];
}
 
function _et($_st) {
   $mtime = explode(" ",microtime()); 
   $execT = (($mtime[1] + $mtime[0]) - $_st);
   echo "\n\n".str_repeat("-", 40)."\nExec time: ".(($execT<1)?($execT*1000)."ms":$execT."s")."\n\n"; 
}
/********************************************************************************
*/
 
 error_reporting(E_ALL);
 ini_set('display_errors', '1');
 
 require_once("sim.class.php");
 $_sim = new avgColor("imgs/647596.jpg");
 
 $_st=_st();
 //var_dump($_sim->mostUsedColor()); 
 var_dump($_sim->avgColor());
 _et($_st);
?>
[PHP] pobierz, plaintext 

Ten post edytował kiler129 14.12.2010, 09:48:13

[Quadina]

Ja bym mimo wszystko liczył dla RGB, najpierw policzył wszystkie pixele, następnie zaniedbał 10% podobnych, posortował i wydrukował wynik. Jasność wydaje mi się tutaj trochę uszkadzaniem takiego algorytmu np. dla zdjęć szarych. Operując na RGB i procentach w odchyleniu standardowym zawsze będzie działać - przynajmniej w teorii. Zagadnienie na tyle Ciekawe, że chyba spróbuje sam coś takiego napisać i zamieszczę oczywiście rozwiązanie tutaj. Pomysł jest jeszcze jeden. Przeskalować obrazek na 10-30 razy mniejszy i dla takiego sprawdzić bez zaniedbywania. Możliwości spajania kolorów przez funkcje zmniejszające obrazki wydają mi się na tyle dobre, żeby można było je wykorzystywać również do takich celów.

[kiler129]

. Pomysł jest jeszcze jeden. Przeskalować obrazek na 10-30 razy mniejszy i dla takiego sprawdzić bez zaniedbywania. Możliwości spajania kolorów przez funkcje zmniejszające obrazki wydają mi się na tyle dobre, żeby można było je wykorzystywać również do takich celów.

Też o tym słyszałem tyle i myślałem lecz w kontekście zmniejszenia do 1x1px. Jest jednak jeden problem - różne subwersje GD generują różne wyniki dla takiej operacji przez co można sobie zrobić niezły bałagan po aktualizacji php

Co do rozwiązania to gdyby moją klasę zmodyfikować tak aby najpierw skalowała np. do 200x200px [gdzie obrazek wtedy jest już analizowany szybko] można zastosować metodę mostUsedColor(10) a następnie wyciągać średnią z tych 10 najczęściej użytych.
Wtedy będzie to chyba najsensowniejsze.

[Quadina]

Pierwsza wersja mojego pomysłu z zmniejszaniem zdjęć i zaniedbywaniem kolorów poniżej. Dużo się można jeszcze przyczepić, w każdym razie obrazek 2048x1536 przerobiła w niecałe 5 sekund.

[PHP] pobierz, plaintext 
<?php
class histogram{
	private $imgRes; //Loaded GD2 resource image
	private $imgResY; //Img height [axis Y]
	private $imgResX; //Img width [axis X]
	private $colorMap; //Table of color in image
	private $identMap; //Table of color in image
	function __construct($imgPath) {
		if(!is_file($imgPath) || !is_readable($imgPath)) {
			trigger_error("Cannot open $imgPath", E_USER_ERROR);
			return false;
		}
		$imgInfo = getimagesize($imgPath);
		$this->imgResY = $imgInfo[1];
		$this->imgResX = $imgInfo[0];
 
		switch($imgInfo["mime"]) {
			case "image/jpeg": $this->imgRes = imagecreatefromjpeg($imgPath); break;
			case "image/png": $this->imgRes = imagecreatefrompng($imgPath); break;
			case "image/gif": $this->imgRes = imagecreatefromgif($imgPath); break;
			case "image/jpeg": $this->imgRes = imagecreatefromjpeg($imgPath); break;
		}
	}
	function normalize($tx=400,$ty=400){
		if($tx>$this->imgResX && $ty>$this->imgResY){
			return false;
		}
		if($tx>$this->imgResX) $tx=$this->imgResX;
		if($ty>$this->imgResY) $ty=$this->imgResY;
		$thumb = imagecreatetruecolor($tx, $ty);
		imagecopyresized($thumb, $this->imgRes, 0, 0, 0, 0, $tx, $ty, $this->imgResX, $this->imgResY);
		$this->imgRes = $thumb;
		$this->imgResX = $tx;
		$this->imgResY = $ty;
		return true;
	}
	function prepare($p=20){
		for($x=0;$x<$this->imgResX;$x++){
			for($y=0;$y<$this->imgResY;$y++){
				$rgb = imagecolorat($this->imgRes, $x, $y);
				$r = (($rgb >> 16) & 0xFF);
				$g = (($rgb >> 8) & 0xFF);
				$b = ($rgb & 0xFF);
				$ident = floor($r/$p).floor($g/$p).floor($b/$p);
				@$this->colorMap[$ident]++;
				$this->identMap[$ident] = $r.'.'.$g.'.'.$b;
			}
		}
		arsort($this->colorMap); //Sort arr
		$this->trcArr($this->colorMap, $p); //Strip array
		return $this->colorMap;
	}
	function trcArr(&$arr, $elements=10) {
		$i=1;
		foreach($arr as $key=>$val) {
			if($i<=$elements) $ret[$key] = $val;
			$i++;
		}
		$arr=$ret;
	}
	function mostUsedColor() {
		$sum = $this->imgResX * $this->imgResY;
		$tmp = each($this->colorMap);
		return array(
			'color' => $this->identMap[ $tmp['key'] ],
			'percent' => floor($tmp['value']/$sum*100),
		);
	}
}
$t1 = microtime(1);
$i = new histogram('avatar.png'); // 100x100
$i->normalize();
$i->prepare();
$t = $i->mostUsedColor();
echo $t['color'].' => '.$t['percent']."\t\t". (microtime(1)-$t1)."ms\n";
 
$t1 = microtime(1);
$i = new histogram('samochod.jpg'); // 800x592
$i->normalize();
$i->prepare();
$t = $i->mostUsedColor();
echo $t['color'].' => '.$t['percent']."\t\t". (microtime(1)-$t1)."ms\n";
 
$i = new histogram('IMAG0241.jpg'); // 2048x1536
$i->normalize();
$i->prepare();
$t = $i->mostUsedColor();
echo $t['color'].' => '.$t['percent']."\t\t". (microtime(1)-$t1)."ms\n";
[PHP] pobierz, plaintext 

Dostaje w zamian trochę większy czas obliczen dla małych zdjęć, ale krótszy dla większych zdjęć - porównywanie wykonałem testując twoją klasę moim testem na tych samych 3 obrazkach.

[PHP] pobierz, plaintext 
// Twoja wersja, ale chyba cos procenty ci sie zle licza
383838 => 955.5         0.092159986495972ms
fdfdfd => 14303.02              4.5690710544586ms
444 => 3460.27          30.853181123734ms
 
// moja wersja 
383838 => 24            0.12960004806519ms
fdfdfd => 57            2.2384610176086ms
1170 => 21              4.648444890976ms
[PHP] pobierz, plaintext 

EDIT: zauważylem, że mamy różne kolory dla największych ostatnich obrazków - zaraz sprawdzę dlaczego tak się stało, ale wydaje mi się, że jest to wynik uproszczenia, które ja stosuje i wiążącego się z nim błędu ostatniego koloru w tablicy $identmap.

Ten post edytował Quadina 14.12.2010, 13:52:46

[kiler129]

No ja obecnie zrobiłem to chyba prościej:

[PHP] pobierz, plaintext 
<?php
class avgColor {
 var $resampledSize=300; //Img scaling to X pixels [keeps aspect ratio]
 var $samplingAvg=10; //Number of results to averaging
 private $gdResImg; //Loaded GD2 resource image
 private $imgResY; //Img height [axis Y]
 private $imgResX; //Img width [axis X]
 var $colorMap; //Table of color in image
 
 private function resizeResource() {
  $max = $this->resampledSize;
  $ratio = $this->imgResX/$this->imgResY;
  $newX=$newY=$max;
  if ($ratio < 1) $newX = $max*$ratio; else $newY = $max/$ratio; //Cares about ratio
  $tmpRes = imagecreatetruecolor($newX, $newY);
  imagecopyresampled($tmpRes, $this->gdResImg, 0, 0, 0, 0, $newX, $newY, $this->imgResX, $this->imgResY);
  $this->imgRes = $tmpRes;
  $this->imgResX = $newX;
  $this->imgResY = $newY;
  unset($tmpRes);
 }
 
 function __construct($imgPath) {
  if(!is_file($imgPath) || !is_readable($imgPath)) {
   trigger_error("Cannot open $imgPath", E_USER_ERROR);
   return false;
  }
 
  $imgInfo = getimagesize($imgPath);
  $this->imgResY = $imgInfo[1];
  $this->imgResX = $imgInfo[0]; 
 
  switch($imgInfo["mime"]) {
   case "image/jpeg": $this->gdResImg = imagecreatefromjpeg($imgPath); break;
   case "image/png": $this->gdResImg = imagecreatefrompng($imgPath); break;
   case "image/gif": $this->gdResImg = imagecreatefromgif($imgPath); break;
   case "image/jpeg": $this->gdResImg = imagecreatefromjpeg($imgPath); break;
  }
 
  $this->resizeResource(); //Resize res for sampling
 }
 
 private function trcArr(&$arr, $elements=10) { //truncate array to specified nums of elements
  $i=1;
  foreach($arr as $key=>$val) {
   if($i<=$elements) $ret[$key] = $val;
   $i++;
  }
  $arr=$ret;
 }
 
 private function mapColors($force=false) { //Make colors map for image; 1st param is force rerun function even if the map is already done
  if(!empty($this->colorMap)&&!$force) return; //If map is already done do nothing
 
  $this->colorMap=array();
  for ($x=0;$x<$this->imgResX;$x++) { //Loop for "rows"
   for ($y=0;$y<$this->imgResY;$y++) { //Loop for every pixel in "row"
    $rgb = imagecolorat($this->gdResImg, $x, $y);
    @$this->colorMap[(($rgb >> 16) & 0xFF)."-".(($rgb >> 8) & 0xFF)."-".($rgb & 0xFF)]++; //Hide notices about index
   }
  }
 
  arsort($this->colorMap); //Sort arr
  $this->trcArr($this->colorMap, $this->samplingAvg); //Strip array
 }
 
 
 
 private function avgColor() { //Better method for avg color
  $this->mapColors(); //Make map w/o force
  $color=array("r"=>0,"g"=>0,"b"=>0,"rgb"=>"fff");
 
  foreach($this->colorMap as $key=>$val) { //Sum colors
   $tmp = explode("-", $key); //Extract from R-G-B notation
   $color["r"] += $tmp[0]; //Red
   $color["g"] += $tmp[1]; //Green
   $color["b"] += $tmp[2]; //Blue 
  }
 
 
  $color["r"] = $color["r"]/$this->samplingAvg;
  $color["g"] = $color["g"]/$this->samplingAvg;
  $color["b"] = $color["b"]/$this->samplingAvg;
  $color["rgb"] = dechex($color["r"]).dechex($color["g"]).dechex($color["b"]);
 
  return $color;
 }
 
 function get() {
  return $this->avgColor();
 }
 
}
?>
 
/************/
<?php
/********************************************************************************
*/
function _st() { 
 $mtime = explode(" ", microtime()); 
 return $mtime[1] + $mtime[0];
}
 
function _et($_st) {
   $mtime = explode(" ",microtime()); 
   $execT = (($mtime[1] + $mtime[0]) - $_st);
   echo "\n\n".str_repeat("-", 40)."\nExec time: ".(($execT<1)?($execT*1000)."ms":$execT."s")."\n\n"; 
}
/********************************************************************************
*/
 
 error_reporting(E_ALL);
 ini_set('display_errors', '1');
 
 require_once("sim.class.php");
 $_sim = new avgColor("imgs/647636.jpg");
 
 $_st=_st();
 var_dump($_sim->get());
 _et($_st);
?>
[PHP] pobierz, plaintext 

I obrazek 12Mpx robi w 15ms. Pokaż obrazek abyśmy testowali na tym samym

[Quadina]

Przygotuje paczkę jak wrócę do domu, teraz wychodzę akurat z roboty ;-) Może odezwij się do mnie na GG to spokojnie przedyskutujemy sprawę optymalizacji - ja strasznie lubię takie tematy ;-)

[Crozin]

Hmmm... Imagick::getImageHistogram()?

[kiler129]

Hmmm... Imagick::getImageHistogram()?

Brak dokumentacji oraz niedostępność imagemagic na sporej ilości serwerów raczej ją dyskwalifikuje

@Quadina - napisz na moje gg: 6388911 [niewidok]

[Quadina]

Histogram Imagicka jest wolny, dla mojego zdjęcia tego 100x100 generował całą sekundę dalej nie sprawdzałem, bo się przeraziłem użyciem pamięci. Przy czym mój skrypt użył 1/10 z tego, więc używanie magicka chyba nie jest optymalne. Po za tym link do bardzo dobrej dokumentacji funkcji, ale w pierwszym przykładzie widzę pewien błąd ;-) Bez urazy, ale lista posortowanych pixeli nas raczej nie interesuje, bo to jesteśmy sobie w stanie zrobić sami - patrząc po czasach nawet znacznie szybciej.

[Crozin]

Brak dokumentacji oraz niedostępność imagemagic na sporej ilości serwerów raczej ją dyskwalifikuje

Dokumentacji szukaj na stronach samego ImageMagicka (w końcu te PHPowe obiekty to tylko interfejs dla zewnętrznego programu). Co do dostępności - niedostępny będzie na większości serwerów współdzielonych, czyli takich na których za używanie powyższych skryptów za po krótkim okresie czasu konto zostanie zawieszone.

Histogram Imagicka jest wolny, dla mojego zdjęcia tego 100x100 generował całą sekundę dalej nie sprawdzałem

JPEG, 1152x864, 218 KiB - około 0.1 sekundy.

[Quadina]

Spoko, sprawdzimy wszystko, sprawdzimy ;-) Własnie instalujemy środowisko testowe, żeby sprawdzić wszystko na większych paczkach danych.

[kiler129]

/** JESLI SZUKASZ ROZWIAZANIA UZYJ KODU Z KONCA TEGO POSTU **/

Problem (chyba) rozwiązany.
Godzinę wikipedii później i pisania na stackoverflow mam taki oto kod:

[PHP] pobierz, plaintext 
<?php
function showColor($c1, $c2, $c3) {
 $hex = rgb2hex($c1,$c2,$c3);
 echo '<div style="background-color:#'.$hex.'; height:30px; display:inline;">'.str_repeat(" ", 25).'</div> <b>#'.$hex.'</b> (<b><font color="red">R:</font></b> '.$c1.' | <b><font color="green">G:</font></b> '.$c2.' | <b><font color="blue">B:</font></b> '.$c3.')<br><br>'; 
}
 
function rgb2hex($r,$g,$b) {
 $colArr=array("r"=>$r,"g"=>$g,"b"=>$b);
 return (($colArr["r"]<16)?"0".dechex($colArr["r"]):dechex($colArr["r"])).(($colArr["g"]<16)?"0".dechex($colArr["g"]):dechex($colArr["g"])).(($colArr["b"]<16)?"0".dechex($colArr["b"]):dechex($colArr["b"]));
}
 
function rgb2lab($r,$g,$b) {
 $rgb = array($r,$g,$b);
 $eps = 216/24389; $k = 24389/27; 
 $xr = 0.964221; $yr = 1.0; $zr = 0.825211;
 $rgb[0] = $rgb[0]/255;
 $rgb[1] = $rgb[1]/255; 
 $rgb[2] = $rgb[2]/255; 
 $rgb[0] = ($rgb[0] <= 0.04045)?($rgb[0]/12.92):pow(($rgb[0]+0.055)/1.055,2.4); 
 $rgb[1] = ($rgb[1] <= 0.04045)?($rgb[1]/12.92):pow(($rgb[1]+0.055)/1.055,2.4); 
 $rgb[2] = ($rgb[2] <= 0.04045)?($rgb[2]/12.92):pow(($rgb[2]+0.055)/1.055,2.4); 
 $x =  0.4360747*$rgb[0] + 0.3850649*$rgb[1] + 0.1430804 *$rgb[2]; 
 $y =  0.2225045*$rgb[0] + 0.7168786*$rgb[1] + 0.0606169 *$rgb[2]; 
 $z =  0.0139322*$rgb[0] + 0.0971045*$rgb[1] + 0.7141733 *$rgb[2]; 
 $xr = $x/$xr; $yr = $y/$yr; $zr = $z/$zr; 
 $fx = ($xr > $eps)?pow($xr, 1/3):($fx = ($k * $xr + 16) / 116); 
 $fy = ($yr > $eps)?pow($yr, 1/3):($fy = ($k * $yr + 16) / 116); 
 $fz = ($zr > $eps)?pow($zr, 1/3):($fz = ($k * $zr + 16) / 116); 
 $lab = array(); 
 $lab[] = round(( 116 * $fy ) - 16); 
 $lab[] = round(500*($fx-$fy)); 
 $lab[] = round(200*($fy-$fz));      
 return $lab; 
} 
 
function deltaE($lab1, $lab2) {
 $l = 1; $c = 1; 
 $c1 = sqrt($lab1[1]*$lab1[1]+$lab1[2]*$lab1[2]); 
 $c2 = sqrt($lab2[1]*$lab2[1]+$lab2[2]*$lab2[2]); 
 $h1 = (((180000000/M_PI)*atan2($lab1[1],$lab1[2])+360000000)%360000000)/1000000; 
 $t = (164<=$h1 AND $h1<=345)?(0.56+abs(0.2*cos($h1+168))):(0.36+abs(0.4*cos($h1+35))); 
 $f = sqrt(pow($c1,4)/(pow($c1,4)+1900)); 
 $sl = ($lab1[0]<16)?(0.511):((0.040975*$lab1[0])/(1+0.01765*$lab1[0])); 
 $sc = (0.0638*$c1)/(1+0.0131*$c1)+0.638; 
 $sh = $sc*($f*$t+1-$f); 
 return sqrt(pow(($lab1[0]-$lab2[0])/($l*$sl),2)+pow(($c1-$c2)/($c*$sc),2)+pow(sqrt(($lab1[1]-$lab2[1])*($lab1[1]-$lab2[1])+($lab1[2]-$lab2[2])*($lab1[2]-$lab2[2])+($c1-$c2)*($c1-$c2))/$sh,2)); 
} 
 
$c1 = array(30,255,123);
$c2 = array(55,250,100);
 
showColor($c1[0], $c1[1], $c1[2]);
showColor($c2[0], $c2[1], $c2[2]);
 
$cl1 = rgb2lab($c1[0], $c1[1], $c1[2]);
$cl2 = rgb2lab($c2[0], $c2[1], $c2[2]);
 
echo "<pre>";
var_dump(deltaE($cl1, $cl2));
?>
[PHP] pobierz, plaintext 

Obliczy różnicę między dwoma kolorami w przestrzeni L A B - inaczej się ponoć tego dobrze nie da zrobić. Teraz tylko spiąć to z kolorami pixeli zdjęć i gotowe.

Edit
Post jest za dlugi bla bla bla: http://wklej.org/id/438798/ - poddaje sie

Edit
Ok, udało się porównać kolory, dodanie tego do fotek to już nie problem.
Kod klasy:

[PHP] pobierz, plaintext 
<?php
class compareColors {
 var $tolerance = 3; //tolerance in %
 
 private function hex2rgb($hex) { //Convert from #FFFFFF to array(0,0,0) in eg.
  $hex = str_replace('#', '', $hex); //Remove #
  if(strlen($hex) != 6){ return array(0,0,0); }
  return array(
   hexdec(substr($hex, 0, 2)),
   hexdec(substr($hex, 2, 2)),
   hexdec(substr($hex, 4, 2))
  );
 }
 
 
 private function rgb2cmyk($rgb) { //Simple conversion from RGB namespace to CMYK namespace. (warning! colors can look diff btw rgb and cmyk, its ok for comparing but not for real conversion!)
  $K = min(array("r"=>(1-$rgb[0]), "g"=>(1-$rgb[1]), "b"=>(1-$rgb[2])));  
  $C = @((1-$rgb[0]-$K)/(1-$K));
  $M = @((1-$rgb[1]-$K)/(1-$K));
  $Y = @((1-$rgb[2]-$K)/(1-$K));
 
  return(array("C"=>$C, "M"=>$M, "Y"=>$Y, "K"=>$K));
 }
 
 
 function compareCMYKColors($cmyk1, $cmyk2, $returnScale=false) { //Compare 2 CMYK colors with given tolerance, it also can return "tolerane" of matching instead of bool
  $tolerance = ($this->tolerance/100); //Convert from % to float
  $diff=array();
  $diff[] = abs($cmyk1["C"]-$cmyk2["C"]);
  $diff[] = abs($cmyk1["M"]-$cmyk2["M"]);
  $diff[] = abs($cmyk1["Y"]-$cmyk2["Y"]);
  asort($diff);
  reset($diff);
  $max1 = each($diff);
  $max2 = each($diff);
 
  if($returnScale) return ((($max1+$max2)/2)*100); //Convert scale to %
  return ($max1["value"]<=$tolerance&&$max2["value"]<=$tolerance) ? true:false;  
 }
 
 
 function compareRGBColors($rgb1, $rgb2, $returnScale=false) { //Alias to above but converts from RGB to CMYK first
   return $this->compareCMYKColors($this->rgb2cmyk($rgb1), $this->rgb2cmyk($rgb2), $returnScale);
 } 
 
 
 function compareHEXColors($hex1, $hex2, $returnScale=false) { //Alias to above
   return $this->compareRGBColors($this->hex2rgb($hex1), $this->hex2rgb($hex2), $returnScale);
 }
 
 function bathCompare($base, $colors, $format="hex") {
  $out=array();
  if($format=="hex") { foreach($colors as $color) { if($this->compareHEXColors($base, $color)) $out[] = $color; } return $out; }
  if($format=="rgb") { foreach($colors as $color) { if($this->compareRGBColors($base, $color)) $out[] = $color; } return $out; }
  if($format=="cmyk") { foreach($colors as $color) { if($this->compareCMYKColors($base, $color)) $out[] = $color; } return $out; }
 
  return false;
 }
 
}
?>
[PHP] pobierz, plaintext 

Kod testowy [+ dane testowe]: http://wklej.org/id/439719/

Ten post edytował kiler129 17.12.2010, 16:34:02