void levelSet3Dfast(MATRIXD im, MATRIX init_mask, int max_its, double E, double T, double alpha,
MATRIX *seg0, MATRIX *tmap, MATRIXD *phi, long **ls_vols, int offset){
long dx = im.dx, dy = im.dy, dz = im.dz;
int *px, *py, *pz, *qx, *qy, *qz, k, tmap_it = 1;
MATRIX intTmp;
MATRIX intTmp2 = allocateMatrix(dx,dy,dz); // add a new temporary matrix
MATRIXD dblTmp = allocateMatrixD(dx,dy,dz);
MATRIXD gradPhi = allocateMatrixD(dx,dy,dz);
int minx, maxx, miny, maxy, minz, maxz;
*phi = allocateMatrixD(dx,dy,dz);
*seg0 = allocateMatrix(dx,dy,dz);
*tmap = allocateMatrix(dx,dy,dz);
*ls_vols = (long *)calloc(max_its,sizeof(long)); // initialized with 0
initializeMatrix(tmap,0);
initializeMatrix(seg0,0); // initialized with 0
initializeMatrix(&intTmp2,0); // initialized with 0
initializeGlobals4bwdist(dx,dy,dz,&px,&py,&pz,&qx,&qy,&qz,&intTmp);
createSignedDistanceMap(init_mask,phi,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: intTmp, dblTmp
findLimits(init_mask,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
for (k = 1; k <= max_its; k++){
calculateCurvature(*phi,&dblTmp,minx,maxx,miny,maxy,minz,maxz); // dblTmp keeps the curvatures
calculateF(im,dblTmp,&dblTmp,E,T,alpha,minx,maxx,miny,maxy,minz,maxz); // first dblTmp (input): curvatures, second dblTmp (output): F values
calculateGradPhi(*phi,dblTmp,&gradPhi,minx,maxx,miny,maxy,minz,maxz);
evolveCurve(phi,dblTmp,gradPhi,minx,maxx,miny,maxy,minz,maxz);
if (k % 50 == 0)
reinitializeDistanceFunction(phi,init_mask,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: init_mask, intTmp, dblTmp
(*ls_vols)[k-1] = selectNonpositive(*phi,&intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
if (k == 1){
selectNonpositive(*phi,seg0,minx,maxx,miny,maxy,minz,maxz);
copyMatrixWithLimits(tmap,*seg0,minx,maxx,miny,maxy,minz,maxz);
findLimits(*tmap,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
}
else if (k % 10 == 0){
selectNonpositive(*phi,&intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
updateMaps(tmap,intTmp2,*seg0,tmap_it,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
copyMatrixWithLimits(seg0,intTmp2,minx,maxx,miny,maxy,minz,maxz); // use the second temporarymatrix
tmap_it++;
findLimits(*tmap,offset,&minx,&maxx,&miny,&maxy,&minz,&maxz);
}
}
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
//selectNonpositive(*phi,seg0,minx,maxx,miny,maxy,minz,maxz); ???? (consider this modification if there are more problems)
freeMatrixD(gradPhi);
freeMatrixD(dblTmp);
freeMatrix(intTmp2);
freeGlobals4bwdist(px,py,pz,qx,qy,qz,intTmp);
}
Cell::Cell(int x, int y){
this->h = 0;
this->g = 0;
this->x = x;
this->y = y;
parent = NULL;
calculateF();
wall = false;
inSolution = false;
}
void levelSet3D(MATRIXD im, MATRIX init_mask, int max_its, double E, double T, double alpha,
MATRIX *seg0, MATRIX *tmap, MATRIXD *phi, long **ls_vols){
// some of these variables will be used as the local variables for other functions
// they are defined outside (like global variables) because we want to decrease the overhead
// corresponding to allocation and deallocation (since we have multiple calls for the same function
long dx = im.dx, dy = im.dy, dz = im.dz;
int *px, *py, *pz, *qx, *qy, *qz, k, tmap_it = 1;
MATRIX intTmp;
MATRIXD dblTmp = allocateMatrixD(dx,dy,dz);
MATRIXD gradPhi = allocateMatrixD(dx,dy,dz);
*phi = allocateMatrixD(dx,dy,dz);
*seg0 = allocateMatrix(dx,dy,dz);
*tmap = allocateMatrix(dx,dy,dz);
*ls_vols = (long *)calloc(max_its,sizeof(long)); // initialized with 0
initializeMatrix(tmap,0);
initializeGlobals4bwdist(dx,dy,dz,&px,&py,&pz,&qx,&qy,&qz,&intTmp);
createSignedDistanceMap(init_mask,phi,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: intTmp, dblTmp
for (k = 1; k <= max_its; k++){
calculateCurvature(*phi,&dblTmp,0,dx-1,0,dy-1,0,dz-1); // dblTmp keeps the curvatures
calculateF(im,dblTmp,&dblTmp,E,T,alpha,0,dx-1,0,dy-1,0,dz-1); // first dblTmp (input): curvatures, second dblTmp (output): F values
calculateGradPhi(*phi,dblTmp,&gradPhi,0,dx-1,0,dy-1,0,dz-1);
evolveCurve(phi,dblTmp,gradPhi,0,dx-1,0,dy-1,0,dz-1);
if (k % 50 == 0)
reinitializeDistanceFunction(phi,init_mask,px,py,pz,qx,qy,qz,intTmp,dblTmp); // temps: init_mask, intTmp, dblTmp
(*ls_vols)[k-1] = selectNonpositive(*phi,&intTmp,0,dx-1,0,dy-1,0,dz-1);
if (k == 1){
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
copyMatrix(tmap,*seg0);
}
else if (k % 10 == 0){
selectNonpositive(*phi,&intTmp,0,dx-1,0,dy-1,0,dz-1);
updateMaps(tmap,intTmp,*seg0,tmap_it,0,dx-1,0,dy-1,0,dz-1);
copyMatrix(seg0,intTmp);
tmap_it++;
}
}
selectNonpositive(*phi,seg0,0,dx-1,0,dy-1,0,dz-1);
freeMatrixD(gradPhi);
freeMatrixD(dblTmp);
freeGlobals4bwdist(px,py,pz,qx,qy,qz,intTmp);
}
// Calculate points C and F from A,B,D,E,P,Q
void calculateCFFromABDEPQ(Pair ab, Pair de, Pair pq, Vert &vertices,
std::set<std::vector<int>,CompareResults> &results) {
for (int c = 0; c < vertices.size(); ++c) {
if (!checkIfInPairs(ab, de, pq, c)) {
Point f;
if (calculateF(ab, de, pq, c, vertices, f)) {
int vertex_nr = isVertex(f, vertices);
if (vertex_nr != NOT_FOUND &&
!checkIfInPairs(ab, de, pq, vertex_nr)) {
//writePairs(ab, de, std::make_pair(c, vertex_nr));
addNewResult(ab, de, std::make_pair(c, vertex_nr), pq, results);
}
}
}
}
}
int patchAreaDistributionCV(int fd, char **par, area_des ad, double *result)
{
char *mapset;
double indice = 0;
struct Cell_head hd;
int ris = RLI_OK;
mapset = G_find_cell(ad->raster, "");
if (G_get_cellhd(ad->raster, mapset, &hd) == -1)
return RLI_ERRORE;
switch (ad->data_type) {
case CELL_TYPE:
{
ris = calculate(fd, ad, &indice);
break;
}
case DCELL_TYPE:
{
ris = calculateD(fd, ad, &indice);
break;
}
case FCELL_TYPE:
{
ris = calculateF(fd, ad, &indice);
break;
}
default:
{
G_fatal_error("data type unknown");
return RLI_ERRORE;
}
}
if (ris != RLI_OK) {
*result = -1;
return RLI_ERRORE;
}
*result = indice;
return RLI_OK;
}
int renyi(int fd, char **par, area_des ad, double *result)
{
int ris = RLI_OK;
double indice = 0;
struct Cell_head hd;
Rast_get_cellhd(ad->raster, "", &hd);
switch (ad->data_type) {
case CELL_TYPE:
{
ris = calculate(ad, fd, par, &indice);
break;
}
case DCELL_TYPE:
{
ris = calculateD(ad, fd, par, &indice);
break;
}
case FCELL_TYPE:
{
ris = calculateF(ad, fd, par, &indice);
break;
}
default:
{
G_fatal_error("data type unknown");
return RLI_ERRORE;
}
}
if (ris != RLI_OK)
return RLI_ERRORE;
*result = indice;
return RLI_OK;
}
int patchAreaDistributionRANGE(int fd, char **par, struct area_entry *ad,
double *result)
{
double indice = 0;
int ris = RLI_OK;
switch (ad->data_type) {
case CELL_TYPE:
{
ris = calculate(fd, ad, &indice);
break;
}
case DCELL_TYPE:
{
ris = calculateD(fd, ad, &indice);
break;
}
case FCELL_TYPE:
{
ris = calculateF(fd, ad, &indice);
break;
}
default:
{
G_fatal_error("data type unknown");
return RLI_ERRORE;
}
}
if (ris != RLI_OK) {
*result = -1;
return RLI_ERRORE;
}
*result = indice;
return RLI_OK;
}
