image<float> *imageINTtoFLOAT(image<int> *input) {
int width = input->width();
int height = input->height();
image<float> *output = new image<float>(width, height, false);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(output, x, y) = imRef(input, x, y);
}
}
return output;
}
image<long> *imageUCHARtoLONG(image<uchar> *input) {
int width = input->width();
int height = input->height();
image<long> *output = new image<long>(width, height, false);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(output, x, y) = imRef(input, x, y);
}
}
return output;
}
image<uchar> *imageRGBtoGRAY(image<rgb> *input) {
int width = input->width();
int height = input->height();
image<uchar> *output = new image<uchar>(width, height, false);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(output, x, y) = (uchar)
(imRef(input, x, y).r * RED_WEIGHT +
imRef(input, x, y).g * GREEN_WEIGHT +
imRef(input, x, y).b * BLUE_WEIGHT);
}
}
return output;
}
image<uchar> *imageLONGtoUCHAR(image<long> *input, long min, long max) {
int width = input->width();
int height = input->height();
image<uchar> *output = new image<uchar>(width, height, false);
if (max == min)
return output;
float scale = UCHAR_MAX / (float)(max - min);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
uchar val = (uchar)((imRef(input, x, y) - min) * scale);
imRef(output, x, y) = bound(val, (uchar)0, (uchar)UCHAR_MAX);
}
}
return output;
}
void Match::SubPixel(GrayImage Im, GrayImage ImMin, GrayImage ImMax)
{
Coord p;
int I, I1, I2, I3, I4, I_min, I_max;
for (p.y=0; p.y<im_size.y; p.y++)
for (p.x=0; p.x<im_size.x; p.x++)
{
I = I_min = I_max = imRef(Im, p.x, p.y);
if (p.x>0) I1 = (imRef(Im, p.x-1, p.y) + I) / 2;
else I1 = I;
if (p.x<im_size.x-1) I2 = (imRef(Im, p.x+1, p.y) + I) / 2;
else I2 = I;
if (p.y>0) I3 = (imRef(Im, p.x, p.y-1) + I) / 2;
else I3 = I;
if (p.y<im_size.y-1) I4 = (imRef(Im, p.x, p.y+1) + I) / 2;
else I4 = I;
if (I_min > I1) I_min = I1;
if (I_min > I2) I_min = I2;
if (I_min > I3) I_min = I3;
if (I_min > I4) I_min = I4;
if (I_max < I1) I_max = I1;
if (I_max < I2) I_max = I2;
if (I_max < I3) I_max = I3;
if (I_max < I4) I_max = I4;
imRef(ImMin, p.x, p.y) = I_min;
imRef(ImMax, p.x, p.y) = I_max;
}
}
void EtGcSegmentRgb::segment(image<rgb> *im, image<rgb>*dest, float sigma, float c, int minSize, std::string sortingMethod){
EtTimer tmr;
//smooth each color channel
#pragma omp parallel for
for (int y = 0; y < imgH; y++) {
for (int x = 0; x < imgW; x++) {
imRef(this->r, x, y) = imRef(im, x, y).r;
imRef(this->g, x, y) = imRef(im, x, y).g;
imRef(this->b, x, y) = imRef(im, x, y).b;
}
}
if( doPreprocess ){
tmr.start();
preprocess(sigma);
tmr.stop();
std::cout << im->width() << " " << im->height() << " Preprocess " << tmr.getElapsedTime() << endl;
}
tmr.start();
buildGraph( );
tmr.stop();
std::cout << im->width() << " " << im->height() << " BuildGraph " << tmr.getElapsedTime() << endl;
//EtGcSegment::segment( im, dest, sigma, c, minSize, sortingMethod );
EtGcSegment::segment( dest, c, minSize, sortingMethod );
}
int main(int argv, char **argc) {
if (argv != 4) {
fprintf(stderr, "usage: %s in(pgm) out(pgm) sigma\n", argc[0]);
exit(1);
}
srand48(time(NULL));
float sigma = atof(argc[3]);
image<uchar> *im = loadPGM(argc[1]);
image<uchar> *out = new image<uchar>(im->width(), im->height());
for (int y = 0; y < im->height(); y++) {
for (int x = 0; x < im->width(); x++) {
double r = gaussian()*sigma;
double v = imRef(im, x, y);
imRef(out, x, y) = bound(vlib_round(v + r), 0, 255);
}
}
savePGM(out, argc[2]);
return 0;
}
void putdigit(int d, GrayImage im, int x0, int y0, int val)
{
int x, y;
assert(x0+DIGIT_WIDTH < imGetWidth(im));
assert(y0+DIGIT_HEIGHT < imGetHeight(im));
assert(d >= 0 && d <= 10);
for (y=0; y < DIGIT_HEIGHT; y++)
for (x=0; x < DIGIT_WIDTH; x++)
if (digits[d][y][x])
imRef(im, x0+x, y0+y) = val;
}
grid_map::Matrix SignedDistanceField::getPlanarSignedDistanceField(Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic>& data) const
{
image<uchar> *input = new image<uchar>(data.rows(), data.cols(), true);
for (int y = 0; y < input->height(); y++) {
for (int x = 0; x < input->width(); x++) {
imRef(input, x, y) = data(x, y);
}
}
// Compute dt.
image<float> *out = dt(input);
Matrix result(data.rows(), data.cols());
// Take square roots.
for (int y = 0; y < out->height(); y++) {
for (int x = 0; x < out->width(); x++) {
result(x, y) = sqrt(imRef(out, x, y));
}
}
return result;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
float sigma, k;
int min_size;
//r = mxGetPr( prhs[0] );
//g = mxGetPr( prhs[1] );
//b = mxGetPr( prhs[3] );
double *image = mxGetPr( prhs[0] );
const mwSize *dims = mxGetDimensions( prhs[0] );
sigma = mxGetScalar( prhs[1] );
k = mxGetScalar( prhs[2] );
min_size = mxGetScalar( prhs[3] );
//mexPrintf( "sigma: %.3f, k: %.3f, min_size: %d\n", sigma, k, min_size );
int height = dims[0];
int width = dims[1];
int c = dims[2];
typedef unsigned char uchar;
imageRGB *input = new imageRGB(width, height);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int index = height * x + y;
imRef(input, x, y).r = static_cast<uchar>( image[index] );
imRef(input, x, y).g = static_cast<uchar>( image[width*height + index] );
imRef(input, x, y).b = static_cast<uchar>( image[width*height*2 + index] );
}
}
int num_ccs;
imageRGB *seg = segment_image(input, sigma, k, min_size, &num_ccs);
// printf("sigma %.2f k %.2f min_size %d\n", sigma, k, min_size);
// mexPrintf( "number of regions: %d\n", num_ccs);
plhs[0] = mxCreateNumericArray(3, dims, mxUINT8_CLASS, mxREAL);
uchar *output = static_cast<uchar*>( mxGetData(plhs[0]) );
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int index = height*x + y;
output[index] = imRef(seg, x, y).r;
output[width * height + index] = imRef(seg, x, y).g;
output[2 * width * height + index] = imRef(seg, x, y).b;
}
}
delete input;
delete seg;
}
void LFLineFitter::Find(int x0,int y0,Point<int> *windPoints,int &nWindPoints,Image<unsigned char> *inputImage,int localWindSize)
{
int x,y;
nWindPoints = 0;
for(y=max(y0-localWindSize,0);y<min(y0+localWindSize,inputImage->height());y++)
for(x=max(x0-localWindSize,0);x<min(x0+localWindSize,inputImage->width());x++)
{
//if(cvGetReal2D(inputImage,y,x)!=0)
if(imRef(inputImage,x,y)!=0)
{
windPoints[nWindPoints].x = x - x0;
windPoints[nWindPoints].y = y - y0;
nWindPoints++;
}
}
}
/* compute laplacian */
static image<float> *laplacian(image<float> *src) {
int width = src->width();
int height = src->height();
image<float> *dst = new image<float>(width, height);
for (int y = 1; y < height-1; y++) {
for (int x = 1; x < width-1; x++) {
float d2x = imRef(src, x-1, y) + imRef(src, x+1, y) -
2*imRef(src, x, y);
float d2y = imRef(src, x, y-1) + imRef(src, x, y+1) -
2*imRef(src, x, y);
imRef(dst, x, y) = d2x + d2y;
}
}
return dst;
}
image<rgb> *imageGRAYtoRGB(image<uchar> *input) {
int width = input->width();
int height = input->height();
image<rgb> *output = new image<rgb>(width, height, false);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(output, x, y).r = imRef(input, x, y);
imRef(output, x, y).g = imRef(input, x, y);
imRef(output, x, y).b = imRef(input, x, y);
}
}
return output;
}
// dissimilarity measure between pixels
static inline float diff(image<float> *r, image<float> *g, image<float> *b,
int x1, int y1, int x2, int y2) {
return sqrt(square(imRef(r, x1, y1)-imRef(r, x2, y2)) +
square(imRef(g, x1, y1)-imRef(g, x2, y2)) +
square(imRef(b, x1, y1)-imRef(b, x2, y2)));
}
void LMDirectionalIntegralDistanceImage::ComputeII(Image<float>* image)
{
int x, y;
Image<float> *tiimage = &iimage_;
for (x = 0 ; x <= width_ ; x++)
{
imRef(tiimage,x,0) = 0;
//cvSetReal2D(iimage_,0,x,0);
//WriteFloat(iimage_,x,0) = 0;
}
for (y = 0 ; y <= height_ ; y++)
{
imRef(tiimage,0,y) = 0;
//cvSetReal2D(iimage_,y,0,0);
//WriteFloat(iimage_,0,y) = 0;
}
if (xindexed_)
{
int miny, maxy;
int py, cy;
if (indices_[width_-1]> 0 )
{
miny = -indices_[width_-1];
maxy = height_;
}
else
{
miny = 0;
maxy = height_-indices_[width_-1];
}
for (y=miny ; y<=maxy ; y++)
{
for (x=1 ; x<width_ ; x++)
{
py = y+indices_[x-1];
cy = y+indices_[x];
if (cy > 0 && cy < height_-1)
{
imRef(tiimage,x,cy) = imRef(tiimage,x-1,py)+imRef(image,x,cy);
//cvSetReal2D( iimage_, cy, x,cvGetReal2D(iimage_,py,x-1) + cvGetReal2D(image,cy,x));
//WriteFloat( iimage_, x , cy) = ReadFloat(iimage_,x-1,py) + ReadFloat(image,x,cy);
}
}
}
}
else
{
int minx, maxx;
int px, cx;
if (indices_[height_-1]> 0 )
{
minx = -indices_[height_-1];
maxx = width_;
}
else
{
minx = 0;
maxx = width_-indices_[height_-1];
}
for (x=minx ; x<=maxx ; x++)
{
for (y=1 ; y<height_; y++)
{
px = x+indices_[y-1];
cx = x+indices_[y];
if (cx > 0 && cx < width_-1)
{
imRef(tiimage,cx,y) = imRef(tiimage,px,y-1) + imRef(image,cx,y);
//cvSetReal2D( iimage_, y, cx,cvGetReal2D(iimage_,y-1,px) + cvGetReal2D(image,y,cx));
//WriteFloat( iimage_, cx , y) = ReadFloat(iimage_,px,y-1) + ReadFloat(image,cx,y);
}
}
}
}
}
/*
* Segment an image
*
* Returns a color image representing the segmentation.
* JASPER: Random is replaced by just an index.
*
* im: image to segment.
* sigma: to smooth the image.
* c: constant for treshold function.
* min_size: minimum component size (enforced by post-processing stage).
* num_ccs: number of connected components in the segmentation.
*/
double *segment_image_index(image<rgb> *im, float sigma, float c, int min_size,
int *num_ccs) {
int width = im->width();
int height = im->height();
image<float> *r = new image<float>(width, height);
image<float> *g = new image<float>(width, height);
image<float> *b = new image<float>(width, height);
// smooth each color channel
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(r, x, y) = imRef(im, x, y).r;
imRef(g, x, y) = imRef(im, x, y).g;
imRef(b, x, y) = imRef(im, x, y).b;
}
}
image<float> *smooth_r = smooth(r, sigma);
image<float> *smooth_g = smooth(g, sigma);
image<float> *smooth_b = smooth(b, sigma);
delete r;
delete g;
delete b;
// build graph
edge *edges = new edge[width*height*4];
int num = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
if (x < width-1) {
edges[num].a = y * width + x;
edges[num].b = y * width + (x+1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x+1, y);
num++;
}
if (y < height-1) {
edges[num].a = y * width + x;
edges[num].b = (y+1) * width + x;
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x, y+1);
num++;
}
if ((x < width-1) && (y < height-1)) {
edges[num].a = y * width + x;
edges[num].b = (y+1) * width + (x+1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x+1, y+1);
num++;
}
if ((x < width-1) && (y > 0)) {
edges[num].a = y * width + x;
edges[num].b = (y-1) * width + (x+1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x+1, y-1);
num++;
}
}
}
delete smooth_r;
delete smooth_g;
delete smooth_b;
// segment
universe *u = segment_graph(width*height, num, edges, c);
// post process small components
for (int i = 0; i < num; i++) {
int a = u->find(edges[i].a);
int b = u->find(edges[i].b);
if ((a != b) && ((u->size(a) < min_size) || (u->size(b) < min_size)))
u->join(a, b);
}
delete [] edges;
*num_ccs = u->num_sets();
//image<rgb> *output = new image<rgb>(width, height);
// pick random colors for each component
double *colors = new double[width*height];
for (int i = 0; i < width*height; i++)
colors[i] = 0;
int idx = 1;
double* indexmap = new double[width * height];
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int comp = u->find(y * width + x);
if (!(colors[comp])){
colors[comp] = idx;
idx = idx + 1;
}
//imRef(output, x, y) = colors[comp];
indexmap[x * height + y] = colors[comp];
}
}
//mexPrintf("indexmap 0: %f\n", indexmap[0]);
//mexPrintf("indexmap 1: %f\n", indexmap[1]);
delete [] colors;
delete u;
return indexmap;
}
void mexFunction(int nlhs, mxArray *out[], int nrhs, const mxArray *input[])
{
// Checking number of arguments
if(nlhs > 3){
mexErrMsgTxt("Function has three return values");
return;
}
if(nrhs != 4){
mexErrMsgTxt("Usage: mexFelzenSegment(UINT8 im, double sigma, double c, int minSize)");
return;
}
if(!mxIsClass(input[0], "uint8")){
mexErrMsgTxt("Only image arrays of the UINT8 class are allowed.");
return;
}
// Load in arrays and parameters
UInt8* matIm = (UInt8*) mxGetPr(input[0]);
int nrDims = (int) mxGetNumberOfDimensions(input[0]);
int* dims = (int*) mxGetDimensions(input[0]);
double* sigma = mxGetPr(input[1]);
double* c = mxGetPr(input[2]);
double* minSize = mxGetPr(input[3]);
int min_size = (int) *minSize;
int height = dims[0];
int width = dims[1];
int imSize = height * width;
//SMANEN: Assertion
int nChannels = dims[2];
if(nChannels!=3){
mexErrMsgTxt("Felzenszwalb segmentation should be called for images with 3 channels.");
return;
}
int idx;
image<rgb>* theIm = new image<rgb>(width, height);
for (int x = 0; x < width; x++){
for (int y = 0; y < height; y++){
idx = x * height + y;
imRef(theIm, x, y).r = matIm[idx];
imRef(theIm, x, y).g = matIm[idx + imSize];
imRef(theIm, x, y).b = matIm[idx + 2 * imSize];
}
}
//SMANEN: Delete this
/*mexPrintf("Warning: Saving passed image as a test. Delete/comment this afterwards.\n");
srand(time(NULL));
double r=rand();
char filename[50];
sprintf(filename,"seg_%f.dat",r);
mexPrintf("Warning: Saving in file %s\n",filename);
std::ofstream myfile;
myfile.open (filename);
for (int x = 0; x < width; x++){
for (int y = 0; y < height; y++){
idx = x * height + y;
myfile<<(int)static_cast<unsigned char>(matIm[idx])<<"\n";
myfile<<(int)static_cast<unsigned char>(matIm[idx + imSize])<<"\n";
myfile<<(int)static_cast<unsigned char>(matIm[idx + 2 * imSize])<<"\n";
}
}
myfile.close();*/
// KOEN: Disable randomness of the algorithm
//srand(12345);
// Call Felzenswalb segmentation algorithm
int num_css;
//image<rgb>* segIm = segment_image(theIm, *sigma, *c, min_size, &num_css);
double* segIndices = segment_image_index(theIm, *sigma, *c, min_size, &num_css);
//mexPrintf("numCss: %d\n", num_css);
// The segmentation index image
out[0] = mxCreateDoubleMatrix(dims[0], dims[1], mxREAL);
double* outSegInd = mxGetPr(out[0]);
// Keep track of minimum and maximum of each blob
out[1] = mxCreateDoubleMatrix(num_css, 4, mxREAL);
double* minmax = mxGetPr(out[1]);
for (int i=0; i < num_css; i++)
minmax[i] = dims[0];
for (int i= num_css; i < 2 * num_css; i++)
minmax[i] = dims[1];
// Keep track of neighbouring blobs using square matrix
out[2] = mxCreateDoubleMatrix(num_css, num_css, mxREAL);
double* nn = mxGetPr(out[2]);
// Copy the contents of segIndices
// Keep track of neighbours
// Get minimum and maximum
// These actually comprise of the bounding boxes
double currDouble;
int mprev, curr, prevHori, mcurr;
for(int x = 0; x < width; x++){
mprev = segIndices[x * height]-1;
for(int y=0; y < height; y++){
//mexPrintf("x: %d y: %d\n", x, y);
idx = x * height + y;
//mexPrintf("idx: %d\n", idx);
//currDouble = segIndices[idx];
//mexPrintf("currDouble: %d\n", currDouble);
curr = segIndices[idx];
//mexPrintf("curr: %d\n", curr);
outSegInd[idx] = curr; // copy contents
//mexPrintf("outSegInd: %f\n", outSegInd[idx]);
mcurr = curr-1;
// Get neighbours (vertical)
//mexPrintf("idx: %d", curr * num_css + mprev);
//mexPrintf(" %d\n", curr + num_css * mprev);
//mexPrintf("mprev: %d\n", mprev);
nn[(mcurr) * num_css + mprev] = 1;
nn[(mcurr) + num_css * mprev] = 1;
// Get horizontal neighbours
//mexPrintf("Get horizontal neighbours\n");
if (x > 0){
prevHori = outSegInd[(x-1) * height + y] - 1;
nn[mcurr * num_css + prevHori] = 1;
nn[mcurr + num_css * prevHori] = 1;
}
// Keep track of min and maximum index of blobs
//mexPrintf("Keep track of min and maximum index\n");
if (minmax[mcurr] > y)
minmax[mcurr] = y;
if (minmax[mcurr + num_css] > x)
minmax[mcurr + num_css] = x;
if (minmax[mcurr + 2 * num_css] < y)
minmax[mcurr + 2 * num_css] = y;
if (minmax[mcurr + 3 * num_css] < x)
minmax[mcurr + 3 * num_css] = x;
//mexPrintf("Mprev = mcurr");
mprev = mcurr;
}
}
// Do minmax plus one for Matlab
for (int i=0; i < 4 * num_css; i++)
minmax[i] += 1;
delete theIm;
delete [] segIndices;
mexPrintf("#########################################################\n");
return;
}
int main(int argc, char **argv) {
if (argc != 5) {
fprintf(stderr, "usage: %s input (without .ppm) output (without .ppm) nbimages ratio \n", argv[0]);
return 1;
}
// (1) variables declarations
char * imname = new char[100];
char * outname = new char[100];
char * appel = new char[1000];
// (2) reading arguments
int nb_images = atoi(argv[3]);
int start=1;
int i;
sprintf(imname, "%s0%004d.ppm", argv[1], start);
sprintf(outname, "%s0%004d.ppm", argv[2], start);
float ratio = atof(argv[4]);
printf("%s\n",imname);
image<rgb> *input;
// (3) loading first image
printf("loading input image.\n");
input = loadPPM(imname);
int width = input->width();
int height = input->height();
int N = width*height;
image<rgb> *output= new image<rgb>((int)(width/ratio), (int)(height/ratio));
for (i=start;i<=nb_images;i++) {
sprintf(imname, "%s0%004d.ppm",argv[1], i);
sprintf(outname, "%s0%004d.ppm",argv[2], i);
input = loadPPM(imname);
int moy_r, moy_g, moy_b, norm;
for (int y = 0; y < height/2; y++) {
for (int x = 0; x < width/2; x++) {
moy_r = imRef(input, x*2,y*2).r;
moy_g = imRef(input, x*2,y*2).g;
moy_b = imRef(input, x*2,y*2).b;
norm = 1;
if (x*2+1<width) {
moy_r += imRef(input, x*2+1,y*2).r;
moy_g += imRef(input, x*2+1,y*2).g;
moy_b += imRef(input, x*2+1,y*2).b;
norm++;}
if (y*2+1<height) {
moy_r += imRef(input, x*2,y*2+1).r;
moy_g += imRef(input, x*2,y*2+1).g;
moy_b += imRef(input, x*2,y*2+1).b;
norm++;}
if ((x*2+1<width) && (y*2+1<height)) {
moy_r += imRef(input, x*2+1,y*2+1).r;
moy_g += imRef(input, x*2+1,y*2+1).g;
moy_b += imRef(input, x*2+1,y*2+1).b;
norm++; }
imRef(output, x,y).r = moy_r/norm;
imRef(output, x,y).g = moy_g/norm;
imRef(output, x,y).b = moy_b/norm;
}
}
savePPM(output, outname);
}
printf("done.\n");
return 0;
}
void Match::SubPixelColor(RGBImage Im, RGBImage ImMin, RGBImage ImMax)
{
Coord p;
int I, I1, I2, I3, I4, I_min, I_max;
for (p.y=0; p.y<im_size.y; p.y++)
for (p.x=0; p.x<im_size.x; p.x++)
{
/* red component */
I = I_min = I_max = imRef(Im, p.x, p.y).r;
if (p.x>0) I1 = (imRef(Im, p.x-1, p.y).r + I) / 2;
else I1 = I;
if (p.x<im_size.x-1) I2 = (imRef(Im, p.x+1, p.y).r + I) / 2;
else I2 = I;
if (p.y>0) I3 = (imRef(Im, p.x, p.y-1).r + I) / 2;
else I3 = I;
if (p.y<im_size.y-1) I4 = (imRef(Im, p.x, p.y+1).r + I) / 2;
else I4 = I;
if (I_min > I1) I_min = I1;
if (I_min > I2) I_min = I2;
if (I_min > I3) I_min = I3;
if (I_min > I4) I_min = I4;
if (I_max < I1) I_max = I1;
if (I_max < I2) I_max = I2;
if (I_max < I3) I_max = I3;
if (I_max < I4) I_max = I4;
imRef(ImMin, p.x, p.y).r = I_min;
imRef(ImMax, p.x, p.y).r = I_max;
/* green component */
I = I_min = I_max = imRef(Im, p.x, p.y).g;
if (p.x>0) I1 = (imRef(Im, p.x-1, p.y).g + I) / 2;
else I1 = I;
if (p.x<im_size.x-1) I2 = (imRef(Im, p.x+1, p.y).g + I) / 2;
else I2 = I;
if (p.y>0) I3 = (imRef(Im, p.x, p.y-1).g + I) / 2;
else I3 = I;
if (p.y<im_size.y-1) I4 = (imRef(Im, p.x, p.y+1).g + I) / 2;
else I4 = I;
if (I_min > I1) I_min = I1;
if (I_min > I2) I_min = I2;
if (I_min > I3) I_min = I3;
if (I_min > I4) I_min = I4;
if (I_max < I1) I_max = I1;
if (I_max < I2) I_max = I2;
if (I_max < I3) I_max = I3;
if (I_max < I4) I_max = I4;
imRef(ImMin, p.x, p.y).g = I_min;
imRef(ImMax, p.x, p.y).g = I_max;
/* blue component */
I = I_min = I_max = imRef(Im, p.x, p.y).b;
if (p.x>0) I1 = (imRef(Im, p.x-1, p.y).b + I) / 2;
else I1 = I;
if (p.x<im_size.x-1) I2 = (imRef(Im, p.x+1, p.y).b + I) / 2;
else I2 = I;
if (p.y>0) I3 = (imRef(Im, p.x, p.y-1).b + I) / 2;
else I3 = I;
if (p.y<im_size.y-1) I4 = (imRef(Im, p.x, p.y+1).b + I) / 2;
else I4 = I;
if (I_min > I1) I_min = I1;
if (I_min > I2) I_min = I2;
if (I_min > I3) I_min = I3;
if (I_min > I4) I_min = I4;
if (I_max < I1) I_max = I1;
if (I_max < I2) I_max = I2;
if (I_max < I3) I_max = I3;
if (I_max < I4) I_max = I4;
imRef(ImMin, p.x, p.y).b = I_min;
imRef(ImMax, p.x, p.y).b = I_max;
}
}
void segment_image(const cv::Mat& src_img, float sigma, float c, int min_size, int *num_ccs, cv::Mat& dst_img)
{
image<rgb>* im = convertfromMat(src_img);
int width = im->width();
int height = im->height();
image<float> *r = new image<float>(width, height);
image<float> *g = new image<float>(width, height);
image<float> *b = new image<float>(width, height);
// smooth each color channel
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(r, x, y) = imRef(im, x, y).r;
imRef(g, x, y) = imRef(im, x, y).g;
imRef(b, x, y) = imRef(im, x, y).b;
}
}
image<float> *smooth_r = smooth(r, sigma);
image<float> *smooth_g = smooth(g, sigma);
image<float> *smooth_b = smooth(b, sigma);
delete r;
delete g;
delete b;
// build graph
edge *edges = new edge[width*height*4];
int num = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
if (x < width-1) {
edges[num].a = y * width + x;
edges[num].b = y * width + (x+1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x+1, y);
num++;
}
if (y < height-1) {
edges[num].a = y * width + x;
edges[num].b = (y+1) * width + x;
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x, y+1);
num++;
}
if ((x < width-1) && (y < height-1)) {
edges[num].a = y * width + x;
edges[num].b = (y+1) * width + (x+1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x+1, y+1);
num++;
}
if ((x < width-1) && (y > 0)) {
edges[num].a = y * width + x;
edges[num].b = (y-1) * width + (x+1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x+1, y-1);
num++;
}
}
}
delete smooth_r;
delete smooth_g;
delete smooth_b;
// segment
universe *u = segment_graph(width*height, num, edges, c);
// post process small components
for (int i = 0; i < num; i++) {
int a = u->find(edges[i].a);
int b = u->find(edges[i].b);
if ((a != b) && ((u->size(a) < min_size) || (u->size(b) < min_size)))
u->join(a, b);
}
delete [] edges;
*num_ccs = u->num_sets();
dst_img = cv::Mat(src_img.size(), CV_32SC1);
// std::map<int,int> key_values;
int idx = 0;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
dst_img.at<int>(y,x) = u->find(y * width + x);
}
}
delete u;
}
int SegmentImage(const image<RGB_f> *im, image<int> *segIdx, float sigma, float c, int min_size)
{
int width = im->width();
int height = im->height();
image<float> *r = new image<float>(width, height);
image<float> *g = new image<float>(width, height);
image<float> *b = new image<float>(width, height);
// smooth each color channel
for (int y = 0; y < height; y++) for (int x = 0; x < width; x++) {
imRef(r, x, y) = imRef(im, x, y).r;
imRef(g, x, y) = imRef(im, x, y).g;
imRef(b, x, y) = imRef(im, x, y).b;
}
image<float> *smooth_r = smooth(r, sigma);
image<float> *smooth_g = smooth(g, sigma);
image<float> *smooth_b = smooth(b, sigma);
delete r;
delete g;
delete b;
// build graph
edge *edges = new edge[width*height * 4];
int num = 0;
for (int y = 0; y < height; y++) for (int x = 0; x < width; x++) {
if (x < width - 1) {
edges[num].a = y * width + x;
edges[num].b = y * width + (x + 1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x + 1, y);
num++;
}
if (y < height - 1) {
edges[num].a = y * width + x;
edges[num].b = (y + 1) * width + x;
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x, y + 1);
num++;
}
if ((x < width - 1) && (y < height - 1)) {
edges[num].a = y * width + x;
edges[num].b = (y + 1) * width + (x + 1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x + 1, y + 1);
num++;
}
if ((x < width - 1) && (y > 0)) {
edges[num].a = y * width + x;
edges[num].b = (y - 1) * width + (x + 1);
edges[num].w = diff(smooth_r, smooth_g, smooth_b, x, y, x + 1, y - 1);
num++;
}
}
delete smooth_r;
delete smooth_g;
delete smooth_b;
universe *u = segment_graph(width*height, num, edges, c); // segment
// post process small components
for (int i = 0; i < num; i++) {
int a = u->find(edges[i].a), b = u->find(edges[i].b);
if ((a != b) && ((u->size(a) < min_size) || (u->size(b) < min_size)))
u->join(a, b);
}
delete[] edges;
map<int, int> marker;
// = new image<int>(width, height);
int idxNum = 0;
for (int y = 0; y < height; y++) {
int *imgIdx = segIdx->access[y];
for (int x = 0; x < width; x++) {
int comp = u->find(y * width + x);
if (marker.find(comp) == marker.end())
marker[comp] = idxNum++;
imgIdx[x] = marker[comp];
}
}
assert(idxNum == u->num_sets());
delete u;
return idxNum;
}
int main(int argc, char **argv) {
if (argc < 6) {
fprintf(stderr, "usage: %s nbimages ratio_horizontal ratio_vertical input1 (without .ppm) input2 (without .ppm) \n", argv[0]);
return 1;
}
// (1) variables declarations
char * imname = new char[100];
char * imname2 = new char[100];
char * outname = new char[100];
char * appel = new char[1000];
// (2) reading arguments
int nb_images = atoi(argv[1]);
int start=1;
int i;
sprintf(imname, "%s0%004d.ppm", argv[4], start);
sprintf(imname2, "%s0%004d.ppm", argv[5], start);
int ratio_horizontal = atoi(argv[2]);
int ratio_vertical = atoi(argv[3]);
printf("%s\n",imname);
image<rgb> *input; image<rgb> *input2;
// (3) loading first image
printf("loading input image.\n");
input = loadPPM(imname);
int width = input->width();
int height = input->height();
int N = width*height;
image<rgb> *big = new image<rgb>(width*ratio_horizontal, height*ratio_vertical);
for (i=start;i<=nb_images;i++) {
sprintf(imname, "%s0%004d.ppm",argv[4], i);
sprintf(imname2, "%s0%004d.ppm",argv[5], i);
sprintf(outname, "%sout-0%004d.ppm", argv[5], i);
input = loadPPM(imname);
input2 = loadPPM(imname2);
if(ratio_vertical==2){
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(big,x,y) = imRef(input, x,y);
imRef(big,x,y+height) = imRef(input2, x,y);
}
}
}
else if(ratio_horizontal==2){
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
imRef(big,x,y) = imRef(input, x,y);
imRef(big,x+width,y) = imRef(input2, x,y);
}
}
}
savePPM(big, outname);
sprintf(appel, "convert %s %s.png ;", outname, outname );
system(appel);
}
printf("done.\n");
return 0;
}
void LFLineFitter::FitLine(Image<unsigned char> *inputImage)
{
//LARGE_INTEGER t1, t2, f;
//QueryPerformanceFrequency(&f);
//QueryPerformanceCounter(&t1);
width_ = inputImage->width();
height_ = inputImage->height();
map<int,Point<int> > edgeMap;
int i,j,k;
int x0,y0;
int width,height;
int index=0;
int nPixels=0;
int nEdges=0;
int maxSupport=0;
LFLineSegment tmpLs,bestLs;
Point<double> lnormal;
int nWindPoints=0,nWaitingKillingList=0,nProposedKillingList=0;
Point<int> *windPoints,*waitingKillingList,*proposedKillingList;
windPoints = new Point<int> [nMaxWindPoints_];
waitingKillingList = new Point<int>[nMaxWindPoints_];
proposedKillingList = new Point<int>[nMaxWindPoints_];
width = inputImage->width();
height = inputImage->height();
nPixels = width*height;
for(int y=0;y<height;y++)
{
for(int x=0;x<width;x++)
{
i = x + y*width;
//if(cvGetReal1D(inputImage,i)!=0)
if(imRef(inputImage,x,y)!=0)
{
edgeMap.insert(pair<int,Point<int> >(i,Point<int>(x,y)));
nEdges++;
}
}
}
nInputEdges_ = nEdges;
nLineSegments_=0;
for(k=0;k<2;k++)
{
if(nEdges<nMinEdges_)
break;
for(i=0;i<nLinesToFitInStage_[k];i++)
{
maxSupport = 0;
for(j=0;j<nTrialsPerLineInStage_[k];j++)
{
// Sample a point
index = SampleAPixel(&edgeMap,inputImage,nPixels);
y0 = index/width;
x0 = index - y0*width;
// Locate the subwindow
Find(x0,y0,windPoints,nWindPoints,inputImage,smallLocalWindowSize_);
// Infer a line direction
FitALine(nWindPoints,windPoints,sigmaFitALine_,lnormal);
// Locate the subwindow
Find(&edgeMap,x0,y0,windPoints,nWindPoints,inputImage,localWindSize_);
// Find the support
FindSupport(nWindPoints,windPoints,lnormal,sigmaFindSupport_,maxGap_,tmpLs,proposedKillingList,nProposedKillingList,x0,y0);
// Check if need to update
if(tmpLs.nSupport_ > maxSupport)
{
maxSupport = tmpLs.nSupport_;
nWaitingKillingList = nProposedKillingList;
memcpy(waitingKillingList,proposedKillingList,sizeof(Point<int>)*nWaitingKillingList);
bestLs = tmpLs;
}
}
// Remove points
for(j=0;j<maxSupport;j++)
{
//cvSetReal2D(inputImage,waitingKillingList[j].y,waitingKillingList[j].x,0.0);
imRef(inputImage,waitingKillingList[j].x,waitingKillingList[j].y) = 0;
edgeMap.erase(waitingKillingList[j].y*width+waitingKillingList[j].x);
}
nEdges -= bestLs.nSupport_;
bestLs.len_ = sqrt( (bestLs.sx_-bestLs.ex_)*(bestLs.sx_-bestLs.ex_) + (bestLs.sy_-bestLs.ey_)*(bestLs.sy_-bestLs.ey_));
outEdgeMap_[nLineSegments_] = bestLs;
nLineSegments_++;
if(nEdges<nMinEdges_)
break;
}
}
MMFunctions::Sort(outEdgeMap_,nLineSegments_,0);
delete [] windPoints;
delete [] waitingKillingList;
delete [] proposedKillingList;
edgeMap.clear();
////////QueryPerformanceCounter(&t2);
//cout<<"[DO] Fit "<<nLineSegments_<<" lines taking "<<setiosflags(ios::fixed)<<setprecision(6)<<(t2.QuadPart - t1.QuadPart)/(1.0*f.QuadPart)<<"seconds"<<endl;
}
