<languageVersion: 1.0;>
  
  kernel IsolateColor
  <
      namespace:      "com.bobs27";
      vendor:         "Todd Yard";
      version:        1;
      description:    "Isolates hue in image.";
  >
  {
  
      parameter int3 color
      <
          minValue:       int3(0, 0, 0);
          maxValue:       int3(255, 255, 255);
          defaultValue:   int3(255, 0, 0);
          description:    "The color to isolate.";
      >;
  
      parameter int hueThreshold
      <
          minValue:       int(0);
          maxValue:       int(360);
          defaultValue:   int(10);
          description:    "The amount off-hue to allow.";
      >;
  
      parameter int luminanceThreshold
      <
          minValue:       int(0);
          maxValue:       int(255);
          defaultValue:   int(100);
          description:    "The amount off-luminance to allow.";
      >;
  
      parameter int hideNonIsolated
      <
          minValue:       int(0);
          maxValue:       int(1);
          defaultValue:   int(0);
          description:    "Whether alpha of 0 should be applied to non-isolated pixels.";
      >;
  
      const float3 grayValues = float3(0.3, 0.59, 0.11);
      
      input image4 source;
      output pixel4 result;
      
      void
      evaluatePixel()
      {
      
          float4 px = sampleNearest(source, outCoord());
  
          // determine hue of color to isolate, between 0 and 360
          int hue = 0;
          int r = color.r;
          int g = color.g;
          int b = color.b;
          if (r == g && g == b) {
              hue = 0;
          } else if (r >= g && g >= b) {
              hue = 60 * (g - b)/(r - b);
          } else if (g >= r && r >= b) {
              hue = 60 + 60*(g - r)/(g - b);
          } else if (g >= b && b >= r) {
              hue = 120 + 60*(b - r)/(g - r);
          } else if (b >= g && g >= r) {
              hue = 180 + 60*(b - g)/(b - r);
          } else if (b >= r && r >= g){
              hue = 240 + 60*(r - g)/(b - g);
          } else if (r >= b && b >= g) {
              hue = 300 + 60*(r - b)/(r - g);
          }
          float isolateHue = float(hue);
          
          // determine hue of color current pixel being evaluated, between 0 and 360
          hue = 0;
          r = int(px.r * 255.0);
          g = int(px.g * 255.0);
          b = int(px.b * 255.0);
          if (r == g && g == b) {
              hue = 0;
          } else if (r >= g && g >= b) {
              hue = 60 * (g - b)/(r - b);
          } else if (g >= r && r >= b) {
              hue = 60 + 60*(g - r)/(g - b);
          } else if (g >= b && b >= r) {
              hue = 120 + 60*(b - r)/(g - r);
          } else if (b >= g && g >= r) {
              hue = 180 + 60*(b - g)/(b - r);
          } else if (b >= r && r >= g){
              hue = 240 + 60*(r - g)/(b - g);
          } else if (r >= b && b >= g) {
              hue = 300 + 60*(r - b)/(r - g);
          }
          float pixelHue = float(hue);
          
          // since hue "wraps" around the 360 degrees, do some manipulation so that
          // values can be more easily evaluated when too close to end of spectrum
          if (pixelHue - float(hueThreshold) < 0.0 && isolateHue + float(hueThreshold) > 360.0) {
              pixelHue = 360.0 - float(hueThreshold);
          } else if (pixelHue + float(hueThreshold) > 360.0 && isolateHue - float(hueThreshold) < 0.0) {
              pixelHue = float(hueThreshold) - 360.0;
          }
          
          // determine the luminance/brightness/value of colors
          float pixelLuminance = px.r * 0.3 + 
                                 px.g * 0.59 +
                                 px.b * 0.11;
          float isolateLuminance = float(color.r)/255.0 * 0.3 + 
                                   float(color.g)/255.0 * 0.59 +
                                   float(color.b)/255.0 * 0.11;
         
          // if luminance and hue are NOT within thresholds...
         if (abs(pixelHue - isolateHue) > float(hueThreshold) ||
              abs(pixelLuminance - isolateLuminance) > float(luminanceThreshold)/255.0
          ) {
              // either hide pixel completely by setting alpha to 0
              if (hideNonIsolated == 1) {
                  px.a = 0.0;
              // or recolor pixel to grayscale
              } else {
                  float distanceToDesaturatedValues = dot(px.rgb, grayValues);
                  px.rgb = float3(distanceToDesaturatedValues);
              }
          }
  
          result = px;
          
      }
      
  }