77 if(
ECAT7_TEST) printf(
"ecat7WriteMainheader()\n");
79 if(fp==NULL || h==NULL)
return(1);
80 little=little_endian();
87 memcpy(buf+46, &h->
sw_version, 2);
if(little) swabip(buf+46, 2);
88 memcpy(buf+48, &h->
system_type, 2);
if(little) swabip(buf+48, 2);
89 memcpy(buf+50, &h->
file_type, 2);
if(little) swabip(buf+50, 2);
95 memcpy(buf+110, &h->
gantry_tilt, 4);
if(little) swawbip(buf+110, 4);
96 memcpy(buf+114, &h->
gantry_rotation, 4);
if(little) swawbip(buf+114, 4);
97 memcpy(buf+118, &h->
bed_elevation, 4);
if(little) swawbip(buf+118, 4);
98 memcpy(buf+122, &h->
intrinsic_tilt, 4);
if(little) swawbip(buf+122, 4);
99 memcpy(buf+126, &h->
wobble_speed, 2);
if(little) swabip(buf+126, 2);
102 memcpy(buf+134, &h->
transaxial_fov, 4);
if(little) swawbip(buf+134, 4);
104 memcpy(buf+140, &h->
coin_samp_mode, 2);
if(little) swabip(buf+140, 2);
105 memcpy(buf+142, &h->
axial_samp_mode, 2);
if(little) swabip(buf+142, 2);
115 memcpy(buf+216, &h->
patient_age, 4);
if(little) swawbip(buf+216, 4);
116 memcpy(buf+220, &h->
patient_height, 4);
if(little) swawbip(buf+220, 4);
117 memcpy(buf+224, &h->
patient_weight, 4);
if(little) swawbip(buf+224, 4);
125 memcpy(buf+352, &h->
num_planes, 2);
if(little) swabip(buf+352, 2);
126 memcpy(buf+354, &h->
num_frames, 2);
if(little) swabip(buf+354, 2);
127 memcpy(buf+356, &h->
num_gates, 2);
if(little) swabip(buf+356, 2);
128 memcpy(buf+358, &h->
num_bed_pos, 2);
if(little) swabip(buf+358, 2);
130 memcpy(buf+364, h->
bed_position, 15*4);
if(little) swawbip(buf+364, 15*4);
132 memcpy(buf+428, &h->
lwr_sctr_thres, 2);
if(little) swabip(buf+428, 2);
133 memcpy(buf+430, &h->
lwr_true_thres, 2);
if(little) swabip(buf+430, 2);
134 memcpy(buf+432, &h->
upr_true_thres, 2);
if(little) swabip(buf+432, 2);
137 memcpy(buf+446, &h->
bin_size, 4);
if(little) swawbip(buf+446, 4);
139 memcpy(buf+454, &h->
dose_start_time, 4);
if(little) swawbip(buf+454, 4);
140 memcpy(buf+458, &h->
dosage, 4);
if(little) swawbip(buf+458, 4);
143 memcpy(buf+498, &h->
septa_state, 2);
if(little) swabip(buf+498, 2);
168 if(
ECAT7_TEST) printf(
"ecat7WriteImageheader()\n");
169 if(fp==NULL || blk<2 || h==NULL)
return(1);
170 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
178 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
179 memcpy(buf+2, &h->
num_dimensions, 2);
if(little) swabip(buf+2, 2);
180 memcpy(buf+4, &h->
x_dimension, 2);
if(little) swabip(buf+4, 2);
181 memcpy(buf+6, &h->
y_dimension, 2);
if(little) swabip(buf+6, 2);
182 memcpy(buf+8, &h->
z_dimension, 2);
if(little) swabip(buf+8, 2);
183 memcpy(buf+10, &h->
x_offset, 4);
if(little) swawbip(buf+10, 4);
184 memcpy(buf+14, &h->
y_offset, 4);
if(little) swawbip(buf+14, 4);
185 memcpy(buf+18, &h->
z_offset, 4);
if(little) swawbip(buf+18, 4);
186 memcpy(buf+22, &h->
recon_zoom, 4);
if(little) swawbip(buf+22, 4);
187 memcpy(buf+26, &h->
scale_factor, 4);
if(little) swawbip(buf+26, 4);
188 memcpy(buf+30, &h->
image_min, 2);
if(little) swabip(buf+30, 2);
189 memcpy(buf+32, &h->
image_max, 2);
if(little) swabip(buf+32, 2);
190 memcpy(buf+34, &h->
x_pixel_size, 4);
if(little) swawbip(buf+34, 4);
191 memcpy(buf+38, &h->
y_pixel_size, 4);
if(little) swawbip(buf+38, 4);
192 memcpy(buf+42, &h->
z_pixel_size, 4);
if(little) swawbip(buf+42, 4);
193 memcpy(buf+46, &h->
frame_duration, 4);
if(little) swawbip(buf+46, 4);
195 memcpy(buf+54, &h->
filter_code, 2);
if(little) swabip(buf+54, 2);
196 memcpy(buf+56, &h->
x_resolution, 4);
if(little) swawbip(buf+56, 4);
197 memcpy(buf+60, &h->
y_resolution, 4);
if(little) swawbip(buf+60, 4);
198 memcpy(buf+64, &h->
z_resolution, 4);
if(little) swawbip(buf+64, 4);
199 memcpy(buf+68, &h->
num_r_elements, 4);
if(little) swawbip(buf+68, 4);
200 memcpy(buf+72, &h->
num_angles, 4);
if(little) swawbip(buf+72, 4);
204 memcpy(buf+88, &h->
gate_duration, 4);
if(little) swawbip(buf+88, 4);
205 memcpy(buf+92, &h->
r_wave_offset, 4);
if(little) swawbip(buf+92, 4);
210 memcpy(buf+112, &h->
filter_order, 2);
if(little) swabip(buf+112, 2);
214 memcpy(buf+162, &h->
mt_1_1, 4);
if(little) swawbip(buf+162, 4);
215 memcpy(buf+166, &h->
mt_1_2, 4);
if(little) swawbip(buf+166, 4);
216 memcpy(buf+170, &h->
mt_1_3, 4);
if(little) swawbip(buf+170, 4);
217 memcpy(buf+174, &h->
mt_2_1, 4);
if(little) swawbip(buf+174, 4);
218 memcpy(buf+178, &h->
mt_2_2, 4);
if(little) swawbip(buf+178, 4);
219 memcpy(buf+182, &h->
mt_2_3, 4);
if(little) swawbip(buf+182, 4);
220 memcpy(buf+186, &h->
mt_3_1, 4);
if(little) swawbip(buf+186, 4);
221 memcpy(buf+190, &h->
mt_3_2, 4);
if(little) swawbip(buf+190, 4);
222 memcpy(buf+194, &h->
mt_3_3, 4);
if(little) swawbip(buf+194, 4);
223 memcpy(buf+198, &h->
rfilter_cutoff, 4);
if(little) swawbip(buf+198, 4);
225 memcpy(buf+206, &h->
rfilter_code, 2);
if(little) swabip(buf+206, 2);
226 memcpy(buf+208, &h->
rfilter_order, 2);
if(little) swabip(buf+208, 2);
227 memcpy(buf+210, &h->
zfilter_cutoff, 4);
if(little) swawbip(buf+210, 4);
229 memcpy(buf+218, &h->
zfilter_code, 2);
if(little) swabip(buf+218, 2);
230 memcpy(buf+220, &h->
zfilter_order, 2);
if(little) swabip(buf+220, 2);
231 memcpy(buf+222, &h->
mt_1_4, 4);
if(little) swawbip(buf+222, 4);
232 memcpy(buf+226, &h->
mt_2_4, 4);
if(little) swawbip(buf+226, 4);
233 memcpy(buf+230, &h->
mt_3_4, 4);
if(little) swawbip(buf+230, 4);
234 memcpy(buf+234, &h->
scatter_type, 2);
if(little) swabip(buf+234, 2);
235 memcpy(buf+236, &h->
recon_type, 2);
if(little) swabip(buf+236, 2);
236 memcpy(buf+238, &h->
recon_views, 2);
if(little) swabip(buf+238, 2);
262 if(
ECAT7_TEST) printf(
"ecat7WriteAttenheader()\n");
263 if(fp==NULL || blk<2 || h==NULL)
return(1);
264 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
272 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
273 memcpy(buf+2, &h->
num_dimensions, 2);
if(little) swabip(buf+2, 2);
275 memcpy(buf+6, &h->
num_r_elements, 2);
if(little) swabip(buf+6, 2);
276 memcpy(buf+8, &h->
num_angles, 2);
if(little) swabip(buf+8, 2);
277 memcpy(buf+10, &h->
num_z_elements, 2);
if(little) swabip(buf+10, 2);
279 memcpy(buf+14, &h->
x_resolution, 4);
if(little) swawbip(buf+14, 4);
280 memcpy(buf+18, &h->
y_resolution, 4);
if(little) swawbip(buf+18, 4);
281 memcpy(buf+22, &h->
z_resolution, 4);
if(little) swawbip(buf+22, 4);
282 memcpy(buf+26, &h->
w_resolution, 4);
if(little) swawbip(buf+26, 4);
283 memcpy(buf+30, &h->
scale_factor, 4);
if(little) swawbip(buf+30, 4);
284 memcpy(buf+34, &h->
x_offset, 4);
if(little) swawbip(buf+34, 4);
285 memcpy(buf+38, &h->
y_offset, 4);
if(little) swawbip(buf+38, 4);
286 memcpy(buf+42, &h->
x_radius, 4);
if(little) swawbip(buf+42, 4);
287 memcpy(buf+46, &h->
y_radius, 4);
if(little) swawbip(buf+46, 4);
288 memcpy(buf+50, &h->
tilt_angle, 4);
if(little) swawbip(buf+50, 4);
296 memcpy(buf+108, &h->
storage_order, 2);
if(little) swabip(buf+108, 2);
297 memcpy(buf+110, &h->
span, 2);
if(little) swabip(buf+110, 2);
298 memcpy(buf+112, h->
z_elements, 64*2);
if(little) swabip(buf+112, 64*2);
299 memcpy(buf+240, h->
fill_cti, 86*2);
if(little) swabip(buf+240, 86*2);
300 memcpy(buf+412, h->
fill_user, 50*2);
if(little) swabip(buf+412, 50*2);
325 if(
ECAT7_TEST) printf(
"ecat7WritePolmapheader()\n");
326 if(fp==NULL || blk<2 || h==NULL)
return(1);
327 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
335 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
336 memcpy(buf+2, &h->
polar_map_type, 2);
if(little) swabip(buf+2, 2);
337 memcpy(buf+4, &h->
num_rings, 2);
if(little) swabip(buf+4, 2);
339 memcpy(buf+70, h->
ring_position, 32*4);
if(little) swawbip(buf+70, 32*4);
340 memcpy(buf+198, h->
ring_angle, 32*2);
if(little) swabip(buf+198, 32*2);
341 memcpy(buf+262, &h->
start_angle, 2);
if(little) swabip(buf+262, 2);
342 memcpy(buf+264, h->
long_axis_left, 3*2);
if(little) swabip(buf+264, 3*2);
343 memcpy(buf+270, h->
long_axis_right, 3*2);
if(little) swabip(buf+270, 3*2);
344 memcpy(buf+276, &h->
position_data, 2);
if(little) swabip(buf+276, 2);
345 memcpy(buf+278, &h->
image_min, 2);
if(little) swabip(buf+278, 2);
346 memcpy(buf+280, &h->
image_max, 2);
if(little) swabip(buf+280, 2);
347 memcpy(buf+282, &h->
scale_factor, 4);
if(little) swawbip(buf+282, 4);
348 memcpy(buf+286, &h->
pixel_size, 4);
if(little) swawbip(buf+286, 4);
349 memcpy(buf+290, &h->
frame_duration, 4);
if(little) swawbip(buf+290, 4);
351 memcpy(buf+298, &h->
processing_code, 2);
if(little) swabip(buf+298, 2);
352 memcpy(buf+300, &h->
quant_units, 2);
if(little) swabip(buf+300, 2);
354 memcpy(buf+342, &h->
gate_duration, 4);
if(little) swawbip(buf+342, 4);
355 memcpy(buf+346, &h->
r_wave_offset, 4);
if(little) swawbip(buf+346, 4);
359 memcpy(buf+404, h->
fill_cti, 27*2);
if(little) swabip(buf+404, 27*2);
384 if(
ECAT7_TEST) printf(
"ecat7WriteNormheader()\n");
385 if(fp==NULL || blk<2 || h==NULL)
return(1);
386 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
394 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
395 memcpy(buf+2, &h->
num_r_elements, 2);
if(little) swabip(buf+2, 2);
400 memcpy(buf+12, &h->
uld, 2);
if(little) swabip(buf+12, 2);
401 memcpy(buf+14, &h->
lld, 2);
if(little) swabip(buf+14, 2);
402 memcpy(buf+16, &h->
scatter_energy, 2);
if(little) swabip(buf+16, 2);
405 memcpy(buf+24, h->
ring_dtcor1, 32*4);
if(little) swawbip(buf+24, 32*4);
406 memcpy(buf+152, h->
ring_dtcor2, 32*4);
if(little) swawbip(buf+152, 32*4);
407 memcpy(buf+280, h->
crystal_dtcor, 8*4);
if(little) swawbip(buf+280, 8*4);
408 memcpy(buf+312, &h->
span, 2);
if(little) swabip(buf+312, 2);
409 memcpy(buf+314, &h->
max_ring_diff, 2);
if(little) swabip(buf+314, 2);
410 memcpy(buf+316, h->
fill_cti, 48*2);
if(little) swabip(buf+316, 48*2);
411 memcpy(buf+412, h->
fill_user, 50*2);
if(little) swabip(buf+412, 50*2);
437 if(
ECAT7_TEST) printf(
"ecat7WriteScanheader()\n");
438 if(fp==NULL || blk<2 || h==NULL)
return(1);
439 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
447 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
448 memcpy(buf+2, &h->
num_dimensions, 2);
if(little) swabip(buf+2, 2);
449 memcpy(buf+4, &h->
num_r_elements, 2);
if(little) swabip(buf+4, 2);
450 memcpy(buf+6, &h->
num_angles, 2);
if(little) swabip(buf+6, 2);
452 memcpy(buf+10, h->
num_z_elements, 64*2);
if(little) swabip(buf+10, 64*2);
453 memcpy(buf+138, &h->
ring_difference, 2);
if(little) swabip(buf+138, 2);
454 memcpy(buf+140, &h->
storage_order, 2);
if(little) swabip(buf+140, 2);
456 memcpy(buf+144, &h->
x_resolution, 4);
if(little) swawbip(buf+144, 4);
457 memcpy(buf+148, &h->
v_resolution, 4);
if(little) swawbip(buf+148, 4);
458 memcpy(buf+152, &h->
z_resolution, 4);
if(little) swawbip(buf+152, 4);
459 memcpy(buf+156, &h->
w_resolution, 4);
if(little) swawbip(buf+156, 4);
460 memcpy(buf+160, h->
fill_gate, 6*2);
if(little) swabip(buf+160, 6*2);
461 memcpy(buf+172, &h->
gate_duration, 4);
if(little) swawbip(buf+172, 4);
462 memcpy(buf+176, &h->
r_wave_offset, 4);
if(little) swawbip(buf+176, 4);
464 memcpy(buf+184, &h->
scale_factor, 4);
if(little) swawbip(buf+184, 4);
465 memcpy(buf+188, &h->
scan_min, 2);
if(little) swabip(buf+188, 2);
466 memcpy(buf+190, &h->
scan_max, 2);
if(little) swabip(buf+190, 2);
467 memcpy(buf+192, &h->
prompts, 4);
if(little) swawbip(buf+192, 4);
468 memcpy(buf+196, &h->
delayed, 4);
if(little) swawbip(buf+196, 4);
469 memcpy(buf+200, &h->
multiples, 4);
if(little) swawbip(buf+200, 4);
470 memcpy(buf+204, &h->
net_trues, 4);
if(little) swawbip(buf+204, 4);
471 memcpy(buf+208, &h->
tot_avg_cor, 4);
if(little) swawbip(buf+208, 4);
472 memcpy(buf+212, &h->
tot_avg_uncor, 4);
if(little) swawbip(buf+212, 4);
473 memcpy(buf+216, &h->
total_coin_rate, 4);
if(little) swawbip(buf+216, 4);
475 memcpy(buf+224, &h->
frame_duration, 4);
if(little) swawbip(buf+224, 4);
477 memcpy(buf+232, h->
fill_cti, 90*2);
if(little) swabip(buf+232, 90*2);
478 memcpy(buf+412, h->
fill_user, 50*2);
if(little) swabip(buf+412, 50*2);
479 memcpy(buf+512, h->
uncor_singles, 128*4);
if(little) swawbip(buf+512, 128*4);
503 if(
ECAT7_TEST) printf(
"ecat7Write2DScanheader()\n");
504 if(fp==NULL || blk<2 || h==NULL)
return(1);
505 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
513 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
514 memcpy(buf+2, &h->
num_dimensions, 2);
if(little) swabip(buf+2, 2);
515 memcpy(buf+4, &h->
num_r_elements, 2);
if(little) swabip(buf+4, 2);
516 memcpy(buf+6, &h->
num_angles, 2);
if(little) swabip(buf+6, 2);
518 memcpy(buf+10, &h->
num_z_elements, 2);
if(little) swabip(buf+10, 2);
520 memcpy(buf+14, &h->
x_resolution, 4);
if(little) swawbip(buf+14, 4);
521 memcpy(buf+18, &h->
y_resolution, 4);
if(little) swawbip(buf+18, 4);
522 memcpy(buf+22, &h->
z_resolution, 4);
if(little) swawbip(buf+22, 4);
523 memcpy(buf+26, &h->
w_resolution, 4);
if(little) swawbip(buf+26, 4);
524 memcpy(buf+30, h->
fill_gate, 6*2);
if(little) swabip(buf+30, 6*2);
525 memcpy(buf+42, &h->
gate_duration, 4);
if(little) swawbip(buf+42, 4);
526 memcpy(buf+46, &h->
r_wave_offset, 4);
if(little) swawbip(buf+46, 4);
528 memcpy(buf+54, &h->
scale_factor, 4);
if(little) swawbip(buf+54, 4);
529 memcpy(buf+58, &h->
scan_min, 2);
if(little) swabip(buf+58, 2);
530 memcpy(buf+60, &h->
scan_max, 2);
if(little) swabip(buf+60, 2);
531 memcpy(buf+62, &h->
prompts, 4);
if(little) swawbip(buf+62, 4);
532 memcpy(buf+66, &h->
delayed, 4);
if(little) swawbip(buf+66, 4);
533 memcpy(buf+70, &h->
multiples, 4);
if(little) swawbip(buf+70, 4);
534 memcpy(buf+74, &h->
net_trues, 4);
if(little) swawbip(buf+74, 4);
535 memcpy(buf+78, h->
cor_singles, 16*4);
if(little) swawbip(buf+78, 16*4);
536 memcpy(buf+142, h->
uncor_singles, 16*4);
if(little) swawbip(buf+142, 16*4);
537 memcpy(buf+206, &h->
tot_avg_cor, 4);
if(little) swawbip(buf+206, 4);
538 memcpy(buf+210, &h->
tot_avg_uncor, 4);
if(little) swawbip(buf+210, 4);
539 memcpy(buf+214, &h->
total_coin_rate, 4);
if(little) swawbip(buf+214, 4);
541 memcpy(buf+222, &h->
frame_duration, 4);
if(little) swawbip(buf+222, 4);
543 memcpy(buf+230, h->
physical_planes, 8*2);
if(little) swabip(buf+230, 8*2);
544 memcpy(buf+246, h->
fill_cti, 83*2);
if(little) swabip(buf+246, 83*2);
545 memcpy(buf+412, h->
fill_user, 50*2);
if(little) swabip(buf+412, 50*2);
570 if(
ECAT7_TEST) printf(
"ecat7Write2DNormheader()\n");
571 if(fp==NULL || blk<2 || h==NULL)
return(1);
572 little=little_endian();
if(
ECAT7_TEST) printf(
"little=%d\n", little);
580 memcpy(buf+0, &h->
data_type, 2);
if(little) swabip(buf+0, 2);
581 memcpy(buf+2, &h->
num_dimensions, 2);
if(little) swabip(buf+2, 2);
582 memcpy(buf+4, &h->
num_r_elements, 2);
if(little) swabip(buf+4, 2);
583 memcpy(buf+6, &h->
num_angles, 2);
if(little) swabip(buf+6, 2);
584 memcpy(buf+8, &h->
num_z_elements, 2);
if(little) swabip(buf+8, 2);
586 memcpy(buf+12, &h->
scale_factor, 4);
if(little) swawbip(buf+12, 4);
587 memcpy(buf+16, &h->
norm_min, 4);
if(little) swawbip(buf+16, 4);
588 memcpy(buf+20, &h->
norm_max, 4);
if(little) swawbip(buf+20, 4);
592 memcpy(buf+34, &h->
storage_order, 2);
if(little) swabip(buf+34, 2);
593 memcpy(buf+36, &h->
span, 2);
if(little) swabip(buf+36, 2);
594 memcpy(buf+38, h->
fill_cti, 64*2);
if(little) swabip(buf+38, 64*2);
595 memcpy(buf+166, h->
fill_cti, 123*2);
if(little) swabip(buf+166, 123*2);
596 memcpy(buf+412, h->
fill_user, 50*2);
if(little) swabip(buf+412, 50*2);
618 char tmp[FILENAME_MAX];
621 if(
ECAT7_TEST) printf(
"ecat7Create(%s, h)\n", fname);
623 if(fname==NULL || h==NULL)
return(NULL);
625 if(access(fname, 0) != -1) {
627 if(access(tmp, 0) != -1) remove(tmp);
628 if(
ECAT7_TEST) printf(
"Renaming %s -> %s\n", fname, tmp);
632 fp=fopen(fname,
"wb+");
if(fp==NULL)
return(fp);
661 if(nr<1 || data==NULL)
return(0);
663 if(amax<0.9999)
return(1);
665 if(modf(amax, &d)>0.0001)
return(1);
667 for(i=0; i<nr; i++)
if(modf(*data++, &d)>0.0001)
return(1);
683 int i, nxtblk, blkNr, data_size, pxlNr, ret;
684 float *fptr, fmin, fmax, g, f;
689 if(
ECAT7_TEST) printf(
"ecat7WriteImageMatrix(fp, %d, h, data)\n", matrix_id);
690 if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
691 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
702 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
713 mdata=(
char*)calloc(blkNr,
MatBLKSIZE);
if(mdata==NULL) {
718 fptr=fdata; fmin=fmax=*fptr;
719 for(i=0; i<pxlNr; i++, fptr++) {
720 if(*fptr>fmax) fmax=*fptr;
else if(*fptr<fmin) fmin=*fptr;
722 if(fabs(fmin)>fabs(fmax)) g=fabs(fmin);
else g=fabs(fmax);
723 if(g>0) f=32766./g;
else f=1.0;
729 sptr=(
short int*)mdata; fptr=fdata;
730 for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(
short int)temp_roundf(f*(*fptr));
732 h->
image_min=(
short int)temp_roundf(f*fmin);
733 h->
image_max=(
short int)temp_roundf(f*fmax);
736 sprintf(
ecat7errmsg,
"cannot determine matrix block (%d).\n", -nxtblk);
737 free(mdata);
return(8);
739 if(
ECAT7_TEST>2) printf(
" block=%d fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
742 sprintf(
ecat7errmsg,
"cannot write subheader (%d).\n", ret);
743 free(mdata);
return(10);
750 sprintf(
ecat7errmsg,
"cannot write matrix data (%d).\n", ret);
768 int i, nxtblk, blkNr, data_size, pxlNr, ret;
769 float *fptr, fmin, fmax, g, f;
774 if(
ECAT7_TEST) printf(
"ecat7Write2DScanMatrix(fp, %d, h, data)\n", matrix_id);
775 if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
776 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
787 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
798 mdata=(
char*)calloc(blkNr,
MatBLKSIZE);
if(mdata==NULL) {
803 fptr=fdata; fmin=fmax=*fptr;
804 for(i=0; i<pxlNr; i++, fptr++) {
805 if(*fptr>fmax) fmax=*fptr;
else if(*fptr<fmin) fmin=*fptr;
807 if(fabs(fmin)>fabs(fmax)) g=fabs(fmin);
else g=fabs(fmax);
808 if(g>0) f=32766./g;
else f=1.0;
814 sptr=(
short int*)mdata; fptr=fdata;
815 for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(
short int)temp_roundf(f*(*fptr));
817 h->
scan_min=(
short int)temp_roundf(f*fmin);
818 h->
scan_max=(
short int)temp_roundf(f*fmax);
821 sprintf(
ecat7errmsg,
"cannot determine matrix block (%d).\n", -nxtblk);
822 free(mdata);
return(8);
824 if(
ECAT7_TEST>2) printf(
" block=%d fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
827 sprintf(
ecat7errmsg,
"cannot write subheader (%d).\n", ret);
828 free(mdata);
return(10);
835 sprintf(
ecat7errmsg,
"cannot write matrix data (%d).\n", ret);
853 int i, nxtblk, blkNr, data_size, pxlNr, dimz, ret;
854 float *fptr, fmin, fmax, g, f;
859 if(
ECAT7_TEST) printf(
"ecat7WriteScanMatrix(fp, %d, h, data)\n", matrix_id);
860 if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
861 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
872 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
883 mdata=(
char*)calloc(blkNr,
MatBLKSIZE);
if(mdata==NULL) {
888 fptr=fdata; fmin=fmax=*fptr;
889 for(i=0; i<pxlNr; i++, fptr++) {
890 if(*fptr>fmax) fmax=*fptr;
else if(*fptr<fmin) fmin=*fptr;
892 if(fabs(fmin)>fabs(fmax)) g=fabs(fmin);
else g=fabs(fmax);
893 if(g>0) f=32766./g;
else f=1.0;
899 sptr=(
short int*)mdata; fptr=fdata;
900 for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(
short int)temp_roundf(f*(*fptr));
902 h->
scan_min=(
short int)temp_roundf(f*fmin);
903 h->
scan_max=(
short int)temp_roundf(f*fmax);
907 sprintf(
ecat7errmsg,
"cannot determine matrix block (%d).\n", -nxtblk);
908 free(mdata);
return(8);
910 if(
ECAT7_TEST>2) printf(
" block=%d fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
913 sprintf(
ecat7errmsg,
"cannot write subheader (%d).\n", ret);
914 free(mdata);
return(10);
922 sprintf(
ecat7errmsg,
"cannot write matrix data (%d).\n", ret);
940 int i, nxtblk, blkNr, data_size, pxlNr, ret;
941 float *fptr, fmin, fmax, g, f;
946 if(
ECAT7_TEST) printf(
"ecat7WritePolarmapMatrix(fp, %d, h, data)\n", matrix_id);
947 if(fp==NULL || matrix_id<1 || h==NULL || fdata==NULL) {
948 sprintf(
ecat7errmsg,
"invalid function parameter.\n");
958 sprintf(
ecat7errmsg,
"invalid matrix dimension.\n");
969 mdata=(
char*)calloc(blkNr,
MatBLKSIZE);
if(mdata==NULL) {
974 fptr=fdata; fmin=fmax=*fptr;
975 for(i=0; i<pxlNr; i++, fptr++) {
976 if(*fptr>fmax) fmax=*fptr;
else if(*fptr<fmin) fmin=*fptr;
978 if(fabs(fmin)>fabs(fmax)) g=fabs(fmin);
else g=fabs(fmax);
979 if(g>0) f=32766./g;
else f=1.0;
985 sptr=(
short int*)mdata; fptr=fdata;
986 for(i=0; i<pxlNr; i++, sptr++, fptr++) *sptr=(
short int)temp_roundf(f*(*fptr));
988 h->
image_min=(
short int)temp_roundf(f*fmin);
989 h->
image_max=(
short int)temp_roundf(f*fmax);
992 sprintf(
ecat7errmsg,
"cannot determine matrix block (%d).\n", -nxtblk);
993 free(mdata);
return(8);
995 if(
ECAT7_TEST>2) printf(
" block=%d fmin=%g fmax=%g\n", nxtblk, fmin, fmax);
998 sprintf(
ecat7errmsg,
"cannot write subheader (%d).\n", ret);
999 free(mdata);
return(10);
1006 sprintf(
ecat7errmsg,
"cannot write matrix data (%d).\n", ret);
1030 int i, blkNr, dataSize, byteNr, little;
1032 if(
ECAT7_TEST) printf(
"ecat7WriteMatrixdata(fp, %d, data, %d, %d)\n",
1033 start_block, pxl_nr, pxl_size);
1034 if(fp==NULL || start_block<1 || data==NULL || pxl_nr<1 || pxl_size<1)
return(1);
1035 little=little_endian(); memset(buf, 0,
MatBLKSIZE);
1036 dataSize=pxl_nr*pxl_size;
1039 if(
ECAT7_TEST>2) printf(
" blkNr=%d\n", blkNr);
1041 fseek(fp, (start_block-1)*
MatBLKSIZE, SEEK_SET);
1042 if(ftell(fp)!=(start_block-1)*
MatBLKSIZE)
return(2);
1044 for(i=0, dptr=data; i<blkNr && dataSize>0; i++) {
1046 memcpy(buf, dptr, byteNr);
1049 if(pxl_size==2) swabip(buf, byteNr);
1050 else if(pxl_size==4) swawbip(buf, byteNr);
1055 dptr+=byteNr; dataSize-=byteNr;
short int calibration_units_label
float well_counter_corr_factor
int ecat7Write2DScanMatrix(FILE *fp, int matrix_id, ECAT7_2Dscanheader *h, float *fdata)
int ecat7WriteScanheader(FILE *fp, int blk, ECAT7_scanheader *h)
short int compression_code
int ecat7WriteMatrixdata(FILE *fp, int start_block, char *data, int pxl_nr, int pxl_size)
int ecat7WriteNormheader(FILE *fp, int blk, ECAT7_normheader *h)
float ecat_calibration_factor
short int patient_orientation
int ecat7WritePolarmapMatrix(FILE *fp, int matrix_id, ECAT7_polmapheader *h, float *fdata)
int ecat7WritePolmapheader(FILE *fp, int blk, ECAT7_polmapheader *h)
char original_file_name[32]
short int angular_compression
short int calibration_units
int ecat7_is_scaling_needed(float amax, float *data, int nr)
int ecat7WriteImageheader(FILE *fp, int blk, ECAT7_imageheader *h)
int ecat7WriteAttenheader(FILE *fp, int blk, ECAT7_attenheader *h)
int ecat7pxlbytes(short int data_type)
short int acquisition_mode
char user_process_code[10]
short int transm_source_type
int ecat7WriteImageMatrix(FILE *fp, int matrix_id, ECAT7_imageheader *h, float *fdata)
int ecat7WriteMainheader(FILE *fp, ECAT7_mainheader *h)
FILE * ecat7Create(const char *fname, ECAT7_mainheader *h)
int ecat7WriteScanMatrix(FILE *fp, int matrix_id, ECAT7_scanheader *h, float *fdata)
short int acquisition_type
int ecat7Write2DScanheader(FILE *fp, int blk, ECAT7_2Dscanheader *h)
char study_description[32]
short int axial_samp_mode
int ecat7EnterMatrix(FILE *fp, int matrix_id, int block_nr)
char radiopharmaceutical[32]
int ecat7Write2DNormheader(FILE *fp, int blk, ECAT7_2Dnormheader *h)