83 if(
ECAT7_TEST) printf(
"ecat7ReadMainheader()\n");
84 if(fp==NULL || h==NULL)
return(1);
85 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
88 fseek(fp, 0, SEEK_SET);
if(ftell(fp)!=0)
return(2);
95 if(little) swabip(buf+46, 2); memcpy(&h->
sw_version, buf+46, 2);
96 if(little) swabip(buf+48, 2); memcpy(&h->
system_type, buf+48, 2);
97 if(little) swabip(buf+50, 2); memcpy(&h->
file_type, buf+50, 2);
103 if(little) swawbip(buf+110, 4); memcpy(&h->
gantry_tilt, buf+110, 4);
104 if(little) swawbip(buf+114, 4); memcpy(&h->
gantry_rotation, buf+114, 4);
105 if(little) swawbip(buf+118, 4); memcpy(&h->
bed_elevation, buf+118, 4);
106 if(little) swawbip(buf+122, 4); memcpy(&h->
intrinsic_tilt, buf+122, 4);
107 if(little) swabip(buf+126, 2); memcpy(&h->
wobble_speed, buf+126, 2);
110 if(little) swawbip(buf+134, 4); memcpy(&h->
transaxial_fov, buf+134, 4);
112 if(little) swabip(buf+140, 2); memcpy(&h->
coin_samp_mode, buf+140, 2);
113 if(little) swabip(buf+142, 2); memcpy(&h->
axial_samp_mode, buf+142, 2);
123 if(little) swawbip(buf+216, 4); memcpy(&h->
patient_age, buf+216, 4);
124 if(little) swawbip(buf+220, 4); memcpy(&h->
patient_height, buf+220, 4);
125 if(little) swawbip(buf+224, 4); memcpy(&h->
patient_weight, buf+224, 4);
133 if(little) swabip(buf+352, 2); memcpy(&h->
num_planes, buf+352, 2);
134 if(little) swabip(buf+354, 2); memcpy(&h->
num_frames, buf+354, 2);
135 if(little) swabip(buf+356, 2); memcpy(&h->
num_gates, buf+356, 2);
136 if(little) swabip(buf+358, 2); memcpy(&h->
num_bed_pos, buf+358, 2);
138 if(little) swawbip(buf+364, 15*4); memcpy(h->
bed_position, buf+364, 15*4);
140 if(little) swabip(buf+428, 2); memcpy(&h->
lwr_sctr_thres, buf+428, 2);
141 if(little) swabip(buf+430, 2); memcpy(&h->
lwr_true_thres, buf+430, 2);
145 if(little) swawbip(buf+446, 4); memcpy(&h->
bin_size, buf+446, 4);
147 if(little) swawbip(buf+454, 4); memcpy(&h->
dose_start_time, buf+454, 4);
148 if(little) swawbip(buf+458, 4); memcpy(&h->
dosage, buf+458, 4);
151 if(little) swabip(buf+498, 2); memcpy(&h->
septa_state, buf+498, 2);
181 if(
ECAT7_TEST) printf(
"ecat7ReadImageheader()\n");
182 if(fp==NULL || h==NULL)
return(1);
183 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
189 if(fread(buf,
MatBLKSIZE, 1, fp)<1)
return(3);
192 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
193 if(little) swabip(buf+2, 2); memcpy(&h->
num_dimensions, buf+2, 2);
194 if(little) swabip(buf+4, 2); memcpy(&h->
x_dimension, buf+4, 2);
195 if(little) swabip(buf+6, 2); memcpy(&h->
y_dimension, buf+6, 2);
196 if(little) swabip(buf+8, 2); memcpy(&h->
z_dimension, buf+8, 2);
197 if(little) swawbip(buf+10, 4); memcpy(&h->
x_offset, buf+10, 4);
198 if(little) swawbip(buf+14, 4); memcpy(&h->
y_offset, buf+14, 4);
199 if(little) swawbip(buf+18, 4); memcpy(&h->
z_offset, buf+18, 4);
200 if(little) swawbip(buf+22, 4); memcpy(&h->
recon_zoom, buf+22, 4);
201 if(little) swawbip(buf+26, 4); memcpy(&h->
scale_factor, buf+26, 4);
202 if(little) swabip(buf+30, 2); memcpy(&h->
image_min, buf+30, 2);
203 if(little) swabip(buf+32, 2); memcpy(&h->
image_max, buf+32, 2);
204 if(little) swawbip(buf+34, 4); memcpy(&h->
x_pixel_size, buf+34, 4);
205 if(little) swawbip(buf+38, 4); memcpy(&h->
y_pixel_size, buf+38, 4);
206 if(little) swawbip(buf+42, 4); memcpy(&h->
z_pixel_size, buf+42, 4);
207 if(little) swawbip(buf+46, 4); memcpy(&h->
frame_duration, buf+46, 4);
209 if(little) swabip(buf+54, 2); memcpy(&h->
filter_code, buf+54, 2);
210 if(little) swawbip(buf+56, 4); memcpy(&h->
x_resolution, buf+56, 4);
211 if(little) swawbip(buf+60, 4); memcpy(&h->
y_resolution, buf+60, 4);
212 if(little) swawbip(buf+64, 4); memcpy(&h->
z_resolution, buf+64, 4);
213 if(little) swawbip(buf+68, 4); memcpy(&h->
num_r_elements, buf+68, 4);
214 if(little) swawbip(buf+72, 4); memcpy(&h->
num_angles, buf+72, 4);
218 if(little) swawbip(buf+88, 4); memcpy(&h->
gate_duration, buf+88, 4);
219 if(little) swawbip(buf+92, 4); memcpy(&h->
r_wave_offset, buf+92, 4);
224 if(little) swabip(buf+112, 2); memcpy(&h->
filter_order, buf+112, 2);
228 if(little) swawbip(buf+162, 4); memcpy(&h->
mt_1_1, buf+162, 4);
229 if(little) swawbip(buf+166, 4); memcpy(&h->
mt_1_2, buf+166, 4);
230 if(little) swawbip(buf+170, 4); memcpy(&h->
mt_1_3, buf+170, 4);
231 if(little) swawbip(buf+174, 4); memcpy(&h->
mt_2_1, buf+174, 4);
232 if(little) swawbip(buf+178, 4); memcpy(&h->
mt_2_2, buf+178, 4);
233 if(little) swawbip(buf+182, 4); memcpy(&h->
mt_2_3, buf+182, 4);
234 if(little) swawbip(buf+186, 4); memcpy(&h->
mt_3_1, buf+186, 4);
235 if(little) swawbip(buf+190, 4); memcpy(&h->
mt_3_2, buf+190, 4);
236 if(little) swawbip(buf+194, 4); memcpy(&h->
mt_3_3, buf+194, 4);
237 if(little) swawbip(buf+198, 4); memcpy(&h->
rfilter_cutoff, buf+198, 4);
239 if(little) swabip(buf+206, 2); memcpy(&h->
rfilter_code, buf+206, 2);
240 if(little) swabip(buf+208, 2); memcpy(&h->
rfilter_order, buf+208, 2);
241 if(little) swawbip(buf+210, 4); memcpy(&h->
zfilter_cutoff, buf+210, 4);
243 if(little) swabip(buf+218, 2); memcpy(&h->
zfilter_code, buf+218, 2);
244 if(little) swabip(buf+220, 2); memcpy(&h->
zfilter_order, buf+220, 2);
245 if(little) swawbip(buf+222, 4); memcpy(&h->
mt_1_4, buf+222, 4);
246 if(little) swawbip(buf+226, 4); memcpy(&h->
mt_2_4, buf+226, 4);
247 if(little) swawbip(buf+230, 4); memcpy(&h->
mt_3_4, buf+230, 4);
248 if(little) swabip(buf+234, 2); memcpy(&h->
scatter_type, buf+234, 2);
249 if(little) swabip(buf+236, 2); memcpy(&h->
recon_type, buf+236, 2);
250 if(little) swabip(buf+238, 2); memcpy(&h->
recon_views, buf+238, 2);
272 if(
ECAT7_TEST) printf(
"ecat7ReadAttenheader()\n");
273 if(fp==NULL || h==NULL)
return(1);
274 little=little_endian();
280 if(fread(buf,
MatBLKSIZE, 1, fp)<1)
return(3);
282 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
283 if(little) swabip(buf+2, 2); memcpy(&h->
num_dimensions, buf+2, 2);
285 if(little) swabip(buf+6, 2); memcpy(&h->
num_r_elements, buf+6, 2);
286 if(little) swabip(buf+8, 2); memcpy(&h->
num_angles, buf+8, 2);
287 if(little) swabip(buf+10, 2); memcpy(&h->
num_z_elements, buf+10, 2);
289 if(little) swawbip(buf+14, 4); memcpy(&h->
x_resolution, buf+14, 4);
290 if(little) swawbip(buf+18, 4); memcpy(&h->
y_resolution, buf+18, 4);
291 if(little) swawbip(buf+22, 4); memcpy(&h->
z_resolution, buf+22, 4);
292 if(little) swawbip(buf+26, 4); memcpy(&h->
w_resolution, buf+26, 4);
293 if(little) swawbip(buf+30, 4); memcpy(&h->
scale_factor, buf+30, 4);
294 if(little) swawbip(buf+34, 4); memcpy(&h->
x_offset, buf+34, 4);
295 if(little) swawbip(buf+38, 4); memcpy(&h->
y_offset, buf+38, 4);
296 if(little) swawbip(buf+42, 4); memcpy(&h->
x_radius, buf+42, 4);
297 if(little) swawbip(buf+46, 4); memcpy(&h->
y_radius, buf+46, 4);
298 if(little) swawbip(buf+50, 4); memcpy(&h->
tilt_angle, buf+50, 4);
306 if(little) swabip(buf+108, 2); memcpy(&h->
storage_order, buf+108, 2);
307 if(little) swabip(buf+110, 2); memcpy(&h->
span, buf+110, 2);
308 if(little) swabip(buf+112, 64*2); memcpy(h->
z_elements, buf+112, 64*2);
309 if(little) swabip(buf+240, 86*2); memcpy(h->
fill_cti, buf+240, 86*2);
310 if(little) swabip(buf+412, 50*2); memcpy(h->
fill_user, buf+412, 50*2);
329 if(
ECAT7_TEST) printf(
"ecat7ReadPolarmapheader()\n");
330 if(fp==NULL || h==NULL)
return(1);
331 little=little_endian();
337 if(fread(buf,
MatBLKSIZE, 1, fp)<1)
return(3);
339 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
340 if(little) swabip(buf+2, 2); memcpy(&h->
polar_map_type, buf+2, 2);
341 if(little) swabip(buf+4, 2); memcpy(&h->
num_rings, buf+4, 2);
343 if(little) swawbip(buf+70, 32*4); memcpy(h->
ring_position, buf+70, 32*4);
344 if(little) swabip(buf+198, 32*2); memcpy(h->
ring_angle, buf+198, 32*2);
345 if(little) swabip(buf+262, 2); memcpy(&h->
start_angle, buf+262, 2);
346 if(little) swabip(buf+264, 3*2); memcpy(h->
long_axis_left, buf+264, 3*2);
347 if(little) swabip(buf+270, 3*2); memcpy(h->
long_axis_right, buf+270, 3*2);
348 if(little) swabip(buf+276, 2); memcpy(&h->
position_data, buf+276, 2);
349 if(little) swabip(buf+278, 2); memcpy(&h->
image_min, buf+278, 2);
350 if(little) swabip(buf+280, 2); memcpy(&h->
image_max, buf+280, 2);
351 if(little) swawbip(buf+282, 4); memcpy(&h->
scale_factor, buf+282, 4);
352 if(little) swawbip(buf+286, 4); memcpy(&h->
pixel_size, buf+286, 4);
353 if(little) swawbip(buf+290, 4); memcpy(&h->
frame_duration, buf+290, 4);
355 if(little) swabip(buf+298, 2); memcpy(&h->
processing_code, buf+298, 2);
356 if(little) swabip(buf+300, 2); memcpy(&h->
quant_units, buf+300, 2);
358 if(little) swawbip(buf+342, 4); memcpy(&h->
gate_duration, buf+342, 4);
359 if(little) swawbip(buf+346, 4); memcpy(&h->
r_wave_offset, buf+346, 4);
363 if(little) swabip(buf+404, 27*2); memcpy(h->
fill_cti, buf+404, 27*2);
382 if(
ECAT7_TEST) printf(
"ecat7ReadNormheader()\n");
383 if(fp==NULL || h==NULL)
return(1);
384 little=little_endian();
390 if(fread(buf,
MatBLKSIZE, 1, fp)<1)
return(3);
392 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
393 if(little) swabip(buf+2, 2); memcpy(&h->
num_r_elements, buf+2, 2);
398 if(little) swabip(buf+12, 2); memcpy(&h->
uld, buf+12, 2);
399 if(little) swabip(buf+14, 2); memcpy(&h->
lld, buf+14, 2);
400 if(little) swabip(buf+16, 2); memcpy(&h->
scatter_energy, buf+16, 2);
403 if(little) swawbip(buf+24, 32*4); memcpy(h->
ring_dtcor1, buf+24, 32*4);
404 if(little) swawbip(buf+152, 32*4); memcpy(h->
ring_dtcor2, buf+152, 32*4);
405 if(little) swawbip(buf+280, 8*4); memcpy(h->
crystal_dtcor, buf+280, 8*4);
406 if(little) swabip(buf+312, 2); memcpy(&h->
span, buf+312, 2);
407 if(little) swabip(buf+314, 2); memcpy(&h->
max_ring_diff, buf+314, 2);
408 if(little) swabip(buf+316, 48*2); memcpy(h->
fill_cti, buf+316, 48*2);
409 if(little) swabip(buf+412, 50*2); memcpy(h->
fill_user, buf+412, 50*2);
428 if(
ECAT7_TEST) printf(
"ecat7ReadScanheader()\n");
429 if(fp==NULL || h==NULL)
return(1);
430 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
435 if(fread(buf,
MatBLKSIZE, 2, fp)<1)
return(3);
438 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
439 if(little) swabip(buf+2, 2); memcpy(&h->
num_dimensions, buf+2, 2);
440 if(little) swabip(buf+4, 2); memcpy(&h->
num_r_elements, buf+4, 2);
441 if(little) swabip(buf+6, 2); memcpy(&h->
num_angles, buf+6, 2);
443 if(little) swabip(buf+10, 64*2); memcpy(h->
num_z_elements, buf+10, 64*2);
444 if(little) swabip(buf+138, 2); memcpy(&h->
ring_difference, buf+138, 2);
445 if(little) swabip(buf+140, 2); memcpy(&h->
storage_order, buf+140, 2);
447 if(little) swawbip(buf+144, 4); memcpy(&h->
x_resolution, buf+144, 4);
448 if(little) swawbip(buf+148, 4); memcpy(&h->
v_resolution, buf+148, 4);
449 if(little) swawbip(buf+152, 4); memcpy(&h->
z_resolution, buf+152, 4);
450 if(little) swawbip(buf+156, 4); memcpy(&h->
w_resolution, buf+156, 4);
451 if(little) swabip(buf+160, 6*2); memcpy(h->
fill_gate, buf+160, 6*2);
452 if(little) swawbip(buf+172, 4); memcpy(&h->
gate_duration, buf+172, 4);
453 if(little) swawbip(buf+176, 4); memcpy(&h->
r_wave_offset, buf+176, 4);
455 if(little) swawbip(buf+184, 4); memcpy(&h->
scale_factor, buf+184, 4);
456 if(little) swabip(buf+188, 2); memcpy(&h->
scan_min, buf+188, 2);
457 if(little) swabip(buf+190, 2); memcpy(&h->
scan_max, buf+190, 2);
458 if(little) swawbip(buf+192, 4); memcpy(&h->
prompts, buf+192, 4);
459 if(little) swawbip(buf+196, 4); memcpy(&h->
delayed, buf+196, 4);
460 if(little) swawbip(buf+200, 4); memcpy(&h->
multiples, buf+200, 4);
461 if(little) swawbip(buf+204, 4); memcpy(&h->
net_trues, buf+204, 4);
462 if(little) swawbip(buf+208, 4); memcpy(&h->
tot_avg_cor, buf+208, 4);
463 if(little) swawbip(buf+212, 4); memcpy(&h->
tot_avg_uncor, buf+212, 4);
464 if(little) swawbip(buf+216, 4); memcpy(&h->
total_coin_rate, buf+216, 4);
466 if(little) swawbip(buf+224, 4); memcpy(&h->
frame_duration, buf+224, 4);
468 if(little) swabip(buf+232, 90*2); memcpy(h->
fill_cti, buf+232, 90*2);
469 if(little) swabip(buf+412, 50*2); memcpy(h->
fill_user, buf+412, 50*2);
470 if(little) swawbip(buf+512, 128*4); memcpy(h->
uncor_singles, buf+512, 128*4);
489 if(
ECAT7_TEST) printf(
"ecat7Read2DScanheader()\n");
490 if(fp==NULL || h==NULL)
return(1);
491 little=little_endian();
497 if(fread(buf,
MatBLKSIZE, 1, fp)<1)
return(3);
499 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
500 if(little) swabip(buf+2, 2); memcpy(&h->
num_dimensions, buf+2, 2);
501 if(little) swabip(buf+4, 2); memcpy(&h->
num_r_elements, buf+4, 2);
502 if(little) swabip(buf+6, 2); memcpy(&h->
num_angles, buf+6, 2);
504 if(little) swabip(buf+10, 2); memcpy(&h->
num_z_elements, buf+10, 2);
506 if(little) swawbip(buf+14, 4); memcpy(&h->
x_resolution, buf+14, 4);
507 if(little) swawbip(buf+18, 4); memcpy(&h->
y_resolution, buf+18, 4);
508 if(little) swawbip(buf+22, 4); memcpy(&h->
z_resolution, buf+22, 4);
509 if(little) swawbip(buf+26, 4); memcpy(&h->
w_resolution, buf+26, 4);
510 if(little) swabip(buf+30, 6*2); memcpy(h->
fill_gate, buf+30, 6*2);
511 if(little) swawbip(buf+42, 4); memcpy(&h->
gate_duration, buf+42, 4);
512 if(little) swawbip(buf+46, 4); memcpy(&h->
r_wave_offset, buf+46, 4);
514 if(little) swawbip(buf+54, 4); memcpy(&h->
scale_factor, buf+54, 4);
515 if(little) swabip(buf+58, 2); memcpy(&h->
scan_min, buf+58, 2);
516 if(little) swabip(buf+60, 2); memcpy(&h->
scan_max, buf+60, 2);
517 if(little) swawbip(buf+62, 4); memcpy(&h->
prompts, buf+62, 4);
518 if(little) swawbip(buf+66, 4); memcpy(&h->
delayed, buf+66, 4);
519 if(little) swawbip(buf+70, 4); memcpy(&h->
multiples, buf+70, 4);
520 if(little) swawbip(buf+74, 4); memcpy(&h->
net_trues, buf+74, 4);
521 if(little) swawbip(buf+78, 16*4); memcpy(h->
cor_singles, buf+78, 16*4);
522 if(little) swawbip(buf+142, 16*4); memcpy(h->
uncor_singles, buf+142, 16*4);
523 if(little) swawbip(buf+206, 4); memcpy(&h->
tot_avg_cor, buf+206, 4);
524 if(little) swawbip(buf+210, 4); memcpy(&h->
tot_avg_uncor, buf+210, 4);
525 if(little) swawbip(buf+214, 4); memcpy(&h->
total_coin_rate, buf+214, 4);
527 if(little) swawbip(buf+222, 4); memcpy(&h->
frame_duration, buf+222, 4);
529 if(little) swabip(buf+230, 8*2); memcpy(h->
physical_planes, buf+230, 8*2);
530 if(little) swabip(buf+246, 83*2); memcpy(h->
fill_cti, buf+246, 83*2);
531 if(little) swabip(buf+412, 50*2); memcpy(h->
fill_user, buf+412, 50*2);
550 if(
ECAT7_TEST) printf(
"ecat7Read2Dnormheader()\n");
551 if(fp==NULL || h==NULL)
return(1);
552 little=little_endian();
558 if(fread(buf,
MatBLKSIZE, 1, fp)<1)
return(3);
560 if(little) swabip(buf+0, 2); memcpy(&h->
data_type, buf+0, 2);
561 if(little) swabip(buf+2, 2); memcpy(&h->
num_dimensions, buf+2, 2);
562 if(little) swabip(buf+4, 2); memcpy(&h->
num_r_elements, buf+4, 2);
563 if(little) swabip(buf+6, 2); memcpy(&h->
num_angles, buf+6, 2);
564 if(little) swabip(buf+8, 2); memcpy(&h->
num_z_elements, buf+8, 2);
566 if(little) swawbip(buf+12, 4); memcpy(&h->
scale_factor, buf+12, 4);
567 if(little) swawbip(buf+16, 4); memcpy(&h->
norm_min, buf+16, 4);
568 if(little) swawbip(buf+20, 4); memcpy(&h->
norm_max, buf+20, 4);
572 if(little) swabip(buf+34, 2); memcpy(&h->
storage_order, buf+34, 2);
573 if(little) swabip(buf+36, 2); memcpy(&h->
span, buf+36, 2);
574 if(little) swabip(buf+38, 64*2); memcpy(h->
fill_cti, buf+38, 64*2);
575 if(little) swabip(buf+166, 123*2); memcpy(h->
fill_cti, buf+166, 123*2);
576 if(little) swabip(buf+412, 50*2); memcpy(h->
fill_user, buf+412, 50*2);
596 int i, n, little, err=0;
600 if(
ECAT7_TEST) printf(
"ecat7ReadMatrixdata(fp, %d, %d, data, %d)\n",
601 start_block, block_nr, dtype);
603 if(block_nr<=0 || start_block<1 || data==NULL)
return(1);
605 fseek(fp, (start_block-1)*
MatBLKSIZE, SEEK_SET);
606 if(ftell(fp)!=(start_block-1)*
MatBLKSIZE)
return(9);
608 if(fread(data,
MatBLKSIZE, block_nr, fp) < block_nr)
return(2);
610 little=little_endian();
615 if(!little) {cptr=data; swabip(cptr, block_nr*
MatBLKSIZE);}
618 for(i=0, cptr=data; i<block_nr*
MatBLKSIZE; i+=4, cptr+=4) {
619 n=
ecat7rInt(cptr, 1, little); memcpy(cptr, &n, 4);
623 for(i=0, cptr=data; i<block_nr*
MatBLKSIZE; i+=4, cptr+=4) {
624 f=
ecat7rFloat(cptr, 1, little); memcpy(cptr, &f, 4);
629 if(little) swawbip(data, block_nr*
MatBLKSIZE);
657 int i, ret, blockNr, pxlNr;
659 float *_fdata, *fptr;
664 if(
ECAT7_TEST) printf(
"ecat7ReadImageMatrix(fp, %d, %d, hdr, fdata)\n",
665 first_block, last_block);
667 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
675 sprintf(
ecat7errmsg,
"cannot read subheader (%d).\n", ret);
682 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
687 blockNr=last_block-first_block;
if(blockNr<1)
return(0);
695 if(ret || mdata==NULL) {
696 sprintf(
ecat7errmsg,
"cannot read matrix data (%d).\n", ret);
697 free(mdata);
return(9);
701 _fdata=(
float*)malloc(pxlNr*
sizeof(
float));
704 free(mdata);
return(11);
708 fptr=_fdata; mptr=mdata;
710 for(i=0; i<pxlNr; i++, mptr++, fptr++)
713 for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
714 sptr=(
short int*)mptr;
718 for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
723 memcpy(fptr, mptr, pxlNr*4);
724 for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->
scale_factor;
751 int i, ret, blockNr, pxlNr;
753 float *_fdata, *fptr;
758 if(
ECAT7_TEST) printf(
"ecat7Read2DScanMatrix(fp, %d, %d, hdr, fdata)\n",
759 first_block, last_block);
761 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
769 sprintf(
ecat7errmsg,
"cannot read subheader (%d).\n", ret);
776 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
781 blockNr=last_block-first_block;
if(blockNr<1)
return(0);
789 if(ret || mdata==NULL) {
790 sprintf(
ecat7errmsg,
"cannot read matrix data (%d).\n", ret);
791 free(mdata);
return(9);
795 _fdata=(
float*)malloc(pxlNr*
sizeof(
float));
798 free(mdata);
return(11);
802 fptr=_fdata; mptr=mdata;
804 for(i=0; i<pxlNr; i++, mptr++, fptr++)
807 for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
808 sptr=(
short int*)mptr;
812 for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
817 memcpy(fptr, mptr, pxlNr*4);
818 for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->
scale_factor;
845 int i, ret, blockNr, trueblockNr, pxlNr, dimz;
847 float *_fdata, *fptr;
852 if(
ECAT7_TEST) printf(
"ecat7ReadScanMatrix(fp, %d, %d, hdr, fdata)\n",
853 first_block, last_block);
855 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
863 sprintf(
ecat7errmsg,
"cannot read subheader (%d).\n", ret);
870 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
877 blockNr=last_block-first_block-1;
if(blockNr<1)
return(0);
878 if(blockNr<trueblockNr) trueblockNr=blockNr;
886 if(ret || mdata==NULL) {
887 sprintf(
ecat7errmsg,
"cannot read matrix data (%d).\n", ret);
888 free(mdata);
return(9);
892 _fdata=(
float*)malloc(pxlNr*
sizeof(
float));
895 free(mdata);
return(11);
899 fptr=_fdata; mptr=mdata;
901 for(i=0; i<pxlNr; i++, mptr++, fptr++)
904 for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
905 sptr=(
short int*)mptr;
909 for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
914 memcpy(fptr, mptr, pxlNr*4);
915 for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->
scale_factor;
940 int i, ret, blockNr, pxlNr;
942 float *_fdata, *fptr;
947 if(
ECAT7_TEST) printf(
"ecat7ReadPolarmapMatrix(fp, %d, %d, hdr, fdata)\n",
948 first_block, last_block);
955 sprintf(
ecat7errmsg,
"cannot read subheader (%d).\n", ret);
960 if(pxlNr<=0)
return 3;
963 blockNr=last_block-first_block;
if(blockNr<1)
return 0;
965 if(mdata==NULL)
return 4;
968 if(ret || mdata==NULL) {
969 if(mdata!=NULL) free(mdata);
974 _fdata=(
float*)malloc(pxlNr*
sizeof(
float));
977 free(mdata);
return 4;
981 fptr=_fdata; mptr=mdata;
983 for(i=0; i<pxlNr; i++, mptr++, fptr++)
986 for(i=0; i<pxlNr; i++, mptr+=2, fptr++) {
987 sptr=(
short int*)mptr;
991 for(i=0; i<pxlNr; i++, mptr+=4, fptr++) {
996 memcpy(fptr, mptr, pxlNr*4);
997 for(i=0; i<pxlNr; i++, fptr++) *fptr *= h->
scale_factor;
1016 union {
unsigned int ul;
float f;} t;
1018 memcpy(&t.ul, bufi, 4);
if(t.ul==0) {
return(0.0);}
1021 if(islittle) swawip(&t.ul, 4);
else swabip(&t.ul, 4);
1024 if(!islittle) swawbip(&t.ul, 4);
1042 memcpy(&i, bufi, 4);
if(!islittle) swawbip(&i, 4);
void ecat7PrintImageheader(ECAT7_imageheader *h, FILE *fp)
void ecat7PrintPolmapheader(ECAT7_polmapheader *h, FILE *fp)
void ecat7Print2DScanheader(ECAT7_2Dscanheader *h, FILE *fp)
void ecat7PrintScanheader(ECAT7_scanheader *h, FILE *fp)
int ecat7pxlbytes(short int data_type)
int ecat7Read2DScanMatrix(FILE *fp, int first_block, int last_block, ECAT7_2Dscanheader *h, float **fdata)
int ecat7ReadScanheader(FILE *fp, int blk, ECAT7_scanheader *h)
float ecat7rFloat(void *bufi, int isvax, int islittle)
int ecat7ReadPolmapheader(FILE *fp, int blk, ECAT7_polmapheader *h)
int ecat7ReadMatrixdata(FILE *fp, int start_block, int block_nr, char *data, int dtype)
int ecat7ReadNormheader(FILE *fp, int blk, ECAT7_normheader *h)
int ecat7ReadAttenheader(FILE *fp, int blk, ECAT7_attenheader *h)
int ecat7rInt(void *bufi, int isvax, int islittle)
int ecat7ReadMainheader(FILE *fp, ECAT7_mainheader *h)
int ecat7ReadPolarmapMatrix(FILE *fp, int first_block, int last_block, ECAT7_polmapheader *h, float **fdata)
int ecat7Read2DScanheader(FILE *fp, int blk, ECAT7_2Dscanheader *h)
int ecat7ReadImageMatrix(FILE *fp, int first_block, int last_block, ECAT7_imageheader *h, float **fdata)
int ecat7ReadImageheader(FILE *fp, int blk, ECAT7_imageheader *h)
int ecat7Read2DNormheader(FILE *fp, int blk, ECAT7_2Dnormheader *h)
int ecat7ReadScanMatrix(FILE *fp, int first_block, int last_block, ECAT7_scanheader *h, float **fdata)
char study_description[32]
float well_counter_corr_factor
short int compression_code
short int patient_orientation
char original_file_name[32]
short int angular_compression
short int calibration_units
short int transm_source_type
short int acquisition_type
char user_process_code[10]
short int axial_samp_mode
short int calibration_units_label
short int acquisition_mode
char radiopharmaceutical[32]
float ecat_calibration_factor