|
NCBI Home IEB Home C Toolkit docs C++ Toolkit source browser C Toolkit source browser (2) |
NCBI C Toolkit Cross ReferenceC/vibrant/prim3d5.c |
source navigation diff markup identifier search freetext search file search |
1 /* prim3d5.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: prim3d5.c
27 *
28 * Author: Alex Smirnov
29 *
30 * Version Creation Date: 04/03/95
31 *
32 * $Revision: 6.3 $
33 *
34 * File Description:
35 *
36 * Modifications:
37 * --------------------------------------------------------------------------
38 * Date Name Description of modification
39 * ------- ---------- -----------------------------------------------------
40 * $Log: prim3d5.c,v $
41 * Revision 6.3 2008/04/29 13:43:50 kans
42 * fixes for warnings caught by mingw cross-compiler
43 *
44 * Revision 6.2 1998/08/12 23:04:05 vakatov
45 * [64-bit platforms] Made "idBuffer" be VoidPtr[] rather than Int4[];
46 * Fixed bugs mostly caused by casting between Int4 vars and 8-byte pointers
47 *
48 * Revision 6.1 1997/11/26 21:30:09 vakatov
49 * Fixed errors and warnings issued by C and C++ (GNU and Sun) compilers
50 *
51 * Revision 6.0 1997/08/25 18:56:42 madden
52 * Revision changed to 6.0
53 *
54 * Revision 5.3 1996/07/25 14:51:05 epstein
55 * BigScalar and Int4 changes for OSF1 portability
56 *
57 * Revision 5.2 1996/06/24 16:25:37 hogue
58 * Put sizeof(long) into Mem operations that assumed 4-byte long
59 *
60 *
61 * log added by C. Hogue 24 June 96
62 * ==========================================================================
63 */
64
65 #ifndef _VIBRANT_
66 #include <vibrant.h>
67 #endif
68
69 #ifndef _PPICT3D_
70 #include <ppict3d.h>
71 #endif
72
73 #ifndef _PDIAGNOS_
74 #include <pdiagnos.h>
75 #endif
76
77 /*****************************************************************************
78 *
79 * DEFINES
80 *
81 *****************************************************************************/
82 #define SETPIXEL(zptr,imageptr,z,color10) \
83 if((Uint2)z>=*((Uint2Ptr)zptr)) \
84 {*((Uint2Ptr)zptr)=(Uint2)z;*((Uint1Ptr)imageptr)= \
85 (Uint1)(color10>>10);}
86
87 #define SETPIXELID(zptr,imageptr,z,curID) \
88 if((Uint2)z>=*((Uint2Ptr)zptr)) \
89 {*((Uint2Ptr)zptr)=(Uint2)z;*((VoidPtr*)imageptr)=curID;}
90
91 /*****************************************************************************
92 *
93 * TYPEDEFS
94 *
95 *****************************************************************************/
96
97 /*****************************************************************************
98 *
99 * GLOBAL VARIABLE
100 *
101 *****************************************************************************/
102 extern Nlm_Context3D Nlm_stCon;
103
104 /*****************************************************************************
105 *
106 * STATIC VARIABLE
107 *
108 *****************************************************************************/
109
110 /*****************************************************************************
111 *
112 * POLYGON
113 *
114 *****************************************************************************/
115 typedef struct Nlm_poly3d {
116 Nlm_Base3D base;
117 long x1,y1,z1;
118 long x2,y2,z2;
119 long vNum;
120 long xmin, ymin, zmin;
121 long xmax, ymax, zmax;
122 long x,y,z,rad;
123 Int4Ptr vert;
124 } Nlm_Poly3D, PNTR Nlm_Poly3DPtr;
125
126 static void Nlm_Poly3DDraw ( Nlm_Poly3DPtr p )
127 {
128 register long reg1;
129 register long reg2;
130 register long reg3;
131 register long reg4;
132 Int4Ptr vPtr;
133 long x,y;
134 long vx[3];
135 long vy[3];
136 long vz[3];
137 long baseColor;
138 long sphColor, lineColor;
139 long dX1, dY1, dZ1;
140 long dX2, dY2, dZ2;
141 long curBaseColor;
142 long xsort[3];
143 long ysort[3];
144 long zsort[3];
145 long savex1, savex2,savecurz,x1,x2,curz;
146 long stepZX, stepColorX;
147 long stepXY1, stepXY2, stepXYm = 0;
148 long stepZY, stepZYm = 0, stepColorY, stepColorYm = 0;
149 long color10, savecolor10;
150 Int2 needCheck, needCheckFr;
151 Int2 vi;
152 Int2 mLeft = 0;
153 long Nlm_stCon_image_end = (long)Nlm_stCon.image +
154 Nlm_stCon.width * Nlm_stCon.height - 1;
155
156 reg1 = (long)p;
157 vPtr = ((Nlm_Poly3DPtr)reg1)->vert;
158 if ( vPtr == NULL ) return;
159
160 /* Rotate and check */
161 reg2 = ((Nlm_Poly3DPtr)reg1)->x;
162 reg3 = ((Nlm_Poly3DPtr)reg1)->y;
163 reg4 = ((Nlm_Poly3DPtr)reg1)->z;
164 x = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
165 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
166 y = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
167 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
168 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
169 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
170 reg4 = Nlm_stCon.zmaxPersp1-reg4;
171 reg2 = Nlm_stCon.width>>1;
172 reg3 = x-reg2;
173 x = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4;
174 reg2 = Nlm_stCon.height>>1;
175 reg3 = y-reg2;
176 y = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4;
177 reg2 = ((Nlm_Poly3DPtr)reg1)->rad / Nlm_stCon.scale;
178 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4;
179 needCheck = 0;
180 x += reg2;
181 if ( x < Nlm_stCon.xmin ) return;
182 if ( x > Nlm_stCon.xmax ) needCheck=1;
183 x -= reg2<<1;
184 if ( x < Nlm_stCon.xmin ) needCheck=1;
185 if ( x > Nlm_stCon.xmax ) return;
186 y += reg2;
187 if ( y < Nlm_stCon.ymin ) return;
188 if ( y > Nlm_stCon.ymax ) needCheck=1;
189 y -= reg2<<1;
190 if ( y < Nlm_stCon.ymin ) needCheck=1;
191 if ( y > Nlm_stCon.ymax ) return;
192
193 reg2 = Nlm_stCon.a[0][0];
194 reg3 = ((Nlm_Poly3DPtr)reg1)->x1 / (long)reg2;
195 reg4 = ((Nlm_Poly3DPtr)reg1)->x2 / (long)reg2;
196 reg2 = Nlm_stCon.a[0][1];
197 reg3 += ((Nlm_Poly3DPtr)reg1)->y1 / (long)reg2;
198 reg4 += ((Nlm_Poly3DPtr)reg1)->y2 / (long)reg2;
199 reg2 = Nlm_stCon.a[0][2];
200 reg3 += ((Nlm_Poly3DPtr)reg1)->z1 / (long)reg2;
201 reg4 += ((Nlm_Poly3DPtr)reg1)->z2 / (long)reg2;
202 reg2 = Nlm_stCon.c[0];
203 reg3 += reg2;
204 reg4 += reg2;
205 vx[1] = reg3; vx[2] = reg4;
206
207 reg2 = Nlm_stCon.a[1][0];
208 reg3 = ((Nlm_Poly3DPtr)reg1)->x1 / (long)reg2;
209 reg4 = ((Nlm_Poly3DPtr)reg1)->x2 / (long)reg2;
210 reg2 = Nlm_stCon.a[1][1];
211 reg3 += ((Nlm_Poly3DPtr)reg1)->y1 / (long)reg2;
212 reg4 += ((Nlm_Poly3DPtr)reg1)->y2 / (long)reg2;
213 reg2 = Nlm_stCon.a[1][2];
214 reg3 += ((Nlm_Poly3DPtr)reg1)->z1 / (long)reg2;
215 reg4 += ((Nlm_Poly3DPtr)reg1)->z2 / (long)reg2;
216 reg2 = Nlm_stCon.c[1];
217 reg3 += reg2;
218 reg4 += reg2;
219 vy[1] = reg3; vy[2] = reg4;
220
221 reg2 = Nlm_stCon.a[2][0];
222 reg3 = ((Nlm_Poly3DPtr)reg1)->x1 / (long)reg2;
223 reg4 = ((Nlm_Poly3DPtr)reg1)->x2 / (long)reg2;
224 reg2 = Nlm_stCon.a[2][1];
225 reg3 += ((Nlm_Poly3DPtr)reg1)->y1 / (long)reg2;
226 reg4 += ((Nlm_Poly3DPtr)reg1)->y2 / (long)reg2;
227 reg2 = Nlm_stCon.a[2][2];
228 reg3 += ((Nlm_Poly3DPtr)reg1)->z1 / (long)reg2;
229 reg4 += ((Nlm_Poly3DPtr)reg1)->z2 / (long)reg2;
230 reg2 = Nlm_stCon.c[2];
231 reg3 += reg2;
232 reg4 += reg2;
233 vz[1] = reg3; vz[2] = reg4;
234
235 reg2 = Nlm_stCon.width>>1;
236 reg3 = vx[1]-reg2;
237 vx[1] = reg2 + (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[1]);
238 reg3 = vx[2]-reg2;
239 vx[2] = reg2 + (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[2]);
240 reg2 = Nlm_stCon.height>>1;
241 reg3 = vy[1]-reg2;
242 vy[1] = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[1]);
243 reg3 = vy[2]-reg2;
244 vy[2] = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[2]);
245 reg3 = vz[1];
246 vz[1] = (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-reg3);
247 reg3 = vz[2];
248 vz[2] = (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-reg3);
249
250 baseColor = (Nlm_stCon.colorOffset +
251 ((Nlm_Poly3DPtr)reg1)->base.color * Nlm_stCon.colorStep)<<10;
252 sphColor = ((Nlm_stCon.colorStep*2)<<10)/3;
253 lineColor = Nlm_stCon.colorStep - (sphColor>>10) - 1;
254 baseColor += sphColor*1414/3146;
255
256 vi = 2;
257 while ( *vPtr != 0x7FFFFFFFL ){
258 reg1 = vi;
259 reg1++;
260 if ( reg1 > 2 ) reg1 = 0;
261 vi = (Int2)reg1;
262 reg1 = (long)vPtr;
263 reg2 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
264 reg3 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
265 reg4 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
266 dX1 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
267 dY1 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
268 dZ1 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
269 vPtr = (Int4Ptr)reg1;
270 vx[vi] = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
271 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
272 vy[vi] = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
273 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
274 vz[vi] = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
275 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
276 reg4 = Nlm_stCon.zmaxPersp1-vz[vi];
277 reg2 = Nlm_stCon.width>>1;
278 reg3 = vx[vi]-reg2;
279 vx[vi] = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4;
280 reg2 = Nlm_stCon.height>>1;
281 reg3 = vy[vi]-reg2;
282 vy[vi] = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4;
283 vz[vi] = (vz[vi]*Nlm_stCon.zmaxPersp)/reg4;
284
285 reg2 = dX1; reg3 = dY1; reg4 = dZ1;
286 dX1 = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
287 reg4 / Nlm_stCon.a[0][2];
288 dY1 = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
289 reg4 / Nlm_stCon.a[1][2];
290 dZ1 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
291 reg4 / Nlm_stCon.a[2][2];
292 reg1 = dZ1 - dX1 + dY1;
293 if ( Nlm_stCon.scale < 128000 ){
294 reg4 = 128000/Nlm_stCon.scale + 1;
295 reg2 = dX1/reg4; reg3 = dY1/reg4; reg4 = dZ1/reg4;
296 } else {
297 reg2 = dX1; reg3 = dY1; reg4 = dZ1;
298 }
299 if ( (reg2*(vx[vi]-(Nlm_stCon.width>>1)) Y_PLUS
300 reg3*(vy[vi]-(Nlm_stCon.height>>1))-
301 reg4*Nlm_stCon.zmaxPersp) > 0 ){
302 reg1 =- reg1;
303 }
304 reg1 = reg1*1000 /(1000000000L/Nlm_stCon.scale);
305 if ( reg1 < -1414 ) reg1 = -1414;
306 if ( reg1 > 1732 ) reg1 = 1732;
307 curBaseColor = baseColor + (reg1*sphColor) / 3146;
308
309 reg1 = vy[0];
310 reg2 = vy[1];
311 reg3 = vy[2];
312 if ( reg1 < reg2 ){
313 if ( reg3 < reg1 ){ /* 312 */
314 xsort[0] = vx[2]; ysort[0] = reg3; zsort[0] = vz[2];
315 xsort[1] = vx[0]; ysort[1] = reg1; zsort[1] = vz[0];
316 xsort[2] = vx[1]; ysort[2] = reg2; zsort[2] = vz[1];
317 } else if ( reg3 < reg2 ){ /* 132 */
318 xsort[0] = vx[0]; ysort[0] = reg1; zsort[0] = vz[0];
319 xsort[1] = vx[2]; ysort[1] = reg3; zsort[1] = vz[2];
320 xsort[2] = vx[1]; ysort[2] = reg2; zsort[2] = vz[1];
321 } else { /* 123 */
322 xsort[0] = vx[0]; ysort[0] = reg1; zsort[0] = vz[0];
323 xsort[1] = vx[1]; ysort[1] = reg2; zsort[1] = vz[1];
324 xsort[2] = vx[2]; ysort[2] = reg3; zsort[2] = vz[2];
325 }
326 } else {
327 if ( reg3 < reg2 ){ /* 321 */
328 xsort[0] = vx[2]; ysort[0] = reg3; zsort[0] = vz[2];
329 xsort[1] = vx[1]; ysort[1] = reg2; zsort[1] = vz[1];
330 xsort[2] = vx[0]; ysort[2] = reg1; zsort[2] = vz[0];
331 } else if ( reg3 < reg1 ){ /* 231 */
332 xsort[0] = vx[1]; ysort[0] = reg2; zsort[0] = vz[1];
333 xsort[1] = vx[2]; ysort[1] = reg3; zsort[1] = vz[2];
334 xsort[2] = vx[0]; ysort[2] = reg1; zsort[2] = vz[0];
335 } else { /* 213 */
336 xsort[0] = vx[1]; ysort[0] = reg2; zsort[0] = vz[1];
337 xsort[1] = vx[0]; ysort[1] = reg1; zsort[1] = vz[0];
338 xsort[2] = vx[2]; ysort[2] = reg3; zsort[2] = vz[2];
339 }
340 }
341 dX1 = xsort[1] - xsort[0];
342 dY1 = ysort[1] - ysort[0];
343 dZ1 = zsort[1] - zsort[0];
344 dX2 = xsort[2] - xsort[0];
345 dY2 = ysort[2] - ysort[0];
346 dZ2 = zsort[2] - zsort[0];
347 reg1 = dY1*dZ2 - dZ1*dY2;
348 reg3 = dX1*dY2 - dY1*dX2;
349 if ( reg3 < 0 ) {
350 reg1=-reg1; reg3=-reg3;
351 }
352 if ( reg3 != 0 ) {
353 stepZX = reg1*(-1024)/reg3;
354 stepColorX = stepZX*lineColor/Nlm_stCon.zmax;
355 } else {
356 stepZX = stepColorX = 0;
357 }
358 needCheckFr = 0;
359 if ( needCheck ){
360 reg1 = ysort[0];
361 reg2 = ysort[2];
362 if ( (reg1 > Nlm_stCon.ymax)||
363 (reg2 < Nlm_stCon.ymin) ) continue;
364 if ( (reg1 < Nlm_stCon.ymin)||
365 (reg2 > Nlm_stCon.ymax) ) needCheckFr = 1;
366 reg1 = vx[0]; reg2 = vx[1];
367 if ( reg1 > reg2 ) { reg3 = reg1; reg1 = reg2; reg2 = reg3; }
368 reg3 = vx[2];
369 if ( reg3 < reg1 ) reg1 = reg3;
370 else if ( reg3 > reg2 ) reg2 = reg3;
371 if ( (reg1 > Nlm_stCon.xmax)||
372 (reg2 < Nlm_stCon.xmin) ) continue;
373 if ( (reg1 < Nlm_stCon.xmin)||
374 (reg2 > Nlm_stCon.xmax) ) needCheckFr = 1;
375 }
376 y = ysort[0];
377 if ( y == ysort[1] ){
378 if ( xsort[0] < xsort[1] ){
379 savex1 = xsort[0];
380 savex2 = xsort[1];
381 savecurz = zsort[0];
382 } else {
383 savex1 = xsort[1];
384 savex2 = xsort[0];
385 savecurz = zsort[1];
386 }
387 if ( ysort[2] != y ){
388 reg1 = ysort[2]-y;
389 stepXY1 = ((xsort[2]-savex1)<<10)/reg1;
390 stepXY2 = ((xsort[2]-savex2)<<10)/reg1;
391 stepZY = ((zsort[2] - savecurz)<<10)/reg1;
392 ysort[1] = 0x80000000L;
393 } else {
394 stepZY = stepXY1 = stepXY2 = 0;
395 }
396 } else {
397 savex1 = savex2 = xsort[0];
398 savecurz = zsort[0];
399 reg1 = xsort[0]; reg2 = ysort[0];
400 if ( ((ysort[1]-reg2)*(xsort[2]-reg1) -
401 (xsort[1]-reg1)*(ysort[2]-reg2)) > 0 ){
402 mLeft = 1;
403 reg3 = ysort[1]-reg2;
404 stepXY1 = ((xsort[1]-savex1)<<10)/reg3;
405 stepZY = ((zsort[1]-zsort[0])<<10)/reg3;
406 stepXY2 = ((xsort[2]-savex1)<<10)/(ysort[2]-reg2);
407 reg3 = ysort[2]-ysort[1];
408 if ( reg3 != 0 ){
409 stepXYm = ((xsort[2]-xsort[1])<<10)/reg3;
410 stepZYm = ((zsort[2]-zsort[1])<<10)/reg3;
411 stepColorYm = (stepZYm*lineColor)/Nlm_stCon.zmax;
412 } else {
413 stepZYm = stepXYm = stepColorYm = 0;
414 }
415 } else {
416 mLeft = 0;
417 reg3 = ysort[2]-reg2;
418 stepXY1 = ((xsort[2]-savex1)<<10)/reg3;
419 stepZY = ((zsort[2]-zsort[0])<<10)/reg3;
420 stepXY2 = ((xsort[1]-savex1)<<10)/(ysort[1]-reg2);
421 reg3 = ysort[2]-ysort[1];
422 if ( reg3 != 0 ){
423 stepXYm = ((xsort[2]-xsort[1])<<10)/reg3;
424 } else stepXYm = 0;
425 }
426 }
427 stepColorY = (stepZY*lineColor)/Nlm_stCon.zmax;
428 savex1 <<= 10;
429 savex2 <<= 10;
430 savecurz <<= 10;
431 savecolor10 = curBaseColor + savecurz*lineColor/Nlm_stCon.zmax;
432 /* y, savex1(10), savex2(10), savecurz(10), stepZX(10),
433 savecolor10, stepColorX(10), stepColorY, stepZY,
434 stepXY1, stepXY2,
435 mLeft, stepXYm, stepColorYm, stepZYm*/
436 for (; y<=ysort[2];y++){
437 color10 = savecolor10;
438 curz = savecurz;
439 x1 = (savex1>>10)+1; x2 = savex2>>10;
440 /* y, x1(10), x2(10), curz(10), stepZX(10), color10, stepColorX(10) */
441 if ( x2 < x1 ) x1 = x2;
442 if ( needCheckFr ){
443 if ( y > Nlm_stCon.ymax ) break;
444 if ( y < Nlm_stCon.ymin ) {
445 if ( y == ysort[1] ){
446 if ( mLeft ) {
447 stepXY1 = stepXYm;
448 stepColorY = stepColorYm;
449 stepZY = stepZYm;
450 savex1 = xsort[1]<<10;
451 } else {
452 stepXY2 = stepXYm;
453 savex2 = xsort[1]<<10;
454 }
455 }
456 savecolor10 += stepColorY;
457 savecurz += stepZY;
458 savex1 += stepXY1; savex2 += stepXY2;
459 continue;
460 }
461 reg2 = Nlm_stCon.xmin;
462 reg3 = Nlm_stCon.xmax;
463 reg1 = x1;
464 if ( reg1 > reg3 ) {
465 if ( y == ysort[1] ){
466 if ( mLeft ) {
467 stepXY1 = stepXYm;
468 stepColorY = stepColorYm;
469 stepZY = stepZYm;
470 savex1 = xsort[1]<<10;
471 } else {
472 stepXY2 = stepXYm;
473 savex2 = xsort[1]<<10;
474 }
475 }
476 savecolor10 += stepColorY;
477 savecurz += stepZY;
478 savex1 += stepXY1; savex2 += stepXY2;
479 continue;
480 }
481 if ( reg1 < reg2 ) {
482 x1 = reg2;
483 reg4 = reg2-reg1;
484 curz += stepZX*reg4;
485 color10 += stepColorX*reg4;
486 }
487 reg1 = x2;
488 if ( reg1 < reg2 ) {
489 if ( y == ysort[1] ){
490 if ( mLeft ) {
491 stepXY1 = stepXYm;
492 stepColorY = stepColorYm;
493 stepZY = stepZYm;
494 savex1 = xsort[1]<<10;
495 } else {
496 stepXY2 = stepXYm;
497 savex2 = xsort[1]<<10;
498 }
499 }
500 savecolor10 += stepColorY;
501 savecurz += stepZY;
502 savex1 += stepXY1; savex2 += stepXY2;
503 continue;
504 }
505 if ( reg1 > reg3 ) {
506 x2 = reg3;
507 }
508 }
509 reg1 = y*Nlm_stCon.width;
510 reg3 = (long)(Nlm_stCon.zBuffer + (reg1 + x1));
511 reg1 = (long)(Nlm_stCon.image + reg1 );
512 reg2 = reg1 + x2;
513 reg1 += x1;
514 if (reg1 < (long)Nlm_stCon.image ||
515 Nlm_stCon_image_end < reg2)
516 break;
517 while ( ((Uint4)reg2 - (Uint4)reg1) >= 4 ){
518 reg4 = curz;
519 curz = reg4 + stepZX;
520 reg4 >>= 10;
521 SETPIXEL(reg3,reg1,reg4,color10);
522 color10 += stepColorX;
523 reg3++; reg3++;
524 reg1++;
525 reg4 = curz;
526 curz = reg4 + stepZX;
527 reg4 >>= 10;
528 SETPIXEL(reg3,reg1,reg4,color10);
529 color10 += stepColorX;
530 reg3++; reg3++;
531 reg1++;
532 reg4 = curz;
533 curz = reg4 + stepZX;
534 reg4 >>= 10;
535 SETPIXEL(reg3,reg1,reg4,color10);
536 color10 += stepColorX;
537 reg3++; reg3++;
538 reg1++;
539 reg4 = curz;
540 curz = reg4 + stepZX;
541 reg4 >>= 10;
542 SETPIXEL(reg3,reg1,reg4,color10);
543 color10 += stepColorX;
544 reg3++; reg3++;
545 reg1++;
546 }
547 do {
548 reg4 = curz;
549 curz = reg4 + stepZX;
550 reg4 >>= 10;
551 SETPIXEL(reg3,reg1,reg4,color10);
552 color10 += stepColorX;
553 reg3++; reg3++;
554 } while (reg1++ != reg2 );
555 if ( y == ysort[1] ){
556 if ( mLeft ) {
557 stepXY1 = stepXYm;
558 stepColorY = stepColorYm;
559 stepZY = stepZYm;
560 savex1 = xsort[1]<<10;
561 } else {
562 stepXY2 = stepXYm;
563 savex2 = xsort[1]<<10;
564 }
565 }
566 savecolor10 += stepColorY;
567 savecurz += stepZY;
568 savex1 += stepXY1; savex2 += stepXY2;
569 }
570 }
571 }
572
573 static void Nlm_Poly3DHitT ( Nlm_Poly3DPtr p )
574 {
575 register long reg1;
576 register long reg2;
577 register long reg3;
578 register long reg4;
579 Int4Ptr vPtr;
580 long x,y;
581 long vx[3];
582 long vy[3];
583 long vz[3];
584 long dX1, dY1, dZ1;
585 long dX2, dY2, dZ2;
586 long xsort[3];
587 long ysort[3];
588 long zsort[3];
589 long savex1, savex2,savecurz,x1,x2,curz;
590 long stepZX;
591 long stepXY1, stepXY2, stepXYm = 0;
592 long stepZY = 0, stepZYm = 0;
593 Int2 needCheck, needCheckFr;
594 Int2 vi;
595 Int2 mLeft = 0;
596
597
598 reg1 = (long)p;
599 vPtr = ((Nlm_Poly3DPtr)reg1)->vert;
600 if ( vPtr == NULL ) return;
601
602 /* Rotate and check */
603 reg2 = ((Nlm_Poly3DPtr)reg1)->x;
604 reg3 = ((Nlm_Poly3DPtr)reg1)->y;
605 reg4 = ((Nlm_Poly3DPtr)reg1)->z;
606 x = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
607 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
608 y = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
609 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
610 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
611 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
612 reg4 = Nlm_stCon.zmaxPersp1-reg4;
613 reg2 = Nlm_stCon.width>>1;
614 reg3 = x-reg2;
615 x = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4;
616 reg2 = Nlm_stCon.height>>1;
617 reg3 = y-reg2;
618 y = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4;
619 reg2 = ((Nlm_Poly3DPtr)reg1)->rad / Nlm_stCon.scale;
620 reg2 = (reg2*Nlm_stCon.zmaxPersp)/reg4;
621 needCheck = 0;
622 x += reg2;
623 if ( x < Nlm_stCon.xmin ) return;
624 if ( x > Nlm_stCon.xmax ) needCheck=1;
625 x -= reg2<<1;
626 if ( x < Nlm_stCon.xmin ) needCheck=1;
627 if ( x > Nlm_stCon.xmax ) return;
628 y += reg2;
629 if ( y < Nlm_stCon.ymin ) return;
630 if ( y > Nlm_stCon.ymax ) needCheck=1;
631 y -= reg2<<1;
632 if ( y < Nlm_stCon.ymin ) needCheck=1;
633 if ( y > Nlm_stCon.ymax ) return;
634
635 reg2 = Nlm_stCon.a[0][0];
636 reg3 = ((Nlm_Poly3DPtr)reg1)->x1 / (long)reg2;
637 reg4 = ((Nlm_Poly3DPtr)reg1)->x2 / (long)reg2;
638 reg2 = Nlm_stCon.a[0][1];
639 reg3 += ((Nlm_Poly3DPtr)reg1)->y1 / (long)reg2;
640 reg4 += ((Nlm_Poly3DPtr)reg1)->y2 / (long)reg2;
641 reg2 = Nlm_stCon.a[0][2];
642 reg3 += ((Nlm_Poly3DPtr)reg1)->z1 / (long)reg2;
643 reg4 += ((Nlm_Poly3DPtr)reg1)->z2 / (long)reg2;
644 reg2 = Nlm_stCon.c[0];
645 reg3 += reg2;
646 reg4 += reg2;
647 vx[1] = reg3; vx[2] = reg4;
648
649 reg2 = Nlm_stCon.a[1][0];
650 reg3 = ((Nlm_Poly3DPtr)reg1)->x1 / (long)reg2;
651 reg4 = ((Nlm_Poly3DPtr)reg1)->x2 / (long)reg2;
652 reg2 = Nlm_stCon.a[1][1];
653 reg3 += ((Nlm_Poly3DPtr)reg1)->y1 / (long)reg2;
654 reg4 += ((Nlm_Poly3DPtr)reg1)->y2 / (long)reg2;
655 reg2 = Nlm_stCon.a[1][2];
656 reg3 += ((Nlm_Poly3DPtr)reg1)->z1 / (long)reg2;
657 reg4 += ((Nlm_Poly3DPtr)reg1)->z2 / (long)reg2;
658 reg2 = Nlm_stCon.c[1];
659 reg3 += reg2;
660 reg4 += reg2;
661 vy[1] = reg3; vy[2] = reg4;
662
663 reg2 = Nlm_stCon.a[2][0];
664 reg3 = ((Nlm_Poly3DPtr)reg1)->x1 / (long)reg2;
665 reg4 = ((Nlm_Poly3DPtr)reg1)->x2 / (long)reg2;
666 reg2 = Nlm_stCon.a[2][1];
667 reg3 += ((Nlm_Poly3DPtr)reg1)->y1 / (long)reg2;
668 reg4 += ((Nlm_Poly3DPtr)reg1)->y2 / (long)reg2;
669 reg2 = Nlm_stCon.a[2][2];
670 reg3 += ((Nlm_Poly3DPtr)reg1)->z1 / (long)reg2;
671 reg4 += ((Nlm_Poly3DPtr)reg1)->z2 / (long)reg2;
672 reg2 = Nlm_stCon.c[2];
673 reg3 += reg2;
674 reg4 += reg2;
675 vz[1] = reg3; vz[2] = reg4;
676
677 reg2 = Nlm_stCon.width>>1;
678 reg3 = vx[1]-reg2;
679 vx[1] = reg2 + (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[1]);
680 reg3 = vx[2]-reg2;
681 vx[2] = reg2 + (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[2]);
682 reg2 = Nlm_stCon.height>>1;
683 reg3 = vy[1]-reg2;
684 vy[1] = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[1]);
685 reg3 = vy[2]-reg2;
686 vy[2] = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-vz[2]);
687 reg3 = vz[1];
688 vz[1] = (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-reg3);
689 reg3 = vz[2];
690 vz[2] = (reg3*Nlm_stCon.zmaxPersp)/(Nlm_stCon.zmaxPersp1-reg3);
691
692 vi = 2;
693 while ( *vPtr != 0x7FFFFFFFL ){
694 reg1 = vi;
695 reg1++;
696 if ( reg1 > 2 ) reg1 = 0;
697 vi = (Int2)reg1;
698 reg1 = (long)vPtr;
699 reg2 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
700 reg3 = *(Int4Ptr)reg1; reg1 += sizeof(Int4);
701 reg4 = *(Int4Ptr)reg1; reg1 += sizeof(Int4) + 3 * sizeof(Int4);
702 vPtr = (Int4Ptr)reg1;
703 vx[vi] = reg2 / Nlm_stCon.a[0][0] + reg3 / Nlm_stCon.a[0][1] +
704 reg4 / Nlm_stCon.a[0][2] + Nlm_stCon.c[0];
705 vy[vi] = reg2 / Nlm_stCon.a[1][0] + reg3 / Nlm_stCon.a[1][1] +
706 reg4 / Nlm_stCon.a[1][2] + Nlm_stCon.c[1];
707 reg4 = reg2 / Nlm_stCon.a[2][0] + reg3 / Nlm_stCon.a[2][1] +
708 reg4 / Nlm_stCon.a[2][2] + Nlm_stCon.c[2];
709 vz[vi] = reg4;
710 reg4 = Nlm_stCon.zmaxPersp1-reg4;
711 reg2 = Nlm_stCon.width>>1;
712 reg3 = vx[vi]-reg2;
713 vx[vi] = reg2 + (reg3*Nlm_stCon.zmaxPersp)/reg4;
714 reg2 = Nlm_stCon.height>>1;
715 reg3 = vy[vi]-reg2;
716 vy[vi] = reg2 Y_PLUS (reg3*Nlm_stCon.zmaxPersp)/reg4;
717 vz[vi] = (vz[vi]*Nlm_stCon.zmaxPersp)/reg4;
718
719 reg1 = vy[0];
720 reg2 = vy[1];
721 reg3 = vy[2];
722 if ( reg1 < reg2 ){
723 if ( reg3 < reg1 ){ /* 312 */
724 xsort[0] = vx[2]; ysort[0] = reg3; zsort[0] = vz[2];
725 xsort[1] = vx[0]; ysort[1] = reg1; zsort[1] = vz[0];
726 xsort[2] = vx[1]; ysort[2] = reg2; zsort[2] = vz[1];
727 } else if ( reg3 < reg2 ){ /* 132 */
728 xsort[0] = vx[0]; ysort[0] = reg1; zsort[0] = vz[0];
729 xsort[1] = vx[2]; ysort[1] = reg3; zsort[1] = vz[2];
730 xsort[2] = vx[1]; ysort[2] = reg2; zsort[2] = vz[1];
731 } else { /* 123 */
732 xsort[0] = vx[0]; ysort[0] = reg1; zsort[0] = vz[0];
733 xsort[1] = vx[1]; ysort[1] = reg2; zsort[1] = vz[1];
734 xsort[2] = vx[2]; ysort[2] = reg3; zsort[2] = vz[2];
735 }
736 } else {
737 if ( reg3 < reg2 ){ /* 321 */
738 xsort[0] = vx[2]; ysort[0] = reg3; zsort[0] = vz[2];
739 xsort[1] = vx[1]; ysort[1] = reg2; zsort[1] = vz[1];
740 xsort[2] = vx[0]; ysort[2] = reg1; zsort[2] = vz[0];
741 } else if ( reg3 < reg1 ){ /* 231 */
742 xsort[0] = vx[1]; ysort[0] = reg2; zsort[0] = vz[1];
743 xsort[1] = vx[2]; ysort[1] = reg3; zsort[1] = vz[2];
744 xsort[2] = vx[0]; ysort[2] = reg1; zsort[2] = vz[0];
745 } else { /* 213 */
746 xsort[0] = vx[1]; ysort[0] = reg2; zsort[0] = vz[1];
747 xsort[1] = vx[0]; ysort[1] = reg1; zsort[1] = vz[0];
748 xsort[2] = vx[2]; ysort[2] = reg3; zsort[2] = vz[2];
749 }
750 }
751 dX1 = xsort[1] - xsort[0];
752 dY1 = ysort[1] - ysort[0];
753 dZ1 = zsort[1] - zsort[0];
754 dX2 = xsort[2] - xsort[0];
755 dY2 = ysort[2] - ysort[0];
756 dZ2 = zsort[2] - zsort[0];
757 reg1 = dY1*dZ2 - dZ1*dY2;
758 reg3 = dX1*dY2 - dY1*dX2;
759 if ( reg3 < 0 ) {
760 reg1=-reg1; reg3=-reg3;
761 }
762 if ( reg3 != 0 ) {
763 stepZX = reg1*(-1024)/reg3;
764 } else {
765 stepZX = 0;
766 }
767
768 needCheckFr = 0;
769 if ( needCheck ){
770 reg1 = ysort[0];
771 reg2 = ysort[2];
772 if ( (reg1 > Nlm_stCon.ymax)||
773 (reg2 < Nlm_stCon.ymin) ) continue;
774 if ( (reg1 < Nlm_stCon.ymin)||
775 (reg2 > Nlm_stCon.ymax) ) needCheckFr = 1;
776 reg1 = vx[0]; reg2 = vx[1];
777 if ( reg1 > reg2 ) { reg3 = reg1; reg1 = reg2; reg2 = reg3; }
778 reg3 = vx[2];
779 if ( reg3 < reg1 ) reg1 = reg3;
780 else if ( reg3 > reg2 ) reg2 = reg3;
781 if ( (reg1 > Nlm_stCon.xmax)||
782 (reg2 < Nlm_stCon.xmin) ) continue;
783 if ( (reg1 < Nlm_stCon.xmin)||
784 (reg2 > Nlm_stCon.xmax) ) needCheckFr = 1;
785 }
786 y = ysort[0];
787 if ( y == ysort[1] ){
788 if ( xsort[0] < xsort[1] ){
789 savex1 = xsort[0];
790 savex2 = xsort[1];
791 savecurz = zsort[0];
792 } else {
793 savex1 = xsort[1];
794 savex2 = xsort[0];
795 savecurz = zsort[1];
796 }
797 if ( ysort[2] != y ){
798 reg1 = ysort[2]-y;
799 stepXY1 = ((xsort[2]-savex1)<<10)/reg1;
800 stepXY2 = ((xsort[2]-savex2)<<10)/reg1;
801 stepZY = ((zsort[2] - savecurz)<<10)/reg1;
802 ysort[1] = 0x80000000L;
803 } else {
804 stepXY1 = stepXY2 = 0;
805 }
806 } else {
807 savex1 = savex2 = xsort[0];
808 savecurz = zsort[0];
809 reg1 = xsort[0]; reg2 = ysort[0];
810 if ( ((ysort[1]-reg2)*(xsort[2]-reg1) -
811 (xsort[1]-reg1)*(ysort[2]-reg2)) > 0 ){
812 mLeft = 1;
813 reg3 = ysort[1]-reg2;
814 stepXY1 = ((xsort[1]-savex1)<<10)/reg3;
815 stepZY = ((zsort[1]-zsort[0])<<10)/reg3;
816 stepXY2 = ((xsort[2]-savex1)<<10)/(ysort[2]-reg2);
817 reg3 = ysort[2]-ysort[1];
818 if ( reg3 != 0 ){
819 stepXYm = ((xsort[2]-xsort[1])<<10)/reg3;
820 stepZYm = ((zsort[2]-zsort[1])<<10)/reg3;
821 } else {
822 stepXYm = 0;
823 }
824 } else {
825 mLeft = 0;
826 reg3 = ysort[2]-reg2;
827 stepXY1 = ((xsort[2]-savex1)<<10)/reg3;
828 stepZY = ((zsort[2]-zsort[0])<<10)/reg3;
829 stepXY2 = ((xsort[1]-savex1)<<10)/(ysort[1]-reg2);
830 reg3 = ysort[2]-ysort[1];
831 if ( reg3 != 0 ){
832 stepXYm = ((xsort[2]-xsort[1])<<10)/reg3;
833 } else stepXYm = 0;
834 }
835 }
836 savex1 <<= 10;
837 savex2 <<= 10;
838 savecurz <<= 10;
839 /* y, savex1(10), savex2(10), savecurz(10), stepZX(10),
840 savecolor10, stepColorX(10), stepColorY, stepZY,
841 stepXY1, stepXY2,
842 mLeft, stepXYm, stepColorYm, stepZYm*/
843 for (; y<=ysort[2];y++){
844 curz = savecurz;
845 x1 = (savex1>>10)+1; x2 = savex2>>10;
846 /* y, x1(10), x2(10), curz(10), stepZX(10), color10, stepColorX(10) */
847 if ( x2 < x1 ) x1 = x2;
848 if ( needCheckFr ){
849 if ( y > Nlm_stCon.ymax ) break;
850 if ( y < Nlm_stCon.ymin ) {
851 if ( y == ysort[1] ){
852 if ( mLeft ) {
853 stepXY1 = stepXYm;
854 stepZY = stepZYm;
855 savex1 = xsort[1]<<10;
856 } else {
857 stepXY2 = stepXYm;
858 savex2 = xsort[1]<<10;
859 }
860 }
861 savecurz += stepZY;
862 savex1 += stepXY1; savex2 += stepXY2;
863 continue;
864 }
865 reg2 = Nlm_stCon.xmin;
866 reg3 = Nlm_stCon.xmax;
867 reg1 = x1;
868 if ( reg1 > reg3 ) {
869 if ( y == ysort[1] ){
870 if ( mLeft ) {
871 stepXY1 = stepXYm;
872 stepZY = stepZYm;
873 savex1 = xsort[1]<<10;
874 } else {
875 stepXY2 = stepXYm;
876 savex2 = xsort[1]<<10;
877 }
878 }
879 savecurz += stepZY;
880 savex1 += stepXY1; savex2 += stepXY2;
881 continue;
882 }
883 if ( reg1 < reg2 ) {
884 x1 = reg2;
885 reg4 = reg2-reg1;
886 curz += stepZX*reg4;
887 }
888 reg1 = x2;
889 if ( reg1 < reg2 ) {
890 if ( y == ysort[1] ){
891 if ( mLeft ) {
892 stepXY1 = stepXYm;
893 stepZY = stepZYm;
894 savex1 = xsort[1]<<10;
895 } else {
896 stepXY2 = stepXYm;
897 savex2 = xsort[1]<<10;
898 }
899 }
900 savecurz += stepZY;
901 savex1 += stepXY1; savex2 += stepXY2;
902 continue;
903 }
904 if ( reg1 > reg3 ) {
905 x2 = reg3;
906 }
907 }
908 reg1 = Nlm_stCon.xmin;
909 x1 -= reg1; x2 -= reg1;
910 reg1 = (y-Nlm_stCon.ymin)*Nlm_stCon.widthCur;
911 reg3 = (long)(Nlm_stCon.zBuffer + (reg1 + x1));
912 reg1 = (long)(Nlm_stCon.idBuffer + reg1);
913 reg2 = reg1 + x2 * sizeof(Nlm_stCon.idBuffer[0]);
914 reg1 += x1 * sizeof(Nlm_stCon.idBuffer[0]);
915 reg2 -= 4 * sizeof(Nlm_stCon.idBuffer[0]);
916 while (reg1 <= reg2) {
917 reg4 = curz;
918 curz = reg4 + stepZX;
919 reg4 >>= 10;
920 SETPIXELID(reg3,reg1,reg4,p);
921 reg3++; reg3++;
922 reg1 += sizeof(Nlm_stCon.idBuffer[0]);
923 reg4 = curz;
924 curz = reg4 + stepZX;
925 reg4 >>= 10;
926 SETPIXELID(reg3,reg1,reg4,p);
927 reg3++; reg3++;
928 reg1 += sizeof(Nlm_stCon.idBuffer[0]);
929 reg4 = curz;
930 curz = reg4 + stepZX;
931 reg4 >>= 10;
932 SETPIXELID(reg3,reg1,reg4,p);
933 reg3++; reg3++;
934 reg1 += sizeof(Nlm_stCon.idBuffer[0]);
935 reg4 = curz;
936 curz = reg4 + stepZX;
937 reg4 >>= 10;
938 SETPIXELID(reg3,reg1,reg4,p);
939 reg3++; reg3++;
940 reg1 += sizeof(Nlm_stCon.idBuffer[0]);
941 }
942 reg1 -= sizeof(Nlm_stCon.idBuffer[0]);
943 reg2 += 4 * sizeof(Nlm_stCon.idBuffer[0]);
944 do {
945 reg1 += sizeof(Nlm_stCon.idBuffer[0]);
946 reg4 = curz;
947 curz = reg4 + stepZX;
948 reg4 >>= 10;
949 SETPIXELID(reg3,reg1,reg4,p);
950 reg3++; reg3++;
951 } while (reg1 != reg2 );
952 if ( y == ysort[1] ){
953 if ( mLeft ) {
954 stepXY1 = stepXYm;
955 stepZY = stepZYm;
956 savex1 = xsort[1]<<10;
957 } else {
958 stepXY2 = stepXYm;
959 savex2 = xsort[1]<<10;
960 }
961 }
962 savecurz += stepZY;
963 savex1 += stepXY1; savex2 += stepXY2;
964 }
965 }
966 }
967
968 static void Nlm_Poly3DGetL ( Nlm_Poly3DPtr p )
969 {
970 register BigScalar ax;
971 register BigScalar bx;
972 register long cx;
973 long minXYZ, maxXYZ;
974 double diam;
975
976 ax = (BigScalar)p;
977 bx = (BigScalar)(((Nlm_PSeg3DPtr)ax)->base.parent);
978 maxXYZ = ((Nlm_Poly3DPtr)ax)->xmax; minXYZ = ((Nlm_Poly3DPtr)ax)->xmin;
979 ((Nlm_Poly3DPtr)ax)->x = (maxXYZ+minXYZ)>>1;
980 cx = maxXYZ - minXYZ;
981 diam = (double)cx*(double)cx;
982 if ( ((Nlm_PSeg3DPtr)bx)->segBox.minX > minXYZ )
983 ((Nlm_PSeg3DPtr)bx)->segBox.minX = minXYZ;
984 if ( ((Nlm_PSeg3DPtr)bx)->segBox.maxX < maxXYZ )
985 ((Nlm_PSeg3DPtr)bx)->segBox.maxX = maxXYZ;
986 maxXYZ = ((Nlm_Poly3DPtr)ax)->ymax; minXYZ = ((Nlm_Poly3DPtr)ax)->ymin;
987 ((Nlm_Poly3DPtr)ax)->y = (maxXYZ+minXYZ)>>1;
988 cx = maxXYZ - minXYZ;
989 diam += (double)cx*(double)cx;
990 if ( ((Nlm_PSeg3DPtr)bx)->segBox.minY > minXYZ )
991 ((Nlm_PSeg3DPtr)bx)->segBox.minY = minXYZ;
992 if ( ((Nlm_PSeg3DPtr)bx)->segBox.maxY < maxXYZ )
993 ((Nlm_PSeg3DPtr)bx)->segBox.maxY = maxXYZ;
994 maxXYZ = ((Nlm_Poly3DPtr)ax)->zmax; minXYZ = ((Nlm_Poly3DPtr)ax)->zmin;
995 ((Nlm_Poly3DPtr)ax)->z = (maxXYZ+minXYZ)>>1;
996 cx = maxXYZ - minXYZ;
997 diam += (double)cx*(double)cx;
998 if ( ((Nlm_PSeg3DPtr)bx)->segBox.minZ > minXYZ )
999 ((Nlm_PSeg3DPtr)bx)->segBox.minZ = minXYZ;
1000 if ( ((Nlm_PSeg3DPtr)bx)->segBox.maxZ < maxXYZ )
1001 ((Nlm_PSeg3DPtr)bx)->segBox.maxZ = maxXYZ;
1002 diam = sqrt ( diam );
1003 ((Nlm_Poly3DPtr)ax)->rad = (long)(diam+0.5);
1004 }
1005
1006 static void Nlm_Poly3DFree ( Nlm_Poly3DPtr p )
1007 {
1008 if ( p->vert != NULL ) MemFree ( p->vert );
1009 p->vert = NULL;
1010 p->vNum = 0;
1011 }
1012
1013 static Nlm_PrimDef3D lineDef = {
1014 (Nlm_PrimDraw3D)Nlm_Poly3DDraw,
1015 (Nlm_PrimHitTest3D)Nlm_Poly3DHitT,
1016 (Nlm_PrimGetLimits3D)Nlm_Poly3DGetL,
1017 (Nlm_PrimCleanup3D)Nlm_Poly3DFree,
1018 (Nlm_Int2)POLY3D
1019 };
1020
1021 Nlm_Prim3D Nlm_AddPoly3D ( Nlm_Picture3D pic, Nlm_Segment3D segment,
1022 BigScalar userData, Uint1 layer, Uint1 color,
1023 Int4 x1, Int4 y1, Int4 z1,
1024 Int4 x2, Int4 y2, Int4 z2 )
1025 {
1026 Nlm_Poly3D l;
1027
1028 Nlm_stCon.pic = pic;
1029 Nlm_DiagReset ();
1030 l.base.userData = userData;
1031 l.base.layer = layer;
1032 l.base.color = color;
1033 l.base.fTable = &lineDef;
1034 l.base.status = 0;
1035 l.x1 = (long)x1; l.x2 = (long)x2;
1036 l.y1 = (long)y1; l.y2 = (long)y2;
1037 l.z1 = (long)z1; l.z2 = (long)z2;
1038 l.vNum = 0;
1039 if ( x1 < x2 ) { l.xmin = x1; l.xmax = x2;
1040 } else { l.xmin = x2; l.xmax = x1; }
1041 if ( y1 < y2 ) { l.ymin = y1; l.ymax = y2;
1042 } else { l.ymin = y2; l.ymax = y1; }
1043 if ( z1 < z2 ) { l.zmin = z1; l.zmax = z2;
1044 } else { l.zmin = z2; l.zmax = z1; }
1045 return (Nlm_Prim3D) Nlm_AddPrim3D ( (Nlm_PSeg3DPtr)segment,
1046 (Nlm_Base3DPtr)&l,
1047 sizeof(Nlm_Poly3D),
1048 "AddPoly3D" );
1049 }
1050
1051 Boolean Nlm_AddVertPoly3D ( Nlm_Picture3D pic, Nlm_Prim3D poly,
1052 Int4 x, Int4 y, Int4 z )
1053 {
1054 register Nlm_Poly3DPtr p;
1055 register Int4Ptr vertPtr;
1056 register long vNum;
1057 double sq;
1058 double dx,dy,dz;
1059 long x1,y1,z1,x2,y2,z2;
1060
1061 p = (Nlm_Poly3DPtr)poly;
1062 if ( p == NULL ) return FALSE;
1063 vNum = p->vNum + 1;
1064 if ( vNum == 1 ){
1065 vertPtr = (Int4Ptr) MemNew( sizeof(Int4)*300 );
1066 p->vert = vertPtr;
1067 x1 = p->x1; y1 = p->y1; z1 = p->z1;
1068 x2 = p->x2; y2 = p->y2; z2 = p->z2;
1069 } else if ( vNum == 2 ) {
1070 x1 = p->x2; y1 = p->y2; z1 = p->z2;
1071 vertPtr = p->vert;
1072 x2 = *vertPtr++; y2 = *vertPtr++; z2 = *vertPtr++;
1073 vertPtr += 3;
1074 } else if ( ((vNum/50)*50) == vNum ){
1075 vertPtr = (Int4Ptr) MemNew( (vNum+50)*6*sizeof(Int4) );
1076 MemCopy ( vertPtr, p->vert, (vNum-1)*6*sizeof(Int4) );
1077 MemFree ( p->vert );
1078 p->vert = vertPtr;
1079 vertPtr += (vNum-3)*6;
1080 x1 = *vertPtr++; y1 = *vertPtr++; z1 = *vertPtr++;
1081 vertPtr += 3;
1082 x2 = *vertPtr++; y2 = *vertPtr++; z2 = *vertPtr++;
1083 vertPtr += 3;
1084 } else {
1085 vertPtr = p->vert;
1086 vertPtr += (vNum-3)*6;
1087 x1 = *vertPtr++; y1 = *vertPtr++; z1 = *vertPtr++;
1088 vertPtr += 3;
1089 x2 = *vertPtr++; y2 = *vertPtr++; z2 = *vertPtr++;
1090 vertPtr += 3;
1091 }
1092 if ( x < (Int4)p->xmin ) p->xmin = (long)x;
1093 else if ( x > (Int4)p->xmax ) p->xmax = (long)x;
1094 if ( y < (Int4)p->ymin ) p->ymin = (long)y;
1095 else if ( y > (Int4)p->ymax ) p->ymax = (long)y;
1096 if ( z < (Int4)p->zmin ) p->zmin = (long)z;
1097 else if ( z > (Int4)p->zmax ) p->zmax = (long)z;
1098 *vertPtr++ = (long)x; *vertPtr++ = (long)y; *vertPtr++ = (long)z;
1099 x -= (Int4)x1; y -= (Int4)y1; z -= (Int4)z1;
1100 x1 = x2-x1; y1 = y2-y1; z1 = z2-z1;
1101 x2 = (long)x; y2 = (long)y; z2 = (long)z;
1102 dx = (double)y1*(double)z2-(double)z1*(double)y2;
1103 dy = (double)z1*(double)x2-(double)x1*(double)z2;
1104 dz = (double)x1*(double)y2-(double)y1*(double)x2;
1105 sq = sqrt ( dx*dx + dy*dy + dz*dz );
1106 dx *= 1e9/sq; dy *= 1e9/sq; dz *= 1e9/sq;
1107 *vertPtr++ = (long)dx;
1108 *vertPtr++ = (long)dy;
1109 *vertPtr++ = (long)dz;
1110 *vertPtr = 0x7FFFFFFFL;
1111 p->vNum = vNum;
1112 return TRUE;
1113 }
1114
1115 |
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more information. |