/*!
pNodeを減算する。
@param[in] pNode
@param[in] lprc 更新範囲
*/
void ImgLayer::SubEditNode(EditNode *pNode, const LPRECT lprc)
{
if (!pNode) return;
RECT rc;
if (lprc) {
//更新範囲とコピー先範囲の論理積
AndRect(lprc, &(pNode->blt_rect), &rc);
}
else {
rc = pNode->blt_rect;
}
m_Img->ImgBlt(
rc.left - m_LayerRect.left,
rc.top - m_LayerRect.top,
rc.right - rc.left,
rc.bottom - rc.top,
&(pNode->undo_img),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
IPLEXT_RASTER_CODE::COPY_BY_BINARY_MASK,
&(pNode->write_map),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top);
}
bool E_ColorReverse::Init(ImgFile_Ptr pFile)
{
IImgLayer_weakPtr _sl = pFile->GetSelectLayer();
if (_sl.expired()) {
OutputError::Alert(IE_ERROR_SELECT_LAYER_DONT_EXIST);
return false;
}
IImgLayer_Ptr sl = _sl.lock();
if (sl->GetLayerType() != IE_LAYER_TYPE::NORMAL_LAYER) {
OutputError::Alert(IE_ERROR_CANT_EDIT_LAYER);
return false;
}
m_pEditLayer = std::dynamic_pointer_cast<ImgLayer>(sl);
RECT rect, mask_rect;
m_pEditLayer->GetLayerRect(&rect);
//マスクの範囲取得
if (pFile->GetMaskState() == IE_MASK_STATE_ID::INVALID) {
m_mask = NULL;
}
else {
pFile->GetMaskRect(&mask_rect);
//範囲を計算
AndRect(&rect, &mask_rect, &rect);
//マスク切り出し
IplImage* tmp_mask = cvCreateImage(
cvSize(rect.right - rect.left, rect.bottom - rect.top),
IPL_DEPTH_8U,
1);
pFile->CopyFileMask(
rect.left,
rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
tmp_mask,
0, 0);
m_mask = tmp_mask;
}
CvSize sizeOfImage;
sizeOfImage.width = rect.right - rect.left;
sizeOfImage.height = rect.bottom - rect.top;
m_pEditLayerHandle = (EditLayerHandle*)pFile->CreateImgFileHandle( IFH_EDIT_LAYER );
m_pEditLayerHandle->SetHandleName( DISPLAY_NAME );
pFile->DoImgFileHandle( m_pEditLayerHandle );
m_pEditNode = m_pEditLayerHandle->CreateEditNode(&rect);
m_pEditNode->blt_rect = rect;
return true;
}
EditNode* ImgLayer::CreateEditNode(const LPRECT lprc)
{
CvSize size = m_Img->GetSize();
EditNode* ret = new EditNode;
ret->edit_img.InitToEqualSize(m_Img, IPL_DEPTH_8U, 4);
ret->undo_img.InitToEqualSize(m_Img, IPL_DEPTH_8U, 4);
ret->write_map.InitToEqualSize(m_Img, IPL_DEPTH_8U, 1);
ret->node_rect = m_LayerRect;
ret->blt_rect = *lprc;
AndRect(&m_LayerRect, lprc, &(ret->blt_rect));
ret->fourcc = LayerSynthesizerMG::GetDefaultLayerSynthFourCC();
ret->isBakedWriteMap = false;
return ret;
}
/*!
pNodeを加算する。
@param[in] pNode
@param[in] lprc 更新範囲
*/
void ImgLayer::AddEditNode(EditNode *pNode, const LPRECT lprc)
{
if(!pNode) return;
RECT rc;
if (lprc) {
//更新範囲とコピー先範囲の論理積
AndRect(lprc, &(pNode->blt_rect), &rc);
}
else {
rc = pNode->blt_rect;
}
if (!pNode->isBakedWriteMap) {
//blt undo image
BltLayerUndoOp bltLayerUndoOp;
AllMaskOp allMaskOp;
pNode->undo_img.OperateBlt<BltLayerUndoOp, AllMaskOp>(
bltLayerUndoOp,
allMaskOp,
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
rc.right - rc.left,
rc.bottom - rc.top,
m_Img,
rc.left - m_LayerRect.left,
rc.top - m_LayerRect.top,
&(pNode->write_map),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top);
//write pixel mark
WritePixelMark writePixelMark;
NormMaskOp normMaskOp;
pNode->write_map.OperateBlt<WritePixelMark, NormMaskOp>(
writePixelMark,
normMaskOp,
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
rc.right - rc.left,
rc.bottom - rc.top,
NULL,
0,
0,
&(pNode->edit_img),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top);
}
//blt edit image
const IplImage* mask = NULL;
ImgFile_Ptr pParentFile = this->GetParentFile().lock();
if (pParentFile->GetMaskState() == IE_MASK_STATE_ID::VALID) {
mask = pParentFile->GetDrawMaskImg();
}
if (!m_IsLockPixelAlpha) {
LayerSynthesizerMG::BlendSynth<NormalCopy>(
pNode->fourcc,
1.0,
m_Img,
rc.left - m_LayerRect.left,
rc.top - m_LayerRect.top,
rc.right - rc.left,
rc.bottom - rc.top,
&(pNode->undo_img),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
&(pNode->edit_img),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
mask,
rc.left,
rc.top);
} else {
LayerSynthesizerMG::BlendSynth<AlphaLockCopy>(
pNode->fourcc,
1.0,
m_Img,
rc.left - m_LayerRect.left,
rc.top - m_LayerRect.top,
rc.right - rc.left,
rc.bottom - rc.top,
&(pNode->undo_img),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
&(pNode->edit_img),
rc.left - pNode->node_rect.left,
rc.top - pNode->node_rect.top,
mask,
rc.left,
rc.top);
}
}
bool ImgLayer::Update(const LPRECT enable_lprc, LPRECT updated_lprc)
{
if (m_pUpdateDataForeGrnd_List->empty()) {
return false;
}
UPDATE_DATA udLayer;
bool isLayerRect = false;
udLayer.isAll = false;
//更新情報の縮小化
ResourceLock( IE_LAYER_RESOURCE_ID::UPDATE_DATA_QUEUE );
LPUpdateData_List::iterator itr = m_pUpdateDataForeGrnd_List->begin();
for (; itr != m_pUpdateDataForeGrnd_List->end(); itr++) {
bool isAll = (*itr)->isAll;
switch ((*itr)->update_flag) {
case UPDATE_FLAG::UPDATE_LAYER_IMAGE:
if (isAll) {//全体更新
udLayer.isAll = isAll;
}
else if (udLayer.isAll == false) {//部分更新
if (isLayerRect == false) {//範囲の初期値がないなら
udLayer.rect = (*itr)->rect;
isLayerRect = true;
}
else {//範囲がすでに存在しているなら
OrRect(&((*itr)->rect), &(udLayer.rect), &(udLayer.rect));
}
}
break;
case UPDATE_FLAG::NO_UPDATE:
break;
default:
OutputError::PushLog( LOG_LEVEL::_WARN, "ImgLayer::Update() unknown update_flag");
break;
}
//最大範囲の更新だったら抜ける。
if ((*itr)->update_flag == UPDATE_FLAG::UPDATE_LAYER_IMAGE &&
isAll)
{
break;
}
}
ResourceUnlock( IE_LAYER_RESOURCE_ID::UPDATE_DATA_QUEUE );
if (udLayer.isAll) {
udLayer.rect = m_LayerRect;
isLayerRect = true;
}
if (enable_lprc) {
AndRect(&(udLayer.rect), enable_lprc, &(udLayer.rect));
}
//update
if (isLayerRect) {
UpdateEditNode(&udLayer.rect);
}
(*updated_lprc) = udLayer.rect;
return IImgLayer::Update(enable_lprc, updated_lprc);
}
bool LevelCorrection::Init(ImgEdit* pEdit)
{
m_is_gamma_dlg = false;
m_is_max_level_dlg = false;
m_is_min_level_dlg = false;
m_is_max_out_dlg = false;
m_is_min_out_dlg = false;
m_gamma = 0.5;
m_max_level = 255;
m_min_level = 0;
m_max_out_val = 255;
m_min_out_val = 0;
for(int i=0; i<4; i++){
m_histogram_img[i] = cvCreateImage(cvSize(LC_HISTOGRAM_W, LC_HISTOGRAM_H), IPL_DEPTH_8U, 3);
cvSet(m_histogram_img[i], cvScalar(255, 255, 255));
}
m_level_sld_img = cvCreateImage(cvSize(LC_LEVEL_SLD_W, LC_LEVEL_SLD_H), IPL_DEPTH_8U, 3);
m_output_sld_img = cvCreateImage(cvSize(LC_OUTPUT_SLD_W, LC_OUTPUT_SLD_H), IPL_DEPTH_8U, 3);
m_BGRA_LUT = cvCreateMat(1, 256, CV_8UC4);
m_pEditFile = pEdit->GetActiveFile();
if(!m_pEditFile) return false;
IImgLayer_weakPtr _sl = m_pEditFile->GetSelectLayer();
if (_sl.expired()) {
OutputError::Alert(IE_ERROR_SELECT_LAYER_DONT_EXIST);
return false;
}
IImgLayer_Ptr sl = _sl.lock();
if (sl->GetLayerType() != IE_LAYER_TYPE::NORMAL_LAYER) {
OutputError::Alert(IE_ERROR_CANT_EDIT_LAYER);
return false;
}
ImgLayer_Ptr l = std::dynamic_pointer_cast<ImgLayer>(sl);
//選択マスクの範囲を取得
bool is_invalid_mask = (m_pEditFile->GetMaskState() == IE_MASK_STATE_ID::INVALID);
if (is_invalid_mask) {
CvSize size = m_pEditFile->GetImgSize();
m_mask_rect.top = m_mask_rect.left = 0;
m_mask_rect.right = size.width;
m_mask_rect.bottom = size.height;
}
else {
m_pEditFile->GetMaskRect(&m_mask_rect);
}
RECT layer_rect;
l->GetLayerRect(&layer_rect);
//
AndRect(&m_mask_rect, &layer_rect, &m_mask_rect);
int width = m_mask_rect.right - m_mask_rect.left;
int height = m_mask_rect.bottom - m_mask_rect.top;
m_pEditLayerHandle = (EditLayerHandle*) m_pEditFile->CreateImgFileHandle( IFH_EDIT_LAYER );
m_pEditLayerHandle->SetHandleName( DISPLAY_NAME );
m_pEditFile->DoImgFileHandle( m_pEditLayerHandle );
m_pEditNode = m_pEditLayerHandle->CreateEditNode(&m_mask_rect);
//get undo image
l->CopyLayerImage(
&(m_pEditNode->undo_img),
0,
0,
m_mask_rect.left,
m_mask_rect.top,
m_mask_rect.right - m_mask_rect.left,
m_mask_rect.bottom - m_mask_rect.top);
//
if(is_invalid_mask){
CvSize size = m_pEditNode->edit_img.GetSize();
m_pEditNode->edit_img.RectFillAlpha(
0,
0,
size.width,
size.height,
255);
}
else{
m_pEditNode->edit_img.RectFillAlpha(
m_mask_rect.left,
m_mask_rect.top,
m_mask_rect.right - m_mask_rect.left,
m_mask_rect.bottom - m_mask_rect.top,
255,
NULL);
}
//create histogram img
int bin_w;
int hist_size = HISTOGRAM_MAX - HISTOGRAM_MIN;
float max_value = 0;
float range_0[] = { HISTOGRAM_MIN, HISTOGRAM_MAX };
float *ranges[] = { range_0 };
IplImage* ch_img[4];
for(int i=0; i<4; i++){
ch_img[i] = cvCreateImage(
cvSize(m_mask_rect.right - m_mask_rect.left, m_mask_rect.bottom - m_mask_rect.top),
IPL_DEPTH_8U,
1);
}
CvHistogram* ch_hist = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1);
m_pEditNode->undo_img.Split(
m_mask_rect.left, m_mask_rect.top,
m_mask_rect.right - m_mask_rect.left,
m_mask_rect.bottom - m_mask_rect.top,
ch_img[0], ch_img[1], ch_img[2], NULL);
for(int i=0; i<3; i++){
cvCalcHist(&(ch_img[i]), ch_hist, 0, NULL);
cvGetMinMaxHistValue(ch_hist, 0, &max_value, 0, 0);
cvScale (ch_hist->bins, ch_hist->bins, ((double) LC_HISTOGRAM_H) / max_value, 0);
bin_w = cvRound((double) LC_HISTOGRAM_W/hist_size);
for(int j=0; j<hist_size; j++){
cvRectangle(
m_histogram_img[i],
cvPoint(j*bin_w, m_histogram_img[i]->height),
cvPoint((j+1)*bin_w, m_histogram_img[i]->height - cvRound(cvGetReal1D(ch_hist->bins, j))),
cvScalar(0, 0, 0),
-1, 8, 0);
}
}
RebuildLevelDlg();
RebuildOutputDlg();
return true;
}
bool E_LaughingMan::Init(ImgFile_Ptr pFile)
{
m_faces = NULL;
IImgLayer_weakPtr _sl = pFile->GetSelectLayer();
if(!_sl.expired()){
OutputError::Alert(IE_ERROR_SELECT_LAYER_DONT_EXIST);
return false;
}
IImgLayer_Ptr sl = _sl.lock();
if(sl->GetLayerType() != IE_LAYER_TYPE::NORMAL_LAYER){
OutputError::Alert(IE_ERROR_CANT_EDIT_LAYER);
return false;
}
m_pEditLayer = std::dynamic_pointer_cast<ImgLayer>(sl);
RECT rect, mask_rect;
m_pEditLayer->GetLayerRect(&rect);
//マスクの範囲取得
if(pFile->GetMaskState() != IE_MASK_STATE_ID::INVALID){
pFile->GetMaskRect(&mask_rect);
//範囲を計算
AndRect(&rect, &mask_rect, &rect);
}
CvSize sizeOfImage;
sizeOfImage.width = rect.right - rect.left;
sizeOfImage.height = rect.bottom - rect.top;
m_pEditLayerHandle = (EditLayerHandle*)pFile->CreateImgFileHandle( IFH_EDIT_LAYER );
m_pEditLayerHandle->SetHandleName( DISPLAY_NAME );
pFile->DoImgFileHandle( m_pEditLayerHandle );
m_pEditNode = m_pEditLayerHandle->CreateEditNode(&rect);
m_pEditNode->blt_rect = rect;
IplImage* bgraImg;
IplImage* editImg;
IplImage* grayImg;
IplImage* editedImg;
bgraImg = cvCreateImage(
cvSize(rect.right - rect.left, rect.bottom - rect.top),
IPL_DEPTH_8U,
4);
editImg = cvCreateImage(
cvSize(rect.right - rect.left, rect.bottom - rect.top),
IPL_DEPTH_8U,
3);
grayImg = cvCreateImage(
cvSize(rect.right - rect.left, rect.bottom - rect.top),
IPL_DEPTH_8U,
1);
editedImg = cvCreateImage(
cvSize(rect.right - rect.left, rect.bottom - rect.top),
IPL_DEPTH_8U,
3);
//レイヤーから有効範囲部分のデータを取得
m_pEditLayer->CopyLayerImage(
bgraImg,
0,
0,
rect.left,
rect.top,
rect.right - rect.left,
rect.bottom - rect.top);
ucvCvtColor(bgraImg, editImg, CV_BGRA2BGR);
cvCvtColor(editImg, grayImg, CV_BGRA2GRAY);
cvEqualizeHist(grayImg, grayImg);
m_cascade = (CvHaarClassifierCascade*)cvLoad(CASCADE_FILE_PATH, 0, 0, 0);
if (m_cascade == NULL) {
return false;
}
m_storage = cvCreateMemStorage(0);;
cvClearMemStorage(m_storage);
m_faces = cvHaarDetectObjects(grayImg, m_cascade, m_storage,
1.1, 2, 0,//CV_HAAR_DO_CANNY_PRUNING,
cvSize(30, 30) );
cvReleaseImage(&bgraImg);
cvReleaseImage(&editImg);
cvReleaseImage(&grayImg);
cvReleaseImage(&editedImg);
return true;
}
