/* grid.c - Don Yang (uguu.org)
   Point grid generator.

   07/14/01
                                                                           */

#include<assert.h>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"grid.h"
#include"triangle.h"


/**************************************************************** BlobGrid */
int BlobGrid(Vertex **list, Grid *grid, int c, int r)
{
   double dx, dy, cx, cy, rx, ry, d, s;
   double minx, maxx, miny, maxy;
   int i, j;

   if( c < 3 || r < 3 )
      return fprintf(stderr, "Parameter out of range\n");

   cx = ((minx = grid->minx) + (maxx = grid->maxx)) / 2;
   cy = ((miny = grid->miny) + (maxy = grid->maxy)) / 2;
   s = maxx - minx;
   if( (d = maxy - miny) < s )
      s = d;

   for(i = 0; i <= c; i++)
   {
      dx = (maxx - minx) * ((double)i / c) + minx - cx;
      for(j = 0; j <= r; j++)
      {
         dy = (maxy - miny) * ((double)j / r) + miny - cy;
         if( (d = dx * dx + dy * dy) == 0 )
         {
            if( AddVertex(list, NULL, rx = cx + dx, ry = cy + dy) )
               return fprintf(stderr, "Out of memory\n");
         }
         else
         {
            d = s / (sqrt(d) + s * 0.4);
            if( AddVertex(list, NULL, rx = cx + d * dx, ry = cy + d * dy) )
               return fprintf(stderr, "Out of memory\n");
         }
         if( rx < grid->minx )   grid->minx = rx;
         if( rx > grid->maxx )   grid->maxx = rx;
         if( ry < grid->miny )   grid->miny = ry;
         if( ry > grid->maxy )   grid->maxy = ry;
      }
   }

   return 0;

} /* BlobGrid() */

/************************************************************ CircularGrid */
int CircularGrid(Vertex **list, Grid *grid, int r, int t)
{
   double a, cx, cy, cr, r0;
   int i, j;

   if( r < 3 || t < 3 )
      return fprintf(stderr, "Parameter out of range\n");

   cx = (grid->minx + grid->maxx) / 2;
   cy = (grid->miny + grid->maxy) / 2;
   cr = grid->maxx - grid->minx;
   if( (a = grid->maxy - grid->miny) < cr )
      cr = a;
   cr /= 2;
   a = (atan2(0, -1) * 2) / (double)t;
   for(i = 0; i < r; i++)
   {
      r0 = (cr * (double)(i + 1)) / (double)r;
      for(j = 0; j < t; j++)
      {
         if( AddVertex(list, NULL, cx + r0 * cos(j*a), cy + r0 * sin(j*a)) )
            return fprintf(stderr, "Out of memory\n");
      }
   }
   return AddVertex(list, NULL, cx, cy);

} /* CircularGrid() */

/**************************************************************** FileGrid */
int FileGrid(Vertex **list, Grid *grid, char *name)
{
   static char *num = "0123456789.-+eE";
   static char buffer[2][256];
   double x, y;
   FILE *infile;
   int i, c, n;

   if( (infile = fopen(name, "rt")) == NULL )
      return fprintf(stderr, "Can not open %s\n", name);

   while( (c = fgetc(infile)) != EOF )
   {
      for(n = 0; n < 2; n++)
      {
         while( !strchr(num, c) )
         {
            if( (c = fgetc(infile)) == EOF )
               break;
         }
         if( c == EOF )
            break;

         buffer[n][0] = (char)c;
         for(i = 1; (c = fgetc(infile)) != EOF; i++)
         {
            if( i >= 255 )
               break;
            if( !strchr(num, c) )
               break;
            buffer[n][i] = (char)c;
         }
         buffer[n][i] = 0;
      }
      if( n == 2 )
      {
         x = atof(buffer[0]);
         y = atof(buffer[1]);
         if( AddVertex(list, NULL, x, y) )
            return 1;
         if( x < grid->minx )    grid->minx = x;
         if( x > grid->maxx )    grid->maxx = x;
         if( y < grid->miny )    grid->miny = y;
         if( y > grid->maxy )    grid->maxy = y;
      }
      if( c == EOF )
         break;
   }

   fclose(infile);
   return 0;

} /* FileGrid() */

/************************************************************** RandomGrid */
int RandomGrid(Vertex **list, Grid *grid, int count)
{
   int i;

   if( count < 3 )
      return fprintf(stderr, "Parameter out of range\n");

   for(i = 0; i < count; i++)
   {
      if( AddVertex(list, NULL,
          (grid->maxx - grid->minx) * ((rand()&4095) / 4095.) + grid->minx,
          (grid->maxy - grid->miny) * ((rand()&4095) / 4095.) + grid->miny) )
         return fprintf(stderr, "Out of memory\n");
   }
   return 0;

} /* RandomGrid() */

/************************************************************** SpiralGrid */
int SpiralGrid(Vertex **list, Grid *grid, int x, int s)
{
   double cx, cy, cr, r0, a, da;
   int i, j;

   if( x < 3 || s < 3 )
      return fprintf(stderr, "Parameter out of range\n");

   cx = (grid->minx + grid->maxx) / 2;
   cy = (grid->miny + grid->maxy) / 2;
   cr = grid->maxx - grid->minx;
   if( (a = grid->maxy - grid->miny) < cr )
      cr = a;
   cr /= 2;
   da = atan2(0, -1) * 2;
   for(i = 0; i < s; i++)
   {
      r0 = cr * ((double)(i + 1)) / (double)s;
      for(j = 0; j < x; j++)
      {
         a = (i * da) / (double)s + (j * da) / (double)x;
         if( AddVertex(list, NULL, cx + r0 * cos(a), cy + r0 * sin(a)) )
            return fprintf(stderr, "Out of memory\n");
      }
   }

   return AddVertex(list, NULL, cx, cy);

} /* SpiralGrid() */

/************************************************************ TriangleGrid */
int TriangleGrid(Vertex **list, Grid *grid, int c, int r)
{
   double x, y, dy;
   int i, j;

   if( c < 3 || r < 3 )
      return fprintf(stderr, "Parameter out of range\n");

   dy = (grid->maxy - grid->miny) / (double)(r * 2);
   for(i = 0; i <= c; i++)
   {
      x = (grid->maxx - grid->minx) * ((double)i / c) + grid->minx;
      if( i & 1 )
      {
         for(j = 0; j <= r; j++)
         {
            y = (grid->maxy - grid->miny) * ((double)j / r) + grid->miny;
            if( AddVertex(list, NULL, x, y) )      /* (triangle.c) */
               return fprintf(stderr, "Out of memory\n");
         }
      }
      else
      {
         for(j = 0; j < r; j++)
         {
            y = (grid->maxy - grid->miny) * ((double)j / r) + grid->miny + dy;
            if( AddVertex(list, NULL, x, y) )
               return fprintf(stderr, "Out of memory\n");
         }
      }
   }

   return 0;

} /* TriangleGrid() */

/************************************************************* UniformGrid */
int UniformGrid(Vertex **list, Grid *grid, int c, int r)
{
   double x, y;
   int i, j;

   if( c < 3 || r < 3 )
      return fprintf(stderr, "Parameter out of range\n");

   for(i = 0; i <= c; i++)
   {
      x = (grid->maxx - grid->minx) * ((double)i / c) + grid->minx;
      for(j = 0; j <= r; j++)
      {
         y = (grid->maxy - grid->miny) * ((double)j / r) + grid->miny;
         if( AddVertex(list, NULL, x, y) )      /* (triangle.c) */
            return fprintf(stderr, "Out of memory\n");
      }
   }

   return 0;

} /* UniformGrid() */