MapGIS Client for JavaScript API

import Zondy from './Zondy'
import { defaultValue, Log } from '../util'

/**
 * 颜色类
 * @classdesc 颜色类
 * @class Color
 * @param {Number} [red = 0.0] 红色
 * @param {Number} [green = 0.0] 绿色
 * @param {Number} [blue = 0.0] 蓝色
 * @param {Number} [alpha = 1.0] 透明度
 */
class Color {
  constructor(red, green, blue, alpha) {
    this.red = defaultValue(red, 0.0)
    this.green = defaultValue(green, 0.0)
    this.blue = defaultValue(blue, 0.0)
    this.alpha = defaultValue(alpha, 1.0)
  }

  /**
   * 转为cesium的rgba值
   * @return {Object} cesium的rgba值
   */
  toCesiumRGB() {
    return {
      red: this.red / 255,
      green: this.green / 255,
      blue: this.blue / 255,
      alpha: this.alpha
    }
  }

  /**
   * 转为rgba字符串
   * @return {String} rgba字符串
   */
  toCssRGBAString() {
    return `rgba(${this.red},${this.green},${this.blue},${this.alpha})`
  }

  /**
   * 转为rgb字符串
   * @return {String} rgb字符串
   */
  toCssRGBString() {
    return `rgb(${this.red},${this.green},${this.blue})`
  }

  /**
   * 克隆字符串
   * @return {Color} 颜色对象
   */
  clone() {
    return new Color(this.red, this.green, this.blue, this.alpha)
  }

  /**
   * 导出为JSON对象
   * @return {Object} JSON对象
   */
  toJSON() {
    return {
      red: this.red,
      green: this.green,
      blue: this.blue,
      alpha: this.alpha
    }
  }
}

/**
 * 将rgb或rgba字符串转成一个Color对象
 * @param {String} rgb rgb或rgba字符
 * @return {Color} Color对象
 */
Color.fromRGBString = function (rgb) {
  if (Color.isRGB(rgb)) {
    if (rgb.indexOf('rgba') > -1 || rgb.indexOf('RGBA') > -1) {
      let cssString = rgb.substring(5, rgb.length - 1)
      cssString = cssString.split(',')
      if (cssString.length === 4) {
        return new Color(
          Number(cssString[0]),
          Number(cssString[1]),
          Number(cssString[2]),
          Number(cssString[3])
        )
      }
    } else if (rgb.indexOf('rgb') > -1 || rgb.indexOf('RGB') > -1) {
      let cssString = rgb.substring(4, rgb.length - 1)
      cssString = cssString.split(',')
      if (cssString.length === 3) {
        return new Color(
          Number(cssString[0]),
          Number(cssString[1]),
          Number(cssString[2])
        )
      }
    }
  }

  return undefined
}

/**
 * 将hex字符串转成一个Color对象
 * @param {String} hex hex字符串
 * @return {Color} Color对象
 */
Color.fromHexString = function (hex) {
  if (Color.isHex(hex)) {
    const rgb = Color.hexToRgb(hex)
    if (rgb.indexOf('rgba') > -1 || rgb.indexOf('RGBA') > -1) {
      return Color.fromRGBString(rgb)
    } else if (rgb.indexOf('rgb') > -1 || rgb.indexOf('RGB') > -1) {
      return Color.fromRGBString(rgb)
    }
  }
  return undefined
}

/**
 * 将json转成一个Color对象
 * @param {String} json json对象
 * @return {Color} Color对象
 */
Color.fromJSON = function (json) {
  json = defaultValue(json, {})
  const red = defaultValue(json.red, 255.0)
  const green = defaultValue(json.green, 255.0)
  const blue = defaultValue(json.blue, 255.0)
  const alpha = defaultValue(json.alpha, 1.0)
  return new Color(red, green, blue, alpha)
}

/**
 * 将hex字符串转成一个rgb字符串
 * @param {String} hex hex字符串
 * @return {String} rgb字符串
 */
Color.hexToRgb = function (hex) {
  // 3位、4位、6位以及8位hex值
  const reg = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/
  // 格式判断
  if (!reg.test(hex)) {
    return
  }
  let newStr = hex.toLowerCase().replace(/\#/g, '')
  let length = newStr.length
  // 三位或四位扩充为8位
  if (length === 3 || length === 4) {
    let t = ''
    for (let i = 0; i < length; i++) {
      t += newStr.slice(i, i + 1).concat(newStr.slice(i, i + 1))
    }
    newStr = t
    length = newStr.length
  }
  // 将字符串分隔，两个两个的分隔
  const arr = []
  for (let i = 0; i < length; i += 2) {
    const s = newStr.slice(i, i + 2)
    arr.push(parseInt(`0x${s}`))
  }
  // 生成rgb字符串
  let rgb
  if (length === 6) {
    rgb = `rgb(${arr.join(',')})`
  } else if (length === 8) {
    rgb = 'rgba('
    for (let i = 0; i < 3; i++) {
      rgb += `${arr[i]},`
    }
    rgb += `${arr[3] / 255})`
  }
  return rgb
}

/**
 * 将rgb字符串转成一个hex字符串
 * @param {String} rgb rgb字符串
 * @return {String} hex字符串
 */
Color.rgbToHex = function (rgb) {
  // 格式校验
  const reg = /^(rgb|rgba|RGB|RGBA)/
  if (!reg.test(rgb)) {
    return
  }

  let arr
  if (rgb.indexOf('rgba') > -1 || rgb.indexOf('RGBA') > -1) {
    arr = rgb.slice(5, rgb.length - 1).split(',')
  } else {
    arr = rgb.slice(4, rgb.length - 1).split(',')
  }

  function get16Str(number) {
    let t = Number(number).toString(16)
    if (t === '0') {
      // 如果为“0”的话，需要补0操作,否则只有5位数
      t += '0'
    }
    // 如果长度为1的话，需要补0操作,否则只有5位数
    if (t.length === 1) {
      t = `0${t}`
    }
    return t
  }

  let hex = '#'
  for (let i = 0; i < 3; i++) {
    hex += get16Str(arr[i])
  }
  // 透明度为0-1
  if (arr.length === 4) {
    hex += get16Str(Number(arr[3]) * 255)
  }
  return hex
}
/**
 * 转换为color对象
 * @param {Color|String} hex字符串或rgba字符串或Color对象
 * @return {Color} 转换后的颜色对象
 */
Color.fromColor = function (color) {
  if (typeof color === 'string') {
    if (Color.isHex(color)) {
      return Color.fromHexString(color)
    } else if (Color.isRGB(color)) {
      return Color.fromRGBString(color)
    }
  } else if (color instanceof Color) {
    return color
  } else if (Array.isArray(color)) {
    if (color.length === 3) {
      return new Color(color[0], color[1], color[2])
    } else if (color.length === 4) {
      return new Color(color[0], color[1], color[2], color[3])
    } else {
      Log.info('非法颜色值数组!')
      return new Color()
    }
  } else if (color instanceof Object) {
    return Color.fromJSON(color)
  } else {
    return new Color()
  }
}

/**
 * 判断是否是hex字符串
 * @param {String} hex hex字符串
 * @return {Boolean} 是否是hex字符串
 */
Color.isHex = function (hex) {
  // 3位、4位、6位以及8位hex值
  const reg = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/
  // 格式判断
  return reg.test(hex)
}

/**
 * 判断是否是rgb字符串
 * @param {String} rgb rgb字符串
 * @return {Boolean} 是否是rgb字符串
 */
Color.isRGB = function (rgb) {
  // 格式校验
  const reg = /^(rgb|rgba|RGB|RGBA)/
  return reg.test(rgb)
}

Zondy.Color = Color
export default Color