void FillHoleShiftMap::ProcessNeighbor(CvPoint currentPoint, CvPoint neighborPoint,
IplImage* maskNeighbor, CvMat* mapping, GCoptimizationGeneralGraph* gcGeneral)
{
CvScalar value = cvGet2D(mapping, currentPoint.y, currentPoint.x);
int nodeId1 = value.val[0];
if(nodeId1 >= 0)
{
if(!IsOutside(currentPoint, cvSize(maskNeighbor->width, maskNeighbor->height)) &&
!IsOutside(neighborPoint, cvSize(maskNeighbor->width, maskNeighbor->height)))
{
// printf("i: %i, j: %i\n", neighborPoint.x, neighborPoint.y);
CvScalar value = cvGet2D(mapping, neighborPoint.y, neighborPoint.x);
int nodeId2 = value.val[0];
if(nodeId2 >= 0)
{
gcGeneral->setNeighbors(nodeId1, nodeId2);
}
if(!IsMaskedPixel(currentPoint.x, currentPoint.y,_mask) && IsMaskedPixel(neighborPoint.x,neighborPoint.y,_mask))
{
CvScalar value = cvGet2D(maskNeighbor, currentPoint.y, currentPoint.x);
SetMaskNeighbor(currentPoint, neighborPoint, &value);
cvSet2D(maskNeighbor, currentPoint.y, currentPoint.x, value);
}
}
}
}
IplImage* FillHoleShiftMap::CalculatedRetargetImage()
{
IplImage* output = cvCloneImage(_maskData);
int num_pixels = _pointMapping->size();
printf("Rendering graph-cut result to image... \n");
for(int i = 0; i < num_pixels; i++)
{
int label = _gcGeneral->whatLabel(i);
CvPoint* point = (*(_pointMapping))[i];
CvPoint shift = GetShift(label, _shiftSize);
CvPoint pointLabel = cvPoint(point->x + shift.x, point->y + shift.y);
if(!IsOutside(pointLabel, cvSize(_input->width, _input->height)))
{
CvScalar value = cvGet2D(_input, pointLabel.y, pointLabel.x);
cvSet2D(output, point->y, point->x, value);
// printf("*%i %i %i %i", point->x, point->y, pointLabel.x, pointLabel.y);
}
else
{
printf("warning mapped outside");
cvSet2D(output, point->y, point->x, cvScalar(255, 0, 0));
}
}
return output;
}
IplImage* ShiftMapHierarchy::GetRetargetImageH()
{
IplImage* output = cvCreateImage(_outputSize, _input->depth, _input->nChannels);
int num_pixels = _outputSize.width * _outputSize.height;
printf("Rendering graph-cut result to image... \n");
for(int i = 0; i < num_pixels; i++)
{
int label = _gc->whatLabel(i);
CvPoint point = GetPoint(i, _outputSize);
CvPoint pointLabel = GetMappedPointInitialGuess(i, label, _outputSize, _shiftSize, _initialGuess);
if(!IsOutside(pointLabel, _inputSize))
{
CvScalar value = cvGet2D(_input, pointLabel.y, pointLabel.x);
cvSet2D(output, point.y, point.x, value);
}
else
{
printf("warning mapped outside");
cvSet2D(output, point.y, point.x, cvScalar(255, 0, 0));
}
}
return output;
}
static __inline int eval_n_mobility(int sq, int color)
{
int dest,r = 0,score = 0;
int opcolor = color ^ 1;
dest = sq + 14;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq - 14;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq + 18;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq - 18;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq + 31;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq - 31;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq + 33;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
dest = sq - 33;
if(!IsOutside(dest) && PieceColor(dest) != color)
{ r++;
score += sq_ctrl[dest];
score += *(safety[opcolor] + dest);
}
score += (mobility[KNIGHT][r]);
return score;
}
bool FillHoleShiftMap::IsMaskedPixel(int x, int y, IplImage* mask)
{
if(!IsOutside(cvPoint(x,y), cvSize(mask->width, mask->height)))
{
CvScalar value = cvGet2D(mask, y, x);
if(value.val[0] < 100)
return true;
else return false;
}
else
{
return true;
}
}
int smoothFunctionFH(int pixel1, int pixel2, int label1, int label2, void* extraData)
{
ForSmoothFH* data = (ForSmoothFH*)extraData;
CvPoint* point1 = (*(data->pointMapping))[pixel1];
CvPoint* point2 = (*(data->pointMapping))[pixel2];
CvPoint shift1 = GetShift(label1, data->shiftSize);
CvPoint shift2 = GetShift(label2, data->shiftSize);
CvPoint origin1 = cvPoint(shift1.x + point1->x, shift1.y + point1->y);
CvPoint origin2 = cvPoint(shift2.x + point2->x, shift2.y + point2->y);
CvPoint neighbor1 = GetNeighbor(*point1, *point2, origin1);
CvPoint neighbor2 = GetNeighbor(*point2, *point1, origin2);
CvSize inputSize = cvSize(data->input->width, data->input->height);
if(IsOutside(origin1, inputSize) || IsOutside(origin2, inputSize)
|| IsOutside(neighbor1, inputSize) || IsOutside(neighbor2, inputSize))
return 10000;
int energy = 0;
energy += SquareColorDifference(origin1, neighbor2, data->input);
energy += SquareColorDifference(origin2, neighbor1, data->input);
energy += SquareColorDifference(origin1, neighbor2, data->inputGradient);
energy += SquareColorDifference(origin2, neighbor1, data->inputGradient);
}
int dataFunctionFH(int pixel, int label, void *extraData)
{
ForDataFH* forData = (ForDataFH*) extraData;
CvPoint* point = (*(forData->pointMapping))[pixel];
CvPoint origin;
CvPoint shift = GetShift(label, forData->shiftSize);
origin.x = point->x + shift.x;
origin.y = point->y + shift.y;
// penalty if outside
if(IsOutside(origin, forData->inputSize))
return 1000000;
// saliency cost
double saliency = 0;
CvScalar value = cvGet2D(forData->saliency, origin.y, origin.x);
saliency += (value.val[0] + value.val[1] + value.val[2]);
// smooth cost with predefined region
int energy = 0;
value = cvGet2D(forData->maskNeighbor, point->y, point->x);
if(value.val[0] == 1)
{
// compare with up position
energy += smoothFunctionFHMask(origin, *point, cvPoint(point->x, point->y - 1),
forData->input, forData->inputGradient, forData->maskData, forData->maskDataGradient);
}
if(value.val[1] == 1)
{
// compare with right
energy += smoothFunctionFHMask(origin, *point, cvPoint(point->x + 1, point->y),
forData->input, forData->inputGradient, forData->maskData, forData->maskDataGradient);
}
if(value.val[2] == 1)
{
// compare with down
energy += smoothFunctionFHMask(origin, *point, cvPoint(point->x, point->y + 1),
forData->input, forData->inputGradient, forData->maskData, forData->maskDataGradient);
}
if(value.val[3] == 1)
{
// compare with left
energy += smoothFunctionFHMask(origin, *point, cvPoint(point->x - 1, point->y),
forData->input, forData->inputGradient, forData->maskData, forData->maskDataGradient);
}
return energy + saliency;
}
void Filler::GetCluster(Pos pos, std::unordered_set<int>& cluster_out)
{
if (IsOutside(pos) ||
visited_.find(pos.GetHash()) != visited_.end() ||
piece_index_.find(pos.GetHash()) == piece_index_.end())
{
return;
}
visited_.insert(pos.GetHash());
cluster_out.insert(piece_index_[pos.GetHash()]);
for (const auto& direction : directions_)
{
GetCluster({ pos.x + direction.first, pos.y + direction.second }, cluster_out);
}
}
int smoothFunctionFHMask2(CvPoint inputPoint, CvPoint outputPoint, CvPoint knownPoint, ForDataFH2* forData)
{
CvPoint inputNeighbor = GetNeighbor(knownPoint, outputPoint, inputPoint); // neighbor of inputPoint
// neighbor of the knownPoint is actually the outputPoint
int energy = 0;
if(IsOutside(inputNeighbor, cvSize(forData->input->width, forData->input->height)))
{
return 100000;
}
// data term
energy += SquareColorDifference(inputNeighbor, forData->input, knownPoint, forData->mask, forData->input);
energy += SquareColorDifference(inputPoint, forData->input, outputPoint, forData->mask, forData->input);
// gradient different term
energy += 2 * SquareColorDifference(inputNeighbor, forData->inputGradient, knownPoint, forData->mask, forData->inputGradient);
energy += 2 * SquareColorDifference(inputPoint, forData->inputGradient, outputPoint, forData->mask, forData->inputGradient);
return energy;
}
void CreateMask(IplImage* input, IplImage* mask, CvPoint shift, CvSize outputSize, IplImage* outputMask, IplImage* outputData)
{
// check size
if(outputMask->width != outputSize.width || outputMask->height != outputSize.height)
return;
if(outputData->width != outputSize.width || outputData->height != outputSize.height)
return;
for(int i = 0; i < outputMask->width; i++)
for(int j = 0; j < outputMask->height; j++)
{
CvPoint inputPixel;
inputPixel.x = shift.x + i;
inputPixel.y = shift.y + j;
if(!IsOutside(inputPixel, cvSize(input->width, input->height)))
{
cvSet2D(outputMask, j, i, cvGet2D(mask, inputPixel.y, inputPixel.x));
}
else
{
cvSet2D(outputMask, j, i, cvScalar(255));
}
}
for(int i = 0; i < outputSize.width; i++)
for(int j = 0; j < outputSize.height; j++)
{
cvSet2D(outputData,j,i, cvScalar(231,233,233));
}
for(int i = 0; i < outputSize.width; i++)
for(int j = 0; j < outputSize.height; j++)
{
if(IsMaskedPixel(i, j, outputMask))
{
// check neighbor
CvPoint inputPixel;
inputPixel.x = shift.x + i;
inputPixel.y = shift.y + j;
CvScalar value;
CvSize inputSize = cvSize(input->width, input->height);
if(!IsOutside(cvPoint(inputPixel.x, inputPixel.y), inputSize) &&
!IsOutside(cvPoint(i,j), outputSize))
{
value = cvGet2D(input, inputPixel.y, inputPixel.x);
cvSet2D(outputData, j, i, value);
}
if(!IsOutside(cvPoint(inputPixel.x+1, inputPixel.y), inputSize) &&
!IsOutside(cvPoint(i+1,j), outputSize))
{
value = cvGet2D(input, inputPixel.y, inputPixel.x + 1);
cvSet2D(outputData, j, i+1, value);
}
if(!IsOutside(cvPoint(inputPixel.x - 1, inputPixel.y), inputSize) &&
!IsOutside(cvPoint(i-1,j), outputSize))
{
value = cvGet2D(input, inputPixel.y, inputPixel.x - 1);
cvSet2D(outputData, j, i-1, value);
}
if(!IsOutside(cvPoint(inputPixel.x, inputPixel.y+1), inputSize) &&
!IsOutside(cvPoint(i,j+1), outputSize))
{
value = cvGet2D(input, inputPixel.y + 1, inputPixel.x);
cvSet2D(outputData, j+1, i, value);
}
if(!IsOutside(cvPoint(inputPixel.x, inputPixel.y-1), inputSize) &&
!IsOutside(cvPoint(i,j-1), outputSize))
{
value = cvGet2D(input, inputPixel.y - 1, inputPixel.x);
cvSet2D(outputData, j-1, i, value);
}
}
}
for(int i = 0; i < outputSize.width - 1; i++)
for(int j = 0; j < outputSize.height - 1; j++)
{
if(IsMaskedPixel(i, j, outputMask))
{
// check neighbor
CvScalar value;
value = cvGet2D(outputData, j, i);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j+1, i);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j-1, i);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j, i+1);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j, i-1);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
}
}
}
// mask is of the same size as input
MaskShift* CreateMaskShift(IplImage* input, IplImage* mask, CvPoint shift, CvSize outputSize)
{
IplImage* outputMask = cvCreateImage(outputSize, IPL_DEPTH_8U, 3);
IplImage* outputTest = cvCreateImage(outputSize, IPL_DEPTH_8U, 3);
IplImage* outputData = cvCreateImage(outputSize, IPL_DEPTH_8U, 3);
for(int i = 0; i < outputMask->width; i++)
for(int j = 0; j < outputMask->height; j++)
{
CvPoint inputPixel;
inputPixel.x = shift.x + i;
inputPixel.y = shift.y + j;
if(!IsOutside(inputPixel, cvSize(input->width, input->height)))
{
cvSet2D(outputMask, j, i, cvGet2D(mask, inputPixel.y, inputPixel.x));
}
else
{
cvSet2D(outputMask, j, i, cvScalar(255));
}
}
for(int i = 0; i < outputSize.width; i++)
for(int j = 0; j < outputSize.height; j++)
{
cvSet2D(outputData,j,i, cvScalar(231,233,233));
}
for(int i = 0; i < outputSize.width; i++)
for(int j = 0; j < outputSize.height; j++)
{
if(IsMaskedPixel(i, j, outputMask))
{
// check neighbor
CvPoint inputPixel;
inputPixel.x = shift.x + i;
inputPixel.y = shift.y + j;
CvScalar value;
CvSize inputSize = cvSize(input->width, input->height);
if(!IsOutside(cvPoint(inputPixel.x, inputPixel.y), inputSize) &&
!IsOutside(cvPoint(i,j), outputSize))
{
value = cvGet2D(input, inputPixel.y, inputPixel.x);
cvSet2D(outputData, j, i, value);
}
if(!IsOutside(cvPoint(inputPixel.x+1, inputPixel.y), inputSize) &&
!IsOutside(cvPoint(i+1,j), outputSize))
{
value = cvGet2D(input, inputPixel.y, inputPixel.x + 1);
cvSet2D(outputData, j, i+1, value);
}
if(!IsOutside(cvPoint(inputPixel.x - 1, inputPixel.y), inputSize) &&
!IsOutside(cvPoint(i-1,j), outputSize))
{
value = cvGet2D(input, inputPixel.y, inputPixel.x - 1);
cvSet2D(outputData, j, i-1, value);
}
if(!IsOutside(cvPoint(inputPixel.x, inputPixel.y+1), inputSize) &&
!IsOutside(cvPoint(i,j+1), outputSize))
{
value = cvGet2D(input, inputPixel.y + 1, inputPixel.x);
cvSet2D(outputData, j+1, i, value);
}
if(!IsOutside(cvPoint(inputPixel.x, inputPixel.y-1), inputSize) &&
!IsOutside(cvPoint(i,j-1), outputSize))
{
value = cvGet2D(input, inputPixel.y - 1, inputPixel.x);
cvSet2D(outputData, j-1, i, value);
}
}
}
int j2 =21;
int i2 = 5;
CvScalar value2 = cvGet2D(outputData, j2+1, i2);
for(int i = 0; i < outputSize.width; i++)
for(int j = 0; j < outputSize.height; j++)
{
if(IsMaskedPixel(i, j, outputMask))
{
// check neighbor
CvScalar value;
value = cvGet2D(outputData, j, i);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j+1, i);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j-1, i);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j, i+1);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
value = cvGet2D(outputData, j, i-1);
if(value.val[0] == 231 && value.val[1] == 233 && value.val[2] == 233)
printf("Test");
}
}
//cvNamedWindow("Test");
//while(1)
//{
// cvShowImage("Test", outputData);
// cvWaitKey(100);
//}
MaskShift* maskShift = new MaskShift(outputMask, input);
maskShift->SetMaskData(outputData);
return maskShift;
}
