Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /trunk/src/dnorm/dnorm.c
ViewVC logotype

Annotation of /trunk/src/dnorm/dnorm.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 147 - (view) (download) (as text)

1 : jhr 114 /*
2 :     Teem: Tools to process and visualize scientific data and images
3 :     Copyright (C) 2008, 2007, 2006, 2005 Gordon Kindlmann
4 :     Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah
5 :    
6 :     This library is free software; you can redistribute it and/or
7 :     modify it under the terms of the GNU Lesser General Public License
8 :     (LGPL) as published by the Free Software Foundation; either
9 :     version 2.1 of the License, or (at your option) any later version.
10 :     The terms of redistributing and/or modifying this software also
11 :     include exceptions to the LGPL that facilitate static linking.
12 :    
13 :     This library is distributed in the hope that it will be useful,
14 :     but WITHOUT ANY WARRANTY; without even the implied warranty of
15 :     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 :     Lesser General Public License for more details.
17 :    
18 :     You should have received a copy of the GNU Lesser General Public License
19 :     along with this library; if not, write to Free Software Foundation, Inc.,
20 :     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 :     */
22 :    
23 :     #ifdef DIDEROT
24 :     # include <teem/air.h>
25 :     # include <teem/biff.h>
26 :     # include <teem/nrrd.h>
27 :     #else
28 :     # include "../nrrd.h"
29 :     #endif
30 :    
31 :     char *dnormInfo = ("Normalizes nrrd representation for Diderot. "
32 :     "Forces information about kind and orientation into "
33 :     "a consistent form, and nixes various other fields. ");
34 :    
35 :     int
36 :     main(int argc, char **argv) {
37 :     char *me, *outS;
38 :     hestOpt *hopt;
39 :     hestParm *hparm;
40 :     airArray *mop;
41 :    
42 :     char *err;
43 :     Nrrd *nin, *nout;
44 :     NrrdIoState *nio;
45 : glk 125 int kindIn, kindOut, headerOnly;
46 : jhr 114 unsigned int kindAxis, axi, si, sj;
47 :    
48 :     me = argv[0];
49 :     mop = airMopNew();
50 :     hparm = hestParmNew();
51 :     hopt = NULL;
52 :     airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
53 : glk 125 hestOptAdd(&hopt, "h,header", NULL, airTypeInt, 0, 0, &headerOnly, NULL,
54 :     "output header of nrrd file only, not the data itself");
55 : jhr 114 hestOptAdd(&hopt, "i", "nin", airTypeOther, 1, 1, &nin, NULL,
56 :     "input image", NULL, NULL, nrrdHestNrrd);
57 :     hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, "-",
58 :     "output filename", NULL);
59 :    
60 :     hestParseOrDie(hopt, argc-1, argv+1, hparm,
61 :     me, dnormInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
62 :     airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
63 :     airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
64 :    
65 :     /* can't deal with block type */
66 :     if (nrrdTypeBlock == nin->type) {
67 :     fprintf(stderr, "%s: can only have scalar kinds (not %s)\n", me,
68 :     airEnumStr(nrrdType, nrrdTypeBlock));
69 :     airMopError(mop); exit(1);
70 :     }
71 :    
72 :     /* make sure all kinds are set to something */
73 :     /* see if there's a range kind, verify that there's only one */
74 :     kindIn = nrrdKindUnknown;
75 :     kindAxis = 0;
76 :     for (axi=0; axi<nin->dim; axi++) {
77 :     if (nrrdKindUnknown == nin->axis[axi].kind
78 :     || nrrdKindIsDomain(nin->axis[axi].kind)) {
79 :     continue;
80 :     }
81 :     if (nrrdKindUnknown != kindIn) {
82 :     fprintf(stderr, "%s: got non-domain kind %s on axis %u, but already "
83 :     "have %s from axis %u\n", me,
84 :     airEnumStr(nrrdKind, nin->axis[axi].kind), axi,
85 :     airEnumStr(nrrdKind, kindIn), kindAxis);
86 :     airMopError(mop); exit(1);
87 :     }
88 :     kindIn = nin->axis[axi].kind;
89 :     kindAxis = axi;
90 :     }
91 :     /* see if the non-domain kind is something we can interpret as a tensor */
92 :     if (nrrdKindUnknown != kindIn) {
93 :     switch (kindIn) {
94 :     /* ======= THESE are the kinds that we can possibly output ======= */
95 :     case nrrdKind2Vector:
96 :     case nrrdKind3Vector:
97 :     case nrrdKind4Vector:
98 :     case nrrdKind2DSymMatrix:
99 :     case nrrdKind2DMatrix:
100 :     case nrrdKind3DSymMatrix:
101 :     case nrrdKind3DMatrix:
102 :     /* =============================================================== */
103 :     kindOut = kindIn;
104 :     break;
105 :     case nrrdKind3Color:
106 :     case nrrdKindRGBColor:
107 :     kindOut = nrrdKind3Vector;
108 :     break;
109 :     case nrrdKind4Color:
110 :     case nrrdKindRGBAColor:
111 :     kindOut = nrrdKind4Vector;
112 :     break;
113 :     default:
114 :     fprintf(stderr, "%s: got non-conforming kind %s on axis %u\n", me,
115 :     airEnumStr(nrrdKind, kindIn), kindAxis);
116 :     airMopError(mop); exit(1);
117 :     break;
118 :     }
119 :     } else {
120 :     kindOut = nrrdKindUnknown;
121 :     }
122 :    
123 : glk 147 /* initialize output by copying */
124 : jhr 114 nout = nrrdNew();
125 :     airMopAdd(mop, nout, (airMopper)nrrdNuke, airMopAlways);
126 :     if (nrrdCopy(nout, nin)) {
127 :     airMopAdd(mop, err = biffGet(NRRD), airFree, airMopAlways);
128 :     fprintf(stderr, "%s: trouble copying:\n%s", me, err);
129 :     airMopError(mop); exit(1);
130 :     }
131 :    
132 :     /* no comments, either advertising the format URL or anything else */
133 :     nio = nrrdIoStateNew();
134 :     airMopAdd(mop, nio, (airMopper)nrrdIoStateNix, airMopAlways);
135 :     nio->skipFormatURL = AIR_TRUE;
136 : glk 125 if (headerOnly) {
137 :     nio->skipData = AIR_TRUE;
138 :     }
139 : jhr 114 nrrdCommentClear(nout);
140 :    
141 :     /* no measurement frame */
142 :     for (si=0; si<NRRD_SPACE_DIM_MAX; si++) {
143 :     for (sj=0; sj<NRRD_SPACE_DIM_MAX; sj++) {
144 :     nout->measurementFrame[si][sj] = AIR_NAN;
145 :     }
146 :     }
147 :    
148 :     /* no key/value pairs */
149 :     nrrdKeyValueClear(nout);
150 :    
151 :     /* no content field */
152 :     nout->content = airFree(nout->content);
153 :    
154 :     /* normalize domain kinds to "space" */
155 :     /* turn off centers (perhaps Diderot should assume cell-centered) */
156 :     /* turn off thickness */
157 :     /* turn off labels and units */
158 :     for (axi=0; axi<nout->dim; axi++) {
159 :     if (nrrdKindUnknown == kindOut) {
160 :     nout->axis[axi].kind = nrrdKindSpace;
161 :     } else {
162 :     nout->axis[axi].kind = (kindAxis == axi
163 :     ? kindOut
164 :     : nrrdKindSpace);
165 :     }
166 :     nout->axis[axi].center = nrrdCenterUnknown;
167 :     nout->axis[axi].thickness = AIR_NAN;
168 :     nout->axis[axi].label = airFree(nout->axis[axi].label);
169 :     nout->axis[axi].units = airFree(nout->axis[axi].units);
170 :     nout->axis[axi].min = AIR_NAN;
171 :     nout->axis[axi].max = AIR_NAN;
172 :     nout->axis[axi].spacing = AIR_NAN;
173 :     }
174 :    
175 :     /* logic of orientation definition:
176 :     if space dimension is known:
177 :     set origin to zero if not already set
178 :     set space direction to unit vector if not already set
179 :     else:
180 :     set origin to zero and all space directions to units
181 :     might be nice to use gage's logic for mapping from world to index,
182 :     but we have to accept a greater variety of kinds and dimensions
183 :     than gage ever has to process.
184 :     */
185 :     if (nout->spaceDim) {
186 :     int saxi = 0;
187 : glk 147 /* we use only the space dimension, not any named space */
188 :     nout->space = nrrdSpaceUnknown;
189 : jhr 114 if (!nrrdSpaceVecExists(nout->spaceDim, nout->spaceOrigin)) {
190 :     nrrdSpaceVecSetZero(nout->spaceOrigin);
191 :     }
192 :     for (axi=0; axi<nout->dim; axi++) {
193 :     if (nrrdKindUnknown == kindOut || kindAxis != axi) {
194 :     if (!nrrdSpaceVecExists(nout->spaceDim,
195 :     nout->axis[axi].spaceDirection)) {
196 :     nrrdSpaceVecSetZero(nout->axis[axi].spaceDirection);
197 :     nout->axis[axi].spaceDirection[saxi] = 1.0;
198 :     }
199 :     saxi++;
200 :     } else {
201 :     nrrdSpaceVecSetNaN(nout->axis[axi].spaceDirection);
202 :     }
203 :     }
204 :     } else {
205 :     int saxi = 0;
206 :     nrrdSpaceVecSetZero(nout->spaceOrigin);
207 :     for (axi=0; axi<nout->dim; axi++) {
208 :     if (nrrdKindUnknown == kindOut || kindAxis != axi) {
209 :     nrrdSpaceVecSetZero(nout->axis[axi].spaceDirection);
210 : glk 125 nout->axis[axi].spaceDirection[saxi]
211 :     = (AIR_EXISTS(nin->axis[axi].spacing)
212 :     ? nin->axis[axi].spacing
213 :     : 1.0);
214 : jhr 114 saxi++;
215 :     } else {
216 :     nrrdSpaceVecSetNaN(nout->axis[axi].spaceDirection);
217 :     }
218 :     }
219 :     nout->spaceDim = saxi;
220 :     }
221 :     /* probably should be asserted earlier */
222 :     if (nout->dim != nout->spaceDim + !!kindOut) {
223 :     fprintf(stderr, "%s: output dim %d != spaceDim %d + %d %s%s%s\n",
224 :     me, nout->dim, nout->spaceDim, !!kindOut,
225 :     kindOut ? "for non-scalar (" : "(scalar data)",
226 :     kindOut ? airEnumStr(nrrdKind, kindOut) : "",
227 :     kindOut ? ") data" : "");
228 :     airMopError(mop); exit(1);
229 :     }
230 :    
231 :     if (nrrdSave(outS, nout, nio)) {
232 :     airMopAdd(mop, err = biffGet(NRRD), airFree, airMopAlways);
233 :     fprintf(stderr, "%s: trouble saving \"%s\":\n%s",
234 :     me, outS, err);
235 :     airMopError(mop); exit(1);
236 :     }
237 :    
238 :     airMopOkay(mop);
239 :     exit(0);
240 :     }

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0