igeo

## Class IRand

- java.lang.Object
- - igeo.IRand

- Direct Known Subclasses:
    IRandom

      public class IRand
      extends java.lang.Object

  A class to provide random number function.
  Author:
    Satoru Sugihara

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static long` | `defaultSeed`
    `protected static java.util.Random` | `random`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `IRand()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static IColor` | `clr()`
    `static IColor` | `clr(float alpha)`
    `static IColor` | `clr(float maxRed, float maxGreen, float maxBlue)`
    `static IColor` | `clr(float maxRed, float maxGreen, float maxBlue, float alpha)`
    `static IColor` | `clr(float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue)`
    `static IColor` | `clr(float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float alpha)`
    `static IColor` | `clr(float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float minAlpha, float maxAlpha)`
    `static IColor` | `clr(IColor c, float maxRed, float maxGreen, float maxBlue)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, float maxRed, float maxGreen, float maxBlue, float alpha)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float alpha)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float minAlpha, float maxAlpha)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, int maxRed, int maxGreen, int maxBlue)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, int maxRed, int maxGreen, int maxBlue, int alpha)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int alpha)` add random numbers to each component of color
    `static IColor` | `clr(IColor c, int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int minAlpha, int maxAlpha)` add random numbers to each component of color
    `static IColor` | `clr(int alpha)`
    `static IColor` | `clr(int maxRed, int maxGreen, int maxBlue)`
    `static IColor` | `clr(int maxRed, int maxGreen, int maxBlue, int alpha)`
    `static IColor` | `clr(int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue)`
    `static IColor` | `clr(int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int alpha)`
    `static IColor` | `clr(int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int minAlpha, int maxAlpha)`
    `static IVec` | `dir()` random direction in 3D
    `static IVec` | `dir(double length)`
    `static IVec` | `dir(IVecI perpendicularAxis)`
    `static IVec` | `dir(IVecI perpendicularAxis, double length)`
    `static IVec` | `dir(IVecI axis, double length, double angleRange)`
    `static IVec` | `dir2()` random direction on XY plane
    `static IVec` | `dir2(double length)`
    `static IVec` | `dir2(IVecI axis, double length, double angleRange)`
    `static IVec` | `direction()`
    `static IVec` | `direction(double length)`
    `static IVec` | `direction(IVecI perpendicularAxis)`
    `static IVec` | `direction(IVecI perpendicularAxis, double length)`
    `static IVec` | `direction(IVecI axis, double length, double angleRange)`
    `static IVec` | `direction2()`
    `static IVec` | `direction2(double length)`
    `static IVec` | `direction2(IVecI axis, double length, double angleRange)`
    `static double` | `get()`
    `static double` | `get(double max)`
    `static double` | `get(double min, double max)`
    `static <T> T` | `get(java.util.List<T> array)` get one element out of array
    `static <T> T` | `get(T[] array)` get one element out of array
    `static IColor` | `getColor()`
    `static IColor` | `getColor(float alpha)`
    `static IColor` | `getColor(float maxRed, float maxGreen, float maxBlue, float alpha)`
    `static IColor` | `getColor(float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue)`
    `static IColor` | `getColor(float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float alpha)`
    `static IColor` | `getColor(float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float minAlpha, float maxAlpha)`
    `static IColor` | `getColor(IColor c, float maxRed, float maxGreen, float maxBlue, float alpha)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float alpha)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, float minRed, float maxRed, float minGreen, float maxGreen, float minBlue, float maxBlue, float minAlpha, float maxAlpha)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, int maxRed, int maxGreen, int maxBlue)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, int maxRed, int maxGreen, int maxBlue, int alpha)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int alpha)` add random numbers to each component of color
    `static IColor` | `getColor(IColor c, int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int minAlpha, int maxAlpha)` add random numbers to each component of color
    `static IColor` | `getColor(int alpha)`
    `static IColor` | `getColor(int maxRed, int maxGreen, int maxBlue)`
    `static IColor` | `getColor(int maxRed, int maxGreen, int maxBlue, int alpha)`
    `static IColor` | `getColor(int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue)`
    `static IColor` | `getColor(int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int alpha)`
    `static IColor` | `getColor(int minRed, int maxRed, int minGreen, int maxGreen, int minBlue, int maxBlue, int minAlpha, int maxAlpha)`
    `static IVec` | `getDirection()`
    `static IVec` | `getDirection(double length)`
    `static IVec` | `getDirection(IVecI perpendicularAxis)`
    `static IVec` | `getDirection(IVecI perpendicularAxis, double length)`
    `static IVec` | `getDirection(IVecI axis, double length, double angleRange)`
    `static IVec` | `getDirection2()`
    `static IVec` | `getDirection2(double length)`
    `static IVec` | `getDirection2(IVecI axis, double length, double angleRange)`
    `static double` | `getDouble()`
    `static double` | `getDouble(double max)`
    `static double` | `getDouble(double min, double max)`
    `static float` | `getf()`
    `static float` | `getf(float max)`
    `static float` | `getf(float min, float max)`
    `static float` | `getFloat()`
    `static float` | `getFloat(float max)`
    `static float` | `getFloat(float min, float max)`
    `static IColor` | `getGray()`
    `static IColor` | `getGray(float alpha)`
    `static IColor` | `getGray(float minGray, float maxGray)`
    `static IColor` | `getGray(float minGray, float maxGray, float alpha)`
    `static IColor` | `getGray(float minGray, float maxGray, float minAlpha, float maxAlpha)`
    `static IColor` | `getGray(int alpha)`
    `static IColor` | `getGrayIColor()`
    `static IColor` | `getGrayIColor(float alpha)`
    `static IColor` | `getGrayIColor(float minGray, float maxGray)`
    `static IColor` | `getGrayIColor(float minGray, float maxGray, float alpha)`
    `static IColor` | `getGrayIColor(float minGray, float maxGray, float minAlpha, float maxAlpha)`
    `static IColor` | `getGrayIColor(int alpha)`
    `static int` | `geti()` returns 0 or 1
    `static int` | `geti(int max)`
    `static int` | `geti(int min, int max)`
    `static IColor` | `getIColor(float maxRed, float maxGreen, float maxBlue)`
    `static IColor` | `getIColor(IColor c, float maxRed, float maxGreen, float maxBlue)` add random numbers to each component of color
    `static int` | `getInt()`
    `static int` | `getInt(int max)`
    `static int` | `getInt(int min, int max)`
    `static int` | `getInteger()`
    `static int` | `getInteger(int max)`
    `static int` | `getInteger(int min, int max)`
    `static boolean` | `getPercent(double percent)`
    `static IVec` | `getPoint()`
    `static IVec` | `getPoint(double max)`
    `static IVec` | `getPoint(double min, double max)`
    `static IVec` | `getPoint(double maxx, double maxy, double maxz)`
    `static IVec` | `getPoint(double minx, double miny, double maxx, double maxy)`
    `static IVec` | `getPoint(double minx, double miny, double minz, double maxx, double maxy, double maxz)`
    `static IVec` | `getPoint(IVec max)`
    `static IVec` | `getPoint(IVec min, IVec max)`
    `static IVec` | `getPoint2()`
    `static IVec` | `getPoint2(double max)`
    `static IVec` | `getPoint2(double min, double max)`
    `static IVec` | `getPoint2(double minx, double miny, double maxx, double maxy)`
    `static IColor` | `gray()`
    `static IColor` | `gray(float alpha)`
    `static IColor` | `gray(float minGray, float maxGray)`
    `static IColor` | `gray(float minGray, float maxGray, float alpha)`
    `static IColor` | `gray(float minGray, float maxGray, float minAlpha, float maxAlpha)`
    `static IColor` | `gray(int alpha)`
    `static void` | `init()`
    `static void` | `init(long seed)`
    `static void` | `initByTime()`
    `protected static float` | `limit1(float value)`
    `protected static int` | `limit255(int value)`
    `static boolean` | `pct(double percent)`
    `static boolean` | `percent(double percent)`
    `static IVec` | `point()`
    `static IVec` | `point(double max)`
    `static IVec` | `point(double min, double max)`
    `static IVec` | `point(double maxx, double maxy, double maxz)`
    `static IVec` | `point(double minx, double miny, double maxx, double maxy)`
    `static IVec` | `point(double minx, double miny, double minz, double maxx, double maxy, double maxz)`
    `static IVec` | `point(IVec max)`
    `static IVec` | `point(IVec min, IVec max)`
    `static IVec` | `point2()`
    `static IVec` | `point2(double max)`
    `static IVec` | `point2(double min, double max)`
    `static IVec` | `point2(double minx, double miny, double maxx, double maxy)`
    `static IVec` | `pt()`
    `static IVec` | `pt(double max)`
    `static IVec` | `pt(double min, double max)`
    `static IVec` | `pt(double maxx, double maxy, double maxz)`
    `static IVec` | `pt(double minx, double miny, double maxx, double maxy)`
    `static IVec` | `pt(double minx, double miny, double minz, double maxx, double maxy, double maxz)`
    `static IVec` | `pt(IVec max)`
    `static IVec` | `pt(IVec min, IVec max)`
    `static IVec` | `pt2()`
    `static IVec` | `pt2(double max)`
    `static IVec` | `pt2(double min, double max)`
    `static IVec` | `pt2(double minx, double miny, double maxx, double maxy)` random point on XY plane

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### defaultSeed

          public static final long defaultSeed

      See Also:
        Constant Field Values

    - #### random

          protected static java.util.Random random

  - ### Constructor Detail

    - #### IRand

          public IRand()

  - ### Method Detail

    - #### init

          public static void init()

    - #### init

          public static void init(long seed)

    - #### initByTime

          public static void initByTime()

    - #### get

          public static double get()

    - #### getDouble

          public static double getDouble(double min,
                                         double max)

    - #### getDouble

          public static double getDouble(double max)

    - #### getDouble

          public static double getDouble()

    - #### get

          public static double get(double min,
                                   double max)

    - #### get

          public static double get(double max)

    - #### getf

          public static float getf()

    - #### getf

          public static float getf(float min,
                                   float max)

    - #### getf

          public static float getf(float max)

    - #### getFloat

          public static float getFloat()

    - #### getFloat

          public static float getFloat(float min,
                                       float max)

    - #### getFloat

          public static float getFloat(float max)

    - #### geti

          public static int geti(int min,
                                 int max)

    - #### geti

          public static int geti(int max)

    - #### geti

          public static int geti()

      returns 0 or 1

    - #### getInt

          public static int getInt(int min,
                                   int max)

    - #### getInt

          public static int getInt(int max)

    - #### getInt

          public static int getInt()

    - #### getInteger

          public static int getInteger(int min,
                                       int max)

    - #### getInteger

          public static int getInteger(int max)

    - #### getInteger

          public static int getInteger()

    - #### get

          public static <T> T get(T[] array)

      get one element out of array

    - #### get

          public static <T> T get(java.util.List<T> array)

      get one element out of array

    - #### pt

          public static IVec pt(IVec min,
                                IVec max)

    - #### point

          public static IVec point(IVec min,
                                   IVec max)

    - #### getPoint

          public static IVec getPoint(IVec min,
                                      IVec max)

    - #### pt

          public static IVec pt(IVec max)

    - #### point

          public static IVec point(IVec max)

    - #### getPoint

          public static IVec getPoint(IVec max)

    - #### pt

          public static IVec pt(double minx,
                                double miny,
                                double minz,
                                double maxx,
                                double maxy,
                                double maxz)

    - #### pt

          public static IVec pt(double maxx,
                                double maxy,
                                double maxz)

    - #### pt

          public static IVec pt(double minx,
                                double miny,
                                double maxx,
                                double maxy)

    - #### pt

          public static IVec pt(double min,
                                double max)

    - #### pt

          public static IVec pt(double max)

    - #### pt

          public static IVec pt()

    - #### point

          public static IVec point(double minx,
                                   double miny,
                                   double minz,
                                   double maxx,
                                   double maxy,
                                   double maxz)

    - #### point

          public static IVec point(double minx,
                                   double miny,
                                   double maxx,
                                   double maxy)

    - #### point

          public static IVec point(double maxx,
                                   double maxy,
                                   double maxz)

    - #### point

          public static IVec point(double min,
                                   double max)

    - #### point

          public static IVec point(double max)

    - #### point

          public static IVec point()

    - #### getPoint

          public static IVec getPoint(double minx,
                                      double miny,
                                      double minz,
                                      double maxx,
                                      double maxy,
                                      double maxz)

    - #### getPoint

          public static IVec getPoint(double minx,
                                      double miny,
                                      double maxx,
                                      double maxy)

    - #### getPoint

          public static IVec getPoint(double maxx,
                                      double maxy,
                                      double maxz)

    - #### getPoint

          public static IVec getPoint(double min,
                                      double max)

    - #### getPoint

          public static IVec getPoint(double max)

    - #### getPoint

          public static IVec getPoint()

    - #### pt2

          public static IVec pt2(double minx,
                                 double miny,
                                 double maxx,
                                 double maxy)

      random point on XY plane

    - #### pt2

          public static IVec pt2(double min,
                                 double max)

    - #### pt2

          public static IVec pt2(double max)

    - #### pt2

          public static IVec pt2()

    - #### point2

          public static IVec point2(double minx,
                                    double miny,
                                    double maxx,
                                    double maxy)

    - #### point2

          public static IVec point2(double min,
                                    double max)

    - #### point2

          public static IVec point2(double max)

    - #### point2

          public static IVec point2()

    - #### getPoint2

          public static IVec getPoint2(double minx,
                                       double miny,
                                       double maxx,
                                       double maxy)

    - #### getPoint2

          public static IVec getPoint2(double min,
                                       double max)

    - #### getPoint2

          public static IVec getPoint2(double max)

    - #### getPoint2

          public static IVec getPoint2()

    - #### dir

          public static IVec dir()

      random direction in 3D

    - #### dir

          public static IVec dir(double length)

    - #### dir

          public static IVec dir(IVecI perpendicularAxis)

    - #### dir

          public static IVec dir(IVecI perpendicularAxis,
                                 double length)

    - #### dir

          public static IVec dir(IVecI axis,
                                 double length,
                                 double angleRange)

    - #### direction

          public static IVec direction()

    - #### direction

          public static IVec direction(double length)

    - #### direction

          public static IVec direction(IVecI perpendicularAxis)

    - #### direction

          public static IVec direction(IVecI perpendicularAxis,
                                       double length)

    - #### direction

          public static IVec direction(IVecI axis,
                                       double length,
                                       double angleRange)

    - #### getDirection

          public static IVec getDirection()

    - #### getDirection

          public static IVec getDirection(double length)

    - #### getDirection

          public static IVec getDirection(IVecI perpendicularAxis)

    - #### getDirection

          public static IVec getDirection(IVecI perpendicularAxis,
                                          double length)

    - #### getDirection

          public static IVec getDirection(IVecI axis,
                                          double length,
                                          double angleRange)

    - #### dir2

          public static IVec dir2()

      random direction on XY plane

    - #### dir2

          public static IVec dir2(double length)

    - #### dir2

          public static IVec dir2(IVecI axis,
                                  double length,
                                  double angleRange)

    - #### direction2

          public static IVec direction2()

    - #### direction2

          public static IVec direction2(double length)

    - #### direction2

          public static IVec direction2(IVecI axis,
                                        double length,
                                        double angleRange)

    - #### getDirection2

          public static IVec getDirection2()

    - #### getDirection2

          public static IVec getDirection2(double length)

    - #### getDirection2

          public static IVec getDirection2(IVecI axis,
                                           double length,
                                           double angleRange)

    - #### getPercent

          public static boolean getPercent(double percent)

    - #### percent

          public static boolean percent(double percent)

    - #### pct

          public static boolean pct(double percent)

    - #### getColor

          public static IColor getColor()

    - #### clr

          public static IColor clr()

    - #### limit255

          protected static int limit255(int value)

    - #### limit1

          protected static float limit1(float value)

    - #### getColor

          public static IColor getColor(int alpha)

    - #### clr

          public static IColor clr(int alpha)

    - #### getColor

          public static IColor getColor(int minRed,
                                        int maxRed,
                                        int minGreen,
                                        int maxGreen,
                                        int minBlue,
                                        int maxBlue,
                                        int minAlpha,
                                        int maxAlpha)

    - #### clr

          public static IColor clr(int minRed,
                                   int maxRed,
                                   int minGreen,
                                   int maxGreen,
                                   int minBlue,
                                   int maxBlue,
                                   int minAlpha,
                                   int maxAlpha)

    - #### getColor

          public static IColor getColor(IColor c,
                                        int minRed,
                                        int maxRed,
                                        int minGreen,
                                        int maxGreen,
                                        int minBlue,
                                        int maxBlue,
                                        int minAlpha,
                                        int maxAlpha)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   int minRed,
                                   int maxRed,
                                   int minGreen,
                                   int maxGreen,
                                   int minBlue,
                                   int maxBlue,
                                   int minAlpha,
                                   int maxAlpha)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(int minRed,
                                        int maxRed,
                                        int minGreen,
                                        int maxGreen,
                                        int minBlue,
                                        int maxBlue,
                                        int alpha)

    - #### clr

          public static IColor clr(int minRed,
                                   int maxRed,
                                   int minGreen,
                                   int maxGreen,
                                   int minBlue,
                                   int maxBlue,
                                   int alpha)

    - #### getColor

          public static IColor getColor(IColor c,
                                        int minRed,
                                        int maxRed,
                                        int minGreen,
                                        int maxGreen,
                                        int minBlue,
                                        int maxBlue,
                                        int alpha)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   int minRed,
                                   int maxRed,
                                   int minGreen,
                                   int maxGreen,
                                   int minBlue,
                                   int maxBlue,
                                   int alpha)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(int minRed,
                                        int maxRed,
                                        int minGreen,
                                        int maxGreen,
                                        int minBlue,
                                        int maxBlue)

    - #### clr

          public static IColor clr(int minRed,
                                   int maxRed,
                                   int minGreen,
                                   int maxGreen,
                                   int minBlue,
                                   int maxBlue)

    - #### getColor

          public static IColor getColor(IColor c,
                                        int minRed,
                                        int maxRed,
                                        int minGreen,
                                        int maxGreen,
                                        int minBlue,
                                        int maxBlue)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   int minRed,
                                   int maxRed,
                                   int minGreen,
                                   int maxGreen,
                                   int minBlue,
                                   int maxBlue)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(int maxRed,
                                        int maxGreen,
                                        int maxBlue,
                                        int alpha)

    - #### clr

          public static IColor clr(int maxRed,
                                   int maxGreen,
                                   int maxBlue,
                                   int alpha)

    - #### getColor

          public static IColor getColor(IColor c,
                                        int maxRed,
                                        int maxGreen,
                                        int maxBlue,
                                        int alpha)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   int maxRed,
                                   int maxGreen,
                                   int maxBlue,
                                   int alpha)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(int maxRed,
                                        int maxGreen,
                                        int maxBlue)

    - #### clr

          public static IColor clr(int maxRed,
                                   int maxGreen,
                                   int maxBlue)

    - #### getColor

          public static IColor getColor(IColor c,
                                        int maxRed,
                                        int maxGreen,
                                        int maxBlue)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   int maxRed,
                                   int maxGreen,
                                   int maxBlue)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(float alpha)

    - #### clr

          public static IColor clr(float alpha)

    - #### getColor

          public static IColor getColor(float minRed,
                                        float maxRed,
                                        float minGreen,
                                        float maxGreen,
                                        float minBlue,
                                        float maxBlue,
                                        float minAlpha,
                                        float maxAlpha)

    - #### clr

          public static IColor clr(float minRed,
                                   float maxRed,
                                   float minGreen,
                                   float maxGreen,
                                   float minBlue,
                                   float maxBlue,
                                   float minAlpha,
                                   float maxAlpha)

    - #### getColor

          public static IColor getColor(IColor c,
                                        float minRed,
                                        float maxRed,
                                        float minGreen,
                                        float maxGreen,
                                        float minBlue,
                                        float maxBlue,
                                        float minAlpha,
                                        float maxAlpha)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   float minRed,
                                   float maxRed,
                                   float minGreen,
                                   float maxGreen,
                                   float minBlue,
                                   float maxBlue,
                                   float minAlpha,
                                   float maxAlpha)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(float minRed,
                                        float maxRed,
                                        float minGreen,
                                        float maxGreen,
                                        float minBlue,
                                        float maxBlue,
                                        float alpha)

    - #### clr

          public static IColor clr(float minRed,
                                   float maxRed,
                                   float minGreen,
                                   float maxGreen,
                                   float minBlue,
                                   float maxBlue,
                                   float alpha)

    - #### getColor

          public static IColor getColor(IColor c,
                                        float minRed,
                                        float maxRed,
                                        float minGreen,
                                        float maxGreen,
                                        float minBlue,
                                        float maxBlue,
                                        float alpha)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   float minRed,
                                   float maxRed,
                                   float minGreen,
                                   float maxGreen,
                                   float minBlue,
                                   float maxBlue,
                                   float alpha)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(float minRed,
                                        float maxRed,
                                        float minGreen,
                                        float maxGreen,
                                        float minBlue,
                                        float maxBlue)

    - #### clr

          public static IColor clr(float minRed,
                                   float maxRed,
                                   float minGreen,
                                   float maxGreen,
                                   float minBlue,
                                   float maxBlue)

    - #### getColor

          public static IColor getColor(IColor c,
                                        float minRed,
                                        float maxRed,
                                        float minGreen,
                                        float maxGreen,
                                        float minBlue,
                                        float maxBlue)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   float minRed,
                                   float maxRed,
                                   float minGreen,
                                   float maxGreen,
                                   float minBlue,
                                   float maxBlue)

      add random numbers to each component of color

    - #### getColor

          public static IColor getColor(float maxRed,
                                        float maxGreen,
                                        float maxBlue,
                                        float alpha)

    - #### clr

          public static IColor clr(float maxRed,
                                   float maxGreen,
                                   float maxBlue,
                                   float alpha)

    - #### getColor

          public static IColor getColor(IColor c,
                                        float maxRed,
                                        float maxGreen,
                                        float maxBlue,
                                        float alpha)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   float maxRed,
                                   float maxGreen,
                                   float maxBlue,
                                   float alpha)

      add random numbers to each component of color

    - #### getIColor

          public static IColor getIColor(float maxRed,
                                         float maxGreen,
                                         float maxBlue)

    - #### clr

          public static IColor clr(float maxRed,
                                   float maxGreen,
                                   float maxBlue)

    - #### getIColor

          public static IColor getIColor(IColor c,
                                         float maxRed,
                                         float maxGreen,
                                         float maxBlue)

      add random numbers to each component of color

    - #### clr

          public static IColor clr(IColor c,
                                   float maxRed,
                                   float maxGreen,
                                   float maxBlue)

      add random numbers to each component of color

    - #### getGrayIColor

          public static IColor getGrayIColor()

    - #### getGray

          public static IColor getGray()

    - #### gray

          public static IColor gray()

    - #### getGrayIColor

          public static IColor getGrayIColor(int alpha)

    - #### getGray

          public static IColor getGray(int alpha)

    - #### gray

          public static IColor gray(int alpha)

    - #### getGrayIColor

          public static IColor getGrayIColor(float alpha)

    - #### getGray

          public static IColor getGray(float alpha)

    - #### gray

          public static IColor gray(float alpha)

    - #### getGrayIColor

          public static IColor getGrayIColor(float minGray,
                                             float maxGray,
                                             float minAlpha,
                                             float maxAlpha)

    - #### getGray

          public static IColor getGray(float minGray,
                                       float maxGray,
                                       float minAlpha,
                                       float maxAlpha)

    - #### gray

          public static IColor gray(float minGray,
                                    float maxGray,
                                    float minAlpha,
                                    float maxAlpha)

    - #### getGrayIColor

          public static IColor getGrayIColor(float minGray,
                                             float maxGray,
                                             float alpha)

    - #### getGray

          public static IColor getGray(float minGray,
                                       float maxGray,
                                       float alpha)

    - #### gray

          public static IColor gray(float minGray,
                                    float maxGray,
                                    float alpha)

    - #### getGrayIColor

          public static IColor getGrayIColor(float minGray,
                                             float maxGray)

    - #### getGray

          public static IColor getGray(float minGray,
                                       float maxGray)

    - #### gray

          public static IColor gray(float minGray,
                                    float maxGray)