(0.5 + number) | 0
 

 
<?php
 
require_once 'colorjizz.php';
 
class CMYTest extends PHPUnit_Framework_TestCase
{
    const DELTA = 0.002;
 
 
    public function testToHexAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toHex()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
    public function testToRGBAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toRGB()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
    public function testToXYZAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toXYZ()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
 
    public function testToCMYKAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toCMYK()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
    public function testToYxyAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toYxy()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
    public function testToCIELabAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toCIELab()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
    public function testToCIELChAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toCIELCh()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
 
    public function testToHSVAndBack()
    {
      for ($c=0; $c<=1; $c+=0.05)
      {
        for ($m=0; $m<=1; $m+=0.05)
        {
          for ($y=0; $y<=1; $y+=0.05)
          {
            $cmy = CMY::create($c, $m, $y)->toHSV()->toCMY();
            $this->assertEquals($c, $cmy->c, null, self::DELTA);
            $this->assertEquals($m, $cmy->m, null, self::DELTA);
            $this->assertEquals($y, $cmy->y, null, self::DELTA);
          }
        }
      }
    }
}
 
?>
 

public function testToHexAndBack()
{
	$cmy = CMY::create($c, $m, $y)->toHex()->toCMY();
	$this->assertEquals($c, $cmy->c, null, self::DELTA);
	$this->assertEquals($m, $cmy->m, null, self::DELTA);
	$this->assertEquals($y, $cmy->y, null, self::DELTA);
}

function testRoundingStuff()
{
	for ($c=0; $c<=1; $c+=0.05)
	{
		for ($m=0; $m<=1; $m+=0.05)
		{
			for ($y=0; $y<=1; $y+=0.05)
			{
				testToHexAndBack($c,$m,$y);
				testToRGBAndBack($c,$m,$y);
				// etc
			}
		}
	}
}

CMYK is a bugger to unit test.

$cmyk = new CMYK(0.05, 0.05, 0.05, 0);
$rgb = $cmyk->toRGB()

rgb gives: 242, 242, 242

$rgb->toCMYK() gives 0, 0, 0, 0.05

Pretty much every other implementation of this online seems to do the same, although with photoshop:

CMYK (%): 5, 5, 5, 0

gives:

RGB: 239, 236, 234

and CMYK (%): 0, 0, 0, 5

gives RGB: 241, 242, 242

Grr.

I really shouldn't have got involved in colours considering I hate them.

Might make it so that everything is forced to go through a greyscale function before it's outputted.

What about his PB?

(Welcome to '99)

\o/

I read a summary thing that one of my lecturers wrote about my assessments in a CAD class at college. He had written "you're drawings have continued to improve". He also continually goes on about what he's going to learn us, telling us that we've already drew something so it'll be easy. Amongst other cringe inducing phrases. A fucking /lecturer/. (fail)

                                                
                                                
                                                
                           ▪                    
             ┌────┐    ┌────┐                      
          │    │    │    │ ▪                    
          │    └────┘    │                      
          │   ──┐  ┌──   │ ▪                    
   ┌──────┤    ▪    ▪    │                      
  ┌┘      │              │ ▪                    
┌─┤       └──┐  │  │  ┌──┘                      
│ │          │ ││  ││ │   ┌─┐                   
│ │          └─┼┤  └┴─┴───┘ │                   
│ │           ─┘│           │                   
│ │   ┌──────┐  └┬──────────┘                   
  │   │      │   │                              
  │   │      │   │                              
  └───┘      └───┘                              

 
use MischiefCollective\ColorJizz\Formats\Hex;
 
// im not sure why you'd ever want to do this
echo Hex::fromString('CC0000')->toCIELab()->toHSV()->toRGB()->toHex()->toString(); // CC0000
 
// or..
use MischiefCollective\ColorJizz\Formats\CIELab;
echo CIELab::create(53, 80, 69)->toHex()->toString(); // FE0000
 

 
 
class CMY {
  function toRGB() {
   return $this->toCMY()->toCMYK();
 }
 
}
 
class RGB {
  function toCMYK() {
    return $this->toCMY()->toRGB();
  }
}
 

Hmm.

Slowly started moving it over to namespaced PHP5.3 with some unit tests and whatnot.

https://github.com/mikeemoo/ColorJizz-PHP

Still a long way to do, and a whole load of comments to add!

It's not very extendable the way it is, though. Thinking of restructuring it so it's got more of a plugin-style system going on.

Your extensibility looks fine, I wouldn't bother trying to make a plug-in style system, it'll just turn into a hideous mess of over-complicated checks involving method_exists and depending on how you do it, file_exists too, all of which will only slow it down.

The only thing I might do is make the arguments to your class methods all objects so you can type hint them and thus enforce them to be something more robust than PHP's crappy loose typing.

If you want to make it really easy to extend, and as you're targeting PHP 5.3, (you'll know this already of course) just make sure you're using the 'static' keyword when calling static functions and not self so they too can be overloaded / inherited. Also put things into suitably small chunks in properly scoped methods and well, that's about it.