dmbilinear.c

Go to the documentation of this file.

#include "dmbilinear.h"


void CfaFlatten(float *Flat, const float *Input, int Width, int Height,
    int RedX, int RedY)
{
    const float *InputRed = Input;
    const float *InputGreen = Input + Width*Height;
    const float *InputBlue = Input + 2*Width*Height;
    const int Green = 1 - ((RedX + RedY) & 1);
    int i, x, y;

    
    for(y = 0, i = 0; y < Height; y++)
        for(x = 0; x < Width; x++, i++)
        {
            if(((x + y) & 1) == Green)
                Flat[i] = InputGreen[i];
            else if((y & 1) == RedY)
                Flat[i] = InputRed[i];
            else
                Flat[i] = InputBlue[i];
        }
}


void BilinearDifference(float *Output, const float *Diff,
    int Width, int Height, int RedX, int RedY)
{
    const int NumPixels = Width*Height;
    const int Green = 1 - ((RedX + RedY) & 1);
    float *OutputRed = Output;
    float *OutputGreen = Output + NumPixels;
    float *OutputBlue = Output + 2*NumPixels;
    float AverageH, AverageV, AverageX;
    int x, y, i;
    
    
    for(y = 0, i = 0; y < Height; y++)
    {
        for(x = 0; x < Width; x++, i++)
        {
            /* The following computes three quantities:
             *   AverageH: average of the horizontal neighbors
             *   AverageV: average of the vertical neighbors
             *   AverageX: average of the diagonal neighbors
             *
             * Near a boundary, the average is computed using only those
             * samples which are defined in the image.  For example on the left
             * boundary of the image, the left neighbors are omitted and
             * AverageH is simply set to the value of the right neighbor.
             */
            if(y == 0)
            {
                AverageV = Diff[i + Width];
                
                if(x == 0)
                {
                    AverageH = Diff[i + 1];
                    AverageX = Diff[i + 1 + Width];
                }
                else if(x < Width - 1)
                {
                    AverageH = (Diff[i - 1] + Diff[i + 1]) / 2;
                    AverageX = (Diff[i - 1 + Width] + Diff[i + 1 + Width]) / 2;
                }
                else
                {
                    AverageH = Diff[i - 1];
                    AverageX = Diff[i - 1 + Width];
                }
                
            }
            else if(y < Height - 1)
            {
                AverageV = (Diff[i - Width] + Diff[i + Width]) / 2;
                
                if(x == 0)
                {
                    AverageH = Diff[i + 1];
                    AverageX = (Diff[i + 1 - Width] + Diff[i + 1 + Width]) / 2;
                }
                else if(x < Width - 1)
                {
                    AverageH = (Diff[i - 1] + Diff[i + 1]) / 2;
                    AverageX = (Diff[i - 1 - Width] + Diff[i + 1 - Width]
                        + Diff[i - 1 + Width] + Diff[i + 1 + Width]) / 4;
                }
                else
                {
                    AverageH = Diff[i - 1];
                    AverageX = (Diff[i - 1 - Width] + Diff[i - 1 + Width]) / 2;
                }
            }
            else
            {
                AverageV = Diff[i - Width];
                
                if(x == 0)
                {
                    AverageH = Diff[i + 1];
                    AverageX = Diff[i + 1 - Width];
                }
                else if(x < Width - 1)
                {
                    AverageH = (Diff[i - 1] + Diff[i + 1]) / 2;
                    AverageX = (Diff[i - 1 - Width] + Diff[i + 1 - Width]) / 2;
                }
                else
                {
                    AverageH = Diff[i - 1];
                    AverageX = Diff[i - 1 - Width];
                }
            }

            if(((x + y) & 1) == Green)
            {
                if((y & 1) == RedY)
                {
                    /* Left and right neighbors are red */
                    OutputRed[i] = OutputGreen[i] + AverageH;
                    OutputBlue[i] = OutputGreen[i] + AverageV;
                }
                else
                {
                    /* Left and right neighbors are blue */
                    OutputRed[i] = OutputGreen[i] + AverageV;
                    OutputBlue[i] = OutputGreen[i] + AverageH;
                }
            }
            else
            {
                if((y & 1) == RedY)
                {
                    /* Center pixel is red */
                    OutputRed[i] = OutputGreen[i] + Diff[i];
                    OutputBlue[i] = OutputGreen[i] + AverageX;
                }
                else
                {
                    /* Center pixel is blue */
                    OutputRed[i] = OutputGreen[i] + AverageX;
                    OutputBlue[i] = OutputGreen[i] + Diff[i];
                }
            }
        }
    }
}


void BilinearDemosaic(float *Output, const float *Input, int Width, int Height,
    int RedX, int RedY)
{
    float *OutputRed = Output;
    float *OutputGreen = Output + Width*Height;
    float *OutputBlue = Output + 2*Width*Height;
    const int Green = 1 - ((RedX + RedY) & 1);
    float AverageH, AverageV, AverageC, AverageX;
    int i, x, y;
        

    for(y = 0, i = 0; y < Height; y++)
    {
        for(x = 0; x < Width; x++, i++)
        {
            /* The following computes four quantities:
             *   AverageH: average of the horizontal neighbors
             *   AverageV: average of the vertical neighbors
             *   AverageC: average of the axial neighbors
             *   AverageX: average of the diagonal neighbors
             *
             * Near a boundary, the average is computed using only those
             * samples which are defined in the image.  For example on the left
             * boundary of the image, the left neighbors are omitted and
             * AverageH is simply set to the value of the right neighbor.
             */
            if(y == 0)
            {
                AverageV = Input[i + Width];
                
                if(x == 0)
                {
                    AverageH = Input[i + 1];
                    AverageC = (Input[i + 1] + Input[i + Width])/2;
                    AverageX = Input[i + 1 + Width];
                }
                else if(x < Width - 1)
                {
                    AverageH = (Input[i - 1] + Input[i + 1]) / 2;
                    AverageC = (Input[i - 1] + Input[i + 1]
                        + Input[i + Width])/3;
                    AverageX = (Input[i - 1 + Width]
                        + Input[i + 1 + Width]) / 2;
                }
                else
                {
                    AverageH = Input[i - 1];
                    AverageC = (Input[i - 1] + Input[i + Width])/2;
                    AverageX = Input[i - 1 + Width];
                }
            }
            else if(y < Height - 1)
            {
                AverageV = (Input[i - Width] + Input[i + Width]) / 2;
                
                if(x == 0)
                {
                    AverageH = Input[i + 1];
                    AverageC = (Input[i + 1] +
                        Input[i - Width] + Input[i + Width]) / 3;
                    AverageX = (Input[i + 1 - Width]
                        + Input[i + 1 + Width]) / 2;
                }
                else if(x < Width - 1)
                {
                    AverageH = (Input[i - 1] + Input[i + 1]) / 2;
                    AverageC = (AverageH + AverageV) / 2;
                    AverageX = (Input[i - 1 - Width] + Input[i + 1 - Width]
                        + Input[i - 1 + Width] + Input[i + 1 + Width]) / 4;
                }
                else
                {
                    AverageH = Input[i - 1];
                    AverageC = (Input[i - 1] +
                        Input[i - Width] + Input[i + Width]) / 3;
                    AverageX = (Input[i - 1 - Width]
                        + Input[i - 1 + Width]) / 2;
                }
            }
            else
            {
                AverageV = Input[i - Width];
                
                if(x == 0)
                {
                    AverageH = Input[i + 1];
                    AverageC = (Input[i + 1] + Input[i - Width]) / 2;
                    AverageX = Input[i + 1 - Width];
                }
                else if(x < Width - 1)
                {
                    AverageH = (Input[i - 1] + Input[i + 1]) / 2;
                    AverageC = (Input[i - 1]
                        + Input[i + 1] + Input[i - Width]) / 3;
                    AverageX = (Input[i - 1 - Width]
                        + Input[i + 1 - Width]) / 2;
                }
                else
                {
                    AverageH = Input[i - 1];
                    AverageC = (Input[i - 1] + Input[i - Width]) / 2;
                    AverageX = Input[i - 1 - Width];
                }
            }
            
            if(((x + y) & 1) == Green)
            {
                /* Center pixel is green */
                OutputGreen[i] = Input[i];
                
                if((y & 1) == RedY)
                {
                    /* Left and right neighbors are red */
                    OutputRed[i] = AverageH;
                    OutputBlue[i] = AverageV;
                }
                else
                {
                    /* Left and right neighbors are blue */
                    OutputRed[i] = AverageV;
                    OutputBlue[i] = AverageH;
                }
            }
            else
            {
                OutputGreen[i] = AverageC;
                
                if((y & 1) == RedY)
                {
                    /* Center pixel is red */
                    OutputRed[i] = Input[i];
                    OutputBlue[i] = AverageX;
                }
                else
                {
                    /* Center pixel is blue */
                    OutputRed[i] = AverageX;
                    OutputBlue[i] = Input[i];
                }
            }
        }
    }
}