frompraat.c

   1 #ifndef PITCHTIER
   2
   3 #include "sgc.h"
   4 #include "frompraat.h"
   5
   6 /* Removed Speckle */
   7 void Sampled_drawInside_cairo (I, cairo_t *cr, double xmin, double xmax, double ymin, double ymax, long ilevel, int unit)
   8 {
   9         iam (Sampled);
  10         long ixmin, ixmax, ix, startOfDefinedStretch = -1;
  11         double *xarray = NULL, *yarray = NULL;
  12         double previousValue = NUMundefined;
  13
  14         Function_unidirectionalAutowindow (me, & xmin, & xmax);
  15         Sampled_getWindowSamples (me, xmin, xmax, & ixmin, & ixmax);
  16         if (ClassFunction_isUnitLogarithmic (my methods, ilevel, unit)) {
  17                 ymin = ClassFunction_convertStandardToSpecialUnit (my methods, ymin, ilevel, unit);
  18                 ymax = ClassFunction_convertStandardToSpecialUnit (my methods, ymax, ilevel, unit);
  19         }
  20         if (ymax <= ymin) return;
  21         xarray = NUMdvector (ixmin - 1, ixmax + 1); cherror
  22         yarray = NUMdvector (ixmin - 1, ixmax + 1); cherror
  23         previousValue = Sampled_getValueAtSample (me, ixmin - 1, ilevel, unit);
  24         if (NUMdefined (previousValue)) {
  25                 startOfDefinedStretch = ixmin - 1;
  26                 xarray [ixmin - 1] = Sampled_indexToX (me, ixmin - 1);
  27                 yarray [ixmin - 1] = previousValue;
  28         }
  29         for (ix = ixmin; ix <= ixmax; ix ++) {
  30                 double x = Sampled_indexToX (me, ix), value = Sampled_getValueAtSample (me, ix, ilevel, unit);
  31                 if (NUMdefined (value)) {
  32                         if (NUMdefined (previousValue)) {
  33                                 xarray [ix] = x;
  34                                 yarray [ix] = value;
  35                         } else {
  36                                 startOfDefinedStretch = ix - 1;
  37                                 xarray [ix - 1] = x - 0.5 * my dx;
  38                                 yarray [ix - 1] = value;
  39                                 xarray [ix] = x;
  40                                 yarray [ix] = value;
  41                         }
  42                 } else if (NUMdefined (previousValue)) {
  43                         Melder_assert (startOfDefinedStretch >= ixmin - 1);
  44                         if (ix > ixmin) {
  45                                 xarray [ix] = x - 0.5 * my dx;
  46                                 yarray [ix] = previousValue;
  47                                 if (xarray [startOfDefinedStretch] < xmin) {
  48                                         double phase = (xmin - xarray [startOfDefinedStretch]) / my dx;
  49                                         xarray [startOfDefinedStretch] = xmin;
  50                                         yarray [startOfDefinedStretch] = phase * yarray [startOfDefinedStretch + 1] + (1.0 - phase) * yarray [startOfDefinedStretch];
  51                                 }
  52                                 Graphics_polyline_cairo (cr, ix + 1 - startOfDefinedStretch, & xarray [startOfDefinedStretch], & yarray [startOfDefinedStretch]);
  53                         }
  54                         startOfDefinedStretch = -1;
  55                 }
  56                 previousValue = value;
  57         }
  58         if (startOfDefinedStretch > -1) {
  59                 double x = Sampled_indexToX (me, ixmax + 1), value = Sampled_getValueAtSample (me, ixmax + 1, ilevel, unit);
  60                 Melder_assert (NUMdefined (previousValue));
  61                 if (NUMdefined (value)) {
  62                         xarray [ixmax + 1] = x;
  63                         yarray [ixmax + 1] = value;
  64                 } else {
  65                         xarray [ixmax + 1] = x - 0.5 * my dx;
  66                         yarray [ixmax + 1] = previousValue;
  67                 }
  68                 if (xarray [startOfDefinedStretch] < xmin) {
  69                         double phase = (xmin - xarray [startOfDefinedStretch]) / my dx;
  70                         xarray [startOfDefinedStretch] = xmin;
  71                         yarray [startOfDefinedStretch] = phase * yarray [startOfDefinedStretch + 1] + (1.0 - phase) * yarray [startOfDefinedStretch];
  72                 }
  73                 if (xarray [ixmax + 1] > xmax) {
  74                         double phase = (xarray [ixmax + 1] - xmax) / my dx;
  75                         xarray [ixmax + 1] = xmax;
  76                         yarray [ixmax + 1] = phase * yarray [ixmax] + (1.0 - phase) * yarray [ixmax + 1];
  77                 }
  78                 Graphics_polyline_cairo (cr, ixmax + 2 - startOfDefinedStretch, & xarray [startOfDefinedStretch], & yarray [startOfDefinedStretch]);
  79         }
  80 end:
  81         NUMdvector_free (xarray, ixmin - 1);
  82         NUMdvector_free (yarray, ixmin - 1);
  83         Melder_clearError ();
  84 }
  85
  86 void Graphics_polyline_cairo (cairo_t *cr, long numberOfPoints, double *xWC, double *yWC) {     /* Base 0. */
  87         short *xyDC;
  88         long i;
  89         if (! numberOfPoints) return;
  90         xyDC = Melder_malloc (short, 2 * numberOfPoints);
  91         if (! xyDC) return;
  92         for (i = 0; i < numberOfPoints; i ++) {
  93                 xyDC [i + i] = xWC [i];
  94                 xyDC [i + i + 1] = yWC [i];
  95         }
  96         polyline_cairo (cr, numberOfPoints, xyDC);
  97         Melder_free (xyDC);
  98 }
  99
 100 void polyline_cairo (cairo_t *cr, long numberOfPoints, short *xyDC) {
 101         long i;
 102 /*      int halfLine = 1;
 103         cairo_move_to (cr, xyDC [0] - halfLine, xyDC [1] - halfLine);
 104         for (i = 1; i < numberOfPoints; i ++) {
 105                 cairo_line_to (cr, xyDC [i + i] - halfLine, xyDC [i + i + 1] - halfLine);
 106         }
 107         cairo_stroke(cr);*/
 108
 109
 110         cairo_new_path (cr);
 111         cairo_move_to (cr, (double) xyDC [0], (double) xyDC [1]);
 112         for (i = 1; i < numberOfPoints; i ++)
 113                cairo_line_to (cr, (double) xyDC [i + i], (double) xyDC [i + i + 1]);
 114         cairo_close_path (cr);
 115         cairo_stroke (cr);
 116 }
 117
 118 #endif