//
//  PRCurvesView.m
//  PRICE
//
//  Created by Riccardo Mottola on 7 August 2011.
//  Copyright 2011 Riccardo Mottola. All rights reserved.
//
// This application is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

#import "PRCurvesView.h"
#import "PRCCurves.h"


@implementation PRCurvesView

- (id)initWithFrame:(NSRect)frame
  {
    self = [super initWithFrame:frame];
    if (self)
      {
	isColor = NO;

        pathLumi = [[PRCurvesPath alloc] init];
        pathR    = [[PRCurvesPath alloc] init];
        pathG    = [[PRCurvesPath alloc] init];
        pathB    = [[PRCurvesPath alloc] init];
        
	pathHLumi = [[NSBezierPath alloc] init];
	pathHR = [[NSBezierPath alloc] init];
	pathHG = [[NSBezierPath alloc] init];
	pathHB = [[NSBezierPath alloc] init];

	pathHLumiTr = [[NSBezierPath alloc] init];
	pathHRTr = [[NSBezierPath alloc] init];
	pathHGTr = [[NSBezierPath alloc] init];
	pathHBTr = [[NSBezierPath alloc] init];

        [pathLumi moveToPoint: NSMakePoint(0, 0)];
        [pathLumi curveToPoint: NSMakePoint(255, 255) controlPoint1: NSMakePoint(50, 0) controlPoint2: NSMakePoint(205, 255)];

        [pathR moveToPoint: NSMakePoint(0, 0)];
        [pathR curveToPoint: NSMakePoint(255, 255) controlPoint1: NSMakePoint(50, 0) controlPoint2: NSMakePoint(205, 255)];

        [pathG moveToPoint: NSMakePoint(0, 0)];
        [pathG curveToPoint: NSMakePoint(255, 255) controlPoint1: NSMakePoint(50, 0) controlPoint2: NSMakePoint(205, 255)];

	[pathB moveToPoint: NSMakePoint(0, 0)];
        [pathB curveToPoint: NSMakePoint(255, 255) controlPoint1: NSMakePoint(50, 0) controlPoint2: NSMakePoint(205, 255)];

	histogramScale = 0.3;
      }
    return self;
}

- (void)dealloc
{
  [pathLumi release];
  [pathR release];
  [pathG release];
  [pathB release];

  [pathHLumi release];
  [pathHR release];
  [pathHG release];
  [pathHB release];

  [pathHLumiTr release];
  [pathHRTr release];
  [pathHGTr release];
  [pathHBTr release];
  
  [super dealloc];
}

-(BOOL)isColor
{
  return isColor;
}

-(void)setFilterController: (PRCCurves *)aFilterController;
{
  controller = aFilterController;
}

-(void)setBlackPoint: (int)value
{
  PRCurvesPath *path;
  NSBezierPathElement pe;
  NSPoint cp[3];
  float diff;
  
  path = pathLumi;
  pe = [path elementAtIndex: 0 associatedPoints: cp];
  diff = cp[0].x - (float)value;
  if ((pe == NSMoveToBezierPathElement) || (pe == NSLineToBezierPathElement))
    {
      /* if we have a straight line, we move the next control point too to preserve the curve */

      NSBezierPathElement pe2;
      NSPoint cp2[3];
      
      if (1 <= [path elementCount])
	{
	  cp[0].x = (float)value;
	  pe2 = [path elementAtIndex: 1 associatedPoints: cp2];
	  if (pe2 == NSCurveToBezierPathElement)
	    {
	      NSLog(@"old cp2-0.x: %f", cp2[0].x);
	      cp2[0].x = cp2[0].x - diff;
	      NSLog(@"new cp2-0.x: %f", cp2[0].x);
	      [path setAssociatedPoints: cp2 atIndex: 1];
	    }
	}
      else if (pe == NSCurveToBezierPathElement)
	{
	  float diff;
    
	  diff = cp[0].x - (float)value;
	  cp[0].x = (float)value;
	  //	  cp[1].x = cp[1].x - diff;
	  //	  cp[2].x = cp[2].x - diff;
	}
      [path setAssociatedPoints: cp atIndex: 0];
    }
}

-(void)setWhitePoint: (int)value
{
  PRCurvesPath *path;
  NSBezierPathElement pe;
  NSPoint cp[3];
  
  path = pathLumi;
  pe = [path elementAtIndex: [path elementCount]-1 associatedPoints: cp];
  if (pe == NSMoveToBezierPathElement)
    cp[0].x = value;
  else if (pe == NSLineToBezierPathElement)
    cp[0].x = value;
  else if (pe == NSCurveToBezierPathElement)
    {
      float diff;
    
      diff = cp[2].x - (float)value;
      cp[2].x = value;
      cp[1].x = cp[1].x - diff;
      //cp[2].x = cp[2].x - diff;
    }
  [path setAssociatedPoints: cp atIndex: [path elementCount]-1];
}


-(PRCurvesPath *)luminancePath
{
  return pathLumi;
}

-(PRCurvesPath *)redPath
{
  return pathR;
}

-(PRCurvesPath *)greenPath
{
  return pathG;
}

-(PRCurvesPath *)bluePath
{
  return pathB;
}

- (void)drawRect:(NSRect)rect
{
  [[NSColor whiteColor] set];
  [NSBezierPath fillRect: [self bounds]];

  if (isColor)
    {
      [[NSColor colorWithDeviceRed:1.0 green:0.0 blue:0.0 alpha:1.0] set];
      [pathHR stroke];
      [[NSColor colorWithDeviceRed:1.0 green:0.0 blue:0.0 alpha:0.7] set];
      [pathHR fill];
      [[NSColor colorWithDeviceRed:1.0 green:0.0 blue:0.0 alpha:1.0] set];
      [pathHRTr stroke];
      [[NSColor colorWithDeviceRed:1.0 green:0.0 blue:0.0 alpha:0.7] set];
      [pathHRTr fill];
      //      [[NSColor redColor] set];
      //      [pathR stroke];
  
      [[NSColor colorWithDeviceRed:0.0 green:1.0 blue:0.0 alpha:1.0] set];
      [pathHG stroke];
      [[NSColor colorWithDeviceRed:0.0 green:1.0 blue:0.0 alpha:0.7] set];
      [pathHG fill];
      [[NSColor colorWithDeviceRed:0.0 green:1.0 blue:0.0 alpha:1.0] set];
      [pathHGTr stroke];
      [[NSColor colorWithDeviceRed:0.0 green:1.0 blue:0.0 alpha:0.7] set];
      [pathHGTr fill];
      //      [[NSColor greenColor] set];
      //      [pathG stroke];

      [[NSColor colorWithDeviceRed:0.0 green:0.0 blue:1.0 alpha:1.0] set];
      [pathHB stroke];
      [[NSColor colorWithDeviceRed:0.0 green:0.0 blue:1.0 alpha:0.7] set];
      [pathHB fill];
      [[NSColor colorWithDeviceRed:0.0 green:0.0 blue:1.0 alpha:1.0] set];
      [pathHBTr stroke];
      [[NSColor colorWithDeviceRed:0.0 green:0.0 blue:1.0 alpha:0.7] set];
      [pathHBTr fill];
      //      [[NSColor blueColor] set];
      //      [pathB stroke];
      //  FIXME: temporary, until we have full RGB support
      [[NSColor blackColor] set];
      [pathLumi stroke];
    }
  else
    {
      [[NSColor colorWithDeviceWhite:0.5 alpha:1.0] set];
      [pathHLumi stroke];
      [[NSColor colorWithDeviceWhite:0.9 alpha:1.0] set];
      [pathHLumi fill];

      [[NSColor colorWithDeviceWhite:0.5 alpha:1.0] set];
      [pathHLumiTr stroke];
      [[NSColor colorWithDeviceWhite:0.9 alpha:1.0] set];
      [pathHLumiTr fill];
  
      [[NSColor blackColor] set];
      [pathLumi stroke];
    }

  
  
  /* boundaries */
  [[NSColor blackColor] set];
  [NSBezierPath strokeRect: [self bounds]];
}

-(void)calculateHistogram: (PRImage *)image;
{
  NSBitmapImageRep *theImageRep;
  unsigned char *theData;
  int w, h;
  int x, y;
  int i;
  int srcSamplesPerPixel;
  int srcBytesPerRow;
  float maxHisto;
  unsigned viewHeight;
  float histoScale;
  
  
  /* get source image representation and associated information */
  theImageRep = [image bitmapRep];
  
  w = [theImageRep pixelsWide];
  h = [theImageRep pixelsHigh];
  pixNum = h * w;
  srcBytesPerRow = [theImageRep bytesPerRow];
  srcSamplesPerPixel = [theImageRep samplesPerPixel];
  
  /* check bith depth and color/greyscale image */
  if ([theImageRep hasAlpha])
    {
      if ([theImageRep samplesPerPixel] == 2)
        {
          printf("Grayscale image\n");
          isColor = NO;
        }
      else
        {
          printf("Color image\n");
          isColor = YES;
        }
    }
  else
    {
      if ([theImageRep samplesPerPixel] == 1)
        {
	  printf("Grayscale image\n");
	  isColor = NO;
        }
      else
        {
          printf("Color image\n");
          isColor = YES;
        }
    }
  
  theData = [theImageRep bitmapData];
  
  if (isColor)
    {
      /* calculate the histogram */
      for (i = 0; i <= UCHAR_MAX; i++)
	histogramDenormR[i] = histogramDenormG[i] = histogramDenormB[i] = 0;
      for (y = 0; y < h; y++)
	for (x = 0; x < w*3; x += 3)
	  {
	    histogramDenormR[theData[y*srcBytesPerRow + x]]++;
	    histogramDenormG[theData[y*srcBytesPerRow + x + 1]]++;
	    histogramDenormB[theData[y*srcBytesPerRow + x + 2]]++;
	  }
        
      /* normalize histogram */
      /* calculate the maximum luminance as maxHisto */
      maxHisto = 0;
      for (i = 0; i <= UCHAR_MAX; i++)
	{
	  histogramR[i] = (float)histogramDenormR[i] / (float)pixNum;
	  histogramG[i] = (float)histogramDenormG[i] / (float)pixNum;
	  histogramB[i] = (float)histogramDenormB[i] / (float)pixNum;
	  if (histogramR[i] > maxHisto)
	    maxHisto = histogramR[i];
	  if (histogramG[i] > maxHisto)
	    maxHisto = histogramG[i];
	  if (histogramB[i] > maxHisto)
	    maxHisto = histogramB[i];
	}
    } 
  else
    {
      /* calculate the histogram */
      for (i = 0; i <= UCHAR_MAX; i++)
        histogramDenormL[i] = 0;
      for (y = 0; y < h; y++)
        for (x = 0; x < w; x++)
          histogramDenormL[theData[y*srcBytesPerRow + x]]++;
      
      /* normalize histogram */
      maxHisto = 0;
      for (i = 0; i <= UCHAR_MAX; i++)
        {
	  histogramL[i] = (float)histogramDenormL[i] / (float)pixNum;
	  if (histogramL[i] > maxHisto)
	    maxHisto = histogramL[i];
        }
    }

  viewHeight = 256;
  NSLog(@"maxHisto L : %f for %u", maxHisto, pixNum);
  histoScale = 1/maxHisto * histogramScale;
  if (isColor)
    {
      [pathHR removeAllPoints];
      [pathHG removeAllPoints];
      [pathHB removeAllPoints];
      [pathHR moveToPoint: NSMakePoint(0, 0)];
      [pathHR moveToPoint: NSMakePoint(0, 0)];
      [pathHG moveToPoint: NSMakePoint(0, 0)];
      [pathHB moveToPoint: NSMakePoint(0, 0)];
      for (i = 0; i < UCHAR_MAX; i++)
	{
	  [pathHR lineToPoint: NSMakePoint(i, histogramR[i] * histoScale * viewHeight)];
	  [pathHG lineToPoint: NSMakePoint(i, histogramG[i] * histoScale * viewHeight)];
	  [pathHB lineToPoint: NSMakePoint(i, histogramB[i] * histoScale * viewHeight)];
	}
      [pathHR lineToPoint: NSMakePoint(viewHeight, 0)];
      [pathHG lineToPoint: NSMakePoint(viewHeight, 0)];
      [pathHB lineToPoint: NSMakePoint(viewHeight, 0)];
    }
  else
    {
      [pathHLumi removeAllPoints];
      [pathHLumi moveToPoint: NSMakePoint(0, 0)];
      for (i = 0; i < UCHAR_MAX; i++)
	{
	  [pathHLumi lineToPoint: NSMakePoint(i, histogramL[i] * histoScale * viewHeight)];
	}
      [pathHLumi lineToPoint: NSMakePoint(viewHeight, 0)];
    }

  NSLog(@"curves histogram initing ended");
}

-(void)calculateFunctions
{
  unsigned i;
  NSArray *curveL;
  
  curveL = [pathLumi values];
  for (i = 0; i <= UCHAR_MAX; i++)
    funL[i] = floor([[curveL objectAtIndex: i] floatValue]);
}

-(void)calculateTransformedHistograms
{
  unsigned long int histogramDenormLTr[UCHAR_MAX]; /* not normalized pixel count for each level */
  unsigned long int histogramDenormRTr[UCHAR_MAX]; /* not normalized pixel count for each level */
  unsigned long int histogramDenormGTr[UCHAR_MAX]; /* not normalized pixel count for each level */
  unsigned long int histogramDenormBTr[UCHAR_MAX]; /* not normalized pixel count for each level */  
  unsigned i;
  float maxHisto;
  unsigned viewHeight;
  float histoScale;
  
  [self calculateFunctions];  

  /* zero histogram */
  for (i = 0; i <= UCHAR_MAX; i++)
    {
      histogramDenormLTr[i] = 0;
      histogramDenormRTr[i] = 0;
      histogramDenormGTr[i] = 0;
      histogramDenormBTr[i] = 0;
    }

  /* derive new histogram */
  for (i = 0; i <= UCHAR_MAX; i++)
    {
      histogramDenormLTr[funL[i]] += histogramDenormL[i];
      histogramDenormRTr[funL[i]] += histogramDenormR[i];
      histogramDenormGTr[funL[i]] += histogramDenormG[i];
      histogramDenormBTr[funL[i]] += histogramDenormB[i];
    }
  
  /* normalize histogram */
  if (isColor)
    {
      maxHisto = 0;
      for (i = 0; i <= UCHAR_MAX; i++)
	{
	  histogramRTr[i] = (float)histogramDenormRTr[i] / (float)pixNum;
	  histogramGTr[i] = (float)histogramDenormGTr[i] / (float)pixNum;
	  histogramBTr[i] = (float)histogramDenormBTr[i] / (float)pixNum;
	  if (histogramRTr[i] > maxHisto)
	    maxHisto = histogramRTr[i];
	  if (histogramGTr[i] > maxHisto)
	    maxHisto = histogramGTr[i];
	  if (histogramBTr[i] > maxHisto)
	    maxHisto = histogramBTr[i];
	}
    }
  else
    {
      maxHisto = 0;
      for (i = 0; i <= UCHAR_MAX; i++)
	{
	  histogramLTr[i] = (float)histogramDenormLTr[i] / (float)pixNum;
	  if (histogramLTr[i] > maxHisto)
	    maxHisto = histogramLTr[i];
	}
    }
  
  viewHeight = 256;
  NSLog(@"transformed maxHisto L : %f for %u", maxHisto, pixNum);
  histoScale = 1/maxHisto * histogramScale;
  [pathHLumiTr removeAllPoints];
  [pathHLumiTr moveToPoint: NSMakePoint(0, 0)];
  for (i = 0; i < UCHAR_MAX; i++)
    {
      [pathHLumiTr lineToPoint: NSMakePoint(histogramLTr[i] * histoScale * viewHeight, i)];
    }
  [pathHLumiTr lineToPoint: NSMakePoint(0, viewHeight -1)];

  [pathHRTr removeAllPoints];
  [pathHGTr removeAllPoints];
  [pathHBTr removeAllPoints];
  [pathHRTr moveToPoint: NSMakePoint(0, 0)];
  [pathHGTr moveToPoint: NSMakePoint(0, 0)];
  [pathHBTr moveToPoint: NSMakePoint(0, 0)];
  for (i = 0; i < UCHAR_MAX; i++)
    {
      [pathHRTr lineToPoint: NSMakePoint(histogramRTr[i] * histoScale * viewHeight, i)];
      [pathHGTr lineToPoint: NSMakePoint(histogramGTr[i] * histoScale * viewHeight, i)];
      [pathHBTr lineToPoint: NSMakePoint(histogramBTr[i] * histoScale * viewHeight, i)];
    }
  [pathHRTr lineToPoint: NSMakePoint(0, viewHeight -1)];
  [pathHGTr lineToPoint: NSMakePoint(0, viewHeight -1)];
  [pathHBTr lineToPoint: NSMakePoint(0, viewHeight -1)];
  NSLog(@"tranformed histogram calculculation ended");
  
  
}

@end