diff --git a/part_1/image.cu b/part_1/image.cu
index c77c4080a803ba691effacac99664347249b023f..38899be3c34b1d1c00ca061cff767b099ae3fec0 100644
--- a/part_1/image.cu
+++ b/part_1/image.cu
@@ -95,6 +95,7 @@ __global__ void cuda_convolution_blur(
// Only proceed if GPU thread corresponds to a pixel in the image. Ignore all extra threads.
if (pixel_index <= total_pixels) {
+ // printf("total_pixels: %ld pixel_index: %ld\n", total_pixels, pixel_index);
// Calculate pixel location data.
int image_row = (pixel_index / image_width) % image_height;
@@ -112,8 +113,8 @@ __global__ void cuda_convolution_blur(
int row_far_top = image_mid_row - mask_mid_row;
int row_far_bot = image_mid_row + mask_mid_row;
- // For now, only compute on pixel in center of image.
- if ((image_row == image_mid_row) && (image_col == image_mid_col)) {
+ // // For now, only compute on pixel in center of image.
+ // if ((image_row == image_mid_row) && (image_col == image_mid_col)) {
// printf("\n\n");
// printf("total_pixels: %ld image_width: %d image_height: %d\n", total_pixels, image_width, image_height);
// printf("Middle pixel found: %ld image_col: %d image_row: %d\n", pixel_index, image_col, image_row);
@@ -169,6 +170,9 @@ __global__ void cuda_convolution_blur(
float convolution_total_r = 0.f;
float convolution_total_g = 0.f;
float convolution_total_b = 0.f;
+ float convolution_weight_total_r = 0.f;
+ float convolution_weight_total_g = 0.f;
+ float convolution_weight_total_b = 0.f;
int convolution_counter = 0;
int mask_index = 0;
for (int row_index = row_far_top; row_index <= row_far_bot; row_index++) {
@@ -178,45 +182,89 @@ __global__ void cuda_convolution_blur(
if ( ( (col_index >= 0) && (col_index < image_width) ) && ( (row_index >= 0) && (row_index < image_height) ) ) {
int arr_index = col_index + (row_index * image_width);
- // int a = col_index;
- // int b = row_index;
- // int c = a + (b * image_width);
- // printf(" [%d,%d] (%d) (%f,%f,%f)", a, b, c, pixel_arr[mask_index].r, pixel_arr[mask_index].g, pixel_arr[mask_index].b);
+ // // // int a = col_index;
+ // // // int b = row_index;
+ // // // int c = a + (b * image_width);
+ // // // printf(" [%d,%d] (%d) (%f,%f,%f)", a, b, c, pixel_arr[mask_index].r, pixel_arr[mask_index].g, pixel_arr[mask_index].b);
convolution_total_r += pixel_arr_orig[arr_index].r * mask_arr[mask_index].r;
convolution_total_g += pixel_arr_orig[arr_index].g * mask_arr[mask_index].g;
convolution_total_b += pixel_arr_orig[arr_index].b * mask_arr[mask_index].b;
convolution_counter += 1;
- // float red = pixel_arr_orig[arr_index].r * mask_arr[mask_index].r;
- // float green = pixel_arr_orig[arr_index].g * mask_arr[mask_index].g;
- // float blue = pixel_arr_orig[arr_index].b * mask_arr[mask_index].b;
- // pixel_arr[arr_index].r = red;
- // pixel_arr[arr_index].g = green;
- // pixel_arr[arr_index].b = blue;
+
+ if ( (col_index == image_mid_col) && (row_index == image_mid_row) ) {
+
+ // float mask_inverse = 1.f - mask_arr[mask_index].r;
+ // float updated_r = pixel_arr_orig[arr_index].r * mask_arr[mask_index].r;
+ // float updated_inv_r = pixel_arr_orig[pixel_index].r * mask_inverse;
+ // printf("[%d,%d] orig_r: %f mask_weight: %f mask_inv: %f\n", col_index, row_index, pixel_arr_orig[arr_index].r, mask_arr[mask_index].r, mask_inverse);
+ // printf("updated_r: %f updated_inv_r: %f\n", updated_r, updated_inv_r);
+ // updated_r = updated_r + updated_inv_r;
+ // // printf("total_pixels: %ld pixel_index: %ld mask_index: %d\n", total_pixels, pixel_index, mask_index);
+ // printf("updated_r: %f\n", updated_r);
+ // // printf("[%d,%d] orig_r: %f mask_weight: %f mask_inv: %f new_r: %f\n", col_index, row_index, pixel_arr_orig[arr_index].r, mask_arr[mask_index].r, mask_inverse, updated_r);
+
+
+
+ }
+
+ // Calculate updated red value.
+ float mask_inverse = 1.f - mask_arr[mask_index].r;
+ float updated_pix = pixel_arr_orig[arr_index].r * mask_arr[mask_index].r;
+ float updated_inv_pix = pixel_arr_orig[pixel_index].r * mask_inverse;
+ convolution_total_r = convolution_total_r + updated_pix + updated_inv_pix;
+ convolution_weight_total_r += mask_arr[mask_index].r;
+
+ // Calculate updated green value.
+ mask_inverse = 1.f - mask_arr[mask_index].g;
+ updated_pix = pixel_arr_orig[arr_index].g * mask_arr[mask_index].g;
+ updated_inv_pix = pixel_arr_orig[pixel_index].g * mask_inverse;
+ convolution_total_g = convolution_total_g + updated_pix + updated_inv_pix;
+ convolution_weight_total_g += mask_arr[mask_index].g;
+
+ // Calculate updated blue value.
+ mask_inverse = 1.f - mask_arr[mask_index].b;
+ updated_pix = pixel_arr_orig[arr_index].b * mask_arr[mask_index].b;
+ updated_inv_pix = pixel_arr_orig[pixel_index].b * mask_inverse;
+ convolution_total_b = convolution_total_b + updated_pix + updated_inv_pix;
+ convolution_weight_total_b += mask_arr[mask_index].b;
+
+
+ // // float red = pixel_arr_orig[arr_index].r * mask_arr[mask_index].r;
+ // // float green = pixel_arr_orig[arr_index].g * mask_arr[mask_index].g;
+ // // float blue = pixel_arr_orig[arr_index].b * mask_arr[mask_index].b;
+ // // pixel_arr[arr_index].r = red;
+ // // pixel_arr[arr_index].g = green;
+ // // pixel_arr[arr_index].b = blue;
}
+ mask_index += 1;
}
- mask_index += 1;
// printf("\n");
}
// Average out values and apply to pixel index.
if (convolution_total_r > 0.f) {
pixel_arr[pixel_index].r = (convolution_total_r / convolution_counter);
+ // pixel_arr[pixel_index].r = (1.f / convolution_weight_total_r) * convolution_total_r;
} else {
pixel_arr[pixel_index].r = 0.f;
}
if (convolution_total_g > 0.f) {
pixel_arr[pixel_index].g = (convolution_total_g / convolution_counter);
+ // pixel_arr[pixel_index].g = (1.f / convolution_weight_total_g) * convolution_total_g;
} else {
pixel_arr[pixel_index].g = 0.f;
}
if (convolution_total_b > 0.f) {
pixel_arr[pixel_index].b = (convolution_total_b / convolution_counter);
+ // pixel_arr[pixel_index].b = (1 / convolution_weight_total_b) * convolution_total_b;
} else {
pixel_arr[pixel_index].b = 0.f;
}
- }
+
+ // printf("\n\n");
+ // }
}
}
@@ -556,12 +604,14 @@ void Image::compute() {
// Found via much struggling and trial + error.
float mask_col_adj = 1.f / (mask_middle_col + 1);
float mask_row_adj = 1.f / (mask_middle_row + 1);
- printf("mask_middle_col: %d mask_middle_row: %d\n", mask_middle_col, mask_middle_row);
- printf("mask_col_adj: %f mask_row_adj: %f\n", mask_col_adj, mask_row_adj);
+ // printf("mask_middle_col: %d mask_middle_row: %d\n", mask_middle_col, mask_middle_row);
+ // printf("mask_col_adj: %f mask_row_adj: %f\n", mask_col_adj, mask_row_adj);
unsigned long mask_total_pixels = mask_width * mask_height;
unsigned long mask_struct_byte_count = mask_total_pixels * pixel_struct_size;
// Initialize mask and set weights.
+ // printf("\n\n");
+ logger.info("Mask size: " + std::to_string(mask_width) + "x" + std::to_string(mask_height));
PixelStruct* mask_arr = new PixelStruct[mask_total_pixels];
for (int mask_row_index = 0; mask_row_index < mask_height; mask_row_index++) {
for (int mask_col_index = 0; mask_col_index < mask_width; mask_col_index++) {
@@ -573,18 +623,22 @@ void Image::compute() {
float mask_row_weight = (fabs(mask_middle_row - fabs(mask_middle_row - mask_row_index)) + 1) * mask_row_adj;
// Calculate overall index weight, based on combination of individual dimension weights.
- float index_weight = mask_col_weight * mask_row_weight;
+ float index_weight = (mask_col_weight * mask_row_weight);
// printf(" [%d, %d] (%d) (%f,%f) ", mask_col_index, mask_row_index, mask_index, mask_col_weight, mask_row_weight);
- printf(" [%d, %d] (%d) (%f) ", mask_col_index, mask_row_index, mask_index, index_weight);
+ // printf(" [%d, %d] (%d) (%f) ", mask_col_index, mask_row_index, mask_index, index_weight);
// Finally, set mask index values.
mask_arr[mask_index].r = index_weight;
mask_arr[mask_index].g = index_weight;
mask_arr[mask_index].b = index_weight;
+ // mask_arr[mask_index].r = 1.f;
+ // mask_arr[mask_index].g = 1.f;
+ // mask_arr[mask_index].b = 1.f;
}
- printf("\n");
+ // printf("\n");
}
+ // printf("\n\n");
// Allocate memory on GPU.
PixelStruct* gpu_pixel_arr;