|
NCBI Home IEB Home C Toolkit docs C++ Toolkit source browser C Toolkit source browser (2) |
NCBI C Toolkit Cross ReferenceC/vibrant/pictur3d.c |
source navigation diff markup identifier search freetext search file search |
1 /* pictur3d.c
2 * ===========================================================================
3 *
4 * PUBLIC DOMAIN NOTICE
5 * National Center for Biotechnology Information (NCBI)
6 *
7 * This software/database is a "United States Government Work" under the
8 * terms of the United States Copyright Act. It was written as part of
9 * the author's official duties as a United States Government employee and
10 * thus cannot be copyrighted. This software/database is freely available
11 * to the public for use. The National Library of Medicine and the U.S.
12 * Government do not place any restriction on its use or reproduction.
13 * We would, however, appreciate having the NCBI and the author cited in
14 * any work or product based on this material
15 *
16 * Although all reasonable efforts have been taken to ensure the accuracy
17 * and reliability of the software and data, the NLM and the U.S.
18 * Government do not and cannot warrant the performance or results that
19 * may be obtained by using this software or data. The NLM and the U.S.
20 * Government disclaim all warranties, express or implied, including
21 * warranties of performance, merchantability or fitness for any particular
22 * purpose.
23 *
24 * ===========================================================================
25 *
26 * File Name: pictur3d.c
27 *
28 * Author: Alex Smirnov
29 *
30 * Version Creation Date: 04/03/95
31 *
32 * $Revision: 6.0 $
33 *
34 * File Description:
35 * 3D picture file.
36 *
37 * Modifications:
38 * --------------------------------------------------------------------------
39 * Date Name Description of modification
40 * ------- ---------- -----------------------------------------------------
41 *
42 *
43 * ==========================================================================
44 */
45
46 #ifndef _PPICT3D_
47 #include <ppict3d.h>
48 #endif
49
50 /*****************************************************************************
51 *
52 * DEFINES
53 *
54 *****************************************************************************/
55
56 /*****************************************************************************
57 *
58 * TYPEDEFS
59 *
60 *****************************************************************************/
61
62 /*****************************************************************************
63 *
64 * GLOBAL VARIABLE
65 *
66 *****************************************************************************/
67 Nlm_Context3D Nlm_stCon;
68
69 /*****************************************************************************
70 *
71 * STATIC VARIABLE
72 *
73 *****************************************************************************/
74 static CharPtr Pict3Dclass = "Picture3D";
75
76 /*****************************************************************************
77 *
78 * FUNCTIONS
79 *
80 *****************************************************************************/
81 static void Nlm_AddToSeg ( Nlm_PSeg3DPtr s, Nlm_Base3DPtr p )
82 {
83 register long ax;
84 register long bx;
85
86 ax = (long)s;
87 bx = (long)(((Nlm_PSeg3DPtr)ax)->last);
88 if ( bx ) {
89 ((Nlm_PSeg3DPtr)ax)->last = p;
90 ax = (long)p;
91 ((Nlm_Base3DPtr)bx)->next = (Nlm_Base3DPtr)ax;
92 ((Nlm_Base3DPtr)ax)->next = NULL;
93 ((Nlm_Base3DPtr)ax)->parent = (Nlm_Base3DPtr)s;
94 } else {
95 bx = (long)p;
96 ((Nlm_PSeg3DPtr)ax)->last = ((Nlm_PSeg3DPtr)ax)->first =
97 (Nlm_Base3DPtr)bx;
98 ((Nlm_Base3DPtr)bx)->next = NULL;
99 ((Nlm_Base3DPtr)bx)->parent = (Nlm_Base3DPtr)ax;
100 }
101 }
102
103 static void Nlm_DeleteFromSeg ( Nlm_PSeg3DPtr seg, Nlm_Base3DPtr base )
104 {
105 register Nlm_Base3DPtr b;
106 register Nlm_Base3DPtr bprev;
107
108 bprev = NULL;
109 for ( b = seg->first; (b != base) && (b != NULL); b = b->next ){
110 bprev = b;
111 }
112 if ( b != NULL ) {
113 if ( bprev != NULL ) bprev->next = b->next;
114 else seg->first = b->next;
115 if ( seg->last == b ) seg->last = bprev;
116 }
117 }
118
119 static void Nlm_Seg3DDraw ( Nlm_PSeg3DPtr s )
120 {
121 register long ax;
122 register long bx;
123 long spx, spy, spz, rad;
124 Uint1 color;
125
126 ax = (long)s;
127 rad = ((Nlm_PSeg3DPtr)ax)->segSph.radius / Nlm_stCon.scale;
128 spz = ((Nlm_PSeg3DPtr)ax)->segSph.x / Nlm_stCon.a[2][0] +
129 ((Nlm_PSeg3DPtr)ax)->segSph.y / Nlm_stCon.a[2][1] +
130 ((Nlm_PSeg3DPtr)ax)->segSph.z / Nlm_stCon.a[2][2] +
131 Nlm_stCon.c[2];
132 spx = ((Nlm_PSeg3DPtr)ax)->segSph.x / Nlm_stCon.a[0][0] +
133 ((Nlm_PSeg3DPtr)ax)->segSph.y / Nlm_stCon.a[0][1] +
134 ((Nlm_PSeg3DPtr)ax)->segSph.z / Nlm_stCon.a[0][2] +
135 Nlm_stCon.c[0];
136 bx = Nlm_stCon.width>>1;
137 spx -= bx;
138 bx = bx + (spx*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-spz);
139 if ( (Nlm_stCon.xmin > (bx + rad)) || (Nlm_stCon.xmax < (bx - rad)) )
140 return;
141 spy = ((Nlm_PSeg3DPtr)ax)->segSph.x / Nlm_stCon.a[1][0] +
142 ((Nlm_PSeg3DPtr)ax)->segSph.y / Nlm_stCon.a[1][1] +
143 ((Nlm_PSeg3DPtr)ax)->segSph.z / Nlm_stCon.a[1][2] +
144 Nlm_stCon.c[1];
145 bx = Nlm_stCon.height>>1;
146 spy -= bx;
147 bx = bx Y_PLUS (spy*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-spz);
148 if ( (Nlm_stCon.ymin > (bx + rad)) || (Nlm_stCon.ymax < (bx - rad)) )
149 return;
150 ax = (long)(((Nlm_PSeg3DPtr)ax)->first);
151 while ( ax ){
152 if ( Nlm_stCon.layerTable[((Nlm_Base3DPtr)ax)->layer] ){
153 if ( ((Nlm_Base3DPtr)ax)->status & HL_MASK ){
154 color = ((Nlm_Base3DPtr)ax)->color;
155 ((Nlm_Base3DPtr)ax)->color = Nlm_stCon.colorHL;
156 ((Nlm_Base3DPtr)ax)->fTable->draw ( (Nlm_VoidPtr)ax );
157 ((Nlm_Base3DPtr)ax)->color = color;
158 } else {
159 ((Nlm_Base3DPtr)ax)->fTable->draw ( (Nlm_VoidPtr)ax );
160 }
161 }
162 ax = (long)(((Nlm_Base3DPtr)ax)->next);
163 }
164 }
165
166 static void Nlm_Seg3DHitT ( Nlm_PSeg3DPtr s )
167 {
168 register long ax;
169 register long bx;
170 long spx, spy, spz, rad;
171
172 ax = (long)s;
173 rad = ((Nlm_PSeg3DPtr)ax)->segSph.radius / Nlm_stCon.scale;
174 spz = ((Nlm_PSeg3DPtr)ax)->segSph.x / Nlm_stCon.a[2][0] +
175 ((Nlm_PSeg3DPtr)ax)->segSph.y / Nlm_stCon.a[2][1] +
176 ((Nlm_PSeg3DPtr)ax)->segSph.z / Nlm_stCon.a[2][2] +
177 Nlm_stCon.c[2];
178 spx = ((Nlm_PSeg3DPtr)ax)->segSph.x / Nlm_stCon.a[0][0] +
179 ((Nlm_PSeg3DPtr)ax)->segSph.y / Nlm_stCon.a[0][1] +
180 ((Nlm_PSeg3DPtr)ax)->segSph.z / Nlm_stCon.a[0][2] +
181 Nlm_stCon.c[0];
182 bx = Nlm_stCon.width>>1;
183 spx -= bx;
184 bx = bx + (spx*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-spz);
185 if ( (Nlm_stCon.xmin > (bx + rad)) || (Nlm_stCon.xmax < (bx - rad)) )
186 return;
187 spy = ((Nlm_PSeg3DPtr)ax)->segSph.x / Nlm_stCon.a[1][0] +
188 ((Nlm_PSeg3DPtr)ax)->segSph.y / Nlm_stCon.a[1][1] +
189 ((Nlm_PSeg3DPtr)ax)->segSph.z / Nlm_stCon.a[1][2] +
190 Nlm_stCon.c[1];
191 bx = Nlm_stCon.height>>1;
192 spy -= bx;
193 bx = bx Y_PLUS (spy*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-spz);
194 if ( (Nlm_stCon.ymin > (bx + rad)) || (Nlm_stCon.ymax < (bx - rad)) )
195 return;
196 ax = (long)(((Nlm_PSeg3DPtr)ax)->first);
197 while ( ax ){
198 if ( Nlm_stCon.layerTable[((Nlm_Base3DPtr)ax)->layer] ){
199 ((Nlm_Base3DPtr)ax)->fTable->hittest ( (Nlm_VoidPtr)ax );
200 }
201 ax = (long)(((Nlm_Base3DPtr)ax)->next);
202 }
203 }
204
205 static void Nlm_Seg3DGetL ( Nlm_PSeg3DPtr s )
206 {
207 register long ax;
208 register long bx;
209 double diam;
210
211 ax = (long)s;
212 ((Nlm_PSeg3DPtr)ax)->segBox.minX = ((Nlm_PSeg3DPtr)ax)->segBox.minY =
213 ((Nlm_PSeg3DPtr)ax)->segBox.minZ = INT4_MAX;
214 ((Nlm_PSeg3DPtr)ax)->segBox.maxX = ((Nlm_PSeg3DPtr)ax)->segBox.maxY =
215 ((Nlm_PSeg3DPtr)ax)->segBox.maxZ = INT4_MIN;
216 ax = (long)(((Nlm_PSeg3DPtr)ax)->first);
217 while ( ax ){
218 if ( Nlm_stCon.layerTable[((Nlm_Base3DPtr)ax)->layer] ){
219 ((Nlm_Base3DPtr)ax)->fTable->getlimits ( (Nlm_VoidPtr)ax );
220 }
221 ax = (long)(((Nlm_Base3DPtr)ax)->next);
222 }
223 ax = (long)s;
224 bx = (long)(((Nlm_PSeg3DPtr)ax)->segBox.maxX -
225 ((Nlm_PSeg3DPtr)ax)->segBox.minX);
226 diam = (double)bx * (double)bx;
227 bx = (long)(((Nlm_PSeg3DPtr)ax)->segBox.maxY -
228 ((Nlm_PSeg3DPtr)ax)->segBox.minY);
229 diam += (double)bx * (double)bx;
230 bx = (long)(((Nlm_PSeg3DPtr)ax)->segBox.maxZ -
231 ((Nlm_PSeg3DPtr)ax)->segBox.minZ);
232 diam += (double)bx * (double)bx;
233 diam = sqrt ( diam );
234 ((Nlm_PSeg3DPtr)ax)->segSph.radius = (long)(diam/2.0) + 1;
235 ((Nlm_PSeg3DPtr)ax)->segSph.x = (((Nlm_PSeg3DPtr)ax)->segBox.maxX +
236 ((Nlm_PSeg3DPtr)ax)->segBox.minX)>>1 ;
237 ((Nlm_PSeg3DPtr)ax)->segSph.y = (((Nlm_PSeg3DPtr)ax)->segBox.maxY +
238 ((Nlm_PSeg3DPtr)ax)->segBox.minY)>>1 ;
239 ((Nlm_PSeg3DPtr)ax)->segSph.z = (((Nlm_PSeg3DPtr)ax)->segBox.maxZ +
240 ((Nlm_PSeg3DPtr)ax)->segBox.minZ)>>1 ;
241 ax = (long)s;
242 bx = (long)(((Nlm_PSeg3DPtr)ax)->base.parent);
243 if ( bx ){
244 if (((Nlm_PSeg3DPtr)bx)->segBox.minX > ((Nlm_PSeg3DPtr)ax)->segBox.minX)
245 ((Nlm_PSeg3DPtr)bx)->segBox.minX = ((Nlm_PSeg3DPtr)ax)->segBox.minX;
246 if (((Nlm_PSeg3DPtr)bx)->segBox.minY > ((Nlm_PSeg3DPtr)ax)->segBox.minY)
247 ((Nlm_PSeg3DPtr)bx)->segBox.minY = ((Nlm_PSeg3DPtr)ax)->segBox.minY;
248 if (((Nlm_PSeg3DPtr)bx)->segBox.minZ > ((Nlm_PSeg3DPtr)ax)->segBox.minZ)
249 ((Nlm_PSeg3DPtr)bx)->segBox.minZ = ((Nlm_PSeg3DPtr)ax)->segBox.minZ;
250 if (((Nlm_PSeg3DPtr)bx)->segBox.maxX < ((Nlm_PSeg3DPtr)ax)->segBox.maxX)
251 ((Nlm_PSeg3DPtr)bx)->segBox.maxX = ((Nlm_PSeg3DPtr)ax)->segBox.maxX;
252 if (((Nlm_PSeg3DPtr)bx)->segBox.maxY < ((Nlm_PSeg3DPtr)ax)->segBox.maxY)
253 ((Nlm_PSeg3DPtr)bx)->segBox.maxY = ((Nlm_PSeg3DPtr)ax)->segBox.maxY;
254 if (((Nlm_PSeg3DPtr)bx)->segBox.maxZ < ((Nlm_PSeg3DPtr)ax)->segBox.maxZ)
255 ((Nlm_PSeg3DPtr)bx)->segBox.maxZ = ((Nlm_PSeg3DPtr)ax)->segBox.maxZ;
256 }
257 }
258
259 static void Nlm_Seg3DClean ( Nlm_PSeg3DPtr s )
260 {
261 register long ax;
262 register long bx;
263
264 ax = (long)(s->first);
265 while ( ax ){
266 ((Nlm_Base3DPtr)ax)->fTable->cleanup ( (Nlm_VoidPtr)ax );
267 bx = (long)(((Nlm_Base3DPtr)ax)->next);
268 MemFree ( (Nlm_VoidPtr)ax );
269 ax = bx;
270 }
271 }
272
273 static Nlm_PrimDef3D segmentDef = {
274 (Nlm_PrimDraw3D)Nlm_Seg3DDraw,
275 (Nlm_PrimHitTest3D)Nlm_Seg3DHitT,
276 (Nlm_PrimGetLimits3D)Nlm_Seg3DGetL,
277 (Nlm_PrimCleanup3D)Nlm_Seg3DClean,
278 (Nlm_Int2)0
279 };
280
281 Nlm_Picture3D Nlm_CreatePicture3D ( void )
282 {
283 register Nlm_PPict3DPtr p;
284 Int2 i;
285
286 Nlm_DiagReset ();
287 p = (Nlm_PPict3DPtr)MemNew ( sizeof(Nlm_PPict3D) );
288 if ( p == NULL ) {
289 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, "CreatePicture3D",
290 "Memory allocation error" );
291 return NULL;
292 }
293 for (i=0;i<256;i++) p->layerTable[i] = TRUE;
294 p->seg.base.fTable = &segmentDef;
295 return (Nlm_Picture3D)p;
296 }
297
298 void Nlm_DeletePicture3D ( Nlm_Picture3D pic )
299 {
300 Nlm_ResetPicture3D ( pic );
301 MemFree ( pic );
302 }
303
304 void Nlm_ResetPicture3D ( Nlm_Picture3D pic )
305 {
306 register Nlm_PPict3DPtr p;
307 Int2 i;
308
309 Nlm_DiagReset ();
310 Nlm_stCon.pic = pic;
311 p = (Nlm_PPict3DPtr)pic;
312 p->seg.base.fTable->cleanup ( (Nlm_VoidPtr)&(p->seg) );
313 for (i=0;i<256;i++) {
314 p->layerTable[i] = TRUE;
315 p->colorR[i] = p->colorG[i] = p->colorB[i] = 0;
316 }
317 p->totalColors = 0;
318 p->version++;
319 }
320
321 Boolean Nlm_AllocPalette3D ( Nlm_Picture3D pic, Uint1 totalColors )
322 {
323 register Nlm_PPict3DPtr p;
324
325 Nlm_DiagReset ();
326 p = (Nlm_PPict3DPtr)pic;
327 if ( p->totalColors != 0 ) {
328 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, "AllocPalette3D",
329 "Palette is allocated already" );
330 return FALSE;
331 }
332 p->totalColors = totalColors;
333 p->version++;
334 return TRUE;
335 }
336
337 Boolean Nlm_SetColor3D ( Nlm_Picture3D pic, Uint1 color,
338 Uint1 red, Uint1 green, Uint1 blue )
339 {
340 register Nlm_PPict3DPtr p;
341
342 Nlm_DiagReset ();
343 p = (Nlm_PPict3DPtr)pic;
344 if ( p->totalColors <= color ) {
345 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, "SetColor3D",
346 "Color index is out of range" );
347 return FALSE;
348 }
349 p->colorR[color] = red;
350 p->colorG[color] = green;
351 p->colorB[color] = blue;
352 p->version++;
353 return TRUE;
354 }
355
356 Boolean Nlm_GetColor3D ( Nlm_Picture3D pic, Uint1 color,
357 Uint1Ptr red, Uint1Ptr green, Uint1Ptr blue )
358 {
359 register Nlm_PPict3DPtr p;
360
361 Nlm_DiagReset ();
362 p = (Nlm_PPict3DPtr)pic;
363 if ( p->totalColors <= color ) {
364 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, "SetColor3D",
365 "Color index is out of range" );
366 return FALSE;
367 }
368 *red = p->colorR[color];
369 *green = p->colorG[color];
370 *blue = p->colorB[color];
371 return TRUE;
372 }
373
374 void Nlm_SetLayer3D ( Nlm_Picture3D pic, Uint1 layer, Boolean layerOn )
375 {
376 register Nlm_PPict3DPtr p;
377
378 Nlm_DiagReset ();
379 p = (Nlm_PPict3DPtr)pic;
380 /* if ( layer == (Uint1)0 ){
381 if ( !layerOn ) Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass,
382 "SetLayer3D",
383 "Can not switch OFF layer 0" );
384 } else {
385 */
386 p->layerTable[layer] = layerOn;
387 p->version++;
388 /* } */
389 }
390
391 Boolean Nlm_GetLayerStatus3D ( Nlm_Picture3D pic, Uint1 layer )
392 {
393 register Nlm_PPict3DPtr p;
394
395 Nlm_DiagReset ();
396 p = (Nlm_PPict3DPtr)pic;
397 return p->layerTable[layer];
398 }
399
400 Nlm_Segment3D Nlm_AddSegment3D ( Nlm_Picture3D pic, Nlm_Segment3D parent,
401 BigScalar userData, Uint1 layer )
402 {
403 register Nlm_PSeg3DPtr s;
404 register Nlm_PPict3DPtr p;
405
406 Nlm_DiagReset ();
407 Nlm_stCon.pic = pic;
408 p = (Nlm_PPict3DPtr)pic;
409 s = (Nlm_PSeg3DPtr)MemNew ( sizeof(Nlm_PSeg3D) );
410 if ( s == NULL ){
411 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, "AddSegment3D",
412 "Memory allocation error" );
413 return NULL;
414 }
415 s->base.fTable = &segmentDef;
416 s->base.userData = userData;
417 s->base.layer = layer;
418 if ( parent == NULL ){
419 Nlm_AddToSeg ( &(p->seg), (Nlm_Base3DPtr)s );
420 } else {
421 Nlm_AddToSeg ( (Nlm_PSeg3DPtr)parent, (Nlm_Base3DPtr)s );
422 }
423 p->version++;
424 return (Nlm_Segment3D)s;
425 }
426
427 void Nlm_GetSegmentInfo3D ( Nlm_Picture3D pic, Nlm_Segment3D segment,
428 BigScalar PNTR userData, Uint1Ptr layer,
429 Nlm_Segment3D PNTR parent )
430 {
431 register Nlm_PSeg3DPtr s;
432
433 Nlm_DiagReset ();
434 s = (Nlm_PSeg3DPtr)segment;
435 if ( userData != NULL ) *userData = s->base.userData;
436 if ( layer != NULL ) *layer = s->base.layer;
437 if ( parent != NULL ) {
438 if ( s->base.parent == (Nlm_Base3DPtr)&(((Nlm_PPict3DPtr)pic)->seg) ){
439 *parent = NULL;
440 } else {
441 *parent = (Nlm_Segment3D)s->base.parent;
442 }
443 }
444 }
445
446
447 Nlm_Boolean Nlm_GetSegSphere3D (Nlm_Picture3D pic, Nlm_Segment3D segment,
448 Nlm_Spher3DPtr sph)
449 {
450 register Nlm_PSeg3DPtr seg = (Nlm_PSeg3DPtr)segment;
451
452 Nlm_DiagReset ();
453 if (seg == NULL) {
454 if ( !Nlm_UpdateGver( (Nlm_PPict3DPtr)pic ) )
455 return FALSE;
456 seg = &((Nlm_PPict3DPtr)pic)->seg;
457 }
458
459 if (sph != NULL)
460 *sph = seg->segSph;
461 return TRUE;
462 }
463
464
465 Nlm_Boolean Nlm_GetSegBox3D (Nlm_Picture3D pic, Nlm_Segment3D segment,
466 Nlm_Box3DPtr box)
467 {
468 register Nlm_PSeg3DPtr seg = (Nlm_PSeg3DPtr)segment;
469
470 Nlm_DiagReset ();
471 if (seg == NULL) {
472 if ( !Nlm_UpdateGver( (Nlm_PPict3DPtr)pic ) )
473 return FALSE;
474 seg = &((Nlm_PPict3DPtr)pic)->seg;
475 }
476
477 if (box != NULL)
478 *box = seg->segBox;
479 return TRUE;
480 }
481
482
483 void Nlm_ChangeSegment3D ( Nlm_Picture3D pic, Nlm_Segment3D segment,
484 BigScalar userData, Uint1 layer )
485 {
486 register Nlm_PSeg3DPtr s;
487
488 Nlm_DiagReset ();
489 s = (Nlm_PSeg3DPtr)segment;
490 s->base.userData = userData;
491 s->base.layer = layer;
492 ((Nlm_PPict3DPtr)pic)->version++;
493 }
494
495 void Nlm_DeleteSegment3D ( Nlm_Picture3D pic, Nlm_Segment3D segment )
496 {
497 register Nlm_PSeg3DPtr s;
498
499 Nlm_DiagReset ();
500 Nlm_stCon.pic = pic;
501 s = (Nlm_PSeg3DPtr)segment;
502 s->base.fTable->cleanup ( (Nlm_VoidPtr)s );
503 Nlm_DeleteFromSeg ( (Nlm_PSeg3DPtr)s->base.parent, (Nlm_Base3DPtr)s );
504 MemFree ( s );
505 ((Nlm_PPict3DPtr)pic)->version++;
506 }
507
508 void Nlm_GetPrimInfo3D ( Nlm_Picture3D pic, Nlm_Prim3D prim,
509 BigScalar PNTR userData, Uint1Ptr layer, Uint1Ptr color,
510 Nlm_Segment3D PNTR parent, Uint2Ptr primType )
511 {
512 register Nlm_Base3DPtr p;
513
514 Nlm_DiagReset ();
515 p = (Nlm_Base3DPtr)prim;
516 if ( userData != NULL ) *userData = p->userData;
517 if ( layer != NULL ) *layer = p->layer;
518 if ( color != NULL ) *color = p->color;
519 if ( parent != NULL ) {
520 if ( p->parent == (Nlm_Base3DPtr)&(((Nlm_PPict3DPtr)pic)->seg) ){
521 *parent = NULL;
522 } else {
523 *parent = (Nlm_Segment3D)p->parent;
524 }
525 }
526 if ( primType != NULL ) *primType = p->fTable->code;
527 }
528
529 void Nlm_ChangePrim3D ( Nlm_Picture3D pic, Nlm_Prim3D prim, BigScalar userData,
530 Uint1 layer, Uint1 color )
531 {
532 register Nlm_Base3DPtr p;
533
534 Nlm_DiagReset ();
535 p = (Nlm_Base3DPtr)prim;
536 p->userData = userData;
537 p->layer = layer;
538 p->color = color;
539 ((Nlm_PPict3DPtr)pic)->version++;
540 }
541
542 void Nlm_DeletePrim3D ( Nlm_Picture3D pic, Nlm_Prim3D prim )
543 {
544 register Nlm_Base3DPtr p;
545
546 Nlm_DiagReset ();
547 Nlm_stCon.pic = pic;
548 p = (Nlm_Base3DPtr)prim;
549 p->fTable->cleanup ( (Nlm_VoidPtr)p );
550 Nlm_DeleteFromSeg ( (Nlm_PSeg3DPtr)p->parent, (Nlm_Base3DPtr)p );
551 MemFree ( p );
552 ((Nlm_PPict3DPtr)pic)->version++;
553 }
554
555 Nlm_Base3DPtr Nlm_AddPrim3D ( Nlm_PSeg3DPtr seg, Nlm_Base3DPtr prim,
556 size_t pSize, CharPtr funName )
557 {
558 register Nlm_Base3DPtr p;
559 Nlm_PPict3DPtr pic;
560
561 pic = (Nlm_PPict3DPtr)Nlm_stCon.pic;
562 if ( (long)prim->color > (long)pic->totalColors ){
563 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, funName,
564 "Color is out of range" );
565 return NULL;
566 }
567 p = (Nlm_Base3DPtr)MemNew ( pSize );
568 if ( p == NULL ){
569 Nlm_DiagPutRecord ( DA_ERROR, Pict3Dclass, funName,
570 "Memory allocation error" );
571 return NULL;
572 }
573 MemCopy ( p, prim, pSize );
574 if ( seg == NULL ){
575 Nlm_AddToSeg ( &(pic->seg), p );
576 } else {
577 Nlm_AddToSeg ( seg, p );
578 }
579 pic->version++;
580 return p;
581 }
582
583 Nlm_Boolean Nlm_UpdateGver ( Nlm_PPict3DPtr pic )
584 {
585 register Nlm_PPict3DPtr p = pic;
586 if (p == NULL)
587 return FALSE;
588
589 Nlm_stCon.pic = (Nlm_Picture3D)p;
590 if ( p->version != p->versionPrev ){
591 p->seg.base.fTable->getlimits ( (Nlm_VoidPtr)&(p->seg) );
592 p->versionPrev = p->version;
593 }
594
595 {{
596 Nlm_Boolean empty = (Nlm_Boolean)
597 (p->seg.segBox.minX == INT4_MAX && p->seg.segBox.maxX == INT4_MIN &&
598 p->seg.segBox.minY == INT4_MAX && p->seg.segBox.maxY == INT4_MIN &&
599 p->seg.segBox.minZ == INT4_MAX && p->seg.segBox.maxZ == INT4_MIN);
600
601 return (Nlm_Boolean)( !empty );
602 }}
603 }
604
605 |
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more information. |