COLORREF CPaletteLinear::Color(_double v)
{
color_map::iterator it;
triplet q;
assert(items.size());
//
it = (items.size() > 1) ? items.lower_bound(v) : items.begin();
if (it == items.begin())
{
q = items.begin()->second;
}
else
if (it == items.end())
{
q = it->second;
}
else
{
_double v1 = it->first;
triplet & more = it->second; it--;
_double v0 = it->first;
triplet & less = it->second;
_double f = (v - v0)/(v1 - v0);
q.a = less.a + f * (more.a - less.a);
q.b = less.b + f * (more.b - less.b);
q.c = less.c + f * (more.c - less.c);
}
return hsv ? FromHSV(q.a,q.b,q.c) : FromRGB(q.a,q.b,q.c);
}
static void CombineChannels( GenericImage<P>& img, int colorSpace, const String& baseId,
const Rect& r,
const GenericImage<P0>* src0, const GenericImage<P1>* src1, const GenericImage<P2>* src2 )
{
bool allChannels = src0 != 0 && src1 != 0 && src2 != 0;
typename P::sample* R = img.PixelData( 0 );
typename P::sample* G = img.PixelData( 1 );
typename P::sample* B = img.PixelData( 2 );
const RGBColorSystem& rgbws = img.RGBWorkingSpace();
for ( int y = r.y0; y < r.y1; ++y )
{
const typename P0::sample* data0 = (src0 != 0) ? src0->PixelAddress( r.x0, y ) : 0;
const typename P1::sample* data1 = (src1 != 0) ? src1->PixelAddress( r.x0, y ) : 0;
const typename P2::sample* data2 = (src2 != 0) ? src2->PixelAddress( r.x0, y ) : 0;
for ( int x = r.x0; x < r.x1; ++x, ++img.Status() )
{
if ( colorSpace == ColorSpaceId::RGB )
{
if ( data0 != 0 )
P0::FromSample( *R++, *data0++ );
if ( data1 != 0 )
P1::FromSample( *G++, *data1++ );
if ( data2 != 0 )
P2::FromSample( *B++, *data2++ );
}
else
{
RGBColorSystem::sample ch0, ch1, ch2;
RGBColorSystem::sample r, g, b;
if ( !allChannels )
{
P::FromSample( r, *R );
P::FromSample( g, *G );
P::FromSample( b, *B );
FromRGB( colorSpace, rgbws, ch0, ch1, ch2, r, g, b );
}
if ( data0 != 0 )
P0::FromSample( ch0, *data0++ );
if ( data1 != 0 )
P1::FromSample( ch1, *data1++ );
if ( data2 != 0 )
P2::FromSample( ch2, *data2++ );
ToRGB( colorSpace, rgbws, r, g, b, ch0, ch1, ch2 );
*R++ = P::ToSample( r );
*G++ = P::ToSample( g );
*B++ = P::ToSample( b );
}
}
}
}
COLORREF CPaletteLinear::FromHSV(_double h, _double s, _double v)
{
uint n;
_double f;
_double vs, vsf;
if (s == 0) // gray
return FromRGB(v,v,v);
h *= 6;
n = floor(h);
f = h - n;
vs = v * s;
vsf = vs * f;
switch (n)
{
case 0: return FromRGB(v, v-vs+vsf, v-vs);
case 1: return FromRGB(v-vsf, v, v-vs);
case 2: return FromRGB(v-vs, v, v-vs+vsf);
case 3: return FromRGB(v-vs, v-vsf, v);
case 4: return FromRGB(v-vs+vsf,v-vs, v);
default: return FromRGB(v, v-vs, v-vsf);
}
}
void Color::FromHSV(float h, float s, float v) {
h = fmod(h, 360);
float chroma = v * s;
float hPrime = h / 60.0;
float X = chroma * (1.0 - fabs(fmod(hPrime, 2) - 1));
float r1, g1, b1;
if (0 <= hPrime && hPrime < 1) {
r1 = chroma;
g1 = X;
b1 = 0;
} else if (1 <= hPrime && hPrime < 2) {
r1 = X;
g1 = chroma;
b1 = 0;
} else if (2 <= hPrime && hPrime < 3) {
r1 = 0;
g1 = chroma;
b1 = X;
} else if (3 <= hPrime && hPrime < 4) {
r1 = 0;
g1 = X;
b1 = chroma;
} else if (4 <= hPrime && hPrime < 5) {
r1 = X;
g1 = 0;
b1 = chroma;
} else if (5 <= hPrime && hPrime < 6) {
r1 = chroma;
g1 = 0;
b1 = X;
}
float m = v - chroma;
FromRGB(255 * (r1 + m), 255 * (g1 + m), 255 * (b1 + m));
}
void Color::FromRGB(RGB newColor) {
FromRGB(newColor.r, newColor.g, newColor.b);
}
Color::Color(uint8_t r, uint8_t g, uint8_t b) {
FromRGB(r, g, b);
}
Color::Color(RGB newColor) {
FromRGB(newColor);
}
void* Run(void*)
{
int size = ivWidth*ivHeight;
// Initialize MultiObjectTLD
#if LOADCLASSIFIERATSTART
MultiObjectTLD p = MultiObjectTLD::loadClassifier((char*)CLASSIFIERFILENAME);
#else
MOTLDSettings settings(COLOR_MODE_RGB);
settings.useColor = false;
MultiObjectTLD p(ivWidth, ivHeight, settings);
#endif
Matrix maRed;
Matrix maGreen;
Matrix maBlue;
unsigned char img[size*3];
#ifdef FORCE_RESIZING
CvSize wsize = {ivWidth, ivHeight};
IplImage* frame = cvCreateImage(wsize, IPL_DEPTH_8U, 3);
#endif
while(!ivQuit)
{
/*
if(reset){
p = *(new MultiObjectTLD(ivWidth, ivHeight, COLOR_MODE_RGB));
reset = false;
}
if(load){
p = MultiObjectTLD::loadClassifier(CLASSIFIERFILENAME);
load = false;
}
*/
// Grab an image
if(!cvGrabFrame(capture)){
std::cout << "error grabbing frame" << std::endl;
break;
}
#ifdef FORCE_RESIZING
IplImage* capframe = cvRetrieveFrame(capture);
cvResize(capframe, frame);
#else
IplImage* frame = cvRetrieveFrame(capture);
#endif
for(int j = 0; j<size; j++){
img[j] = frame->imageData[j*3+2];
img[j+size] = frame->imageData[j*3+1];
img[j+2*size] = frame->imageData[j*3];
}
// Process it with motld
p.processFrame(img);
// Add new box
if(mouseMode == MOUSE_MODE_ADD_BOX){
p.addObject(mouseBox);
mouseMode = MOUSE_MODE_IDLE;
}
// Display result
HandleInput();
p.getDebugImage(img, maRed, maGreen, maBlue, drawMode);
FromRGB(maRed, maGreen, maBlue);
cvShowImage("MOCTLD", curImage);
p.enableLearning(learningEnabled);
if(save){
p.saveClassifier((char*)CLASSIFIERFILENAME);
save = false;
}
}
//delete[] img;
cvReleaseCapture(&capture);
return 0;
}
