int main (int argc,char *argv[])
{
static char FuncName[]= {"SUMA_inflate_compare"};
SUMA_SurfSpecFile Spec;
char *specfilename = NULL;
int kar, id;
SUMA_Boolean brk;
SUMA_Boolean SurfIn = NOPE;
SUMA_SurfaceObject *Surf1 = NULL, *Surf2=NULL;
char *Surf1_FileName = NULL;
char *Surf2_FileName = NULL;
char *Vol1Parent_FileName=NULL;
char *Vol2Parent_FileName=NULL;
/* for SureFit surface */
SUMA_SFname *Surf1_SFName = NULL, *Surf2_SFName = NULL;
/* other variables */
int i;
int num_nodes1;
int num_nodes2;
float P0[3];
float delta_t;
float P1[3];
float N0[3];
float maxdistance, mindistance;
float *distance;
float Points[2][3]= { {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}}, p1[3]= {0.0, 0.0, 0.0}, p2[3]= {0.0, 0.0, 0.0};
SUMA_COLOR_MAP *MyColMap;
SUMA_SCALE_TO_MAP_OPT *MyOpt;
SUMA_COLOR_SCALED_VECT * MySV;
SUMA_MT_INTERSECT_TRIANGLE *triangle;
SUMA_SURF_NORM SN1;
SUMA_SURF_NORM SN2;
SUMA_SurfaceObject *SO1, *SO2;
struct timeval tt;
FILE *colorfile;
FILE *distancefile;
char colorfilename[1000];
char distancefilename[1000];
char *tag1 = NULL;
char *tag2 = NULL;
char *state1 = NULL;
char *state2 = NULL;
char *hemi = NULL;
float B_dim[3];
SUMA_ISINBOX isin;
SUMA_PATCH *Patch=NULL;
SUMA_Boolean TryFull = NOPE, FullOnly;
SUMA_MEMBER_FACE_SETS *Memb = NULL;
int *FaceSet_tmp;
int N_FaceSet_tmp;
char *fout = NULL;
int inflation = 10; /* inflation in mm */
/* allocate space for CommonFields structure */
SUMAg_CF = SUMA_Create_CommonFields ();
if (SUMAg_CF == NULL) {
fprintf(SUMA_STDERR,"Error %s: Failed in SUMA_Create_CommonFields\n", FuncName);
exit(1);
}
if (argc < 5) {
cmp_surf_usage();
exit (1);
}
/* read in the surfaces */
kar = 1;
brk = NOPE;
SurfIn = NOPE;
FullOnly = YUP;
while (kar < argc) {
/* loop accross command line options */
if ((strcmp(argv[kar], "-h") == 0) || (strcmp(argv[kar], "-help") == 0)) {
cmp_surf_usage ();
exit (1);
}
if (!brk && (strcmp(argv[kar], "-hemi")) == 0) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -hemi");
exit (1);
}
hemi = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-prefix")) == 0) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -prefix");
exit (1);
}
fout = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-spec")) == 0) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -spec ");
exit (1);
}
specfilename = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-box")) == 0) {
kar ++;
if (kar+2 >= argc) {
fprintf (SUMA_STDERR, "need 3 arguments after -box");
exit (1);
}
B_dim[0] = atof(argv[kar]);
kar ++;
B_dim[1] = atof(argv[kar]);
kar ++;
B_dim[2] = atof(argv[kar]);
FullOnly = NOPE;
brk = YUP;
}
if (!brk) {
fprintf (SUMA_STDERR,"Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]);
exit (1);
}
else {
brk = NOPE;
kar ++;
}
}/* loop across command line options */
if (specfilename == NULL) {
fprintf (SUMA_STDERR,"Error %s: No spec filename specified.\n", FuncName);
exit(1);
}
if (!SUMA_AllocSpecFields(&Spec)) {
SUMA_S_Err("Failed to allocate spec fields");
exit(1);
}
if (!SUMA_Read_SpecFile (specfilename, &Spec)) {
fprintf(SUMA_STDERR,"Error %s: Error in SUMA_Read_SpecFile\n", FuncName);
exit(1);
}
/**** loading the first surface *****/
if (SUMA_iswordin(Spec.SurfaceType[0], "FreeSurfer") == 1) {
Surf1_FileName = Spec.SurfaceFile[0];
Surf1 = SUMA_Load_Surface_Object(Surf1_FileName, SUMA_FREE_SURFER, SUMA_ASCII, Vol1Parent_FileName);
tag1 = "FS";
}
else if (SUMA_iswordin(Spec.SurfaceType[0], "SureFit") == 1) {
Surf1_SFName = SUMA_malloc(sizeof(SUMA_SFname));
strcpy(Surf1_SFName->name_coord,Spec.CoordFile[0]);
strcpy(Surf1_SFName->name_topo, Spec.TopoFile[0]);
strcpy(Surf1_SFName->name_param, Spec.SureFitVolParam[0]);
Surf1 = SUMA_Load_Surface_Object(Surf1_SFName, SUMA_SUREFIT, SUMA_ASCII,Vol1Parent_FileName);
tag1 = "SF";
}
state1 = Spec.State[0];
/**** loading the second surface *****/
if (SUMA_iswordin(Spec.SurfaceType[0], "FreeSurfer") == 1) {
Surf2_FileName = Spec.SurfaceFile[0];
Surf2 = SUMA_Load_Surface_Object(Surf1_FileName, SUMA_FREE_SURFER, SUMA_ASCII, Vol1Parent_FileName);
tag2 = "FS";
}
else if (SUMA_iswordin(Spec.SurfaceType[0], "SureFit") == 1) {
Surf2_SFName = SUMA_malloc(sizeof(SUMA_SFname));
strcpy(Surf2_SFName->name_coord,Spec.CoordFile[0]);
strcpy(Surf2_SFName->name_topo, Spec.TopoFile[0]);
strcpy(Surf2_SFName->name_param, Spec.SureFitVolParam[0]);
Surf2 = SUMA_Load_Surface_Object(Surf1_SFName, SUMA_SUREFIT, SUMA_ASCII,Vol1Parent_FileName);
tag2 = "SF";
}
state2 = Spec.State[0];
if (fout == NULL) { /* form default name */
sprintf(distancefilename, "dist_%s_%s_%s_%dmm.txt",hemi,tag1,state1,inflation);
sprintf(colorfilename, "dist_%s_%s_%s_%dmm.col",hemi,tag1,state1,inflation);
}
else {
sprintf (colorfilename, "%s.col", fout);
sprintf (distancefilename, "%s.txt", fout);
}
if (SUMA_filexists(colorfilename) || SUMA_filexists(distancefilename)) {
fprintf (SUMA_STDERR,"Error %s: One or both of output files %s, %s exists.\nWill not overwrite.\n", \
FuncName, distancefilename, colorfilename);
exit(1);
}
/***********************************************************************************************/
SO1 = Surf1;
SO2 = Surf2;
/*SUMA_Print_Surface_Object ( SO1, NULL);
SUMA_Print_Surface_Object ( SO2, NULL);*/
num_nodes1 = SO1->N_Node;
num_nodes2 = SO2->N_Node;
fprintf(SUMA_STDERR, "Number of nodes in surface 1: %d \n", num_nodes1);
fprintf(SUMA_STDERR, "Number of nodes in surface 2: %d \n", num_nodes2);
SN1 = SUMA_SurfNorm(SO1->NodeList, SO1->N_Node, SO1->FaceSetList, SO1->N_FaceSet);
/* Take each node in the SO1-> Nodelist and its corresponding SN1->NodeNormList. This is the normalized normal vector to the node on the first surface.
So each node is P0. P1 is computed as some point along the normal vector to that node. Lets say P1 is P0 + 10 mm along the normal.
Write out P1 as a surface */
/* for each node on the first surface do the following */
SUMA_etime (&tt, 0);
for (i = 0; i < num_nodes1; i++) {
id = SO1->NodeDim * i;
P0[0] = SO1->NodeList[id];
P0[1] = SO1->NodeList[id+1];
P0[2] = SO1->NodeList[id+2];
N0[0] = SN1.NodeNormList[id];
N0[1] = SN1.NodeNormList[id+1];
N0[2] = SN1.NodeNormList[id+2];
SUMA_POINT_AT_DISTANCE(N0, P0, 10, Points);
P1[0] = Points[0][0];
P1[1] = Points[0][1];
P1[2] = Points[0][2];
// fprintf(SUMA_STDERR,"P0 values: %f\t%f\t%f, P1 values: %f\t%f\t%f\n", P0[0],P0[1],P0[2],P1[0],P1[1],P1[2]);
/* Saving the new surfaces */
SO2->NodeList[id] = P1[0];
SO2->NodeList[id+1] = P1[1];
SO2->NodeList[id+2] = P1[2];
}
/* Now use SO1 and SO2 as the two surfaces and compute the distance */
SN1 = SUMA_SurfNorm(SO1->NodeList, SO1->N_Node, SO1->FaceSetList, SO1->N_FaceSet);
SN2 = SUMA_SurfNorm(SO2->NodeList, SO2->N_Node, SO2->FaceSetList, SO2->N_FaceSet);
if (!FullOnly) {
/* get the Node member structure */
fprintf(SUMA_STDOUT, "%s: Computing MemberFaceSets... \n", FuncName);
Memb = SUMA_MemberFaceSets (SO2->N_Node, SO2->FaceSetList, SO2->N_FaceSet, 3, SO2->idcode_str);
if (Memb->NodeMemberOfFaceSet == NULL) {
fprintf(SUMA_STDERR, "Error %s: Failed in SUMA_MemberFaceSets. \n", FuncName);
exit(1);
}
}
/* Take each node in the SO1-> Nodelist and its corresponding SN1->NodeNormList. This is the normalized normal vector to the node on the first surface.
So each node is P0. P1 is computed as some point along the normal vector to that node. Lets say P1 is P0 + 10 mm along the normal. */
/* for each node on the first surface do the following */
SUMA_etime (&tt, 0);
distance = SUMA_malloc(num_nodes1*sizeof(float));
for (i = 0; i < num_nodes1; i++) {
//for (i = 0; i < 10; i++) {
id = SO1->NodeDim * i;
P0[0] = SO1->NodeList[id];
P0[1] = SO1->NodeList[id+1];
P0[2] = SO1->NodeList[id+2];
N0[0] = SN1.NodeNormList[id];
N0[1] = SN1.NodeNormList[id+1];
N0[2] = SN1.NodeNormList[id+2];
SUMA_POINT_AT_DISTANCE(N0, P0, 1000, Points);
P1[0] = Points[0][0];
P1[1] = Points[0][1];
P1[2] = Points[0][2];
if (!FullOnly) {
/* trying to speed up intersection computations
by restricting it to nodes within a box */
TryFull = NOPE;
/* search for nodes on surface 2 within xx mm of P0 */
isin = SUMA_isinbox (SO2->NodeList, SO2->N_Node, P0, B_dim, 0);
if (isin.nIsIn) {
/* find the patch of surface 2 that is formed by those intersection nodes */
Patch = SUMA_getPatch ( isin.IsIn, isin.nIsIn,
SO2->N_Node, SO2->FaceSetList, SO2->N_FaceSet,
Memb, 1, 0, 1);
if (Patch == NULL) {
fprintf(SUMA_STDERR,
"Error %s: Null returned from SUMA_getPatch.\n", FuncName);
exit (1);
}
/* Perform the intersection based on that patch using Shruti's version */
FaceSet_tmp = Patch->FaceSetList;
N_FaceSet_tmp = Patch->N_FaceSet;
} else {
fprintf (SUMA_STDOUT,
"%s: No nodes in box about node %d. \n"
"Trying for full surface intersection.\n", FuncName, i);
TryFull = YUP; /* flag to send it to full intersection */
}
}
if (FullOnly || TryFull) {
Patch = NULL;
FaceSet_tmp = SO2->FaceSetList;
N_FaceSet_tmp = SO2->N_FaceSet;
}
/*now try with the segment from Points[0] to Points[1] returned above. */
p1[0] = Points[0][0];
p1[1] = Points[0][1];
p1[2] = Points[0][2];
p2[0] = Points[1][0];
p2[1] = Points[1][1];
p2[2] = Points[1][2];
triangle = SUMA_MT_intersect_triangle(p1,p2, SO2->NodeList, SO2->N_Node, SO2->FaceSetList, SO2->N_FaceSet, NULL, 0);
//SUMA_Show_MT_intersect_triangle(triangle, NULL);
if (triangle->N_hits ==0) {
distance[i] = -1;
// fprintf(SUMA_STDERR, "Could not find hit for node %d in either direction.\n", i);
}
else {
distance[i] = sqrtf( pow(triangle->P[0]-P0[0],2)+
pow(triangle->P[1]-P0[1],2)+
pow(triangle->P[2]-P0[2],2) );
/* fprintf(SUMA_STDERR, "distance is : %f\n", distance[i]); */
}
SUMA_Free_MT_intersect_triangle(triangle);
if (Patch) SUMA_freePatch(Patch);
/* calculating the time elapsed and remaining */
if (!(i%100)) {
delta_t = SUMA_etime(&tt, 1);
fprintf (SUMA_STDERR,
" [%d]/[%d] %.2f/100%% completed. "
"Dt = %.2f min done of %.2f min total\r" ,
i, num_nodes1, (float)i / num_nodes1 * 100,
delta_t/60, delta_t/i * num_nodes1/60);
}
}
/* write out the distance file */
if((distancefile = fopen(distancefilename, "w"))==NULL) {
fprintf(SUMA_STDERR, "Could not open file distance.txt.\n");
exit(1);
}
else {
for (i=0; i < num_nodes1; ++i) {
fprintf (distancefile,"%d\t%f\n", i, distance[i]);
}
fclose (distancefile);
}
/* output this distance as a color file */
MyColMap = SUMA_FindNamedColMap("byr64");
MyOpt = SUMA_ScaleToMapOptInit();
MySV = SUMA_Create_ColorScaledVect(num_nodes1, 0);
mindistance = minimum(num_nodes1, distance);
maxdistance = maximum(num_nodes1, distance);
SUMA_ScaleToMap(distance,num_nodes1,mindistance, maxdistance,
MyColMap,MyOpt,MySV);
/* write out the distance color file */
if((colorfile = fopen(colorfilename, "w"))==NULL) {
fprintf(SUMA_STDERR, "Could not open file distance.col.\n");
exit(1);
}
else {
for (i=0; i < num_nodes1; ++i) {
fprintf (colorfile,
"%d\t%f\t%f\t%f\n",
i, MySV->cV[3*i ], MySV->cV[3*i+1], MySV->cV[3*i+2]);
}
fclose (colorfile);
}
if (!SUMA_FreeSpecFields(&Spec)) {
SUMA_S_Err("Failed to free spec fields");
}
if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1);
return 1;
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"SurfPatch"};
SUMA_GETPATCH_OPTIONS *Opt;
char *ppref=NULL, ext[5];
float *far=NULL;
MRI_IMAGE *im = NULL;
int SO_read = -1;
int *NodePatch=NULL, N_NodePatch=-1, *FaceSetList=NULL ,
N_FaceSet = -1, N_Node = -1, N_Spec=0;
int i, inodeoff=-1, ilabeloff=-1, nvec, ncol, cnt;
SUMA_SurfaceObject *SO = NULL;
SUMA_PATCH *ptch = NULL;
SUMA_SurfSpecFile *Spec;
SUMA_INDEXING_ORDER d_order;
void *SO_name = NULL;
SUMA_Boolean exists = NOPE;
SUMA_SO_File_Type typetmp;
SUMA_SurfaceObject *SOnew = NULL;
float *NodeList = NULL;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-spec;-s;-sv;");
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
Opt = SUMA_GetPatch_ParseInput (argv, argc, ps);
if (argc < 2)
{
SUMA_S_Err("Too few options");
usage_SUMA_getPatch(ps, 0);
exit (1);
}
/* read all surfaces */
Spec = SUMA_IO_args_2_spec(ps, &N_Spec);
if (N_Spec == 0) {
SUMA_S_Err("No surfaces found.");
exit(1);
}
if (N_Spec > 1 ) {
SUMA_S_Err( "Mike, you cannot mix -spec with -i or -t options "
"for specifying surfaces.");
exit(1);
}
if (Spec->N_Surfs < 1) {
SUMA_S_Err("No surfaces");
exit(1);
}
if (Opt->DoVol && Spec->N_Surfs != 2) {
SUMA_S_Errv("Must specify 2 and only 2 surfaces with -vol options\n"
"Have %d from the command line\n",Spec->N_Surfs);
exit(1);
}
if (Opt->oType != SUMA_FT_NOT_SPECIFIED && !Opt->VolOnly) {
for (i=0; i < Spec->N_Surfs; ++i) {
if (Spec->N_Surfs > 1) {
sprintf(ext, "_%c", 65+i);
ppref = SUMA_append_string(Opt->out_prefix, ext);
} else {
ppref = SUMA_copy_string(Opt->out_prefix);
}
SO_name = SUMA_Prefix2SurfaceName(ppref, NULL, NULL,
Opt->oType, &exists);
if (exists && !THD_ok_overwrite()) {
fprintf(SUMA_STDERR, "Error %s:\nOutput file(s) %s* on disk.\n"
"Will not overwrite.\n", FuncName, ppref);
exit(1);
}
if (ppref) SUMA_free(ppref); ppref = NULL;
if (SO_name) SUMA_free(SO_name); SO_name = NULL;
}
}
/* read in the file containing the node information */
im = mri_read_1D (Opt->in_name);
if (!im) {
SUMA_S_Errv("Failed to read 1D file '%s'\n", Opt->in_name);
exit(1);
}
far = MRI_FLOAT_PTR(im);
nvec = im->nx;
ncol = im->ny;
if (Opt->nodecol >= ncol || Opt->labelcol >= ncol) {
fprintf(SUMA_STDERR, "\n"
"Error %s: Input file has a total of %d columns.\n"
"One or both user-specified node (%d) and \n"
"label (%d) columns are too high. Maximum usable\n"
"column index is %d.\n"
, FuncName, ncol, Opt->nodecol,
Opt->labelcol, ncol -1 );
exit(1);
}
d_order = SUMA_COLUMN_MAJOR;
if (!nvec) {
SUMA_SL_Err("Empty file");
exit(1);
}
/* form the node vector */
NodePatch = (int *)SUMA_malloc(sizeof(int)*nvec);
if (!NodePatch) {
SUMA_SL_Crit("Failed to allocate.");
exit(1);
}
inodeoff = Opt->nodecol*nvec;
if (Opt->labelcol < 0) { /* all listed nodes */
for (i=0; i<nvec; ++i) {
NodePatch[i] = far[i+inodeoff];
}
N_NodePatch = nvec;
} else {
ilabeloff = Opt->labelcol*nvec;
if (Opt->thislabel < 0) { /* all nodes with non zero labels */
cnt = 0;
for (i=0; i<nvec; ++i) {
if (far[i+ilabeloff]) {
NodePatch[cnt] = far[i+inodeoff];
++cnt;
}
}
N_NodePatch = cnt;
} else { /* select labels */
cnt = 0;
for (i=0; i<nvec; ++i) {
if (far[i+ilabeloff] == Opt->thislabel) {
NodePatch[cnt] = far[i+inodeoff];
++cnt;
}
}
N_NodePatch = cnt;
}
NodePatch = (int *) SUMA_realloc(NodePatch , sizeof(int)*N_NodePatch);
}
/* done with im, free it */
mri_free(im); im = NULL;
if (Opt->DoVol) {
SUMA_SurfaceObject *SO1 =
SUMA_Load_Spec_Surf_with_Metrics(Spec, 0, ps->sv[0], 0);
SUMA_SurfaceObject *SO2 =
SUMA_Load_Spec_Surf_with_Metrics(Spec, 1, ps->sv[0], 0);
double Vol = 0.0;
SUMA_SurfaceObject *SOp = SUMA_Alloc_SurfObject_Struct(1);
byte *adj_N=NULL;
if (Opt->adjust_contour)
adj_N = SUMA_calloc(SO1->N_Node, sizeof(byte));
if (!SO1 || !SO2) {
SUMA_SL_Err("Failed to load surfaces.");
exit(1);
}
/* a chunk used to test SUMA_Pattie_Volume */
Vol = SUMA_Pattie_Volume(SO1, SO2, NodePatch, N_NodePatch,
SOp, Opt->minhits,
Opt->FixBowTie, Opt->adjust_contour,
adj_N, Opt->verb);
fprintf (SUMA_STDOUT,"Volume = %f\n", fabs(Vol));
if (Opt->out_volprefix) {
if (Opt->oType != SUMA_FT_NOT_SPECIFIED) SOp->FileType = Opt->oType;
if (Opt->flip) {
if (Opt->verb > 1)
SUMA_S_Note("Flipping stitched surf's triangles\n");
SUMA_FlipSOTriangles (SOp);
}
if (!(SUMA_Save_Surface_Object_Wrap ( Opt->out_volprefix, NULL,
SOp, SUMA_PLY, SUMA_ASCII,
NULL))) {
fprintf (SUMA_STDERR,
"Error %s: Failed to write surface object.\n", FuncName);
}
if (Opt->adjust_contour && adj_N) {
Opt->out_volprefix =
SUMA_append_replace_string(Opt->out_volprefix,
".adjneighb","",1);
ppref = SUMA_Extension(Opt->out_volprefix, ".1D.dset", NOPE);
SUMA_WRITE_IND_ARRAY_1D(adj_N, NULL, SO1->N_Node, 1, ppref);
SUMA_free(ppref); ppref=NULL;
}
}
if (SOp) SUMA_Free_Surface_Object(SOp); SOp = NULL;
}
if (!Opt->VolOnly) {
FaceSetList = NULL;
N_FaceSet = -1;
for (i=0; i < Spec->N_Surfs; ++i) {/* loop to read in surfaces */
/* now identify surface needed */
if (!(SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, i, ps->sv[0], 0))) {
SUMA_S_Err("Failed to load surface .\n");
exit(1);
}
if (SO->aSO) {
/* otherwise, when you reset the number of FaceSets for example,
and you still write in GIFTI, the old contents of aSO will
prevail */
SO->aSO = SUMA_FreeAfniSurfaceObject(SO->aSO);
}
/* extract the patch */
ptch = SUMA_getPatch (NodePatch, N_NodePatch, SO->N_Node,
SO->FaceSetList, SO->N_FaceSet,
SO->MF, Opt->minhits,
Opt->FixBowTie, (!i && !Opt->DoVol));
/* verbose only for first patch, and
if no volume computation was required
This is to keep the warnings to a minimum*/
if (!ptch) {
SUMA_SL_Err("Failed to form patch.");
exit(1);
}
if (LocalHead) SUMA_ShowPatch(ptch, NULL);
/* Now create a surface with that patch */
if (Spec->N_Surfs > 1) {
sprintf(ext, "_%c", 65+i);
ppref = SUMA_append_string(Opt->out_prefix, ext);
} else {
ppref = SUMA_copy_string(Opt->out_prefix);
}
/* save the original type */
typetmp = SO->FileType;
if (Opt->oType != SUMA_FT_NOT_SPECIFIED) SO->FileType = Opt->oType;
SO_name = SUMA_Prefix2SurfaceName(ppref, NULL, NULL,
SO->FileType, &exists);
if (ppref) SUMA_free(ppref); ppref = NULL;
/* save the original pointers to the facesets and their number */
FaceSetList = SO->FaceSetList;
N_FaceSet = SO->N_FaceSet;
NodeList = SO->NodeList;
N_Node = SO->N_Node;
/* replace with Patch */
SO->FaceSetList = ptch->FaceSetList;
SO->N_FaceSet = ptch->N_FaceSet;
if (Opt->Do_p2s) {
if (LocalHead)
fprintf (SUMA_STDERR,
"%s: Changing patch to surface...\n", FuncName);
SOnew = SUMA_Patch2Surf(SO->NodeList, SO->N_Node,
SO->FaceSetList, SO->N_FaceSet, 3);
if (!SOnew) {
SUMA_S_Err("Failed to change patch to surface.");
exit(1);
}
SO->FaceSetList = SOnew->FaceSetList;
SO->N_FaceSet = SOnew->N_FaceSet;
SO->N_Node = SOnew->N_Node;
SO->NodeList = SOnew->NodeList;
}
if (SO->N_FaceSet <= 0) {
SUMA_S_Warn("The patch is empty.\n"
" Non existing surface not written to disk.\n");
} else {
/* Is the gain wanted? */
if (Opt->coordgain) {
SUMA_SL_Note("Applying coord gain to surface nodes!");
for (cnt=0; cnt < SO->NodeDim*SO->N_Node; ++cnt)
SO->NodeList[cnt] *= Opt->coordgain;
}
if (Opt->flip) {
if (Opt->verb > 1) SUMA_S_Note("Flipping triangles\n");
SUMA_FlipTriangles (SO->FaceSetList, SO->N_FaceSet);
SUMA_RECOMPUTE_NORMALS(SO);
}
if (!SUMA_Save_Surface_Object (SO_name, SO, SO->FileType,
SUMA_ASCII, NULL)) {
fprintf (SUMA_STDERR,
"Error %s: Failed to write surface object.\n",
FuncName);
exit (1);
}
}
/* bring SO back to shape */
SO->FileType = typetmp;
SO->FaceSetList = FaceSetList; FaceSetList = NULL;
SO->N_FaceSet = N_FaceSet; N_FaceSet = -1;
SO->NodeList = NodeList; NodeList = NULL;
SO->N_Node = N_Node; N_Node = -1;
if (SO_name) SUMA_free(SO_name); SO_name = NULL;
if (ptch) SUMA_freePatch(ptch); ptch = NULL;
if (SOnew) SUMA_Free_Surface_Object(SOnew); SOnew = NULL;
/* get rid of old surface object */
}
}
SUMA_LH("clean up");
if (!SUMA_FreeSpecFields(Spec)) { SUMA_S_Err("Failed to free spec fields"); }
SUMA_free(Spec); Spec = NULL;
if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL;
if (Opt->out_volprefix) SUMA_free(Opt->out_volprefix);
Opt->out_volprefix = NULL;
if (Opt) SUMA_free(Opt);
if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) {
SUMA_SL_Err("DO Cleanup Failed!");
}
if (!SUMA_Free_CommonFields(SUMAg_CF)) {
SUMA_SL_Err("SUMAg_CF Cleanup Failed!");
}
SUMA_RETURN(0);
}
