Android笔记——Bitmap自动取色（纯搬运）

2015/6/12更新：发现一个更好的，带demo

https://github.com/MichaelEvans/ColorArt

说明：
这个是一个老外写的自动自动从bitmap中取主色与第二主色的工具类，稍微研究了下用法，但感觉效果一般，记录下。
感兴趣的同学可以自行研究下，老外的代码没注释，这点给黄老师我造成的困惑不少。
顺便附上老外的github地址：https://gist.github.com/chrisbanes/ba8e7b9ec0e40f6949c6

大概的用法：

image = (ImageView)findViewById(R.id.image);
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.test);
DominantColorCalculator colorCalculator = new DominantColorCalculator(bitmap);
ColorScheme scheme = colorCalculator.getColorScheme();
View main = findViewById(R.id.main);
View second = findViewById(R.id.second);
main.setBackgroundColor(scheme.primaryText);
second.setBackgroundColor(scheme.secondaryText);

老外的核心代码，及简单解释：
1、ColorScheme类，作用貌似是记录颜色，其中xxxtext都是Color对象

/*
 * Copyright 2014 Chris Banes
 *
 * 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.
 */

public class ColorScheme {

    public final int primaryAccent;
    public final int secondaryAccent;
    public final int tertiaryAccent;

    public final int primaryText;
    public final int secondaryText;

    public ColorScheme(int primaryAccent, int secondaryAccent, int tertiaryAccent,
            int primaryText, int secondaryText) {
        this.primaryAccent = primaryAccent;
        this.secondaryAccent = secondaryAccent;
        this.tertiaryAccent = tertiaryAccent;
        this.primaryText = primaryText;
        this.secondaryText = secondaryText;
    }
}

2、ColorUtils类，有一些颜色操作的工具方法，比如颜色混合、亮暗调整、YIQ转换等等

/*
 * Copyright 2014 Chris Banes
 *
 * 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.
 */

import android.graphics.Color;

public class ColorUtils {

    public static int darken(final int color, float fraction) {
        return blendColors(Color.BLACK, color, fraction);
    }

    public static int lighten(final int color, float fraction) {
        return blendColors(Color.WHITE, color, fraction);
    }

    /**
     * @return luma value according to to YIQ color space.
     */
    public static final int calculateYiqLuma(int color) {
        return Math.round((299 * Color.red(color) + 587 * Color.green(color) + 114 * Color.blue(color)) / 1000f);
    }

    /**
     * Blend {@code color1} and {@code color2} using the given ratio.
     *
     * @param ratio of which to blend. 1.0 will return {@code color1}, 0.5 will give an even blend,
     *              0.0 will return {@code color2}.
     */
    public static int blendColors(int color1, int color2, float ratio) {
        final float inverseRatio = 1f - ratio;
        float r = (Color.red(color1) * ratio) + (Color.red(color2) * inverseRatio);
        float g = (Color.green(color1) * ratio) + (Color.green(color2) * inverseRatio);
        float b = (Color.blue(color1) * ratio) + (Color.blue(color2) * inverseRatio);
        return Color.rgb((int) r, (int) g, (int) b);
    }

    public static final int changeBrightness(final int color, float fraction) {
        return calculateYiqLuma(color) >= 128
                ? darken(color, fraction)
                : lighten(color, fraction);
    }

    public static final int calculateContrast(MedianCutQuantizer.ColorNode color1,
            MedianCutQuantizer.ColorNode color2) {
        return Math.abs(ColorUtils.calculateYiqLuma(color1.getRgb())
                - ColorUtils.calculateYiqLuma(color2.getRgb()));
    }

    public static final float calculateColorfulness(MedianCutQuantizer.ColorNode node) {
        float[] hsv = node.getHsv();
        return hsv[1] * hsv[2];
    }

}

3、和Android的Bitmap对象的接口类，构造方法中传入bitmap对象即开始转换，然后通过getColorScheme获得抓取到的颜色

/*
 * Copyright 2014 Chris Banes
 *
 * 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.
 */

import android.graphics.Bitmap;
import android.graphics.Color;

import java.util.Arrays;
import java.util.Comparator;

import org.apache.chrisbanes.colorscheme.MedianCutQuantizer.ColorNode;

public class DominantColorCalculator {

    private static final int NUM_COLORS = 10;

    private static final int PRIMARY_TEXT_MIN_CONTRAST = 135;

    private static final int SECONDARY_MIN_DIFF_HUE_PRIMARY = 120;

    private static final int TERTIARY_MIN_CONTRAST_PRIMARY = 20;
    private static final int TERTIARY_MIN_CONTRAST_SECONDARY = 90;

    private final MedianCutQuantizer.ColorNode[] mPalette;
    private final MedianCutQuantizer.ColorNode[] mWeightedPalette;
    private ColorScheme mColorScheme;

    public DominantColorCalculator(Bitmap bitmap) {
        final int width = bitmap.getWidth();
        final int height = bitmap.getHeight();

        final int[] rgbPixels = new int[width * height];
        bitmap.getPixels(rgbPixels, 0, width, 0, 0, width, height);

        final MedianCutQuantizer mcq = new MedianCutQuantizer(rgbPixels, NUM_COLORS);

        mPalette = mcq.getQuantizedColors();
        mWeightedPalette = weight(mPalette);

        findColors();
    }

    public ColorScheme getColorScheme() {
        return mColorScheme;
    }

    private void findColors() {
        final ColorNode primaryAccentColor = findPrimaryAccentColor();
        final ColorNode secondaryAccentColor = findSecondaryAccentColor(primaryAccentColor);

        final int tertiaryAccentColor = findTertiaryAccentColor(
                primaryAccentColor, secondaryAccentColor);

        final int primaryTextColor = findPrimaryTextColor(primaryAccentColor);
        final int secondaryTextColor = findSecondaryTextColor(primaryAccentColor);

        mColorScheme = new ColorScheme(
                primaryAccentColor.getRgb(),
                secondaryAccentColor.getRgb(),
                tertiaryAccentColor,
                primaryTextColor,
                secondaryTextColor);
    }

    /**
     * @return the first color from our weighted palette.
     */
    private ColorNode findPrimaryAccentColor() {
        return mWeightedPalette[0];
    }

    /**
     * @return the next color in the weighted palette which ideally has enough difference in hue.
     */
    private ColorNode findSecondaryAccentColor(final ColorNode primary) {
        final float primaryHue = primary.getHsv()[0];

        // Find the first color which has sufficient difference in hue from the primary
        for (ColorNode candidate : mWeightedPalette) {
            final float candidateHue = candidate.getHsv()[0];

            // Calculate the difference in hue, if it's over the threshold return it
            if (Math.abs(primaryHue - candidateHue) >= SECONDARY_MIN_DIFF_HUE_PRIMARY) {
                return candidate;
            }
        }

        // If we get here, just return the second weighted color
        return mWeightedPalette[1];
    }

    /**
     * @return the first color from our weighted palette which has sufficient contrast from the
     *         primary and secondary colors.
     */
    private int findTertiaryAccentColor(final ColorNode primary, final ColorNode secondary) {
        // Find the first color which has sufficient contrast from both the primary & secondary
        for (ColorNode color : mWeightedPalette) {
            if (ColorUtils.calculateContrast(color, primary) >= TERTIARY_MIN_CONTRAST_PRIMARY
                    && ColorUtils.calculateContrast(color, secondary) >= TERTIARY_MIN_CONTRAST_SECONDARY) {
                return color.getRgb();
            }
        }

        // We couldn't find a colour. In that case use the primary colour, modifying it's brightness
        // by 45%
        return ColorUtils.changeBrightness(secondary.getRgb(), 0.45f);
    }

    /**
     * @return the first color which has sufficient contrast from the primary colors.
     */
    private int findPrimaryTextColor(final ColorNode primary) {
        // Try and find a colour with sufficient contrast from the primary colour
        for (ColorNode color : mPalette) {
            if (ColorUtils.calculateContrast(color, primary) >= PRIMARY_TEXT_MIN_CONTRAST) {
                return color.getRgb();
            }
        }

        // We haven't found a colour, so return black/white depending on the primary colour's
        // brightness
        return ColorUtils.calculateYiqLuma(primary.getRgb()) >= 128 ? Color.BLACK : Color.WHITE;
    }

    /**
     * @return return black/white depending on the primary colour's brightness
     */
    private int findSecondaryTextColor(final ColorNode primary) {
        return ColorUtils.calculateYiqLuma(primary.getRgb()) >= 128 ? Color.BLACK : Color.WHITE;
    }

    private static ColorNode[] weight(ColorNode[] palette) {
        final MedianCutQuantizer.ColorNode[] copy = Arrays.copyOf(palette, palette.length);
        final float maxCount = palette[0].getCount();

        Arrays.sort(copy, new Comparator<ColorNode>() {
            @Override
            public int compare(ColorNode lhs, ColorNode rhs) {
                final float lhsWeight = calculateWeight(lhs, maxCount);
                final float rhsWeight = calculateWeight(rhs, maxCount);

                if (lhsWeight < rhsWeight) {
                    return 1;
                } else if (lhsWeight > rhsWeight) {
                    return -1;
                }
                return 0;
            }
        });

        return copy;
    }

    private static float calculateWeight(ColorNode node, final float maxCount) {
        return FloatUtils.weightedAverage(
                ColorUtils.calculateColorfulness(node), 2f,
                (node.getCount() / maxCount), 1f
        );
    }

}

4、一个计算浮点数组平均权重平均值的工具方法类

/*
 * Copyright 2014 Chris Banes
 *
 * 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.
 */

public class FloatUtils {

    public static float weightedAverage(float... values) {
        assert values.length % 2 == 0;

        float sum = 0;
        float sumWeight = 0;

        for (int i = 0; i < values.length; i += 2) {
            float value = values[i];
            float weight = values[i + 1];

            sum += (value * weight);
            sumWeight += weight;
        }

        return sum / sumWeight;
    }

}

5、关键类，获取位图中的颜色

/**
 * This sample code is made available as part of the book "Digital Image
 * Processing - An Algorithmic Introduction using Java" by Wilhelm Burger
 * and Mark J. Burge, Copyright (C) 2005-2008 Springer-Verlag Berlin,
 * Heidelberg, New York.
 * Note that this code comes with absolutely no warranty of any kind.
 * See http://www.imagingbook.com for details and licensing conditions.
 *
 * Modified by Chris Banes.
 */

import android.graphics.Color;
import android.util.Log;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/*
 * This is an implementation of Heckbert's median-cut color quantization algorithm
 * (Heckbert P., "Color Image Quantization for Frame Buffer Display", ACM Transactions
 * on Computer Graphics (SIGGRAPH), pp. 297-307, 1982).
 * Unlike in the original algorithm, no initial uniform (scalar) quantization is used to
 * for reducing the number of image colors. Instead, all colors contained in the original
 * image are considered in the quantization process. After the set of representative
 * colors has been found, each image color is mapped to the closest representative
 * in RGB color space using the Euclidean distance.
 * The quantization process has two steps: first a ColorQuantizer object is created from
 * a given image using one of the constructor methods provided. Then this ColorQuantizer
 * can be used to quantize the original image or any other image using the same set of
 * representative colors (color table).
 */

public class MedianCutQuantizer {

    private static final String LOG_TAG = MedianCutQuantizer.class
            .getSimpleName();

    private ColorNode[] imageColors = null; // original (unique) image colors
    private ColorNode[] quantColors = null; // quantized colors

    public MedianCutQuantizer(int[] pixels, int Kmax) {
        quantColors = findRepresentativeColors(pixels, Kmax);
    }

    public int countQuantizedColors() {
        return quantColors.length;
    }

    public ColorNode[] getQuantizedColors() {
        return quantColors;
    }

    ColorNode[] findRepresentativeColors(int[] pixels, int Kmax) {
        ColorHistogram colorHist = new ColorHistogram(pixels);
        int K = colorHist.getNumberOfColors();
        ColorNode[] rCols = null;

        imageColors = new ColorNode[K];
        for (int i = 0; i < K; i++) {
            int rgb = colorHist.getColor(i);
            int cnt = colorHist.getCount(i);
            imageColors[i] = new ColorNode(rgb, cnt);
        }

        if (K <= Kmax) {
            // image has fewer colors than Kmax
            rCols = imageColors;
        } else {
            ColorBox initialBox = new ColorBox(0, K - 1, 0);
            List<ColorBox> colorSet = new ArrayList<ColorBox>();
            colorSet.add(initialBox);
            int k = 1;
            boolean done = false;
            while (k < Kmax && !done) {
                ColorBox nextBox = findBoxToSplit(colorSet);
                if (nextBox != null) {
                    ColorBox newBox = nextBox.splitBox();
                    colorSet.add(newBox);
                    k = k + 1;
                } else {
                    done = true;
                }
            }
            rCols = averageColors(colorSet);
        }
        return rCols;
    }

    public void quantizeImage(int[] pixels) {
        for (int i = 0; i < pixels.length; i++) {
            ColorNode color = findClosestColor(pixels[i]);
            pixels[i] = Color.rgb(color.red, color.grn, color.blu);
        }
    }

    ColorNode findClosestColor(int rgb) {
        int idx = findClosestColorIndex(rgb);
        return quantColors[idx];
    }

    int findClosestColorIndex(int rgb) {
        int red = Color.red(rgb);
        int grn = Color.green(rgb);
        int blu = Color.blue(rgb);
        int minIdx = 0;
        int minDistance = Integer.MAX_VALUE;
        for (int i = 0; i < quantColors.length; i++) {
            ColorNode color = quantColors[i];
            int d2 = color.distance2(red, grn, blu);
            if (d2 < minDistance) {
                minDistance = d2;
                minIdx = i;
            }
        }
        return minIdx;
    }

    private ColorBox findBoxToSplit(List<ColorBox> colorBoxes) {
        ColorBox boxToSplit = null;
        // from the set of splitable color boxes
        // select the one with the minimum level
        int minLevel = Integer.MAX_VALUE;
        for (ColorBox box : colorBoxes) {
            if (box.colorCount() >= 2) { // box can be split
                if (box.level < minLevel) {
                    boxToSplit = box;
                    minLevel = box.level;
                }
            }
        }
        return boxToSplit;
    }

    private ColorNode[] averageColors(List<ColorBox> colorBoxes) {
        int n = colorBoxes.size();
        ColorNode[] avgColors = new ColorNode[n];
        int i = 0;
        for (ColorBox box : colorBoxes) {
            avgColors[i] = box.getAverageColor();
            i = i + 1;
        }
        return avgColors;
    }

    // -------------- class ColorNode
    // -------------------------------------------

    public static class ColorNode {

        private final int red, grn, blu;
        private final int cnt;

        private float[] hsv;

        ColorNode(int rgb, int cnt) {
            this.red = Color.red(rgb);
            this.grn = Color.green(rgb);
            this.blu = Color.blue(rgb);
            this.cnt = cnt;
        }

        ColorNode(int red, int grn, int blu, int cnt) {
            this.red = red;
            this.grn = grn;
            this.blu = blu;
            this.cnt = cnt;
        }

        public int getRgb() {
            return Color.rgb(red, grn, blu);
        }

        public float[] getHsv() {
            if (hsv == null) {
                hsv = new float[3];
                Color.RGBToHSV(red, grn, blu, hsv);
            }
            return hsv;
        }

        public int getCount() {
            return cnt;
        }

        int distance2(int red, int grn, int blu) {
            // returns the squared distance between (red, grn, blu)
            // and this this color
            int dr = this.red - red;
            int dg = this.grn - grn;
            int db = this.blu - blu;
            return dr * dr + dg * dg + db * db;
        }

        public String toString() {
            return new StringBuilder(getClass().getSimpleName()).append(" #")
                    .append(Integer.toHexString(getRgb())).append(". count: ")
                    .append(cnt).toString();
        }
    }

    // -------------- class ColorBox -------------------------------------------

    class ColorBox {

        int lower = 0; // lower index into 'imageColors'
        int upper = -1; // upper index into 'imageColors'
        int level; // split level o this color box
        int count = 0; // number of pixels represented by thos color box
        int rmin, rmax; // range of contained colors in red dimension
        int gmin, gmax; // range of contained colors in green dimension
        int bmin, bmax; // range of contained colors in blue dimension

        ColorBox(int lower, int upper, int level) {
            this.lower = lower;
            this.upper = upper;
            this.level = level;
            this.trim();
        }

        int colorCount() {
            return upper - lower;
        }

        void trim() {
            // recompute the boundaries of this color box
            rmin = 255;
            rmax = 0;
            gmin = 255;
            gmax = 0;
            bmin = 255;
            bmax = 0;
            count = 0;
            for (int i = lower; i <= upper; i++) {
                ColorNode color = imageColors[i];
                count = count + color.cnt;
                int r = color.red;
                int g = color.grn;
                int b = color.blu;
                if (r > rmax) {
                    rmax = r;
                }
                if (r < rmin) {
                    rmin = r;
                }
                if (g > gmax) {
                    gmax = g;
                }
                if (g < gmin) {
                    gmin = g;
                }
                if (b > bmax) {
                    bmax = b;
                }
                if (b < bmin) {
                    bmin = b;
                }
            }
        }

        // Split this color box at the median point along its
        // longest color dimension
        ColorBox splitBox() {
            if (this.colorCount() < 2) // this box cannot be split
            {
                return null;
            } else {
                // find longest dimension of this box:
                ColorDimension dim = getLongestColorDimension();

                // find median along dim
                int med = findMedian(dim);

                // now split this box at the median return the resulting new
                // box.
                int nextLevel = level + 1;
                ColorBox newBox = new ColorBox(med + 1, upper, nextLevel);
                this.upper = med;
                this.level = nextLevel;
                this.trim();
                return newBox;
            }
        }

        // Find longest dimension of this color box (RED, GREEN, or BLUE)
        ColorDimension getLongestColorDimension() {
            int rLength = rmax - rmin;
            int gLength = gmax - gmin;
            int bLength = bmax - bmin;
            if (bLength >= rLength && bLength >= gLength) {
                return ColorDimension.BLUE;
            } else if (gLength >= rLength && gLength >= bLength) {
                return ColorDimension.GREEN;
            } else {
                return ColorDimension.RED;
            }
        }

        // Find the position of the median in RGB space along
        // the red, green or blue dimension, respectively.
        int findMedian(ColorDimension dim) {
            // sort color in this box along dimension dim:
            Arrays.sort(imageColors, lower, upper + 1, dim.comparator);
            // find the median point:
            int half = count / 2;
            int nPixels, median;
            for (median = lower, nPixels = 0; median < upper; median++) {
                nPixels = nPixels + imageColors[median].cnt;
                if (nPixels >= half) {
                    break;
                }
            }
            return median;
        }

        ColorNode getAverageColor() {
            int rSum = 0;
            int gSum = 0;
            int bSum = 0;
            int n = 0;
            for (int i = lower; i <= upper; i++) {
                ColorNode ci = imageColors[i];
                int cnt = ci.cnt;
                rSum = rSum + cnt * ci.red;
                gSum = gSum + cnt * ci.grn;
                bSum = bSum + cnt * ci.blu;
                n = n + cnt;
            }
            double nd = n;
            int avgRed = (int) (0.5 + rSum / nd);
            int avgGrn = (int) (0.5 + gSum / nd);
            int avgBlu = (int) (0.5 + bSum / nd);
            return new ColorNode(avgRed, avgGrn, avgBlu, n);
        }

        public String toString() {
            String s = this.getClass().getSimpleName();
            s = s + " lower=" + lower + " upper=" + upper;
            s = s + " count=" + count + " level=" + level;
            s = s + " rmin=" + rmin + " rmax=" + rmax;
            s = s + " gmin=" + gmin + " gmax=" + gmax;
            s = s + " bmin=" + bmin + " bmax=" + bmax;
            s = s + " bmin=" + bmin + " bmax=" + bmax;
            return s;
        }
    }

    // --- color dimensions ------------------------

    // The main purpose of this enumeration class is associate
    // the color dimensions with the corresponding comparators.
    enum ColorDimension {
        RED(new redComparator()), GREEN(new grnComparator()), BLUE(
                new bluComparator());

        public final Comparator<ColorNode> comparator;

        ColorDimension(Comparator<ColorNode> cmp) {
            this.comparator = cmp;
        }
    }

    // --- color comparators used for sorting colors along different dimensions
    // ---

    static class redComparator implements Comparator<ColorNode> {
        public int compare(ColorNode colA, ColorNode colB) {
            return colA.red - colB.red;
        }
    }

    static class grnComparator implements Comparator<ColorNode> {
        public int compare(ColorNode colA, ColorNode colB) {
            return colA.grn - colB.grn;
        }
    }

    static class bluComparator implements Comparator<ColorNode> {
        public int compare(ColorNode colA, ColorNode colB) {
            return colA.blu - colB.blu;
        }
    }

    // -------- utility methods -----------

    void listColorNodes(ColorNode[] nodes) {
        int i = 0;
        for (ColorNode color : nodes) {
            Log.d(LOG_TAG, "Color Node #" + i + " " + color.toString());
            i++;
        }
    }

    static class ColorHistogram {

        int colorArray[] = null;
        int countArray[] = null;

        ColorHistogram(int[] color, int[] count) {
            this.countArray = count;
            this.colorArray = color;
        }

        ColorHistogram(int[] pixelsOrig) {
            int N = pixelsOrig.length;
            int[] pixelsCpy = new int[N];
            for (int i = 0; i < N; i++) {
                // remove possible alpha components
                pixelsCpy[i] = 0xFFFFFF & pixelsOrig[i];
            }
            Arrays.sort(pixelsCpy);

            // count unique colors:
            int k = -1; // current color index
            int curColor = -1;
            for (int i = 0; i < pixelsCpy.length; i++) {
                if (pixelsCpy[i] != curColor) {
                    k++;
                    curColor = pixelsCpy[i];
                }
            }
            int nColors = k + 1;

            // tabulate and count unique colors:
            colorArray = new int[nColors];
            countArray = new int[nColors];
            k = -1; // current color index
            curColor = -1;
            for (int i = 0; i < pixelsCpy.length; i++) {
                if (pixelsCpy[i] != curColor) { // new color
                    k++;
                    curColor = pixelsCpy[i];
                    colorArray[k] = curColor;
                    countArray[k] = 1;
                } else {
                    countArray[k]++;
                }
            }
        }

        public int[] getColorArray() {
            return colorArray;
        }

        public int[] getCountArray() {
            return countArray;
        }

        public int getNumberOfColors() {
            if (colorArray == null) {
                return 0;
            } else {
                return colorArray.length;
            }
        }

        public int getColor(int index) {
            return this.colorArray[index];
        }

        public int getCount(int index) {
            return this.countArray[index];
        }
    }

} // class MedianCut

剩余的大家自行研究了，如果有研究出更详细的用法，记得联系黄老师哦！
QQ:811868948
E-Mail:halfmanhuang@gmail.com