C++ TLFImage类代码示例

/*
     Функция:
        CFSaveToDIB
     Цель:
         Сохраняет изображение в формате DIB
     Параметры:
       [ in ] hImage  - дескриптор изображения
       [ out ] info   - указатель на заголовок DIB
       [ out ] DIBPixels - указатель на пиксели изображения
     Возвращаемые заначения:
     CF_SUCCESS - данные изображения успешно записаны в память.
     в противном случае возвращает код ошибки.
     Замечания:
     Функция всегда записывает любое изображение hImage в формате
     DIB, который имеет глубину цвета 3 байта
*/
CF_ERROR __EXPORT_TYPE CFSaveToDIB( CF_IMAGE hImage, CF_BMP* info, BYTE* DIBPixels )
{
    CF_ERROR status = CF_SUCCESS;
     if(info == NULL)
    {
        status = CFF_INVALID_DIB;
        return status;
    }

	TLFImage* image = (TLFImage*)hImage;
    if(image == NULL)
    {
        status = CFF_INVALID_HANDLE;
		return status;
    }
    BITMAPINFO lInfo;
    memcpy( &lInfo, info, sizeof( BITMAPINFO ) );
    bool flag = DIBPixels == NULL? false : true;
    if(awpImageToDIB( image->GetImage(), &lInfo, (void**)(&DIBPixels), flag )!=AWP_OK)
	{
        status = CFF_INVALID_DIB;
        return status;
    }
    memcpy( info, &lInfo, sizeof( BITMAPINFO ) );  
    return status;
}

CF_ERROR __EXPORT_TYPE CFGetImageParams(CF_IMAGE hImage, CF_IMAGE_PARAMS* pParams)
{
	CF_ERROR status = CF_SUCCESS;
	// проверим входные параметры
	if (pParams == NULL)
	{
		return CFF_INVALID_PARAM;
	}
	TLFImage* image = (TLFImage*)hImage;
	if(image == NULL)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	awpImage* pImage = NULL;
	pImage = image->GetImage();
	if (awpCheckImage(pImage) != AWP_OK)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	pParams->width = pImage->sSizeX;
	pParams->height = pImage->sSizeY;
	switch(pImage->bChannels)
	{
		case 1:
			pParams->bpp = 8;
		break;
		case 3:
			pParams->bpp = 24;
		break;
	}
	return status;
}

// запись растрового изображения в неструктурированную память
CF_ERROR __EXPORT_TYPE CFSaveToDump(CF_IMAGE hImage, CF_WORD* pWidth, CF_WORD* pHeight, CF_WORD* pBpp, CF_BYTE* buffer)
{
	CF_ERROR status = CF_SUCCESS;
	// проверим входные параметры дескриптора изображения
	TLFImage* image = (TLFImage*)hImage;
	if(image == NULL)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	awpImage* pImage = NULL;
	pImage = image->GetImage();
	if (awpCheckImage(pImage) != AWP_OK)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	// проверим возможность конвертации изображения 

    //проверим остальные параметры
	if (pWidth == NULL || pHeight == NULL || pBpp == NULL || buffer == NULL)
	{
		return CFF_INVALID_PARAM;
	}
	// выполним копирование
	*pWidth = pImage->sSizeX;
	*pHeight= pImage->sSizeY;
	*pBpp   = 8*pImage->bChannels;
	int bufsize = pImage->sSizeX*pImage->sSizeY*pImage->bChannels;
	CF_BYTE* b = (CF_BYTE*)pImage->pPixels;
	memcpy(buffer, b, bufsize);
	return status;
}

//-------------------------------TLFEmptyAverageNNPredictor----------------------
TLFDblVector* TLFEmptyAverageNNPredictor::Features(ILFDetectEngine* engine, TLFRect* rect, int id)
{
	if (engine == NULL || rect == NULL)
		return NULL;
	ILFObjectDetector* d = engine->GetDetector(0);
	if (d == NULL)
		return NULL;
	TLFImage* img = d->GetImage();
	if (img == NULL)
		return NULL;
	TLFDblVector* data = new TLFDblVector(id);
	double w = (double)rect->Width() / 8;
	double h = (double)rect->Height() /8;
	double s = w*h;
	for (int y = 0; y < 8; y++)
	{
		int yy = (int)floor(rect->Top() + y*w + 0.5);
		for (int x = 0; x < 8 ; x++)
		{
			int xx = (int)floor(rect->Left() + x*w + 0.5);
			double value = img->CalcLnSum(xx, yy, (int)w, (int)h)/s;
			data->AddValue(value);
		}
	}
	return data;
}

/*
    CFLoadFromDIB
	loads image from Windows DIB 
*/
CF_ERROR __EXPORT_TYPE CFLoadFromDIB( CF_IMAGE hImage, CF_BMP info, BYTE* DIBPixels )
{
    CF_ERROR status = CF_SUCCESS;
    TLFImage* image = (TLFImage*)hImage;
    if(image == NULL)
    {
        status = CFF_INVALID_HANDLE;
        return status;
    }
	awpImage* img = NULL;
    BITMAPINFO lInfo;
    memcpy( &lInfo, &info, sizeof(CF_BMP) );
    if( awpDIBToImage(&lInfo, DIBPixels, &img)!= AWP_OK )
    {
        status = CFF_INVALID_DIB;
        return status;
    }
    try
    {
        image->SetImage( img );
    }
    catch (...)
    {
        status = CFCR_NOT_ENOUGH_MEMORY;
        awpReleaseImage(&img);
        return status;
    }
    awpReleaseImage(&img);
    return status;
}

/*
     Функция:
        CFDIBSize
     Цель:
         Возвращает размер буфера, необходимый для сохранения
         изображения в формате DIB
     Параметры:
       [ in ] hImage  - дескриптор изображения
       [ out ] pSize  - указатель на переменную, в которой будет сохранено
                        значение размера буфера.
     Возвращаемые заначения:
     CF_SUCCESS - Переменная pSize cодержит значение размера буфера
     в противном случае возвращает код ошибки.
*/
CF_ERROR __EXPORT_TYPE CFDIBSize(CF_IMAGE hImage, int* pSize)
{
    CF_ERROR status = CF_SUCCESS;
    // проверим входные параметры
    if (pSize == NULL)
    {
        return CFF_INVALID_PARAM;
    }
    TLFImage* image = (TLFImage*)hImage;
    if(image == NULL)
    {
        status = CFF_INVALID_HANDLE;
        *pSize = 0;
		return status;
	}
	*pSize = 0;
	awpImage* pImage = NULL;
	pImage = image->GetImage();
	if (awpCheckImage(pImage) != AWP_OK)
	{
		status = CFF_INVALID_HANDLE;
		*pSize = 0;
		return status;
	}
	int dib_width = ((pImage->sSizeX*24 + 31)/32) * 4; /* aligned to 4 bytes */
	*pSize = dib_width*pImage->sSizeY;
	return status;
}

TLFRect* TLFMomentsPredictor::Predict(ILFDetectEngine* engine)
{
 	TLFFGEngine* e = dynamic_cast<TLFFGEngine*>(engine);
	if (e == NULL)
		return NULL;
	if (m_pPredicted != NULL)
	{
		delete m_pPredicted;
		m_pPredicted = NULL;
	}
	TLFImage* fg = e->GetForegroundImage();
	if (fg != NULL)
	{
	   SLFBinaryMoments m;
	   TLFThresholdProc* proc = e->GetThresholdProc();
	   if (e != NULL)
	   {
			TLFRect r;
			r.SetRect(m_rect.GetRect());
			r.Inflate(2,2);
			proc->ProcessMoments(r, m);
			if (m.area > 0)
			{
				awpRect o_rect;
				o_rect.left = (AWPSHORT)GetMinMomnetsX(m); if (o_rect.left < 0)  o_rect.left = 0; 
				o_rect.top = (AWPSHORT)GetMinMomnetsY(m);  if (o_rect.top < 0) o_rect.top = 0;
				o_rect.right = (AWPSHORT)GetMaxMomnetsX(m); if (o_rect.right >= fg->GetImage()->sSizeX) o_rect.right = fg->GetImage()->sSizeX - 1;
				o_rect.bottom = (AWPSHORT)GetMaxMomnetsY(m); if (o_rect.bottom >= fg->GetImage()->sSizeY) o_rect.bottom = fg->GetImage()->sSizeY - 1;
				double w  = o_rect.right - o_rect.left;
				double h  = o_rect.bottom - o_rect.top;
				double s = (o_rect.right - o_rect.left)*(o_rect.bottom - o_rect.top);
				double s1 = fg->GetImage()->sSizeX*fg->GetImage()->sSizeY;
   				if (m.area/s > 0)
				{

					TLFRect* r_result = new TLFRect();
					r_result->SetRect(o_rect);
					r_result->Inflate(2,2);
					m_pPredicted = r_result;
					m_rect.SetRect(r_result->GetRect());
					return r_result;

				}
				else
		  			return NULL;
			}
			else
				return NULL;
	   }
	   else
		return NULL;
	}
	else
		return NULL;
}

/*
    Функция:
        CFSaveImage
    Цель:
        Сохраняет изображение в формате jpeg на диске
    Параметры:
        [in] hImage - дескриптор изображения
        [in] path   - полное имя файла для записи.
    Возвращаемые заначения:
		CF_SUCCESS - в случае упешной записи файла.
        в противном случае возвращает код ошибки.
*/
CF_ERROR __EXPORT_TYPE CFSaveImage( CF_IMAGE hImage, char* path )
{
    CF_ERROR status = CF_SUCCESS;
    TLFImage* image = (TLFImage*)hImage;
    if(image == NULL)
    {
        status = CFF_INVALID_HANDLE;
        return status;
    }
	if(!image->SaveImage( path ))
    {
        status = CFF_CANNOT_SAVE_IMAGE;
        return status;
    }  
    return status;
}

TLFDescriptor* TLFAverageNNTracker::Features(ILFDetectEngine* engine, TLFRect* rect, int id)
{
	if (engine == NULL || rect == NULL)
		return NULL;
	TSCObjectDetector* d = dynamic_cast<TSCObjectDetector*>(engine->GetDetector(0));
	if (d == NULL)
		return NULL;
	TLFImage* img = d->GetImage();
	if (img == NULL || img->GetImage() == NULL)
		return NULL;

	//
	int idx = d->GetStagesCount() - 1;
	TLFObjectList* stages = d->GetStrongs();

	TCSStrong* s = dynamic_cast<TCSStrong*>(stages->Get(idx));
	if (s == NULL)
		return NULL;
	double* data = (double*)malloc(s->GetCount()*sizeof(double));
	int width = rect->Width();
	double scale_coef = (double)width / (double)d->GetBaseWidth();
	TLFRect fragment;

	for (int i = 0; i < s->GetCount(); i++)
	{
		ILFWeak  * weak = s->GetWeak(i);
		if (weak != NULL)
		{
			TCSSensor* sensor = dynamic_cast<TCSSensor*>(weak->Fetaure());
			awpRect Fragment = sensor->GetRect();

			fragment.SetRect(Fragment);
			fragment.Scale(scale_coef);
			fragment.Shift(rect->Left(), rect->Top());

			Fragment = fragment.GetRect();
			double s = fragment.Width()*fragment.Height();
			double value = img->CalcLnSum(Fragment.left, Fragment.top, fragment.Width(), fragment.Height());
			value /= s;
			data[i] = value;

		}
	}
	TLFDescriptor* dscr = new TLFDescriptor(s->GetCount(), id, data);
	free(data);
	return dscr;
}

/*
	CFLoadImage
	Load image from path 
*/
CF_ERROR __EXPORT_TYPE CFLoadImage( CF_IMAGE hImage, char* path )
{
    CF_ERROR status = CF_SUCCESS;
    // преобразование типов.
    TLFImage* image = (TLFImage*)hImage;
    if(image == NULL)
    {
        status = CFF_INVALID_HANDLE;
        return status;
    }

    if(!image->LoadImage( path ))
    {
        status = CFF_CANNOT_LOAD_IMAGE;
        return status;
    }    
	return status;
}

bool TLFSabotage::PorocessImage(awpImage* img, bool* result)
{
	*result = false;
	if (img == NULL)
		return false;
	// преобразования. 
	awpImage* tmp = NULL;
	// копируем входное изображение во временное. 
	if (awpCopyImage(img, &tmp) != AWP_OK)
		return false;
	if (tmp->sSizeX != this->m_srcWidth || tmp->sSizeY != this->m_srcHeight || tmp->bChannels != this->m_srcBPP)
	{
		// переинициализация
		TLFImage initImage;
		initImage.SetImage(img);
		this->Init(&initImage);
		_AWP_SAFE_RELEASE_(tmp)
		return true;
	}

// загрузака растрового изображения из неструктуированной памяти. 
CF_ERROR __EXPORT_TYPE CFLoadFromDump(CF_IMAGE hImage, CF_WORD width, CF_WORD height, CF_WORD bpp, CF_BYTE* pixels,  CF_WORD line_width)
{
	CF_ERROR status = CF_SUCCESS;
    // получение указателя на изображение
	TLFImage* image = (TLFImage*)hImage;
	if(image == NULL)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	// проверка указателя на пиксели
	if (pixels == NULL)
	{
		status = CFF_INVALID_PARAM;
		return status;
	}
	// проверка числа битов на пиксель
	if (bpp != 8 && bpp != 24)
	{
		status = CFF_INVALID_PARAM;
		return status;
	}
	awpImage* tmp = NULL;
	if (awpCreateImage(&tmp, width, height, bpp == 8?1:3, AWP_BYTE) != AWP_OK)
	{
	   status = CFCR_NOT_ENOUGH_MEMORY;
	   return status;
	}
	// копирование пикселей в изображение tmp
	int bufsize = width*(bpp == 8 ? 1:3);// число байт в строке, с возможным выравниваием
	BYTE* b = (BYTE*)tmp->pPixels;
	for (int i = 0; i < height; i++)
	{
		memcpy(b, pixels, bufsize);
		b+= bufsize; 
		pixels += line_width;
	}
	image->SetImage(tmp);
	awpReleaseImage(&tmp);
	return status;
}

bool CLBPTrackCompare::LoadCheckTrack(const char* lpFileName)
{
    bool res = CNCCPTrackCompare::LoadCheckTrack(lpFileName);
    this->m_checklbp.Clear();
    if (res)
    {
        for (int i = 0; i < this->m_pcheck->GetNumImages(); i++)
        {
            awpImage* img = this->m_pcheck->GetImage(i);
            awpImage* dscr = NULL;
            int descrSize = 59;
            int imgHeight = 16;
            awpCreateImage(&dscr, descrSize, imgHeight, 1, AWP_DOUBLE);
            awpLBPGridDescriptor(img, dscr, NULL, 4, 4, AWP_LBP_U2R1, true, 1);
            TLFImage* lfimg = new TLFImage();
            lfimg->SetImage(dscr);
            this->m_checklbp.Add(lfimg);
        }
    }
    return res;
}

CF_ERROR __EXPORT_TYPE CFGetDumpSize(CF_IMAGE hImage, CF_DWORD* pDumpSize)
{
	CF_ERROR status = CF_SUCCESS;
	TLFImage* image = (TLFImage*)hImage;
	if(image == NULL)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	awpImage* pImage = NULL;
	pImage = image->GetImage();
	if (awpCheckImage(pImage) != AWP_OK)
	{
		status = CFF_INVALID_HANDLE;
		return status;
	}
	if (pDumpSize == NULL)
		return CFF_INVALID_PARAM;
	//todo: здесь мы предполагаем, что изображения могут быть либо 
	//полутоновыми, либо цветными, пиксели содержат только 1 байт на цвет
	*pDumpSize = pImage->sSizeX*pImage->sSizeY*(pImage->bChannels == 1?1:3);
	return status;
}

void TLFDBLabeledImages::GetFarFrr(TLFDetectEngine& engine, double& Far, double& Frr, double overlap)
{
	Far = 0;
	Frr = 0;
	if (GetItemsCount() == 0)
		return;

	for (int i = 0; i < m_dataFiles.GetCount(); i++)
	{ 
		TLFDBSementicDescriptor* d = (TLFDBSementicDescriptor*)m_dataFiles.Get(i);
		string strImageName = d->GetImageFile();
		TLFImage img;
		img.LoadImage(strImageName.c_str());
		engine.SetSourceImage(&img, true);
		TLFSemanticImageDescriptor* d1 = engine.GetSemantic();
		Far += d1->Compare(d, overlap);
		Frr += d->Compare(d1, overlap);
		if (i % 100 == 0)
			printf(">");
	}
	printf("\n");
	Far /= GetItemsCount();
	Frr /= GetItemsCount();
}