void insert_ellipsoid(const CImg<t>& tensor, const float X, const float Y, const float Z, const float tfact,
const float vx, const float vy, const float vz,
CImgList<tp>& points, CImgList<tf>& faces, CImgList<tc>& colors,
const unsigned int res1=20, const unsigned int res2=20) {
// Compute eigen elements
float l1 = tensor[0], l2 = tensor[1], l3 = tensor[2], fa = get_FA(l1,l2,l3);
CImg<> vec = CImg<>::matrix(tensor[3],tensor[6],tensor[9],
tensor[4],tensor[7],tensor[10],
tensor[5],tensor[8],tensor[11]);
const int
r = (int)cimg::min(30 + 1.5f*cimg::abs(255*fa*tensor[3]),255.0f),
g = (int)cimg::min(30 + 1.5f*cimg::abs(255*fa*tensor[4]),255.0f),
b = (int)cimg::min(30 + 1.5f*cimg::abs(255*fa*tensor[5]),255.0f);
// Define mesh points
const unsigned int N0 = points.size();
for (unsigned int v = 1; v<res2; v++)
for (unsigned int u = 0; u<res1; u++) {
const float
alpha = (float)(u*2*cimg::PI/res1),
beta = (float)(-cimg::PI/2 + v*cimg::PI/res2),
x = (float)(tfact*l1*std::cos(beta)*std::cos(alpha)),
y = (float)(tfact*l2*std::cos(beta)*std::sin(alpha)),
z = (float)(tfact*l3*std::sin(beta));
points.insert((CImg<tp>::vector(X,Y,Z) + vec*CImg<tp>::vector(x,y,z)).mul(CImg<tp>::vector(vx,vy,vz)));
}
const unsigned int N1 = points.size();
points.insert((CImg<tp>::vector(X,Y,Z) - vec*CImg<tp>::vector(0,0,l3*tfact)));
points.insert((CImg<tp>::vector(X,Y,Z) + vec*CImg<tp>::vector(0,0,l3*tfact)));
points[points.size() - 2](0)*=vx; points[points.size() - 2](1)*=vy; points[points.size() - 2](2)*=vz;
points[points.size() - 1](0)*=vx; points[points.size() - 1](1)*=vy; points[points.size() - 1](2)*=vz;
// Define mesh triangles
for (unsigned int vv = 0; vv<res2 - 2; ++vv)
for (unsigned int uu = 0; uu<res1; ++uu) {
const int nv = (vv + 1)%(res2 - 1), nu = (uu + 1)%res1;
faces.insert(CImg<tf>::vector(N0 + res1*vv + nu,N0 + res1*nv + uu,N0 + res1*vv + uu));
faces.insert(CImg<tf>::vector(N0 + res1*vv + nu,N0 + res1*nv + nu,N0 + res1*nv + uu));
colors.insert(CImg<tc>::vector(r,g,b));
colors.insert(CImg<tc>::vector(r,g,b));
}
for (unsigned int uu = 0; uu<res1; ++uu) {
const int nu = (uu + 1)%res1;
faces.insert(CImg<tf>::vector(N0 + nu,N0 + uu,N1));
faces.insert(CImg<tf>::vector(N0 + res1*(res2 - 2) + nu, N1 + 1,N0 + res1*(res2 - 2) + uu));
colors.insert(CImg<tc>::vector(r,g,b));
colors.insert(CImg<tc>::vector(r,g,b));
}
}
CImgList<uint8_t>* ph_getKeyFramesFromVideo(const char *filename){
long N = GetNumberVideoFrames(filename);
if (N < 0){
return NULL;
}
float frames_per_sec = 0.5*fps(filename);
if (frames_per_sec < 0){
return NULL;
}
int step = (int)(frames_per_sec + ROUNDING_FACTOR(frames_per_sec));
long nbframes = (long)(N/step);
float *dist = (float*)malloc((nbframes)*sizeof(float));
if (!dist){
return NULL;
}
CImg<float> prev(64,1,1,1,0);
VFInfo st_info;
st_info.filename = filename;
st_info.nb_retrieval = 100;
st_info.step = step;
st_info.pixelformat = 0;
st_info.pFormatCtx = NULL;
st_info.width = -1;
st_info.height = -1;
CImgList<uint8_t> *pframelist = new CImgList<uint8_t>();
if (!pframelist){
return NULL;
}
int nbread = 0;
int k=0;
do {
nbread = NextFrames(&st_info, pframelist);
if (nbread < 0){
delete pframelist;
free(dist);
return NULL;
}
unsigned int i = 0;
while ((i < pframelist->size()) && (k < nbframes)){
CImg<uint8_t> current = pframelist->at(i++);
CImg<float> hist = current.get_histogram(64,0,255);
float d = 0.0;
dist[k] = 0.0;
cimg_forX(hist,X){
d = hist(X) - prev(X);
d = (d>=0) ? d : -d;
dist[k] += d;
prev(X) = hist(X);
}
k++;
}
pframelist->clear();
} while ((nbread >= st_info.nb_retrieval)&&(k < nbframes));
//@ Toma una lista de imagenes y le aplica el umbral especificado a cada imagen
CImgList<bool> umbralizarLista(CImgList<double> l_img, double umbral) {
CImgList<bool> ret_val;
//Recorre la lista
for (unsigned int i = 0; i < l_img.size(); i++) {
//Temporal a pushear
CImg<bool> tempy(l_img[i].width(), l_img[i].height(), l_img[i].depth(), l_img[i].spectrum(), false);
//Recorre la imagen
cimg_forXY(l_img[i],x,y) {
if (fabs(l_img[i](x,y)) > umbral) {
tempy(x,y) = true;
}
}
ret_val.push_back(tempy);
}
return ret_val;
}
void insert_fiber(const CImg<T>& fiber, const CImg<te>& eigen, const CImg<tc>& palette,
const int xm, const int ym, const int zm,
const float vx, const float vy, const float vz,
CImgList<tp>& points, CImgList<tf>& primitives, CImgList<tc>& colors) {
const int N0 = points.size();
float x0 = fiber(0,0), y0 = fiber(0,1), z0 = fiber(0,2), fa0 = eigen.linear_atXYZ(x0,y0,z0,12);
points.insert(CImg<>::vector(vx*(x0 -xm),vy*(y0 - ym),vz*(z0 - zm)));
for (int l = 1; l<fiber.width(); ++l) {
float x1 = fiber(l,0), y1 = fiber(l,1), z1 = fiber(l,2), fa1 = eigen.linear_atXYZ(x1,y1,z1,12);
points.insert(CImg<tp>::vector(vx*(x1 - xm),vy*(y1 - ym),vz*(z1 - zm)));
primitives.insert(CImg<tf>::vector(N0 + l - 1,N0 + l));
const unsigned char
icol = (unsigned char)(fa0*255),
r = palette(icol,0),
g = palette(icol,1),
b = palette(icol,2);
colors.insert(CImg<unsigned char>::vector(r,g,b));
x0 = x1; y0 = y1; z0 = z1; fa0 = fa1;
}
}
//@ Aplica el operador derivada segun el parametro opcion
//0: Gradiente de Roberts
//1: Gradiente de Prewitt
//2: Gradiente de Sobel
//3: Laplaciano de 4 vecinos
//4: Laplaciano de 8 vecinos
//5: LoG, Laplaciano del Gaussiano
//Devuelve una lista con todos los resultados de aplicar todas las mascaras del operador en particular
CImgList<double> aplicarDerivada(CImg<double> img, unsigned int opcion = 0) {
CImgList<double> derivada;
if (opcion == 0)
derivada = operadorRoberts();
if (opcion == 1)
derivada = operadorPrewitt();
if (opcion == 2)
derivada = operadorSobel();
if (opcion == 3)
derivada = operadorLaplaciano4();
if (opcion == 4)
derivada = operadorLaplaciano8();
if (opcion == 5)
derivada = operadorLoG();
CImgList<double> resultados;
unsigned int cantidad = derivada.size();
for (unsigned int i = 0; i < cantidad; i++) {
resultados.push_back(img.get_convolve(derivada[i]));
}
return resultados;
}
// Main procedure
//----------------
int main (int argc, char **argv) {
cimg_usage("Compute the skeleton of a shape, using Hamilton-Jacobi equations");
// Read command line arguments
cimg_help("Input/Output options\n"
"--------------------");
const char* file_i = cimg_option("-i",cimg_imagepath "milla.bmp","Input (black&white) image");
const int median = cimg_option("-median",0,"Apply median filter");
const bool invert = cimg_option("-inv",false,"Invert image values");
const char* file_o = cimg_option("-o",(char*)0,"Output skeleton image");
const bool display = cimg_option("-visu",true,"Display results");
cimg_help("Skeleton computation parameters\n"
"-------------------------------");
const float thresh = cimg_option("-t",-0.3f,"Threshold");
const bool curve = cimg_option("-curve",false,"Create medial curve");
cimg_help("Torsello correction parameters\n"
"------------------------------");
const bool correction = cimg_option("-corr",false,"Torsello correction");
const float dlt1 = 2;
const float dlt2 = cimg_option("-dlt",1.0f,"Discrete step");
// Load the image (forcing it to be scalar with 2 values { 0,1 }).
CImg<unsigned int> image0(file_i), image = image0.get_norm().quantize(2).normalize(0.0f,1.0f);
if (median) image.blur_median(median);
if (invert) (image-=1)*=-1;
if (display) (image0.get_normalize(0,255),image.get_normalize(0,255)).display("Input image - Binary image");
// Compute distance map.
CImgList<float> visu;
CImg<float> distance = image.get_distance(0);
if (display) visu.insert(distance);
// Compute the gradient of the distance function, and the flux (divergence) of the gradient field.
const CImgList<float> grad = distance.get_gradient("xyz");
CImg<float> flux = image.get_flux(grad,1,1);
if (display) visu.insert(flux);
// Use the Torsello correction of the flux if necessary.
if (correction) {
CImg<float>
logdensity = image.get_logdensity(distance,grad,flux,dlt1),
nflux = image.get_corrected_flux(logdensity,grad,flux,dlt2);
if (display) visu.insert(logdensity).insert(nflux);
flux = nflux;
}
if (visu) {
cimglist_apply(visu,normalize)(0,255);
visu.display(visu.size()==2?"Distance function - Flux":"Distance function - Flux - Log-density - Corrected flux");
}
// Compute the skeleton
const CImg<unsigned int> skel = image.get_skeleton(flux,distance,curve,thresh);
if (display) {
(image0.resize(-100,-100,1,3)*=0.7f).get_shared_channel(1)|=skel*255.0;
image0.draw_image(0,0,0,0,image*255.0,0.5f).display("Image + Skeleton");
}
// Save output image if necessary.
if (file_o) skel.save(file_o);
return 0;
}