static int
most_frequent_label(MRI *mri_seg, MRI_SEGMENT *mseg)
{
int label_counts[MAX_CMA_LABELS], i, max_count, max_label, label ;
memset(label_counts, 0, sizeof(label_counts)) ;
for (i = max_count = max_label = 0 ; i < mseg->nvoxels ; i++)
{
label = MRIgetVoxVal(mri_seg,
mseg->voxels[i].x,
mseg->voxels[i].y,
mseg->voxels[i].z, 0) ;
if (IS_WM(label) == 0 && IS_UNKNOWN(label) == 0)
{
label_counts[label]++ ;
}
}
for (i = max_count = max_label = 0 ; i < MAX_CMA_LABELS ; i++)
{
if (label_counts[i] > max_count)
{
max_count = label_counts[i] ;
max_label = i ;
}
}
return(max_label) ;
}
/**
* gst_video_colorimetry_to_string:
* @cinfo: a #GstVideoColorimetry
*
* Make a string representation of @cinfo.
*
* Returns: a string representation of @cinfo.
*/
gchar *
gst_video_colorimetry_to_string (GstVideoColorimetry * cinfo)
{
gint i;
for (i = 0; colorimetry[i].name; i++) {
if (IS_EQUAL (&colorimetry[i], cinfo)) {
return g_strdup (colorimetry[i].name);
}
}
if (!IS_UNKNOWN (cinfo)) {
return g_strdup_printf ("%d:%d:%d:%d", cinfo->range, cinfo->matrix,
cinfo->transfer, cinfo->primaries);
}
return NULL;
}
inline_static int setup_all_presets(struct wininfo *hwinfo)
{
int pnum, s;
char note[100];
if (IS_UNKNOWN(hwinfo))
{
fprintf(stderr,"PAPI doesn't support this chipset?\n");
abort();
}
if (IS_AMDATHLON(hwinfo) || IS_AMDDURON(hwinfo))
_papi_hwd_preset_map = k7_preset_map;
else if (IS_P4(hwinfo))
{
fprintf(stderr,"PAPI doesn't support the P4 yet...\n");
abort();
}
else
_papi_hwd_preset_map = p6_preset_map;
for (pnum = 0; pnum < PAPI_MAX_PRESET_EVENTS; pnum++)
{
if ((s = _papi_hwd_preset_map[pnum].selector))
{
if (_papi_hwi_system_info.num_cntrs == 2)
{
sprintf(note,"0x%x,0x%x",
_papi_hwd_preset_map[pnum].counter_cmd.evntsel[0],
_papi_hwd_preset_map[pnum].counter_cmd.evntsel[1]);
strcat(_papi_hwd_preset_map[pnum].note,note);
}
else if (_papi_hwi_system_info.num_cntrs == 4)
{
sprintf(note,"0x%x,0x%x,0x%x,0x%x",
_papi_hwd_preset_map[pnum].counter_cmd.evntsel[0],
_papi_hwd_preset_map[pnum].counter_cmd.evntsel[1],
_papi_hwd_preset_map[pnum].counter_cmd.evntsel[2],
_papi_hwd_preset_map[pnum].counter_cmd.evntsel[3]);
strcat(_papi_hwd_preset_map[pnum].note,note);
}
else
abort();
}
}
return(PAPI_OK);
}
int
main(int argc, char *argv[]) {
char **av, fname[STRLEN], *out_fname, *subject_name, *cp ;
int ac, nargs, i, n, noint = 0, options ;
int msec, minutes, seconds, nsubjects, input ;
struct timeb start ;
GCA *gca ;
MRI *mri_seg, *mri_tmp, *mri_inputs ;
TRANSFORM *transform ;
LTA *lta;
GCA_BOUNDARY *gcab ;
Progname = argv[0] ;
ErrorInit(NULL, NULL, NULL) ;
DiagInit(NULL, NULL, NULL) ;
TimerStart(&start) ;
parms.use_gradient = 0 ;
spacing = 8 ;
/* rkt: check for and handle version tag */
nargs = handle_version_option
(argc, argv,
"$Id: mri_gcab_train.c,v 1.4 2011/03/16 20:23:33 fischl Exp $",
"$Name: $");
if (nargs && argc - nargs == 1)
exit (0);
argc -= nargs;
// parse command line args
ac = argc ;
av = argv ;
for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) {
nargs = get_option(argc, argv) ;
argc -= nargs ;
argv += nargs ;
}
printf("reading gca from %s\n", argv[1]) ;
gca = GCAread(argv[1]) ;
if (!gca)
exit(Gerror) ;
if (!strlen(subjects_dir)) /* hasn't been set on command line */
{
cp = getenv("SUBJECTS_DIR") ;
if (!cp)
ErrorExit(ERROR_BADPARM, "%s: SUBJECTS_DIR not defined in environment",
Progname);
strcpy(subjects_dir, cp) ;
if (argc < 4)
usage_exit(1) ;
}
// options parsed. subjects and gca name remaining
out_fname = argv[argc-1] ;
nsubjects = argc-3 ;
for (options = i = 0 ; i < nsubjects ; i++) {
if (argv[i+1][0] == '-') {
nsubjects-- ;
options++ ;
}
}
printf("training on %d subject and writing results to %s\n",
nsubjects, out_fname) ;
n = 0 ;
gcab = GCABalloc(gca, 8, 0, 30, 10, target_label);
strcpy(gcab->gca_fname, argv[1]) ;
// going through the subject one at a time
for (nargs = i = 0 ; i < nsubjects+options ; i++) {
subject_name = argv[i+2] ;
//////////////////////////////////////////////////////////////
printf("***************************************"
"************************************\n");
printf("processing subject %s, %d of %d...\n", subject_name,i+1-nargs,
nsubjects);
if (stricmp(subject_name, "-NOINT") == 0) {
printf("not using intensity information for subsequent subjects...\n");
noint = 1 ;
nargs++ ;
continue ;
} else if (stricmp(subject_name, "-INT") == 0) {
printf("using intensity information for subsequent subjects...\n");
noint = 0 ;
nargs++ ;
continue ;
}
// reading this subject segmentation
sprintf(fname, "%s/%s/mri/%s", subjects_dir, subject_name, seg_dir) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
fprintf(stderr, "Reading segmentation from %s...\n", fname) ;
mri_seg = MRIread(fname) ;
if (!mri_seg)
ErrorExit(ERROR_NOFILE, "%s: could not read segmentation file %s",
Progname, fname) ;
if ((mri_seg->type != MRI_UCHAR) && (mri_seg->type != MRI_FLOAT)) {
ErrorExit
(ERROR_NOFILE,
"%s: segmentation file %s is not type UCHAR or FLOAT",
Progname, fname) ;
}
if (binarize) {
int j ;
for (j = 0 ; j < 256 ; j++) {
if (j == binarize_in)
MRIreplaceValues(mri_seg, mri_seg, j, binarize_out) ;
else
MRIreplaceValues(mri_seg, mri_seg, j, 0) ;
}
}
if (insert_fname) {
MRI *mri_insert ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, insert_fname) ;
mri_insert = MRIread(fname) ;
if (mri_insert == NULL)
ErrorExit(ERROR_NOFILE,
"%s: could not read volume from %s for insertion",
Progname, insert_fname) ;
MRIbinarize(mri_insert, mri_insert, 1, 0, insert_label) ;
MRIcopyLabel(mri_insert, mri_seg, insert_label) ;
MRIfree(&mri_insert) ;
}
replaceLabels(mri_seg) ;
MRIeraseBorderPlanes(mri_seg, 1) ;
for (input = 0 ; input < gca->ninputs ; input++) {
//////////// set the gca type //////////////////////////////
// is this T1/PD training?
// how can we allow flash data training ???????
// currently checks the TE, TR, FA to be the same for all inputs
// thus we cannot allow flash data training.
////////////////////////////////////////////////////////////
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name,input_names[input]);
if (DIAG_VERBOSE_ON)
printf("reading co-registered input from %s...\n", fname) ;
fprintf(stderr, " reading input %d: %s\n", input, fname);
mri_tmp = MRIread(fname) ;
if (!mri_tmp)
ErrorExit
(ERROR_NOFILE,
"%s: could not read image from file %s", Progname, fname) ;
// input check 1
if (getSliceDirection(mri_tmp) != MRI_CORONAL) {
ErrorExit
(ERROR_BADPARM,
"%s: must be in coronal direction, but it is not\n",
fname);
}
// input check 2
if (mri_tmp->xsize != 1 || mri_tmp->ysize != 1 || mri_tmp->zsize != 1) {
ErrorExit
(ERROR_BADPARM,
"%s: must have 1mm voxel size, but have (%f, %f, %f)\n",
fname, mri_tmp->xsize, mri_tmp->ysize, mri_tmp->ysize);
}
// input check 3 is removed. now we can handle c_(ras) != 0 case
// input check 4
if (i == 0) {
TRs[input] = mri_tmp->tr ;
FAs[input] = mri_tmp->flip_angle ;
TEs[input] = mri_tmp->te ;
} else if (!FEQUAL(TRs[input],mri_tmp->tr) ||
!FEQUAL(FAs[input],mri_tmp->flip_angle) ||
!FEQUAL(TEs[input], mri_tmp->te))
ErrorExit
(ERROR_BADPARM,
"%s: subject %s input volume %s: sequence parameters "
"(%2.1f, %2.1f, %2.1f)"
"don't match other inputs (%2.1f, %2.1f, %2.1f)",
Progname, subject_name, fname,
mri_tmp->tr, DEGREES(mri_tmp->flip_angle), mri_tmp->te,
TRs[input], DEGREES(FAs[input]), TEs[input]) ;
// first time do the following
if (input == 0) {
int nframes = gca->ninputs ;
///////////////////////////////////////////////////////////
mri_inputs =
MRIallocSequence(mri_tmp->width, mri_tmp->height, mri_tmp->depth,
mri_tmp->type, nframes) ;
if (!mri_inputs)
ErrorExit
(ERROR_NOMEMORY,
"%s: could not allocate input volume %dx%dx%dx%d",
mri_tmp->width, mri_tmp->height, mri_tmp->depth,nframes) ;
MRIcopyHeader(mri_tmp, mri_inputs) ;
}
// -mask option ////////////////////////////////////////////
if (mask_fname)
{
MRI *mri_mask ;
sprintf(fname, "%s/%s/mri/%s",
subjects_dir, subject_name, mask_fname);
printf("reading volume %s for masking...\n", fname) ;
mri_mask = MRIread(fname) ;
if (!mri_mask)
ErrorExit(ERROR_NOFILE, "%s: could not open mask volume %s.\n",
Progname, fname) ;
MRImask(mri_tmp, mri_mask, mri_tmp, 0, 0) ;
MRIfree(&mri_mask) ;
}
MRIcopyFrame(mri_tmp, mri_inputs, 0, input) ;
MRIfree(&mri_tmp) ;
}// end of inputs per subject
/////////////////////////////////////////////////////////
// xform_name is given, then we can use the consistent c_(r,a,s) for gca
/////////////////////////////////////////////////////////
if (xform_name)
{
// we read talairach.xfm which is a RAS-to-RAS
sprintf(fname, "%s/%s/mri/transforms/%s",
subjects_dir, subject_name, xform_name) ;
if (Gdiag & DIAG_SHOW && DIAG_VERBOSE_ON)
printf("INFO: reading transform file %s...\n", fname);
if (!FileExists(fname))
{
fprintf(stderr,"ERROR: cannot find transform file %s\n",fname);
exit(1);
}
transform = TransformRead(fname);
if (!transform)
ErrorExit(ERROR_NOFILE, "%s: could not read transform from file %s",
Progname, fname);
modify_transform(transform, mri_inputs, gca);
// Here we do 2 things
// 1. modify gca direction cosines to
// that of the transform destination (both linear and non-linear)
// 2. if ras-to-ras transform,
// then change it to vox-to-vox transform (linear case)
// modify transform to store inverse also
TransformInvert(transform, mri_inputs) ;
// verify inverse
lta = (LTA *) transform->xform;
}
else
{
GCAreinit(mri_inputs, gca);
// just use the input value, since dst = src volume
transform = TransformAlloc(LINEAR_VOXEL_TO_VOXEL, NULL) ;
}
////////////////////////////////////////////////////////////////////
// train gca
////////////////////////////////////////////////////////////////////
// segmentation is seg volume
// inputs is the volumes of all inputs
// transform is for this subject
// noint is whether to use intensity information or not
GCABtrain(gcab, mri_inputs, mri_seg, transform, target_label) ;
MRIfree(&mri_seg) ;
MRIfree(&mri_inputs) ;
TransformFree(&transform) ;
}
GCABcompleteTraining(gcab) ;
if (smooth > 0) {
printf("regularizing conditional densities with smooth=%2.2f\n", smooth) ;
GCAregularizeConditionalDensities(gca, smooth) ;
}
if (navgs) {
printf("applying mean filter %d times to conditional densities\n", navgs) ;
GCAmeanFilterConditionalDensities(gca, navgs) ;
}
printf("writing trained GCAB to %s...\n", out_fname) ;
if (GCABwrite(gcab, out_fname) != NO_ERROR)
ErrorExit
(ERROR_BADFILE, "%s: could not write gca to %s", Progname, out_fname) ;
if (Gdiag & DIAG_WRITE && DIAG_VERBOSE_ON)
{
MRI *mri ;
mri = GCAbuildMostLikelyVolume(gca, NULL) ;
MRIwrite(mri, "m.mgz") ;
MRIfree(&mri) ;
}
if (histo_fname) {
FILE *fp ;
int histo_counts[10000], xn, yn, zn, max_count ;
GCA_NODE *gcan ;
memset(histo_counts, 0, sizeof(histo_counts)) ;
fp = fopen(histo_fname, "w") ;
if (!fp)
ErrorExit(ERROR_BADFILE, "%s: could not open histo file %s",
Progname, histo_fname) ;
max_count = 0 ;
for (xn = 0 ; xn < gca->node_width; xn++) {
for (yn = 0 ; yn < gca->node_height ; yn++) {
for (zn = 0 ; zn < gca->node_depth ; zn++) {
gcan = &gca->nodes[xn][yn][zn] ;
if (gcan->nlabels < 1)
continue ;
if (gcan->nlabels == 1 && IS_UNKNOWN(gcan->labels[0]))
continue ;
histo_counts[gcan->nlabels]++ ;
if (gcan->nlabels > max_count)
max_count = gcan->nlabels ;
}
}
}
max_count = 20 ;
for (xn = 1 ; xn < max_count ; xn++)
fprintf(fp, "%d %d\n", xn, histo_counts[xn]) ;
fclose(fp) ;
}
GCAfree(&gca) ;
msec = TimerStop(&start) ;
seconds = nint((float)msec/1000.0f) ;
minutes = seconds / 60 ;
seconds = seconds % 60 ;
printf("classifier array training took %d minutes"
" and %d seconds.\n", minutes, seconds) ;
exit(0) ;
return(0) ;
}
int mps_librarydb_traverse_directory(char *directoryName, sqlite3 *db,
long caller_file_path_id)
{
DIR *directoryStreamPointer;
struct dirent *directoryElementPointer;
struct stat statStructure;
char filePathCopy[MPS_MAX_LIBRARY_PATH_LENGTH];
char fullFilePath[MPS_MAX_LIBRARY_PATH_LENGTH];
char escapedFileName[MPS_MAX_LIBRARY_PATH_LENGTH];
char escapedTitle[MPS_MAX_TRACK_INFO_FIELD_LENGTH];
char escapedArtist[MPS_MAX_TRACK_INFO_FIELD_LENGTH];
char escapedAlbum[MPS_MAX_TRACK_INFO_FIELD_LENGTH];
char escapedGenre[MPS_MAX_TRACK_INFO_FIELD_LENGTH];
char escapedDname[NAME_MAX+1];
char *zErrMsg = 0;
int i, sqlite_rc, gti_rc, rv = MPS_LIBRARYDBD_SUCCESS;
int updated_track_count, updated_file_path_count;
int tempErrno;
long artistId, albumId, filePathId;
char sqlStatement[MAX_SQL_STATEMENT_LENGTH];
char whereClause[MAX_SQL_STATEMENT_LENGTH];
mps_library_track_info_t track_info;
MPS_DBG_PRINT("Entering %s(%s, 0x%08x, %d)\n", __func__,
directoryName, (unsigned)db, caller_file_path_id);
if ((directoryStreamPointer = opendir(directoryName))
== NULL) {
MPS_LOG("Error: Couldn't open \"%s\"\n", directoryName);
goto OUT;
}
while (1) {
errno = 0;
if ((directoryElementPointer = readdir(directoryStreamPointer))
== NULL) {
tempErrno=errno;
if (tempErrno ==0) {
break;
}
else {
MPS_LOG("readdir() returned NULL with errno==%d\n", tempErrno);
sleep(10);
continue;
}
}
MPS_DBG_PRINT("Top of while() loop. d_name=\"%s\"\n",
directoryElementPointer->d_name);
/* zero the track_info structure */
memset(&track_info, 0, sizeof(mps_library_track_info_t));
//Construct full path name in source directory
// could I just use realpath()?
strcpy(fullFilePath, directoryName);
strcat(fullFilePath, "/");
strcat(fullFilePath, directoryElementPointer->d_name);
track_info.parent_path_id = caller_file_path_id;
strncpy(track_info.file_name, directoryElementPointer->d_name,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
// escape the ' characters for sqlite's benefit
copy_and_sqlite_escape(escapedFileName,
track_info.file_name,
MPS_MAX_LIBRARY_PATH_LENGTH);
stat(fullFilePath, &statStructure);
if (S_ISREG(statStructure.st_mode)
&& *(directoryElementPointer->d_name) != '.') {
MPS_DBG_PRINT("Is a regular file\n");
track_info.file_type = mps_get_file_type(directoryElementPointer->d_name);
if (track_info.file_type == MPS_LIBRARY_UNKNOWN) {
MPS_DBG_PRINT("\"%s\" has an unrecognized file type\n",
directoryElementPointer->d_name);
continue;
}
track_info.file_length = statStructure.st_size;
track_info.file_last_modification = statStructure.st_mtime;
if (*state == LIBRARYDBD_STATE_UPDATINGDB) {
snprintf(sqlStatement, MAX_SQL_STATEMENT_LENGTH,
"UPDATE mps_library_titles SET db_version=%ld "
"WHERE file_length=%ld AND file_last_modification=%ld "
"AND parent_path_id=%ld AND file_name='%s'; ",
/* "LIMIT 1; ", -- this might work if I build from
non-"amalgamation" source */
dbVersion, track_info.file_length,
track_info.file_last_modification,
caller_file_path_id, escapedFileName);
MPS_DBG_PRINT("Calling sqlite3_exec on \"%s\"\n", sqlStatement);
sqlite_rc = sqlite3_exec(db, sqlStatement, NULL, 0, &zErrMsg);
if( sqlite_rc != SQLITE_OK ){
MPS_LOG("SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
return MPS_LIBRARYDBD_FAILURE;
}
else {
updated_track_count = sqlite3_changes(db);
}
if (updated_track_count > 0) {
MPS_DBG_PRINT("File \"%s\" doesn't appear to have changed, updated scan_counter = %d\n",
fullFilePath, dbVersion);
}
}
if (*state == LIBRARYDBD_STATE_CREATINGDB ||
(*state == LIBRARYDBD_STATE_UPDATINGDB && updated_track_count == 0)){
gti_rc = get_track_info(fullFilePath, &track_info);
if (gti_rc != MPS_LIBRARYDBD_SUCCESS) {
MPS_DBG_PRINT("get_track_info() returned MPS_LIBRARYDBD_FAILURE\n");
// Don't continue and add entry if get_track_info failed.
continue;
}
MPS_DBG_PRINT("Adding file \"%s\"\n", fullFilePath);
highestTitleId++;
sanitize_and_copy (escapedTitle,
track_info.title,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
if (IS_UNKNOWN(escapedTitle)) {
sprintf(escapedTitle, "Unknown Title (%s)", escapedFileName);
}
sanitize_and_copy (escapedAlbum,
track_info.album,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
if (IS_UNKNOWN(escapedAlbum)) {
strcpy(escapedAlbum, "Unknown Album");
}
sanitize_and_copy (escapedArtist,
track_info.artist,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
if (IS_UNKNOWN(escapedArtist)) {
strcpy(escapedArtist, "Unknown Artist");
}
copy_and_sqlite_escape(escapedGenre,
track_info.genre,
MPS_MAX_TRACK_INFO_FIELD_LENGTH);
/* update artist table */
artistId = update_artist_table(escapedArtist, db);
/* update albums table */
albumId = update_album_table(escapedAlbum, artistId, db);
snprintf(sqlStatement, MAX_SQL_STATEMENT_LENGTH,
"insert into mps_library_titles "
"values("
"%ld, " // title_id int64
"%ld, " // db_version int64
"%ld, " // file_length int64
"%ld, " // file_last_modification int64
"%ld, " // parent_path_id int64
"'%s', " // file_name text
"%d, " // file_type int
"'%s', " // title text
"%ld, " // album_id int64
"%ld, " // artist_id int64
"%d, " // year int
"'%s', " // genre text
"%d, " // time_length int
"%d, " // play_count int
"%ld, " // last_played int64
"%d, " // ordinal_track_number int
"%d, " // bitrate int
"%d, " // sampling_rate int
"%d, " // channel_mode int
"%d, " // vbr_mode int
"%ld " // filesystem_id int64
"); ",
highestTitleId, dbVersion,
track_info.file_length, track_info.file_last_modification,
caller_file_path_id, escapedFileName, track_info.file_type,
escapedTitle, albumId, artistId,
track_info.year, escapedGenre, track_info.time_length,
track_info.play_count, track_info.last_played,
track_info.ordinal_track_number, track_info.bitrate,
track_info.sampling_rate, track_info.channel_mode,
track_info.vbr_mode, 0L /*fs_id hardcoded */);
MPS_DBG_PRINT("Calling sqlite3_exec on \"%s\"\n", sqlStatement);
sqlite_rc = sqlite3_exec(db, sqlStatement, NULL, 0, &zErrMsg);
if( sqlite_rc != SQLITE_OK ){
MPS_LOG("SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
highestTitleId--;
return MPS_LIBRARYDBD_FAILURE;
}
else {
numberTitlesAdded++;
}
}
}
else if (S_ISDIR(statStructure.st_mode)) {
MPS_DBG_PRINT("Is a directory\n");
copy_and_sqlite_escape(escapedDname,
directoryElementPointer->d_name,
MPS_MAX_LIBRARY_PATH_LENGTH);
if (strcmp(directoryElementPointer->d_name, ".") &&
strcmp(directoryElementPointer->d_name, "..")) {
if (*state == LIBRARYDBD_STATE_UPDATINGDB) {
snprintf(sqlStatement, MAX_SQL_STATEMENT_LENGTH,
"update mps_library_file_path set db_version=%ld "
"where parent_id=%ld and name='%s'",
dbVersion, caller_file_path_id, escapedDname);
MPS_DBG_PRINT("Calling sqlite3_exec on \"%s\"\n", sqlStatement);
sqlite_rc = sqlite3_exec(db, sqlStatement, NULL, 0, &zErrMsg);
if( sqlite_rc != SQLITE_OK ){
MPS_LOG("SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
return MPS_LIBRARYDBD_FAILURE;
}
else {
updated_file_path_count = sqlite3_changes(db);
}
if (updated_file_path_count > 0) {
snprintf(whereClause, MAX_SQL_STATEMENT_LENGTH,
"parent_id=%ld and name='%s'",
caller_file_path_id, escapedDname);
rv = mps_librarydb_get_long(db, "mps_library_file_path", "id",
whereClause, &filePathId);
if (rv < MPS_LIBRARYDBD_SUCCESS) {
goto OUT;
}
}
}
if (*state == LIBRARYDBD_STATE_CREATINGDB ||
(*state == LIBRARYDBD_STATE_UPDATINGDB &&
updated_file_path_count == 0)){
filePathId = ++highestFilePathId;
snprintf(sqlStatement, MAX_SQL_STATEMENT_LENGTH,
"insert into mps_library_file_path "
"values("
"%ld, " // id int64
"%ld, " // parent_id int64
"'%s', " // name text
"%ld, " // db_version int64
"%ld " // filesystem_id int64
"); ",
highestFilePathId, caller_file_path_id,
escapedDname, dbVersion, 0L /* fs_id hard coded */);
MPS_DBG_PRINT("Calling sqlite3_exec on \"%s\"\n", sqlStatement);
sqlite_rc = sqlite3_exec(db, sqlStatement, NULL, 0, &zErrMsg);
if( sqlite_rc != SQLITE_OK ){
MPS_LOG("SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
highestFilePathId--;
rv = MPS_LIBRARYDBD_FAILURE;
goto CLOSE_OUT;
}
else {
numberFilePathsAdded++;
}
}
MPS_DBG_PRINT("Adding directory \"%s\"\n", fullFilePath);
mps_librarydb_traverse_directory(fullFilePath, db, filePathId);
}
}
}
CLOSE_OUT:
closedir(directoryStreamPointer);
OUT:
MPS_DBG_PRINT("Leaving %s() - return value %d\n", __func__, rv);
return rv;
}
static MRI *
edit_ventricular_unknowns(MRI *mri_in_labeled, MRI *mri_T1, MRI *mri_out_labeled) {
int label, x, y, z, xm1, xp1, ym1, yp1, zm1, zp1, lxp1, lxm1, lyp1, lym1, lzp1, lzm1, nchanged,
l1 = 0, l2 = 0, change, i, total_changed, dwm, dhypo, dven, left ;
MRI *mri_in ;
mri_in = MRIcopy(mri_in_labeled, NULL) ;
mri_out_labeled = MRIcopy(mri_in_labeled, mri_out_labeled) ;
total_changed = 0 ;
/* first change unknowns near hypointensities to wm or hypo */
do {
nchanged = 0 ;
for (x = 0 ; x < mri_T1->width ; x++) {
for (y = 0 ; y < mri_T1->height ; y++) {
for (z = 0 ; z < mri_T1->depth ; z++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
change = 0 ;
left = 0 ;
label = MRIvox(mri_in, x, y, z) ;
if ((IS_GM(label) == 0) && (IS_UNKNOWN(label) == 0))
continue ;
dhypo = distance_to_label(mri_in, WM_hypointensities, x, y, z, 0, 1, 0, 2) ; /* look inferior */
if (dhypo > 2)
dhypo = distance_to_label(mri_in, WM_hypointensities, x, y, z, 0, 0, -1, 2) ; /* look inferior */
if (dhypo > 2)
dhypo = distance_to_label(mri_in, WM_hypointensities, x, y, z, 0, 0, 1, 2) ; /* look anterior */
if (dhypo > 2)
dhypo = distance_to_label(mri_in, WM_hypointensities, x, y, z, 0, 0, -1, 2) ; /* look inferior */
if (dhypo > 2)
continue ;
#define WM_DIST 4
dwm = distance_to_label(mri_in, Left_Cerebral_White_Matter, x, y, z, 0, -1, 0, WM_DIST) ; /* superior */
if (dwm > WM_DIST) {
dwm = distance_to_label(mri_in, Right_Cerebral_White_Matter, x, y, z, 0, -1, 0, WM_DIST) ;
} else
left = 1 ;
if (dwm > WM_DIST) /* not superior, look anterior */
{
dwm = distance_to_label(mri_in, Right_Cerebral_White_Matter, x, y, z, 0, 0, 1, WM_DIST) ;
if (dwm > WM_DIST) {
dwm = distance_to_label(mri_in, Left_Cerebral_White_Matter, x, y, z, 0, 0, 1, WM_DIST) ;
if (dwm <= WM_DIST)
left = 1 ;
}
}
if (dwm > WM_DIST) /* not superior, or anterior look posterior */
{
dwm = distance_to_label(mri_in, Right_Cerebral_White_Matter, x, y, z, 0, 0, -1, WM_DIST) ;
if (dwm > WM_DIST) {
dwm = distance_to_label(mri_in, Left_Cerebral_White_Matter, x, y, z, 0, 0, -1, WM_DIST) ;
if (dwm <= WM_DIST)
left = 1 ;
}
}
if (dwm > WM_DIST) /* couldn't find wm anywhere (didn't look inferior), check for region of hypos */
{
dwm = distance_to_label(mri_in, WM_hypointensities, x, y, z, 0, -1, 0, WM_DIST) ;
if (distance_to_label(mri_in, Left_Cerebral_White_Matter, x, y, z, 0, -1, 0, 30) <= 30)
left = 1 ;
}
if (dwm > WM_DIST)
continue ;
dven = distance_to_label(mri_in, left ? Left_Lateral_Ventricle : Right_Lateral_Ventricle, x, y, z, 0, 1, 0, 15) ;
if (dven > 15) {
dven = distance_to_label(mri_in, left ? Left_Lateral_Ventricle : Right_Lateral_Ventricle, x, y, z, 0, 0, -1, 3) ;
if (dven > 3)
distance_to_label(mri_in, left ? Left_Lateral_Ventricle : Right_Lateral_Ventricle, x, y, z, 0, 0, 1, 3) ;
if (dven > 3)
continue ;
}
nchanged++ ;
mle_label(mri_T1, mri_out_labeled, x, y, z, 15, left ? Left_Cerebral_White_Matter : Right_Cerebral_White_Matter,
WM_hypointensities) ;
}
}
}
total_changed += nchanged ;
MRIcopy(mri_out_labeled, mri_in) ;
} while (nchanged > 0) ;
for (i = 0 ; i < 2 ; i++) {
for ( nchanged = x = 0 ; x < mri_T1->width ; x++) {
for (y = 0 ; y < mri_T1->height ; y++) {
for (z = 0 ; z < mri_T1->depth ; z++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
change = 0 ;
label = MRIvox(mri_in, x, y, z) ;
if (IS_UNKNOWN(label) == 0)
continue ;
xm1 = mri_T1->xi[x-1] ;
xp1 = mri_T1->xi[x+1] ;
ym1 = mri_T1->yi[y-1] ;
yp1 = mri_T1->yi[y+1] ;
zm1 = mri_T1->zi[z-1] ;
zp1 = mri_T1->zi[z+1] ;
lxp1 = MRIvox(mri_in, xp1, y, z) ;
lxm1 = MRIvox(mri_in, xm1, y, z) ;
lyp1 = MRIvox(mri_in, x, yp1, z) ;
lym1 = MRIvox(mri_in, x, ym1, z) ;
lzp1 = MRIvox(mri_in, x, y, zp1) ;
lzm1 = MRIvox(mri_in, x, y, zm1) ;
/* if it has ventricle on one side and wm on the other, change it to wm or ventricle
these are caused by slight discrepencies between the FreeSurfer ribbon and the
CMA subcortical segs.
*/
if ((IS_WMH(lxm1) && IS_LAT_VENT(lxp1)) ||
(IS_WMH(lxp1) && IS_LAT_VENT(lxm1))) {
change = 1 ;
l1 = lxm1 ;
l2 = lxp1 ;
}
if ((IS_WMH(lym1) && IS_LAT_VENT(lyp1)) ||
(IS_WMH(lyp1) && IS_LAT_VENT(lym1))) {
change = 1 ;
l1 = lym1 ;
l2 = lyp1 ;
}
if ((IS_WMH(lzm1) && IS_LAT_VENT(lzp1)) ||
(IS_WMH(lzp1) && IS_LAT_VENT(lzm1))) {
change = 1 ;
l1 = lzm1 ;
l2 = lzp1 ;
}
if (change) {
nchanged++ ;
mle_label(mri_T1, mri_out_labeled, x, y, z, 15, l1, l2) ;
} else /* could be two unknowns in a row */
{
int yi, olabel, wm, un, ven ;
#define WLEN 4
ven = un = wm = 0 ;
change = 0 ;
for (yi = y-1 ; yi >= MAX(0,y-WLEN) ; yi--) {
olabel = MRIvox(mri_in, x, yi, z) ;
/* should be only white matter and unkowns above it */
if (IS_WMH(olabel)) {
if (IS_WM(olabel))
l1 = olabel ;
wm++ ;
} else if (IS_UNKNOWN(olabel))
un++ ;
else
change = -1 ; /* something else there - don't change */
}
/* if there is some wm above and no other labels */
if ((wm >= WLEN/2) && ((wm+un) >= (WLEN-1)) && change >= 0) {
un = 0 ;
for (yi = y+1 ; yi <= MIN(mri_in->height-1,y+WLEN) ; yi++) {
olabel = MRIvox(mri_in, x, yi, z) ;
/* should be only ventricle and unkowns below it */
if (IS_LAT_VENT(olabel)) {
ven++ ;
l2 = olabel ;
} else if (IS_UNKNOWN(olabel))
un++ ;
else
change = -1 ;
}
if (change >= 0 && ((ven+un) >= WLEN) && (ven >= WLEN/2))
change = 1 ;
if (change > 0) {
nchanged++ ;
mle_label(mri_T1, mri_out_labeled, x, y, z, 15, l1, l2) ;
}
}
if (change <= 0) /* look in posterior/anterior direction. If everthing is wm and ven change it */
{
int zi ;
change = wm = ven = un = 0 ;
for (zi = z-WLEN ; zi <= z+WLEN ; zi++) {
if (zi < 0 || zi >= mri_in->depth)
continue ;
olabel = MRIvox(mri_in, x, y, zi) ;
/* should be only white matter and unkowns above it */
if (IS_WMH(olabel)) {
if (IS_WM(olabel))
l1 = olabel ;
wm++ ;
} else if (IS_UNKNOWN(olabel))
un++ ;
else if (IS_LAT_VENT(olabel))
ven++ ;
else
change = -1 ; /* something else there - don't change */
}
if (change >= 0 && ((ven+wm) >= WLEN) && (ven >= WLEN/2) && (wm >= WLEN/2))
change = 1 ;
if (change > 0) {
nchanged++ ;
mle_label(mri_T1, mri_out_labeled, x, y, z, 15, l1, l2) ;
}
}
if (change <= 0) /* look in medial/lateral direction. If everthing is wm and ven change it */
{
int xi ;
change = wm = ven = un = 0 ;
for (xi = x-WLEN ; xi <= x+WLEN ; xi++) {
if (xi < 0 || xi >= mri_in->width)
continue ;
olabel = MRIvox(mri_in, xi, y, z) ;
/* should be only white matter and unkowns above it */
if (IS_WMH(olabel)) {
if (IS_WM(olabel))
l1 = olabel ;
wm++ ;
} else if (IS_UNKNOWN(olabel))
un++ ;
else if (IS_LAT_VENT(olabel)) {
ven++ ;
l2 = olabel ;
} else
change = -1 ; /* something else there - don't change */
}
if (change >= 0 && ((ven+wm) >= WLEN) && (ven >= WLEN/2) && (wm >= WLEN/2))
change = 1 ;
if (change > 0) {
nchanged++ ;
mle_label(mri_T1, mri_out_labeled, x, y, z, 15, l1, l2) ;
}
}
}
}
}
}
/* now relabel cortex that is between WM and hypointensity */
for (x = 0 ; x < mri_T1->width ; x++) {
for (y = 0 ; y < mri_T1->height ; y++) {
for (z = 0 ; z < mri_T1->depth ; z++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
change = 0 ;
label = MRIvox(mri_in, x, y, z) ;
if (IS_GM(label) == 0 && (IS_UNKNOWN(label) == 0))
continue ;
xm1 = mri_T1->xi[x-1] ;
xp1 = mri_T1->xi[x+1] ;
ym1 = mri_T1->yi[y-1] ;
yp1 = mri_T1->yi[y+1] ;
zm1 = mri_T1->zi[z-1] ;
zp1 = mri_T1->zi[z+1] ;
lxp1 = MRIvox(mri_in, xp1, y, z) ;
lxm1 = MRIvox(mri_in, xm1, y, z) ;
lyp1 = MRIvox(mri_in, x, yp1, z) ;
lym1 = MRIvox(mri_in, x, ym1, z) ;
lzp1 = MRIvox(mri_in, x, y, zp1) ;
lzm1 = MRIvox(mri_in, x, y, zm1) ;
if ((IS_WM(lxm1) && IS_HYPO(lxp1)) ||
(IS_WM(lxp1) && IS_HYPO(lxm1))) {
change = 1 ;
l1 = lxm1 ;
l2 = lxp1 ;
}
if ((IS_WM(lym1) && IS_HYPO(lyp1)) ||
(IS_WM(lyp1) && IS_HYPO(lym1))) {
change = 1 ;
l1 = lym1 ;
l2 = lyp1 ;
}
if ((IS_WM(lzm1) && IS_HYPO(lzp1)) ||
(IS_WM(lzp1) && IS_HYPO(lzm1))) {
change = 1 ;
l1 = lzm1 ;
l2 = lzp1 ;
}
if ((IS_HYPO(lxm1) && IS_HYPO(lxp1)) ||
(IS_HYPO(lxp1) && IS_HYPO(lxm1))) {
change = 1 ;
l1 = lxm1 ;
l2 = lxp1 ;
}
if ((IS_HYPO(lym1) && IS_HYPO(lyp1)) ||
(IS_HYPO(lyp1) && IS_HYPO(lym1))) {
change = 1 ;
l1 = lym1 ;
l2 = lyp1 ;
}
if ((IS_HYPO(lzm1) && IS_HYPO(lzp1)) ||
(IS_HYPO(lzp1) && IS_HYPO(lzm1))) {
change = 1 ;
l1 = lzm1 ;
l2 = lzp1 ;
}
if (change) {
nchanged++ ;
mle_label(mri_T1, mri_out_labeled, x, y, z, 15, l1, l2) ;
}
}
}
}
MRIcopy(mri_out_labeled, mri_in) ;
total_changed += nchanged ;
}
printf("%d unknown voxels changed to wm or ventricle\n", total_changed) ;
MRIfree(&mri_in) ;
return(mri_out_labeled) ;
}
static MRI *
edit_lateral_ventricles(MRI *mri_in_labeled, MRI *mri_T1, MRI *mri_out_labeled) {
int width, height, depth, x, y, z, nchanged, label, total_changed,
left, niter, change, dvent, dwhite, olabel ;
MRI *mri_tmp ;
mri_out_labeled = MRIcopy(mri_in_labeled, mri_out_labeled) ;
mri_tmp = MRIcopy(mri_out_labeled, NULL) ;
width = mri_T1->width ;
height = mri_T1->height ;
depth = mri_T1->depth ;
niter = total_changed = 0 ;
do {
nchanged = 0 ;
/* change gray to wm if near amygdala */
for (z = 0 ; z < depth ; z++) {
for (y = 0 ; y < height ; y++) {
for (x = 0 ; x < width ; x++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
label = MRIvox(mri_tmp, x, y, z) ;
change = left = 0 ;
switch (label) {
case Left_Inf_Lat_Vent:
left = 1 ;
case Right_Inf_Lat_Vent:
dwhite = distance_to_label(mri_out_labeled,
left ? Left_Cerebral_White_Matter :
Right_Cerebral_White_Matter,
x,y,z,0,1,0,3);
dvent = distance_to_label(mri_out_labeled,
left ? Left_Inf_Lat_Vent :
Right_Inf_Lat_Vent,
x,y,z,0,-1,0,3);
if (dvent <= 1 && dwhite <= 1) /* borders ventricle superior and wm inferior */
{
mle_label(mri_T1, mri_tmp, x, y, z, 9,
left ? Left_Inf_Lat_Vent : Right_Inf_Lat_Vent,
left ? Left_Cerebral_White_Matter : Right_Cerebral_White_Matter) ;
}
break ;
case Unknown:
if (neighborLabel(mri_tmp, x, y, z, 1, Left_Lateral_Ventricle) &&
neighborLabel(mri_tmp, x, y, z,1,Left_Cerebral_White_Matter))
change = left = 1 ;
if (neighborLabel(mri_tmp, x, y, z, 1, Right_Lateral_Ventricle) &&
neighborLabel(mri_tmp, x, y, z,1,Right_Cerebral_White_Matter))
change = 1 ;
if (change) {
#if 0
label = left ?
Left_Cerebral_White_Matter : Right_Cerebral_White_Matter;
/* MRIvox(mri_tmp, x, y, z) = label ;*/
#else
mle_label(mri_T1, mri_tmp, x, y, z, 9,
left ? Left_Lateral_Ventricle : Right_Lateral_Ventricle,
left ? Left_Cerebral_White_Matter : Right_Cerebral_White_Matter) ;
#endif
nchanged++ ;
continue ;
}
default:
break ;
}
}
}
}
MRIcopy(mri_tmp, mri_out_labeled) ;
total_changed += nchanged ;
} while ((nchanged > 0) && (++niter < 1)) ;
/* change all gm within 2 mm of ventricle to wm */
for (z = 0 ; z < depth ; z++) {
for (y = 0 ; y < height ; y++) {
for (x = 0 ; x < width ; x++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
label = MRIvox(mri_out_labeled, x, y, z) ;
if (IS_GM(label) == 0)
continue ;
left = label == Left_Cerebral_Cortex ;
olabel = left ? Left_Lateral_Ventricle : Right_Lateral_Ventricle;
if (MRIneighborsInWindow(mri_out_labeled, x, y, z, 5, olabel) >= 1) {
total_changed++ ;
MRIvox(mri_out_labeled, x, y, z) = left ? Left_Cerebral_White_Matter : Right_Cerebral_White_Matter;
}
}
}
}
#if 0
/* change all unknown within 1 mm of ventricle and 1mm of wm to one of them */
for (z = 0 ; z < depth ; z++) {
for (y = 0 ; y < height ; y++) {
for (x = 0 ; x < width ; x++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
label = MRIvox(mri_out_labeled, x, y, z) ;
if (IS_UNKNOWN(label) == 0)
continue ;
left = label == Left_Cerebral_Cortex ;
olabel = left ? Left_Lateral_Ventricle : Right_Lateral_Ventricle;
if (MRIneighborsInWindow(mri_out_labeled, x, y, z, 5, olabel) >= 1) {
total_changed++ ;
MRIvox(mri_out_labeled, x, y, z) = left ? Left_Cerebral_White_Matter : Right_Cerebral_White_Matter;
}
}
}
}
#endif
MRIfree(&mri_tmp) ;
printf("%d unknown voxels bordering ventricles changed to wm.\n",
total_changed) ;
return(mri_out_labeled) ;
}
static MRI *
edit_border_voxels(MRI *mri_in_labeled, MRI *mri_T1, MRI *mri_out_labeled) {
int label, x, y, z, xm1, xp1, ym1, yp1, zm1, zp1, lxp1, lxm1, lyp1, lym1, lzp1, lzm1, nchanged,
change, olabel ;
float means[MAX_CMA_LABELS], xp1d, xm1d, yp1d, ym1d, zp1d, zm1d, val, ld ;
MRI *mri_tmp ;
if (mri_in_labeled == mri_out_labeled) {
mri_tmp = MRIcopy(mri_in_labeled, NULL) ;
mri_in_labeled = mri_tmp;
} else
mri_tmp = NULL ;
mri_out_labeled = MRIcopy(mri_in_labeled, mri_out_labeled) ;
for (nchanged = x = 0 ; x < mri_T1->width ; x++) {
for (y = 0 ; y < mri_T1->height ; y++) {
for (z = 0 ; z < mri_T1->depth ; z++) {
if (x == Gx && y == Gy && z == Gz)
DiagBreak() ;
change = 0 ;
olabel = label = MRIvox(mri_in_labeled, x, y, z) ;
if (IS_UNKNOWN(label))
continue ;
xm1 = mri_T1->xi[x-1] ;
xp1 = mri_T1->xi[x+1] ;
ym1 = mri_T1->yi[y-1] ;
yp1 = mri_T1->yi[y+1] ;
zm1 = mri_T1->zi[z-1] ;
zp1 = mri_T1->zi[z+1] ;
lxp1 = MRIvox(mri_in_labeled, xp1, y, z) ;
lxm1 = MRIvox(mri_in_labeled, xm1, y, z) ;
lyp1 = MRIvox(mri_in_labeled, x, yp1, z) ;
lym1 = MRIvox(mri_in_labeled, x, ym1, z) ;
lzp1 = MRIvox(mri_in_labeled, x, y, zp1) ;
lzm1 = MRIvox(mri_in_labeled, x, y, zm1) ;
if (label == lxm1 &&
label == lxp1 &&
label == lym1 &&
label == lyp1 &&
label == lzm1 &&
label == lzp1)
continue ; /* it's not a border label */
if (!(IS_WM(label) || IS_HIPPO(label) || IS_GM(label) || IS_UNKNOWN(label) || IS_LAT_VENT(label)))
continue ;
val = MRIgetVoxVal(mri_T1, x, y, z, 0) ;
means[label] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, label) ;
ld = fabs(means[label] - val) ;
if (ld/means[label] < 0.1)
continue ;
ld *= 0.5 ; /* bias towards keeping same label */
if (lxm1 != label)
means[lxm1] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, lxm1) ;
if (lxp1 != label)
means[lxp1] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, lxp1) ;
if (lym1 != label)
means[lym1] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, lym1) ;
if (lyp1 != label)
means[lyp1] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, lyp1) ;
if (lzm1 != label)
means[lzm1] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, lzm1) ;
if (lzp1 != label)
means[lzp1] = label_mean(mri_T1, mri_in_labeled, x, y, z, 15, lzp1) ;
xp1d = fabs(means[lxp1] - val) ;
if (xp1d < ld) {
ld = xp1d ;
olabel = lxp1 ;
}
xm1d = fabs(means[lxm1] - val) ;
if (xm1d < ld) {
ld = xm1d ;
olabel = lxm1 ;
}
yp1d = fabs(means[lyp1] - val) ;
if (yp1d < ld) {
olabel = lyp1 ;
ld = yp1d ;
}
ym1d = fabs(means[lym1] - val) ;
if (ym1d < ld) {
olabel = lym1 ;
ld = ym1d ;
}
zp1d = fabs(means[lzp1] - val) ;
if (zp1d < ld) {
olabel = lzp1 ;
ld = zp1d ;
}
zm1d = fabs(means[lzm1] - val) ;
if (zp1d < ld) {
olabel = lzp1 ;
ld = zp1d ;
}
/* only let certain labels change */
if (!(IS_WM(olabel) || IS_HIPPO(olabel) || IS_GM(olabel) || IS_UNKNOWN(olabel) || IS_LAT_VENT(olabel)))
continue ;
if ((IS_GM(label) && IS_HIPPO(olabel)) ||
(IS_GM(olabel) && IS_HIPPO(label)))
continue ; /* don't change hippo to gm based on intensity - too similar */
if ((label != olabel) && MRIneighborsInWindow(mri_in_labeled, x, y, z, 3, olabel) > 5) {
nchanged++ ;
MRIvox(mri_out_labeled, x, y, z) = olabel ;
}
}
}
}
if (mri_tmp)
MRIfree(&mri_tmp) ;
printf("%d border voxels changed\n", nchanged) ;
return(mri_out_labeled) ;
}
