void Map::load(QString dir)
{
QDir qDir(dir);
qDir.mkpath(dir);
if(dir[dir.size() - 1] != '\\')
dir += '\\';
leftPopulation -> loadPopulation(dir + "LeftPopulation\\");
rightPopulation -> loadPopulation(dir + "RightPopulation\\");
QFile *fileX = new QFile(dir + "mapX.save");
QFile *fileY = new QFile(dir + "mapY.save");
QFile *fileS = new QFile(dir + "mapS.save");
if (! fileX -> open(QIODevice::ReadOnly | QIODevice::Text) ||
! fileY -> open(QIODevice::ReadOnly | QIODevice::Text) ||
! fileS -> open(QIODevice::ReadOnly | QIODevice::Text) )
{
// Error while trying to read file
}
else
{
// Everything is OK
QTextStream inX(fileX);
QTextStream inY(fileY);
QTextStream inS(fileS);
inS >> minDeltaX;
inS >> maxDeltaX;
inS >> minDeltaY;
inS >> maxDeltaY;
inS >> lengthStartEnd;
inS >> lengthTotal;
int tmp_size;
inX >> tmp_size;
inY >> tmp_size;
points.resize(tmp_size);
for(int i = 0; i < points.size(); ++i)
{
inX >> points[i].x;
inY >> points[i].y;
}
}
fileX -> close();
fileY -> close();
fileS -> close();
updateLoseTimer();
}
void pfstmo_mantiuk06(pfs::Frame& frame, float scaleFactor,
float saturationFactor, float detailFactor,
bool cont_eq, pfs::Progress &ph)
{
#ifndef NDEBUG
std::stringstream ss;
ss << "pfstmo_mantiuk06 (";
if (!cont_eq)
{
ss << "Mode: Contrast Mapping, ";
}
else
{
scaleFactor = -scaleFactor;
ss << "Mode: Contrast Equalization, ";
}
ss << "scaleFactor: " << scaleFactor;
ss << ", saturationFactor: " << saturationFactor;
ss << ", detailFactor: " << detailFactor << ")" << std::endl;
std::cout << ss.str();
#endif
pfs::Channel *inRed, *inGreen, *inBlue;
frame.getXYZChannels(inRed, inGreen, inBlue);
int cols = frame.getWidth();
int rows = frame.getHeight();
pfs::Array2Df inY( cols, rows );
pfs::transformRGB2Y(inRed, inGreen, inBlue, &inY);
tmo_mantiuk06_contmap(*inRed, *inGreen, *inBlue, inY,
scaleFactor, saturationFactor, detailFactor, itmax, tol,
ph);
frame.getTags().setTag("LUMINANCE", "RELATIVE");
}
cv::Mat flow_2_RGB( const cv::Mat &inpFlow, const float &max_size )
{
//////////////////////////
bool use_value = false;
cv::Mat sat;
cv::Mat rgbFlow;
//////////////////////////
if (inpFlow.empty()) exit(1);
if (inpFlow.depth() != CV_32F) { std::cout << "FlowTo RGB: error inpFlow wrong data type ( has be CV_32FC2" << std::endl; exit(1); }
if (!sat.empty() )
if( sat.type() != CV_8UC1) { std::cout << "FlowTo RGB: error sat must have type CV_8UC1" << std::endl; exit(1); }
const float grad2deg = (float)(90/3.141);
double satMaxVal = 0;
double minVal = 0;
if(!sat.empty())
{
cv::minMaxLoc(sat, &minVal, &satMaxVal);
satMaxVal = 255.0/satMaxVal;
}
cv::Mat pol(inpFlow.size(), CV_32FC2);
float mean_val = 0, min_val = 1000, max_val = 0;
for(int r = 0; r < inpFlow.rows; r++)
{
for(int c = 0; c < inpFlow.cols; c++)
{
cv::Mat1f inX( 1,1); inX(0,0)=inpFlow.at<cv::Point2f>(r,c).x;
cv::Mat1f inY( 1,1); inY(0,0)=inpFlow.at<cv::Point2f>(r,c).y;
cv::Mat1f outX(1,1);
cv::Mat1f outY(1,1);
cv::cartToPolar( inX, inY, outX, outY, false );
cv::Point2f polar;
polar.x = outX(0,0);
polar.y = outY(0,0);
polar.y *= grad2deg;
mean_val +=polar.x;
max_val = MAX(max_val, polar.x);
min_val = MIN(min_val, polar.x);
pol.at<cv::Point2f>(r,c) = cv::Point2f(polar.y,polar.x);
}
}
mean_val /= inpFlow.size().area();
float scale = max_val - min_val;
float shift = -min_val;
scale = 255.f/scale;
if( max_size > 0)
{
scale = 255.f/max_size;
shift = 0;
}
//calculate the angle, motion value
cv::Mat hsv(inpFlow.size(), CV_8UC3);
uchar * ptrHSV = hsv.ptr<uchar>();
int idx_val = (use_value) ? 2:1;
int idx_sat = (use_value) ? 1:2;
for(int r = 0; r < inpFlow.rows; r++, ptrHSV += hsv.step1())
{
uchar * _ptrHSV = ptrHSV;
for(int c = 0; c < inpFlow.cols; c++, _ptrHSV+=3)
{
cv::Point2f vpol = pol.at<cv::Point2f>(r,c);
_ptrHSV[0] = cv::saturate_cast<uchar>(vpol.x);
_ptrHSV[idx_val] = cv::saturate_cast<uchar>( (vpol.y + shift) * scale);
if( sat.empty())
_ptrHSV[idx_sat] = 255;
else
_ptrHSV[idx_sat] = 255- cv::saturate_cast<uchar>(sat.at<uchar>(r,c) * satMaxVal);
}
}
std::vector<cv::Mat> vec;
cv::split(hsv, vec);
cv::equalizeHist(vec[idx_val],vec[idx_val]);
cv::merge(vec,hsv);
cv::Mat rgbFlow32F;
cv::cvtColor(hsv, rgbFlow32F, CV_HSV2BGR);
rgbFlow32F.convertTo(rgbFlow, CV_8UC3);
///////////////
return rgbFlow;
///////////////
}
