Pipe

What

The pipe is inspired by the famous painting of René Magritte [1] : "Ceci n'est pas une pipe".

Geometry

The pipe is described by three cubic Bezier functions, and the drawing is made using Frenet Frames [2] .

The main pipeshape is described with an axis in YZ-plane, and the ovals describing the thickness along the main outline is described with two Beziers, one for X and one for Y.

bezier bezierZ=new bezier(
                    new v3d(1f,4.0f,0f),
                    new v3d(1f,-4.5f,2.5f),
                    new v3d(1f,8.5f,3.5f),
                    new v3d(1f,6.0f,8.0f));
bezier bezierX=new bezier(
                    new v3d(1.5f,0f,0f),
                    new v3d(2.1f,0f,0f),
                    new v3d(0.4f,0f,0f),
                    new v3d(0.3f,0f,0f));
bezier bezierY=new bezier(
                    new v3d(0f,1.5f,0f),
                    new v3d(0f,2.1f,0f),
                    new v3d(0f,0.4f,0f),
                    new v3d(0f,0.1f,0f));

v3d is a simple utility class for handling vectors, crossproduct, matrixmultiplication etc.

The bezierfunctions are handled with a simple class:

package pipe;
/**
 * Handling a Bezier function and its derivative
 * @author bs
 */
public class bezier {
    v3d p0,p1,p2,p3;
    public bezier(v3d P0,v3d P1,v3d P2,v3d P3)
    {
       p0=P0;p1=P1;p2=P2;p3=P3;
    }
    
    /**
     * Calculate a position for a given parameter t [0..1]
     * @param t The parameter t
     * @return A point as a vector
     */
    public v3d B(float t){
        return new v3d(
              p0.x*(-t*t*t   + 3*t*t - 3*t + 1)+
              p1.x*(3*t*t*t  - 6*t*t + 3*t)+
              p2.x*(-3*t*t*t + 3*t*t)+
              p3.x*(t*t*t),
              
              p0.y*(-t*t*t   + 3*t*t - 3*t + 1)+
              p1.y*(3*t*t*t  - 6*t*t + 3*t)+
              p2.y*(-3*t*t*t + 3*t*t)+
              p3.y*(t*t*t),
              
              p0.z*(-t*t*t   + 3*t*t - 3*t + 1)+
              p1.z*(3*t*t*t  - 6*t*t + 3*t)+
              p2.z*(-3*t*t*t + 3*t*t)+
              p3.z*(t*t*t));
    }
    
    /**
     * Calculate a value of the derivative for a given parameter t [0..1]
     * @param t The parameter t
     * @return A vector
     */    
    public v3d dB(float t){
        return new v3d(
              p0.x*(-3*t*t + 6*t  - 3)+
              p1.x*(9*t*t  - 12*t + 3)+
              p2.x*(-9*t*t + 6*t)+
              p3.x*(3*t*t),
              
              p0.y*(-3*t*t + 6*t  - 3)+
              p1.y*(9*t*t  - 12*t + 3)+
              p2.y*(-9*t*t + 6*t)+
              p3.y*(3*t*t),
              
              p0.z*(-3*t*t + 6*t  - 3)+
              p1.z*(9*t*t  - 12*t + 3)+
              p2.z*(-9*t*t + 6*t)+
              p3.z*(3*t*t));
    }
    
}

The points and the normals on the pipebody is calculated as Frenet Frames. The method that generates the pipeshape is:

BUF=FloatBuffer.allocate((RCOUNT+2)*(ZCOUNT+2)*3);
NBUF=FloatBuffer.allocate((RCOUNT+2)*(ZCOUNT+2)*3);
BUF.rewind();
NBUF.rewind();

float bigt=0.0f;
// all bands along the pipebody
for(int zix=0;zix<ZCOUNT;zix++)
{
    // where is it
    v3d C=bezierZ.B(bigt);
    
    // finding the normalized tangent
    // here in yz-plane
    v3d Z=bezierZ.dB(bigt).normalize();
               
    // finding a second vector, use x
    v3d X=new v3d(1.0f,0.0f,0.0f).normalize();
    
    // finding a third vector
    v3d Y=Z.cross(X).normalize();
    
   // setting up the matix that will take us to the
   // Frenet frame located at this t-point
   // M=|X,Y,Z,C|, where C is the Bezier itself
   // note transpose of matrix         
   float M[]={
        X.x,X.y,X.z,0,
        Y.x,Y.y,Y.z,0,
        Z.x,Z.y,Z.z,0,
        C.x,C.y,C.z,1};
                
   // do the ellipse            
    float v=0.0f;
    v3d xp=bezierX.B(bigt);
    v3d yp=bezierY.B(bigt);
    // doing the ellipse
    for(int vix=0;vix <= RCOUNT;vix++)
    {
        float xv=(float)(xp.x*Math.cos(v));
        float yv=(float)(yp.y*Math.sin(v));
        v3d p=new v3d(xv,yv,0).matmult(M);
        //points
        BUF.put(p.x);
        BUF.put(p.y);
        BUF.put(p.z);
        
        // generate normals
        NBUF.put(p.x-C.x);
        NBUF.put(p.y-C.y);
        NBUF.put(p.z-C.z);
        v+=rstep;
    }            
    bigt+=zstep;
}

We use the buffered data to draw the shape

BUF.rewind();
 NBUF.rewind();
 int roundCount=RCOUNT+1;
  
 setBrownMaterial(gl);
 
 gl.glBegin(GL.GL_QUAD_STRIP);
 int offset=0;
 for(int zix=1;zix < BROWNCOUNT; zix++)
 {
     offset=roundCount*zix*3;
     for(int rix=0;rix <roundCount;rix++)
     {
         gl.glNormal3fv(NBUF.array(), offset-roundCount*3+(rix)*3);
         gl.glVertex3fv(BUF.array(), offset-roundCount*3+(rix)*3);
         gl.glNormal3fv(NBUF.array(), offset+rix*3);               
         gl.glVertex3fv(BUF.array(), offset+rix*3);
     }
 }
 gl.glEnd();

 setBrassMaterial(gl);
 
 gl.glBegin(GL.GL_QUAD_STRIP);
 for(int zix=BROWNCOUNT-1;zix < BRASSCOUNT;zix++)
 {
     offset=roundCount*zix*3;
     for(int rix=0;rix <roundCount;rix++)
     {
         gl.glNormal3fv(NBUF.array(), offset-roundCount*3+(rix)*3);
         gl.glVertex3fv(BUF.array(), offset-roundCount*3+(rix)*3);
         gl.glNormal3fv(NBUF.array(), offset+rix*3);               
         gl.glVertex3fv(BUF.array(), offset+rix*3);
     }
 }
 gl.glEnd();       
  
 setBlackMaterial(gl);
 
 gl.glBegin(GL.GL_QUAD_STRIP);
 for(int zix=BRASSCOUNT;zix < ZCOUNT;zix++)
 {
     offset=roundCount*zix*3;
     for(int rix=0;rix <roundCount;rix++)
     {
         gl.glNormal3fv(NBUF.array(), offset-roundCount*3+(rix)*3);
         gl.glVertex3fv(BUF.array(), offset-roundCount*3+(rix)*3);
         gl.glNormal3fv(NBUF.array(), offset+rix*3);               
         gl.glVertex3fv(BUF.array(), offset+rix*3);
     }
 }
 gl.glEnd();

The project: https://svnit.hiof.no/svn/psource/JOGL/pipe

References

Rene MagritteWikipediaen.wikipedia.org/wiki/Ren%C3%A9_Magritte24-05-2011

Calculation of Reference Frames along a Space CurveJules Bloomenthalwebhome.cs.uvic.ca/~blob/courses/305/notes/pdf/ref-frames.pdf24-05-2011