ColorImage.cpp

/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved.                                                         */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib.  */
/*----------------------------------------------------------------------------*/

#include "ColorImage.h"

#include "WPIErrors.h"

ColorImage::ColorImage(ImageType type) : ImageBase(type)
{
}

ColorImage::~ColorImage()
{
}

BinaryImage *ColorImage::ComputeThreshold(ColorMode colorMode,
                int low1, int high1,
                int low2, int high2,
                int low3, int high3)
{
        BinaryImage *result = new BinaryImage();
        Range range1 = {low1, high1},
                range2 = {low2, high2},
                range3 = {low3, high3};
        
        int success = imaqColorThreshold(result->GetImaqImage(), m_imaqImage, 1, colorMode, &range1, &range2, &range3);
        wpi_setImaqErrorWithContext(success, "ImaqThreshold error");
        return result;
}

BinaryImage *ColorImage::ThresholdRGB(int redLow, int redHigh, int greenLow, int greenHigh, int blueLow, int blueHigh)
{
        return ComputeThreshold(IMAQ_RGB, redLow, redHigh, greenLow, greenHigh, blueLow, blueHigh);
}

BinaryImage *ColorImage::ThresholdRGB(Threshold &t)
{
        return ComputeThreshold(IMAQ_RGB, t.plane1Low, t.plane1High,
                                                                t.plane2Low, t.plane2High,
                                                                t.plane3Low, t.plane3High);
}

BinaryImage *ColorImage::ThresholdHSL(int hueLow, int hueHigh, int saturationLow, int saturationHigh, int luminenceLow, int luminenceHigh)
{
        return ComputeThreshold(IMAQ_HSL, hueLow, hueHigh, saturationLow, saturationHigh, luminenceLow, luminenceHigh);
}

BinaryImage *ColorImage::ThresholdHSL(Threshold &t)
{
        return ComputeThreshold(IMAQ_HSL, t.plane1Low, t.plane1High,
                                                                t.plane2Low, t.plane2High,
                                                                t.plane3Low, t.plane3High);
}

BinaryImage *ColorImage::ThresholdHSV(int hueLow, int hueHigh, int saturationLow, int saturationHigh, int valueLow, int valueHigh)
{
        return ComputeThreshold(IMAQ_HSV, hueLow, hueHigh, saturationLow, saturationHigh, valueLow, valueHigh);
}

BinaryImage *ColorImage::ThresholdHSV(Threshold &t)
{
        return ComputeThreshold(IMAQ_HSV, t.plane1Low, t.plane1High,
                                                                t.plane2Low, t.plane2High,
                                                                t.plane3Low, t.plane3High);
}

BinaryImage *ColorImage::ThresholdHSI(int hueLow, int hueHigh, int saturationLow, int saturationHigh, int intensityLow, int intensityHigh)
{
        return ComputeThreshold(IMAQ_HSI, hueLow, hueHigh, saturationLow, saturationHigh, intensityLow, intensityHigh);
}

BinaryImage *ColorImage::ThresholdHSI(Threshold &t)
{
        return ComputeThreshold(IMAQ_HSI, t.plane1Low, t.plane1High,
                                                                t.plane2Low, t.plane2High,
                                                                t.plane3Low, t.plane3High);
}

MonoImage *ColorImage::ExtractColorPlane(ColorMode mode, int planeNumber)
{
        MonoImage *result = new MonoImage();
        if (m_imaqImage == NULL)
                wpi_setWPIError(NullParameter);
        int success = imaqExtractColorPlanes(m_imaqImage, 
                                                                                 mode, 
                                                                                 (planeNumber == 1) ? result->GetImaqImage() : NULL, 
                                                                                 (planeNumber == 2) ? result->GetImaqImage() : NULL, 
                                                                                 (planeNumber == 3) ? result->GetImaqImage() : NULL);
        wpi_setImaqErrorWithContext(success, "Imaq ExtractColorPlanes failed");
        return result;
}

/*
 * Extract the first color plane for an image.
 * @param mode The color mode in which to operate
 * @returns a pointer to a MonoImage that is the extracted plane.
 */
MonoImage *ColorImage::ExtractFirstColorPlane(ColorMode mode)
{
        return ExtractColorPlane(mode, 1);
}

/*
 * Extract the second color plane for an image.
 * @param mode The color mode in which to operate
 * @returns a pointer to a MonoImage that is the extracted plane.
 */
MonoImage *ColorImage::ExtractSecondColorPlane(ColorMode mode)
{
        return ExtractColorPlane(mode, 2);
}

/*
 * Extract the third color plane for an image.
 * @param mode The color mode in which to operate
 * @returns a pointer to a MonoImage that is the extracted plane.
 */
MonoImage *ColorImage::ExtractThirdColorPlane(ColorMode mode)
{
        return ExtractColorPlane(mode, 3);
}

/*
 * Extract the red plane from an RGB image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetRedPlane()
{
        return ExtractFirstColorPlane(IMAQ_RGB);
}

/*
 * Extract the green plane from an RGB image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetGreenPlane()
{
    return ExtractSecondColorPlane(IMAQ_RGB);
}

/*
 * Extract the blue plane from an RGB image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetBluePlane()
{
    return ExtractThirdColorPlane(IMAQ_RGB);
}

/*
 * Extract the Hue plane from an HSL image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetHSLHuePlane()
{
        return ExtractFirstColorPlane(IMAQ_HSL);
}

/*
 * Extract the Hue plane from an HSV image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetHSVHuePlane()
{
        return ExtractFirstColorPlane(IMAQ_HSV);
}

/*
 * Extract the Hue plane from an HSI image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetHSIHuePlane()
{
        return ExtractFirstColorPlane(IMAQ_HSI);
}

/*
 * Extract the Luminance plane from an HSL image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetLuminancePlane()
{
        return ExtractThirdColorPlane(IMAQ_HSL);
}

/*
 * Extract the Value plane from an HSV image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetValuePlane()
{
        return ExtractThirdColorPlane(IMAQ_HSV);
}

/*
 * Extract the Intensity plane from an HSI image.
 * @returns a pointer to a MonoImage that is the extraced plane.
 */
MonoImage *ColorImage::GetIntensityPlane()
{
        return ExtractThirdColorPlane(IMAQ_HSI);
}

void ColorImage::ReplacePlane(ColorMode mode, MonoImage *plane, int planeNumber) {
        int success = imaqReplaceColorPlanes(m_imaqImage, 
                                                                                 (const Image*) m_imaqImage, 
                                                                             mode, 
                                                                             (planeNumber == 1) ? plane->GetImaqImage() : NULL, 
                                                                             (planeNumber == 2) ? plane->GetImaqImage() : NULL, 
                                                                             (planeNumber == 3) ? plane->GetImaqImage() : NULL);
        wpi_setImaqErrorWithContext(success, "Imaq ReplaceColorPlanes failed");
}

void ColorImage::ReplaceFirstColorPlane(ColorMode mode, MonoImage *plane)
{
        ReplacePlane(mode, plane, 1);
}

void ColorImage::ReplaceSecondColorPlane(ColorMode mode, MonoImage *plane)
{
        ReplacePlane(mode, plane, 2);
}

void ColorImage::ReplaceThirdColorPlane(ColorMode mode, MonoImage *plane)
{ 
        ReplacePlane(mode, plane, 3);
}

void ColorImage::ReplaceRedPlane(MonoImage *plane)
{
        ReplaceFirstColorPlane(IMAQ_RGB, plane);
}

void ColorImage::ReplaceGreenPlane(MonoImage *plane)
{
        ReplaceSecondColorPlane(IMAQ_RGB, plane);
}

void ColorImage::ReplaceBluePlane(MonoImage *plane)
{
        ReplaceThirdColorPlane(IMAQ_RGB, plane);
}


void ColorImage::ReplaceHSLHuePlane(MonoImage *plane)
{
        return ReplaceFirstColorPlane(IMAQ_HSL, plane);
}

void ColorImage::ReplaceHSVHuePlane(MonoImage *plane)
{
        return ReplaceFirstColorPlane(IMAQ_HSV, plane);
}

void ColorImage::ReplaceHSIHuePlane(MonoImage *plane)
{
        return ReplaceFirstColorPlane(IMAQ_HSI, plane);
}

void ColorImage::ReplaceHSLSaturationPlane(MonoImage *plane)
{
        return ReplaceSecondColorPlane(IMAQ_HSL, plane);
}

void ColorImage::ReplaceHSVSaturationPlane(MonoImage *plane)
{
        return ReplaceSecondColorPlane(IMAQ_HSV, plane);
}

void ColorImage::ReplaceHSISaturationPlane(MonoImage *plane)
{
        return ReplaceSecondColorPlane(IMAQ_HSI, plane);
}

void ColorImage::ReplaceLuminancePlane(MonoImage *plane)
{
        return ReplaceThirdColorPlane(IMAQ_HSL, plane);
}

void ColorImage::ReplaceValuePlane(MonoImage *plane)
{
        return ReplaceThirdColorPlane(IMAQ_HSV, plane);
}

void ColorImage::ReplaceIntensityPlane(MonoImage *plane)
{
        return ReplaceThirdColorPlane(IMAQ_HSI, plane);
}

//TODO: frcColorEqualize(Image* dest, const Image* source, int colorEqualization) needs to be modified
//The colorEqualization parameter is discarded and is set to TRUE in the call to imaqColorEqualize.
void ColorImage::Equalize(bool allPlanes)
{
        // Note that this call uses NI-defined TRUE and FALSE
        int success = imaqColorEqualize(m_imaqImage, (const Image*) m_imaqImage, (allPlanes) ? TRUE : FALSE);
        wpi_setImaqErrorWithContext(success, "Imaq ColorEqualize error");
}

void ColorImage::ColorEqualize()
{
        Equalize(true);
}

void ColorImage::LuminanceEqualize()
{
        Equalize(false);
}