|
NCBI Home IEB Home C Toolkit docs C++ Toolkit source browser C Toolkit source browser (2) |
NCBI C Toolkit Cross ReferenceC/vibrant/prim3d2.c |
source navigation diff markup identifier search freetext search file search |
1 /* prim3d2.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: prim3d2.c
27 *
28 * Author: Alex Smirnov
29 *
30 * Version Creation Date: 04/03/95
31 *
32 * $Revision: 6.1 $
33 *
34 * File Description:
35 *
36 * Modifications:
37 * --------------------------------------------------------------------------
38 * Date Name Description of modification
39 * ------- ---------- -----------------------------------------------------
40 *
41 * $Log: prim3d2.c,v $
42 * Revision 6.1 1998/08/12 23:04:03 vakatov
43 * [64-bit platforms] Made "idBuffer" be VoidPtr[] rather than Int4[];
44 * Fixed bugs mostly caused by casting between Int4 vars and 8-byte pointers
45 *
46 * Revision 6.0 1997/08/25 18:56:33 madden
47 * Revision changed to 6.0
48 *
49 * Revision 5.1 1996/07/25 14:50:13 epstein
50 * BigScalar change for OSF1 portability
51 *
52 * Revision 5.0 1996/05/28 13:45:08 ostell
53 * Set to revision 5.0
54 *
55 * Revision 1.4 1996/04/04 19:29:32 vakatov
56 * The sphere XY-centering is attuned to match the cylinder centering.
57 * Shere of small(1-3) radius still has a 1-point overhead over the
58 * cylinder of the same radius.
59 *
60 *
61 * ==========================================================================
62 */
63
64 #ifndef _VIBRANT_
65 #include <vibrant.h>
66 #endif
67
68 #ifndef _PPICT3D_
69 #include <ppict3d.h>
70 #endif
71
72 #ifndef _PDIAGNOS_
73 #include <pdiagnos.h>
74 #endif
75
76 /*****************************************************************************
77 *
78 * DEFINES
79 *
80 *****************************************************************************/
81
82 /*****************************************************************************
83 *
84 * TYPEDEFS
85 *
86 *****************************************************************************/
87
88 /*****************************************************************************
89 *
90 * GLOBAL VARIABLE
91 *
92 *****************************************************************************/
93 extern Nlm_Context3D Nlm_stCon;
94 extern Uint1 Nlm_Isqrt[129*129];
95
96 /*****************************************************************************
97 *
98 * STATIC VARIABLE
99 *
100 *****************************************************************************/
101
102 /*****************************************************************************
103 *
104 * FUNCTIONS
105 *
106 *****************************************************************************/
107 static void Nlm_Empty3D ( Nlm_VoidPtr p )
108 {
109 }
110
111 /*****************************************************************************
112 *
113 * SPHERE
114 *
115 *****************************************************************************/
116 typedef struct Nlm_sphere3d {
117 Nlm_Base3D base;
118 long x,y,z;
119 long radius;
120 } Nlm_Sphere3D, PNTR Nlm_Sphere3DPtr;
121
122 static void Nlm_Sphere3DDraw ( Nlm_Sphere3DPtr p )
123 {
124 register long reg1;
125 register long reg2;
126 register long reg3;
127 register long reg4;
128 Uint1Ptr cenPtr;
129 Uint1Ptr cenZPtr;
130 Uint1Ptr cenCurPtr;
131 Uint1Ptr cenCurZPtr;
132 Uint1Ptr curPtr;
133 Uint1Ptr radiusF;
134 Uint1Ptr zF;
135 long x,y,z;
136 long dy,dxEnd,dyEnd;
137 long xmin, ymin, xmax, ymax;
138 long baseColor, colorScale;
139
140 reg1 = (long)p;
141
142 /* Rotate and check */
143 reg2 = ((Nlm_Sphere3DPtr)reg1)->x;
144 reg3 = ((Nlm_Sphere3DPtr)reg1)->y;
145 reg4 = ((Nlm_Sphere3DPtr)reg1)->z;
146 x = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
147 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
148 y = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
149 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
150 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
151 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
152 z = reg4;
153 reg4 = Nlm_stCon.zmaxPersp1-reg4;
154 reg2 = Nlm_stCon.width>>1;
155 reg3 = x-reg2;
156 x = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4 + 1;
157 reg2 = Nlm_stCon.height>>1;
158 reg3 = y-reg2;
159 y = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4 + 1;
160 reg2 = ((Nlm_Sphere3DPtr)reg1)->radius / Nlm_stCon.scale;
161 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4 - 1;
162 z = (z*Nlm_stCon.zmaxPersp)/reg4;
163
164 if ( reg2 > 127 ) return;
165 if ( reg2 < 1 ) reg2 = 1;
166 reg3 = x;
167 xmin = Nlm_stCon.xmin - reg3;
168 xmax = Nlm_stCon.xmax - reg3;
169 if ( (reg2 < xmin) || (-reg2 > xmax) ) return;
170 reg4 = y;
171 ymin = Nlm_stCon.ymin - reg4;
172 ymax = Nlm_stCon.ymax - reg4;
173 if ( (reg2 < ymin) || (-reg2 > ymax) ) return;
174 /* Calculate center pointers */
175 reg4 = reg4 * Nlm_stCon.width + reg3;
176 cenPtr = Nlm_stCon.image + reg4;
177 reg4 <<= 1;
178 cenZPtr =(Uint1Ptr)Nlm_stCon.zBuffer + reg4;
179
180 /* calculate yStart and yEnd */
181 reg3 = -reg2;
182 if ( reg3 < ymin ) reg3 = ymin;
183 dy = reg3;
184 reg4 = reg3*Nlm_stCon.width;
185 cenCurPtr = cenPtr + reg4;
186 reg4 <<= 1;
187 cenCurZPtr = cenZPtr + reg4;
188 reg4 = reg2;
189 if ( reg4 > ymax ) reg4 = ymax;
190 dyEnd = reg4;
191
192 radiusF = &(Nlm_Isqrt[reg2*(reg2+1)]);
193 baseColor = Nlm_stCon.colorOffset + 1 +
194 ((Nlm_Sphere3DPtr)reg1)->base.color * Nlm_stCon.colorStep +
195 (Nlm_stCon.colorStep*141*(z+Nlm_stCon.zmax))/
196 (628*Nlm_stCon.zmax);
197 colorScale = ((reg2*314)<<8)/
198 (Nlm_stCon.colorStep*(50+(50*z)/Nlm_stCon.zmax));
199
200 while ( dy <= dyEnd ){
201 reg1 = radiusF[dy];
202 zF = &(Nlm_Isqrt[reg1*(reg1+1)]);
203 dxEnd = reg1;
204 if ( reg1 > xmax ) dxEnd = xmax;
205 reg1 = -reg1;
206 if ( reg1 < xmin ) reg1 = xmin;
207 curPtr = cenCurPtr + reg1;
208 reg4 = (long)(cenCurZPtr + (reg1 << 1));
209 while ( dxEnd - reg1 >= 4 ){
210 reg2 = zF[reg1];
211 reg3 = z+reg2;
212 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
213 *((Uint2Ptr)reg4)=(Uint2)reg3;
214 *((Uint1Ptr)curPtr)=(Uint1)(baseColor +
215 ((reg2-reg1 Y_PLUS dy)<<8)/colorScale);
216 }
217 reg4++; reg4++;
218 curPtr++;
219 reg1++;
220 reg2 = zF[reg1];
221 reg3 = z+reg2;
222 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
223 *((Uint2Ptr)reg4)=(Uint2)reg3;
224 *((Uint1Ptr)curPtr)=(Uint1)(baseColor +
225 ((reg2-reg1 Y_PLUS dy)<<8)/colorScale);
226 }
227 reg4++; reg4++;
228 curPtr++;
229 reg1++;
230 reg2 = zF[reg1];
231 reg3 = z+reg2;
232 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
233 *((Uint2Ptr)reg4)=(Uint2)reg3;
234 *((Uint1Ptr)curPtr)=(Uint1)(baseColor +
235 ((reg2-reg1 Y_PLUS dy)<<8)/colorScale);
236 }
237 reg4++; reg4++;
238 curPtr++;
239 reg1++;
240 reg2 = zF[reg1];
241 reg3 = z+reg2;
242 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
243 *((Uint2Ptr)reg4)=(Uint2)reg3;
244 *((Uint1Ptr)curPtr)=(Uint1)(baseColor +
245 ((reg2-reg1 Y_PLUS dy)<<8)/colorScale);
246 }
247 reg4++; reg4++;
248 curPtr++;
249 reg1++;
250 }
251 while ( reg1 <= dxEnd ){
252 reg2 = zF[reg1];
253 reg3 = z+reg2;
254 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
255 *((Uint2Ptr)reg4)=(Uint2)reg3;
256 *((Uint1Ptr)curPtr)=(Uint1)(baseColor +
257 ((reg2-reg1 Y_PLUS dy)<<8)/colorScale);
258 }
259 reg4++; reg4++;
260 curPtr++;
261 reg1++;
262 }
263 cenCurPtr += Nlm_stCon.width;
264 cenCurZPtr += (Nlm_stCon.width << 1);
265 dy++;
266 }
267 }
268
269 static void Nlm_Sphere3DHitT ( Nlm_Sphere3DPtr p )
270 {
271 register long reg1;
272 register long reg2;
273 register long reg3;
274 register long reg4;
275 Uint1Ptr cenPtr;
276 Uint1Ptr cenZPtr;
277 Uint1Ptr cenCurPtr;
278 Uint1Ptr cenCurZPtr;
279 Uint1Ptr curPtr;
280 Uint1Ptr radiusF;
281 Uint1Ptr zF;
282 long x,y,z;
283 long dy,dxEnd,dyEnd;
284 long xmin, ymin, xmax, ymax;
285
286 reg1 = (long)p;
287
288 /* Rotate and check */
289 reg2 = ((Nlm_Sphere3DPtr)reg1)->x;
290 reg3 = ((Nlm_Sphere3DPtr)reg1)->y;
291 reg4 = ((Nlm_Sphere3DPtr)reg1)->z;
292 x = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
293 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
294 y = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
295 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
296 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
297 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
298 z = reg4;
299 reg4 = Nlm_stCon.zmaxPersp1-reg4;
300 reg2 = Nlm_stCon.width>>1;
301 reg3 = x-reg2;
302 x = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4 + 1;
303 reg2 = Nlm_stCon.height>>1;
304 reg3 = y-reg2;
305 y = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4 + 1;
306 reg2 = ((Nlm_Sphere3DPtr)reg1)->radius / Nlm_stCon.scale;
307 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4 - 1;
308 z = (z*Nlm_stCon.zmaxPersp)/reg4;
309
310 if ( reg2 > 127 ) return;
311 if ( reg2 < 1 ) reg2 = 1;
312 reg3 = x;
313 xmin = Nlm_stCon.xmin - reg3;
314 xmax = Nlm_stCon.xmax - reg3;
315 if ( (reg2 < xmin) || (-reg2 > xmax) ) return;
316 reg4 = y;
317 ymin = Nlm_stCon.ymin - reg4;
318 ymax = Nlm_stCon.ymax - reg4;
319 if ( (reg2 < ymin) || (-reg2 > ymax) ) return;
320
321 /* Calculate center pointers */
322 reg4 = (reg4-Nlm_stCon.ymin) * Nlm_stCon.widthCur + (reg3-Nlm_stCon.xmin);
323 cenZPtr =(Uint1Ptr)(Nlm_stCon.zBuffer + reg4);
324 cenPtr = (Uint1Ptr)(Nlm_stCon.idBuffer + reg4);
325
326 /* calculate yStart and yEnd */
327 reg3 = -reg2;
328 if ( reg3 < ymin ) reg3 = ymin;
329 dy = reg3;
330
331 reg4 = reg3*Nlm_stCon.widthCur;
332 cenCurZPtr = cenZPtr + reg4 * sizeof(Nlm_stCon.zBuffer [0]);
333 cenCurPtr = cenPtr + reg4 * sizeof(Nlm_stCon.idBuffer[0]);
334
335 reg4 = reg2;
336 if ( reg4 > ymax ) reg4 = ymax;
337 dyEnd = reg4;
338
339 radiusF = &(Nlm_Isqrt[reg2*(reg2+1)]);
340 while ( dy <= dyEnd ){
341 reg1 = radiusF[dy];
342 zF = &(Nlm_Isqrt[reg1*(reg1+1)]);
343 dxEnd = reg1;
344 if ( reg1 > xmax ) dxEnd = xmax;
345 reg1 = -reg1;
346 if ( reg1 < xmin ) reg1 = xmin;
347 curPtr = cenCurPtr + reg1 * sizeof(Nlm_stCon.idBuffer[0]);
348 reg4 = (long)(cenCurZPtr + (reg1 << 1));
349 while ( dxEnd - reg1 >= 4 ){
350 reg2 = zF[reg1];
351 reg3 = z+reg2;
352 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
353 *((Uint2Ptr)reg4)=(Uint2)reg3;
354 *((VoidPtr*)curPtr) = p;
355 }
356 reg4++; reg4++;
357 curPtr += sizeof(Nlm_stCon.idBuffer[0]);
358 reg1++;
359 reg2 = zF[reg1];
360 reg3 = z+reg2;
361 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
362 *((Uint2Ptr)reg4)=(Uint2)reg3;
363 *((VoidPtr*)curPtr) = p;
364 }
365 reg4++; reg4++;
366 curPtr += sizeof(Nlm_stCon.idBuffer[0]);
367 reg1++;
368 reg2 = zF[reg1];
369 reg3 = z+reg2;
370 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
371 *((Uint2Ptr)reg4)=(Uint2)reg3;
372 *((VoidPtr*)curPtr) = p;
373 }
374 reg4++; reg4++;
375 curPtr += sizeof(Nlm_stCon.idBuffer[0]);
376 reg1++;
377 reg2 = zF[reg1];
378 reg3 = z+reg2;
379 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
380 *((Uint2Ptr)reg4)=(Uint2)reg3;
381 *((VoidPtr*)curPtr) = p;
382 }
383 reg4++; reg4++;
384 curPtr += sizeof(Nlm_stCon.idBuffer[0]);
385 reg1++;
386 }
387 while ( reg1 <= dxEnd ){
388 reg2 = zF[reg1];
389 reg3 = z+reg2;
390 if((Uint2)reg3>=*((Uint2Ptr)reg4)) {
391 *((Uint2Ptr)reg4)=(Uint2)reg3;
392 *((VoidPtr*)curPtr) = p;
393 }
394 reg4++; reg4++;
395 curPtr += sizeof(Nlm_stCon.idBuffer[0]);
396 reg1++;
397 }
398 cenCurPtr += (Nlm_stCon.widthCur * sizeof(Nlm_stCon.idBuffer[0]));
399 cenCurZPtr += (Nlm_stCon.widthCur << 1);
400 dy++;
401 }
402 }
403
404 static void Nlm_Sphere3DGetL ( Nlm_Sphere3DPtr p )
405 {
406 register BigScalar ax;
407 register BigScalar bx;
408 long minXY, maxXY;
409
410 ax = (BigScalar)p;
411 bx = (BigScalar)(((Nlm_PSeg3DPtr)ax)->base.parent);
412 maxXY = ((Nlm_Sphere3DPtr)ax)->x + ((Nlm_Sphere3DPtr)ax)->radius;
413 minXY = ((Nlm_Sphere3DPtr)ax)->x - ((Nlm_Sphere3DPtr)ax)->radius;
414 if ( ((Nlm_PSeg3DPtr)bx)->segBox.minX > minXY )
415 ((Nlm_PSeg3DPtr)bx)->segBox.minX = minXY;
416 if ( ((Nlm_PSeg3DPtr)bx)->segBox.maxX < maxXY )
417 ((Nlm_PSeg3DPtr)bx)->segBox.maxX = maxXY;
418 maxXY = ((Nlm_Sphere3DPtr)ax)->y + ((Nlm_Sphere3DPtr)ax)->radius;
419 minXY = ((Nlm_Sphere3DPtr)ax)->y - ((Nlm_Sphere3DPtr)ax)->radius;
420 if ( ((Nlm_PSeg3DPtr)bx)->segBox.minY > minXY )
421 ((Nlm_PSeg3DPtr)bx)->segBox.minY = minXY;
422 if ( ((Nlm_PSeg3DPtr)bx)->segBox.maxY < maxXY )
423 ((Nlm_PSeg3DPtr)bx)->segBox.maxY = maxXY;
424 maxXY = ((Nlm_Sphere3DPtr)ax)->z + ((Nlm_Sphere3DPtr)ax)->radius;
425 minXY = ((Nlm_Sphere3DPtr)ax)->z - ((Nlm_Sphere3DPtr)ax)->radius;
426 if ( ((Nlm_PSeg3DPtr)bx)->segBox.minZ > minXY )
427 ((Nlm_PSeg3DPtr)bx)->segBox.minZ = minXY;
428 if ( ((Nlm_PSeg3DPtr)bx)->segBox.maxZ < maxXY )
429 ((Nlm_PSeg3DPtr)bx)->segBox.maxZ = maxXY;
430 }
431
432 static Nlm_PrimDef3D sphereDef = {
433 (Nlm_PrimDraw3D)Nlm_Sphere3DDraw,
434 (Nlm_PrimHitTest3D)Nlm_Sphere3DHitT,
435 (Nlm_PrimGetLimits3D)Nlm_Sphere3DGetL,
436 (Nlm_PrimCleanup3D)Nlm_Empty3D,
437 (Nlm_Int2)SPHERE3D
438 };
439
440 Nlm_Prim3D Nlm_AddSphere3D ( Nlm_Picture3D pic, Nlm_Segment3D segment,
441 BigScalar userData, Uint1 layer, Uint1 color,
442 Int4 x, Int4 y, Int4 z, Uint4 radius )
443 {
444 Nlm_Sphere3D l;
445
446 Nlm_stCon.pic = pic;
447 Nlm_DiagReset ();
448 l.base.userData = userData;
449 l.base.layer = layer;
450 l.base.color = color;
451 l.base.fTable = &sphereDef;
452 l.base.status = 0;
453 l.x = (long)x; l.y = (long)y; l.z = (long)z;
454 l.radius = radius;
455 return (Nlm_Prim3D) Nlm_AddPrim3D ( (Nlm_PSeg3DPtr)segment,
456 (Nlm_Base3DPtr)&l,
457 sizeof(Nlm_Sphere3D),
458 "AddSphere3D" );
459 }
460
461
462 |
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more information. |