استفاده از فضاهای رنگی مختلف برای مقایسه رنگ ها

const getClosestColorInThePalette = (referenceColor = rgbModel) => {
   const key = `${referenceColor.red},${referenceColor.green},${referenceColor.blue}`;
   if (closestColors[key])
      return closestColors[key];
   let closestColor = {
      blue: -1,
      green: -1,
      name: '',
      red: -1,
   };
   let shortestDistance = Number.MAX_SAFE_INTEGER;
   const algorithm = local.getItem('algorithm');
   palette.forEach(paletteColor => {
      if (shortestDistance === 0)
         return;
      let distance;
      switch (algorithm) {
         case algorithms.CMYK:
            const {cyan: paletteCyan, magenta: paletteMagenta, yellow: paletteYellow, key: paletteKey} = convertRgbToCmyk(paletteColor);
            const {cyan: referenceCyan, magenta: referenceMagenta, yellow: referenceYellow, key: referenceKey} = convertRgbToCmyk(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceCyan - paletteCyan, 2)
               + Math.pow(referenceMagenta - paletteMagenta, 2)
               + Math.pow(referenceYellow - paletteYellow, 2)
               + Math.pow(referenceKey - paletteKey, 2)
            );
            break;
         case algorithms.RGB:
         default:
            distance = Math.sqrt(
               Math.pow(paletteColor.red - referenceColor.red, 2)
               + Math.pow(paletteColor.green - referenceColor.green, 2)
               + Math.pow(paletteColor.blue - referenceColor.blue, 2)
            );
            break;
      }
      if (distance < shortestDistance) {
         shortestDistance = distance;
         closestColor = paletteColor;
         closestColors[key] = paletteColor;
      }
   });
   return closestColor;
};

const convertRgbToCmyk = (rgbColor = rgbModel) => {
   const {red, green, blue} = rgbColor;
   let cyan = 255 - red;
   let magenta = 255 - green;
   let yellow = 255 - blue;
   let key = Math.min(cyan, magenta, yellow);
   const divider = key === 255 ? 1 : 255 - key;
   cyan = ((cyan - key) / divider);
   magenta = ((magenta - key) / divider);
   yellow = ((yellow - key) / divider);
   key = key / 255;
   return {
      cyan,
      magenta,
      yellow,
      key,
   };
};

const getClosestColorInThePalette = (referenceColor = rgbModel) => {
   const key = `${referenceColor.red},${referenceColor.green},${referenceColor.blue}`;
   if (closestColors[key])
      return closestColors[key];
   let closestColor = {
      blue: -1,
      green: -1,
      name: '',
      red: -1,
   };
   let shortestDistance = Number.MAX_SAFE_INTEGER;
   const algorithm = local.getItem('algorithm');
   palette.forEach(paletteColor => {
      if (shortestDistance === 0)
         return;
      let distance;
      switch (algorithm) {
         case algorithms.CMYK:
            const {cyan: paletteCyan, magenta: paletteMagenta, yellow: paletteYellow, key: paletteKey} = convertRgbToCmyk(paletteColor);
            const {cyan: referenceCyan, magenta: referenceMagenta, yellow: referenceYellow, key: referenceKey} = convertRgbToCmyk(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceCyan - paletteCyan, 2)
               + Math.pow(referenceMagenta - paletteMagenta, 2)
               + Math.pow(referenceYellow - paletteYellow, 2)
               + Math.pow(referenceKey - paletteKey, 2)
            );
            break;
         case algorithms.HSL:
            const {hue: paletteHue, saturation: paletteSaturation, lightness: paletteLightness} = convertRgbToHsl(paletteColor);
            const {hue: referenceHue, saturation: referenceSaturation, lightness: referenceLightness} = convertRgbToHsl(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceHue - paletteHue, 2)
               + Math.pow(referenceSaturation - paletteSaturation, 2)
               + Math.pow(referenceLightness - paletteLightness, 2)
            );
            break;
         case algorithms.RGB:
         default:
            distance = Math.sqrt(
               Math.pow(paletteColor.red - referenceColor.red, 2)
               + Math.pow(paletteColor.green - referenceColor.green, 2)
               + Math.pow(paletteColor.blue - referenceColor.blue, 2)
            );
            break;
      }
      if (distance < shortestDistance) {
         shortestDistance = distance;
         closestColor = paletteColor;
         closestColors[key] = paletteColor;
      }
   });
   return closestColor;
};

const convertRgbToHsl = (rgbcolor = rgbModel) => {
   let { red, green, blue } = rgbcolor;
   red = red / 255;
   green = green / 255;
   blue = blue / 255;
   const maximum = Math.max(red, green, blue);
   const minimum = Math.min(red, green, blue);
   const basis = (maximum + minimum) / 2;
   let hue;
   let saturation;
   let lightness = basis;
   if (maximum === minimum) {
      hue = 0;
      saturation = 0;
   } else {
      const difference = maximum - minimum;
      saturation = lightness > 0.5 ? difference / (2 - maximum - minimum) : difference / (maximum + minimum);
      switch (maximum) {
         case red:
            hue = (green - blue) / difference + (green < blue ? 6 : 0);
            break;
         case green:
            hue = (blue - red) / difference + 2;
            break;
         case blue:
         default:
            hue = (red - green) / difference + 4;
            break;
      }
      hue = hue / 6;
   }
   return {
      hue,
      saturation,
      lightness,
   };
}

const getClosestColorInThePalette = (referenceColor = rgbModel) => {
   const key = `${referenceColor.red},${referenceColor.green},${referenceColor.blue}`;
   if (closestColors[key])
      return closestColors[key];
   let closestColor = {
      blue: -1,
      green: -1,
      name: '',
      red: -1,
   };
   let shortestDistance = Number.MAX_SAFE_INTEGER;
   const algorithm = local.getItem('algorithm');
   palette.forEach(paletteColor => {
      if (shortestDistance === 0)
         return;
      let distance;
      switch (algorithm) {
         case algorithms.CMYK:
            const {cyan: paletteCyan, magenta: paletteMagenta, yellow: paletteYellow, key: paletteKey} = convertRgbToCmyk(paletteColor);
            const {cyan: referenceCyan, magenta: referenceMagenta, yellow: referenceYellow, key: referenceKey} = convertRgbToCmyk(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceCyan - paletteCyan, 2)
               + Math.pow(referenceMagenta - paletteMagenta, 2)
               + Math.pow(referenceYellow - paletteYellow, 2)
               + Math.pow(referenceKey - paletteKey, 2)
            );
            break;
         case algorithms.HSL:
            const {hue: paletteHue, saturation: paletteSaturation, lightness: paletteLightness} = convertRgbToHsl(paletteColor);
            const {hue: referenceHue, saturation: referenceSaturation, lightness: referenceLightness} = convertRgbToHsl(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceHue - paletteHue, 2)
               + Math.pow(referenceSaturation - paletteSaturation, 2)
               + Math.pow(referenceLightness - paletteLightness, 2)
            );
            break;
         case algorithms.XYZ:
            const {x: paletteX, y: paletteY, z: paletteZ} = convertRgbToXyz(paletteColor);
            const {x: referenceX, y: referenceY, z: referenceZ} = convertRgbToXyz(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceX - paletteX, 2)
               + Math.pow(referenceY - paletteY, 2)
               + Math.pow(referenceZ - paletteZ, 2)
            );
            break;
         case algorithms.RGB:
         default:
            distance = Math.sqrt(
               Math.pow(paletteColor.red - referenceColor.red, 2)
               + Math.pow(paletteColor.green - referenceColor.green, 2)
               + Math.pow(paletteColor.blue - referenceColor.blue, 2)
            );
            break;
      }
      if (distance < shortestDistance) {
         shortestDistance = distance;
         closestColor = paletteColor;
         closestColors[key] = paletteColor;
      }
   });
   return closestColor;
};

const convertRgbToXyz = (rgbColor = rgbModel) => {
   const convert = color => {
      color = color / 255;
      color = color > 0.04045 ? Math.pow(((color + 0.055) / 1.055), 2.4) : color / 12.92;
      color = color * 100;
      return color;
   }

   let {red, green, blue} = rgbColor;
   red = convert(red);
   green = convert(green);
   blue = convert(blue);
   const x = (red * 0.4124564) + (green * 0.3575761) + (blue * 0.1804375);
   const y = (red * 0.2126729) + (green * 0.7151522) + (blue * 0.0721750);
   const z = (red * 0.0193339) + (green * 0.1191920) + (blue * 0.9503041);
   return {
      x,
      y,
      z,
   };
};

const getClosestColorInThePalette = (referenceColor = rgbModel) => {
   const key = `${referenceColor.red},${referenceColor.green},${referenceColor.blue}`;
   if (closestColors[key])
      return closestColors[key];
   let closestColor = {
      blue: -1,
      green: -1,
      name: '',
      red: -1,
   };
   let shortestDistance = Number.MAX_SAFE_INTEGER;
   const algorithm = local.getItem('algorithm');
   palette.forEach(paletteColor => {
      if (shortestDistance === 0)
         return;
      let distance;
      switch (algorithm) {
         case algorithms.CMYK:
            const {cyan: paletteCyan, magenta: paletteMagenta, yellow: paletteYellow, key: paletteKey} = convertRgbToCmyk(paletteColor);
            const {cyan: referenceCyan, magenta: referenceMagenta, yellow: referenceYellow, key: referenceKey} = convertRgbToCmyk(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceCyan - paletteCyan, 2)
               + Math.pow(referenceMagenta - paletteMagenta, 2)
               + Math.pow(referenceYellow - paletteYellow, 2)
               + Math.pow(referenceKey - paletteKey, 2)
            );
            break;
         case algorithms.HSL:
            const {hue: paletteHue, saturation: paletteSaturation, lightness: paletteLightness} = convertRgbToHsl(paletteColor);
            const {hue: referenceHue, saturation: referenceSaturation, lightness: referenceLightness} = convertRgbToHsl(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceHue - paletteHue, 2)
               + Math.pow(referenceSaturation - paletteSaturation, 2)
               + Math.pow(referenceLightness - paletteLightness, 2)
            );
            break;
         case algorithms.XYZ:
            const {x: paletteX, y: paletteY, z: paletteZ} = convertRgbToXyz(paletteColor);
            const {x: referenceX, y: referenceY, z: referenceZ} = convertRgbToXyz(referenceColor);
            distance = Math.sqrt(
               Math.pow(referenceX - paletteX, 2)
               + Math.pow(referenceY - paletteY, 2)
               + Math.pow(referenceZ - paletteZ, 2)
            );
            break;
         case algorithms.DELTA_E:
            const paletteLabColor = convertRgbToLab(paletteColor);
            const referenceLabColor = convertRgbToLab(referenceColor);
            distance = calculateDeltaE2000(paletteLabColor, referenceLabColor);
            break;
         case algorithms.RGB:
         default:
            distance = Math.sqrt(
               Math.pow(paletteColor.red - referenceColor.red, 2)
               + Math.pow(paletteColor.green - referenceColor.green, 2)
               + Math.pow(paletteColor.blue - referenceColor.blue, 2)
            );
            break;
      }
      if (distance < shortestDistance) {
         shortestDistance = distance;
         closestColor = paletteColor;
         closestColors[key] = paletteColor;
      }
   });
   return closestColor;
};

const convertRgbToLab = (rgbColor = rgbModel) => {
   const xyzColor = convertRgbToXyz(rgbColor);
   return convertXyzToLab(xyzColor);
};

const convertXyzToLab = (xyzColor = xyzModel) => {
   const adjust = value => value > 0.008856 ? Math.pow(value, (1 / 3)) : (7.787 * value) + (16 / 116);

   let {x, y, z} = xyzColor;
   x = x / 94.811;
   y = y / 100;
   z = z / 107.304;
   x = adjust(x);
   y = adjust(y);
   z = adjust(z);
   const lightness = (116 * y) - 16;
   const redGreen = 500 * (x - y);
   const blueYellow = 200 * (y - z);
   return {
      lightness,
      redGreen,
      blueYellow,
   };
};

const calculateDeltaE2000 = (labColor1 = labModel, labColor2 = labModel) => {
   const {lightness: lightness1, redGreen: redGreen1, blueYellow: blueYellow1} = labColor1;
   const {lightness: lightness2, redGreen: redGreen2, blueYellow: blueYellow2} = labColor2;
   Math.rad2deg = function (rad) {
      return 360 * rad / (2 * Math.PI);
   };
   Math.deg2rad = function (deg) {
      return (2 * Math.PI * deg) / 360;
   };
   const avgL = (lightness1 + lightness2) / 2;
   const c1 = Math.sqrt(Math.pow(redGreen1, 2) + Math.pow(blueYellow1, 2));
   const c2 = Math.sqrt(Math.pow(redGreen2, 2) + Math.pow(blueYellow2, 2));
   const avgC = (c1 + c2) / 2;
   const g = (1 - Math.sqrt(Math.pow(avgC, 7) / (Math.pow(avgC, 7) + Math.pow(25, 7)))) / 2;
   const a1p = redGreen1 * (1 + g);
   const a2p = redGreen2 * (1 + g);
   const c1p = Math.sqrt(Math.pow(a1p, 2) + Math.pow(blueYellow1, 2));
   const c2p = Math.sqrt(Math.pow(a2p, 2) + Math.pow(blueYellow2, 2));
   const avgCp = (c1p + c2p) / 2;
   let h1p = Math.rad2deg(Math.atan2(blueYellow1, a1p));
   if (h1p < 0)
      h1p = h1p + 360;
   let h2p = Math.rad2deg(Math.atan2(blueYellow2, a2p));
   if (h2p < 0)
      h2p = h2p + 360;
   const avghp = Math.abs(h1p - h2p) > 180 ? (h1p + h2p + 360) / 2 : (h1p + h2p) / 2;
   const t = 1 -
      0.17 * Math.cos(Math.deg2rad(avghp - 30))
      + 0.24 * Math.cos(Math.deg2rad(2 * avghp))
      + 0.32 * Math.cos(Math.deg2rad(3 * avghp + 6))
      - 0.2 * Math.cos(Math.deg2rad(4 * avghp - 63));
   let deltahp = h2p - h1p;
   if (Math.abs(deltahp) > 180) {
      if (h2p <= h1p) {
         deltahp += 360;
      } else {
         deltahp -= 360;
      }
   }
   const deltalp = lightness2 - lightness1;
   const deltacp = c2p - c1p;
   deltahp = 2 * Math.sqrt(c1p * c2p) * Math.sin(Math.deg2rad(deltahp) / 2);
   const sl = 1 + ((0.015 * Math.pow(avgL - 50, 2)) / Math.sqrt(20 + Math.pow(avgL - 50, 2)));
   const sc = 1 + 0.045 * avgCp;
   const sh = 1 + 0.015 * avgCp * t;
   const deltaro = 30 * Math.exp(-(Math.pow((avghp - 275) / 25, 2)));
   const rc = 2 * Math.sqrt(Math.pow(avgCp, 7) / (Math.pow(avgCp, 7) + Math.pow(25, 7)));
   const rt = -rc * Math.sin(2 * Math.deg2rad(deltaro));
   const kl = 1;
   const kc = 1;
   const kh = 1;
   return Math.sqrt(Math.pow(deltalp / (kl * sl), 2)
      + Math.pow(deltacp / (kc * sc), 2)
      + Math.pow(deltahp / (kh * sh), 2)
      + rt * (deltacp / (kc * sc)) * (deltahp / (kh * sh)));
};