void filterIcy(Img *img, Img *icyCurve, Img *icyColor, double size, int withWind) {
  if (!img->data) return;
  size = fabs(size);
  if (!(size > IMG_PRECISION)) withWind = FALSE;

  const int    optNoiseWidth0 = (int)round(size/4);
  const int    optNoiseWidth1 = (int)round(size);
  const double optNoise0 = 1;
  const double optNoise1 = 0.75;
  const double optBright0 = 1.1;
  const double optBright1 = 1.4;

  const double optWind = 0.75;
  const int    optWindWidth0 = (int)round(size/4);
  const int    optWindWidth1 = (int)round(size/2);
  const double optWindNoise0 = 0.5;
  const double optWindNoise1 = 0.75;
  const double optWindAtt = withWind ? pow(0.95, 4/size) : 0;

  double blurSize = size/2;
  if (optNoiseWidth0) filterMulNoiseGray(img, img->w/optNoiseWidth0, img->h/optNoiseWidth0, 1-optNoise0, 1);
  if (optNoiseWidth1) filterMulNoiseGray(img, img->w/optNoiseWidth1, img->h/optNoiseWidth1, 1-optNoise1, 1);
  filterFillCh(img, 3, 1);
  filterBlurGauss(img, blurSize, blurSize);

  ClMat m;
  clmMulColor(&m, optBright0);
  filterMatrix(img, &m);

  if (icyCurve && icyCurve->data) {
    //int mi = 0;
    //for(int i = 1; i < icyCurve->w; ++i)
    //  if (imgPixel(icyCurve, i-1, 0)[0] - IMG_PRECISION <= imgPixel(icyCurve, i, 0)[0])
    //    mi = i; else break;
    int mi = 128;
    int mmi = size > 4 ? round(mi*4/size) : mi;
    if (mmi < mi && mi < icyCurve->w - 1) {
      Img imgA = {}, imgB = {};
      imgCropTo(&imgA, icyCurve, 0, 0, mi, icyCurve->h);
      filterResampleCubic(&imgA, mmi, icyCurve->h);
      imgInit(&imgB, icyCurve->w - mi + mmi + 1, icyCurve->h);
      imgCopyTo(&imgB, &imgA, 1, 0, 0, 0, imgA.w, imgA.h);
      imgCopyTo(&imgB, icyCurve, mmi + 1, 0, mi, 0, icyCurve->w - mi, icyCurve->h);
      filterFillCh(&imgB, 3, 1);
      filterCurveByCh(img, &imgB, 0);
      imgDestroy(&imgA);
      imgDestroy(&imgB);
    } else {
      filterCurveByCh(img, icyCurve, 0);
    }
  }

  clmMulColor(&m, optBright1);
  filterMatrix(img, &m);

  if (withWind) {
    Img wind = {};
    imgCopy(&wind, img);

    Img pat = {};
    imgInit(&pat, img->w, 1);
    double clOne[] = {1,1,1,1};
    filterFill(&pat, clOne);
    if (optWindWidth0) filterMulNoiseGray(&pat, img->w/optWindWidth0, 1, 1-optWindNoise0, 1);
    if (optWindWidth1) filterMulNoiseGray(&pat, img->w/optWindWidth1, 1, 1-optWindNoise1, 1);
    filterWind(&wind, &pat, optWindAtt);
    imgDestroy(&pat);

    filterBlend(&wind, img, &bfuncSum, -1);
    filterBlend(img, &wind, &bfuncSum, optWind);
    imgDestroy(&wind);
  }

  if (icyColor)
    filterCurveByCh(img, icyColor, 0);

  //clmScreenToCompositeYUV(&m);
  //filterMatrix(img, &m);
  filterScreenToCompositeHSV(img);
}


int icyGenerate(Img *img, int argc, char **argv) {
  if (img) imgDestroy(img);

  char *inFile = "", *outFile = "";
  char *curveFile = "data/icy-curve.tga", *colorFile = "data/icy-color.tga";
  double size = 4;
  int withWind = TRUE;
  int withoutWind = FALSE;
  ArgDesc descs[] = {
    { 'i', &inFile, &pargString, "path to input image" },
    { 'o', &outFile, &pargString, "path to output image" },
    { 'c', &curveFile, &pargString, "path to image with crystal curve" },
    { 'l', &colorFile, &pargString, "path to image with color curve" },
    { 's', &size, &pargDouble, "effect size" },
    { 'w', &withWind, NULL, "add icicles (default)" },
    { 'n', &withoutWind, NULL, "no icicles" },
    {}
  };

  if (!parseArgs(descs, argc, argv) || !inFile[0] || !outFile[0]) {
    printUsage(descs);
    return FALSE;
  }

  if (withoutWind) withWind = FALSE;

  Img imgC = {};
  Img imgCurve = {};
  Img imgColor = {};
  if (!imgLoad(&imgC, inFile))
    return FALSE;

  imgLoad(&imgCurve, curveFile);
  imgLoad(&imgColor, colorFile);
  filterIcy(&imgC, &imgCurve, &imgColor, size, withWind);

  if (!imgSave(&imgC, outFile))
    imgDestroy(&imgC);
  int success = !!imgC.data;

  if (img) imgSwap(img, &imgC);
  imgDestroy(&imgCurve);
  imgDestroy(&imgCurve);
  imgDestroy(&imgC);

  return success;
}