From: pfuetz@igd.fhg.de (Matthias Pfuetzner)
Newsgroups: comp.windows.x.pex,comp.unix.aix,alt.graphics,comp.graphics
Subject: IBM's graPHIGS package, problem with GPNBS, any hint? (again!)
Date: 15 Sep 92 13:27:04 GMT
Reply-To: pfuetz@igd.fhg.de (Matthias Pfuetzner)
Followup-To: poster
Organization: Zentrum fuer Graphische Datenverarbeitung, Darmstadt, FRG

Hi again!

In article <1484@igd.fhg.de> I wrote:
>I have a problem with IBM RS/6000 graPHIGS library and the GPNBS call.
>
>Simply said: The above call inserts the corresponding element into the
>structure store, but I don't see nothing on the screen!
[some stuff deleted]
>                                 The data I supply for the B-spline surface is
>OK, as I am also using libphigs.a (producing PEX calls) on the IBM and on Sun
>workstations with X11R5 by MIT. With these libraries I see my surface!
[some stuff deleted]

Here now a complete, but stripped down example! If anybody can tell me what I
did wrong, I'd really appreciate it.

Sincerly,
        Matthias
----- cut ----- cut ----- cut ----- cut ----- cut ----- cut -----
/* To build, use:
   cc -g -I/usr/include -I/usr/lpp/graPHIGS/samples/cbinding -DAIXV3 -D_BSD
                                                     -D__STR31__ -c my_test.c
   cc -o my_test my_test.o -g -lgP -lXext -lX11 -lm
*/

#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <phigs.h>
#include <afmnc.h>

typedef struct
{
   Pint     num_floats;    /* number of Pfloats in list */
   Pfloat   *floats;       /* list of floats            */
} Pfloat_list;

typedef struct
{
   Pint     u_dim;         /* dimension (number of divisions) along U */
   Pint     v_dim;         /* dimension (number of divisions) along V */
} Ppcs_dims;

typedef struct
{
   Pfloat   x;             /* x coordinate */
   Pfloat   y;             /* y coordinate */
   Pfloat   z;             /* z coordinate */
   Pfloat   w;             /* w coordinate */
} Ppoint4;

typedef struct
{                          /* grid of 3D or 4D points, [u_dim][v_dim] */
   Ppcs_dims   num_points; /* number of points in each dimension */
   union
   {
      Ppoint3  *point3d;   /* array of 3D points */
      Ppoint4  *point4d;   /* array of 4D points */
   } points;
} Ppoint_grid34;

int         ret_val;
Ppoint3     vrp;
Pvec3       vpn;
Pvec3       vup;
Pview_rep3  vrep;
Pint        err;
Pview_map3  view_map;
double      x3d[3];
double      A1;
double      A2;
double      B1;
double      L1;
double      L2;
double      RI;
double      RA;
double      ALFA;

int tube_bow()
{
   Ppoint_list_list3 side_list;
   Ppoint_list3      side;
   Ppoint3           p[4];
   Ppoint3           pf;
   Pvec3             shift;
   Pvec3             scale;
   Pmatrix3          matrix;
   Pfloat_list       uknots;
   Pfloat            tmp_floats_x[4];
   Pfloat_list       vknots;
   Pfloat            tmp_floats_y[8];
   Ppoint_grid34     grid;
   Ppoint4           tmp_points[10];
   double            tmp_ang;
   double            tmp_ang_15x;
   double            tmp_ang_25x;
   double            tmp_ang_35x;
   double            tmp_ang_45x;
   double            tmp_ang_15y;
   double            tmp_ang_25y;
   double            tmp_ang_35y;
   double            tmp_ang_45y;
   double            diff_x;
   double            diff_y;
   double            weight;
   
   
   
   side.num_points = 4;
   side.points     = p;
   
   side_list.num_point_lists = 1;
   side_list.point_lists     = &side;
   
   pf.x = x3d[0];
   pf.y = x3d[1];
   pf.z = x3d[2];
   
   shift.delta_x = 0.;
   shift.delta_y = 0.;
   shift.delta_z = 0.;
   
   scale.delta_x = 1.;
   scale.delta_y = 1.;
   scale.delta_z = 1.;
   
   pbuild_tran_matrix3( &pf, &shift, (Pfloat)0., (Pfloat)0., (Pfloat)0.,
                        &scale, &err, matrix );
   
   pset_local_tran3( matrix, PTYPE_REPLACE );
   
   uknots.num_floats = 4;
   uknots.floats = tmp_floats_x;
   
   uknots.floats[0] = 0.;
   uknots.floats[1] = 0.;
   uknots.floats[2] = 1.;
   uknots.floats[3] = 1.;
   
   if( ALFA <= 90.0 )
      vknots.num_floats = 6;
   else
      vknots.num_floats = 8;
   
   vknots.floats = tmp_floats_y;
   
   vknots.floats[0] = 0.;
   vknots.floats[1] = 0.;
   vknots.floats[2] = 0.;
   vknots.floats[3] = 1.;
   vknots.floats[4] = 1.;
   
   if( ALFA <= 90.0 )
      vknots.floats[5] = 1.;
   else
   {
      vknots.floats[5] = 2.;
      vknots.floats[6] = 2.;
      vknots.floats[7] = 2.;
   }
   
   grid.num_points.u_dim = 2;
   if( ALFA <= 90.0 )
      grid.num_points.v_dim = 3;
   else
      grid.num_points.v_dim = 5;

   grid.points.point4d = tmp_points;
        
   tmp_ang = ALFA * 3.14159265358979323846 / 180;
   if( ALFA <= 90.0 )
   {
      tmp_ang_25x = tan( tmp_ang / 2 );
      tmp_ang_25y = tan( tmp_ang / 2 );
      
      tmp_ang_45x = cos( ( 90 - ALFA ) * 3.14159265358979323846 / 180. );
      tmp_ang_45y = sin( ( 90 - ALFA ) * 3.14159265358979323846 / 180. );
      
      weight = cos( tmp_ang / 2 );
   }
   else
   {
      tmp_ang_15x = tan( tmp_ang / 4 );
      tmp_ang_15y = tan( tmp_ang / 4 );
      
      tmp_ang_25x = cos((90 - ( ALFA / 2. ) ) * 3.14159265358979323846 / 180.);
      tmp_ang_25y = sin((90 - ( ALFA / 2. ) ) * 3.14159265358979323846 / 180.);
      
      tmp_ang_35x = tan( 3 * tmp_ang / 4 );
      tmp_ang_35y = tan( 3 * tmp_ang / 4 );
      
      tmp_ang_45x = sin( ( 180 - ALFA ) * 3.14159265358979323846 / 180. );
      tmp_ang_45y = cos( ( 180 - ALFA ) * 3.14159265358979323846 / 180. );
      
      weight = cos( tmp_ang / 4 );
   }
   
   /**************/
   /* Front part */
   /**************/
   
   /* front */
   p[0].x = x3d[0];
   p[0].y = x3d[1] - (A1/2);
   p[0].z = x3d[2] + (B1/2);
      
   p[1].x = x3d[0] + L2;
   p[1].y = x3d[1] - (A1/2);
   p[1].z = x3d[2] + (B1/2);
   
   p[2].x = x3d[0] + L2;
   p[2].y = x3d[1] + (A1/2);
   p[2].z = x3d[2] + (B1/2);
   
   p[3].x = x3d[0];
   p[3].y = x3d[1] + (A1/2);
   p[3].z = x3d[2] + (B1/2);
   
   pfill_area_set3( &side_list );
   
   /* back */
   p[3].x = x3d[0];
   p[3].y = x3d[1] - (A1/2);
   p[3].z = x3d[2] - (B1/2);
   
   p[2].x = x3d[0] + L2;
   p[2].y = x3d[1] - (A1/2);
   p[2].z = x3d[2] - (B1/2);
   
   p[1].x = x3d[0] + L2;
   p[1].y = x3d[1] + (A1/2);
   p[1].z = x3d[2] - (B1/2);
   
   p[0].x = x3d[0];
   p[0].y = x3d[1] + (A1/2);
   p[0].z = x3d[2] - (B1/2);
   
   pfill_area_set3( &side_list );
   
   /* bottom */
   p[3].x = x3d[0];
   p[3].y = x3d[1] - (A1/2);
   p[3].z = x3d[2] + (B1/2);
   
   p[2].x = x3d[0] + L2;
   p[2].y = x3d[1] - (A1/2);
   p[2].z = x3d[2] + (B1/2);
   
   p[1].x = x3d[0] + L2;
   p[1].y = x3d[1] - (A1/2);
   p[1].z = x3d[2] - (B1/2);
   
   p[0].x = x3d[0];
   p[0].y = x3d[1] - (A1/2);
   p[0].z = x3d[2] - (B1/2);
   
   pfill_area_set3( &side_list );
   
   /* top */
   p[0].x = x3d[0];
   p[0].y = x3d[1] + (A1/2);
   p[0].z = x3d[2] + (B1/2);
   
   p[1].x = x3d[0] + L2;
   p[1].y = x3d[1] + (A1/2);
   p[1].z = x3d[2] + (B1/2);
   
   p[2].x = x3d[0] + L2;
   p[2].y = x3d[1] + (A1/2);
   p[2].z = x3d[2] - (B1/2);
   
   p[3].x = x3d[0];
   p[3].y = x3d[1] + (A1/2);
   p[3].z = x3d[2] - (B1/2);
   
   pfill_area_set3( &side_list );
   
   /***************/
   /* Middle part */
   /***************/
   
   /* back */
   
   /* Assign the points */
   
   /* [0][0] */
   grid.points.point4d[0].x = x3d[0] + L2;
   grid.points.point4d[0].y = x3d[1] - (A1/2);
   grid.points.point4d[0].z = x3d[2] + (B1/2);
   grid.points.point4d[0].w = 1.0;
   
   /* [1][0] */
   grid.points.point4d[1].x = x3d[0] + L2;
   grid.points.point4d[1].y = x3d[1] + (A1/2);
   grid.points.point4d[1].z = x3d[2] + (B1/2);
   grid.points.point4d[1].w = 1.0;
   
   if( ALFA <= 90.0 )
   {
      /* [0][1] */
      grid.points.point4d[2].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[2].y = x3d[1] - (A1/2);
      grid.points.point4d[2].z = x3d[2] + (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [1][1] */
      grid.points.point4d[3].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2 );
      grid.points.point4d[3].y = x3d[1] + (A1/2);
      grid.points.point4d[3].z = x3d[2] + (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [0][2] */
      grid.points.point4d[4].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[4].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_45y ) * RI );
      grid.points.point4d[4].z = x3d[2] + (B1/2);
      grid.points.point4d[4].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[5].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[5].y = x3d[1] - (A1/2) + A2 -
                                 ( ( 1 - tmp_ang_45y ) * (RI + A2) );
      grid.points.point4d[5].z = x3d[2] + (B1/2);
      grid.points.point4d[5].w = 1.0;
   }
   else
   {
      /* [0][1] */
      grid.points.point4d[2].x = x3d[0] + L2 + ( tmp_ang_15x * RI );
      grid.points.point4d[2].y = x3d[1] - (A1/2);
      grid.points.point4d[2].z = x3d[2] + (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [1][1] */
      grid.points.point4d[3].x = x3d[0] + L2 +
                                 ( tmp_ang_15x * (3*RA + RI + A2)/4 );
      grid.points.point4d[3].y = x3d[1] + (A1/2);
      grid.points.point4d[3].z = x3d[2] + (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [0][2] */
      grid.points.point4d[4].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[4].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * RI );
      grid.points.point4d[4].z = x3d[2] + (B1/2);
      grid.points.point4d[4].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[5].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2 );
      grid.points.point4d[5].y = x3d[1] + (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * (RA + RI + A2)/2 );
      grid.points.point4d[5].z = x3d[2] + (B1/2);
      grid.points.point4d[5].w = 1.0;
      
      diff_x = grid.points.point4d[2].x - grid.points.point4d[4].x;
      diff_y = grid.points.point4d[2].y - grid.points.point4d[4].y;
      
      grid.points.point4d[6].x = grid.points.point4d[4].x - diff_x;
      grid.points.point4d[6].y = grid.points.point4d[4].y - diff_y;
      grid.points.point4d[6].z = x3d[2] + (B1/2);
      grid.points.point4d[6].w = weight;
      
      diff_x = grid.points.point4d[3].x - grid.points.point4d[5].x;
      diff_y = grid.points.point4d[3].y - grid.points.point4d[5].y;
      
      grid.points.point4d[7].x = grid.points.point4d[5].x - diff_x;
      grid.points.point4d[7].y = grid.points.point4d[5].y - diff_y;
      grid.points.point4d[7].z = x3d[2] + (B1/2);
      grid.points.point4d[7].w = weight;
      
      /* [0][4] */
      grid.points.point4d[8].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[8].y = x3d[1] - (A1/2) - RI - tmp_ang_45y * RI;
      grid.points.point4d[8].z = x3d[2] + (B1/2);
      grid.points.point4d[8].w = 1.0;
      
      /* [1][4] */
      grid.points.point4d[9].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[9].y = x3d[1] - (A1/2) - RI -
                                 tmp_ang_45y * (RI + A2);
      grid.points.point4d[9].z = x3d[2] + (B1/2);
      grid.points.point4d[9].w = 1.0;
   }
   
   GPNBS( (Pint)2, (Pint) 3, uknots.num_floats - 2, vknots.num_floats - 3,
          uknots.floats, vknots.floats, 0, 0, 0, 1, 4, grid.points.point4d,
          uknots.floats[0], uknots.floats[uknots.num_floats - 1],
          vknots.floats[0], vknots.floats[vknots.num_floats - 1] );
   
   /* front */
   
   /* Assign the points */
   
   /* [0][0] */
   grid.points.point4d[1].x = x3d[0] + L2;
   grid.points.point4d[1].y = x3d[1] - (A1/2);
   grid.points.point4d[1].z = x3d[2] - (B1/2);
   grid.points.point4d[1].w = 1.0;
   
   /* [1][0] */
   grid.points.point4d[0].x = x3d[0] + L2;
   grid.points.point4d[0].y = x3d[1] + (A1/2);
   grid.points.point4d[0].z = x3d[2] - (B1/2);
   grid.points.point4d[0].w = 1.0;
   
   if( ALFA <= 90.0 )
   {
      /* [0][1] */
      grid.points.point4d[3].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[3].y = x3d[1] - (A1/2);
      grid.points.point4d[3].z = x3d[2] - (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [1][1] */
      grid.points.point4d[2].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2);
      grid.points.point4d[2].y = x3d[1] + (A1/2);
      grid.points.point4d[2].z = x3d[2] - (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [0][2] */
      grid.points.point4d[5].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[5].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_45y ) * RI );
      grid.points.point4d[5].z = x3d[2] - (B1/2);
      grid.points.point4d[5].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[4].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[4].y = x3d[1] - (A1/2) + A2 -
                                 ( ( 1 - tmp_ang_45y ) * (RI + A2) );
      grid.points.point4d[4].z = x3d[2] - (B1/2);
      grid.points.point4d[4].w = 1.0;
   }
   else
   {
      /* [0][1] */
      grid.points.point4d[3].x = x3d[0] + L2 + ( tmp_ang_15x * RI );
      grid.points.point4d[3].y = x3d[1] - (A1/2);
      grid.points.point4d[3].z = x3d[2] - (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [1][1] */
      grid.points.point4d[2].x = x3d[0] + L2 +
                                 ( tmp_ang_15x * (3*RA + RI + A2)/4 );
      grid.points.point4d[2].y = x3d[1] + (A1/2);
      grid.points.point4d[2].z = x3d[2] - (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [0][2] */
      grid.points.point4d[5].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[5].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * RI );
      grid.points.point4d[5].z = x3d[2] - (B1/2);
      grid.points.point4d[5].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[4].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2);
      grid.points.point4d[4].y = x3d[1] + (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * (RA + RI + A2)/2 );
      grid.points.point4d[4].z = x3d[2] - (B1/2);
      grid.points.point4d[4].w = 1.0;
      
      diff_x = grid.points.point4d[3].x - grid.points.point4d[5].x;
      diff_y = grid.points.point4d[3].y - grid.points.point4d[5].y;
      
      grid.points.point4d[7].x = grid.points.point4d[5].x - diff_x;
      grid.points.point4d[7].y = grid.points.point4d[5].y - diff_y;
      grid.points.point4d[7].z = x3d[2] - (B1/2);
      grid.points.point4d[7].w = weight;
      
      diff_x = grid.points.point4d[2].x - grid.points.point4d[4].x;
      diff_y = grid.points.point4d[2].y - grid.points.point4d[4].y;
      
      grid.points.point4d[6].x = grid.points.point4d[4].x - diff_x;
      grid.points.point4d[6].y = grid.points.point4d[4].y - diff_y;
      grid.points.point4d[6].z = x3d[2] - (B1/2);
      grid.points.point4d[6].w = weight;
      
      /* [0][4] */
      grid.points.point4d[9].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[9].y = x3d[1] - (A1/2) - RI - tmp_ang_45y * RI;
      grid.points.point4d[9].z = x3d[2] - (B1/2);
      grid.points.point4d[9].w = 1.0;
      
      /* [1][4] */
      grid.points.point4d[8].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[8].y = x3d[1] - (A1/2) - RI -
                                 tmp_ang_45y * (RI + A2);
      grid.points.point4d[8].z = x3d[2] - (B1/2);
      grid.points.point4d[8].w = 1.0;
   }
   
   GPNBS( (Pint)2, (Pint) 3, uknots.num_floats - 2, vknots.num_floats - 3,
          uknots.floats, vknots.floats, 0, 0, 0, 1, 4, grid.points.point4d,
          uknots.floats[0], uknots.floats[uknots.num_floats - 1],
          vknots.floats[0], vknots.floats[vknots.num_floats - 1] );
   
   /* top */
   
   /* Assign the points */
   
   /* [0][0] */
   grid.points.point4d[1].x = x3d[0] + L2;
   grid.points.point4d[1].y = x3d[1] - (A1/2);
   grid.points.point4d[1].z = x3d[2] + (B1/2);
   grid.points.point4d[1].w = 1.0;
   
   /* [1][0] */
   grid.points.point4d[0].x = x3d[0] + L2;
   grid.points.point4d[0].y = x3d[1] - (A1/2);
   grid.points.point4d[0].z = x3d[2] - (B1/2);
   grid.points.point4d[0].w = 1.0;
   
   if( ALFA <= 90.0 )
   {
      /* [0][1] */
      grid.points.point4d[3].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[3].y = x3d[1] - (A1/2);
      grid.points.point4d[3].z = x3d[2] + (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [1][1] */
      grid.points.point4d[2].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[2].y = x3d[1] - (A1/2);
      grid.points.point4d[2].z = x3d[2] - (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [0][2] */
      grid.points.point4d[5].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[5].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_45y ) * RI );
      grid.points.point4d[5].z = x3d[2] + (B1/2);
      grid.points.point4d[5].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[4].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[4].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_45y ) * RI );
      grid.points.point4d[4].z = x3d[2] - (B1/2);
      grid.points.point4d[4].w = 1.0;
   }
   else
   {
      /* [0][1] */
      grid.points.point4d[3].x = x3d[0] + L2 + ( tmp_ang_15x * RI );
      grid.points.point4d[3].y = x3d[1] - (A1/2);
      grid.points.point4d[3].z = x3d[2] + (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [1][1] */
      grid.points.point4d[2].x = x3d[0] + L2 + ( tmp_ang_15x * RI );
      grid.points.point4d[2].y = x3d[1] - (A1/2);
      grid.points.point4d[2].z = x3d[2] - (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [0][2] */
      grid.points.point4d[5].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[5].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * RI );
      grid.points.point4d[5].z = x3d[2] + (B1/2);
      grid.points.point4d[5].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[4].x = x3d[0] + L2 + ( tmp_ang_25x * RI );
      grid.points.point4d[4].y = x3d[1] - (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * RI );
      grid.points.point4d[4].z = x3d[2] - (B1/2);
      grid.points.point4d[4].w = 1.0;
      
      diff_x = grid.points.point4d[3].x - grid.points.point4d[5].x;
      diff_y = grid.points.point4d[3].y - grid.points.point4d[5].y;
      
      grid.points.point4d[7].x = grid.points.point4d[5].x - diff_x;
      grid.points.point4d[7].y = grid.points.point4d[5].y - diff_y;
      grid.points.point4d[7].z = x3d[2] + (B1/2);
      grid.points.point4d[7].w = weight;
      
      diff_x = grid.points.point4d[2].x - grid.points.point4d[4].x;
      diff_y = grid.points.point4d[2].y - grid.points.point4d[4].y;
      
      grid.points.point4d[6].x = grid.points.point4d[4].x - diff_x;
      grid.points.point4d[6].y = grid.points.point4d[4].y - diff_y;
      grid.points.point4d[6].z = x3d[2] - (B1/2);
      grid.points.point4d[6].w = weight;
      
      /* [0][4] */
      grid.points.point4d[9].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[9].y = x3d[1] - (A1/2) - RI - tmp_ang_45y * RI;
      grid.points.point4d[9].z = x3d[2] + (B1/2);
      grid.points.point4d[9].w = 1.0;
      
      /* [1][4] */
      grid.points.point4d[8].x = x3d[0] + L2 + ( tmp_ang_45x * RI );
      grid.points.point4d[8].y = x3d[1] - (A1/2) - RI - tmp_ang_45y * RI;
      grid.points.point4d[8].z = x3d[2] - (B1/2);
      grid.points.point4d[8].w = 1.0;
   }
   
   GPNBS( (Pint)2, (Pint) 3, uknots.num_floats - 2, vknots.num_floats - 3,
          uknots.floats, vknots.floats, 0, 0, 0, 1, 4, grid.points.point4d,
          uknots.floats[0], uknots.floats[uknots.num_floats - 1],
          vknots.floats[0], vknots.floats[vknots.num_floats - 1] );
   
   /* bottom */
   
   /* Assign the points */
   
   /* [0][0] */
   grid.points.point4d[0].x = x3d[0] + L2;
   grid.points.point4d[0].y = x3d[1] + (A1/2);
   grid.points.point4d[0].z = x3d[2] + (B1/2);
   grid.points.point4d[0].w = 1.0;
   
   /* [1][0] */
   grid.points.point4d[1].x = x3d[0] + L2;
   grid.points.point4d[1].y = x3d[1] + (A1/2);
   grid.points.point4d[1].z = x3d[2] - (B1/2);
   grid.points.point4d[1].w = 1.0;
   
   if( ALFA <= 90.0 )
   {
      /* [0][1] */
      grid.points.point4d[2].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2 );
      grid.points.point4d[2].y = x3d[1] + (A1/2);
      grid.points.point4d[2].z = x3d[2] + (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [1][1] */
      grid.points.point4d[3].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2 );
      grid.points.point4d[3].y = x3d[1] + (A1/2);
      grid.points.point4d[3].z = x3d[2] - (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [0][2] */
      grid.points.point4d[4].x = x3d[0] + L2 +
                                 ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[4].y = x3d[1] - (A1/2) + A2 -
                                 ( ( 1 - tmp_ang_45y ) * (RI + A2) );
      grid.points.point4d[4].z = x3d[2] + (B1/2);
      grid.points.point4d[4].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[5].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[5].y = x3d[1] - (A1/2) + A2 -
                                 ( ( 1 - tmp_ang_45y ) * (RI + A2) );
      grid.points.point4d[5].z = x3d[2] - (B1/2);
      grid.points.point4d[5].w = 1.0;
   }
   else
   {
      /* [0][1] */
      grid.points.point4d[2].x = x3d[0] + L2 +
                                 ( tmp_ang_15x * (3*RA + RI + A2)/4 );
      grid.points.point4d[2].y = x3d[1] + (A1/2);
      grid.points.point4d[2].z = x3d[2] + (B1/2);
      grid.points.point4d[2].w = weight;
      
      /* [1][1] */
      grid.points.point4d[3].x = x3d[0] + L2 +
                                 ( tmp_ang_15x * (3*RA + RI + A2)/4 );
      grid.points.point4d[3].y = x3d[1] + (A1/2);
      grid.points.point4d[3].z = x3d[2] - (B1/2);
      grid.points.point4d[3].w = weight;
      
      /* [0][2] */
      grid.points.point4d[4].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2 );
      grid.points.point4d[4].y = x3d[1] + (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * (RA +RI + A2)/2 );
      grid.points.point4d[4].z = x3d[2] + (B1/2);
      grid.points.point4d[4].w = 1.0;
      
      /* [1][2] */
      grid.points.point4d[5].x = x3d[0] + L2 +
                                 ( tmp_ang_25x * (RA + RI + A2)/2 );
      grid.points.point4d[5].y = x3d[1] + (A1/2) -
                                 ( ( 1 - tmp_ang_25y ) * (RA + RI + A2)/2 );
      grid.points.point4d[5].z = x3d[2] - (B1/2);
      grid.points.point4d[5].w = 1.0;
      
      diff_x = grid.points.point4d[2].x - grid.points.point4d[4].x;
      diff_y = grid.points.point4d[2].y - grid.points.point4d[4].y;
      
      grid.points.point4d[6].x = grid.points.point4d[4].x - diff_x;
      grid.points.point4d[6].y = grid.points.point4d[4].y - diff_y;
      grid.points.point4d[6].z = x3d[2] + (B1/2);
      grid.points.point4d[6].w = weight;
      
      diff_x = grid.points.point4d[3].x - grid.points.point4d[5].x;
      diff_y = grid.points.point4d[3].y - grid.points.point4d[5].y;
      
      grid.points.point4d[7].x = grid.points.point4d[5].x - diff_x;
      grid.points.point4d[7].y = grid.points.point4d[5].y - diff_y;
      grid.points.point4d[7].z = x3d[2] - (B1/2);
      grid.points.point4d[7].w = weight;
      
      /* [0][4] */
      grid.points.point4d[8].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[8].y = x3d[1] - (A1/2) - RI -
                                 tmp_ang_45y * (RI + A2);
      grid.points.point4d[8].z = x3d[2] + (B1/2);
      grid.points.point4d[8].w = 1.0;
      
      /* [1][4] */
      grid.points.point4d[9].x = x3d[0] + L2 + ( tmp_ang_45x * (RI + A2) );
      grid.points.point4d[9].y = x3d[1] - (A1/2) - RI -
                                 tmp_ang_45y * (RI + A2);
      grid.points.point4d[9].z = x3d[2] - (B1/2);
      grid.points.point4d[9].w = 1.0;
   }
   
   GPNBS( (Pint)2, (Pint) 3, uknots.num_floats - 2, vknots.num_floats - 3,
          uknots.floats, vknots.floats, 0, 0, 0, 1, 4, grid.points.point4d,
          uknots.floats[0], uknots.floats[uknots.num_floats - 1],
          vknots.floats[0], vknots.floats[vknots.num_floats - 1] );
   
   /*************/
   /* Back part */
   /*************/
   
   shift.delta_x = 0.;
   shift.delta_y = 0.;
   shift.delta_z = 0.;
   
   pf.x = x3d[0] + L2;
   pf.y = x3d[1] - A1/2 - RI;
   pf.z = x3d[2];
   
   scale.delta_x = 1.;
   scale.delta_y = 1.;
   scale.delta_z = 1.;
   
   pbuild_tran_matrix3( &pf, &shift,
                        0., 0., -ALFA * 3.14159265358979323846 / 180,
                        &scale, &err, matrix );
   
   pset_local_tran3( matrix, PTYPE_PRECONCAT );
   
   /* front */
   p[0].x = x3d[0] + L2;
   p[0].y = x3d[1] - (A1/2);
   p[0].z = x3d[2] + (B1/2);
   
   p[1].x = x3d[0] + L2 + L1;
   p[1].y = x3d[1] - (A1/2);
   p[1].z = x3d[2] + (B1/2);
   
   p[2].x = x3d[0] + L2 + L1;
   p[2].y = x3d[1] - (A1/2) + A2;
   p[2].z = x3d[2] + (B1/2);
   
   p[3].x = x3d[0] + L2;
   p[3].y = x3d[1] - (A1/2) + A2;
   p[3].z = x3d[2] + (B1/2);
   
   pfill_area_set3( &side_list );
   
   /* back */
   p[3].x = x3d[0] + L2;
   p[3].y = x3d[1] - (A1/2);
   p[3].z = x3d[2] - (B1/2);
   
   p[2].x = x3d[0] + L2 + L1;
   p[2].y = x3d[1] - (A1/2);
   p[2].z = x3d[2] - (B1/2);
   
   p[1].x = x3d[0] + L2 + L1;
   p[1].y = x3d[1] - (A1/2) + A2;
   p[1].z = x3d[2] - (B1/2);
   
   p[0].x = x3d[0] + L2;
   p[0].y = x3d[1] - (A1/2) + A2;
   p[0].z = x3d[2] - (B1/2);
   
   pfill_area_set3( &side_list );
   
   /* bottom */
   p[3].x = x3d[0] + L2;
   p[3].y = x3d[1] - (A1/2);
   p[3].z = x3d[2] + (B1/2);
   
   p[2].x = x3d[0] + L2 + L1;
   p[2].y = x3d[1] - (A1/2);
   p[2].z = x3d[2] + (B1/2);
   
   p[1].x = x3d[0] + L2 + L1;
   p[1].y = x3d[1] - (A1/2);
   p[1].z = x3d[2] - (B1/2);
   
   p[0].x = x3d[0] + L2;
   p[0].y = x3d[1] - (A1/2);
   p[0].z = x3d[2] - (B1/2);
   
   pfill_area_set3( &side_list );
   
   /* top */
   p[0].x = x3d[0] + L2;
   p[0].y = x3d[1] - (A1/2) + A2;
   p[0].z = x3d[2] + (B1/2);
   
   p[1].x = x3d[0] + L2 + L1;
   p[1].y = x3d[1] - (A1/2) + A2;
   p[1].z = x3d[2] + (B1/2);
   
   p[2].x = x3d[0] + L2 + L1;
   p[2].y = x3d[1] - (A1/2) + A2;
   p[2].z = x3d[2] - (B1/2);
   
   p[3].x = x3d[0] + L2;
   p[3].y = x3d[1] - (A1/2) + A2;
   p[3].z = x3d[2] - (B1/2);
   
   pfill_area_set3( &side_list );
} /* tube_bow */

/************************************************************************/
/* main                                                                 */
/************************************************************************/
main()

{
   popen_phigs( PDEF_ERR_FILE, PDEF_MEM_SIZE );
   popen_ws( 1, "*", 6 );
   
   vrp.x = 0.;
   vrp.y = 0.;
   vrp.z = 0.;
   
   vpn.delta_x = 0.;
   vpn.delta_y = 0.;
   vpn.delta_z = 1.;
   
   vup.delta_x = 0.;
   vup.delta_y = 1.;
   vup.delta_z = 0.;
   
   peval_view_ori_matrix3( &vrp, &vpn, &vup, &err, vrep.ori_matrix );
   
   view_map.win.x_min = -65.0;
   view_map.win.x_max =  185.0;
   
   view_map.win.y_min = -125.0;
   view_map.win.y_max =  125.0;
   
   view_map.proj_vp.x_min = 0.;
   view_map.proj_vp.x_max = 1.;
   view_map.proj_vp.y_min = 0.;
   view_map.proj_vp.y_max = 1.;
   view_map.proj_vp.z_min = 0.;
   view_map.proj_vp.z_max = 1.;
   
   view_map.proj_type = PTYPE_PERSPECT;
   
   view_map.proj_ref_point.x = 0.;
   view_map.proj_ref_point.y = 0.;
   view_map.proj_ref_point.z = 50000.;
   
   view_map.view_plane  =  0.;
   view_map.back_plane  = -2000.;
   view_map.front_plane =  2000.;
   
   peval_view_map_matrix3( &view_map, &err, vrep.map_matrix );
   
   vrep.clip_limit   = view_map.proj_vp;
   vrep.xy_clip      = PIND_NO_CLIP;
   vrep.back_clip    = PIND_NO_CLIP;
   vrep.front_clip   = PIND_NO_CLIP;
   
   pset_view_rep3( 1, 1, &vrep );
   
   pset_disp_upd_st( 1, PDEFER_WAIT, PMODE_UWOR );
   
   popen_struct( 1 );
   pset_view_ind( 1 );
   
   pset_int_colr_ind( 2 );
   
   pset_edge_colr_ind( 3 );
   
   pset_int_style( PSTYLE_SOLID );
   
   pset_edgetype( PLINE_SOLID );
   
   pset_edge_flag( PEDGE_ON );
   
   x3d[0] = 0.;
   x3d[1] = 0.;
   x3d[2] = 0.;
   A1 = 40.;
   A2 = 40.;
   B1 = 80.;
   L1 = 5.;
   L2 = 5.;
   RI = 10.;
   RA = 50.;
   ALFA = 90.;
   
   tube_bow();
   
   pclose_struct();
   
   ppost_struct( 1, 1, 1.0 );
   pupd_ws( 1, PFLAG_PERFORM );
   
   ret_val = getchar();
   
   pclose_ws( 1 );
   pclose_phigs();
} /* main */
----- cut ----- cut ----- cut ----- cut ----- cut ----- cut -----
-- 
    Matthias Pfuetzner  |  @work:  +49 6151 155-150  | @home: +49 6151 75717
    6100 Darmstadt, FRG | ZGDV, Wilhelminenstrasse 7 | Lichtenbergstrasse 73
      pfuetzner@igd.fhg.de, pfuetzner@zgdvda.UUCP    | Hans-Ulrich Klose sagte:
    Wir pfeifen nicht nach ihrer Tanze... (09.09.92 in der Haushaltsdebatte)