Java 按减少黑暗度的顺序显示相同颜色的n个不同阴影的算法

要求如下：

我们需要将值映射到颜色。因此，每个离散值都有一种颜色

我们允许用户指定一个

maxColor

但NO

minColor

，但允许用户指定表示阴影数量的容器数量。因此，如果选择的

maxColor

为

Color.GREEN

且

bins=5

，则我们希望有5种绿色，其中选择的最大颜色最暗，其余四种颜色将按亮度增加的顺序排列

//Give me a list of 5 shades of Green with the first argument being the darkest.
List<Color> greenShades = calculateShades(Color.GREEN,5);

//Give me a list of 7 shades of RED with the first argument being the darkest.
List<Color> greenShades = calculateShades(Color.RED,7);

//给我一个5种绿色的列表，第一个参数是最暗的。
列表绿色阴影=计算阴影（Color.GREEN，5）；
//给我一个7种红色的列表，第一个参数是最暗的。
列表绿色阴影=计算阴影（颜色：红色，7）；

---

我用Java编写代码时，将问题标记为Java。但我知道这只是一个算法。因此，在其他语言（如JavaScript）中实现此实现的想法也是可以接受的。

基本概念围绕着基于源代码的一小部分生成颜色的想法

也就是说，如果你想要5个波段，每个波段将是最后一个波段强度的1/5

public List<Color> getColorBands(Color color, int bands) {

    List<Color> colorBands = new ArrayList<>(bands);
    for (int index = 0; index < bands; index++) {
        colorBands.add(darken(color, (double) index / (double) bands));
    }
    return colorBands;

}

public static Color darken(Color color, double fraction) {

    int red = (int) Math.round(Math.max(0, color.getRed() - 255 * fraction));
    int green = (int) Math.round(Math.max(0, color.getGreen() - 255 * fraction));
    int blue = (int) Math.round(Math.max(0, color.getBlue() - 255 * fraction));

    int alpha = color.getAlpha();

    return new Color(red, green, blue, alpha);

}

public List getColorBands（颜色、int-bands）{
列表色带=新的阵列列表（色带）；
对于（int index=0；index

作为一个快速而恶劣的例子

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSlider;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class ColorBands {

    public static void main(String[] args) {
        new ColorBands();
    }

    public ColorBands() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private JPanel bandsPane;
        private JSlider slider;
        private Timer changeTimer;

        public TestPane() {
            bandsPane = new JPanel(new GridBagLayout());
            slider = new JSlider(1, 100);
            setLayout(new BorderLayout());
            add(new JScrollPane(bandsPane));
            add(slider, BorderLayout.SOUTH);
            slider.addChangeListener(new ChangeListener() {
                @Override
                public void stateChanged(ChangeEvent e) {
                    changeTimer.restart();
                }
            });

            changeTimer = new Timer(250, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    int bands = slider.getValue();
                    List<Color> bandsList = getColorBands(Color.RED, bands);
                    bandsPane.removeAll();
                    GridBagConstraints gbc = new GridBagConstraints();
                    gbc.gridwidth = GridBagConstraints.REMAINDER;
                    gbc.insets = new Insets(1, 1, 1, 1);
                    for (Color color : bandsList) {
                        bandsPane.add(new ColorBand(color), gbc);
                    }
                    gbc.weighty = 1;
                    bandsPane.add(new JPanel(), gbc);
                    revalidate();
                    repaint();
                }
            });
            changeTimer.setRepeats(false);
            slider.setValue(1);
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }
    }

    public List<Color> getColorBands(Color color, int bands) {

        List<Color> colorBands = new ArrayList<>(bands);
        for (int index = 0; index < bands; index++) {
            colorBands.add(darken(color, (double) index / (double) bands));
        }
        return colorBands;

    }

    public static Color darken(Color color, double fraction) {

        int red = (int) Math.round(Math.max(0, color.getRed() - 255 * fraction));
        int green = (int) Math.round(Math.max(0, color.getGreen() - 255 * fraction));
        int blue = (int) Math.round(Math.max(0, color.getBlue() - 255 * fraction));

        int alpha = color.getAlpha();

        return new Color(red, green, blue, alpha);

    }

    public class ColorBand extends JPanel {

        public ColorBand(Color color) {
            setBackground(color);
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(100, 20);
        }

    }

}

导入java.awt.BorderLayout；
导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.GridBagConstraints；
导入java.awt.GridBagLayout；
导入java.awt.Insets；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.util.ArrayList；
导入java.util.Collections；
导入java.util.List；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.JScrollPane；
导入javax.swing.JSlider；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
导入javax.swing.event.ChangeEvent；
导入javax.swing.event.ChangeListener；
公共级色带{
公共静态void main（字符串[]args）{
新色带（）；
}
公共色带（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
}
JFrame=新JFrame（“测试”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setLayout（新的BorderLayout（））；
frame.add（newtestpane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共类TestPane扩展了JPanel{
私人JPanel bandsPane；
专用滑动滑块；
私人定时器；
公共测试窗格（）{
bandsPane=新的JPanel（新的GridBagLayout（））；
滑块=新的JSlider（1100）；
setLayout（新的BorderLayout（））；
添加（新JScrollPane（bandsPane））；
添加（滑块，BorderLayout.SOUTH）；
slider.addChangeListener（新的ChangeListener（）{
@凌驾
公共无效状态已更改（更改事件e）{
changeTimer.restart（）；
}
});
changeTimer=新计时器（250，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
int bands=slider.getValue（）；
List bandsList=getColorBands（Color.RED，bands）；
bandsPane.removeAll（）；
GridBagConstraints gbc=新的GridBagConstraints（）；
gbc.gridwidth=GridBagConstraints.rements；
gbc.插图=新插图（1,1,1,1）；
用于（颜色：bandsList）{
bandsPane.添加（新色带（颜色），gbc）；
}
gbc.weighty=1；
添加（新的JPanel（），gbc）；
重新验证（）；
重新油漆（）；
}
});
changeTimer.setRepeats（假）；
滑块。设置值（1）；
}
@凌驾
公共维度getPreferredSize（）{
返回新维度（200200）；
}
}
公共列表getColorBands（颜色、int-bands）{
列表色带=新的阵列列表（色带）；
对于（int index=0；indexpublic List<Color> calculateShades(Color baseColor, int numberShades)
{
  //decompose color into RGB
  int redMax  = baseColor.getRed();
  int greenMax  = baseColor.getGreen();
  int blueMax  = baseColor.getBlue();


  //Max color component in RGB
  final int MAX_COMPONENT = 255;

  //bin sizes for each color component
  int redDelta = (MAX_COMPONENT - redMax) / numberShades;
  int greenDelta = (MAX_COMPONENT - greenMax) / numberShades;
  int blueDelta = (MAX_COMPONENT - blueMax) / numberShades;

  List<Color> colors = new ArrayList<Color>();

  int redCurrent = redMax;
  int greenCurrent = greenMax;
  int blueCurrent = blueMax;

  //now step through each shade, and decrease darkness by adding color to it
  for(int i = 0; i < numberShades; i++)
  {

     //step up by the bin size, but stop at the max color component (255)
     redCurrent = (redCurrent+redDelta) < MAX_COMPONENT ? (redCurrent + redDelta ) : MAX_COMPONENT;
     greenCurrent = (greenCurrent+greenDelta) < MAX_COMPONENT ? (greenCurrent + greenDelta ) : MAX_COMPONENT;
     blueCurrent = (blueCurrent+blueDelta) < MAX_COMPONENT ? (blueCurrent + blueDelta ) : MAX_COMPONENT;

     Color nextShade = new Color(redCurrent, greenCurrent, blueCurrent);
     colors.add(nextShade);
  }

  return colors;
}

public Color darker() {
    return new Color(Math.max((int)(getRed()  *FACTOR), 0), 
         Math.max((int)(getGreen()*FACTOR), 0),
         Math.max((int)(getBlue() *FACTOR), 0));
}

Hue = <some value h>
Saturation = <some value s>
Luminosity = (max(R,G,B) + min (R,G,B))/2

L1 = 0
L2 = ((1 * 100) / 4)
L3 = ((2 * 100) / 4)
L4 = ((3 * 100) / 4)
L5 = 100