Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.operator.scalar;
 
 
 import java.awt.Color;
 
 import static com.facebook.presto.operator.scalar.StringFunctions.upper;
 import static com.facebook.presto.spi.StandardErrorCode.INTERNAL_ERROR;
 import static com.facebook.presto.spi.StandardErrorCode.INVALID_FUNCTION_ARGUMENT;
 import static com.facebook.presto.util.Failures.checkCondition;
 import static java.lang.String.format;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 public final class ColorFunctions
 {
     private static final String ANSI_RESET = "\u001b[0m";
 
     private static final Slice RENDERED_TRUE = render(Slices.copiedBuffer("\u2713"), color(Slices.copiedBuffer("green")));
     private static final Slice RENDERED_FALSE = render(Slices.copiedBuffer("\u2717"), color(Slices.copiedBuffer("red")));
 
     public enum SystemColor
     {
         BLACK(0, "black"),
         RED(1, "red"),
         GREEN(2, "green"),
         YELLOW(3, "yellow"),
         BLUE(4, "blue"),
         MAGENTA(5, "magenta"),
         CYAN(6, "cyan"),
         WHITE(7, "white");
 
         private final int index;
         private final String name;
 
         SystemColor(int indexString name)
         {
             this. = index;
             this. = name;
         }
 
         private int getIndex()
         {
             return ;
         }
 
         public String getName()
         {
             return ;
         }
 
         public static SystemColor valueOf(int index)
         {
             for (SystemColor color : values()) {
                 if (index == color.getIndex()) {
                     return color;
                 }
             }
             throw new PrestoException("Invalid color index: " + index);
         }
     }
 
     private ColorFunctions() {}
 
     @ScalarFunction
     public static long color(@SqlType(.Slice color)
     {
         int rgb = parseRgb(color);
 
         if (rgb != -1) {
             return rgb;
         }
 
         // encode system colors (0-15) as negative values, offset by one
         try {
             SystemColor systemColor = SystemColor.valueOf(upper(color).toString());
             int index = systemColor.getIndex();
             return -(index + 1);
         }
         catch (IllegalArgumentException e) {
            throw new PrestoException(format("Invalid color: '%s'"color.toString()), e);
        }
    }
    public static long rgb(@SqlType(.long red, @SqlType(.long green, @SqlType(.long blue)
    {
        checkCondition(red >= 0 && red <= 255, "red must be between 0 and 255");
        checkCondition(green >= 0 && green <= 255, "green must be between 0 and 255");
        checkCondition(blue >= 0 && blue <= 255, "blue must be between 0 and 255");
        return (red << 16) | (green << 8) | blue;
    }

    
Interpolate a color between lowColor and highColor based the provided value

The value is truncated to the range [low, high] if it's outside. Color must be a valid rgb value of the form #rgb

    public static long color(
            @SqlType(.double value,
            @SqlType(.double low,
            @SqlType(.double high,
            @SqlType(.long lowColor,
            @SqlType(.long highColor)
    {
        return color((value - low) * 1.0 / (high - low), lowColorhighColor);
    }

    
Interpolate a color between lowColor and highColor based on the provided value

The value is truncated to the range [0, 1] if necessary Color must be a valid rgb value of the form #rgb

    public static long color(@SqlType(.double fraction, @SqlType(.long lowColor, @SqlType(.long highColor)
    {
        checkCondition(lowColor >= 0, "lowColor not a valid RGB color");
        checkCondition(highColor >= 0, "highColor not a valid RGB color");
        fraction = Math.min(1, fraction);
        fraction = Math.max(0, fraction);
        return interpolate((floatfractionlowColorhighColor);
    }
    public static Slice render(@SqlType(.Slice value, @SqlType(.long color)
    {
        StringBuilder builder = new StringBuilder(value.length());
        // color
        builder.append(ansiColorEscape(color))
                .append(value.toString())
                .append();
        return Slices.copiedBuffer(builder.toString(), );
    }
    public static Slice render(@SqlType(.long value, @SqlType(.long color)
    {
        return render(Slices.copiedBuffer(Long.toString(value), ), color);
    }
    public static Slice render(@SqlType(.double value, @SqlType(.long color)
    {
        return render(Slices.copiedBuffer(Double.toString(value), ), color);
    }
    public static Slice render(@SqlType(.boolean value)
    {
        return value ?  : ;
    }
    public static Slice bar(@SqlType(.double percent, @SqlType(.long width)
    {
        return bar(percentwidthrgb(255, 0, 0), rgb(0, 255, 0));
    }
    public static Slice bar(
            @SqlType(.double percent,
            @SqlType(.long width,
            @SqlType(.long lowColor,
            @SqlType(.long highColor)
    {
        long count = (int) (percent * width);
        count = Math.min(widthcount);
        count = Math.max(0, count);
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < counti++) {
            float fraction = (float) (i * 1.0 / (width - 1));
            int color = interpolate(fractionlowColorhighColor);
            builder.append(ansiColorEscape(color))
                    .append('\u2588');
        }
        // reset
        builder.append();
        // pad to force column to be the requested width
        for (long i = counti < width; ++i) {
            builder.append(' ');
        }
        return Slices.copiedBuffer(builder.toString(), );
    }
    private static int interpolate(float fractionlong lowRgblong highRgb)
    {
        float[] lowHsv = Color.RGBtoHSB(getRed(lowRgb), getGreen(lowRgb), getBlue(lowRgb), null);
        float[] highHsv = Color.RGBtoHSB(getRed(highRgb), getGreen(highRgb), getBlue(highRgb), null);
        float h = fraction * (highHsv[0] - lowHsv[0]) + lowHsv[0];
        float s = fraction * (highHsv[1] - lowHsv[1]) + lowHsv[1];
        float v = fraction * (highHsv[2] - lowHsv[2]) + lowHsv[2];
        return Color.HSBtoRGB(hsv) & 0xFF_FF_FF;
    }

    
Convert the given color (rgb or system) to an ansi-compatible index (for use with ESC[38;5;<value>m)
    private static int toAnsi(int redint greenint blue)
    {
        // rescale to 0-5 range
        red = red * 6 / 256;
        green = green * 6 / 256;
        blue = blue * 6 / 256;
        return 16 + red * 36 + green * 6 + blue;
    }
    private static String ansiColorEscape(long color)
    {
        return "\u001b[38;5;" + toAnsi(color) + 'm';
    }

    
Convert the given color (rgb or system) to an ansi-compatible index (for use with ESC[38;5;<value>m)
    private static int toAnsi(long color)
    {
        if (color >= 0) { // an rgb value encoded as in Color.getRGB
            return toAnsi(getRed(color), getGreen(color), getBlue(color));
        }
        else {
            return (int) (-color - 1);
        }
    }
    static int parseRgb(Slice color)
    {
        if (color.length() != 4 || color.getByte(0) != '#') {
            return -1;
        }
        int red = Character.digit((charcolor.getByte(1), 16);
        int green = Character.digit((charcolor.getByte(2), 16);
        int blue = Character.digit((charcolor.getByte(3), 16);
        if (red == -1 || green == -1 || blue == -1) {
            return -1;
        }
        // replicate the nibbles to turn a color of the form #rgb => #rrggbb (css semantics)
        red = (red << 4) | red;
        green = (green << 4) | green;
        blue = (blue << 4) | blue;
        return (intrgb(redgreenblue);
    }
    static int getRed(long color)
    {
        checkCondition(color >= 0, "color is not a valid rgb value");
        return (int) ((color >>> 16) & 0xff);
    }
    static int getGreen(long color)
    {
        checkCondition(color >= 0, "color is not a valid rgb value");
        return (int) ((color >>> 8) & 0xff);
    }
    static int getBlue(long color)
    {
        checkCondition(color >= 0, "color is not a valid rgb value");
        return (int) (color & 0xff);
    }
New to GrepCode? Check out our FAQ X