1 /*****************************************************************************
2 Major portions of this software are copyrighted by the Medical College
3 of Wisconsin, 1994-2000, and are released under the Gnu General Public
4 License, Version 2. See the file README.Copyright for details.
5 ******************************************************************************/
6
7 #include "mrilib.h"
8
9 /** Only for 2D images **/
10
mri_transpose_float(MRI_IMAGE * im)11 MRI_IMAGE * mri_transpose_float( MRI_IMAGE * im )
12 {
13 MRI_IMAGE * om ;
14 float * iar , * oar ;
15 int ii,jj,nx,ny ;
16
17 ENTRY("mri_transpose_float") ;
18
19 if( im == NULL || im->kind != MRI_float ) RETURN(NULL) ;
20
21 nx = im->nx ; ny = im->ny ;
22 om = mri_new( ny , nx , MRI_float ) ;
23 iar = MRI_FLOAT_PTR(im) ;
24 oar = MRI_FLOAT_PTR(om) ;
25
26 for( jj=0 ; jj < ny ; jj++ )
27 for( ii=0 ; ii < nx ; ii++ )
28 oar[jj+ii*ny] = iar[ii+jj*nx] ;
29
30 MRI_COPY_AUX(om,im) ;
31 RETURN(om) ;
32 }
33
mri_transpose_double(MRI_IMAGE * im)34 MRI_IMAGE * mri_transpose_double( MRI_IMAGE * im )
35 {
36 MRI_IMAGE * om ;
37 double * iar , * oar ;
38 int ii,jj,nx,ny ;
39
40 ENTRY("mri_transpose_double") ;
41
42 if( im == NULL || im->kind != MRI_double ) RETURN(NULL) ;
43
44 nx = im->nx ; ny = im->ny ;
45 om = mri_new( ny , nx , MRI_double ) ;
46 iar = MRI_DOUBLE_PTR(im) ;
47 oar = MRI_DOUBLE_PTR(om) ;
48
49 for( jj=0 ; jj < ny ; jj++ )
50 for( ii=0 ; ii < nx ; ii++ )
51 oar[jj+ii*ny] = iar[ii+jj*nx] ;
52
53 MRI_COPY_AUX(om,im) ;
54 RETURN(om) ;
55 }
56
mri_transpose_short(MRI_IMAGE * im)57 MRI_IMAGE * mri_transpose_short( MRI_IMAGE * im )
58 {
59 MRI_IMAGE * om ;
60 short * iar , * oar ;
61 int ii,jj,nx,ny ;
62
63 ENTRY("mri_transpose_short") ;
64
65 if( im == NULL || im->kind != MRI_short ) RETURN(NULL) ;
66
67 nx = im->nx ; ny = im->ny ;
68 om = mri_new( ny , nx , MRI_short ) ;
69 iar = MRI_SHORT_PTR(im) ;
70 oar = MRI_SHORT_PTR(om) ;
71
72 for( jj=0 ; jj < ny ; jj++ )
73 for( ii=0 ; ii < nx ; ii++ )
74 oar[jj+ii*ny] = iar[ii+jj*nx] ;
75
76 MRI_COPY_AUX(om,im) ;
77 RETURN(om) ;
78 }
79
mri_transpose_byte(MRI_IMAGE * im)80 MRI_IMAGE * mri_transpose_byte( MRI_IMAGE * im )
81 {
82 MRI_IMAGE * om ;
83 byte * iar , * oar ;
84 int ii,jj,nx,ny ;
85
86 ENTRY("mri_transpose_byte") ;
87
88 if( im == NULL || im->kind != MRI_byte ) RETURN(NULL) ;
89
90 nx = im->nx ; ny = im->ny ;
91 om = mri_new( ny , nx , MRI_byte ) ;
92 iar = MRI_BYTE_PTR(im) ;
93 oar = MRI_BYTE_PTR(om) ;
94
95 for( jj=0 ; jj < ny ; jj++ )
96 for( ii=0 ; ii < nx ; ii++ )
97 oar[jj+ii*ny] = iar[ii+jj*nx] ;
98
99 MRI_COPY_AUX(om,im) ;
100 RETURN(om) ;
101 }
102
mri_transpose_int(MRI_IMAGE * im)103 MRI_IMAGE * mri_transpose_int( MRI_IMAGE * im )
104 {
105 MRI_IMAGE * om ;
106 int * iar , * oar ;
107 int ii,jj,nx,ny ;
108
109 ENTRY("mri_transpose_int") ;
110
111 if( im == NULL || im->kind != MRI_int ) RETURN(NULL) ;
112
113 nx = im->nx ; ny = im->ny ;
114 om = mri_new( ny , nx , MRI_int ) ;
115 iar = MRI_INT_PTR(im) ;
116 oar = MRI_INT_PTR(om) ;
117
118 for( jj=0 ; jj < ny ; jj++ )
119 for( ii=0 ; ii < nx ; ii++ )
120 oar[jj+ii*ny] = iar[ii+jj*nx] ;
121
122 MRI_COPY_AUX(om,im) ;
123 RETURN(om) ;
124 }
125
mri_transpose_complex(MRI_IMAGE * im)126 MRI_IMAGE * mri_transpose_complex( MRI_IMAGE * im )
127 {
128 MRI_IMAGE * om ;
129 complex * iar , * oar ;
130 int ii,jj,nx,ny ;
131
132 ENTRY("mri_transpose_complex") ;
133
134 if( im == NULL || im->kind != MRI_complex ) RETURN(NULL) ;
135
136 nx = im->nx ; ny = im->ny ;
137 om = mri_new( ny , nx , MRI_complex ) ;
138 iar = MRI_COMPLEX_PTR(im) ;
139 oar = MRI_COMPLEX_PTR(om) ;
140
141 for( jj=0 ; jj < ny ; jj++ )
142 for( ii=0 ; ii < nx ; ii++ )
143 oar[jj+ii*ny] = iar[ii+jj*nx] ;
144
145 MRI_COPY_AUX(om,im) ;
146 RETURN(om) ;
147 }
148
mri_transpose_rgbyte(MRI_IMAGE * im)149 MRI_IMAGE * mri_transpose_rgbyte( MRI_IMAGE * im )
150 {
151 MRI_IMAGE * om ;
152 rgbyte * iar , * oar ;
153 int ii,jj,nx,ny ;
154
155 ENTRY("mri_transpose_rgbyte") ;
156
157 if( im == NULL || im->kind != MRI_rgb ) RETURN(NULL) ;
158
159 nx = im->nx ; ny = im->ny ;
160 om = mri_new( ny , nx , MRI_rgb ) ;
161 iar = (rgbyte *) MRI_RGB_PTR(im) ;
162 oar = (rgbyte *) MRI_RGB_PTR(om) ;
163
164 for( jj=0 ; jj < ny ; jj++ )
165 for( ii=0 ; ii < nx ; ii++ )
166 oar[jj+ii*ny] = iar[ii+jj*nx] ;
167
168 MRI_COPY_AUX(om,im) ;
169 RETURN(om) ;
170 }
171
172
mri_transpose(MRI_IMAGE * im)173 MRI_IMAGE * mri_transpose( MRI_IMAGE * im )
174 {
175 if( im == NULL ) return NULL ;
176
177 switch( im->kind ){
178 case MRI_float : return mri_transpose_float (im) ;
179 case MRI_short : return mri_transpose_short (im) ;
180 case MRI_byte : return mri_transpose_byte (im) ;
181 case MRI_int : return mri_transpose_int (im) ;
182 case MRI_complex: return mri_transpose_complex(im) ;
183 case MRI_rgb: return mri_transpose_rgbyte (im) ;
184 case MRI_double: return mri_transpose_double (im) ;
185 default: fprintf(stderr,"Cannot transpose type %d.\n", im->kind);
186 }
187 return NULL ;
188 }
189
190
191 /* Interleave the columns of data, given nfirst groups of nint columns
192 * (nfirst*nint = ny). Return a new MRI_IMAGE (so we don't have to do
193 * this in place.
194 *
195 * for ifirst = 0..nfirst
196 * for iint = 0..nint
197 * col[iint + ifirst*nint] <- col[ifirst + iint*nfirst]
198 *
199 * Each of the ny columns will keep the same nx values, except that
200 * they will be moved to a different column. 27 Jul 2009 [rickr]
201 */
mri_interleave_columns(MRI_IMAGE * oldim,int nint)202 MRI_IMAGE * mri_interleave_columns( MRI_IMAGE * oldim, int nint )
203 {
204 MRI_IMAGE *newim=NULL;
205 char *dold, *dnew;
206 int ifirst, iint, nfirst, colsize;
207
208 ENTRY("mri_interleave_columns") ;
209
210 /* check that the inputs seem good */
211 if( !oldim ) RETURN(NULL);
212 if( nint <= 0 || nint > oldim->ny ) {
213 fprintf(stderr,"** interleave_cols: invalid nint=%d (ny=%d)\n",
214 nint, oldim->ny);
215 RETURN(NULL);
216 }
217 if( oldim->pixel_size <= 0 || oldim->pixel_size > 8 ) {
218 fprintf(stderr,"** interleave_cols: invalid pixel_size %d\n",
219 oldim->pixel_size);
220 RETURN(NULL);
221 }
222
223 nfirst = oldim->ny / nint;
224 if( nint * nfirst != oldim->ny ) {
225 fprintf(stderr,"** interleave_cols: nint * nfirst != ny (%d,%d,%d)\n",
226 nint, nfirst, oldim->ny);
227 RETURN(NULL);
228 }
229 if( oldim->nx * oldim->ny != oldim->nvox ) {
230 fprintf(stderr,"** interleave_cols: nx*ny != nvox (%d,%d,%lld)\n",
231 oldim->nx, oldim->ny, oldim->nvox);
232 RETURN(NULL);
233 }
234
235 /* all seems well, make a copy image and shuffle the data */
236 newim = mri_copy(oldim) ;
237 if( !newim ){
238 fprintf(stderr,"** mri_interleave_columns: failed to copy old image\n");
239 RETURN(NULL);
240 }
241
242 /* permute data, ignoring data type (except for pixel_size) */
243 dold = (char *)oldim->im;
244 dnew = (char *)newim->im;
245 colsize = oldim->nx * oldim->pixel_size;
246 for( ifirst=0; ifirst < nfirst; ifirst++ )
247 for( iint=0; iint < nint; iint++ ) {
248 memcpy(dnew + (iint + ifirst * nint )*colsize,
249 dold + (ifirst + iint * nfirst)*colsize,
250 colsize);
251 }
252
253 #ifdef USE_MRI_LABELS
254 fprintf(stderr,"** mri_interleave_columns: need to process labels\n");
255 #endif
256
257 RETURN(newim);
258 }
259