libimg/include/image/filters.h

#ifndef FILTERS_H
#define FILTERS_H
#include "utils.h"

/**
 * @brief Packs new alpha channel
 * @details Takes a value from 0 - 255 for levels of opacity in image and packs
 * it into the first byte. 0 is transparent and 255 is fully opaque.
 * @param[in] clr Takes in a packed pixel
 * @param[in] alpha One byte value to be packed for image
 * @return unsigned int Packed color with new alpha channel.
 */
unsigned int
u32_put_alpha(const unsigned int clr, const unsigned char alpha);

/**
 * @brief Inverts bits for color channels
 * @details Takes a packed color and inverts the RGB channel bits from 0 to 1
 * and vice versa. Then saves the alpha channel back to new packed image.
 * @param[in] clr Takes in a packed pixel
 * @return unsigned int Packed color with inverted RGB channels.
 */
unsigned int
u32_invert(const unsigned int clr);

/**
 * @brief Inverts RED and BLUE channels
 * @details Takes a packed color and isolates the A and G channels, then shifts
 * the clr Red channel 16 Bits right and B channel 16 Bits left.
 * @param[in] clr Takes in a packed pixel
 * @return unsigned int Packed color with inverted RB channels.
 */
unsigned int
u32_swap_rb(const unsigned int clr);

/**
 * @brief Grays pixels from RGB channels
 * @details Takes a packed color and merges RGB channels and sets all RGB
 * channels to new gray.
 * @param[in] clr Takes in a packed pixel
 * @return unsigned int Packed color with gray RGB channels.
 */
unsigned int
u32_grayscale(const unsigned int clr);

/**
 * @brief Grays pixels from RGB channels
 * @details If greyscale value is less than Max then set color to transparent
 * and black. If greater, set color to opaque white. channels to new gray.
 * @param[in] clr Takes in a packed pixel
 * @param[in] max Max gray value for split
 * @return unsigned int Packed color with white or black RGB channels.
 */
unsigned int
u32_step(const unsigned int clr, const unsigned char max);

/**
 * @brief Brightens Color
 * @details Uses a factor to multiply RGB channels to increase values closer to
 * 255 to raise brightness. Use x > 1 for a brighter pixel and x < 1 for a
 * darker pixel
 * @param[in] clr Takes in a packed pixel
 * @param[in] factor Used to multiply against RGB channels. Can be 0 < x > 1 but
 * NOT negative.
 * @return unsigned int Packed color with brighter or darker pixel
 */
unsigned int
u32_brighten(const unsigned int clr, const float factor);

/**
 * @brief Combines RGB values between 2 packed colors
 * @details Takes and adds the respective RGB values between 2 colors and
 * divides by 2 to make sure each channel is below 255. So, even if 2 pixels are
 * white, the max values will stay 255.
 * @param[in] clr_a Packed Pixel A
 * @param[in] clr_b Packed Pixel B
 * @return unsigned int Packed ARGB pixel.
 */
unsigned int
u32_mix(const unsigned int clr_a, const unsigned int clr_b);

/**
 * @brief Combines RGB values between 2 packed colors
 * @details Takes and adds the respective RGB values between 2 colors and
 * divides by 2 to make sure each channel is below 255. So, even if 2 pixels are
 * white, the max values will stay 255.
 * @param[in] clr_a Packed Pixel A
 * @param[in] clr_b Packed Pixel B
 * @return unsigned int Packed ARGB pixel.
 */
unsigned int
u32_lerp(const unsigned clr_a, const unsigned int clr_b, const float ratio);

/**
 * @brief Returns a Packed Pixel of one Channel
 * @param[in] clr Packed Pixel
 * @param[in] keep Character of 'r', 'g', 'b', keeping the channel respectively.
 * @return unsigned int Packed Pixel with one channel kept, includes alpha auto
 */
unsigned int
u32_mask(const unsigned int clr, const char keep);

/**
 * @brief Rotates the bits of each channel by n
 * @details Moves bits of channels left by n with the max being 8 and
 * recommended to use 0 < x < 8 instead of 8; 8 just returns the same pixel as
 * it is just rotated back to original position. Cannot be greater than 8
 * because the calculations would result in a negative.
 * @param[in] clr Packed Pixel
 * @param[in] dist Distance from original position to move each bit to the left.
 * @return unsigned int Packed Pixel with newly moved bits
 */
unsigned int
u32_rotl(const unsigned int clr, const int dist);

/**
 * @brief Raises Color Vibrance
 * @details Raises the vibrance by essentially raising specific channels higher
 * and lowering others.
 * @param[in] clr Packed Pixel
 * @param[in] factor Floating point to raise or lower vibrance by.
 * @return unsigned int Packed Pixel with one channel kept, includes alpha auto
 */
unsigned int
u32_contrast(const unsigned int clr, const float factor);

/**
 * @brief Averages Red and Blue Channels for Green Channel
 * @param[in] clr Packed Pixel
 * @return unsigned int Packed Pixel with green pixel averaged
 */
unsigned int
u32_avg_gb(const unsigned int clr);

/**
 * @brief Blurs image in a radiance with a box
 * @details Uses 2 loops to scan from left to right; selecting a pixel and
 * mixing all of the pixels from "radius" left to "radius" right and averaging
 * them. Then it moves to the next pixel doing the same. Then it does the second
 * loop from top to bottom doing the same principle. This can take some time
 * depending on hardware, image size, radius, etc.
 * @param[in] buf The image buffer to be blurred
 * @param[in] metadata the PPM image container
 * @param[in] radius The amount of pixels around the left and right, then top
 * and bottom to mix with the currently selected pixel
 * @return unsigned int Pointer to new created image buffer.
 */
unsigned int*
u32_box_blur(const unsigned int* buf, const PPM* metadata, const int radius);

#endif