static void
getMapping(const char * const rmapFileName,
const unsigned int * const lumahist,
xelval const maxval,
unsigned int const pixelCount,
gray ** const lumamapP) {
/*----------------------------------------------------------------------------
Calculate the luminosity mapping table which gives the
histogram-equalized luminosity for each original luminosity.
-----------------------------------------------------------------------------*/
gray * lumamap;
lumamap = pgm_allocrow(maxval+1);
if (rmapFileName)
readMapFile(rmapFileName, maxval, lumamap);
else
computeMap(lumahist, maxval, pixelCount, lumamap);
*lumamapP = lumamap;
}
// return probability channel
bool probabilityMap2D::apply(const channel8& src1, const channel8& src2, channel& dest) const {
const parameters& param = getParameters();
point chnl1_size = src1.size();
point chnl2_size = src2.size();
// size of src1 equals src2 ?
if ( (chnl1_size.x != chnl2_size.x) || (chnl1_size.y != chnl2_size.y) ) {
setStatusString("probabilityMap2D: channels do not match");
return false;
}
// the color model MUST have 2 dimensions!
if (probabilityHistogram.dimensions() == 2) {
// resize probability channel
dest.resize(src1.size());
ivector theBin(2);
// compute first iteration
int y;
vector<channel8::value_type>::const_iterator srcIterator1, eit1;
vector<channel8::value_type>::const_iterator srcIterator2, eit2;
vector<channel::value_type>::iterator destIterator;
for (y=0;y<src1.rows();++y) {
srcIterator1 = src1.getRow(y).begin();
eit1 = src1.getRow(y).end();
srcIterator2 = src2.getRow(y).begin();
eit2 = src2.getRow(y).end();
destIterator = dest.getRow(y).begin();
while (srcIterator1 != eit1) {
theBin[0] = lookupTable[0][*srcIterator1];
theBin[1] = lookupTable[1][*srcIterator2];
(*destIterator)=static_cast<float>(probabilityHistogram.at(theBin));
srcIterator1++;
srcIterator2++;
destIterator++;
}
}
// compute all other iterations
if (param.iterations > 1) {
int i;
if (param.gaussian) {
gaussKernel2D<float> gk(param.windowSize,param.variance);
convolution convolver;
convolution::parameters convParam;
convParam.boundaryType = lti::Mirror;
convParam.setKernel(gk);
convolver.setParameters(convParam);
for (i=1;i<param.iterations;++i) {
convolver.apply(dest);
computeMap(src1,src2,dest);
}
} else {
squareConvolution<float> convolver;
squareConvolution<float>::parameters convParam;
convParam.boundaryType = lti::Mirror;
convParam.initSquare(param.windowSize);
convolver.setParameters(convParam);
for (i=1;i<param.iterations;++i) {
convolver.apply(dest);
computeMap(src1,src2,dest);
}
}
} // of (param.iterations > 1)
return true;
} // of (probabilityHistogram.dimensions() == 2)
setStatusString("probabilityMap2D: no models loaded");
return false;
}
int main(int argc, char **argv){
std::string filename("");
unsigned int scale = 5, dmst = 2, window = 3, detectorType = 0, descriptorType = 0, distanceType = 2, strategy = 0;
double baseSigma = 0.2, sigmaStep = 1.4, minPeak = 0.34, minPeakDistance = 0.001, success = 0.95, inlier = 0.4, matchingThreshold = 0.4;
bool useMaxRange = false;
int i = 1;
while(i < argc){
if(strncmp("-filename", argv[i], sizeof("-filename")) == 0 ){
filename = argv[++i];
i++;
} else if(strncmp("-detector", argv[i], sizeof("-detector")) == 0 ){
detectorType = atoi(argv[++i]);
i++;
} else if(strncmp("-descriptor", argv[i], sizeof("-descriptor")) == 0 ){
descriptorType = atoi(argv[++i]);
i++;
} else if(strncmp("-corresp", argv[i], sizeof("-corresp")) == 0 ){
corresp = atoi(argv[++i]);
i++;
} else if(strncmp("-distance", argv[i], sizeof("-distance")) == 0 ){
distanceType = atoi(argv[++i]);
i++;
} else if(strncmp("-baseSigma", argv[i], sizeof("-baseSigma")) == 0 ){
baseSigma = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-sigmaStep", argv[i], sizeof("-sigmaStep")) == 0 ){
sigmaStep = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-minPeak", argv[i], sizeof("-minPeak")) == 0 ){
minPeak = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-minPeakDistance", argv[i], sizeof("-minPeakDistance")) == 0 ){
minPeakDistance = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-scale", argv[i], sizeof("-scale")) == 0 ){
scale = atoi(argv[++i]);
i++;
} else if(strncmp("-dmst", argv[i], sizeof("-dmst")) == 0 ){
dmst = atoi(argv[++i]);
i++;
} else if(strncmp("-window", argv[i], sizeof("-window")) == 0 ){
scale = atoi(argv[++i]);
i++;
} else if(strncmp("-acceptanceSigma", argv[i], sizeof("-acceptanceSigma")) == 0 ){
acceptanceSigma = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-success", argv[i], sizeof("-success")) == 0 ){
success = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-inlier", argv[i], sizeof("-inlier")) == 0 ){
inlier = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-matchingThreshold", argv[i], sizeof("-matchingThreshold")) == 0 ){
matchingThreshold = strtod(argv[++i], NULL);
i++;
} else {
i++;
}
}
if(!filename.size()){
help();
exit(-1);
}
CarmenLogWriter writer;
CarmenLogReader reader;
m_sensorReference = LogSensorStream(&reader, &writer);
m_sensorReference.load(filename);
SimpleMinMaxPeakFinder *m_peakMinMax = new SimpleMinMaxPeakFinder(minPeak, minPeakDistance);
std::string detector("");
switch(detectorType){
case 0:
m_detectorCurvature = new CurvatureDetector(m_peakMinMax, scale, baseSigma, sigmaStep, dmst);
m_detectorCurvature->setUseMaxRange(useMaxRange);
m_detector = m_detectorCurvature;
detector = "curvature";
break;
case 1:
m_detectorNormalEdge = new NormalEdgeDetector(m_peakMinMax, scale, baseSigma, sigmaStep, window);
m_detectorNormalEdge->setUseMaxRange(useMaxRange);
m_detector = m_detectorNormalEdge;
detector = "edge";
break;
case 2:
m_detectorNormalBlob = new NormalBlobDetector(m_peakMinMax, scale, baseSigma, sigmaStep, window);
m_detectorNormalBlob->setUseMaxRange(useMaxRange);
m_detector = m_detectorNormalBlob;
detector = "blob";
break;
case 3:
m_detectorRange = new RangeDetector(m_peakMinMax, scale, baseSigma, sigmaStep);
m_detectorRange->setUseMaxRange(useMaxRange);
m_detector = m_detectorRange;
detector = "range";
break;
default:
std::cerr << "Wrong detector type" << std::endl;
exit(-1);
}
HistogramDistance<double> *dist = NULL;
std::string distance("");
switch(distanceType){
case 0:
dist = new EuclideanDistance<double>();
distance = "euclid";
break;
case 1:
dist = new Chi2Distance<double>();
distance = "chi2";
break;
case 2:
dist = new SymmetricChi2Distance<double>();
distance = "symchi2";
break;
case 3:
dist = new BatthacharyyaDistance<double>();
distance = "batt";
break;
case 4:
dist = new KullbackLeiblerDistance<double>();
distance = "kld";
break;
case 5:
dist = new JensenShannonDistance<double>();
distance = "jsd";
break;
default:
std::cerr << "Wrong distance type" << std::endl;
exit(-1);
}
std::string descriptor("");
switch(descriptorType){
case 0:
m_betaGenerator = new BetaGridGenerator(0.02, 0.5, 4, 12);
m_betaGenerator->setDistanceFunction(dist);
m_descriptor = m_betaGenerator;
descriptor = "beta";
break;
case 1:
m_shapeGenerator = new ShapeContextGenerator(0.02, 0.5, 4, 12);
m_shapeGenerator->setDistanceFunction(dist);
m_descriptor = m_shapeGenerator;
descriptor = "shape";
break;
default:
std::cerr << "Wrong descriptor type" << std::endl;
exit(-1);
}
std::cerr << "Processing file:\t" << filename << "\nDetector:\t\t" << detector << "\nDescriptor:\t\t" << descriptor << "\nDistance:\t\t" << distance << std::endl;
switch(strategy){
case 0:
m_ransac = new RansacFeatureSetMatcher(acceptanceSigma * acceptanceSigma * 5.99, success, inlier, matchingThreshold, acceptanceSigma * acceptanceSigma * 3.84, false);
break;
case 1:
m_ransac = new RansacMultiFeatureSetMatcher(acceptanceSigma * acceptanceSigma * 5.99, success, inlier, matchingThreshold, acceptanceSigma * acceptanceSigma * 3.84, false);
break;
default:
std::cerr << "Wrong strategy type" << std::endl;
exit(-1);
}
m_sensorReference.seek(0,END);
unsigned int end = m_sensorReference.tell();
m_sensorReference.seek(0,BEGIN);
m_pointsReference.resize(end + 1);
m_posesReference.resize(end + 1);
computeBoundingBox();
detectLog();
describeLog();
std::stringstream mapFile;
mapFile << filename << "_map.png";
/* cairo_surface_t * cairoMapSurface = cairo_pdf_surface_create(mapFile.str().c_str(), sizeX, sizeY);
cairo_surface_t * cairoOutSurface = cairo_pdf_surface_create(outFile.str().c_str(), sizeX, sizeY);*/
cairo_surface_t * cairoMapSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, sizeX, sizeY);
// cairo_surface_t * cairoMapSurface = cairo_svg_surface_create(mapFile.str().c_str(), sizeX, sizeY);
cairoMap = cairo_create(cairoMapSurface);
std::stringstream outDir;
outDir << filename << "_" << detector << "_" << descriptor << "_" << distance << "/";
mkdir(outDir.str().c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
computeMap();
std::string bar(50,' ');
bar[0] = '#';
unsigned int progress = 0;
for(unsigned int i =0; i < m_pointsReference.size(); i++){
unsigned int currentProgress = (i*100)/(m_pointsReference.size() - 1);
if (progress < currentProgress){
progress = currentProgress;
bar[progress/2] = '#';
std::cout << "\rMatching [" << bar << "] " << progress << "%" << std::flush;
}
std::stringstream outFile;
outFile << outDir.str() << "frame_";
outFile.width(4);
outFile.fill('0');
outFile << std::right << i << ".png";
cairo_surface_t * cairoOutSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, sizeX, sizeY);
// cairo_surface_t * cairoOutSurface = cairo_svg_surface_create(outFile.str().c_str(), sizeX, sizeY);
cairoOut = cairo_create(cairoOutSurface);
cairo_translate(cairoOut, -offsetX, -offsetY);
cairo_scale(cairoOut, scaleFactor, scaleFactor);
cairo_set_line_width(cairoOut, 1./scaleFactor);
match(i);
cairo_surface_write_to_png(cairoOutSurface, outFile.str().c_str());
cairo_surface_destroy(cairoOutSurface);
cairo_destroy(cairoOut);
}
std::cout << " done." << std::endl;
cairo_surface_write_to_png(cairoMapSurface, mapFile.str().c_str());
cairo_surface_destroy(cairoMapSurface);
cairo_destroy(cairoMap);
// cairo_show_page(cairoOut);
}
