void filterIcy(Img *img, 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 curve[][3] = {
    {  0   , 0   , 0 },
    {  0.15, 0.65, 0 },
    {  0.35, 0.15, 0 },
    {  0.65, 0.85, 0 },
    {  0.85, 0.35, 0 },
    {  1   , 1   , 0 } };
  double curveColor[][5] = {
    { 0  ,  0  , 0  , 0  , 1 },
    { 0.6,  0.4, 0.4, 0.6, 1 },
    { 1  ,  1  , 1  , 1  , 1 } };


  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);

  Img imgC = {};
  imgInit(&imgC, 512, 1);

  curve[0][0] = curve[1][0]*(1 - 4/size);
  filterRasterizeTCurve(&imgC, curve[0], sizeof(curve)/sizeof(*curve), curve[0][0], 1);
  filterFillCh(&imgC, 3, 1);
  filterCurveByCh(img, &imgC, 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);
  }

  filterRasterizeCurveColor(&imgC, curveColor[0], sizeof(curveColor)/sizeof(*curveColor), 0, 1);
  filterCurveByCh(img, &imgC, 0);
  imgDestroy(&imgC);

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


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

  char *inFile = "", *outFile = "";
  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" },
    { '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 = {};
  if (!imgLoad(&imgC, inFile))
    return FALSE;

  filterIcy(&imgC, size, withWind);

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

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

  return success;
}