Debian Codegraph @

javactn/jni_src/javactn.c

raw
1 #include <jni.h>
2 #include "ctn_os.h"
3
4 #include "DICOM_DICOMWrapper.h"
5 #include "DICOM_DDR_DIRInterface.h"
6 #include "DICOM_InfoObj_Image.h"
7 #include "DICOM_InfoObj_Waveform.h"
8 #include "DICOM_Module_ImagePixelModule.h"
9 #include "DICOM_Module_WaveformModule.h"
10 #include "DICOM_Misc_Timer.h"
11 #include "DICOM_Network_Association.h"
12 #if 0
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #endif
17
18 #include "dicom.h"
19 #include "lst.h"
20 #include "condition.h"
21 #include "dicom_objects.h"
22 #include "dicom_ddr.h"
23 #include "utility.h"
24 #include "dulprotocol.h"
25 #include "dicom_messages.h"
26 #include "dicom_services.h"
27 #include "dicom_uids.h"
28
29 static int verboseFlag = -1;
30
31 static void setCodedValues(JNIEnv *env,
32 jobject obj,
33 DCM_OBJECT** dcmObj)
34 {
35 jfieldID fid;
36 jstring jstr;
37 jclass cls;
38 CONDITION cond;
39
40 long flag = 1;
41 char codeValue[DICOM_CS_LENGTH+1] = "";
42 char codingSchemeDesig[DICOM_SH_LENGTH+1] = "";
43 char codingSchemeVersion[DICOM_SH_LENGTH+1] = "";
44 char codeMeaning[DICOM_LO_LENGTH+1] = "";
45
46 char mappingResource[DICOM_CS_LENGTH+1] = "";
47 char contextGroupVersion[DICOM_DT_LENGTH+1] = "";
48 char contextIdentifier[DICOM_CS_LENGTH+1] = "";
49
50 DCM_FLAGGED_ELEMENT flagged[] = {
51 {DCM_MAKETAG(0x0008, 0x0105), DCM_CS, "", 1, sizeof(mappingResource), NULL, 1, NULL},
52 {DCM_MAKETAG(0x0008, 0x0106), DCM_DT, "", 1, sizeof(contextGroupVersion), NULL, 2, NULL},
53 {DCM_MAKETAG(0x0008, 0x010f), DCM_CS, "", 1, sizeof(contextIdentifier), NULL, 4, NULL},
54 };
55
56 DCM_ELEMENT required[] = {
57 {DCM_MAKETAG(0x0008, 0x0100), DCM_SH, "", 1, sizeof(codeValue), NULL},
58 {DCM_MAKETAG(0x0008, 0x0102), DCM_SH, "", 1, sizeof(codingSchemeDesig), NULL},
59 {DCM_MAKETAG(0x0008, 0x0103), DCM_SH, "", 1, sizeof(codingSchemeVersion), NULL},
60 {DCM_MAKETAG(0x0008, 0x0104), DCM_LO, "", 1, sizeof(codeMeaning), NULL}
61 };
62
63 flagged[0].e.d.string = mappingResource;
64 flagged[0].flagAddress = &flag;
65 flagged[1].e.d.string = contextGroupVersion;
66 flagged[1].flagAddress = &flag;
67 flagged[2].e.d.string = contextIdentifier;
68 flagged[2].flagAddress = &flag;
69
70 required[0].d.string = codeValue;
71 required[1].d.string = codingSchemeDesig;
72 required[2].d.string = codingSchemeVersion;
73 required[3].d.string = codeMeaning;
74
75 cond = DCM_ParseObject(dcmObj,
76 required, (int)DIM_OF(required),
77 flagged, (int)DIM_OF(flagged), NULL);
78 if (cond != DCM_NORMAL)
79 COND_DumpConditions();
80
81 cls = (*env)->GetObjectClass(env, obj);
82
83 fid = (*env)->GetFieldID(env, cls, "CodeValue", "Ljava/lang/String;");
84 if (fid == 0)
85 return;
86 jstr = (*env)->NewStringUTF(env, codeValue);
87 (*env)->SetObjectField(env, obj, fid, jstr);
88
89 fid = (*env)->GetFieldID(env, cls, "CodingSchemeDesignator", "Ljava/lang/String;");
90 if (fid == 0)
91 return;
92 jstr = (*env)->NewStringUTF(env, codingSchemeDesig);
93 (*env)->SetObjectField(env, obj, fid, jstr);
94
95 fid = (*env)->GetFieldID(env, cls, "CodingSchemeVersion", "Ljava/lang/String;");
96 if (fid == 0)
97 return;
98 jstr = (*env)->NewStringUTF(env, codingSchemeVersion);
99 (*env)->SetObjectField(env, obj, fid, jstr);
100
101 fid = (*env)->GetFieldID(env, cls, "CodeMeaning", "Ljava/lang/String;");
102 if (fid == 0)
103 return;
104 jstr = (*env)->NewStringUTF(env, codeMeaning);
105 (*env)->SetObjectField(env, obj, fid, jstr);
106
107 fid = (*env)->GetFieldID(env, cls, "MappingResource", "Ljava/lang/String;");
108 if (fid == 0)
109 return;
110 jstr = (*env)->NewStringUTF(env, mappingResource);
111 (*env)->SetObjectField(env, obj, fid, jstr);
112
113 fid = (*env)->GetFieldID(env, cls, "ContextGroupVersion", "Ljava/lang/String;");
114 if (fid == 0)
115 return;
116 jstr = (*env)->NewStringUTF(env, contextGroupVersion);
117 (*env)->SetObjectField(env, obj, fid, jstr);
118
119 fid = (*env)->GetFieldID(env, cls, "ContextIdentifier", "Ljava/lang/String;");
120 if (fid == 0)
121 return;
122 jstr = (*env)->NewStringUTF(env, contextIdentifier);
123 (*env)->SetObjectField(env, obj, fid, jstr);
124 }
125
126 typedef struct {
127 DCM_VALUEREPRESENTATION v;
128 char* nm;
129 } VR_MAP;
130
131 static void mapVRToString(DCM_VALUEREPRESENTATION vr, char* s)
132 {
133 VR_MAP m[] = {
134 { DCM_AE, "AE" },
135 { DCM_AS, "AS" },
136 { DCM_AT, "AT" },
137 { DCM_CS, "CS" },
138 { DCM_DA, "DA" },
139 { DCM_DD, "DD" },
140 { DCM_DS, "DS" },
141 { DCM_FD, "FD" },
142 { DCM_FL, "FL" },
143 { DCM_IS, "IS" },
144 { DCM_LO, "LO" },
145 { DCM_LT, "LT" },
146 { DCM_OT, "OT" },
147 { DCM_SH, "SH" },
148 { DCM_SL, "SL" },
149 { DCM_SQ, "SQ" },
150 { DCM_SS, "SS" },
151 { DCM_ST, "ST" },
152 { DCM_TM, "TM" },
153 { DCM_UI, "UI" },
154 { DCM_UL, "UL" },
155 { DCM_UN, "UN" },
156 { DCM_US, "US" },
157 /*{ DCM_UNKNOWN, "UNK" },*/
158 { DCM_RET, "RET" },
159 { DCM_CTX, "CTX" },
160 { DCM_PN, "PN" },
161 { DCM_OB, "OB" },
162 { DCM_OW, "OW" },
163 { DCM_DT, "DT" },
164 { DCM_DLM, "DLM" },
165 { DCM_UT, "UT" }
166 };
167 int ix = 0;
168 for (ix = 0; ix < (int)DIM_OF(m); ix++) {
169 if (vr == m[ix].v) {
170 strcpy(s, m[ix].nm);
171 return;
172 }
173 }
174 strcpy(s, "No VR");
175 }
176
177 /* Public entry points are below this line. */
178
179 static CONDITION
180 countTagCallback(const DCM_ELEMENT* e, void* ctx)
181 {
182 int *count;
183
184 count = (int *)ctx;
185 (*count)++;
186
187 return DCM_NORMAL;
188 }
189
190 typedef struct {
191 int index;
192 jint *tags;
193 } TAG_STRUCT;
194
195 static CONDITION
196 fillTagsCallback(const DCM_ELEMENT* e, void* ctx)
197 {
198 TAG_STRUCT *t;
199
200 t = (TAG_STRUCT *)ctx;
201 t->tags[t->index] = e->tag;
202 t->index++;
203
204 return DCM_NORMAL;
205 }
206
207 JNIEXPORT jlong JNICALL Java_DICOM_DICOMWrapper_newObjectJNI
208 (JNIEnv *env, jobject obj)
209 {
210 jlong p = 0;
211 CONDITION cond;
212
213 cond = DCM_CreateObject((DCM_OBJECT**)&p, 0);
214 if (cond != DCM_NORMAL) {
215 COND_PopCondition(TRUE);
216 return 0;
217 }
218 return p;
219 }
220
221 JNIEXPORT jlong JNICALL
222 Java_DICOM_DICOMWrapper_openFileJNI(JNIEnv *env, jobject obj, jstring st)
223 {
224 jlong p = 0;
225 DCM_OBJECT *o;
226 CONDITION cond;
227
228 char buf[512];
229 int i;
230 const char *str = (*env)->GetStringUTFChars(env, st, 0);
231 strcpy(buf, str);
232
233 for (i = 0; buf[i] != '\0'; i++) {
234 if (buf[i] == '\\')
235 buf[i] = '/';
236 }
237 #if 0
238 printf("%s\n", str);
239 #endif
240
241 /* We were using this flag for some Toshiba images on the
242 ** NEMA CD: DCM_ACCEPTVRMISMATCH. We have turned it off
243 */
244
245 cond = DCM_OpenFile(buf,
246 DCM_ORDERLITTLEENDIAN | DCM_TRYFILENAMECHANGE | DCM_ACCEPTVRMISMATCH,
247 (DCM_OBJECT**)&p);
248 if (cond != DCM_NORMAL)
249 cond = DCM_OpenFile(buf,
250 DCM_PART10FILE | DCM_TRYFILENAMECHANGE | DCM_ACCEPTVRMISMATCH,
251 (DCM_OBJECT **)&p);
252
253 if (cond != DCM_NORMAL) {
254 COND_DumpConditions();
255 /*exit(1);*/
256 }
257 (void)COND_PopCondition(TRUE);
258
259 (*env)->ReleaseStringUTFChars(env, st, str);
260 return p;
261 }
262
263 JNIEXPORT void JNICALL Java_DICOM_DICOMWrapper_closeFileJNI
264 (JNIEnv *env, jobject obj, jlong dcmObj)
265 {
266 CONDITION cond;
267
268 if (verboseFlag < 0) {
269 if (getenv("DCM_VERBOSE") == NULL)
270 verboseFlag = 0;
271 else
272 verboseFlag = 1;
273 }
274 if (verboseFlag) {
275 printf("Closing DICOM object\n");
276 DCM_Debug(1);
277 printf("Closing DICOM object\n");
278 }
279
280 cond = DCM_CloseObject((DCM_OBJECT**)&dcmObj);
281 if (cond != DCM_NORMAL)
282 COND_DumpConditions();
283
284 (void)COND_PopCondition(TRUE);
285 }
286
287 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_writeFileJNI
288 (JNIEnv *env, jobject obj, jlong dcmObj, jstring fileName)
289 {
290 CONDITION cond;
291
292 char buf[512];
293 int i;
294 const char *str = (*env)->GetStringUTFChars(env, fileName, 0);
295 strcpy(buf, str);
296
297 for (i = 0; buf[i] != '\0'; i++) {
298 if (buf[i] == '\\')
299 buf[i] = '/';
300 }
301
302 (*env)->ReleaseStringUTFChars(env, fileName, str);
303
304 cond = DCM_WriteFile((DCM_OBJECT**)&dcmObj, DCM_ORDERLITTLEENDIAN, buf);
305 if (cond != DCM_NORMAL) {
306 COND_PopCondition(TRUE);
307 return 1;
308 }
309 return 0;
310 }
311
312 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_getInt
313 (JNIEnv *env, jobject obj, jlong dcmObj, jshort group, jshort element)
314 {
315 DCM_ELEMENT e;
316 S32 value;
317 void *ctx = NULL;
318 U32 rtnLength = 0;
319
320 e.tag = DCM_MAKETAG(group, element);
321 DCM_LookupElement(&e);
322 e.d.ot = (void*)&value;
323 switch(e.representation) {
324 case DCM_US:
325 case DCM_SS:
326 e.length = 2;
327 break;
328 case DCM_UL:
329 case DCM_SL:
330 e.length = 4;
331 break;
332 default:
333 e.length = 0;
334 break;
335 }
336 DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
337 COND_DumpConditions();
338 if (e.length == 2)
339 return *e.d.ss;
340 else
341 return *e.d.sl;
342 }
343
344 JNIEXPORT jfloat JNICALL Java_DICOM_DICOMWrapper_getFloat
345 (JNIEnv *env, jobject obj, jlong dcmObj, jshort group, jshort element)
346 {
347 DCM_ELEMENT e;
348 char s[256] = "0";
349 U32 rtnLength = 0;
350 float f;
351
352 e.tag = DCM_MAKETAG(group, element);
353 DCM_LookupElement(&e);
354 switch (e.representation) {
355 case DCM_IS:
356 case DCM_DS:
357 e.length = sizeof(s);
358 e.d.string = s;
359 break;
360 default:
361 fprintf(stderr, "Cannot get decimal value for: %04x %04x %s\n",
362 group, element, e.description);
363 exit(1);
364 }
365 DCM_ParseObject((DCM_OBJECT**)&dcmObj, &e, 1, NULL, 0, NULL);
366 sscanf(s, "%f", &f);
367 return f;
368 }
369
370 JNIEXPORT jstring JNICALL Java_DICOM_DICOMWrapper_getStringJNI__JSS
371 (JNIEnv *env, jobject obj, jlong dcmObj, jshort group, jshort element)
372 {
373 DCM_ELEMENT e;
374 char s[128] = "<none>";
375 char *sPtr;
376 U32 length = 0;
377 jstring rtnString;
378 CONDITION cond;
379
380 e.tag = DCM_MAKETAG(group, element);
381
382 #if 0
383 DCM_LookupElement(&e);
384 cond = DCM_GetElementSize((DCM_OBJECT**)&dcmObj, e.tag, &length);
385 if (cond != DCM_NORMAL) {
386 (void)COND_PopCondition(TRUE);
387 length = 2;
388 }
389 if (length >= sizeof(s)) {
390 sPtr = (char *)malloc(length + 1);
391 e.length = length + 1;
392 } else {
393 sPtr = s;
394 e.length = sizeof(s);
395 }
396 e.d.string = sPtr;
397 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, &e, 1, NULL, 0, NULL);
398 if (cond != DCM_NORMAL) {
399 (void)COND_PopCondition(TRUE);
400 sPtr[0] = '\0';
401 }
402 #endif
403
404 sPtr = DCM_GetString((DCM_OBJECT**)&dcmObj, e.tag);
405 if (sPtr == 0) {
406 sPtr = s;
407 }
408 rtnString = (*env)->NewStringUTF(env, sPtr);
409 if (sPtr != s)
410 free(sPtr);
411
412 return rtnString;
413 }
414
415 JNIEXPORT jstring JNICALL Java_DICOM_DICOMWrapper_getStringJNI__JI
416 (JNIEnv *env, jobject obj, jlong dcmObj, jint tag)
417 {
418 DCM_ELEMENT e;
419 char s[128] = "<none>";
420 char *sPtr;
421 jstring rtnString;
422 CONDITION cond;
423
424 e.tag = tag;
425
426 #if 0
427 memset(&e, 0, sizeof(e));
428 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
429 if (cond != DCM_NORMAL) {
430 (void)COND_PopCondition(TRUE);
431 e.length = 2;
432 }
433 if (e.representation == DCM_SQ) {
434 sPtr = s;
435 strcpy(s, "<Sequence>");
436 } else {
437 if (e.length >= sizeof(s)) {
438 sPtr = (char *)malloc(e.length + 1);
439 e.length = e.length + 1;
440 } else {
441 sPtr = s;
442 e.length = sizeof(s);
443 }
444 e.d.string = sPtr;
445 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, &e, 1, NULL, 0, NULL);
446 if (cond != DCM_NORMAL) {
447 (void)COND_PopCondition(TRUE);
448 sPtr[0] = '\0';
449 }
450 }
451 #endif
452
453 sPtr = DCM_GetString((DCM_OBJECT**)&dcmObj, e.tag);
454 if (sPtr == 0) {
455 sPtr = s;
456 }
457
458 rtnString = (*env)->NewStringUTF(env, sPtr);
459 if (sPtr != s)
460 free(sPtr);
461
462 return rtnString;
463 }
464
465 JNIEXPORT jstring JNICALL Java_DICOM_DICOMWrapper_getStringJNI__JIII
466 (JNIEnv *env, jobject obj, jlong dcmObj, jint seqTag, jint tag, jint item)
467 {
468 DCM_ELEMENT e;
469 char s[128];
470 char *sPtr;
471 U32 length = 0;
472 jstring rtnString;
473 CONDITION cond;
474 LST_HEAD* l = 0;
475 DCM_SEQUENCE_ITEM* seqItem;
476
477 cond = DCM_GetSequenceList((DCM_OBJECT**)&dcmObj, seqTag, &l);
478 if (cond != DCM_NORMAL) {
479 rtnString = (*env)->NewStringUTF(env, "");
480 return rtnString;
481 }
482
483 seqItem = (DCM_SEQUENCE_ITEM*)LST_Head(&l);
484 (void)LST_Position(&l, seqItem);
485 while(item-- > 1) {
486 seqItem = (DCM_SEQUENCE_ITEM*)LST_Next(&l);
487 }
488
489 if (seqItem == NULL) {
490 rtnString = (*env)->NewStringUTF(env, "");
491 return rtnString;
492 }
493
494 e.tag = tag;
495
496 DCM_LookupElement(&e);
497 cond = DCM_GetElementSize(&seqItem->object, e.tag, &length);
498 if (cond != DCM_NORMAL) {
499 (void)COND_PopCondition(TRUE);
500 length = 2;
501 }
502 if (length >= sizeof(s)) {
503 sPtr = (char *)malloc(length + 1);
504 e.length = length + 1;
505 } else {
506 sPtr = s;
507 e.length = sizeof(s);
508 }
509 e.d.string = sPtr;
510 cond = DCM_ParseObject(&seqItem->object, &e, 1, NULL, 0, NULL);
511 if (cond != DCM_NORMAL) {
512 (void)COND_PopCondition(TRUE);
513 sPtr[0] = '\0';
514 }
515
516 rtnString = (*env)->NewStringUTF(env, sPtr);
517 if (sPtr != s)
518 free(sPtr);
519
520 return rtnString;
521 }
522
523
524 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_getSequenceLengthJNI
525 (JNIEnv *env, jobject obj, jlong dcmObj, jshort group, jshort element)
526 {
527 CONDITION cond;
528 DCM_TAG t;
529 LST_HEAD* l = 0;
530 unsigned length;
531
532 t = DCM_MAKETAG(group, element);
533 cond = DCM_GetSequenceList((DCM_OBJECT**)&dcmObj, t, &l);
534 if (cond != DCM_NORMAL) {
535 (void)COND_PopCondition(TRUE);
536 return -1;
537 }
538 length = LST_Count(&l);
539 return (jint)length;
540 }
541
542 JNIEXPORT jlong JNICALL Java_DICOM_DICOMWrapper_getSequenceObjJNI
543 (JNIEnv *env, jobject obj, jlong dcmObj, jshort group, jshort element,
544 jint index)
545 {
546 CONDITION cond;
547 DCM_TAG t;
548 LST_HEAD* l = 0;
549 DCM_SEQUENCE_ITEM* item;
550 jlong rtnValue = 0;
551 DCM_OBJECT** dummyPtr;
552
553 t = DCM_MAKETAG(group, element);
554 cond = DCM_GetSequenceList((DCM_OBJECT**)&dcmObj, t, &l);
555 if (cond != DCM_NORMAL) {
556 (void)COND_PopCondition(TRUE);
557 return -1;
558 }
559
560 item = (DCM_SEQUENCE_ITEM*)LST_Head(&l);
561 LST_Position(&l, item);
562
563 while (index-- > 0) {
564 item = (DCM_SEQUENCE_ITEM*)LST_Next(&l);
565 }
566
567 dummyPtr = (DCM_OBJECT**)&rtnValue;
568 *dummyPtr = item->object;
569 return rtnValue;
570 }
571
572 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_attributePresentJNI
573 (JNIEnv *env, jobject obj, jlong dcmObj, jint tag)
574 {
575 CONDITION cond;
576 DCM_ELEMENT e;
577
578 memset(&e, 0, sizeof(e));
579
580 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
581 if (cond == DCM_NORMAL) {
582 return 1;
583 } else {
584 (void)COND_PopCondition(TRUE);
585 return 0;
586 }
587 }
588
589 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_countTagsJNI
590 (JNIEnv *env, jobject obj, jlong dcmObj)
591 {
592 CONDITION cond;
593 int count = 0;
594
595 cond = DCM_ScanParseObject((DCM_OBJECT**)&dcmObj, 0, 0, 0, 0,
596 countTagCallback, &count);
597 if (cond != DCM_NORMAL) {
598 (void)COND_PopCondition(TRUE);
599 count = -1;
600 }
601
602 return count;
603 }
604
605 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_fillTagsJNI
606 (JNIEnv *env, jobject obj, jlong dcmObj, jintArray arr)
607 {
608 jint *tags = 0;
609 CONDITION cond;
610 TAG_STRUCT t;
611 jint rtnValue = 0;
612
613 jsize len;
614 len = (*env)->GetArrayLength(env, arr);
615 tags = (*env)->GetIntArrayElements(env, arr, 0);
616
617 t.index = 0;
618 t.tags = tags;
619 cond = DCM_ScanParseObject((DCM_OBJECT**)&dcmObj, 0, 0, 0, 0,
620 fillTagsCallback, &t);
621 if (cond != DCM_NORMAL) {
622 (void)COND_PopCondition(TRUE);
623 rtnValue = -1;
624 }
625
626 (*env)->ReleaseIntArrayElements(env, arr, tags, 0);
627 return rtnValue;
628 }
629
630 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_setStringJNI
631 (JNIEnv *env, jobject obj, jlong dcmObject, jint tag, jstring s)
632 {
633 CONDITION cond;
634 DCM_ELEMENT e;
635
636 const char *str = (*env)->GetStringUTFChars(env, s, 0);
637
638 memset(&e, 0, sizeof(e));
639 e.tag = tag;
640 DCM_LookupElement(&e);
641 e.d.string = str;
642 e.length = strlen(str);
643
644 cond = DCM_ModifyElements((DCM_OBJECT**)&dcmObject, &e, 1, 0, 0, 0);
645
646 (*env)->ReleaseStringUTFChars(env, s, str);
647
648 if (cond != DCM_NORMAL) {
649 COND_PopCondition(TRUE);
650 return 1;
651 }
652 return 0;
653 }
654
655 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_setStringSeqJNI
656 (JNIEnv *env, jobject obj, jlong dcmObject, jint seqTag, jint tag, jstring s,
657 jint index)
658
659 {
660 LST_HEAD* l1 = 0;
661 CONDITION cond;
662 DCM_SEQUENCE_ITEM* item1 = 0;
663
664 cond = DCM_GetSequenceList((DCM_OBJECT**)&dcmObject, seqTag, &l1);
665 if (cond != DCM_NORMAL) {
666 DCM_ELEMENT e = {seqTag, DCM_SQ, "", 1, 0, 0 };
667 DCM_SEQUENCE_ITEM* item = 0;
668
669 (void)COND_PopCondition(TRUE);
670
671 l1 = LST_Create();
672 e.d.sq = l1;
673 item = (DCM_SEQUENCE_ITEM*)malloc(sizeof(*item));
674 DCM_CreateObject(&(item->object), 0);
675 LST_Enqueue(&l1, item);
676 cond = DCM_AddSequenceElement((DCM_OBJECT**)&dcmObject, &e);
677 if (cond != DCM_NORMAL) {
678 COND_DumpConditions();
679 exit(1);
680 }
681 }
682
683 if (index != 0) {
684 item1 = (DCM_SEQUENCE_ITEM*) LST_Head(&l1);
685 (void) LST_Position(&l1, item1);
686
687 while(index-- > 1) {
688 item1 = (DCM_SEQUENCE_ITEM*) LST_Next(&l1);
689 }
690 }
691
692 if (item1 == 0) {
693 item1 = (DCM_SEQUENCE_ITEM*)malloc(sizeof(*item1));
694 DCM_CreateObject(&(item1->object), 0);
695 LST_Enqueue(&l1, item1);
696 }
697
698 {
699 DCM_ELEMENT e1;
700 const char *str = (*env)->GetStringUTFChars(env, s, 0);
701
702 memset(&e1, 0, sizeof(e1));
703 e1.tag = tag;
704 DCM_LookupElement(&e1);
705 e1.d.string = str;
706 e1.length = strlen(str);
707
708 cond = DCM_ModifyElements(&item1->object, &e1, 1, 0, 0, 0);
709
710 (*env)->ReleaseStringUTFChars(env, s, str);
711 }
712
713 return 0;
714 }
715
716 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_addSequenceJNI
717 (JNIEnv *env, jobject obj, jlong dcmObj, jint seqTag)
718 {
719 DCM_ELEMENT e;
720 CONDITION cond;
721 memset(&e, 0, sizeof(e));
722
723 e.tag = seqTag;
724 e.representation = DCM_SQ;
725 e.d.sq = LST_Create();
726
727 cond = DCM_AddSequenceElement((DCM_OBJECT**)&dcmObj, &e);
728 if (cond != DCM_NORMAL) {
729 COND_DumpConditions();
730 COND_PopCondition(TRUE);
731 return -1;
732 }
733 return 0;
734 }
735
736 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_addToSequenceJNI
737 (JNIEnv *env, jobject obj, jlong dcmObj, jint seqTag, jint index,
738 jlong newObj)
739 {
740 LST_HEAD* l = 0;
741 CONDITION cond;
742 DCM_OBJECT* copyObject = 0;
743 DCM_SEQUENCE_ITEM* item;
744
745 cond = DCM_GetSequenceList((DCM_OBJECT**)&dcmObj, seqTag, &l);
746 if (cond != DCM_NORMAL)
747 return -1;
748
749 cond = DCM_CopyObject((DCM_OBJECT**)&newObj, &copyObject);
750 if (cond != DCM_NORMAL)
751 return -1;
752
753 item = CTN_MALLOC(sizeof(*item));
754 if (item == 0)
755 return -1;
756
757 item->object = copyObject;
758 LST_Enqueue(&l, item);
759 return 0;
760 }
761
762 JNIEXPORT jstring JNICALL Java_DICOM_DICOMWrapper_getVRJNI
763 (JNIEnv *env, jobject obj, jlong dcmObj, jint tag)
764 {
765 DCM_ELEMENT e;
766 char s[128] = "XX";
767 jstring rtnString;
768 CONDITION cond;
769
770 e.tag = tag;
771
772 memset(&e, 0, sizeof(e));
773 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
774 if (cond != DCM_NORMAL) {
775 (void)COND_PopCondition(TRUE);
776 } else {
777 mapVRToString(e.representation, s);
778 }
779
780 rtnString = (*env)->NewStringUTF(env, s);
781
782 return rtnString;
783 }
784
785 JNIEXPORT jstring JNICALL Java_DICOM_DICOMWrapper_getDescrJNI
786 (JNIEnv *env, jobject obj, jlong dcmObj, jint tag)
787 {
788 DCM_ELEMENT e;
789 jstring rtnString;
790 CONDITION cond;
791
792 e.tag = tag;
793
794 memset(&e, 0, sizeof(e));
795 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
796 if (cond != DCM_NORMAL) {
797 (void)COND_PopCondition(TRUE);
798 strcpy(e.description, "No description");
799 }
800
801 rtnString = (*env)->NewStringUTF(env, e.description);
802
803 return rtnString;
804 }
805
806 JNIEXPORT jint JNICALL Java_DICOM_DICOMWrapper_getLengthJNI
807 (JNIEnv *env, jobject obj, jlong dcmObj, jint tag)
808 {
809 DCM_ELEMENT e;
810 CONDITION cond;
811
812 e.tag = tag;
813
814 memset(&e, 0, sizeof(e));
815 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
816 if (cond != DCM_NORMAL) {
817 (void)COND_PopCondition(TRUE);
818 return 0;
819 }
820
821 return (int)e.length;
822
823 }
824
825 /* Code for DICOM DIR Interface */
826
827
828 JNIEXPORT jint JNICALL Java_DICOM_DDR_DIRInterface_getPatientCount
829 (JNIEnv *env, jobject obj, jlong dcmObj)
830 {
831 jint patientCount;
832 LST_HEAD *pList;
833 DDR_PATIENT *p;
834
835 pList = LST_Create();
836 DDR_GetPatientList((DCM_OBJECT**)&dcmObj, &pList);
837 patientCount = LST_Count(&pList);
838 while ((p = LST_Dequeue(&pList)) != NULL)
839 free(p);
840
841 return patientCount;
842 }
843
844 JNIEXPORT void JNICALL Java_DICOM_DDR_DIRInterface_setPatientAttributes
845 (JNIEnv *env, jobject obj, jlong dcmObj, jint index, jobject patient)
846 {
847 jfieldID fid;
848 jstring jstr;
849 jclass cls;
850
851 DDR_PATIENT *p;
852 LST_HEAD *lst;
853
854 lst = LST_Create();
855 DDR_GetPatientList((DCM_OBJECT **)&dcmObj, &lst);
856 p = LST_Dequeue(&lst);
857 while (index-- > 0) {
858 free(p);
859 p = LST_Dequeue(&lst);
860 }
861 if (p == NULL)
862 return;
863
864 cls = (*env)->GetObjectClass(env, patient);
865
866 fid = (*env)->GetFieldID(env, cls, "PatientName", "Ljava/lang/String;");
867 if (fid == 0)
868 return;
869 jstr = (*env)->NewStringUTF(env, p->PatientName);
870 (*env)->SetObjectField(env, patient, fid, jstr);
871
872 fid = (*env)->GetFieldID(env, cls, "PatientID", "Ljava/lang/String;");
873 if (fid == 0)
874 return;
875 jstr = (*env)->NewStringUTF(env, p->PatientID);
876 (*env)->SetObjectField(env, patient, fid, jstr);
877
878 fid = (*env)->GetFieldID(env, cls, "BirthDate", "Ljava/lang/String;");
879 if (fid == 0)
880 return;
881 jstr = (*env)->NewStringUTF(env, p->BirthDate);
882 (*env)->SetObjectField(env, patient, fid, jstr);
883
884 fid = (*env)->GetFieldID(env, cls, "Sex", "Ljava/lang/String;");
885 if (fid == 0)
886 return;
887 jstr = (*env)->NewStringUTF(env, p->Sex);
888 (*env)->SetObjectField(env, patient, fid, jstr);
889
890 while (p != NULL) {
891 free (p);
892 p = LST_Dequeue(&lst);
893 }
894 }
895
896
897 JNIEXPORT jint JNICALL Java_DICOM_DDR_DIRInterface_getStudyCount
898 (JNIEnv *env, jobject obj, jlong dcmObj, jstring patientID)
899 {
900 jint studyCount;
901 LST_HEAD *sList;
902 DDR_STUDY *s;
903
904 const char *str = (*env)->GetStringUTFChars(env, patientID, 0);
905
906 sList = LST_Create();
907 DDR_GetStudyList((DCM_OBJECT**)&dcmObj, str, &sList);
908
909 (*env)->ReleaseStringUTFChars(env, patientID, str);
910
911 studyCount = LST_Count(&sList);
912 while ((s = LST_Dequeue(&sList)) != NULL)
913 free(s);
914
915 return studyCount;
916 }
917
918
919 JNIEXPORT void JNICALL Java_DICOM_DDR_DIRInterface_setStudyAttributes
920 (JNIEnv *env, jobject obj, jlong dcmObj, jstring patientID,
921 jint index, jobject study)
922 {
923 jfieldID fid;
924 jstring jstr;
925 jclass cls;
926
927 DDR_STUDY *s;
928 LST_HEAD *lst;
929
930 const char *str = (*env)->GetStringUTFChars(env, patientID, 0);
931
932 lst = LST_Create();
933 DDR_GetStudyList((DCM_OBJECT **)&dcmObj, str, &lst);
934 (*env)->ReleaseStringUTFChars(env, patientID, str);
935
936 s = LST_Dequeue(&lst);
937 while (index-- > 0) {
938 free (s);
939 s = LST_Dequeue(&lst);
940 }
941 if (s == NULL)
942 return;
943
944 cls = (*env)->GetObjectClass(env, study);
945
946 fid = (*env)->GetFieldID(env, cls, "StudyDate", "Ljava/lang/String;");
947 if (fid == 0)
948 return;
949 jstr = (*env)->NewStringUTF(env, s->StudyDate);
950 (*env)->SetObjectField(env, study, fid, jstr);
951
952 fid = (*env)->GetFieldID(env, cls, "StudyTime", "Ljava/lang/String;");
953 if (fid == 0)
954 return;
955 jstr = (*env)->NewStringUTF(env, s->StudyTime);
956 (*env)->SetObjectField(env, study, fid, jstr);
957
958 fid = (*env)->GetFieldID(env, cls, "StudyDescription", "Ljava/lang/String;");
959 if (fid == 0)
960 return;
961 jstr = (*env)->NewStringUTF(env, s->StudyDescription);
962 (*env)->SetObjectField(env, study, fid, jstr);
963
964 fid = (*env)->GetFieldID(env, cls, "StudyInstanceUID", "Ljava/lang/String;");
965 if (fid == 0)
966 return;
967 jstr = (*env)->NewStringUTF(env, s->StudyInstanceUID);
968 (*env)->SetObjectField(env, study, fid, jstr);
969
970 fid = (*env)->GetFieldID(env, cls, "StudyID", "Ljava/lang/String;");
971 if (fid == 0)
972 return;
973 jstr = (*env)->NewStringUTF(env, s->StudyID);
974 (*env)->SetObjectField(env, study, fid, jstr);
975
976 fid = (*env)->GetFieldID(env, cls, "AccessionNumber", "Ljava/lang/String;");
977 if (fid == 0)
978 return;
979 jstr = (*env)->NewStringUTF(env, s->AccessionNumber);
980 (*env)->SetObjectField(env, study, fid, jstr);
981
982 while (s != NULL) {
983 free (s);
984 s = LST_Dequeue(&lst);
985 }
986 }
987
988 JNIEXPORT jint JNICALL Java_DICOM_DDR_DIRInterface_getSeriesCount
989 (JNIEnv *env, jobject obj, jlong dcmObj, jstring patientID,
990 jstring studyInstanceUID)
991 {
992 jint seriesCount;
993 LST_HEAD *sList;
994 DDR_SERIES *s;
995
996 const char *strPatient = (*env)->GetStringUTFChars(env, patientID, 0);
997 const char *strStudy = (*env)->GetStringUTFChars(env, studyInstanceUID, 0);
998
999 sList = LST_Create();
1000 DDR_GetSeriesList((DCM_OBJECT**)&dcmObj, strPatient, strStudy, &sList);
1001
1002 (*env)->ReleaseStringUTFChars(env, patientID, strPatient);
1003 (*env)->ReleaseStringUTFChars(env, studyInstanceUID, strStudy);
1004
1005 seriesCount = LST_Count(&sList);
1006 while ((s = LST_Dequeue(&sList)) != NULL)
1007 free(s);
1008
1009 return seriesCount;
1010 }
1011
1012 JNIEXPORT void JNICALL Java_DICOM_DDR_DIRInterface_setSeriesAttributes
1013 (JNIEnv *env, jobject obj, jlong dcmObj, jstring patientID,
1014 jstring studyInstanceUID, jint index, jobject series)
1015 {
1016 jfieldID fid;
1017 jstring jstr;
1018 jclass cls;
1019
1020 DDR_SERIES *s;
1021 LST_HEAD *lst;
1022
1023 const char *strPatient = (*env)->GetStringUTFChars(env, patientID, 0);
1024 const char *strStudy = (*env)->GetStringUTFChars(env, studyInstanceUID, 0);
1025
1026 lst = LST_Create();
1027 DDR_GetSeriesList((DCM_OBJECT **)&dcmObj, strPatient, strStudy, &lst);
1028 (*env)->ReleaseStringUTFChars(env, patientID, strPatient);
1029 (*env)->ReleaseStringUTFChars(env, studyInstanceUID, strStudy);
1030
1031 s = LST_Dequeue(&lst);
1032 while (index-- > 0) {
1033 free (s);
1034 s = LST_Dequeue(&lst);
1035 }
1036 if (s == NULL)
1037 return;
1038
1039 cls = (*env)->GetObjectClass(env, series);
1040
1041 fid = (*env)->GetFieldID(env, cls, "Modality", "Ljava/lang/String;");
1042 if (fid == 0)
1043 return;
1044 jstr = (*env)->NewStringUTF(env, s->Modality);
1045 (*env)->SetObjectField(env, series, fid, jstr);
1046
1047 fid = (*env)->GetFieldID(env, cls, "SeriesInstanceUID", "Ljava/lang/String;");
1048 if (fid == 0)
1049 return;
1050 jstr = (*env)->NewStringUTF(env, s->SeriesInstanceUID);
1051 (*env)->SetObjectField(env, series, fid, jstr);
1052
1053 fid = (*env)->GetFieldID(env, cls, "SeriesNumber", "Ljava/lang/String;");
1054 if (fid == 0)
1055 return;
1056 jstr = (*env)->NewStringUTF(env, s->SeriesNumber);
1057 (*env)->SetObjectField(env, series, fid, jstr);
1058
1059 while (s != NULL) {
1060 free (s);
1061 s = LST_Dequeue(&lst);
1062 }
1063 }
1064
1065 JNIEXPORT jint JNICALL Java_DICOM_DDR_DIRInterface_getLeafCount
1066 (JNIEnv *env, jobject obj, jlong dcmObj, jstring patientID,
1067 jstring studyInstanceUID, jstring seriesInstanceUID)
1068 {
1069 jint leafCount;
1070 LST_HEAD *lList;
1071 DDR_SERIES_LEAF *l;
1072
1073 const char *strPatient = (*env)->GetStringUTFChars(env, patientID, 0);
1074 const char *strStudy = (*env)->GetStringUTFChars(env, studyInstanceUID, 0);
1075 const char *strSeries = (*env)->GetStringUTFChars(env, seriesInstanceUID, 0);
1076
1077 lList = LST_Create();
1078 DDR_GetSeriesLeafList((DCM_OBJECT**)&dcmObj, strPatient, strStudy, strSeries,
1079 &lList);
1080
1081 (*env)->ReleaseStringUTFChars(env, patientID, strPatient);
1082 (*env)->ReleaseStringUTFChars(env, studyInstanceUID, strStudy);
1083 (*env)->ReleaseStringUTFChars(env, seriesInstanceUID, strSeries);
1084
1085 leafCount = LST_Count(&lList);
1086 while ((l = LST_Dequeue(&lList)) != NULL)
1087 free(l);
1088
1089 return leafCount;
1090 }
1091
1092 JNIEXPORT void JNICALL Java_DICOM_DDR_DIRInterface_setLeafAttributes
1093 (JNIEnv *env, jobject obj, jlong dcmObj, jstring patientID,
1094 jstring studyInstanceUID, jstring seriesInstanceUID,
1095 jint index, jobject leaf)
1096 {
1097 jfieldID fid;
1098 jstring jstr;
1099 jclass cls;
1100
1101 DDR_SERIES_LEAF *l;
1102 LST_HEAD *lst;
1103
1104 const char *strPatient = (*env)->GetStringUTFChars(env, patientID, 0);
1105 const char *strStudy = (*env)->GetStringUTFChars(env, studyInstanceUID, 0);
1106 const char *strSeries = (*env)->GetStringUTFChars(env, seriesInstanceUID, 0);
1107
1108 lst = LST_Create();
1109 DDR_GetSeriesLeafList((DCM_OBJECT **)&dcmObj,
1110 strPatient, strStudy, strSeries,
1111 &lst);
1112 (*env)->ReleaseStringUTFChars(env, patientID, strPatient);
1113 (*env)->ReleaseStringUTFChars(env, studyInstanceUID, strStudy);
1114 (*env)->ReleaseStringUTFChars(env, seriesInstanceUID, strSeries);
1115
1116 l = LST_Dequeue(&lst);
1117 while (index-- > 0) {
1118 free (l);
1119 l = LST_Dequeue(&lst);
1120 }
1121 if (l == NULL)
1122 return;
1123
1124 cls = (*env)->GetObjectClass(env, leaf);
1125
1126 fid = (*env)->GetFieldID(env, cls, "RecordType", "Ljava/lang/String;");
1127 if (fid == 0)
1128 return;
1129 jstr = (*env)->NewStringUTF(env, l->RecordType);
1130 (*env)->SetObjectField(env, leaf, fid, jstr);
1131
1132 fid = (*env)->GetFieldID(env, cls, "FileID", "Ljava/lang/String;");
1133 if (fid == 0)
1134 return;
1135 jstr = (*env)->NewStringUTF(env, l->FileID);
1136 (*env)->SetObjectField(env, leaf, fid, jstr);
1137
1138 fid = (*env)->GetFieldID(env, cls, "SOPClassUID", "Ljava/lang/String;");
1139 if (fid == 0)
1140 return;
1141 jstr = (*env)->NewStringUTF(env, l->SOPClassUID);
1142 (*env)->SetObjectField(env, leaf, fid, jstr);
1143
1144 fid = (*env)->GetFieldID(env, cls, "SOPInstanceUID", "Ljava/lang/String;");
1145 if (fid == 0)
1146 return;
1147 jstr = (*env)->NewStringUTF(env, l->SOPInstanceUID);
1148 (*env)->SetObjectField(env, leaf, fid, jstr);
1149
1150 fid = (*env)->GetFieldID(env, cls, "TransferSyntax", "Ljava/lang/String;");
1151 if (fid == 0)
1152 return;
1153 jstr = (*env)->NewStringUTF(env, l->TransferSyntaxUID);
1154 (*env)->SetObjectField(env, leaf, fid, jstr);
1155
1156
1157 while (l != NULL) {
1158 free (l);
1159 l = LST_Dequeue(&lst);
1160 }
1161 }
1162
1163 /* Code for DICOM Image Interface */
1164
1165
1166 JNIEXPORT void JNICALL Java_DICOM_InfoObj_Image_setPatientAttributes
1167 (JNIEnv *env, jobject obj, jlong dcmObj, jobject patient)
1168 {
1169 jfieldID fid;
1170 jstring jstr;
1171 jclass cls;
1172 char patientName[DICOM_PN_LENGTH+1] = "";
1173 char patientID[DICOM_LO_LENGTH+1] = "";
1174 char birthDate[DICOM_DA_LENGTH+1] = "";
1175 char sex[DICOM_CS_LENGTH + 1] = "";
1176 long flag = 1;
1177
1178 DCM_FLAGGED_ELEMENT attributes[] = {
1179 {DCM_PATNAME, DCM_PN, "", 1, sizeof(patientName), NULL, 1, NULL},
1180 {DCM_PATID, DCM_LO, "", 1, sizeof(patientID), NULL, 2, NULL},
1181 {DCM_PATBIRTHDATE, DCM_DA, "", 1, sizeof(birthDate), NULL, 4, NULL},
1182 {DCM_PATSEX, DCM_CS, "", 1, sizeof(sex), NULL, 8, NULL}
1183 };
1184
1185 attributes[0].e.d.string = patientName;
1186 attributes[0].flagAddress = &flag;
1187 attributes[1].e.d.string = patientID;
1188 attributes[1].flagAddress = &flag;
1189 attributes[2].e.d.string = birthDate;
1190 attributes[2].flagAddress = &flag;
1191 attributes[3].e.d.string = sex;
1192 attributes[3].flagAddress = &flag;
1193
1194 DCM_ParseObject((DCM_OBJECT **)&dcmObj, NULL, 0, attributes,
1195 (int)DIM_OF(attributes), NULL);
1196
1197 cls = (*env)->GetObjectClass(env, patient);
1198
1199 if (flag & 1) {
1200 fid = (*env)->GetFieldID(env, cls, "PatientName", "Ljava/lang/String;");
1201 if (fid == 0)
1202 return;
1203 jstr = (*env)->NewStringUTF(env, patientName);
1204 (*env)->SetObjectField(env, patient, fid, jstr);
1205 }
1206
1207 if (flag & 2) {
1208 fid = (*env)->GetFieldID(env, cls, "PatientID", "Ljava/lang/String;");
1209 if (fid == 0)
1210 return;
1211 jstr = (*env)->NewStringUTF(env, patientID);
1212 (*env)->SetObjectField(env, patient, fid, jstr);
1213 }
1214
1215 if (!(flag & 4))
1216 strcpy(birthDate, "");
1217
1218 fid = (*env)->GetFieldID(env, cls, "BirthDate", "Ljava/lang/String;");
1219 if (fid == 0)
1220 return;
1221 jstr = (*env)->NewStringUTF(env, birthDate);
1222 (*env)->SetObjectField(env, patient, fid, jstr);
1223
1224
1225 if (flag & 8) {
1226 fid = (*env)->GetFieldID(env, cls, "Sex", "Ljava/lang/String;");
1227 if (fid == 0)
1228 return;
1229 jstr = (*env)->NewStringUTF(env, sex);
1230 (*env)->SetObjectField(env, patient, fid, jstr);
1231 }
1232 }
1233
1234
1235 JNIEXPORT void JNICALL Java_DICOM_InfoObj_Image_setImgAttributes
1236 (JNIEnv *env, jobject obj, jlong dcmObj, jobject img)
1237 {
1238 jfieldID fid;
1239 jstring jstr;
1240 jclass cls;
1241 char windowCenter[DICOM_DS_LENGTH+1] = "0";
1242 char windowWidth[DICOM_DS_LENGTH+1] = "0";
1243 char rescaleSlope[DICOM_DS_LENGTH+1] = "1";
1244 char rescaleIntercept[DICOM_DS_LENGTH + 1] = "0";
1245 char numberOfFrames[DICOM_IS_LENGTH + 1] = "1";
1246 long flag = 1;
1247 U16 samplesPerPixel;
1248 U16 rows, columns, bitsAllocated, bitsStored, highBit, pixelRepresentation;
1249 char photometricInterpretation[DICOM_CS_LENGTH+1] = "";
1250 int frameCount;
1251
1252 DCM_FLAGGED_ELEMENT flagged[] = {
1253 {DCM_IMGWINDOWCENTER, DCM_DS, "", 1, sizeof(windowCenter), NULL, 1, NULL},
1254 {DCM_IMGWINDOWWIDTH, DCM_DS, "", 1, sizeof(windowWidth), NULL, 2, NULL},
1255 {DCM_IMGRESCALESLOPE, DCM_DS, "", 1, sizeof(rescaleSlope), NULL, 4, NULL},
1256 {DCM_IMGRESCALEINTERCEPT, DCM_DS, "", 1, sizeof(rescaleIntercept), NULL, 8, NULL},
1257 {DCM_IMGNUMBEROFFRAMES, DCM_IS, "", 1, sizeof(numberOfFrames), NULL, 0x10, NULL}
1258 };
1259 DCM_ELEMENT required[] = {
1260 {DCM_IMGROWS, DCM_US, "", 1, sizeof(rows), NULL},
1261 {DCM_IMGCOLUMNS, DCM_US, "", 1, sizeof(columns), NULL},
1262 {DCM_IMGBITSALLOCATED, DCM_US, "", 1, sizeof(bitsAllocated), NULL},
1263 {DCM_IMGBITSSTORED, DCM_US, "", 1, sizeof(bitsStored), NULL},
1264 {DCM_IMGHIGHBIT, DCM_US, "", 1, sizeof(highBit), NULL},
1265 {DCM_IMGPIXELREPRESENTATION, DCM_US, "", 1, sizeof(pixelRepresentation), NULL},
1266 {DCM_IMGSAMPLESPERPIXEL, DCM_US, "", 1, sizeof(samplesPerPixel), NULL},
1267 {DCM_IMGPHOTOMETRICINTERP, DCM_CS, "", 1, sizeof(photometricInterpretation), NULL}
1268 };
1269
1270 float f = 0.;
1271
1272 flagged[0].e.d.string = windowCenter;
1273 flagged[0].flagAddress = &flag;
1274 flagged[1].e.d.string = windowWidth;
1275 flagged[1].flagAddress = &flag;
1276 flagged[2].e.d.string = rescaleSlope;
1277 flagged[2].flagAddress = &flag;
1278 flagged[3].e.d.string = rescaleIntercept;
1279 flagged[3].flagAddress = &flag;
1280 flagged[4].e.d.string = numberOfFrames;
1281 flagged[4].flagAddress = &flag;
1282
1283 required[0].d.us = &rows;
1284 required[1].d.us = &columns;
1285 required[2].d.us = &bitsAllocated;
1286 required[3].d.us = &bitsStored;
1287 required[4].d.us = &highBit;
1288 required[5].d.us = &pixelRepresentation;
1289 required[6].d.us = &samplesPerPixel;
1290 required[7].d.string = photometricInterpretation;
1291
1292 DCM_ParseObject((DCM_OBJECT **)&dcmObj,
1293 required, (int)DIM_OF(required),
1294 flagged, (int)DIM_OF(flagged), NULL);
1295
1296 cls = (*env)->GetObjectClass(env, img);
1297
1298 frameCount = atoi(numberOfFrames);
1299 if (frameCount <= 0)
1300 frameCount = 1;
1301
1302
1303 if (getenv("CTN_REDUCED") != NULL) {
1304 if ((rows > 512) && (columns > 512) && (frameCount > 1)) {
1305 rows /= 2;
1306 columns /= 2;
1307 }
1308 }
1309 if (getenv("CTN_EXPANDED") != NULL) {
1310 if ((rows < 128) && (columns < 128)) {
1311 rows *= 4;
1312 columns *= 4;
1313 }
1314 }
1315
1316 fid = (*env)->GetFieldID(env, cls, "DCMObject", "J");
1317 if (fid == 0)
1318 return;
1319 (*env)->SetLongField(env, img, fid, dcmObj);
1320
1321 fid = (*env)->GetFieldID(env, cls, "PhotometricInterpretation",
1322 "Ljava/lang/String;");
1323 if (fid == 0)
1324 return;
1325 jstr = (*env)->NewStringUTF(env, photometricInterpretation);
1326 (*env)->SetObjectField(env, img, fid, jstr);
1327
1328 fid = (*env)->GetFieldID(env, cls, "SamplesPerPixel", "I");
1329 if (fid == 0)
1330 return;
1331 (*env)->SetIntField(env, img, fid, samplesPerPixel);
1332
1333 fid = (*env)->GetFieldID(env, cls, "Rows", "I");
1334 if (fid == 0)
1335 return;
1336 (*env)->SetIntField(env, img, fid, rows);
1337
1338 fid = (*env)->GetFieldID(env, cls, "Columns", "I");
1339 if (fid == 0)
1340 return;
1341 (*env)->SetIntField(env, img, fid, columns);
1342
1343 fid = (*env)->GetFieldID(env, cls, "BitsAllocated", "I");
1344 if (fid == 0)
1345 return;
1346 (*env)->SetIntField(env, img, fid, bitsAllocated);
1347
1348 fid = (*env)->GetFieldID(env, cls, "BitsStored", "I");
1349 if (fid == 0)
1350 return;
1351 (*env)->SetIntField(env, img, fid, bitsStored);
1352
1353 fid = (*env)->GetFieldID(env, cls, "HighBit", "I");
1354 if (fid == 0)
1355 return;
1356 (*env)->SetIntField(env, img, fid, highBit);
1357
1358 fid = (*env)->GetFieldID(env, cls, "PixelRepresentation", "I");
1359 if (fid == 0)
1360 return;
1361 (*env)->SetIntField(env, img, fid, pixelRepresentation);
1362
1363
1364 if (flag & 1) {
1365 fid = (*env)->GetFieldID(env, cls, "WindowCenter", "F");
1366 if (fid == 0)
1367 return;
1368 sscanf(windowCenter, "%f", &f);
1369 (*env)->SetFloatField(env, img, fid, f);
1370 }
1371
1372 if (flag & 2) {
1373 fid = (*env)->GetFieldID(env, cls, "WindowWidth", "F");
1374 if (fid == 0)
1375 return;
1376 sscanf(windowWidth, "%f", &f);
1377 (*env)->SetFloatField(env, img, fid, f);
1378 }
1379
1380 if (flag & 4) {
1381 fid = (*env)->GetFieldID(env, cls, "RescaleSlope", "F");
1382 if (fid == 0)
1383 return;
1384 sscanf(rescaleSlope, "%f", &f);
1385 (*env)->SetFloatField(env, img, fid, f);
1386 }
1387
1388 if (flag & 8) {
1389 fid = (*env)->GetFieldID(env, cls, "RescaleIntercept", "F");
1390 if (fid == 0)
1391 return;
1392 sscanf(rescaleIntercept, "%f", &f);
1393 (*env)->SetFloatField(env, img, fid, f);
1394 }
1395
1396 #if 0
1397 if (frameCount > 30)
1398 frameCount = 30;
1399 #endif
1400
1401 fid = (*env)->GetFieldID(env, cls, "FrameCount", "I");
1402 if (fid == 0)
1403 return;
1404 (*env)->SetIntField(env, img, fid, frameCount);
1405
1406 }
1407
1408 /* The following code supports the Image Pixel Module */
1409
1410 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_getPixelsByte
1411 (JNIEnv *env, jobject obj, jlong dcmObj, jbyteArray arr,
1412 jint rows, jint cols, jint samplesPerPixel)
1413 {
1414 jbyte *pixels = 0;
1415 DCM_ELEMENT e = {DCM_PXLPIXELDATA, DCM_OB, "", 1, 0, NULL};
1416 void *ctx = NULL;
1417 U32 rtnLength = 0;
1418
1419 jsize len;
1420 len = (*env)->GetArrayLength(env, arr);
1421 pixels = (*env)->GetByteArrayElements(env, arr, 0);
1422
1423 e.length = len;
1424 if (len != rows*cols*samplesPerPixel) {
1425 fprintf(stderr, "Len = %d, rows = %d, cols = %d, samples/pixel = %d\n",
1426 len, rows, cols, samplesPerPixel);
1427 exit(1);
1428 }
1429 e.d.ot = pixels;
1430 DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
1431
1432 (*env)->ReleaseByteArrayElements(env, arr, pixels, 0);
1433 }
1434
1435
1436 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_getPixelsShort
1437 (JNIEnv *env, jobject obj, jlong dcmObj, jshortArray arr,
1438 jint rows, jint cols, jint samplesPerPixel)
1439 {
1440 jshort *pixels = 0;
1441 DCM_ELEMENT e = {DCM_PXLPIXELDATA, DCM_OB, "", 1, 0, NULL};
1442 void *ctx = NULL;
1443 U32 rtnLength = 0;
1444
1445 jsize len;
1446 len = (*env)->GetArrayLength(env, arr);
1447 pixels = (*env)->GetShortArrayElements(env, arr, 0);
1448
1449 e.length = len * 2;
1450 if (len != rows*cols*samplesPerPixel) {
1451 fprintf(stderr, "Len = %d, rows = %d, cols = %d, samples/pixel = %d\n",
1452 len, rows, cols, samplesPerPixel);
1453 exit(1);
1454 }
1455 e.d.ot = pixels;
1456 DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
1457
1458 (*env)->ReleaseShortArrayElements(env, arr, pixels, 0);
1459 }
1460
1461 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_remapPixelsByte
1462 (JNIEnv *env, jobject obj, jlong dcmObj, jbyteArray arr,
1463 jint rows, jint cols, jint samplesPerPixel, jintArray arrayOut)
1464 {
1465 jbyte *inPixels = 0;
1466 jint *outPixels;
1467 int index;
1468 unsigned char *c;
1469 U32 *u;
1470
1471 jsize len;
1472 len = (*env)->GetArrayLength(env, arr);
1473
1474 inPixels = (*env)->GetByteArrayElements(env, arr, 0);
1475 outPixels = (*env)->GetIntArrayElements(env, arrayOut, 0);
1476
1477 c = (unsigned char*)inPixels;
1478 u = (U32*)outPixels;
1479
1480 for (index = 0; index < rows * cols; index++)
1481 u[index] = c[index] << 16 | c[index] << 8 | c[index];
1482
1483 (*env)->ReleaseByteArrayElements(env, arr, inPixels, 0);
1484 (*env)->ReleaseIntArrayElements(env, arr, outPixels, 0);
1485 }
1486
1487 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_getPixelFrameByte
1488 (JNIEnv *env, jobject obj, jlong dcmObj, jshortArray arr,
1489 jint rows, jint cols, jint samplesPerPixel, jint frame)
1490 {
1491 jbyte *pixels = 0;
1492 DCM_ELEMENT e = {DCM_PXLPIXELDATA, DCM_OB, "", 1, 0, NULL};
1493 unsigned long offset;
1494 CONDITION cond;
1495 jsize len;
1496
1497 len = (*env)->GetArrayLength(env, arr);
1498 pixels = (*env)->GetByteArrayElements(env, arr, 0);
1499
1500 e.length = len;
1501 if (len != rows*cols*samplesPerPixel) {
1502 fprintf(stderr, "Len = %d, rows = %d, cols = %d, samplesPerPixel = %d\n",
1503 len, rows, cols, samplesPerPixel);
1504 exit(1); /* repair */
1505 }
1506 e.d.ot = pixels;
1507 offset = (frame - 1) * rows * cols * samplesPerPixel;
1508 cond = DCM_GetElementValueOffset((DCM_OBJECT**)&dcmObj, &e, offset);
1509 if (cond != DCM_NORMAL) {
1510 COND_DumpConditions();
1511 exit(1); /* repair */
1512 }
1513
1514 (*env)->ReleaseByteArrayElements(env, arr, pixels, 0);
1515 }
1516
1517
1518 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_getPixelFrameShort
1519 (JNIEnv *env, jobject obj, jlong dcmObj, jshortArray arr,
1520 jint rows, jint cols, jint samplesPerPixel, jint frame)
1521 {
1522 jshort *pixels = 0;
1523 DCM_ELEMENT e = {DCM_PXLPIXELDATA, DCM_OB, "", 1, 0, NULL};
1524 unsigned long offset;
1525 CONDITION cond;
1526 jsize len;
1527
1528 len = (*env)->GetArrayLength(env, arr);
1529 pixels = (*env)->GetShortArrayElements(env, arr, 0);
1530
1531 e.length = len * 2;
1532 if (len != rows*cols*samplesPerPixel) {
1533 fprintf(stderr, "Len = %d, rows = %d, cols = %d, samples/pixel = %d\n",
1534 len, rows, cols, samplesPerPixel);
1535 exit(1); /* repair */
1536 }
1537 e.d.ot = pixels;
1538
1539 offset = (frame - 1) * rows * cols * samplesPerPixel * 2;
1540 cond = DCM_GetElementValueOffset((DCM_OBJECT**)&dcmObj, &e, offset);
1541 if (cond != DCM_NORMAL) {
1542 COND_DumpConditions();
1543 exit(1); /* repair */
1544 }
1545
1546 (*env)->ReleaseShortArrayElements(env, arr, pixels, 0);
1547 }
1548
1549
1550 static jint getIntParameter(JNIEnv *env, jobject obj, const char* fieldName)
1551 {
1552 jfieldID fid;
1553 jclass cls;
1554 jint rtnValue;
1555
1556 cls = (*env)->GetObjectClass(env, obj);
1557
1558 fid = (*env)->GetFieldID(env, cls, fieldName, "I");
1559 if (fid == 0)
1560 return;
1561
1562 rtnValue = (*env)->GetIntField(env, obj, fid);
1563
1564 return rtnValue;
1565 }
1566
1567 static jint getFloatParameter(JNIEnv *env, jobject obj, const char* fieldName)
1568 {
1569 jfieldID fid;
1570 jclass cls;
1571 jfloat rtnValue;
1572
1573 cls = (*env)->GetObjectClass(env, obj);
1574
1575 fid = (*env)->GetFieldID(env, cls, fieldName, "F");
1576 if (fid == 0)
1577 return;
1578
1579 rtnValue = (*env)->GetFloatField(env, obj, fid);
1580
1581 return rtnValue;
1582 }
1583
1584 typedef struct {
1585 jint rows;
1586 jint cols;
1587 jint bitsAllocated;
1588 jint bitsStored;
1589 jint highBit;
1590 jint pixelRepresentation;
1591 jint samplesPerPixel;
1592
1593 jfloat windowCenter;
1594 jfloat windowWidth;
1595 jfloat rescaleSlope;
1596 jfloat rescaleIntercept;
1597 } IMAGE_PARAMETERS;
1598
1599
1600 static void getImageParameters(JNIEnv *env, jobject obj, IMAGE_PARAMETERS *params)
1601 {
1602 params->rows = getIntParameter(env, obj, "Rows");
1603 params->cols = getIntParameter(env, obj, "Columns");
1604 params->bitsAllocated = getIntParameter(env, obj, "BitsAllocated");
1605 params->bitsStored = getIntParameter(env, obj, "BitsStored");
1606 params->highBit = getIntParameter(env, obj, "HighBit");
1607 params->pixelRepresentation = getIntParameter(env, obj, "PixelRepresentation");
1608 params->samplesPerPixel = getIntParameter(env, obj, "SamplesPerPixel");
1609
1610 params->windowCenter = getFloatParameter(env, obj, "WindowCenter");
1611 params->windowWidth = getFloatParameter(env, obj, "WindowWidth");
1612 params->rescaleSlope = getFloatParameter(env, obj, "RescaleSlope");
1613 params->rescaleIntercept = getFloatParameter(env, obj, "RescaleIntercept");
1614 }
1615
1616 static void* getPixels(jlong dcmObj, jint rows, jint cols, jint samplesPerPixel,
1617 jint bitsPerPixel, jint frame)
1618 {
1619 unsigned char* p;
1620 DCM_ELEMENT e = {DCM_PXLPIXELDATA, DCM_OB, "", 1, 0, NULL};
1621 unsigned long offset;
1622 CONDITION cond;
1623 U16 localRows = 0;
1624 U16 localCols = 0;
1625
1626 DCM_ELEMENT row_cols[] = {
1627 { DCM_IMGROWS, DCM_US, "", 1, sizeof(U16), NULL},
1628 { DCM_IMGCOLUMNS, DCM_US, "", 1, sizeof(U16), NULL}
1629 };
1630
1631 row_cols[0].d.us = &localRows;
1632 row_cols[1].d.us = &localCols;
1633
1634 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, row_cols, 2, NULL, 0, NULL);
1635 if (cond != DCM_NORMAL) {
1636 fprintf(stderr, "Could not get rows/cols in getPixels\n"); /* repair */
1637 COND_DumpConditions();
1638 exit(1);
1639 }
1640
1641 e.length = localRows * localCols * samplesPerPixel * (bitsPerPixel/8);
1642 p = malloc(e.length);
1643 if (p == NULL) { /* repair */
1644 fprintf(stderr, "Unable to malloc %d bytes in getPixels\n",
1645 rows * cols * samplesPerPixel * (bitsPerPixel/8));
1646 exit(1);
1647 }
1648
1649 e.d.ot = p;
1650 offset = (frame - 1) * e.length;
1651 cond = DCM_GetElementValueOffset((DCM_OBJECT**)&dcmObj, &e, offset);
1652 if (cond != DCM_NORMAL) {
1653 COND_DumpConditions();
1654 exit(1); /* repair */
1655 }
1656 return p;
1657 }
1658
1659
1660 static void map16BitToColor32(const U16 *up, U32 *pixels,
1661 const IMAGE_PARAMETERS* params,
1662 U16 originalRows, U16 originalColumns,
1663 jint center, jint width)
1664 {
1665 if (params->pixelRepresentation == DCM_PIXELUNSIGNED) {
1666 S32 shift = 0;
1667 S32 index = 0;
1668 S32 p;
1669 S32 intensity;
1670 float slope;
1671
1672 shift = center - width/2;
1673 slope = 254./(float)width;
1674
1675 for (index = 0; index < params->rows * params->cols; index++) {
1676 p = *up++;
1677 p = (p-shift) * slope;
1678 if (p < 0)
1679 p = 0;
1680 else if (p > 254)
1681 p = 254;
1682
1683 *pixels++ = p << 16 | p << 8 | p;
1684 }
1685 } else {
1686 S32 shift = 0;
1687 S32 index = 0;
1688 S32 p;
1689 S16 *sp;
1690 S32 intensity;
1691 float slope;
1692
1693 sp = (S16 *)up;
1694
1695 /* Some of the NM images we see have no C/W values and terrible
1696 ** values for high bit. We are going to try to recalculate here.
1697 */
1698
1699 if (originalColumns == 64 && width > 4096) {
1700 S16 maxPixel = 0;
1701 S16 minPixel = 0;
1702
1703 maxPixel = minPixel = sp[0];
1704 for (index = 0; index < originalRows * originalColumns; index++) {
1705 if (sp[index] > maxPixel)
1706 maxPixel = sp[index];
1707 if (sp[index] < minPixel)
1708 minPixel = sp[index];
1709 }
1710
1711 width = maxPixel - minPixel;
1712 center = width/2;
1713 }
1714 shift = center - width/2;
1715 slope = 254./(float)width;
1716
1717 #if 0
1718 if (params->cols == 64) {
1719 for (index = 0; index < 64 * 64; index++) {
1720 fprintf(stderr, " %5d", sp[index]);
1721 if ((index % 8) == 1)
1722 fprintf(stderr, "\n");
1723 }
1724 }
1725 #endif
1726
1727 if ((originalRows > 128) ||
1728 (originalColumns > 128) ||
1729 getenv("CTN_EXPANDED") == NULL) {
1730
1731 for (index = 0; index < params->rows * params->cols; index++) {
1732 p = *sp++;
1733 p = (p-shift) * slope;
1734 if (p < 0)
1735 p = 0;
1736 else if (p > 254)
1737 p = 254;
1738
1739 *pixels++ = p << 16 | p << 8 | p;
1740 }
1741 } else {
1742 int rowIndex = 0;
1743 int colIndex = 0;
1744 U32 newP;
1745
1746 for (rowIndex = 0; rowIndex < originalRows; rowIndex++, pixels += 3*params->cols) {
1747 for (colIndex = 0; colIndex < originalColumns; colIndex++) {
1748 p = *sp++;
1749 p = (p-shift) * slope;
1750 if (p < 0)
1751 p = 0;
1752 else if (p > 254)
1753 p = 254;
1754
1755 newP = p << 16 | p << 8 | p;
1756
1757 pixels[0] = newP;
1758 pixels[1] = newP;
1759 pixels[2] = newP;
1760 pixels[3] = newP;
1761
1762 pixels[params->cols] = newP;
1763 pixels[params->cols+1] = newP;
1764 pixels[params->cols+2] = newP;
1765 pixels[params->cols+3] = newP;
1766
1767 pixels[(2*params->cols)] = newP;
1768 pixels[(2*params->cols) + 1] = newP;
1769 pixels[(2*params->cols) + 2] = newP;
1770 pixels[(2*params->cols) + 3] = newP;
1771
1772 pixels[(3*params->cols)] = newP;
1773 pixels[(3*params->cols) + 1] = newP;
1774 pixels[(3*params->cols) + 2] = newP;
1775 pixels[(3*params->cols) + 3] = newP;
1776
1777 pixels+=4;
1778 }
1779 }
1780 }
1781 }
1782 }
1783
1784 static void map16BitToColor32Slope(const U16 *up, U32 *pixels,
1785 const IMAGE_PARAMETERS* params,
1786 jint center, jint width)
1787 {
1788 if (params->pixelRepresentation == DCM_PIXELUNSIGNED) {
1789 S32 shift = 0;
1790 S32 index = 0;
1791 S32 p;
1792 S32 intensity;
1793 float slope;
1794
1795 shift = center - width/2;
1796 slope = 254./(float)width;
1797
1798 #if 0
1799 fprintf(stderr, "C/W = %d/%d\n", center,width);
1800 fprintf(stderr, "S/I = %f/%f\n", params->rescaleSlope, params->rescaleIntercept);
1801 fprintf(stderr, "shift/slope = %d/%f\n", shift, slope);
1802 #endif
1803
1804
1805 for (index = 0; index < params->rows * params->cols; index++) {
1806 p = *up++;
1807 p = (p * params->rescaleSlope) + params->rescaleIntercept;
1808 p = (p-shift) * slope;
1809 if (p < 0)
1810 p = 0;
1811 else if (p > 254)
1812 p = 254;
1813
1814 *pixels++ = p << 16 | p << 8 | p;
1815 }
1816 } else {
1817 S32 shift = 0;
1818 S32 index = 0;
1819 S32 p;
1820 S32 intensity;
1821 float slope;
1822
1823 shift = center - width/2;
1824 slope = 254./(float)width;
1825
1826 #if 0
1827 fprintf(stderr, "C/W = %d/%d\n", center,width);
1828 fprintf(stderr, "S/I = %f/%f\n", params->rescaleSlope, params->rescaleIntercept);
1829 fprintf(stderr, "shift/slope = %d/%f\n", shift, slope);
1830 #endif
1831
1832 for (index = 0; index < params->rows * params->cols; index++) {
1833 p = *up++;
1834 p = (p * params->rescaleSlope) + params->rescaleIntercept;
1835 p = (p-shift) * slope;
1836 if (p < 0)
1837 p = 0;
1838 else if (p > 254)
1839 p = 254;
1840
1841 *pixels++ = p << 16 | p << 8 | p;
1842 }
1843 }
1844 }
1845
1846 static void getPixelFrameAsColor_Monochrome_8(JNIEnv *env, jobject obj, jlong dcmObj,
1847 jintArray arr, jint rows, jint cols,
1848 jint frame, const IMAGE_PARAMETERS *params)
1849 {
1850 U32 *pixels = 0;
1851 unsigned char *p = 0;
1852 CONDITION cond;
1853 jsize len;
1854 int index;
1855 int pixelCount;
1856 U16 localRows = 0;
1857 U16 localCols = 0;
1858
1859 DCM_ELEMENT row_cols[] = {
1860 { DCM_IMGROWS, DCM_US, "", 1, sizeof(U16), NULL},
1861 { DCM_IMGCOLUMNS, DCM_US, "", 1, sizeof(U16), NULL}
1862 };
1863
1864 len = (*env)->GetArrayLength(env, arr);
1865 pixels = (U32*)(*env)->GetIntArrayElements(env, arr, 0);
1866
1867 p = getPixels(dcmObj, params->rows, params->cols, params->samplesPerPixel, 8, frame);
1868
1869 pixelCount = params->rows * params->cols * params->samplesPerPixel;
1870
1871 row_cols[0].d.us = &localRows;
1872 row_cols[1].d.us = &localCols;
1873
1874 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, row_cols, 2, NULL, 0, NULL);
1875 if (cond != DCM_NORMAL) {
1876 fprintf(stderr, "Could not get rows/cols in getPixels\n"); /* repair */
1877 COND_DumpConditions();
1878 exit(1);
1879 }
1880
1881 if (params->rows == localRows) {
1882 for (index = 0; index < pixelCount; index++) {
1883 pixels[index] = p[index] << 16 | p[index] << 8 | p[index];
1884 }
1885 } else if (params->rows < localRows) {
1886 int rowIndex = 0;
1887 int colIndex = 0;
1888 int srcIndex;
1889
1890 index = 0;
1891 for (rowIndex = 0; rowIndex < params->rows; rowIndex++) {
1892 srcIndex = rowIndex * 2 * localCols;
1893 for (colIndex = 0; colIndex < params->cols; colIndex++, index++, srcIndex += 2) {
1894 pixels[index] = p[srcIndex] << 16 | p[srcIndex] << 8 | p[srcIndex];
1895 }
1896 }
1897 } else {
1898 int rowIndex = 0;
1899 int colIndex = 0;
1900 int srcIndex = 0;
1901 int index = 0;
1902
1903 U32 newP;
1904
1905 for (rowIndex = 0; rowIndex < localRows; rowIndex ++, index += 3*params->cols) {
1906 for (colIndex = 0; colIndex < localCols; colIndex++) {
1907 newP = p[srcIndex] << 16 | p[srcIndex] << 8 | p[srcIndex];
1908 srcIndex++;
1909
1910 pixels[index] = newP;
1911 pixels[index + 1] = newP;
1912 pixels[index + 2] = newP;
1913 pixels[index + 3] = newP;
1914
1915 pixels[params->cols+ index] = newP;
1916 pixels[params->cols + index +1] = newP;
1917 pixels[params->cols + index + 2] = newP;
1918 pixels[params->cols + index + 3] = newP;
1919
1920 pixels[(2*params->cols)] = newP;
1921 pixels[(2*params->cols) + 1] = newP;
1922 pixels[(2*params->cols) + 2] = newP;
1923 pixels[(2*params->cols) + 3] = newP;
1924
1925 pixels[(2*params->cols) + index] = newP;
1926 pixels[(2*params->cols) + index + 1] = newP;
1927 pixels[(2*params->cols) + index + 2] = newP;
1928 pixels[(2*params->cols) + index + 3] = newP;
1929
1930 index += 4;
1931 }
1932 }
1933 }
1934
1935
1936 (*env)->ReleaseIntArrayElements(env, arr, (jint*)pixels, 0);
1937
1938 free(p);
1939 }
1940 static void getPixelFrameAsColor_Monochrome_16(JNIEnv *env, jobject obj, jlong dcmObj,
1941 jintArray arr, jint rows, jint cols,
1942 jint frame, const IMAGE_PARAMETERS *params)
1943 {
1944 U32 *pixels = 0;
1945 U16 *up = 0;
1946 CONDITION cond;
1947 jsize len;
1948 int index;
1949 int pixelCount;
1950 jint computedWidth;
1951 jint computedCenter;
1952
1953 U16 localRows = 0;
1954 U16 localCols = 0;
1955
1956 DCM_ELEMENT row_cols[] = {
1957 { DCM_IMGROWS, DCM_US, "", 1, sizeof(U16), NULL},
1958 { DCM_IMGCOLUMNS, DCM_US, "", 1, sizeof(U16), NULL}
1959 };
1960 jboolean flag = 1;
1961
1962 row_cols[0].d.us = &localRows;
1963 row_cols[1].d.us = &localCols;
1964
1965 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, row_cols, 2, NULL, 0, NULL);
1966 if (cond != DCM_NORMAL) {
1967 fprintf(stderr, "Could not get rows/cols in getPixels\n"); /* repair */
1968 COND_DumpConditions();
1969 exit(1);
1970 }
1971
1972 len = (*env)->GetArrayLength(env, arr);
1973
1974 pixels = (U32*)(*env)->GetIntArrayElements(env, arr, &flag);
1975
1976 up = getPixels(dcmObj, params->rows, params->cols, params->samplesPerPixel, 16, frame);
1977
1978 pixelCount = params->rows * params->cols * params->samplesPerPixel;
1979 computedCenter = (1 << params->highBit);
1980 computedWidth = computedCenter << 1;
1981
1982 if (params->rescaleSlope == 0. && params->windowWidth == 0)
1983 map16BitToColor32(up, pixels, params, localRows, localCols,
1984 computedCenter, computedWidth);
1985 else if (params->rescaleSlope == 0.)
1986 map16BitToColor32(up, pixels, params, localRows, localCols,
1987 params->windowCenter, params->windowWidth);
1988 else if (params->windowWidth == 0)
1989 map16BitToColor32Slope(up, pixels, params, computedCenter, computedWidth);
1990 else
1991 map16BitToColor32Slope(up, pixels, params, params->windowCenter, params->windowWidth);
1992
1993 free(up);
1994
1995 (*env)->ReleaseIntArrayElements(env, arr, (jint*)pixels, 0);
1996 }
1997 static void getPixelFrameAsColor_Monochrome(JNIEnv *env, jobject obj, jlong dcmObj,
1998 jintArray arr, jint rows, jint cols,
1999 jint frame, const IMAGE_PARAMETERS *params)
2000 {
2001 if (params->bitsAllocated == 8)
2002 getPixelFrameAsColor_Monochrome_8(env, obj, dcmObj, arr, rows, cols, frame, params);
2003 else
2004 getPixelFrameAsColor_Monochrome_16(env, obj, dcmObj, arr, rows, cols, frame, params);
2005 }
2006
2007 static void fillPaletteDescriptor(jlong dcmObj, DCM_TAG tag, U16 *descriptor)
2008 {
2009 DCM_ELEMENT e;
2010 CONDITION cond;
2011 void *ctx = NULL;
2012 U32 rtnLength;
2013
2014 memset(&e, 0, sizeof e);
2015 e.tag = tag;
2016
2017 e.representation = DCM_US;
2018 e.description[0] = '\0';
2019 e.multiplicity = 1;
2020 e.length = 3*sizeof(U16);
2021 e.d.us = descriptor;
2022
2023 cond = DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
2024 if (cond != DCM_NORMAL) {
2025 memset(descriptor, 0, 3*sizeof(U16));
2026 COND_PopCondition(TRUE);
2027 }
2028 }
2029
2030 static void fillPaletteMap(jlong dcmObj, U16 *descriptor, U16 *map, DCM_TAG tag)
2031 {
2032 DCM_ELEMENT e;
2033 void *ctx = NULL;
2034 U32 rtnLength = 0;
2035 CONDITION cond;
2036
2037 e.tag = tag;
2038
2039 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
2040 if (cond != DCM_NORMAL)
2041 return;
2042
2043 e.d.us = map;
2044
2045 cond = DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
2046 if (cond != DCM_NORMAL) {
2047 memset(map, 0, 256 * sizeof(S16));
2048 COND_PopCondition(TRUE);
2049 }
2050
2051 }
2052
2053 static void remap(U16 *map)
2054 {
2055 int i;
2056 int flag = 0;
2057
2058 for (i = 0; (i < 256) && (flag == 0); i++) {
2059 if ((map[i] & 0xff00) != 0)
2060 flag = 1;
2061 }
2062 if (flag != 0) {
2063 for (i = 0; i < 256; i++) {
2064 map[i] = (map[i] >> 8) & 0x00ff;
2065 }
2066 }
2067 }
2068
2069 static void copyMap(U16 *descriptor, U16 *src, U16 *dst)
2070 {
2071 int i;
2072 U16 entries;
2073 U16 firstPixel;
2074
2075 entries = descriptor[0];
2076 firstPixel = descriptor[1];
2077
2078 for (i = 0; i <= firstPixel; i++)
2079 dst[i] = src[0];
2080
2081 for (i = 0; i < entries; i++)
2082 dst[firstPixel + i] = src[i];
2083
2084 for (i = 255; i >= firstPixel + entries; i--)
2085 dst[i] = src[entries-1];
2086
2087 }
2088
2089 static void fillPalettes(jlong dcmObj, U16 *red, U16 *green, U16 *blue)
2090 {
2091 DCM_ELEMENT e;
2092 CONDITION cond;
2093 U16 redDescriptor[3];
2094 U16 greenDescriptor[3];
2095 U16 blueDescriptor[3];
2096 void *ctx = NULL;
2097 jfieldID fid;
2098 jclass cls;
2099 U32 rtnLength;
2100 int i, j;
2101 U16 localRed[256];
2102 U16 localGreen[256];
2103 U16 localBlue[256];
2104
2105
2106 fillPaletteDescriptor(dcmObj, DCM_IMGLUTDESCRIPTRED, redDescriptor);
2107 fillPaletteDescriptor(dcmObj, DCM_IMGLUTDESCRIPTGREEN, greenDescriptor);
2108 fillPaletteDescriptor(dcmObj, DCM_IMGLUTDESCRIPTBLUE, blueDescriptor);
2109
2110 fillPaletteMap(dcmObj, redDescriptor, localRed, DCM_IMGLOOKUPDATARED);
2111 fillPaletteMap(dcmObj, greenDescriptor, localGreen, DCM_IMGLOOKUPDATAGREEN);
2112 fillPaletteMap(dcmObj, blueDescriptor, localBlue, DCM_IMGLOOKUPDATABLUE);
2113
2114 copyMap(redDescriptor, localRed, red);
2115 copyMap(greenDescriptor, localGreen, green);
2116 copyMap(blueDescriptor, localBlue, blue);
2117
2118 remap(red);
2119 remap(green);
2120 remap(blue);
2121 }
2122
2123
2124 static void getPixelFrameAsColor_Palette(JNIEnv *env, jobject obj, jlong dcmObj,
2125 jintArray arr, jint rows, jint cols,
2126 jint frame, const IMAGE_PARAMETERS *params)
2127 {
2128 U16 redTable[256];
2129 U16 greenTable[256];
2130 U16 blueTable[256];
2131
2132 U32 *pixels = 0;
2133 unsigned char *p = 0;
2134 CONDITION cond;
2135 jsize len;
2136 int index;
2137 int pixelCount;
2138
2139 fillPalettes(dcmObj, redTable, greenTable, blueTable);
2140
2141 len = (*env)->GetArrayLength(env, arr);
2142 pixels = (U32*)(*env)->GetIntArrayElements(env, arr, 0);
2143
2144 p = getPixels(dcmObj, params->rows, params->cols, params->samplesPerPixel, 8, frame);
2145
2146 pixelCount = params->rows * params->cols;
2147 for (index = 0; index < pixelCount; index++) {
2148 pixels[index] =
2149 redTable[p[index]] << 16 |
2150 greenTable[p[index]] << 8 |
2151 blueTable[p[index]];
2152 }
2153
2154 free(p);
2155 }
2156 static void getPixelFrameAsColor_RGB(JNIEnv *env, jobject obj, jlong dcmObj,
2157 jintArray arr, jint rows, jint cols,
2158 jint frame, const IMAGE_PARAMETERS *params)
2159 {
2160 U32 *pixels = 0;
2161 unsigned char *p = 0;
2162 unsigned char *p1 = 0;
2163 CONDITION cond;
2164 jsize len;
2165 int index;
2166 int pixelCount;
2167
2168 len = (*env)->GetArrayLength(env, arr);
2169 pixels = (U32*)(*env)->GetIntArrayElements(env, arr, 0);
2170
2171 p = getPixels(dcmObj, params->rows, params->cols, params->samplesPerPixel, 8, frame);
2172
2173 pixelCount = params->rows * params->cols;
2174 for (index = 0, p1 = p; index < pixelCount; index++, p1 += 3) {
2175 pixels[index] = p1[0] << 16 | p1[1] << 8 | p1[2];
2176 }
2177
2178 free(p);
2179 }
2180
2181 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_getPixelFrameAsColor
2182 (JNIEnv *env, jobject obj, jlong dcmObj, jintArray arr,
2183 jint rows, jint cols, jint frame)
2184 {
2185 jfieldID fid;
2186 jstring jstr;
2187 jclass cls;
2188 jobject photometricInterpretation;
2189 const char *str = 0;
2190 IMAGE_PARAMETERS parameters;
2191
2192 cls = (*env)->GetObjectClass(env, obj);
2193
2194 fid = (*env)->GetFieldID(env, cls, "PhotometricInterpretation", "Ljava/lang/String;");
2195 if (fid == 0)
2196 return;
2197
2198 photometricInterpretation = (*env)->GetObjectField(env, obj, fid);
2199
2200 str = (*env)->GetStringUTFChars(env, photometricInterpretation, 0);
2201
2202 #if 0
2203 printf("%s\n", str);
2204 #endif
2205
2206 getImageParameters(env, obj, &parameters);
2207
2208 #if 0
2209 printf("%d %d %f %f %f %f\n", parameters.rows, parameters.cols,
2210 parameters.windowCenter, parameters.windowWidth,
2211 parameters.rescaleSlope, parameters.rescaleIntercept);
2212 #endif
2213
2214 if (strcmp(str, "MONOCHROME1") == 0)
2215 getPixelFrameAsColor_Monochrome(env, obj, dcmObj, arr, rows, cols, frame, &parameters);
2216 else if (strcmp(str, "MONOCHROME2") == 0)
2217 getPixelFrameAsColor_Monochrome(env, obj, dcmObj, arr, rows, cols, frame, &parameters);
2218 else if (strcmp(str, "RGB") == 0)
2219 getPixelFrameAsColor_RGB(env, obj, dcmObj, arr, rows, cols, frame, &parameters);
2220 else if (strcmp(str, "PALETTE COLOR") == 0)
2221 getPixelFrameAsColor_Palette(env, obj, dcmObj, arr, rows, cols, frame, &parameters);
2222
2223 #if 0
2224 (*env)->DeleteLocalRef(env, arr);
2225 #endif
2226
2227 }
2228
2229
2230 /* Now the stuff for indexed (monochrome images) */
2231
2232
2233 static void map16BitToIndexed(const U16 *up, unsigned char *pixels,
2234 const IMAGE_PARAMETERS* params,
2235 U16 originalRows, U16 originalColumns,
2236 jint center, jint width)
2237 {
2238 if (params->pixelRepresentation == DCM_PIXELUNSIGNED) {
2239 S32 shift = 0;
2240 S32 index = 0;
2241 S32 p;
2242 S32 intensity;
2243 float slope;
2244
2245 shift = center - width/2;
2246 slope = 254./(float)width;
2247
2248 for (index = 0; index < params->rows * params->cols; index++) {
2249 p = *up++;
2250 p = (p-shift) * slope;
2251 if (p < 0)
2252 p = 0;
2253 else if (p > 254)
2254 p = 254;
2255
2256 *pixels++ = p;
2257 }
2258 } else {
2259 S32 shift = 0;
2260 S32 index = 0;
2261 S32 p;
2262 S16 *sp;
2263 S32 intensity;
2264 float slope;
2265
2266 sp = (S16 *)up;
2267
2268 /* Some of the NM images we see have no C/W values and terrible
2269 ** values for high bit. We are going to try to recalculate here.
2270 */
2271
2272 if (originalColumns == 64 && width > 4096) {
2273 S16 maxPixel = 0;
2274 S16 minPixel = 0;
2275
2276 maxPixel = minPixel = sp[0];
2277 for (index = 0; index < originalRows * originalColumns; index++) {
2278 if (sp[index] > maxPixel)
2279 maxPixel = sp[index];
2280 if (sp[index] < minPixel)
2281 minPixel = sp[index];
2282 }
2283
2284 width = maxPixel - minPixel;
2285 center = width/2;
2286 }
2287 shift = center - width/2;
2288 slope = 254./(float)width;
2289
2290 #if 0
2291 if (params->cols == 64) {
2292 for (index = 0; index < 64 * 64; index++) {
2293 fprintf(stderr, " %5d", sp[index]);
2294 if ((index % 8) == 1)
2295 fprintf(stderr, "\n");
2296 }
2297 }
2298 #endif
2299
2300 if ((originalRows > 128) ||
2301 (originalColumns > 128) ||
2302 getenv("CTN_EXPANDED") == NULL) {
2303
2304 for (index = 0; index < params->rows * params->cols; index++) {
2305 p = *sp++;
2306 p = (p-shift) * slope;
2307 if (p < 0)
2308 p = 0;
2309 else if (p > 254)
2310 p = 254;
2311
2312 *pixels++ = p;
2313 }
2314 } else {
2315 int rowIndex = 0;
2316 int colIndex = 0;
2317 U32 newP;
2318
2319 for (rowIndex = 0; rowIndex < originalRows; rowIndex++, pixels += 3*params->cols) {
2320 for (colIndex = 0; colIndex < originalColumns; colIndex++) {
2321 p = *sp++;
2322 p = (p-shift) * slope;
2323 if (p < 0)
2324 p = 0;
2325 else if (p > 254)
2326 p = 254;
2327
2328 newP = p;
2329
2330 pixels[0] = newP;
2331 pixels[1] = newP;
2332 pixels[2] = newP;
2333 pixels[3] = newP;
2334
2335 pixels[params->cols] = newP;
2336 pixels[params->cols+1] = newP;
2337 pixels[params->cols+2] = newP;
2338 pixels[params->cols+3] = newP;
2339
2340 pixels[(2*params->cols)] = newP;
2341 pixels[(2*params->cols) + 1] = newP;
2342 pixels[(2*params->cols) + 2] = newP;
2343 pixels[(2*params->cols) + 3] = newP;
2344
2345 pixels[(3*params->cols)] = newP;
2346 pixels[(3*params->cols) + 1] = newP;
2347 pixels[(3*params->cols) + 2] = newP;
2348 pixels[(3*params->cols) + 3] = newP;
2349
2350 pixels+=4;
2351 }
2352 }
2353 }
2354 }
2355 }
2356
2357 static void map16BitToIndexedSlope(const U16 *up, unsigned char *pixels,
2358 const IMAGE_PARAMETERS* params,
2359 jint center, jint width)
2360 {
2361 if (params->pixelRepresentation == DCM_PIXELUNSIGNED) {
2362 S32 shift = 0;
2363 S32 index = 0;
2364 S32 p;
2365 S32 intensity;
2366 float slope;
2367
2368 shift = center - width/2;
2369 slope = 254./(float)width;
2370
2371 #if 0
2372 fprintf(stderr, "C/W = %d/%d\n", center,width);
2373 fprintf(stderr, "S/I = %f/%f\n", params->rescaleSlope, params->rescaleIntercept);
2374 fprintf(stderr, "shift/slope = %d/%f\n", shift, slope);
2375 #endif
2376
2377
2378 for (index = 0; index < params->rows * params->cols; index++) {
2379 p = *up++;
2380 p = (p * params->rescaleSlope) + params->rescaleIntercept;
2381 p = (p-shift) * slope;
2382 if (p < 0)
2383 p = 0;
2384 else if (p > 254)
2385 p = 254;
2386
2387 *pixels++ = p;
2388 }
2389 } else {
2390 S32 shift = 0;
2391 S32 index = 0;
2392 S32 p;
2393 S32 intensity;
2394 float slope;
2395
2396 shift = center - width/2;
2397 slope = 254./(float)width;
2398
2399 #if 0
2400 fprintf(stderr, "C/W = %d/%d\n", center,width);
2401 fprintf(stderr, "S/I = %f/%f\n", params->rescaleSlope, params->rescaleIntercept);
2402 fprintf(stderr, "shift/slope = %d/%f\n", shift, slope);
2403 #endif
2404
2405 for (index = 0; index < params->rows * params->cols; index++) {
2406 p = *up++;
2407 p = (p * params->rescaleSlope) + params->rescaleIntercept;
2408 p = (p-shift) * slope;
2409 if (p < 0)
2410 p = 0;
2411 else if (p > 254)
2412 p = 254;
2413
2414 *pixels++ = p;
2415 }
2416 }
2417 }
2418
2419 static void getPixelFrameAsIndexed_Monochrome_8(JNIEnv *env, jobject obj, jlong dcmObj,
2420 jbyteArray arr, jint rows, jint cols,
2421 jint frame, const IMAGE_PARAMETERS *params)
2422 {
2423 unsigned char *pixels = 0;
2424 unsigned char *p = 0;
2425 CONDITION cond;
2426 jsize len;
2427 int index;
2428 int pixelCount;
2429 U16 localRows = 0;
2430 U16 localCols = 0;
2431
2432 DCM_ELEMENT row_cols[] = {
2433 { DCM_IMGROWS, DCM_US, "", 1, sizeof(U16), NULL},
2434 { DCM_IMGCOLUMNS, DCM_US, "", 1, sizeof(U16), NULL}
2435 };
2436
2437 len = (*env)->GetArrayLength(env, arr);
2438 pixels = (unsigned char*)(*env)->GetByteArrayElements(env, arr, 0);
2439
2440 p = getPixels(dcmObj, params->rows, params->cols, params->samplesPerPixel, 8, frame);
2441
2442 pixelCount = params->rows * params->cols * params->samplesPerPixel;
2443
2444 row_cols[0].d.us = &localRows;
2445 row_cols[1].d.us = &localCols;
2446
2447 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, row_cols, 2, NULL, 0, NULL);
2448 if (cond != DCM_NORMAL) {
2449 fprintf(stderr, "Could not get rows/cols in getPixels\n"); /* repair */
2450 COND_DumpConditions();
2451 exit(1);
2452 }
2453
2454 if (params->rows == localRows) {
2455 #if 0
2456 for (index = 0; index < pixelCount; index++) {
2457 pixels[index] = p[index];
2458 }
2459 #endif
2460 memcpy(pixels, p, pixelCount);
2461 } else if (params->rows < localRows) {
2462 int rowIndex = 0;
2463 int colIndex = 0;
2464 int srcIndex;
2465
2466 index = 0;
2467 for (rowIndex = 0; rowIndex < params->rows; rowIndex++) {
2468 srcIndex = rowIndex * 2 * localCols;
2469 for (colIndex = 0; colIndex < params->cols; colIndex++, index++, srcIndex += 2) {
2470 pixels[index] = p[srcIndex];
2471 }
2472 }
2473 } else {
2474 int rowIndex = 0;
2475 int colIndex = 0;
2476 int srcIndex = 0;
2477 int index = 0;
2478
2479 U32 newP;
2480
2481 for (rowIndex = 0; rowIndex < localRows; rowIndex ++, index += 3*params->cols) {
2482 for (colIndex = 0; colIndex < localCols; colIndex++) {
2483 newP = p[srcIndex];
2484 srcIndex++;
2485
2486 pixels[index] = newP;
2487 pixels[index + 1] = newP;
2488 pixels[index + 2] = newP;
2489 pixels[index + 3] = newP;
2490
2491 pixels[params->cols+ index] = newP;
2492 pixels[params->cols + index +1] = newP;
2493 pixels[params->cols + index + 2] = newP;
2494 pixels[params->cols + index + 3] = newP;
2495
2496 pixels[(2*params->cols)] = newP;
2497 pixels[(2*params->cols) + 1] = newP;
2498 pixels[(2*params->cols) + 2] = newP;
2499 pixels[(2*params->cols) + 3] = newP;
2500
2501 pixels[(2*params->cols) + index] = newP;
2502 pixels[(2*params->cols) + index + 1] = newP;
2503 pixels[(2*params->cols) + index + 2] = newP;
2504 pixels[(2*params->cols) + index + 3] = newP;
2505
2506 index += 4;
2507 }
2508 }
2509 }
2510
2511
2512 (*env)->ReleaseByteArrayElements(env, arr, (jbyte*)pixels, 0);
2513
2514 free(p);
2515 }
2516 static void getPixelFrameAsIndexed_Monochrome_16(JNIEnv *env, jobject obj, jlong dcmObj,
2517 jbyteArray arr, jint rows, jint cols,
2518 jint frame, const IMAGE_PARAMETERS *params)
2519 {
2520 unsigned char *pixels = 0;
2521 U16 *up = 0;
2522 CONDITION cond;
2523 jsize len;
2524 int index;
2525 int pixelCount;
2526 jint computedWidth;
2527 jint computedCenter;
2528
2529 U16 localRows = 0;
2530 U16 localCols = 0;
2531
2532 DCM_ELEMENT row_cols[] = {
2533 { DCM_IMGROWS, DCM_US, "", 1, sizeof(U16), NULL},
2534 { DCM_IMGCOLUMNS, DCM_US, "", 1, sizeof(U16), NULL}
2535 };
2536 jboolean flag = 1;
2537
2538 row_cols[0].d.us = &localRows;
2539 row_cols[1].d.us = &localCols;
2540
2541 cond = DCM_ParseObject((DCM_OBJECT**)&dcmObj, row_cols, 2, NULL, 0, NULL);
2542 if (cond != DCM_NORMAL) {
2543 fprintf(stderr, "Could not get rows/cols in getPixels\n"); /* repair */
2544 COND_DumpConditions();
2545 exit(1);
2546 }
2547
2548 len = (*env)->GetArrayLength(env, arr);
2549
2550 pixels = (unsigned char*)(*env)->GetByteArrayElements(env, arr, &flag);
2551
2552 up = getPixels(dcmObj, params->rows, params->cols, params->samplesPerPixel, 16, frame);
2553
2554 pixelCount = params->rows * params->cols * params->samplesPerPixel;
2555 computedCenter = (1 << params->highBit);
2556 computedWidth = computedCenter << 1;
2557
2558 if (params->rescaleSlope == 0. && params->windowWidth == 0)
2559 map16BitToIndexed(up, pixels, params, localRows, localCols,
2560 computedCenter, computedWidth);
2561 else if (params->rescaleSlope == 0.)
2562 map16BitToIndexed(up, pixels, params, localRows, localCols,
2563 params->windowCenter, params->windowWidth);
2564 else if (params->windowWidth == 0)
2565 map16BitToIndexedSlope(up, pixels, params, computedCenter, computedWidth);
2566 else
2567 map16BitToIndexedSlope(up, pixels, params, params->windowCenter, params->windowWidth);
2568
2569 free(up);
2570
2571 (*env)->ReleaseByteArrayElements(env, arr, (jbyte*)pixels, 0);
2572 }
2573
2574 static void getPixelFrameAsIndexed_Monochrome(JNIEnv *env, jobject obj, jlong dcmObj,
2575 jbyteArray arr, jint rows, jint cols,
2576 jint frame, const IMAGE_PARAMETERS *params)
2577 {
2578 if (params->bitsAllocated == 8)
2579 getPixelFrameAsIndexed_Monochrome_8(env, obj, dcmObj, arr, rows, cols, frame, params);
2580 else
2581 getPixelFrameAsIndexed_Monochrome_16(env, obj, dcmObj, arr, rows, cols, frame, params);
2582 }
2583
2584
2585 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_getPixelFrameAsIndexed
2586 (JNIEnv *env, jobject obj, jlong dcmObj, jbyteArray arr,
2587 jint rows, jint cols, jint frame)
2588 {
2589 jfieldID fid;
2590 jstring jstr;
2591 jclass cls;
2592 jobject photometricInterpretation;
2593 const char *str = 0;
2594 IMAGE_PARAMETERS parameters;
2595
2596 cls = (*env)->GetObjectClass(env, obj);
2597
2598 fid = (*env)->GetFieldID(env, cls, "PhotometricInterpretation", "Ljava/lang/String;");
2599 if (fid == 0)
2600 return;
2601
2602 photometricInterpretation = (*env)->GetObjectField(env, obj, fid);
2603
2604 str = (*env)->GetStringUTFChars(env, photometricInterpretation, 0);
2605
2606 getImageParameters(env, obj, &parameters);
2607
2608 #if 0
2609 printf("%d %d %f %f %f %f\n", parameters.rows, parameters.cols,
2610 parameters.windowCenter, parameters.windowWidth,
2611 parameters.rescaleSlope, parameters.rescaleIntercept);
2612 #endif
2613
2614 if (strcmp(str, "MONOCHROME1") == 0)
2615 getPixelFrameAsIndexed_Monochrome(env, obj, dcmObj, arr, rows, cols, frame, &parameters);
2616 else if (strcmp(str, "MONOCHROME2") == 0)
2617 getPixelFrameAsIndexed_Monochrome(env, obj, dcmObj, arr, rows, cols, frame, &parameters);
2618 else if (strcmp(str, "RGB") == 0) {
2619 fprintf(stderr, "Not supposed to ask for indexed pixel data with RGB image\n");
2620 exit(1);
2621 } else if (strcmp(str, "PALETTE COLOR") == 0) {
2622 fprintf(stderr, "Not supposed to ask for indexed pixel data with palette color\n");
2623 exit(1);
2624 }
2625 }
2626
2627 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_fillPaletteDescriptor(
2628 JNIEnv *env, jobject obj, jlong dcmObj, jstring color, jobject palette)
2629 {
2630 DCM_ELEMENT e;
2631 CONDITION cond;
2632 U16 paletteDescriptor[3];
2633 void *ctx = NULL;
2634 jfieldID fid;
2635 jclass cls;
2636 U32 rtnLength;
2637
2638
2639 const char *str = (*env)->GetStringUTFChars(env, color, 0);
2640
2641 memset(&e, 0, sizeof e);
2642 if (strcmp(str, "RED") == 0)
2643 e.tag = DCM_IMGLUTDESCRIPTRED;
2644 else if (strcmp(str, "GREEN") == 0)
2645 e.tag = DCM_IMGLUTDESCRIPTGREEN;
2646 else
2647 e.tag = DCM_IMGLUTDESCRIPTBLUE;
2648
2649 e.representation = DCM_US;
2650 e.description[0] = '\0';
2651 e.multiplicity = 1;
2652 e.length = sizeof(paletteDescriptor);
2653 e.d.us = paletteDescriptor;
2654
2655 cond = DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
2656 if (cond != DCM_NORMAL) {
2657 memset(paletteDescriptor, 0, sizeof(paletteDescriptor));
2658 COND_PopCondition(TRUE);
2659 }
2660
2661 cls = (*env)->GetObjectClass(env, palette);
2662
2663 fid = (*env)->GetFieldID(env, cls, "Entries", "S");
2664 if (fid == 0)
2665 return;
2666 (*env)->SetShortField(env, palette, fid, paletteDescriptor[0]);
2667
2668 fid = (*env)->GetFieldID(env, cls, "FirstPixel", "S");
2669 if (fid == 0)
2670 return;
2671 (*env)->SetShortField(env, palette, fid, paletteDescriptor[1]);
2672
2673 fid = (*env)->GetFieldID(env, cls, "BitsPerPixel", "S");
2674 if (fid == 0)
2675 return;
2676 (*env)->SetShortField(env, palette, fid, paletteDescriptor[2]);
2677 }
2678
2679 JNIEXPORT void JNICALL Java_DICOM_Module_ImagePixelModule_fillPaletteMap(
2680 JNIEnv *env, jobject obj, jlong dcmObj, jstring color,
2681 jint entries, jint bitsPerPixel, jshortArray map)
2682 {
2683 DCM_ELEMENT e;
2684 CONDITION cond;
2685 void *ctx = NULL;
2686 jfieldID fid;
2687 jclass cls;
2688 U32 rtnLength;
2689 DCM_TAG tag;
2690 S16 *mapPtr;
2691
2692 const char *str = (*env)->GetStringUTFChars(env, color, 0);
2693
2694 memset(&e, 0, sizeof e);
2695 if (strcmp(str, "RED") == 0)
2696 tag = DCM_IMGLOOKUPDATARED;
2697 else if (strcmp(str, "GREEN") == 0)
2698 tag = DCM_IMGLOOKUPDATAGREEN;
2699 else
2700 tag = DCM_IMGLOOKUPDATABLUE;
2701
2702 cond = DCM_GetElement((DCM_OBJECT**)&dcmObj, tag, &e);
2703 if (cond != DCM_NORMAL)
2704 return;
2705
2706 e.representation = DCM_US;
2707 if (e.representation != DCM_US) {
2708 fprintf(stderr, "Representation for lookup table is not US\n");
2709 exit(1);
2710 }
2711
2712 mapPtr = (*env)->GetShortArrayElements(env, map, 0);
2713 e.d.ss = mapPtr;
2714
2715 cond = DCM_GetElementValue((DCM_OBJECT**)&dcmObj, &e, &rtnLength, &ctx);
2716 if (cond != DCM_NORMAL) {
2717 memset(mapPtr, 0, entries * sizeof(S16));
2718 COND_PopCondition(TRUE);
2719 }
2720
2721 (*env)->ReleaseShortArrayElements(env, map, mapPtr, 0);
2722 }
2723
2724
2725 /* The following code supports the Waveform IOD */
2726
2727 JNIEXPORT void JNICALL Java_DICOM_InfoObj_Waveform_setPatientAttributes
2728 (JNIEnv *env, jobject obj, jlong dcmObj, jobject patient)
2729 {
2730 Java_DICOM_InfoObj_Image_setPatientAttributes(env, obj, dcmObj, patient);
2731 }
2732
2733 JNIEXPORT void JNICALL Java_DICOM_InfoObj_Waveform_setWaveformModuleAttributes
2734 (JNIEnv *env, jobject obj, jlong dcmObj, jobject waveform)
2735 {
2736 jfieldID fid;
2737 jstring jstr;
2738 jclass cls;
2739
2740 LST_HEAD *waveformSequence;
2741 CONDITION cond;
2742 DCM_SEQUENCE_ITEM *seqItem;
2743
2744 U16 numberOfChannels = 0;
2745 U32 numberOfSamples = 0;
2746 float samplingFrequency = 0.;
2747 char samplingFrequencyTxt[DICOM_DS_LENGTH*2 + 2] = "";
2748 char groupLabel[DICOM_SH_LENGTH + 1] = "";
2749 char *c;
2750 char waveformSampleValueRepresentation[DICOM_CS_LENGTH+1];
2751 long flag = 1;
2752
2753 DCM_ELEMENT e[] = {
2754 { DCM_MAKETAG(0x003a, 0x0005), DCM_US, "", 1,
2755 sizeof(numberOfChannels), NULL },
2756 { DCM_MAKETAG(0x003a, 0x0010), DCM_UL, "", 1,
2757 sizeof(numberOfSamples), NULL },
2758 { DCM_MAKETAG(0x003a, 0x001a), DCM_DS, "", 1,
2759 sizeof(samplingFrequencyTxt), NULL},
2760 { DCM_MAKETAG(0x003a, 0x0103), DCM_CS, "", 1,
2761 sizeof(waveformSampleValueRepresentation), NULL}
2762 };
2763
2764 DCM_FLAGGED_ELEMENT optional[] = {
2765 { DCM_MAKETAG(0x003a, 0x0020), DCM_SH, "", 1, sizeof(groupLabel), NULL, 1, NULL }
2766 };
2767
2768 cond = DCM_GetSequenceList((DCM_OBJECT**) &dcmObj,
2769 DCM_MAKETAG(0x003a, 0x0002),
2770 &waveformSequence);
2771 if (cond != DCM_NORMAL) {
2772 COND_DumpConditions();
2773 exit(1); /* repair */
2774 }
2775
2776 seqItem = LST_Head(&waveformSequence);
2777 if (seqItem == NULL) {
2778 fprintf(stderr, "Empty waveform sequence\n");
2779 exit(1); /* repair */
2780 }
2781
2782 e[0].d.us = &numberOfChannels;
2783 e[1].d.ul = &numberOfSamples;
2784 e[2].d.string = samplingFrequencyTxt;
2785 e[3].d.string = waveformSampleValueRepresentation;
2786
2787 optional[0].e.d.string = groupLabel;
2788 optional[0].flagAddress = &flag;
2789
2790 cond = DCM_ParseObject(&seqItem->object, e, (int)DIM_OF(e),
2791 optional, (int)DIM_OF(optional), NULL);
2792 if (cond != DCM_NORMAL) {
2793 COND_DumpConditions();
2794 exit(1); /* repair */
2795 }
2796
2797 cls = (*env)->GetObjectClass(env, waveform);
2798
2799 fid = (*env)->GetFieldID(env, cls, "DCMObject", "J");
2800 if (fid == 0)
2801 return;
2802 (*env)->SetLongField(env, waveform, fid, dcmObj);
2803
2804 fid = (*env)->GetFieldID(env, cls, "NumberOfChannels", "I");
2805 if (fid == 0)
2806 return;
2807 (*env)->SetIntField(env, waveform, fid, numberOfChannels);
2808
2809 fid = (*env)->GetFieldID(env, cls, "NumberOfSamples", "I");
2810 if (fid == 0)
2811 return;
2812 (*env)->SetIntField(env, waveform, fid, numberOfSamples);
2813
2814 c = strtok(samplingFrequencyTxt, "\\");
2815 if (c == NULL) {
2816 samplingFrequency = 1.;
2817 } else {
2818 samplingFrequency = atof(c);
2819
2820 c = strtok(NULL, "\\");
2821 if (c != NULL)
2822 samplingFrequency /= atof(c);
2823 }
2824
2825 fid = (*env)->GetFieldID(env, cls, "SamplingFrequency", "F");
2826 if (fid == 0)
2827 return;
2828 (*env)->SetFloatField(env, waveform, fid, samplingFrequency);
2829
2830 fid = (*env)->GetFieldID(env, cls, "GroupLabel", "Ljava/lang/String;");
2831 if (fid == 0)
2832 return;
2833 jstr = (*env)->NewStringUTF(env, groupLabel);
2834 (*env)->SetObjectField(env, waveform, fid, jstr);
2835
2836 fid = (*env)->GetFieldID(env, cls, "WaveformSampleValueRepresentation",
2837 "Ljava/lang/String;");
2838 if (fid == 0)
2839 return;
2840 jstr = (*env)->NewStringUTF(env, waveformSampleValueRepresentation);
2841 (*env)->SetObjectField(env, waveform, fid, jstr);
2842 }
2843
2844 /* These functions support the Waveform Module (the module inside
2845 ** inside the Waveform IOD.
2846 */
2847
2848 JNIEXPORT void JNICALL Java_DICOM_Module_WaveformModule_setChannelAttributes
2849 (JNIEnv *env, jobject obj, jlong dcmObj, jint ordinalNumber, jobject channel)
2850 {
2851 jfieldID fid;
2852 jstring jstr;
2853 jclass cls;
2854
2855 LST_HEAD *waveformSequence;
2856 LST_HEAD *channelSequence;
2857 CONDITION cond;
2858 DCM_SEQUENCE_ITEM *seqItem;
2859 DCM_SEQUENCE_ITEM *channelItem;
2860
2861 char channelStatus[DICOM_CS_LENGTH + 1] = "";
2862 char channelLabel[DICOM_SH_LENGTH + 1] = "";
2863 char channelNumberTxt[DICOM_IS_LENGTH + 1] = "-1";
2864 char channelSensitivityTxt[DICOM_DS_LENGTH + 1] = "";
2865 char channelSensitivityCorrectionFactorTxt[DICOM_DS_LENGTH + 1] = "";
2866 char channelBaselineTxt[DICOM_DS_LENGTH + 1] = "";
2867 U16 bitsPerSample = 0;
2868 int channelNumber;
2869 float f;
2870 long flag = 0;
2871 int idx;
2872
2873 DCM_FLAGGED_ELEMENT optional[] = {
2874 { DCM_MAKETAG(0x003a, 0x0205), DCM_CS, "", 1,
2875 sizeof(channelStatus), NULL, 1, NULL },
2876 { DCM_MAKETAG(0x003a, 0x0202), DCM_IS, "", 1,
2877 sizeof(channelNumberTxt), NULL, 2, NULL },
2878 { DCM_MAKETAG(0x003a, 0x0203), DCM_IS, "", 1,
2879 sizeof(channelLabel), NULL, 4, NULL },
2880 };
2881 DCM_ELEMENT required[] = {
2882 { DCM_MAKETAG(0x003a, 0x0210), DCM_DS, "", 1,
2883 sizeof(channelSensitivityTxt), NULL},
2884 { DCM_MAKETAG(0x003a, 0x0212), DCM_DS, "", 1,
2885 sizeof(channelSensitivityCorrectionFactorTxt), NULL},
2886 { DCM_MAKETAG(0x003a, 0x0213), DCM_DS, "", 1,
2887 sizeof(channelBaselineTxt), NULL},
2888 { DCM_MAKETAG(0x003a, 0x021a), DCM_US, "", 1,
2889 sizeof(bitsPerSample), NULL}
2890 };
2891
2892 cond = DCM_GetSequenceList((DCM_OBJECT**) &dcmObj,
2893 DCM_MAKETAG(0x003a, 0x0002),
2894 &waveformSequence);
2895 if (cond != DCM_NORMAL) {
2896 COND_DumpConditions();
2897 exit(1); /* repair */
2898 }
2899
2900 seqItem = LST_Head(&waveformSequence);
2901 if (seqItem == NULL) {
2902 fprintf(stderr, "Empty waveform sequence\n");
2903 exit(1); /* repair */
2904 }
2905
2906 cond = DCM_GetSequenceList((DCM_OBJECT**) &seqItem->object,
2907 DCM_MAKETAG(0x003a, 0x0200),
2908 &channelSequence);
2909 if (cond != DCM_NORMAL) {
2910 COND_DumpConditions();
2911 exit(1); /* repair */
2912 }
2913
2914 channelItem = LST_Head(&channelSequence);
2915 (void)LST_Position(&channelSequence, channelItem);
2916 for (idx = 1; idx <= ordinalNumber; idx++)
2917 channelItem = LST_Next(&channelSequence);
2918
2919 if (channelItem == NULL) {
2920 fprintf(stderr, "Empty channel sequence\n");
2921 exit(1); /* repair */
2922 }
2923
2924 optional[0].e.d.string = channelStatus;
2925 optional[0].flagAddress = &flag;
2926 optional[1].e.d.string = channelNumberTxt;
2927 optional[1].flagAddress = &flag;
2928 optional[2].e.d.string = channelLabel;
2929 optional[2].flagAddress = &flag;
2930
2931 required[0].d.string = channelSensitivityTxt;
2932 required[1].d.string = channelSensitivityCorrectionFactorTxt;
2933 required[2].d.string = channelBaselineTxt;
2934 required[3].d.us = &bitsPerSample;
2935
2936 cond = DCM_ParseObject(&channelItem->object, required, (int)DIM_OF(required),
2937 optional, (int)DIM_OF(optional), NULL);
2938 if (cond != DCM_NORMAL) {
2939 COND_DumpConditions();
2940 exit(1); /* repair */
2941 }
2942
2943 cls = (*env)->GetObjectClass(env, channel);
2944
2945 /* First, handle the required attributes */
2946 f = atof(channelSensitivityTxt);
2947 fid = (*env)->GetFieldID(env, cls, "ChannelSensitivity", "F");
2948 if (fid == 0)
2949 return;
2950 (*env)->SetFloatField(env, channel, fid, f);
2951
2952 f = atof(channelSensitivityCorrectionFactorTxt);
2953 fid = (*env)->GetFieldID(env, cls, "ChannelSensitivityCorrectionFactor", "F");
2954 if (fid == 0)
2955 return;
2956 (*env)->SetFloatField(env, channel, fid, f);
2957
2958 f = atof(channelBaselineTxt);
2959 fid = (*env)->GetFieldID(env, cls, "ChannelBaseline", "F");
2960 if (fid == 0)
2961 return;
2962 (*env)->SetFloatField(env, channel, fid, f);
2963
2964 fid = (*env)->GetFieldID(env, cls, "BitsPerSample", "I");
2965 if (fid == 0)
2966 return;
2967 (*env)->SetIntField(env, channel, fid, bitsPerSample);
2968
2969
2970
2971 /* This section handles type 3 attributes */
2972
2973 fid = (*env)->GetFieldID(env, cls, "ChannelStatus", "Ljava/lang/String;");
2974 if (fid == 0)
2975 return;
2976 jstr = (*env)->NewStringUTF(env, channelStatus);
2977 (*env)->SetObjectField(env, channel, fid, jstr);
2978
2979 fid = (*env)->GetFieldID(env, cls, "ChannelLabel", "Ljava/lang/String;");
2980 if (fid == 0)
2981 return;
2982 jstr = (*env)->NewStringUTF(env, channelLabel);
2983 (*env)->SetObjectField(env, channel, fid, jstr);
2984
2985 if (flag & 2)
2986 channelNumber = atoi(channelNumberTxt);
2987 else
2988 channelNumber = ordinalNumber;
2989
2990 fid = (*env)->GetFieldID(env, cls, "ChannelNumber", "I");
2991 if (fid == 0)
2992 return;
2993 (*env)->SetIntField(env, channel, fid, channelNumber);
2994
2995 /* This section handles second level objects within the waveform channel */
2996 /* Channel Source */
2997 {
2998 LST_HEAD *channelSourceSequence = NULL;
2999 jobject channelSourceObj;
3000 DCM_SEQUENCE_ITEM *channelSourceItem;
3001
3002 fid = (*env)->GetFieldID(env, cls,"ChannelSource", "LDICOM/Misc/CodedValue;");
3003 if (fid == 0) {
3004 fprintf(stderr, "Could not find ChannelSource\n");
3005 return;
3006 }
3007
3008 cond = DCM_GetSequenceList((DCM_OBJECT**) &channelItem->object,
3009 DCM_MAKETAG(0x003a, 0x0208),
3010 &channelSourceSequence);
3011 channelSourceItem = LST_Head(&channelSourceSequence);
3012
3013 channelSourceObj = (*env)->GetObjectField(env, channel, fid);
3014
3015 setCodedValues(env,
3016 channelSourceObj,
3017 &channelSourceItem->object);
3018
3019 }
3020
3021 /* Channel Sensitivity Units */
3022 {
3023 LST_HEAD *channelSourceSequence = NULL;
3024 jobject channelSourceObj;
3025 DCM_SEQUENCE_ITEM *channelSourceItem;
3026
3027 fid = (*env)->GetFieldID(env, cls,"ChannelSensitivityUnits", "LDICOM/Misc/CodedValue;");
3028 if (fid == 0) {
3029 fprintf(stderr, "Could not find ChannelSensitivityUnits\n");
3030 return;
3031 }
3032
3033 cond = DCM_GetSequenceList((DCM_OBJECT**) &channelItem->object,
3034 DCM_MAKETAG(0x003a, 0x0211),
3035 &channelSourceSequence);
3036 channelSourceItem = LST_Head(&channelSourceSequence);
3037
3038 channelSourceObj = (*env)->GetObjectField(env, channel, fid);
3039
3040 setCodedValues(env,
3041 channelSourceObj,
3042 &channelSourceItem->object);
3043
3044 }
3045
3046 }
3047
3048
3049 JNIEXPORT void JNICALL Java_DICOM_Module_WaveformModule_setChannelSource
3050 (JNIEnv *env, jobject obj, jlong dcmObj, jint ordinalNumber, jobject channelSource)
3051 {
3052 #if 0
3053 jfieldID fid;
3054 jstring jstr;
3055 jclass cls;
3056
3057 LST_HEAD *waveformSequence;
3058 LST_HEAD *channelSequence;
3059 CONDITION cond;
3060 DCM_SEQUENCE_ITEM *seqItem;
3061 DCM_SEQUENCE_ITEM *channelItem;
3062
3063 cond = DCM_GetSequenceList((DCM_OBJECT**) &dcmObj,
3064 DCM_MAKETAG(0x003a, 0x0002),
3065 &waveformSequence);
3066 if (cond != DCM_NORMAL) {
3067 COND_DumpConditions();
3068 exit(1); /* repair */
3069 }
3070
3071 seqItem = LST_Head(&waveformSequence);
3072 if (seqItem == NULL) {
3073 fprintf(stderr, "Empty waveform sequence\n");
3074 exit(1); /* repair */
3075 }
3076
3077 cond = DCM_GetSequenceList((DCM_OBJECT**) &seqItem->object,
3078 DCM_MAKETAG(0x003a, 0x0200),
3079 &channelSequence);
3080 if (cond != DCM_NORMAL) {
3081 COND_DumpConditions();
3082 exit(1); /* repair */
3083 }
3084
3085 channelItem = LST_Head(&channelSequence);
3086 if (channelItem == NULL) {
3087 fprintf(stderr, "Empty channel sequence\n");
3088 exit(1); /* repair */
3089 }
3090
3091 {
3092 LST_HEAD *channelSourceSequence = NULL;
3093 DCM_SEQUENCE_ITEM *channelSourceItem;
3094
3095 cond = DCM_GetSequenceList((DCM_OBJECT**) &channelItem->object,
3096 DCM_MAKETAG(0x003a, 0x0208),
3097 &channelSourceSequence);
3098 channelSourceItem = LST_Head(&channelSourceSequence);
3099
3100 setCodedValues(env,
3101 obj,
3102 &channelSourceItem->object);
3103
3104 }
3105 #endif
3106 }
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116 JNIEXPORT void JNICALL Java_DICOM_Module_WaveformModule_getSamplesByte(
3117 JNIEnv *env, jobject obj, jlong dcmObj, jbyteArray arr, jint channels,
3118 jint samplesPerChannel)
3119 {
3120 jbyte *samples = 0;
3121 DCM_ELEMENT e = {DCM_MAKETAG(0x003a, 0x1000), DCM_OB, "", 1, 0, NULL};
3122 void *ctx = NULL;
3123 U32 rtnLength = 0;
3124 CONDITION cond;
3125 LST_HEAD *waveformSequence = NULL;
3126 DCM_SEQUENCE_ITEM *seqItem;
3127
3128 jsize len;
3129 len = (*env)->GetArrayLength(env, arr);
3130 samples = (*env)->GetByteArrayElements(env, arr, 0);
3131
3132
3133 cond = DCM_GetSequenceList((DCM_OBJECT**) &dcmObj,
3134 DCM_MAKETAG(0x003a, 0x0002),
3135 &waveformSequence);
3136 if (cond != DCM_NORMAL) {
3137 COND_DumpConditions();
3138 exit(1); /* repair */
3139 }
3140
3141 seqItem = LST_Head(&waveformSequence);
3142 if (seqItem == NULL) {
3143 fprintf(stderr, "Empty waveform sequence\n");
3144 exit(1); /* repair */
3145 }
3146
3147
3148 if (len != channels * samplesPerChannel) {
3149 fprintf(stderr, "Byte: Len = %d, channels = %d, samplesPerChannel = %d\n",
3150 len, channels, samplesPerChannel);
3151 exit(1);
3152 }
3153
3154 e.length = len;
3155 e.d.ot = samples;
3156 DCM_GetElementValue((DCM_OBJECT**)&seqItem->object, &e, &rtnLength, &ctx);
3157
3158 (*env)->ReleaseByteArrayElements(env, arr, samples, 0);
3159 }
3160
3161 JNIEXPORT void JNICALL Java_DICOM_Module_WaveformModule_getSamplesShort(
3162 JNIEnv *env, jobject obj, jlong dcmObj, jshortArray arr, jint channels,
3163 jint samplesPerChannel)
3164 {
3165 jshort *samples = 0;
3166 DCM_ELEMENT e = {DCM_MAKETAG(0x003a, 0x1000), DCM_US, "", 1, 0, NULL};
3167 void *ctx = NULL;
3168 U32 rtnLength = 0;
3169 CONDITION cond;
3170 LST_HEAD *waveformSequence = NULL;
3171 DCM_SEQUENCE_ITEM *seqItem;
3172
3173 jsize len;
3174 len = (*env)->GetArrayLength(env, arr);
3175 samples = (*env)->GetShortArrayElements(env, arr, 0);
3176
3177
3178 cond = DCM_GetSequenceList((DCM_OBJECT**) &dcmObj,
3179 DCM_MAKETAG(0x003a, 0x0002),
3180 &waveformSequence);
3181 if (cond != DCM_NORMAL) {
3182 COND_DumpConditions();
3183 exit(1); /* repair */
3184 }
3185
3186 seqItem = LST_Head(&waveformSequence);
3187 if (seqItem == NULL) {
3188 fprintf(stderr, "Empty waveform sequence\n");
3189 exit(1); /* repair */
3190 }
3191
3192 if (len != channels * samplesPerChannel) {
3193 fprintf(stderr, "Len = %d, channels = %d, samplesPerChannel = %d\n",
3194 len, channels, samplesPerChannel);
3195 exit(1);
3196 }
3197
3198 e.length = len*2;
3199 e.d.ot = samples;
3200 DCM_GetElementValue((DCM_OBJECT**)&seqItem->object, &e, &rtnLength, &ctx);
3201
3202 (*env)->ReleaseShortArrayElements(env, arr, samples, 0);
3203 }
3204
3205
3206 /* The functions below support the MISC module
3207 */
3208
3209 JNIEXPORT jlong JNICALL Java_DICOM_Misc_Timer_timeStruct
3210 (JNIEnv *env, jobject obj)
3211 {
3212 void * timeStamp;
3213
3214 timeStamp = UTL_GetTimeStamp();
3215 return (jlong)timeStamp;
3216 }
3217
3218 JNIEXPORT jdouble JNICALL Java_DICOM_Misc_Timer_computeDelta
3219 (JNIEnv *env, jobject obj, jlong timeStamp)
3220 {
3221 double delta;
3222
3223 if (timeStamp == 0)
3224 return 0.;
3225
3226 delta = UTL_DeltaTime((void*)timeStamp);
3227 return delta;
3228 }
3229
3230 JNIEXPORT jdouble JNICALL Java_DICOM_Misc_Timer_releaseTimeStruct
3231 (JNIEnv *env, jobject obj, jlong timeStamp)
3232 {
3233 if (timeStamp == 0)
3234 return;
3235
3236 UTL_ReleaseTimeStamp((void*)timeStamp);
3237 }
3238
3239 static DUL_ASSOCIATESERVICEPARAMETERS* mParams = 0;
3240 static DUL_NETWORKKEY* mNetwork = 0;
3241 static DUL_ASSOCIATIONKEY* mAssociation = 0;
3242
3243 JNIEXPORT jint JNICALL Java_DICOM_Network_Association_open
3244 (JNIEnv *env, jobject obj, jstring callingAE, jstring calledAE,
3245 jstring host, jstring port, jstring sopClass)
3246 {
3247 CONDITION cond;
3248
3249 const char *s1 = (*env)->GetStringUTFChars(env, callingAE, 0);
3250 const char *s2 = (*env)->GetStringUTFChars(env, calledAE, 0);
3251 const char *s3 = (*env)->GetStringUTFChars(env, host, 0);
3252 const char *s4 = (*env)->GetStringUTFChars(env, port, 0);
3253 const char *s5 = (*env)->GetStringUTFChars(env, sopClass, 0);
3254
3255 cond = DUL_InitializeNetwork(DUL_NETWORK_TCP, DUL_AEREQUESTOR,
3256 NULL, DUL_TIMEOUT, DUL_ORDERBIGENDIAN,
3257 &mNetwork);
3258 if (cond != DUL_NORMAL)
3259 return -1;
3260
3261
3262 mParams = CTN_MALLOC(sizeof(*mParams));
3263 if (mParams == NULL)
3264 return -1;
3265
3266 DUL_DefaultServiceParameters(mParams);
3267 sprintf(mParams->calledPresentationAddress, "%s:%s", s3, s4);
3268 strcpy(mParams->callingPresentationAddress, "");
3269 strcpy(mParams->calledAPTitle, s2);
3270 strcpy(mParams->callingAPTitle, s1);
3271
3272 cond = SRV_RequestServiceClass(s5, DUL_SC_ROLE_SCU, mParams);
3273 if (cond != SRV_NORMAL) {
3274 DUL_DropNetwork(&mNetwork);
3275 mNetwork = 0;
3276 return -1;
3277 }
3278
3279 cond = DUL_RequestAssociation(&mNetwork, mParams, &mAssociation);
3280 if (cond != DUL_NORMAL) {
3281 DUL_DropNetwork(&mNetwork);
3282 mNetwork = 0;
3283 return -1;
3284 }
3285
3286 (*env)->ReleaseStringUTFChars(env, callingAE, s1);
3287 (*env)->ReleaseStringUTFChars(env, calledAE, s2);
3288 (*env)->ReleaseStringUTFChars(env, host, s3);
3289 (*env)->ReleaseStringUTFChars(env, port, s4);
3290 (*env)->ReleaseStringUTFChars(env, sopClass, s5);
3291
3292 return 0;
3293 }
3294
3295 JNIEXPORT jint JNICALL Java_DICOM_Network_Association_close
3296 (JNIEnv *env, jobject obj)
3297 {
3298 return 0;
3299 }
3300
3301 typedef struct {
3302 JNIEnv *env;
3303 jobject obj;
3304 } QUERY_CALLBACK_STRUCT;
3305
3306 static CONDITION queryCallback(MSG_C_FIND_REQ* findRequest,
3307 MSG_C_FIND_RESP *findResponse,
3308 int count,
3309 char *SOPClass, char* queryLevel, void* x)
3310 {
3311 QUERY_CALLBACK_STRUCT* s;
3312 jclass cls;
3313
3314 s = (QUERY_CALLBACK_STRUCT*) x;
3315
3316 if (findResponse->status == MSG_K_C_FIND_MATCHCONTINUING ||
3317 findResponse->status == MSG_K_C_FIND_MATCHCONTINUINGWARN) {
3318 jmethodID mid;
3319 jlong l;
3320 cls = (*s->env)->GetObjectClass(s->env, s->obj);
3321 mid = (*s->env)->GetMethodID(s->env, cls, "callbackCFind", "(J)I");
3322 if (mid == 0)
3323 return;
3324
3325
3326 l = 0;
3327 DCM_CopyObject(&findResponse->identifier, (DCM_OBJECT**)&l);
3328 /*memcpy(&l, &findResponse->identifier, sizeof(findResponse->identifier));*/
3329 (*s->env)->CallIntMethod(s->env, s->obj, mid, l);
3330 /*DCM_DumpElements(&findResponse->identifier, 1);*/
3331 }
3332
3333 return SRV_NORMAL;
3334 }
3335
3336 JNIEXPORT jlong JNICALL Java_DICOM_Query_CFindSCU_sendQuery
3337 (JNIEnv *env, jobject obj, jlong dcmObj)
3338 {
3339 MSG_C_FIND_REQ request;
3340 MSG_C_FIND_RESP response;
3341 CONDITION cond;
3342 QUERY_CALLBACK_STRUCT s;
3343
3344 s.env = env;
3345 s.obj = obj;
3346
3347 memset(&request, 0, sizeof(request));
3348 memset(&response, 0, sizeof(response));
3349
3350 request.type = MSG_K_C_FIND_REQ;
3351 request.messageID = SRV_MessageIDOut();
3352 request.dataSetType = DCM_CMDDATAIDENTIFIER;
3353 request.identifier = *((DCM_OBJECT**)&dcmObj);
3354 strcpy(request.classUID, DICOM_SOPPATIENTQUERY_FIND);
3355 /*DCM_DumpElements((DCM_OBJECT**)&dcmObj, 1);*/
3356
3357 cond = SRV_CFindRequest(&mAssociation, mParams, &request, &response,
3358 queryCallback, &s, 0);
3359 if (cond != SRV_NORMAL) {
3360 COND_DumpConditions();
3361 COND_PopCondition(TRUE);
3362 }
3363 }