WarpingField<T> STWarp<T>::computeWarp() {
if(params.verbosity >0) {
printf("=== Computing warping field for %s, size %dx%dx%d(%d) ===\n",
params.name.c_str(),
dimensions[1],
dimensions[0],
dimensions[2],
videoA->channelCount());
}
if(params.verbosity >0) {
if(typeid(T)==typeid(float)) {
printf("+ Single-precision computation\n");
} else{
printf("+ Double-precision computation\n");
}
if(params.bypassTimeWarp){
printf("+ By-passing timewarp map\n");
}
printf("+ Regularizing lambda [%5f,%5f,%5f,%5f]\n",
params.lambda[0],
params.lambda[1],
params.lambda[2],
params.lambda[3]);
}
// Get dimensions of the pyramid levels
vector<vector<int> > pyrSizes = getPyramidSizes();
int nLevels = pyrSizes.size();
// Build Pyramids
vector<Video<stwarp_video_t>*> pyramidA(nLevels);
vector<Video<stwarp_video_t>*> pyramidB(nLevels);
buildPyramid(pyrSizes,pyramidA,pyramidB);
WarpingField<T> warpField;
if(initialWarpField) {
warpField = *initialWarpField;
} else {
if(params.verbosity >0) {
printf("+ Generating initial warp field\n");
}
warpField = WarpingField<T>(dimensions[0], dimensions[1],
dimensions[2], 3);
}
for (int i = nLevels-1; i >= 0 ; --i) {
videoA = pyramidA[i];
videoB = pyramidB[i];
// update dimensions
this->dimensions = videoA->dimensions();
if(params.verbosity >0) {
printf("+ Multiscale level %02d: %dx%dx%d (B:%d)\n", i+1,dimensions[1],
dimensions[0],dimensions[2],videoB->frameCount());
}
// resample warping field
resampleWarpingField(warpField,pyrSizes[i]);
// computeUVW
multiscaleIteration(warpField);
if(params.verbosity >0) {
printf(" x[%.4f, %.4f] ", warpField.min(0), warpField.max(0));
printf(" y[%.4f, %.4f] ", warpField.min(1), warpField.max(1));
printf(" t[%.4f, %.4f]\n", warpField.min(2), warpField.max(2));
}
// Cleanup allocated videos
if (i != 0) {
if( videoA != nullptr ){
delete videoA;
videoA = nullptr;
}
if( videoB != nullptr ){
delete videoB;
videoB = nullptr;
}
}
}
return warpField;
}
int IKNSaliencyMap::calculate()
{
calculated = false;
int rt_code = checkParameters();
if(rt_code != AM_OK)
return(rt_code);
printf("[INFO]: %s: Computation started.\n",mapName.c_str());
createColorChannels();
//----
// I
IttiPyramid::Ptr pyramidI( new IttiPyramid() );
initializePyramid(pyramidI,I);
// R
IttiPyramid::Ptr pyramidR( new IttiPyramid() );
initializePyramid(pyramidR,R);
// G
IttiPyramid::Ptr pyramidG( new IttiPyramid() );
initializePyramid(pyramidG,G);
// B
IttiPyramid::Ptr pyramidB( new IttiPyramid() );
initializePyramid(pyramidB,B);
// Y
IttiPyramid::Ptr pyramidY( new IttiPyramid() );
initializePyramid(pyramidY,Y);
// O
std::vector<IttiPyramid::Ptr> pyramidO;
pyramidO.resize(numberOfOrientations);
for(int i = 0; i < numberOfOrientations; ++ i)
{
pyramidO.at(i) = IttiPyramid::Ptr( new IttiPyramid() );
initializePyramid(pyramidO.at(i),I);
}
// create feature maps
rt_code = createFeatureMapsI(pyramidI);
if(rt_code != AM_OK)
return(rt_code);
for(int i = 0; i < numberOfOrientations; ++ i)
{
float angle = i*180.0/numberOfOrientations;
rt_code = createFeatureMapsO(pyramidO.at(i),angle);
if(rt_code != AM_OK)
return(rt_code);
}
rt_code = createFeatureMapsRG(pyramidR,pyramidG);
if(rt_code != AM_OK)
return(rt_code);
rt_code = createFeatureMapsRG(pyramidB,pyramidY);
if(rt_code != AM_OK)
return(rt_code);
// for(unsigned int i = pyramidG->getStartLevel(); i <= (unsigned int)pyramidG->getMaxLevel(); ++i)
// {
// cv::Mat tempG;
// if(pyramidG->getImage(i,tempG))
// {
// cv::imshow("G",tempG);
// cv::waitKey(-1);
// }
// }
float totalWeight = weightOfColor + weightOfIntensities + weightOfOrientations;
cv::Mat intensity;
if(!pyramidI->getMap(intensity))
{
printf("[ERROR]: Something went wrong! Can't get saliency map from the pyramid!\n");
return(AM_CUSTOM);
}
intensity = weightOfIntensities*intensity/totalWeight;
// cv::imshow("intensity",intensity);
// cv::waitKey(-1);
cv::Mat orientation;
for(int i = 0; i < numberOfOrientations; ++i)
{
cv::Mat orientation_temp;
if(!pyramidO.at(i)->getMap(orientation_temp))
{
printf("[ERROR]: Something went wrong! Can't get saliency map from the pyramid!\n");
return(AM_CUSTOM);
}
if(i==0)
orientation_temp.copyTo(orientation);
else
orientation = orientation + orientation_temp;
}
v4r::normalize(orientation,normalization_type);
orientation = weightOfOrientations*orientation/totalWeight;
// cv::imshow("orientation",orientation);
// cv::waitKey(-1);
cv::Mat colorRG;
if(!pyramidR->getMap(colorRG))
{
printf("[ERROR]: Something went wrong! Can't get saliency map from the pyramid!\n");
return(AM_CUSTOM);
}
// cv::imshow("colorRG",colorRG);
// cv::waitKey(-1);
cv::Mat colorBY;
if(!pyramidB->getMap(colorBY))
{
printf("[ERROR]: Something went wrong! Can't get saliency map from the pyramid!\n");
return(AM_CUSTOM);
}
// cv::imshow("colorBY",colorBY);
// cv::waitKey(-1);
cv::Mat color = colorRG + colorBY;
v4r::normalize(color,normalization_type);
color = weightOfColor*color/totalWeight;
// cv::imshow("color",color);
// cv::waitKey(-1);
map = intensity + color + orientation;
calculated = true;
printf("[INFO]: %s: Computation finished.\n",mapName.c_str());
return(AM_OK);
}
