ogldemo.c

CVI教程,用于信号采集系统的多任务开发软件.学习简单,功能实用.

        void *callbackData, int eventData1, int eventData2)
{
    switch (event) {
        case EVENT_COMMIT:
            RemovePopup (0);
            if (control == CYLINDER_OK)
                return cylinder();                  

            break;
    }
    return 0;
}

int CVICALLBACK torusConfigure  (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event) {
        case EVENT_COMMIT:
            RemovePopup (0);
            if (control == TORUS_OK)
                return torus();                 
            break;
    }
    return 0;
}

int CVICALLBACK coneConfigure (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event) {
        case EVENT_COMMIT:
            RemovePopup (0);
            if (control == CONE_OK)
                return cone();                  

            break;
    }
    return 0;
}

int CVICALLBACK ConfigUniformPlot (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    switch (event) {
        case EVENT_COMMIT:
            RemovePopup (0);
            if (control == UPLOT_OK)
                return uniform();
            break;
    }
    return 0;
}

//----------------------------------------------------------------------------
// SPlot
//----------------------------------------------------------------------------
int CVICALLBACK SPlot (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int waitCursorState = GetWaitCursorState();
    int error = 0;
    OGLVertexD *pts = NULL,*ptsPtr;
    switch (event) {
        case EVENT_COMMIT:
        {
            int plot;
            
            if (!waitCursorState)
                SetWaitCursor(1);
        
            if (molecule != 0)
            {
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LATITUDE, &mollatitude) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LONGITUDE,
                                             &mollongitude) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_DISTANCE,
                                             &moldistance) );
            
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERX,
                                             &molcenter.x) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERY,
                                             &molcenter.y) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERZ,
                                             &molcenter.z) );
                if (molecule != -1)
                {
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LATITUDE, latitude) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LONGITUDE,
                                                 longitude) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_DISTANCE,
                                                 distance) );
            
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERX,
                                                 center.x) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERY,
                                                 center.y) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERZ,
                                                 center.z) );
                }
                molecule = 0;
            }
            errChk( SetCtrlAttribute (demoPanel, DEMOPANEL_PICTURE,
                                      ATTR_CALLBACK_FUNCTION_POINTER, NULL) );
            errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_PLOTTING_ENABLE, 1) );
            errChk( OGLSetCtrlAttribute (demoPanel, demoControl,OGLATTR_ZDIVISIONS, 5));
            errChk( OGLSetCtrlAttribute (demoPanel, demoControl,OGLATTR_PLOTAREA_ZSTART, -0.5));
            errChk( OGLSetCtrlAttribute (demoPanel, demoControl,OGLATTR_PLOTAREA_ZSIZE, 1.0));
            errChk( OGLSetCtrlAttribute(demoPanel,demoControl,OGLATTR_XAXIS_SCALING,OGLVAL_MANUAL) );
            errChk( OGLSetCtrlAttribute(demoPanel,demoControl,OGLATTR_YAXIS_SCALING,OGLVAL_MANUAL) );
            errChk( OGLSetCtrlAttribute(demoPanel,demoControl,OGLATTR_ZAXIS_SCALING,OGLVAL_MANUAL) );
            errChk( GetCtrlVal(demoPanel,DEMOPANEL_SPLOTLIST,&plot) );
            
            switch(plot)
            {
                case LISTSPHERE :
                {
                    register int i,j;
                    double lat,longit;
                    double latStep,longStep;
                
                    errChk( sphere() );
                    nullChk( pts = (OGLVertexD *) malloc((sphereConfig.longitude.steps+1)*(sphereConfig.latitude.steps+1)*sizeof(OGLVertexD)) );
                    ptsPtr = pts;
                
                    latStep = (sphereConfig.latitude.max - sphereConfig.latitude.min)/sphereConfig.latitude.steps;
                    longStep = (sphereConfig.longitude.max - sphereConfig.longitude.min)/sphereConfig.longitude.steps;
                
                    for(i=0,lat = sphereConfig.latitude.min;i<=sphereConfig.latitude.steps;i++,lat+=latStep)
                    {
                        double sint = sin(RAD(lat));
                        double z = sphereConfig.radius*cos(RAD(lat));
                        for(j=0,longit = sphereConfig.longitude.min;j<=sphereConfig.longitude.steps;j++,longit+=longStep,ptsPtr++)
                        {
                            ptsPtr->x = sphereConfig.radius*sint*cos(RAD(longit));      
                            ptsPtr->y = sphereConfig.radius*sint*sin(RAD(longit));      
                            ptsPtr->z = z;
                        }
                    }
                
                    errChk( createSPlot(pts,sphereConfig.longitude.steps+1,sphereConfig.latitude.steps+1) );
                    break;
                }
                
                case LISTCYLINDER :
                {
                    register int i,j;
                    double ht,longit;
                    double htStep,longStep;
                
                    errChk( cylinder() );
                    nullChk( pts = (OGLVertexD *) malloc((cylinderConfig.longitude.steps+1)*(cylinderConfig.height.steps+1)*sizeof(OGLVertexD)) );
                    ptsPtr = pts;
                
                    htStep = cylinderConfig.height.max/cylinderConfig.height.steps;
                    longStep = (cylinderConfig.longitude.max - cylinderConfig.longitude.min)/cylinderConfig.longitude.steps;
                
                    for(i=0,ht = cylinderConfig.height.min;i<=cylinderConfig.height.steps;i++,ht+=htStep)
                    {
                        for(j=0,longit = cylinderConfig.longitude.min;j<=cylinderConfig.longitude.steps;j++,longit+=longStep,ptsPtr++)
                        {
                            ptsPtr->x = cylinderConfig.radius*cos(RAD(longit));     
                            ptsPtr->y = cylinderConfig.radius*sin(RAD(longit));     
                            ptsPtr->z = ht;
                        }
                    }
                
                    errChk( createSPlot(pts,cylinderConfig.longitude.steps+1,cylinderConfig.height.steps+1) );
                    break;
                }   
                
                case LISTTORUS :
                {
                    register int i,j;
                    double lat,longit;
                    double latStep,longStep;
                
                    errChk( torus() );
                    nullChk( pts = (OGLVertexD *) malloc((torusConfig.longitude.steps+1)*(torusConfig.latitude.steps+1)*sizeof(OGLVertexD)) );
                    ptsPtr = pts;
                
                    latStep = (torusConfig.latitude.max - torusConfig.latitude.min)/torusConfig.latitude.steps;
                    longStep = (torusConfig.longitude.max - torusConfig.longitude.min)/torusConfig.longitude.steps;
                
                    for(i=0,lat = torusConfig.latitude.min;i<=torusConfig.latitude.steps;i++,lat+=latStep)
                    {
                        double radius = torusConfig.majorrad + torusConfig.minorrad*cos(RAD(lat));
                        double z = torusConfig.minorrad*sin(RAD(lat));
                        for(j=0,longit = torusConfig.longitude.min;j<=torusConfig.longitude.steps;j++,longit+=longStep,ptsPtr++)
                        {
                            ptsPtr->x = radius*cos(RAD(longit));        
                            ptsPtr->y = radius*sin(RAD(longit));        
                            ptsPtr->z = z;
                        }
                    }
                
                    errChk( createSPlot(pts,torusConfig.longitude.steps+1,torusConfig.latitude.steps+1) );
                    break;
                }
                
                case LISTCONE :
                {
                    register int i,j;
                    double ht,longit;
                    double htStep,longStep;
                    double radStep;
                    double radius;
                
                    errChk( cone() );
                    nullChk( pts = (OGLVertexD *) malloc((coneConfig.longitude.steps+1)*(coneConfig.height.steps+1)*sizeof(OGLVertexD)) );
                    ptsPtr = pts;
                
                    htStep = coneConfig.height.max/coneConfig.height.steps;
                    longStep = (coneConfig.longitude.max - coneConfig.longitude.min)/coneConfig.longitude.steps;
                    radStep = (coneConfig.toprad - coneConfig.bottomrad)/coneConfig.height.steps;
                
                    for(i=0,ht = coneConfig.height.min,radius = coneConfig.bottomrad;i<=coneConfig.height.steps;i++,ht+=htStep,radius+=radStep)
                    {
                        for(j=0,longit = coneConfig.longitude.min;j<=coneConfig.longitude.steps;j++,longit+=longStep,ptsPtr++)
                        {
                            ptsPtr->x = radius*cos(RAD(longit));        
                            ptsPtr->y = radius*sin(RAD(longit));        
                            ptsPtr->z = ht;
                        }
                    }
                
                    errChk( createSPlot(pts,coneConfig.longitude.steps+1,coneConfig.height.steps+1) );
                    break;
                }
            }
            break;
        }
    }
Error :
    if (pts)
        free(pts);
    if (!waitCursorState)
        SetWaitCursor(0);

    return error;
}

//----------------------------------------------------------------------------
// UPlot
//----------------------------------------------------------------------------
int CVICALLBACK UPlot (int panel, int control, int event,
        void *callbackData, int eventData1, int eventData2)
{
    int waitCursorState = GetWaitCursorState();

    int error = 0;
    switch (event) {
        case EVENT_COMMIT:
        {
            int plot;
            register int i,j;
            double x,y;
            double xStep,yStep;
            double *pts,*ptsPtr;

            if (!waitCursorState)
                SetWaitCursor(1);
        
            if (molecule != 0)
            {
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LATITUDE, &mollatitude) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LONGITUDE,
                                             &mollongitude) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_DISTANCE,
                                             &moldistance) );
            
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERX,
                                             &molcenter.x) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERY,
                                             &molcenter.y) );
                errChk( OGLGetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERZ,
                                             &molcenter.z) );
                if (molecule != -1)
                {
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LATITUDE, latitude) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_LONGITUDE,
                                                 longitude) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_DISTANCE,
                                                 distance) );
            
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERX,
                                                 center.x) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERY,
                                                 center.y) );
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_VIEW_CENTERZ,
                                                 center.z) );
                }
                molecule = 0;
            }
            errChk( SetCtrlAttribute (demoPanel, DEMOPANEL_PICTURE,
                                      ATTR_CALLBACK_FUNCTION_POINTER, NULL) );
            errChk( OGLSetCtrlAttribute (demoPanel, demoControl, OGLATTR_PLOTTING_ENABLE, 1) );
            errChk( OGLSetCtrlAttribute(demoPanel,demoControl,OGLATTR_XAXIS_SCALING,OGLVAL_AUTO) );
            errChk( OGLSetCtrlAttribute(demoPanel,demoControl,OGLATTR_YAXIS_SCALING,OGLVAL_AUTO) );
            errChk( OGLSetCtrlAttribute(demoPanel,demoControl,OGLATTR_ZAXIS_SCALING,OGLVAL_AUTO) );
            errChk( GetCtrlVal(demoPanel,DEMOPANEL_UPLOTLIST,&plot) );
            errChk( uniform() );
            
            xStep = (uniformConfig.x.max - uniformConfig.x.min)/uniformConfig.x.steps;
            yStep = (uniformConfig.y.max - uniformConfig.y.min)/uniformConfig.y.steps;
            
            nullChk( pts = (double *) malloc((uniformConfig.x.steps+1)*(uniformConfig.y.steps+1)*sizeof(double)) );
            ptsPtr = pts;
            
            switch(plot)
            {
                case SINHXCOSY :
                {
                    double radxStep = RAD(xStep);
                    double radyStep = RAD(yStep);
                    for(j=0,y=RAD(uniformConfig.y.min);j<=uniformConfig.y.steps;j++,y+=radyStep)
                    {
                        double cosy = cos(y);
                        for(i=0,x=RAD(uniformConfig.x.min);i<=uniformConfig.x.steps;i++,ptsPtr++,x+=radxStep)
                            *ptsPtr = sinh(x)*cosy;
                    }
                    
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl,OGLATTR_ZDIVISIONS, 5));
                    errChk( OGLSetCtrlAttribute (demoPanel, demoControl,OGLATTR_PLOTAREA_ZSTART, -0.5));