Actual source code: axisc.c

petsc-3.5.1 2014-08-06
Report Typos and Errors
  1: #include <../src/sys/classes/draw/utils/axisimpl.h>  /*I   "petscdraw.h"  I*/

  3: PetscClassId PETSC_DRAWAXIS_CLASSID = 0;

  7: /*@
  8:    PetscDrawAxisCreate - Generate the axis data structure.

 10:    Collective over PetscDraw

 12:    Input Parameters:
 13: .  win - PetscDraw object where axis to to be made

 15:    Ouput Parameters:
 16: .  axis - the axis datastructure

 18:    Level: advanced

 20: @*/
 21: PetscErrorCode  PetscDrawAxisCreate(PetscDraw draw,PetscDrawAxis *axis)
 22: {
 23:   PetscDrawAxis  ad;
 24:   PetscObject    obj = (PetscObject)draw;
 26:   PetscBool      isnull;

 31:   PetscObjectTypeCompare(obj,PETSC_DRAW_NULL,&isnull);
 32:   if (isnull) {
 33:     PetscDrawOpenNull(PetscObjectComm((PetscObject)obj),(PetscDraw*)axis);

 35:     (*axis)->win = draw;
 36:     return(0);
 37:   }
 38:   PetscHeaderCreate(ad,_p_PetscDrawAxis,int,PETSC_DRAWAXIS_CLASSID,"PetscDrawAxis","Draw Axis","Draw",PetscObjectComm((PetscObject)obj),PetscDrawAxisDestroy,0);
 39:   PetscLogObjectParent((PetscObject)draw,(PetscObject)ad);

 41:   ad->xticks    = PetscADefTicks;
 42:   ad->yticks    = PetscADefTicks;
 43:   ad->xlabelstr = PetscADefLabel;
 44:   ad->ylabelstr = PetscADefLabel;
 45:   ad->win       = draw;
 46:   ad->ac        = PETSC_DRAW_BLACK;
 47:   ad->tc        = PETSC_DRAW_BLACK;
 48:   ad->cc        = PETSC_DRAW_BLACK;
 49:   ad->xlabel    = 0;
 50:   ad->ylabel    = 0;
 51:   ad->toplabel  = 0;

 53:   *axis = ad;
 54:   return(0);
 55: }

 59: /*@
 60:     PetscDrawAxisDestroy - Frees the space used by an axis structure.

 62:     Collective over PetscDrawAxis

 64:     Input Parameters:
 65: .   axis - the axis context

 67:     Level: advanced

 69: @*/
 70: PetscErrorCode  PetscDrawAxisDestroy(PetscDrawAxis *axis)
 71: {

 75:   if (!*axis) return(0);
 76:   if (--((PetscObject)(*axis))->refct > 0) return(0);

 78:   PetscFree((*axis)->toplabel);
 79:   PetscFree((*axis)->xlabel);
 80:   PetscFree((*axis)->ylabel);
 81:   PetscHeaderDestroy(axis);
 82:   return(0);
 83: }

 87: /*@
 88:     PetscDrawAxisSetColors -  Sets the colors to be used for the axis,
 89:                          tickmarks, and text.

 91:     Not Collective (ignored on all processors except processor 0 of PetscDrawAxis)

 93:     Input Parameters:
 94: +   axis - the axis
 95: .   ac - the color of the axis lines
 96: .   tc - the color of the tick marks
 97: -   cc - the color of the text strings

 99:     Level: advanced

101: @*/
102: PetscErrorCode  PetscDrawAxisSetColors(PetscDrawAxis axis,int ac,int tc,int cc)
103: {
105:   if (!axis) return(0);
106:   axis->ac = ac; axis->tc = tc; axis->cc = cc;
107:   return(0);
108: }

112: /*@C
113:     PetscDrawAxisSetLabels -  Sets the x and y axis labels.

115:     Not Collective (ignored on all processors except processor 0 of PetscDrawAxis)

117:     Input Parameters:
118: +   axis - the axis
119: .   top - the label at the top of the image
120: -   xlabel,ylabel - the labes for the x and y axis

122:     Notes: Must be called before PetscDrawAxisDraw() or PetscDrawLGDraw()
123:            There should be no newlines in the arguments

125:     Level: advanced

127: @*/
128: PetscErrorCode  PetscDrawAxisSetLabels(PetscDrawAxis axis,const char top[],const char xlabel[],const char ylabel[])
129: {

133:   if (!axis) return(0);
134:   PetscFree(axis->xlabel);
135:   PetscFree(axis->ylabel);
136:   PetscFree(axis->toplabel);
137:   PetscStrallocpy(xlabel,&axis->xlabel);
138:   PetscStrallocpy(ylabel,&axis->ylabel);
139:   PetscStrallocpy(top,&axis->toplabel);
140:   return(0);
141: }

145: /*@
146:     PetscDrawAxisSetHoldLimits -  Causes an axis to keep the same limits until this is called
147:         again

149:     Not Collective (ignored on all processors except processor 0 of PetscDrawAxis)

151:     Input Parameters:
152: +   axis - the axis
153: -   hold - PETSC_TRUE - hold current limits, PETSC_FALSE allow limits to be changed

155:     Level: advanced

157:     Notes:
158:         Once this has been called with PETSC_TRUE the limits will not change if you call
159:      PetscDrawAxisSetLimits() until you call this with PETSC_FALSE

161: .seealso:  PetscDrawAxisSetLimits()

163: @*/
164: PetscErrorCode  PetscDrawAxisSetHoldLimits(PetscDrawAxis axis,PetscBool hold)
165: {
167:   if (!axis) return(0);
168:   axis->hold = hold;
169:   return(0);
170: }

174: /*@
175:     PetscDrawAxisDraw - PetscDraws an axis.

177:     Not Collective (ignored on all processors except processor 0 of PetscDrawAxis)

179:     Input Parameter:
180: .   axis - Axis structure

182:     Level: advanced

184:     Note:
185:     This draws the actual axis.  The limits etc have already been set.
186:     By picking special routines for the ticks and labels, special
187:     effects may be generated.  These routines are part of the Axis
188:     structure (axis).
189: @*/
190: PetscErrorCode  PetscDrawAxisDraw(PetscDrawAxis axis)
191: {
192:   int            i,ntick,numx,numy,ac = axis->ac,tc = axis->tc,cc = axis->cc,rank;
193:   size_t         len;
194:   PetscReal      tickloc[MAXSEGS],sep,h,w,tw,th,xl,xr,yl,yr;
195:   char           *p;
196:   PetscDraw      draw = axis->win;

200:   if (!axis) return(0);
201:   MPI_Comm_rank(PetscObjectComm((PetscObject)axis),&rank);
202:   if (rank) return(0);

204:   if (axis->xlow == axis->xhigh) {axis->xlow -= .5; axis->xhigh += .5;}
205:   /*  if ((axis->yhigh - axis->ylow) <= 1.e-5*PetscMax(PetscAbsReal(axis->yhigh),PetscAbsReal(axis->ylow))) {
206:     axis->ylow  -= 1.e-5*PetscMax(PetscAbsReal(axis->yhigh),PetscAbsReal(axis->ylow));
207:     axis->yhigh += 1.e-5*PetscMax(PetscAbsReal(axis->yhigh),PetscAbsReal(axis->ylow));
208:    } */
209:   if (axis->ylow == axis->yhigh) {axis->ylow -= .5; axis->yhigh += .5;}

211:   xl   = axis->xlow; xr = axis->xhigh; yl = axis->ylow; yr = axis->yhigh;
212:   PetscDrawSetCoordinates(draw,xl,yl,xr,yr);
213:   PetscDrawStringGetSize(draw,&tw,&th);
214:   numx = (int)(.15*(xr-xl)/tw); if (numx > 6) numx = 6;if (numx< 2) numx = 2;
215:   numy = (int)(.50*(yr-yl)/th); if (numy > 6) numy = 6;if (numy< 2) numy = 2;
216:   xl  -= 11*tw; xr += 2*tw; yl -= 2.5*th; yr += 2*th;
217:   if (axis->xlabel) yl -= 2*th;
218:   if (axis->ylabel) xl -= 2*tw;
219:   PetscDrawSetCoordinates(draw,xl,yl,xr,yr);
220:   PetscDrawStringGetSize(draw,&tw,&th);

222:   PetscDrawLine(draw,axis->xlow,axis->ylow,axis->xhigh,axis->ylow,ac);
223:   PetscDrawLine(draw,axis->xlow,axis->ylow,axis->xlow,axis->yhigh,ac);

225:   if (axis->toplabel) {
226:      PetscStrlen(axis->toplabel,&len);
227:     w    = xl + .5*(xr - xl) - .5*len*tw;
228:     h    = axis->yhigh;
229:     PetscDrawString(draw,w,h,cc,axis->toplabel);
230:   }

232:   /* PetscDraw the ticks and labels */
233:   if (axis->xticks) {
234:     (*axis->xticks)(axis->xlow,axis->xhigh,numx,&ntick,tickloc,MAXSEGS);
235:     /* PetscDraw in tick marks */
236:     for (i=0; i<ntick; i++) {
237:       PetscDrawLine(draw,tickloc[i],axis->ylow-.5*th,tickloc[i],axis->ylow+.5*th,tc);
238:     }
239:     /* label ticks */
240:     for (i=0; i<ntick; i++) {
241:       if (axis->xlabelstr) {
242:         if (i < ntick - 1) sep = tickloc[i+1] - tickloc[i];
243:         else if (i > 0)    sep = tickloc[i]   - tickloc[i-1];
244:         else               sep = 0.0;
245:         (*axis->xlabelstr)(tickloc[i],sep,&p);
246:         PetscStrlen(p,&len);
247:         w    = .5*len*tw;
248:         PetscDrawString(draw,tickloc[i]-w,axis->ylow-1.2*th,cc,p);
249:       }
250:     }
251:   }
252:   if (axis->xlabel) {
253:     PetscStrlen(axis->xlabel,&len);
254:     w    = xl + .5*(xr - xl) - .5*len*tw;
255:     h    = axis->ylow - 2.5*th;
256:     PetscDrawString(draw,w,h,cc,axis->xlabel);
257:   }
258:   if (axis->yticks) {
259:     (*axis->yticks)(axis->ylow,axis->yhigh,numy,&ntick,tickloc,MAXSEGS);
260:     /* PetscDraw in tick marks */
261:     for (i=0; i<ntick; i++) {
262:       PetscDrawLine(draw,axis->xlow -.5*tw,tickloc[i],axis->xlow+.5*tw,tickloc[i],tc);
263:     }
264:     /* label ticks */
265:     for (i=0; i<ntick; i++) {
266:       if (axis->ylabelstr) {
267:         if (i < ntick - 1) sep = tickloc[i+1] - tickloc[i];
268:         else if (i > 0)    sep = tickloc[i]   - tickloc[i-1];
269:         else               sep = 0.0;
270:         (*axis->xlabelstr)(tickloc[i],sep,&p);
271:         PetscStrlen(p,&len);
272:         w    = axis->xlow - len * tw - 1.2*tw;
273:         PetscDrawString(draw,w,tickloc[i]-.5*th,cc,p);
274:       }
275:     }
276:   }
277:   if (axis->ylabel) {
278:     PetscStrlen(axis->ylabel,&len);
279:     h    = yl + .5*(yr - yl) + .5*len*th;
280:     w    = xl + 1.5*tw;
281:     PetscDrawStringVertical(draw,w,h,cc,axis->ylabel);
282:   }
283:   return(0);
284: }

288: /*
289:     Removes all zeros but one from .0000
290: */
291: PetscErrorCode PetscStripe0(char *buf)
292: {
294:   size_t         n;
295:   PetscBool      flg;
296:   char           *str;

299:   PetscStrlen(buf,&n);
300:   PetscStrendswith(buf,"e00",&flg);
301:   if (flg) buf[n-3] = 0;
302:   PetscStrstr(buf,"e0",&str);
303:   if (str) {
304:     buf[n-2] = buf[n-1];
305:     buf[n-1] = 0;
306:   }
307:   PetscStrstr(buf,"e-0",&str);
308:   if (str) {
309:     buf[n-2] = buf[n-1];
310:     buf[n-1] = 0;
311:   }
312:   return(0);
313: }

317: /*
318:     Removes all zeros but one from .0000
319: */
320: PetscErrorCode PetscStripAllZeros(char *buf)
321: {
323:   size_t         i,n;

326:   PetscStrlen(buf,&n);
327:   if (buf[0] != '.') return(0);
328:   for (i=1; i<n; i++) {
329:     if (buf[i] != '0') return(0);
330:   }
331:   buf[0] = '0';
332:   buf[1] = 0;
333:   return(0);
334: }

338: /*
339:     Removes trailing zeros
340: */
341: PetscErrorCode PetscStripTrailingZeros(char *buf)
342: {
344:   char           *found;
345:   size_t         i,n,m = PETSC_MAX_INT;

348:   /* if there is an e in string DO NOT strip trailing zeros */
349:   PetscStrchr(buf,'e',&found);
350:   if (found) return(0);

352:   PetscStrlen(buf,&n);
353:   /* locate decimal point */
354:   for (i=0; i<n; i++) {
355:     if (buf[i] == '.') {m = i; break;}
356:   }
357:   /* if not decimal point then no zeros to remove */
358:   if (m == PETSC_MAX_INT) return(0);
359:   /* start at right end of string removing 0s */
360:   for (i=n-1; i>m; i++) {
361:     if (buf[i] != '0') return(0);
362:     buf[i] = 0;
363:   }
364:   return(0);
365: }

369: /*
370:     Removes leading 0 from 0.22 or -0.22
371: */
372: PetscErrorCode PetscStripInitialZero(char *buf)
373: {
375:   size_t         i,n;

378:   PetscStrlen(buf,&n);
379:   if (buf[0] == '0') {
380:     for (i=0; i<n; i++) buf[i] = buf[i+1];
381:   } else if (buf[0] == '-' && buf[1] == '0') {
382:     for (i=1; i<n; i++) buf[i] = buf[i+1];
383:   }
384:   return(0);
385: }

389: /*
390:      Removes the extraneous zeros in numbers like 1.10000e6
391: */
392: PetscErrorCode PetscStripZeros(char *buf)
393: {
395:   size_t         i,j,n;

398:   PetscStrlen(buf,&n);
399:   if (n<5) return(0);
400:   for (i=1; i<n-1; i++) {
401:     if (buf[i] == 'e' && buf[i-1] == '0') {
402:       for (j=i; j<n+1; j++) buf[j-1] = buf[j];
403:       PetscStripZeros(buf);
404:       return(0);
405:     }
406:   }
407:   return(0);
408: }

412: /*
413:       Removes the plus in something like 1.1e+2 or 1.1e+02
414: */
415: PetscErrorCode PetscStripZerosPlus(char *buf)
416: {
418:   size_t         i,j,n;

421:   PetscStrlen(buf,&n);
422:   if (n<5) return(0);
423:   for (i=1; i<n-2; i++) {
424:     if (buf[i] == '+') {
425:       if (buf[i+1] == '0') {
426:         for (j=i+1; j<n; j++) buf[j-1] = buf[j+1];
427:         return(0);
428:       } else {
429:         for (j=i+1; j<n+1; j++) buf[j-1] = buf[j];
430:         return(0);
431:       }
432:     } else if (buf[i] == '-') {
433:       if (buf[i+1] == '0') {
434:         for (j=i+1; j<n; j++) buf[j] = buf[j+1];
435:         return(0);
436:       }
437:     }
438:   }
439:   return(0);
440: }