/*
* $Id: mp03c.c,v 1.8 1995/06/22 21:08:21 haley Exp $
*/
/***********************************************************************
* *
* Copyright (C) 1993 *
* University Corporation for Atmospheric Research *
* All Rights Reserved *
* *
***********************************************************************/
/*
* File: mp03c.c
*
* Author: David Brown
* National Center for Atmospheric Research
* PO 3000, Boulder, Colorado
*
* Date: Fri Oct 14 11:42:41 MDT 1994
*
* Description: Demonstrates MapPlot masking; loosely emulates the
* LLU example 'colcon'
*/
#include <stdio.h>
#include <math.h>
#include <ncarg/gks.h>
#include <ncarg/ncargC.h>
#include <ncarg/hlu/hlu.h>
#include <ncarg/hlu/App.h>
#include <ncarg/hlu/NcgmWorkstation.h>
#include <ncarg/hlu/PSWorkstation.h>
#include <ncarg/hlu/XWorkstation.h>
#include <ncarg/hlu/MapPlot.h>
#include <ncarg/hlu/ContourPlot.h>
#include <ncarg/hlu/ScalarField.h>
main(int argc, char *argv[])
{
int appid,wid,mapid,dataid,cnid;
int rlist,grlist;
float Z[50*50];
int M = 50, N = 50;
int mlow = 13, mhigh = 18;
float dlow = 13.0, dhigh = 18.0;
int len_dims[2];
int NCGM=0, X11=1, PS=0;
extern void gendat();
NhlString mask_specs[] = { "oceans" };
/*
* Initialize the high level utility library
*/
NhlInitialize();
/*
* Create an application context. Set the app dir to the current
* directory so the application looks for a resource file in the working
* directory.
*/
rlist = NhlRLCreate(NhlSETRL);
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNappUsrDir,"./");
NhlCreate(&appid,"mp03",NhlappClass,NhlDEFAULT_APP,rlist);
if (NCGM) {
/*
* Create a meta file workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkMetaName,"./mp03c.ncgm");
NhlCreate(&wid,"mp03Work",
NhlncgmWorkstationClass,NhlDEFAULT_APP,rlist);
}
else if (X11) {
/*
* Create an X workstation.
*/
NhlRLClear(rlist);
NhlRLSetInteger(rlist,NhlNwkPause,True);
NhlCreate(&wid,"mp03Work",NhlxWorkstationClass,appid,rlist);
}
else if (PS) {
/*
* Create a PS workstation.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNwkPSFileName,"mp03c.ps");
NhlCreate(&wid,"mp03Work",NhlpsWorkstationClass,appid,rlist);
}
/*
* Call the routine 'gendat' to create the first array of contour
* data. Create a ScalarField data object and hand it the data created by
* 'gendat'. Define the extent of the data coordinates as the whole
* globe
*/
NhlRLClear(rlist);
len_dims[0] = N;
len_dims[1] = M;
gendat(Z,M,M,N,mlow,mhigh,dlow,dhigh);
NhlRLSetMDFloatArray(rlist,NhlNsfDataArray,Z,2,len_dims);
NhlRLSetInteger(rlist,NhlNsfXCStartV,-180);
NhlRLSetInteger(rlist,NhlNsfXCEndV,180);
NhlRLSetInteger(rlist,NhlNsfYCStartV,-90);
NhlRLSetInteger(rlist,NhlNsfYCEndV,90);
NhlCreate(&dataid,"Gendat",NhlscalarFieldClass,appid,rlist);
/*
* Create a Contour object, supplying the ScalarField object as data,
* and setting the size of the viewport.
*/
NhlRLClear(rlist);
NhlRLSetInteger(rlist,NhlNcnScalarFieldData,dataid);
NhlRLSetString(rlist,NhlNcnLabelDrawOrder,"postdraw");
NhlCreate(&cnid,"Contour1",NhlcontourPlotClass,wid,rlist);
/*
* Create a MapPlot object, setting the fill to draw over the main draw,
* and masking out the oceans.
*/
NhlRLClear(rlist);
NhlRLSetString(rlist,NhlNmpFillOn,"true");
NhlRLSetString(rlist,NhlNpmTitleDisplayMode,"always");
NhlRLSetString(rlist,NhlNtiMainString,"mp03c");
NhlRLSetString(rlist,NhlNmpFillDrawOrder,"postdraw");
NhlRLSetString(rlist,NhlNmpAreaMaskingOn,"true");
NhlRLSetStringArray(rlist,NhlNmpMaskAreaSpecifiers,
mask_specs,NhlNumber(mask_specs));
NhlCreate(&mapid,"Map1",NhlmapPlotClass,wid,rlist);
/*
* Overlay the Contour object on the MapPlot object
*/
NhlAddOverlay(mapid,cnid,-1);
NhlDraw(mapid);
NhlFrame(wid);
/*
* Destroy the objects created, close the HLU library and exit.
*/
NhlDestroy(mapid);
NhlDestroy(wid);
NhlClose();
exit(0);
}
#define max(x,y) ((x) > (y) ? (x) : (y) )
#define min(x,y) ((x) < (y) ? (x) : (y) )
#define pow2(x) ((x)*(x))
void gendat (data,idim,m,n,mlow,mhgh,dlow,dhgh)
float *data, dlow, dhgh;
int idim, m, n, mlow, mhgh;
{
/*
* This is a routine to generate test data for two-dimensional graphics
* routines. Given an array "DATA", dimensioned "IDIM x 1", it fills
* the sub-array ((DATA(I,J),I=1,M),J=1,N) with a two-dimensional field
* of data having approximately "MLOW" lows and "MHGH" highs, a minimum
* value of exactly "DLOW" and a maximum value of exactly "DHGH".
*
* "MLOW" and "MHGH" are each forced to be greater than or equal to 1
* and less than or equal to 25.
*
* The function used is a sum of exponentials.
*/
float ccnt[3][50], fovm, fovn, dmin, dmax, temp;
extern float fran();
int nlow, nhgh, ncnt, i, j, k, ii;
fovm=9./(float)m;
fovn=9./(float)n;
nlow=max(1,min(25,mlow));
nhgh=max(1,min(25,mhgh));
ncnt=nlow+nhgh;
for( k=1; k <= ncnt; k++ ) {
ccnt[0][k-1]=1.+((float)m-1.)*fran();
ccnt[1][k-1]=1.+((float)n-1.)*fran();
if (k <= nlow) {
ccnt[2][k-1]= -1.;
}
else {
ccnt[2][k-1] = 1.;
}
}
dmin = 1.e36;
dmax = -1.e36;
ii = 0;
for( j = 1; j <= n; j++ ) {
for( i = 1; i <= m; i++ ) {
data[ii]=.5*(dlow+dhgh);
for( k = 1; k <= ncnt; k++ ) {
temp = -(pow2((fovm*((float)(i)-ccnt[0][k-1])))+
pow2(fovn*((float)(j)-ccnt[1][k-1])));
if (temp >= -20.) data[ii]=data[ii]+.5*(dhgh-dlow)
*ccnt[2][k-1]*exp(temp);
}
dmin=min(dmin,data[ii]);
dmax=max(dmax,data[ii]);
ii++;
}
}
for( j = 0; j < m*n; j++ ) {
data[j]=(data[j]-dmin)/(dmax-dmin)*(dhgh-dlow)+dlow;
}
}
float rseq[] = { .749, .973, .666, .804, .081, .483, .919, .903, .951, .960,
.039, .269, .270, .756, .222, .478, .621, .063, .550, .798, .027, .569,
.149, .697, .451, .738, .508, .041, .266, .249, .019, .191, .266, .625,
.492, .940, .508, .406, .972, .311, .757, .378, .299, .536, .619, .844,
.342, .295, .447, .499, .688, .193, .225, .520, .954, .749, .997, .693,
.217, .273, .961, .948, .902, .104, .495, .257, .524, .100, .492, .347,
.981, .019, .225, .806, .678, .710, .235, .600, .994, .758, .682, .373,
.009, .469, .203, .730, .588, .603, .213, .495, .884, .032, .185, .127,
.010, .180, .689, .354, .372, .429 };
float fran()
{
static int iseq = 0;
iseq = (iseq % 100) + 1;
return(rseq[iseq-1]);
}