4898794edd81be5285ea6e544acbedeaeb31bf78
max
  Tue Nov 23 08:10:57 2021 -0800
Fixing pointers to README file for license in all source code files. refs #27614

diff --git src/hg/oneShot/transparentTriangleTest/transparentTriangleTest.c src/hg/oneShot/transparentTriangleTest/transparentTriangleTest.c
index d6de647..afa674f 100644
--- src/hg/oneShot/transparentTriangleTest/transparentTriangleTest.c
+++ src/hg/oneShot/transparentTriangleTest/transparentTriangleTest.c
@@ -1,271 +1,271 @@
 /* transparentTriangleTest - Test out a normalized transparency idea using transparent triangles.. */
 
 /* Copyright (C) 2013 The Regents of the University of California 
- * See README in this or parent directory for licensing information. */
+ * See kent/LICENSE or http://genome.ucsc.edu/license/ for licensing information. */
 #include "common.h"
 #include "linefile.h"
 #include "hash.h"
 #include "options.h"
 #include "sqlNum.h"
 #include "memgfx.h"
 #include "rainbow.h"
 #include "hvGfx.h"
 
 int clWidth = 800, clHeight = 100;
 int clLineCount = 10;
 
 struct rgbColor lightRainbowAtPos(double pos);
 /* Given pos, a number between 0 and 1, return a lightish rainbow rgbColor
  * where 0 maps to red,  0.1 is orange, and 0.9 is violet and 1.0 is back to red */
 
 void usage()
 /* Explain usage and exit. */
 {
 errAbort(
   "transparentTriangleTest - Test out a normalized transparency idea using transparent triangles.\n"
   "usage:\n"
   "   transparentTriangleTest triangleCount output maxNorm\n"
   "options:\n"
   "   -width=N - width of image in pixels\n"
   "   -height=N - height of a single row of triangles in pixels\n"
   "   -lineCount=N - number of triangle rows\n"
   );
 }
 
 /* Command line validation table. */
 static struct optionSpec options[] = {
    {"width", OPTION_INT},
    {"height", OPTION_INT},
    {"count", OPTION_INT},
    {NULL, 0},
 };
 
 struct floatPic
 /* A picture that stores RGB values in floating point. */
     {
     float **lines;   /* points to start of each line of image */
     float *image;
     int width;	/* Width in pixels. */
     int height; /* Heigh in pixels. */
     };
 
 struct floatPic *floatPicNew(int width, int height)
 /* Return a new floatPic. */
 {
 long lineSize = 3L * width;
 long imageSize = lineSize * height;
 struct floatPic *pic = needMem(sizeof(struct floatPic));
 pic->width = width;
 pic->height = height;
 pic->image = needHugeMem(imageSize * sizeof(float));
 
 /* Create and initialize line start array */
 AllocArray(pic->lines, height);
 int i = height;
 float *line = pic->image;
 float **lines = pic->lines;
 while (--i >= 0)
     {
     *lines++ = line;
     line += lineSize;
     }
 return pic;
 }
 
 void floatPicSet(struct floatPic *pic, float r, float g, float b)
 /* Set full image to a single color */
 {
 long totalSize = pic->width * pic->height;
 float *p = pic->image;
 while (--totalSize >= 0)
     {
     *p++ = r;
     *p++ = g;
     *p++ = b;
     }
 }
 
 void floatPicSetHorizontal(struct floatPic *pic, int x, int y, int count, float r, float g, float b)
 /* Set count pixels in a horizontal line starting at x,y */
 {
 float *p = pic->lines[y] + x*3;
 while (--count >= 0)
     {
     *p++ = r;
     *p++ = g;
     *p++ = b;
     }
 }
 
 void floatPicMulHorizontal(struct floatPic *pic, int x, int y, int count, float r, float g, float b)
 /* Multiply pixels with existing content in horizongal line starting at x,y. */
 {
 float *p = pic->lines[y] + x*3;
 while (--count >= 0)
     {
     *p++ *= r;
     *p++ *= g;
     *p++ *= b;
     }
 }
 
 double floatPicMinComponent(struct floatPic *pic)
 /* Return minimum r, g, or b componenent in pic. */
 {
 long totalSize = pic->width * pic->height * 3;
 float curMin = 1.0;
 float *p = pic->image;
 while (--totalSize >= 0)
     {
     float comp = *p++;
     if (comp < curMin)
          curMin = comp;
     }
 return curMin;
 }
 
 double floatPicMinValue(struct floatPic *pic)
 /* Return number between 0 and 1 where 0 is darkest, 1 is lightest */
 {
 float rScale = 0.3, gScale = 0.5, bScale = 0.2;
 long totalSize = pic->width * pic->height;
 float curMin = 1.0;
 float *p = pic->image;
 while (--totalSize >= 0)
     {
     float curVal = rScale * p[0] + gScale * p[1] + bScale * p[2];
     p += 3;
     if (curVal < curMin)
          curMin = curVal;
     }
 return curMin;
 }
 
 void floatPicNormalize(struct floatPic *pic, float normFactor)
 /* Adjust darkness while trying to keep same colors. */
 {
 long totalSize = pic->width * pic->height*3;
 float *p = pic->image;
 while (--totalSize >= 0)
     {
     *p = powf(*p, normFactor);
     p += 1;
     }
 }
 
 void floatPicIntoHvg(struct floatPic *pic, int xOff, int yOff, struct hvGfx *hvg)
 /* Copy float pic into hvg at given offset. */
 {
 int width = pic->width, height = pic->height;
 Color *lineBuf;
 AllocArray(lineBuf, width);
 int y;
 for (y=0; y<height; ++y)
     {
     float *fp = pic->lines[y];
     Color *cp = lineBuf;
     int i = width;
     while (--i >= 0)
         {
 	int red = fp[0]*255.9;
 	int green = fp[1]*255.9;
 	int blue = fp[2]*255.9;
 	*cp++ = MAKECOLOR_32(red, green, blue);
 	fp += 3;
 	}
     hvGfxVerticalSmear(hvg, xOff, y + yOff, width, 1, lineBuf, TRUE);
     }
 freez(&lineBuf);
 }
 
 void drawAlignedTriangle(struct floatPic *pic,  struct rgbColor *rgb, int xOff, int yOff, 
     int width, int height)
 /* Draw an isocoles triangle with symmetric peak at top */
 {
 float red = rgb->r / 255.9;
 float green = rgb->g / 255.9;
 float blue = rgb->b / 255.9;
 int y;
 double invHeight = 1.0/height;
 double xCen = xOff + width*0.5;
 for (y=0; y<=height; ++y)
     {
     int curWidth = y*width*invHeight;
     int x1 = xCen - curWidth/2;
     floatPicMulHorizontal(pic, x1, y+yOff, curWidth, red, green, blue);
     }
 }
 
 void drawTriangles(struct floatPic *pic, int count, int xOff, int yOff, int width, int height)
 /* Draw count # of evenly spaced triangles starting at xOff, yOff, and spanning in total 
  * width and height in image. */
 {
 int w = width - 1;
 int h = height - 1;
 int oneWidth = h;
 int dx = (w - oneWidth)/count;
 int x = xOff;
 int i;
 double col = 0, dCol = (1.0/count);
 for (i=0; i<count; ++i)
     {
     struct rgbColor rgb = veryLightRainbowAtPos(col);
     drawAlignedTriangle(pic, &rgb, x, yOff, oneWidth, h);
     col += dCol;
     x += dx;
     }
 }
 
 void transparentTriangleTest(char *countString, char *outFile, char *maxNormString)
 /* transparentTriangleTest - Test out a normalized transparency idea using transparent triangles. */
 {
 double maxNorm = sqlDouble(maxNormString);
 if (maxNorm < 0.0 || maxNorm > 1.0)
     errAbort("maxNorm parameter must be between 0 and 1");
 int triangleCount = sqlUnsigned(countString);
 if (triangleCount < 2)
   errAbort("Triangle count must be at least 2."); 
 struct hvGfx *hvg  = hvGfxOpenPng(clWidth, clHeight*(clLineCount+1), outFile, FALSE);
 struct floatPic *pic = floatPicNew(clWidth, clHeight);
 uglyTime("Allocate picture");
 int i;
 double minNorm = 0.001;
 double dNorm = 0.0;
 if (clLineCount > 1)
     dNorm = (maxNorm - minNorm)/(clLineCount-1);
 for (i=0; i<=clLineCount; ++i)
     {
     double desiredVal = maxNorm - i*dNorm;
     int yOff = i*clHeight;
     floatPicSet(pic, 1.0, 1.0, 1.0);
     uglyTime("set picture to white");
     drawTriangles(pic, triangleCount, 0, 0, clWidth, clHeight);
     uglyTime("Draw triangles");
     double currentVal = floatPicMinComponent(pic);
     uglyTime("Figure minComponent %g", currentVal);
     if (currentVal > 0 && i != clLineCount) /* Don't do it on last line or if impossible. */
 	{
 	double normFactor = log(desiredVal)/log(currentVal);
 	floatPicNormalize(pic, normFactor);
 	uglyTime("Normalize to %g", desiredVal);
 	}
     floatPicIntoHvg(pic, 0, yOff, hvg);
     uglyTime("Convert to hvg");
     }
 hvGfxClose(&hvg);
 uglyTime("Save as PNG");
 }
 
 int main(int argc, char *argv[])
 /* Process command line. */
 {
 optionInit(&argc, argv, options);
 if (argc != 4)
     usage();
 clWidth = optionInt("width", clWidth);
 clHeight = optionInt("height", clHeight);
 clLineCount = optionInt("lineCount", clLineCount);
 uglyTime(NULL);
 transparentTriangleTest(argv[1], argv[2], argv[3]);
 return 0;
 }