int main(int argc, char **argv) {
if(argc!= 5){
printf("Usage: diademAddScaleFromImage cloud.cl image cube_to_translate out.cl\n");
exit(0);
}
Cloud<Point3D>* orig = new Cloud<Point3D>(argv[1]);
Image<float>* scales = new Image<float> (argv[2]);
CubeF* cb = new CubeF (argv[3]);
Cloud<Point3Dw>* dest = new Cloud<Point3Dw>();
int x, y, z, nP;
for(nP = 0; nP < orig->points.size(); nP++){
cb->micrometersToIndexes3
(orig->points[nP]->coords[0], orig->points[nP]->coords[1], orig->points[nP]->coords[2],
x, y, z);
dest->points.push_back
(new Point3Dw(orig->points[nP]->coords[0],
orig->points[nP]->coords[1],
orig->points[nP]->coords[2],
scales->at(x,y)));
}
dest->saveToFile(argv[4]);
}
int main(int argc, char **argv) {
if(argc!=3){
printf("graphFindLeaves graph.gr leaves.cl\n");
exit(0);
}
Graph<Point3D, EdgeW<Point3D> >* gr =
new Graph<Point3D, EdgeW<Point3D> >(argv[1]);
Cloud<Point3D>* cl = new Cloud<Point3D>();
vector<int> pointsToAdd = gr->findLeaves();
for(int i = 0; i < pointsToAdd.size(); i++){
cl->addPoint(gr->cloud->points[pointsToAdd[i]]->coords[0],
gr->cloud->points[pointsToAdd[i]]->coords[1],
gr->cloud->points[pointsToAdd[i]]->coords[2]);
}
//Leaves are green
cl->v_r = 0;
cl->v_g = 1;
cl->v_b = 0;
cl->v_radius = 0.8;
cl->saveToFile(argv[2]);
}
int main(int argc, char **argv) {
struct arguments arguments;
/* Default values. */
arguments.verbose = 0;
arguments.outputFile = "out.cl";
arguments.cloudName = "";
arguments.volumeX = "";
arguments.volumeY = "";
arguments.volumeZ = "";
argp_parse (&argp, argc, argv, 0, 0, &arguments);
printf ("Cloud = %s\n OutputFile = %s\n",
arguments.cloudName.c_str(), arguments.outputFile.c_str());
//Code starts here
Cloud<Point3D>* cl = new Cloud<Point3D>(arguments.cloudName);
Cloud<Point3Do>* out = new Cloud<Point3Do>(arguments.outputFile);
Cube< float, double>* vx = new Cube<float, double>(arguments.volumeX);
Cube< float, double>* vy = new Cube<float, double>(arguments.volumeY);
Cube< float, double>* vz = new Cube<float, double>(arguments.volumeZ);
vector< int > idx(3);
vector< float > micr(3);
float theta, phi, r;
for(int i = 0; i < cl->points.size(); i++){
micr[0] = cl->points[i]->coords[0];
micr[1] = cl->points[i]->coords[1];
micr[2] = cl->points[i]->coords[2];
vx->micrometersToIndexes(micr, idx);
r = sqrt( vx->at(idx[0],idx[1],idx[2])*vx->at(idx[0],idx[1],idx[2]) +
vy->at(idx[0],idx[1],idx[2])*vy->at(idx[0],idx[1],idx[2]) +
vz->at(idx[0],idx[1],idx[2])*vz->at(idx[0],idx[1],idx[2]) );
theta = atan2(vy->at(idx[0],idx[1],idx[2]), vx->at(idx[0],idx[1],idx[2]));
phi = acos(vz->at(idx[0],idx[1],idx[2])/r);
Point3Do* pt = new Point3Do(micr[0], micr[1], micr[2],
theta, phi);
out->points.push_back(pt);
}
out->saveToFile(arguments.outputFile);
}
int main(int argc, char **argv) {
Cloud<Point3D>* cd = new Cloud<Point3D>();
cd->v_saveVisibleAttributes = true;
cd->loadFromFile("data/cloud.cl");
printf("Cloud loaded\n");
cd->saveToFile("data/cloud_copy.cl");
printf("Check manually that the files data/cloud.cl and data/cloud_copy.cl represent the same cloud\n");
Cloud<Point2D>* cd2 = new Cloud<Point2D>();
cd2->v_saveVisibleAttributes = true;
cd2->loadFromFile("data/cloud2D.cl");
printf("Cloud2D loaded\n");
cd2->saveToFile("data/cloud2D_copy.cl");
printf("Check manually that the files data/cloud2D.cl and data/cloud2D_copy.cl represent the same cloud\n");
}
int main(int argc, char **argv) {
struct arguments arguments;
/* Default values. */
arguments.flag_min = 0;
arguments.verbose = 0;
arguments.threshold = 0;
arguments.windowxy = 8;
arguments.windowz = 10;
arguments.flag_layer = 0;
arguments.flag_log = 0;
arguments.saveAsCloud = true;
arguments.somaDefined = false;
argp_parse (&argp, argc, argv, 0, 0, &arguments);
printf ("Volume = %s\nFile = %s\n"
"bool_min = %s\n"
"threshold = %f \n"
"saveAsCloud = %i \n",
arguments.args[0], arguments.args[1],
arguments.flag_min ? "yes" : "no",
arguments.threshold,
arguments.saveAsCloud
);
if(arguments.flag_log && arguments.flag_layer){
printf("Not yet implemented logarithmic decimation layer by layer\n");
}
Cube_P* cube = CubeFactory::load(arguments.args[0]);
if(arguments.flag_log){
cube->decimate_log(arguments.threshold, arguments.windowxy, arguments.windowz,
arguments.args[1], false);
}
if(!(arguments.flag_log || arguments.flag_layer)){
cube->decimate(arguments.threshold, arguments.windowxy, arguments.windowz,
arguments.args[1], false);
}
if(arguments.flag_layer){
// for(int z = 0; z <
// cube->decimate
printf("Lazy enough for not doing this and I do not see the point now\n");
}
if(arguments.saveAsCloud){
Cloud<Point3D >* cd = new Cloud<Point3D>();
vector< vector< double > > idxs = loadMatrix(arguments.args[1]);
// vector< int > indexes(3);
// vector< float > micrometers(3);
//The first point will be the soma
if(arguments.somaDefined){
cd->points.push_back
(new Point3D(arguments.somaX, arguments.somaY, arguments.somaZ));
}
for(int i = 0; i < idxs.size(); i++){
Point3D* pt = new Point3D( idxs[i][0],
idxs[i][1],
idxs[i][2]);
cd->points.push_back( pt );
}
// cd->v_radius = cube->voxelWidth;
cd->v_radius = 0.5;
cd->saveToFile(arguments.args[1]);
}
}
int main(int argc, char **argv) {
struct arguments arguments;
/* Default values. */
arguments.flag_min = 0;
arguments.verbose = 0;
arguments.threshold = 0.02;
arguments.windowxy = 8;
arguments.windowz = 10;
arguments.flag_layer = 0;
arguments.flag_log = 0;
arguments.saveAsCloud = true;
arguments.somaDefined = false;
argp_parse (&argp, argc, argv, 0, 0, &arguments);
string directory(arguments.args[0]);
float threshold = arguments.threshold;
printf ("Volume = %s\nFile = %s\n"
"bool_min = %s\n"
"threshold = %f \n"
"saveAsCloud = %i \n",
arguments.args[0], arguments.args[0],
arguments.flag_min ? "yes" : "no",
arguments.threshold,
arguments.saveAsCloud
);
// Cube<float, double>* c1 = new Cube<float, double>
// (directory + "/1/bf_2_3162.nfo");
// Cube<float, double>* c2 = new Cube<float, double>
// (directory + "/2/bf_2_3162.nfo");
// Cube<float, double>* c4 = new Cube<float, double>
// (directory + "/4/bf_2_3162.nfo");
// Cube<float, double>* c8 = new Cube<float, double>
// (directory + "/8/bf_2_3162.nfo");
// vector<Cube<float, double>*> thetas;
// vector<Cube<float, double>*> phis;
// thetas.push_back(new Cube<float, double>
// (directory + "/1/aguet_2.00_2.00_theta.nfo"));
// thetas.push_back(new Cube<float, double>
// (directory + "/2/aguet_2.00_2.00_theta.nfo"));
// thetas.push_back(new Cube<float, double>
// (directory + "/4/aguet_2.00_2.00_theta.nfo"));
// thetas.push_back(new Cube<float, double>
// (directory + "/8/aguet_2.00_2.00_theta.nfo"));
// phis.push_back(new Cube<float, double>
// (directory + "/1/aguet_2.00_2.00_phi.nfo"));
// phis.push_back(new Cube<float, double>
// (directory + "/2/aguet_2.00_2.00_phi.nfo"));
// phis.push_back(new Cube<float, double>
// (directory + "/4/aguet_2.00_2.00_phi.nfo"));
// phis.push_back(new Cube<float, double>
// (directory + "/8/aguet_2.00_2.00_phi.nfo"));
Cube<float, double>* c1 = new Cube<float, double>
(directory + "/C14_4_1-d.nfo");
Cube<float, double>* c2 = new Cube<float, double>
(directory + "/C14_4_2-d.nfo");
// (directory + "/2/bf_2_3162.nfo");
Cube<float, double>* c4 = new Cube<float, double>
(directory + "/C14_4_4-d.nfo");
// (directory + "/4/bf_2_3162.nfo");
Cube<float, double>* c8 = new Cube<float, double>
(directory + "/C14_4_4-d.nfo");
// (directory + "/8/bf_2_3162.nfo");
vector<Cube<float, double>*> thetas;
vector<Cube<float, double>*> phis;
thetas.push_back(new Cube<float, double>
(directory + "/C14_4_1-d_theta.nfo"));
// (directory + "/1/aguet_2.00_2.00_theta.nfo"));
thetas.push_back(new Cube<float, double>
(directory + "/C14_4_2-d_theta.nfo"));
// (directory + "/2/aguet_2.00_2.00_theta.nfo"));
thetas.push_back(new Cube<float, double>
(directory + "/C14_4_4-d_theta.nfo"));
// (directory + "/4/aguet_2.00_2.00_theta.nfo"));
thetas.push_back(new Cube<float, double>
(directory + "/C14_4_4-d_theta.nfo"));
// (directory + "/8/aguet_2.00_2.00_theta.nfo"));
phis.push_back(new Cube<float, double>
(directory + "/C14_4_1-d_phi.nfo"));
// (directory + "/1/aguet_2.00_2.00_phi.nfo"));
phis.push_back(new Cube<float, double>
(directory + "/C14_4_2-d_phi.nfo"));
// (directory + "/2/aguet_2.00_2.00_phi.nfo"));
phis.push_back(new Cube<float, double>
(directory + "/C14_4_4-d_phi.nfo"));
// (directory + "/4/aguet_2.00_2.00_phi.nfo"));
phis.push_back(new Cube<float, double>
(directory + "/C14_4_4-d_phi.nfo"));
// (directory + "/8/aguet_2.00_2.00_phi.nfo"));
vector< vector < float > > toReturn;
vector< int > toReturnScales;
vector< float > toReturnThetas;
vector< float > toReturnPhis;
int cubeCardinality = c1->cubeWidth*c1->cubeHeight*c1->cubeDepth;
bool* visitedPoints = (bool*)malloc(cubeCardinality*sizeof(bool));
for(int i = 0; i < cubeCardinality; i++)
visitedPoints[i] = false;
multimap< float, int > valueToCoordsC1;
multimap< float, int > valueToCoordsC2;
multimap< float, int > valueToCoordsC4;
multimap< float, int > valueToCoordsC8;
//Computes the min and the max
float min_c1, max_c1, min_c2, max_c2,min_c4, max_c4,min_c8, max_c8, min_c, max_c;
c1->min_max(&min_c1, &max_c1);
c2->min_max(&min_c2, &max_c2);
c4->min_max(&min_c4, &max_c4);
c8->min_max(&min_c8, &max_c8);
min_c = min(min_c1, min_c2);
min_c = min(min_c , min_c4);
min_c = min(min_c , min_c8);
max_c = max(max_c1, max_c2);
max_c = max(max_c , max_c4);
max_c = max(max_c , max_c8);
double step_size = (max_c - min_c) / 5;
double current_threshold = max_c - step_size;
int position = 0;
int positionInC1 = 0;
int ix, iy, iz;
float mx,my,mz;
printf("Cube<T,U>::decimate Creating the map[\n");
// Loop for the decimation
while(
(current_threshold > min_c) &&
(current_threshold > threshold - step_size)
){
if( fabs(threshold - current_threshold) < step_size)
current_threshold = threshold;
valueToCoordsC1.erase(valueToCoordsC1.begin(), valueToCoordsC1.end() );
valueToCoordsC2.erase(valueToCoordsC2.begin(), valueToCoordsC2.end() );
valueToCoordsC4.erase(valueToCoordsC4.begin(), valueToCoordsC4.end() );
valueToCoordsC8.erase(valueToCoordsC8.begin(), valueToCoordsC8.end() );
// Find the non-visited points above the threshold for C1
for(int z = 0; z < c1->cubeDepth; z++){
for(int y = 0; y < c1->cubeHeight; y++){
for(int x = 0; x < c1->cubeWidth; x++)
{
position = x + y*c1->cubeWidth + z*c1->cubeWidth*c1->cubeHeight;
if( (c1->at(x,y,z) > current_threshold) &&
(visitedPoints[position] == false))
{
valueToCoordsC1.insert(pair<float, int >(c1->at(x,y,z), position));
}
}
}
printf("Threshold: %f, Layer %02i and %07i points\r",
current_threshold, z, (int)valueToCoordsC1.size()); fflush(stdout);
}//z of c1
printf("\n");
// Find the non-visited points above the threshold for C2
for(int z = 0; z < c2->cubeDepth; z++){
for(int y = 0; y < c2->cubeHeight; y++){
for(int x = 0; x < c2->cubeWidth; x++)
{
if(c2->at(x,y,z) > current_threshold){
c2->indexesToMicrometers3(x,y,z,mx, my,mz);
c1->micrometersToIndexes3(mx,my,mz,ix,iy,iz);
position = ix + iy*c1->cubeWidth + iz*c1->cubeWidth*c1->cubeHeight;
if(visitedPoints[position] == false)
{
valueToCoordsC2.insert(pair<float, int >(c2->at(x,y,z), position));
}
}
}
}
printf("Threshold: %f, Layer %02i and %07i points\r",
current_threshold, z, (int)valueToCoordsC2.size()); fflush(stdout);
}//z of c2
printf("\n");
// Find the non-visited points above the threshold for C2
for(int z = 0; z < c4->cubeDepth; z++){
for(int y = 0; y < c4->cubeHeight; y++){
for(int x = 0; x < c4->cubeWidth; x++)
{
if(c4->at(x,y,z) > current_threshold){
c4->indexesToMicrometers3(x,y,z,mx, my,mz);
c1->micrometersToIndexes3(mx,my,mz,ix,iy,iz);
position = ix + iy*c1->cubeWidth + iz*c1->cubeWidth*c1->cubeHeight;
if(visitedPoints[position] == false)
{
valueToCoordsC4.insert(pair<float, int >(c4->at(x,y,z), position));
}
}
}
}
printf("Threshold: %f, Layer %02i and %07i points\r",
current_threshold, z, (int)valueToCoordsC4.size()); fflush(stdout);
}//z of c4
printf("\n");
// Find the non-visited points above the threshold for C2
for(int z = 0; z < c8->cubeDepth; z++){
for(int y = 0; y < c8->cubeHeight; y++){
for(int x = 0; x < c8->cubeWidth; x++)
{
if(c8->at(x,y,z) > current_threshold){
c8->indexesToMicrometers3(x,y,z,mx, my,mz);
c1->micrometersToIndexes3(mx,my,mz,ix,iy,iz);
position = ix + iy*c1->cubeWidth + iz*c1->cubeWidth*c1->cubeHeight;
if(visitedPoints[position] == false)
{
valueToCoordsC8.insert(pair<float, int >(c8->at(x,y,z), position));
}
}
}
}
printf("Threshold: %f, Layer %02i and %07i points\r",
current_threshold, z, (int)valueToCoordsC8.size()); fflush(stdout);
}//z of c8
printf("\n");
printf("The maps have been creared, now it is time to see what happens\n");
int nPointsToEvaluate =
valueToCoordsC1.size() + valueToCoordsC2.size() +
valueToCoordsC4.size() + valueToCoordsC8.size();
int nPointsEvaluated = 0;
int nPointsAdded = 0;
multimap< float, int >::reverse_iterator riterC1 = valueToCoordsC1.rbegin();
multimap< float, int >::reverse_iterator riterC2 = valueToCoordsC2.rbegin();
multimap< float, int >::reverse_iterator riterC4 = valueToCoordsC4.rbegin();
multimap< float, int >::reverse_iterator riterC8 = valueToCoordsC8.rbegin();
vector< float > values(4);
float maxVal;
int maxIdx, position, windowErase, z_p, x_p, y_p;
while(nPointsEvaluated < nPointsToEvaluate){
nPointsEvaluated++;
for(int i = 0; i < 4; i++)
values[i] = -1e8;
//Puts the values in the vector
if(riterC1!=valueToCoordsC1.rend()) values[0] = (*riterC1).first;
if(riterC2!=valueToCoordsC2.rend()) values[1] = (*riterC2).first;
if(riterC4!=valueToCoordsC4.rend()) values[2] = (*riterC4).first;
if(riterC8!=valueToCoordsC8.rend()) values[3] = (*riterC8).first;
maxIdx = 0; maxVal = values[0];
for(int i = 1; i < 4; i++){
if(values[i] > maxVal){
maxVal = values[i];
maxIdx = i;
}
}
if(maxIdx==0){ position = (*riterC1).second; riterC1++; windowErase = 30; }
if(maxIdx==1){ position = (*riterC2).second; riterC2++; windowErase = 35; }
if(maxIdx==2){ position = (*riterC4).second; riterC4++; windowErase = 40; }
if(maxIdx==3){ position = (*riterC8).second; riterC8++; windowErase = 40; }
if(visitedPoints[position] == true)
continue;
z_p = position / (c1->cubeWidth*c1->cubeHeight);
y_p = (position - z_p*c1->cubeWidth*c1->cubeHeight)/c1->cubeWidth;
x_p = position - z_p*c1->cubeWidth*c1->cubeHeight - y_p*c1->cubeWidth;
//To prevent the bug in the images
if(x_p<=5) continue;
int counter = 0;
for(int z = max(z_p-windowErase*2/3,0);
z < min(z_p+windowErase*2/3, (int)c1->cubeDepth); z++)
for(int y = max(y_p-windowErase,0); y < min(y_p+windowErase, (int)c1->cubeHeight); y++)
for(int x = max(x_p-windowErase,0); x < min(x_p+windowErase, (int)c1->cubeWidth); x++){
if(visitedPoints[x + y*c1->cubeWidth + z*c1->cubeWidth*c1->cubeHeight] == true)
counter++;
visitedPoints[x + y*c1->cubeWidth + z*c1->cubeWidth*c1->cubeHeight] = true;
}
//Only add the point if half of the points arround it have not been visited. Prevents small points to be added
if(counter > windowErase*windowErase*windowErase*2*2*2/2)
continue;
vector< float > coords(3);
c1->indexesToMicrometers3(x_p, y_p, z_p, coords[0], coords[1], coords[2]);
toReturn.push_back(coords);
toReturnScales.push_back(maxIdx);
thetas[maxIdx]->micrometersToIndexes3(coords[0], coords[1], coords[2],
x_p, y_p, z_p);
toReturnThetas.push_back(thetas[maxIdx]->at(x_p,y_p,z_p));
toReturnPhis.push_back(phis[maxIdx]->at(x_p,y_p,z_p));
nPointsAdded++;
// printf("nEval = %i of %i\n", nPointsEvaluated, nPointsToEvaluate);
} // while goinf throught the nms
printf("%i points have been added\n", nPointsAdded);
current_threshold = current_threshold - step_size;
}// While threshold
vector<float> radius(4);
radius[0] = 0.4;
radius[1] = 0.8;
radius[2] = 1.2;
radius[3] = 1.6;
Cloud<Point3D >* cd1 = new Cloud<Point3D>();
Cloud<Point3D >* cd2 = new Cloud<Point3D>();
Cloud<Point3D >* cd4 = new Cloud<Point3D>();
Cloud<Point3D >* cd8 = new Cloud<Point3D>();
Cloud<Point3D >* ct = new Cloud<Point3D>();
Cloud<Point3Dotw>* ctw = new Cloud<Point3Dotw>();
if(arguments.somaDefined){
ct->points.push_back
(new Point3D(arguments.somaX, arguments.somaY, arguments.somaZ));
ctw->points.push_back
(new Point3Dotw(arguments.somaX, arguments.somaY, arguments.somaZ,
Point3Dot::TrainingPositive, 5.0));
}
vector< Cloud< Point3D>*> clouds;
clouds.push_back(cd1); clouds.push_back(cd2);
clouds.push_back(cd4); clouds.push_back(cd8);
for(int i = 0; i < toReturn.size(); i++){
Point3D* pt = new Point3D( toReturn[i][0],
toReturn[i][1],
toReturn[i][2]);
clouds[toReturnScales[i]]->points.push_back( pt );
ct->points.push_back( pt );
ctw->points.push_back
(new Point3Dotw(toReturn[i][0], toReturn[i][1], toReturn[i][2],
toReturnThetas[i], toReturnPhis[i],
Point3Dot::TrainingPositive,
radius[toReturnScales[i]]));
}
cd1->v_r = 1; cd1->v_g = 0; cd1->v_b = 0; cd1->v_radius = radius[0];
cd2->v_r = 0; cd2->v_g = 1; cd2->v_b = 0; cd2->v_radius = radius[1];
cd4->v_r = 0; cd4->v_g = 0; cd4->v_b = 1; cd4->v_radius = radius[2];
cd8->v_r = 1; cd8->v_g = 1; cd8->v_b = 0; cd8->v_radius = radius[3];
cd1->saveToFile(directory + "/decimation_1.cl");
cd2->saveToFile(directory + "/decimation_2.cl");
cd4->saveToFile(directory + "/decimation_4.cl");
cd8->saveToFile(directory + "/decimation_8.cl");
ct->saveToFile (directory + "/decimated.cl");
ctw->saveToFile(directory + "/decimatedW.cl");
}
int main(int argc, char **argv) {
vector<int> idxs(3);
vector<float> microm(3);
char buff[1024];
// For the color
const gsl_rng_type * T2;
gsl_rng * r;
gsl_rng_env_setup();
T2 = gsl_rng_default;
r = gsl_rng_alloc (T2);
// Cube<uchar, ulong>* cube = new Cube<uchar, ulong>("/media/neurons/cut2/cut2.nfo");
// Cloud_P* decimatedCloud = CloudFactory::load("/media/neurons/cut2/decimated.cl");
Cube<float, double>* cube = new Cube<float, double>
("/media/neurons/steerableFilters3D/tmp/cut/cut.nfo");
Cloud_P* decimatedCloud = CloudFactory::load
("/media/neurons/steerableFilters3D/tmp/cut/dense.cl");
Cloud<Point3D>* seedPointsSelected = new Cloud<Point3D>();
DistanceDijkstraColorNegatedEuclidean* djkc
= new DistanceDijkstraColorNegatedEuclidean(cube);
CubeLiveWire* cubeLiveWire = new CubeLiveWire(cube, djkc);;
vector<int> origIdxs(3);
origIdxs[0] = 151;
origIdxs[1] = 152;
origIdxs[2] = 9;
if(fileExists("/media/neurons/steerableFilters3D/tmp/cut/parents.nfo") &&
fileExists("/media/neurons/steerableFilters3D/tmp/cut/distances.nfo")){
printf("Loading the distances .... ");fflush(stdout);
cubeLiveWire->loadParents("/media/neurons/steerableFilters3D/tmp/cut/parents.nfo");
cubeLiveWire->loadDistances("/media/neurons/steerableFilters3D/tmp/cut/distances.nfo");
} else{
printf("Computing the distances .... ");fflush(stdout);
cubeLiveWire->computeDistances(origIdxs[0],origIdxs[1],origIdxs[2]);
cubeLiveWire->saveParents("parents");
cubeLiveWire->saveDistances("distances");
}
printf(" distances done \n");
multimap<float, Graph<Point3D, EdgeW<Point3D> >*> paths;
Cloud< Point3D>* cloud = new Cloud<Point3D>();
cube->indexesToMicrometers(origIdxs,microm);
cloud->addPoint(microm[0],microm[1],microm[2]);
cloud->v_g = 1.0;
cloud->v_radius = 2.0;
cloud->saveToFile("/media/neurons/steerableFilters3D/tmp/cut/original.cl");
float cost;
printf("Finding the shortest paths from all points to the soma[");fflush(stdout);
for(int i = 0; i < decimatedCloud->points.size(); i++){
cube->micrometersToIndexes3(decimatedCloud->points[i]->coords[0],
decimatedCloud->points[i]->coords[1],
decimatedCloud->points[i]->coords[2],
idxs[0],idxs[1],idxs[2]);
Graph<Point3D, EdgeW<Point3D> >* shortestPath =
cubeLiveWire->findShortestPathG(origIdxs[0],origIdxs[1],origIdxs[2],
idxs[0],idxs[1],idxs[2]
);
cost = shortestPath->cloud->points.size() -
cube->integralOverCloud(shortestPath->cloud);
paths.insert(pair<float, Graph<Point3D, EdgeW<Point3D> >*>
( exp(cost/(shortestPath->cloud->points.size())), shortestPath));
if(i%100 == 0) printf("%02f]\r",
float(i*100)/decimatedCloud->points.size());fflush(stdout);
}
printf("\n");
// Saves the paths according to the minimum mean distance
if(1){
int nGraphSaved = 0;
for(multimap< float, Graph<Point3D, EdgeW<Point3D> >*>::iterator
iter = paths.begin();
iter != paths.end();
iter++){
Graph<Point3D, EdgeW<Point3D> >* gr = (*iter).second;
sprintf(buff, "/media/neurons/steerableFilters3D/tmp/cut/opath%04i.gr",
nGraphSaved++);
gr->v_r = gsl_rng_uniform(r);
gr->v_g = gsl_rng_uniform(r);
gr->v_b = gsl_rng_uniform(r);
gr->v_radius = 0.3;
gr->cloud->v_r = gsl_rng_uniform(r);
gr->cloud->v_g = gsl_rng_uniform(r);
gr->cloud->v_b = gsl_rng_uniform(r);
gr->cloud->v_radius = 0.3;
gr->saveToFile(buff);
if(nGraphSaved%100 == 0)
printf("Saving the %i path with size %i\n", nGraphSaved, gr->cloud->points.size());
}
}
// Getting the first 100 paths
multimap< float, Graph<Point3D, EdgeW<Point3D> >*>::iterator
iter = paths.begin();
int cubeLength = cube->cubeDepth*cube->cubeHeight*cube->cubeWidth;
int* visited_orig = (int*) malloc(cubeLength*sizeof(int));
int*** visited;
visited = (int***) malloc(cube->cubeDepth*sizeof(int**));
for(int z = 0; z < cube->cubeDepth; z++){
visited [z] = (int**) malloc(cube->cubeHeight*sizeof(int*));
for(int j = 0; j < cube->cubeHeight; j++){
visited[z][j] =(int*) &visited_orig [(z*cube->cubeHeight + j)*cube->cubeWidth];
}
}
for(int i = 0; i < cubeLength; i++)
visited_orig[i] = 0;
int limitEnd = decimatedCloud->points.size()-1;
// int limitEnd = 500 ;
int nGraphsAdded = 0;
int nGraphsRejected = 0;
while(nGraphsAdded < limitEnd){
iter = paths.begin();
Graph<Point3D, EdgeW<Point3D> >* gr = (*iter).second;
int nPoint = 0;
bool alreadyVisited = false;
//Check if there is a visited part of the path
for(nPoint = 0; nPoint < gr->cloud->points.size(); nPoint++){
microm[0] = gr->cloud->points[nPoint]->coords[0];
microm[1] = gr->cloud->points[nPoint]->coords[1];
microm[2] = gr->cloud->points[nPoint]->coords[2];
cube->micrometersToIndexes(microm, idxs);
if(visited[idxs[2]][idxs[1]][idxs[0]] == true){
alreadyVisited = true;
break; // we reached a visited voxel
}
}
//If the path has been already visited, we better forget of the visited part
// and add a new graph to the list
if(alreadyVisited){
Graph<Point3D, EdgeW<Point3D> >* toAdd = gr->subGraphToPoint(nPoint);
cost = toAdd->cloud->points.size() -
cube->integralOverCloud(toAdd->cloud);
if(nGraphsRejected%100 == 0)
printf("Rejected %i paths\n", nGraphsRejected++);
fflush(stdout);
nGraphsRejected++;
paths.erase(paths.begin());
paths.insert(pair<float, Graph<Point3D, EdgeW<Point3D> >*>
(exp(cost/(toAdd->cloud->points.size())), toAdd));
} else {
for(int i = 0; i < gr->cloud->points.size(); i++){
microm[0] = gr->cloud->points[i]->coords[0];
microm[1] = gr->cloud->points[i]->coords[1];
microm[2] = gr->cloud->points[i]->coords[2];
if( (i==0) ||
((i == gr->cloud->points.size()-1)&&(i>0))
)
seedPointsSelected->points.push_back
(new Point3D(microm[0],microm[1],microm[2]));
cube->micrometersToIndexes(microm, idxs);
visited[idxs[2]][idxs[1]][idxs[0]] = true;
visited[origIdxs[2]][origIdxs[1]][origIdxs[0]] = false;
}
gr->v_r = gsl_rng_uniform(r);
gr->v_g = gsl_rng_uniform(r);
gr->v_b = gsl_rng_uniform(r);
gr->v_radius = 0.3;
gr->cloud->v_r = gsl_rng_uniform(r);
gr->cloud->v_g = gsl_rng_uniform(r);
gr->cloud->v_b = gsl_rng_uniform(r);
gr->cloud->v_radius = 0.3;
// cost = cube->integralOverCloud(gr->cloud)/gr->cloud->points.size();
sprintf(buff, "/media/neurons/steerableFilters3D/tmp/cut/path%04i.gr",nGraphsAdded);
nGraphsAdded++;
gr->saveToFile(buff);
if(nGraphsAdded%100 == 0)
printf("Adding the %i path with size %i\n", nGraphsAdded, gr->cloud->points.size());
paths.erase(paths.begin());
}
}//while
seedPointsSelected->v_r = 1;
seedPointsSelected->v_g = 0;
seedPointsSelected->v_b = 1;
seedPointsSelected->v_radius = 0.7;
seedPointsSelected->saveToFile("/media/neurons/steerableFilters3D/tmp/cut/seedPointsSelected.cl");
// Saves the visited points into a cube
Cube<int, long>* visitedC =
new Cube<int, long>(cube->cubeWidth, cube->cubeHeight, cube->cubeDepth,
cube->directory + "visited",
cube->voxelWidth, cube->voxelHeight, cube->voxelDepth);
for(int x = 0; x < cube->cubeWidth; x++)
for(int y = 0; y < cube->cubeHeight; y++)
for(int z = 0; z < cube->cubeDepth; z++){
visitedC->put(x,y,z, visited[z][y][x]);
}
}//main
int main(int argc, char **argv) {
struct arguments args;
/* Default values. */
args.name_image = "";
args.name_orientation = "";
args.name_mask = "";
args.name_cloud = "cloud.cl";
args.flag_symmetrize = false;
args.number_negative_points = 0;
argp_parse (&argp, argc, argv, 0, 0, &args);
printf("Img: %s\nOrs: %s\nOut: %s\nMsk: %s\nSymmetrize: %i\nNumber_points: %i\n",
args.name_image.c_str(),
args.name_orientation.c_str(),
args.name_cloud.c_str(),
args.name_mask.c_str(),
args.flag_symmetrize, args.number_negative_points);
/** Random number generation.*/
gsl_rng_env_setup();
T2 = gsl_rng_default;
r = gsl_rng_alloc (T2);
Image< float >* img = new Image< float >(args.name_image);
Image< float >* orient = NULL;
Image< float >* mask = NULL;
if(args.name_orientation != "")
orient = new Image<float>(args.name_orientation);
if(args.name_mask != "")
mask = new Image<float>(args.name_mask);
vector< int > indexes(3);
vector< float > micrometers(3);
indexes[2] = 0;
vector< double > cumPDF = getCumulativePdf(img, mask);
// saveVectorDouble(cumPDF, "cumPDF.txt");
Cloud< Point2Dot >* cloud;
if(fileExists(args.name_cloud))
cloud = new Cloud< Point2Dot >(args.name_cloud);
else
cloud = new Cloud< Point2Dot >();
double ort = 0;
int nPoints = 0;
while(nPoints < args.number_negative_points){
int idx = sampleCumulativePdf(cumPDF, img);
indexes[1] = (int)idx/img->width;
indexes[0] = idx - img->width*indexes[1];
//If the mask is 0, then loop again
// if(mask != NULL)
// if(mask->at(indexes[0], indexes[1]) < 100)
// continue;
img->indexesToMicrometers(indexes, micrometers);
if(orient == NULL){
ort = (gsl_rng_uniform(r)-0.5)*2*M_PI;
} else {
ort = orient->at(indexes[0], indexes[1]);
}
cloud->points.push_back(new Point2Dot(micrometers[0], micrometers[1],
ort, -1));
nPoints++;
if(args.flag_symmetrize){
cloud->points.push_back(new Point2Dot(micrometers[0], micrometers[1],
ort + M_PI, -1));
nPoints++;
}
}
cloud->saveToFile(args.name_cloud);
}