bool IPNGHandler::saveImage(const std::string fileName, const PixelBuffer* bufferToSave)
{
bool success = false;
png_image image;
memset(&image, 0, (sizeof image));
image.height = bufferToSave->getHeight();
image.width = bufferToSave->getWidth();
image.version = PNG_IMAGE_VERSION;
image.opaque = NULL;
image.format = PNG_FORMAT_RGBA;
png_bytep buffer = new png_byte[PNG_IMAGE_SIZE(image)];
for (int y = image.height-1; y >= 0; y--) {
for (int x = 0; x < image.width; x++) {
ColorData currentPixel = bufferToSave->getPixel(x, y);
buffer[((image.height-(y+1))*image.width+x)*4] = (png_byte) (currentPixel.getRed()*255.0);
buffer[((image.height-(y+1))*image.width+x)*4+1] = (png_byte) (currentPixel.getGreen()*255.0);
buffer[((image.height-(y+1))*image.width+x)*4+2] = (png_byte) (currentPixel.getBlue()*255.0);
buffer[((image.height-(y+1))*image.width+x)*4+3] = (png_byte) (currentPixel.getAlpha()*255.0);
}
}
if (png_image_write_to_file(&image, fileName.c_str(), 0/*convert_to_8bit*/,
buffer, 0/*row_stride*/, NULL/*colormap*/) != 0) {
success = true;
} else {
success = false;
}
delete[] buffer;
return success;
}
void TBlur::applyToBuffer(int toolX, int toolY, ColorData toolColor, PixelBuffer* buf)
{
int left_bound = toolX-15;
int right_bound = toolX+15;
int lower_bound = toolY-15;
int upper_bound = toolY+15;
int x;
int y;
int width = right_bound - left_bound;
int height = upper_bound - lower_bound;
ColorData *colorArray = new ColorData[width*height];
for(x = left_bound; x < right_bound; x++)
for(y = lower_bound; y < upper_bound; y++)
{
int filterY;
int filterX;
float red = 0.f;
float green = 0.f;
float blue = 0.f;
//multiply every value of the filter with corresponding image pixel
for(filterX = 0; filterX < t_kernel->getWidth(); filterX++)
for(filterY = 0; filterY < t_kernel->getHeight(); filterY++)
{
float multiplier = t_kernel->getValue(filterX,filterY)/t_kernel->getFactor();
int offsetX = x-1+filterX;
int offsetY = y-1+filterY;
ColorData oldColor;
if (offsetX>=0 && offsetX < buf->getWidth() && offsetY>=0 && offsetY < buf->getHeight())
oldColor = buf->getPixel(offsetX,offsetY);
red = red + oldColor.getRed() * multiplier;
green = green + oldColor.getGreen() * multiplier;
blue = blue + oldColor.getBlue() * multiplier;
}
//truncate
if (red < 0) red = 0;
if (green <0) green = 0;
if (blue <0 ) blue = 0;
if (red >1) red = 1;
if (green >1) green =1;
if (blue >1) blue = 1;
//store the value
colorArray[width*(y-lower_bound)+(x-left_bound)] = ColorData(red,green,blue);
}
for(int x = left_bound; x < right_bound; x++)
for(int y = lower_bound; y < upper_bound; y++)
{
if (x>=0 && x < buf->getWidth() && y >=0 && y < buf->getHeight())
buf->setPixel(x, y, colorArray[width*(y-lower_bound)+(x-left_bound)]);
}
}
PixelBuffer * Filter::generateFilteredBuffer(const PixelBuffer & input_buffer) {
PixelBuffer * output_buffer = new PixelBuffer(input_buffer.getWidth(), input_buffer.getHeight(), input_buffer.getBackground());
for (int i = 0; i < input_buffer.getWidth(); i++) {
for (int j = 0; j < input_buffer.getHeight(); j++) {
ColorData p = generatePixel(input_buffer, i, j);
output_buffer->setPixel(i, j, p.clampedColor());
}
}
return output_buffer;
}
void Highlighter::draw(PixelBuffer *background, int x, int y){
for (int i=0; i<15; i++){
for (int c = 0; c < 5; c++){
ColorData get = background->getPixel(x-2+c, y-7+i);
// float s=0.2126*red + 0.7152*green + 0.0722*blue;
// float i=s*0.4;
const ColorData& color = ColorData(red * m_mask[i][c]*get.getLuminance()+ (1-m_mask[i][c]*get.getLuminance())* get.getRed(),green * m_mask[i][c]*get.getLuminance() + (1-m_mask[i][c]*get.getLuminance()) * get.getGreen(), blue *m_mask[i][c]*get.getLuminance() + (1-m_mask[i][c]*get.getLuminance()) * get.getBlue());
background->setPixel(x-2+c,y-7+i,color);
}
}
}
void ImageManager::ApplyBorder(ILuint DevilImageID, int32_t BorderColorID)
{
ilBindImage(DevilImageID);
uint8_t* ImageData = ilGetData();
uint32_t bpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
uint32_t width = ilGetInteger(IL_IMAGE_WIDTH);
uint32_t height = ilGetInteger(IL_IMAGE_HEIGHT);
uint8_t Red, Green, Blue;
ColorData* BorderColor = DATA->getColorData(BorderColorID);
if(BorderColor != NULL)
{
Red = BorderColor->getRed();
Green = BorderColor->getGreen();
Blue = BorderColor->getBlue();
if(ImageData != NULL)
{
for(uint32_t i = 0; i < width; i++)
{
ImageData[(i * width * bpp) + 0] = Blue; // Blue
ImageData[(i * width * bpp) + 1] = Green; // Green
ImageData[(i * width * bpp) + 2] = Red; // Red
ImageData[(i * width * bpp) + 3] = 255; // Alpha
ImageData[(i * width * bpp) + ((height - 1) * bpp) + 0] = Blue; // Blue
ImageData[(i * width * bpp) + ((height - 1) * bpp) + 1] = Green; // Green
ImageData[(i * width * bpp) + ((height - 1) * bpp) + 2] = Red; // Red
ImageData[(i * width * bpp) + ((height - 1) * bpp) + 3] = 255; // Alpha
}
for(uint32_t j = 0; j < height; j++)
{
ImageData[((width - 1) * height * bpp) + (j * bpp) + 0] = Blue; // Blue
ImageData[((width - 1) * height * bpp) + (j * bpp) + 1] = Green; // Green
ImageData[((width - 1) * height * bpp) + (j * bpp) + 2] = Red; // Red
ImageData[((width - 1) * height * bpp) + (j * bpp) + 3] = 255; // Alpha
ImageData[(j * bpp) + 0] = Blue; // Blue
ImageData[(j * bpp) + 1] = Green; // Green
ImageData[(j * bpp) + 2] = Red; // Red
ImageData[(j * bpp) + 3] = 255; // Alpha
}
}
}
}
/// A filter that reduce the number of possible colors by binning each color value into the the
///number of bins specified.
/// Inherits from Filter
ColorData FQuantize::generatePixel(const PixelBuffer &buffer, int x, int y) const {
ColorData c = buffer.getPixel(x, y);
float red = c.getRed();
float blue = c.getBlue();
float green = c.getGreen();
int steps = m_bins-1;
red = round(red*steps)/steps;
green = round(green*steps)/steps;
blue = round(blue*steps)/steps;
ColorData output(red, green, blue);
return output;
}
// Default implementation of 2D convolution
void ConvolutionTool::applyToolOnCanvas(PixelBuffer* pixel_buffer){
// check if the tool mask is valid
if(m_mask == NULL){
cerr << "[ConvolutionTool] mask is null" << endl;
return;
}
// Dimensions of the canvas and mask
int width = pixel_buffer->getWidth();
int height = pixel_buffer->getHeight();
int mw = m_mask->getWidth();
int mh = m_mask->getHeight();
// Coordinates to access the canvas
int posx,posy;
// Declare variable to store intermediate results
ColorData tmp;
PixelBuffer tmpPb(width,height, ColorData(0.0,0.0,0.0));
// 2D Convolution
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
tmp = ColorData(0.0,0.0,0.0);
// Multiply every value of the mask a corresponding image pixel
for(int mx = 0; mx < mw; mx++){
for(int my = 0; my < mh; my++){
posx = (x - mw / 2 + mx);
posy = (y - mh / 2 + my);
// If trying to access out of bounds indicies, skip
if(posx < 0 || posy < 0 || posx >= width || posy >= height) continue;
// Accumulate values
tmp = tmp + (pixel_buffer->getPixel(posx,posy) * m_mask->getValue(mx,my));
}
}
tmpPb.setPixel(x,y,tmp.clampedColor());
}
}
// Set result
PixelBuffer::copyPixelBuffer(&tmpPb,pixel_buffer);
}
///apply filter effect to PixelBuffer* buffer passed into this function
void FThreshold::applyFilter(PixelBuffer * imageBuffer){
int width = imageBuffer -> getWidth();
int height = imageBuffer -> getHeight();
float threshold = getFloatParameter();
for(int i = 0; i < width; i++){
for(int j = 0; j < height; j++){
ColorData currPixel = imageBuffer -> getPixel(i, j);
// if the grayscale is larger than parameter, then set pixel as white
// otherwise, set current pixel as black
int newRed = currPixel.getRed() > threshold ? 1.0: 0.0;
int newBlue = currPixel.getBlue() > threshold ? 1.0 : 0.0;
int newGreen = currPixel.getGreen() > threshold ? 1.0 : 0.0;
imageBuffer -> setPixel(i, j, ColorData(newRed, newGreen, newBlue));
}
}
}
static jintArray movie_frameColorData(JNIEnv* env, jobject movie,jint frameIndex){
jintArray colIntArray = NULL;
GifMovie* m = J2Movie(env, movie);
if(m!=NULL&&frameIndex>=0){
ColorData *data = m->getFrameColorData(frameIndex);
if(data!=NULL){
int width = data->getWidth();
int height = data->getHeight();
int *col = data->getColorData();
if(width>0&&height>0&&col!=NULL){
colIntArray = env->NewIntArray(width*height);
env->SetIntArrayRegion(colIntArray,0,width*height,col);
}
}
}
return colIntArray;
}
void JpegFacade::save(int width,int height, PixelBuffer* pixelbuffer){
int r,g,b,a;
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE *outfile = fopen(m_filename.c_str(), "wb");
JSAMPROW buffer[1];
//int row_stride;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jpeg_stdio_dest(&cinfo, outfile);
cinfo.image_width = width;
cinfo.image_height = height;
cinfo.input_components = 3;
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
jpeg_set_quality(&cinfo, 100, TRUE);
jpeg_start_compress(&cinfo, TRUE);
//row_stride = cinfo.image_width * 3;
//(unsigned char*)raw_image = (unsigned char*)malloc( cinfo.image_width*cinfo.image_height*cinfo.num_components );
//number of total elements per row
buffer[0] = (unsigned char *)malloc( cinfo.image_width*cinfo.num_components );
int row_stride = cinfo.image_width*cinfo.input_components;
while (cinfo.next_scanline < cinfo.image_height) {
//buffer[0] = &raw_image[ cinfo.next_scanline * cinfo.image_width * cinfo.input_components];
for (int i = 0 ; i < row_stride; i=i+3){
ColorData color = pixelbuffer->getPixel((int)i/3,cinfo.image_height-cinfo.next_scanline-1);
r = color.getRed()*255;
g = color.getGreen()*255;
b = color.getBlue()*255;
buffer[0][i] = r;
buffer[0][i+1] = g;
buffer[0][i+2] = b;
}
(void) jpeg_write_scanlines(&cinfo, buffer, 1);
}
//Don't need to motify, save memory
jpeg_finish_compress(&cinfo);
fclose(outfile);
delete buffer[0];
jpeg_destroy_compress(&cinfo);
}
void F_Channels::applyFilter(PixelBuffer *canvas)
{
ColorData curColor;
float red;
float green;
float blue;
for(int curX = 0; curX < canvas->getWidth(); curX++)
{
for (int curY = 0; curY < canvas->getHeight(); curY++)
{
curColor = canvas->getPixel(curX, curY);
red = curColor.getRed() * m_filterParameter.red;
green = curColor.getGreen() * m_filterParameter.green;
blue = curColor.getBlue() * m_filterParameter.blue;
canvas->setPixel(curX, curY, ColorData(red, green, blue));
}
}
}
void Tool::Apply(int x, int y, int m_height, PixelBuffer* m_displayBuffer, ColorData color)
{
x = x - centerX;
y = y + centerY;
float trans;
for (int i = 0; i < maskHeight; i++)
{
for (int j = 0; j < maskWidth; j++)
{
trans = mask[i][j];
ColorData curColor = m_displayBuffer->getPixel(x + j, m_height - y + i);
if (mask[i][j] < 1 && mask[i][j] > 0){
trans = curColor.getLuminance() * mask[i][j];
//std::cout << "High " << trans << std::endl; //fot test only
//std::cout << "High2 " << mask[i][j] << std::endl; //fot test only
}
m_displayBuffer->setPixel(x + j, m_height - y + i, color * trans + curColor * (1 - trans));
}
}
}
///Tells you if x and y are equal colors
bool FillTool::compareColorData(ColorData x, ColorData y) {
if (x.getRed() == y.getRed() && x.getBlue() == y.getBlue() && x.getGreen() == y.getGreen()) {
return true;
} else {
return false;
}
}
//applies kernel to one pixel, modifies temporary buffer
void ConvolutionFilter::applyKernel(int x, int y,PixelBuffer *buf, PixelBuffer *temp)
{
float r=0,g=0,b=0;
int i,j,xloc,yloc,w,h;
ColorData pixel;
w = buf->getWidth();
h = buf->getHeight();
for (i = 0; i < kernelSize; i++)
{
for (j = 0; j < kernelSize; j++)
{
xloc = x+i-(kernelSize/2);
yloc = y+j-(kernelSize/2);
if (xloc > -1 && xloc < w && yloc > -1 && yloc < h)
{
pixel = buf -> getPixel(x + i - (kernelSize/2),y + j - (kernelSize/2));
r += (kernel[i][j] * pixel.getRed());
g += (kernel[i][j] * pixel.getGreen());
b += (kernel[i][j] * pixel.getBlue());
}
}
}
temp -> setPixel(x,y,ColorData(r,g,b));
}
void Saturation::applyFilter(PixelBuffer* buffer, float saturation_amount)
{
cout<<"Saturation";
for (int x = 0; x < buffer->getWidth(); x ++)
{
for (int y = 0; y < buffer->getHeight(); y++)
{
ColorData currentColor = buffer->getPixel(x,y);
float luminence = currentColor.getLuminance();
ColorData newColor = ColorData(0,0,0);
float redChannel = currentColor.getRed();
float greenChannel = currentColor.getGreen();
float blueChannel = currentColor.getBlue();
float redDifference = (redChannel - luminence) * saturation_amount;
float greenDifference = (greenChannel - luminence) * saturation_amount;
float blueDifference = (blueChannel - luminence) * saturation_amount;
newColor.setRed(luminence + redDifference);
newColor.setGreen(luminence + greenDifference);
newColor.setBlue(luminence + blueDifference);
buffer->setPixel(x,y,newColor);
}
}
}
void Stamp::applyToolOnCanvas(PixelBuffer * canvas){
int c_width = canvas->getWidth();
int c_height = canvas->getHeight();
int s_width = m_stamp->getWidth();
int s_height = m_stamp->getHeight();
for(int i = 0; i < s_width; i++){
for(int j = 0; j < s_height; j++){
// position on canvas
int cur_x = m_startPointx + i - s_width / 2;
int cur_y = m_startPointy + j - s_height / 2;
if(cur_x < 0 || cur_y < 0 || cur_x >= canvas->getWidth() || cur_y >= canvas->getHeight()){
continue;
}
ColorData c = m_stamp->getPixel(i,j);
c.setRed(c.getRed() * m_r);
c.setGreen(c.getGreen() * m_g);
c.setBlue(c.getBlue() * m_b);
canvas->setPixel(cur_x,cur_y,c);
}
}
}
///apply filter effect to the PixelBuffer* buffer passed into this function
void FBlur::applyFilter(PixelBuffer* imageBuffer){
// if kernel is already initialized, do not need initialize it again.
kernel = buildKernel(std::round(getFloatParameter()));
// printKernel();
if(getName() == "FEdgeDetection"){
imageBuffer -> convertToLuminance();
}
int width = imageBuffer -> getWidth();
int height = imageBuffer -> getHeight();
//create a new pixel buffer for storing the convolution result.
PixelBuffer* newImageBuffer
= new PixelBuffer(width, height, imageBuffer -> getBackgroundColor());
for(int i = 0; i < width; i++){
for(int j = 0; j < height; j++){
float newRed = 0;
float newGreen = 0;
float newBlue = 0;
for(size_t filterI = 0; filterI < kernel.size(); filterI++){
for(size_t filterJ = 0; filterJ < kernel[filterI].size(); filterJ++){
//The location imageI and imageJ is calculated so that
//for the center element of the filter it'll be i, j
int imageI = (i - kernel.size()/2 + filterI + width) % width;
int imageJ = (j - kernel[filterI].size()/2 + filterJ + height) % height;
ColorData currPixel = imageBuffer -> getPixel(imageI, imageJ);
newRed += currPixel.getRed() * kernel[filterI][filterJ];
newGreen += currPixel.getGreen()*kernel[filterI][filterJ];
newBlue += currPixel.getBlue()*kernel[filterI][filterJ];
}
}
ColorData newPixel = ColorData(newRed, newGreen, newBlue);
newPixel = newPixel.clampedColor();
newImageBuffer -> setPixel(i, j, newPixel);
}
}
newImageBuffer -> copyPixelBuffer(newImageBuffer, imageBuffer);
delete newImageBuffer;
}
ColorData TStamp::processPixel(int maskX, int maskY, ColorData toolColor, PixelBuffer* buffer, int bufferX, int bufferY)
{
ColorData stampColor = TStamp::m_stampBuffer->getPixel(maskX, maskY);
stampColor.setRed(toolColor.getRed() * stampColor.getRed());
stampColor.setGreen(toolColor.getGreen() * stampColor.getGreen());
stampColor.setBlue(toolColor.getBlue() * stampColor.getBlue());
float alpha = stampColor.getAlpha();
return stampColor*alpha + buffer->getPixel(bufferX, bufferY)*(1-alpha);
}
ILuint ImageManager::GeneratedOverLayImage(ILuint TextureDevILID, int16_t PrimaryColorID, int16_t BorderColorID)
{
ILuint TextureImageID;
ilGenImages(1, &TextureImageID);
ilBindImage(TextureImageID);
ilCopyImage(TextureDevILID);
ilConvertImage(IL_LUMINANCE_ALPHA, IL_UNSIGNED_BYTE);
uint8_t* TextureImageData = ilGetData();
uint32_t width = ilGetInteger(IL_IMAGE_WIDTH);
uint32_t height = ilGetInteger(IL_IMAGE_HEIGHT);
ColorData* PrimaryColor = DATA->getColorData(PrimaryColorID);
ILuint NewImageID;
ilGenImages(1, &NewImageID);
ilBindImage(NewImageID);
ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL);
uint8_t* NewImageData = ilGetData();
uint32_t bpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
if(PrimaryColor != NULL)
{
for(uint32_t i = 0; i < width; i++)
{
for(uint32_t j = 0; j < height; j++)
{
float Base = TextureImageData[(i * width * 2) + (j * 2) + 0];
uint8_t Alpha = TextureImageData[(i * width * 2) + (j * 2) + 1];
Base /= 255.0;
float OriginalBlue = PrimaryColor->getBlue();
OriginalBlue /= 255.0;
float OriginalGreen = PrimaryColor->getGreen();
OriginalGreen /= 255.0;
float OriginalRed = PrimaryColor->getRed();
OriginalRed /= 255.0;
// coloring using overlay mode
if(Base >= 0.5)
{
NewImageData[(i * width * bpp) + (j * bpp) + 0] = (1.0 - 2.0 * (1.0 - OriginalBlue) * (1.0 - Base)) * 255; // Blue
NewImageData[(i * width * bpp) + (j * bpp) + 1] = (1.0 - 2.0 * (1.0 - OriginalGreen) * (1.0 - Base)) * 255; // Green
NewImageData[(i * width * bpp) + (j * bpp) + 2] = (1.0 - 2.0 * (1.0 - OriginalRed) * (1.0 - Base)) * 255; // Red
NewImageData[(i * width * bpp) + (j * bpp) + 3] = Alpha;
}
else
{
NewImageData[(i * width * bpp) + (j * bpp) + 0] = (2.0 * OriginalBlue * Base) * 255; // Blue
NewImageData[(i * width * bpp) + (j * bpp) + 1] = (2.0 * OriginalGreen * Base) * 255; // Green
NewImageData[(i * width * bpp) + (j * bpp) + 2] = (2.0 * OriginalRed * Base) * 255; // Red
NewImageData[(i * width * bpp) + (j * bpp) + 3] = Alpha;
}
}
}
}
if (BorderColorID != -1)
{
ApplyBorder(NewImageID, BorderColorID);
}
return NewImageID;
}
ILuint ImageManager::GenerateGradientImage(ILuint TextureDevILID, int16_t PrimaryColorID, int16_t SecondaryColorID, int16_t BorderColorID)
{
ILuint TextureImageID;
ilGenImages(1, &TextureImageID);
ilBindImage(TextureImageID);
ilCopyImage(TextureDevILID);
ilConvertImage(IL_LUMINANCE, IL_UNSIGNED_BYTE); //Load as IL_LUMINANCE to avoid convertion?
uint8_t* TextureImageData = ilGetData();
uint32_t width = ilGetInteger(IL_IMAGE_WIDTH);
uint32_t height = ilGetInteger(IL_IMAGE_HEIGHT);
ILuint MaskImageID;
ilGenImages(1, &MaskImageID);
ilBindImage(MaskImageID);
ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL);
uint8_t* MaskImageData = ilGetData();
ColorData* PrimaryColor = DATA->getColorData(PrimaryColorID);
ColorData* SecondaryColor = DATA->getColorData(SecondaryColorID);
uint32_t bpp = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
if(SecondaryColor != NULL)
{
for(uint32_t i = 0; i < width; i++)
{
for(uint32_t j = 0; j < height; j++)
{
MaskImageData[(i * width * bpp) + (j * bpp) + 0] = SecondaryColor->getBlue(); // Blue
MaskImageData[(i * width * bpp) + (j * bpp) + 1] = SecondaryColor->getGreen(); // Green
MaskImageData[(i * width * bpp) + (j * bpp) + 2] = SecondaryColor->getRed(); // Red
MaskImageData[(i * width * bpp) + (j * bpp) + 3] = 255 - TextureImageData[(i * width) + j]; // Alpha
}
}
}
ILuint NewImageID;
ilGenImages(1, &NewImageID);
ilBindImage(NewImageID);
ilTexImage(width, height, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL);
uint8_t* NewImageData = ilGetData();
if(PrimaryColor != NULL)
{
for(uint32_t i = 0; i < width; i++)
{
for(uint32_t j = 0; j < height; j++)
{
NewImageData[(i * width * bpp) + (j * bpp) + 0] = PrimaryColor->getBlue(); // Blue
NewImageData[(i * width * bpp) + (j * bpp) + 1] = PrimaryColor->getGreen(); // Green
NewImageData[(i * width * bpp) + (j * bpp) + 2] = PrimaryColor->getRed(); // Red
NewImageData[(i * width * bpp) + (j * bpp) + 3] = 255; // Alpha
}
}
}
ilOverlayImage(MaskImageID, 0, 0, 0);
if (BorderColorID != -1)
{
ApplyBorder(NewImageID, BorderColorID);
}
return NewImageID;
}
void TStamp::applyStamp(int toolX, int toolY, PixelBuffer* buffer, PixelBuffer* stamp, ColorData stampColorAdjust)
{
int stampHeight = stamp->getHeight();
int stampWidth = stamp->getWidth();
int stampX = 0;
int stampY = 0;
for (int x = toolX - (stampWidth/2); x <toolX + (stampWidth/2); x++)
{
stampY = 0;
for (int y = toolY - (stampHeight/2); y<toolY + (stampHeight/2); y++)
{
ColorData stampColor = ColorData(0,0,0,0);
ColorData bufferColor = ColorData(0,0,0,0);
if (!(x <= 0 || x >= buffer->getWidth() || y <= 0 || y >= buffer->getHeight()))
{
stampColor = stamp->getPixel(stampX,stampY);
bufferColor = buffer ->getPixel(x,y);
stampColor.setRed(stampColor.getRed() * stampColorAdjust.getRed());
stampColor.setGreen(stampColor.getGreen() * stampColorAdjust.getGreen());
stampColor.setBlue(stampColor.getBlue() * stampColorAdjust.getBlue());
float stampDifference = stampColor.getAlpha();
float bufferDifference = (1 - stampDifference);
stampColor = (stampColor * stampDifference) + (bufferColor * bufferDifference);
buffer -> setPixel(x,y,stampColor);
}
stampY++;
}
stampX++;
}
}
ColorData F_MotionBlur::getBlurredColor(int canvasX, int canvasY)
{
int distance = m_kernelSize/2;
ColorData blurredColor;
ColorData curPixel;
float red = 0;
float green = 0;
float blue = 0;
float colorFactor = 0;
int curX;
int curY;
float kernalVal;
assert(m_filterParameter.amountI >= 0 && m_filterParameter.amountI <= 3);
switch(m_filterParameter.amountI)
{
case 0:// N/S
for(curY = 0; curY < m_kernelSize; curY++)
{
curX = distance;
int xVal= canvasX + (curX - distance);
int yVal= canvasY + (curY - distance);
if ((xVal >= 0) && (xVal < m_tempCanvas->getWidth()) && (yVal >= 0) && (yVal < m_tempCanvas->getHeight()))
{
curPixel = m_tempCanvas->getPixel(xVal, yVal);
kernalVal = m_kernel->getKernelVal(curX, curY);
red += kernalVal * curPixel.getRed();
green += kernalVal * curPixel.getGreen();
blue += kernalVal * curPixel.getBlue();
colorFactor += kernalVal;
}
}
break;
case 1:// E/W
for(curX = 0; curX < m_kernelSize; curX++)
{
curY = distance;
int xVal= canvasX + (curX - distance);
int yVal= canvasY + (curY - distance);
if ((xVal >= 0) && (xVal < m_tempCanvas->getWidth()) && (yVal >= 0) && (yVal < m_tempCanvas->getHeight()))
{
curPixel = m_tempCanvas->getPixel(xVal, yVal);
kernalVal = m_kernel->getKernelVal(curX, curY);
red += kernalVal * curPixel.getRed();
green += kernalVal * curPixel.getGreen();
blue += kernalVal * curPixel.getBlue();
colorFactor += kernalVal;
}
}
break;
case 2:// NE/SW
for(curX = 0; curX < m_kernelSize; curX++)
{
curY = curX;
int xVal= canvasX + (curX - distance);
int yVal= canvasY + (curY - distance);
if ((xVal >= 0) && (xVal < m_tempCanvas->getWidth()) && (yVal >= 0) && (yVal < m_tempCanvas->getHeight()))
{
curPixel = m_tempCanvas->getPixel(xVal, yVal);
kernalVal = m_kernel->getKernelVal(curX, curY);
red += kernalVal * curPixel.getRed();
green += kernalVal * curPixel.getGreen();
blue += kernalVal * curPixel.getBlue();
colorFactor += kernalVal;
}
}
break;
case 3:// NW/SE
for(curX = 0; curX < m_kernelSize; curX++)
{
curY = m_kernelSize - curX - 1;
int xVal= canvasX + (curX - distance);
int yVal= canvasY + (curY - distance);
if ((xVal >= 0) && (xVal < m_tempCanvas->getWidth()) && (yVal >= 0) && (yVal < m_tempCanvas->getHeight()))
{
curPixel = m_tempCanvas->getPixel(xVal, yVal);
kernalVal = m_kernel->getKernelVal(curX, curY);
red += kernalVal * curPixel.getRed();
green += kernalVal * curPixel.getGreen();
blue += kernalVal * curPixel.getBlue();
colorFactor += kernalVal;
}
}
break;
default:
for(curX = 0; curX < m_kernelSize; curX++)
{
for(curY = 0; curY < m_kernelSize; curY++)
{
int xVal= canvasX + (curX - distance);
int yVal= canvasY + (curY - distance);
if ((xVal >= 0) && (xVal < m_tempCanvas->getWidth()) && (yVal >= 0) && (yVal < m_tempCanvas->getHeight()))
{
curPixel = m_tempCanvas->getPixel(xVal, yVal);
kernalVal = m_kernel->getKernelVal(curX, curY);
red += kernalVal * curPixel.getRed();
green += kernalVal * curPixel.getGreen();
blue += kernalVal * curPixel.getBlue();
colorFactor += kernalVal;
}
}
}
}
red /= colorFactor;
green /= colorFactor;
blue /= colorFactor;
blurredColor = ColorData(red, green, blue);
return blurredColor;
}
void Tool::apply(int xCoord, int yCoord, PixelBuffer *pixelbuff, ColorData curColor)
{
//creating tool mask offsets for the boundary checking
int toolHeight = this->getHeight();
int toolWidth = this->getWidth();
int x_offset;
int y_offset;
int canvas_w = pixelbuff->getWidth();
int canvas_h = pixelbuff->getHeight();
ColorData pixel;
const std::vector<std::vector<float> > &tool_mask = this->mask.get_mask();
//iterate through 2d vector
for(int i = 0; i < toolHeight; i++)
{
y_offset = yCoord - (toolHeight/2) + i;
if((y_offset < 0) || (y_offset >= canvas_h)) //Checking to see if mask goes out of bounds
{
continue;
}
for(int j = 0; j < toolWidth; j++)
{
x_offset = xCoord - (toolWidth/2) + j;
if ((x_offset < 0) || (x_offset >= canvas_w)) //Checking to see if mask goes out of bounds
{
continue;
}
pixel = pixelbuff->getPixel(x_offset, y_offset);
pixel.setRed((pixel.getRed()*(1 - tool_mask[i][j])) + (curColor.getRed()*tool_mask[i][j]));
pixel.setBlue((pixel.getBlue()*(1 - tool_mask[i][j])) + (curColor.getBlue()*tool_mask[i][j]));
pixel.setGreen((pixel.getGreen()*(1 - tool_mask[i][j])) + (curColor.getGreen()*tool_mask[i][j]));
pixel.setAlpha((pixel.getAlpha()*(1 - tool_mask[i][j])) + tool_mask[i][j]);
pixelbuff->setPixel(x_offset, y_offset, pixel);
}
}
}
void Stamp::setCurrentColor(ColorData color){
m_r = color.getRed();
m_g = color.getGreen();
m_b = color.getBlue();
}
