Shorter type name

2 files changed, 41 insertions, 41 deletions

diff --git a/lib/seg/mask_data.c b/lib/seg/mask_data.c
index 52a3ac4..97e9165 100644
--- a/lib/seg/mask_data.c
+++ b/lib/seg/mask_data.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 
 // Allocate Mask Data for Label
-MaskData* create_mask_data(ImageMaskData_t label)
+MaskData* create_mask_data(MaskData_t label)
 {
   MaskData *data = (MaskData*)malloc(sizeof(MaskData));
   data->label = label;
@@ -90,7 +90,7 @@ Result insert_mask(AVLNode* node, MaskData* data)
 
 // Allocate a label's Mask data in a tree
 //  If it already exists, skip the allocation
-AVLNode* insert_mask_alloc(AVLNode* node, ImageMaskData_t label)
+AVLNode* insert_mask_alloc(AVLNode* node, MaskData_t label)
 {
   MaskData* data = create_mask_data(label);
   Result result = insert_mask(node, data);
@@ -112,7 +112,7 @@ void print_label(AVLNode* root)
 }
 
 // Increase the label's area
-bool_t increase_label_area(AVLNode* root, ImageMaskData_t label)
+bool_t increase_label_area(AVLNode* root, MaskData_t label)
 {
   if (root == NULL) {
     return FALSE;
@@ -131,7 +131,7 @@ bool_t increase_label_area(AVLNode* root, ImageMaskData_t label)
 }
 
 // Increase the label's perimeter
-bool_t increase_label_perimeter(AVLNode* root, ImageMaskData_t label)
+bool_t increase_label_perimeter(AVLNode* root, MaskData_t label)
 {
   if (root == NULL) {
     return FALSE;
@@ -151,7 +151,7 @@ bool_t increase_label_perimeter(AVLNode* root, ImageMaskData_t label)
 
 // Increase the label's area
 //  Create an AVL node if it doesn't exist
-AVLNode* increase_label_area_alloc(AVLNode* root, ImageMaskData_t label)
+AVLNode* increase_label_area_alloc(AVLNode* root, MaskData_t label)
 {
   AVLNode* new_root = root;
   bool_t success = increase_label_area(new_root, label);
@@ -164,7 +164,7 @@ AVLNode* increase_label_area_alloc(AVLNode* root, ImageMaskData_t label)
 
 // Increase the label's perimeter
 //  Create an AVL node if it doesn't exist
-AVLNode* increase_label_perimeter_alloc(AVLNode* root, ImageMaskData_t label)
+AVLNode* increase_label_perimeter_alloc(AVLNode* root, MaskData_t label)
 {
   AVLNode* new_root = root;
   bool_t success = increase_label_perimeter(new_root, label);
@@ -175,8 +175,8 @@ AVLNode* increase_label_perimeter_alloc(AVLNode* root, ImageMaskData_t label)
   return new_root;
 }
 
-// Comparison of ImageMaskData_ts
-bool_t compare_image_mask_data_t(ImageMaskData_t* s1, ImageMaskData_t* s2)
+// Comparison of MaskData_ts
+bool_t compare_image_mask_data_t(MaskData_t* s1, MaskData_t* s2)
 {
   return *s1 < *s2;
 }
@@ -186,20 +186,20 @@ void print_in_order_image_mask_data_t(AVLNode* root)
 {
   if (root != NULL) {
     print_in_order_image_mask_data_t(root->left);
-    printf("%d ", *((ImageMaskData_t*)root->data));
+    printf("%d ", *((MaskData_t*)root->data));
     print_in_order_image_mask_data_t(root->right);
   }
 }
 
-// Check if ImageMaskData_t in AVLTree with ImageMaskData_t* data
-bool_t in_image_mask_data_t_tree(AVLNode* root, ImageMaskData_t value)
+// Check if MaskData_t in AVLTree with MaskData_t* data
+bool_t in_image_mask_data_t_tree(AVLNode* root, MaskData_t value)
 {
   if (root == NULL) {
     return FALSE;
   }
-  if (*((ImageMaskData_t*)root->data) == value) {
+  if (*((MaskData_t*)root->data) == value) {
     return TRUE;
-  } else if (value < *((ImageMaskData_t*)root->data)) {
+  } else if (value < *((MaskData_t*)root->data)) {
     return in_image_mask_data_t_tree(root->left, value);
   } else {
     return in_image_mask_data_t_tree(root->right, value);
@@ -227,7 +227,7 @@ AVLNode* get_small_labels(AVLNode* removal_tree, AVLNode* label_tree, size_t min
 }
 
 // Get mask label data
-AVLNode* get_mask_data(ImageMaskData_t* masks, uint32_t width, uint32_t height)
+AVLNode* get_mask_data(MaskData_t* masks, uint32_t width, uint32_t height)
 {
   AVLNode* root = NULL;
   for (size_t y = 0; y < height; y++) {
@@ -245,7 +245,7 @@ AVLNode* get_mask_data(ImageMaskData_t* masks, uint32_t width, uint32_t height)
 }
 
 // Filter out small masks in mask
-void filter_small_masks(ImageMaskData_t* masks, uint32_t width, uint32_t height, size_t min_area, size_t min_perimeter)
+void filter_small_masks(MaskData_t* masks, uint32_t width, uint32_t height, size_t min_area, size_t min_perimeter)
 {
   AVLNode* root = get_mask_data(masks, width, height);
   AVLNode* small_label_tree = NULL;
diff --git a/lib/seg/util.c b/lib/seg/util.c
index afced0a..a3b3eb6 100644
--- a/lib/seg/util.c
+++ b/lib/seg/util.c
@@ -21,11 +21,11 @@ size_t xy_to_coord(size_t x, size_t y, uint32_t width, uint32_t height)
 
 // Determine if coordinate is on a mask boundary
 //  Assumes mask is (WxH)
-bool_t is_on_mask_boundary(ImageMaskData_t* mask, uint32_t width, uint32_t height, size_t x, size_t y)
+bool_t is_on_mask_boundary(MaskData_t* mask, uint32_t width, uint32_t height, size_t x, size_t y)
 {
   size_t starting_coord = xy_to_coord(x, y, width, height);
   size_t proposed_position;
-  ImageMaskData_t current_value = mask[starting_coord];
+  MaskData_t current_value = mask[starting_coord];
 
   // Left neighbor
   if (x != 0) {
@@ -57,9 +57,9 @@ bool_t is_on_mask_boundary(ImageMaskData_t* mask, uint32_t width, uint32_t heigh
 }
 
 // Dilate masks by one 4-connected pixel
-ImageMaskData_t* _dilate(ImageMaskData_t* mask, uint32_t width, uint32_t height)
+MaskData_t* _dilate(MaskData_t* mask, uint32_t width, uint32_t height)
 {
-  ImageMaskData_t *new_mask = (ImageMaskData_t*)calloc(width*height,sizeof(ImageMaskData_t));
+  MaskData_t *new_mask = (MaskData_t*)calloc(width*height,sizeof(MaskData_t));
   for (size_t y = 0; y < height; y++) {
     for (size_t x = 0; x < width; x++) {
       size_t current_position = xy_to_coord(x, y, width, height);
@@ -102,9 +102,9 @@ ImageMaskData_t* _dilate(ImageMaskData_t* mask, uint32_t width, uint32_t height)
 }
 
 // Dilate masks by one 4-connected pixel
-void dilate(ImageMaskData_t** mask, uint32_t width, uint32_t height)
+void dilate(MaskData_t** mask, uint32_t width, uint32_t height)
 {
-  ImageMaskData_t *new_mask = _dilate(*mask, width, height);
+  MaskData_t *new_mask = _dilate(*mask, width, height);
   if (new_mask != NULL) {
     free(*mask);
     *mask = new_mask;
@@ -112,10 +112,10 @@ void dilate(ImageMaskData_t** mask, uint32_t width, uint32_t height)
 }
 
 // Erode masks by one 4-connected pixel
-ImageMaskData_t* _erode(ImageMaskData_t* mask, uint32_t width, uint32_t height)
+MaskData_t* _erode(MaskData_t* mask, uint32_t width, uint32_t height)
 {
-  ImageMaskData_t *new_mask = (ImageMaskData_t*)calloc(width*height,sizeof(ImageMaskData_t));
-  memcpy(new_mask, mask, width*height*sizeof(ImageMaskData_t));
+  MaskData_t *new_mask = (MaskData_t*)calloc(width*height,sizeof(MaskData_t));
+  memcpy(new_mask, mask, width*height*sizeof(MaskData_t));
   for (size_t y = 0; y < height; y++) {
     for (size_t x = 0; x < width; x++) {
       size_t current_position = xy_to_coord(x, y, width, height);
@@ -154,9 +154,9 @@ ImageMaskData_t* _erode(ImageMaskData_t* mask, uint32_t width, uint32_t height)
 }
 
 // Erode masks by one 4-connected pixel
-void erode(ImageMaskData_t** mask, uint32_t width, uint32_t height)
+void erode(MaskData_t** mask, uint32_t width, uint32_t height)
 {
-  ImageMaskData_t *new_mask = _erode(*mask, width, height);
+  MaskData_t *new_mask = _erode(*mask, width, height);
   if (new_mask != NULL) {
     free(*mask);
     *mask = new_mask;
@@ -164,10 +164,10 @@ void erode(ImageMaskData_t** mask, uint32_t width, uint32_t height)
 }
 
 // Close up masks by N-pixels
-ImageMaskData_t* _closeup(ImageMaskData_t* mask, uint32_t width, uint32_t height, size_t num_pixels)
+MaskData_t* _closeup(MaskData_t* mask, uint32_t width, uint32_t height, size_t num_pixels)
 {
-  ImageMaskData_t *new_mask = (ImageMaskData_t*)calloc(width*height,sizeof(ImageMaskData_t));
-  memcpy(new_mask, mask, width*height*sizeof(ImageMaskData_t));
+  MaskData_t *new_mask = (MaskData_t*)calloc(width*height,sizeof(MaskData_t));
+  memcpy(new_mask, mask, width*height*sizeof(MaskData_t));
   for (size_t count = 0; count < num_pixels; count++) {
     dilate(&new_mask, width, height);
   }
@@ -190,9 +190,9 @@ ImageMaskData_t* _closeup(ImageMaskData_t* mask, uint32_t width, uint32_t height
 
 // Close up masks by N-pixels
 //  Update pointer
-void closeup(ImageMaskData_t** mask, uint32_t width, uint32_t height, size_t num_pixels)
+void closeup(MaskData_t** mask, uint32_t width, uint32_t height, size_t num_pixels)
 {
-  ImageMaskData_t *new_mask = _closeup(*mask, width, height, num_pixels);
+  MaskData_t *new_mask = _closeup(*mask, width, height, num_pixels);
   if (new_mask != NULL) {
     free(*mask);
     *mask = new_mask;
@@ -220,7 +220,7 @@ ImageMask* combine_masks(ImageMask *destination, ImageMask *extra_labels)
 // Process Tif File to Labels
 //  width, height will be overwritten with image dimensions
 //  starting_label_p will be incremented for each label found in the image
-ImageMask* tif_to_labels(char* tif_file_name, uint32_t *width, uint32_t *height, ImageMaskData_t *starting_label_p)
+ImageMask* tif_to_labels(char* tif_file_name, uint32_t *width, uint32_t *height, MaskData_t *starting_label_p)
 {
   TIFFSetWarningHandler(TiffDummyHandler);
   //-TIFF-IMAGE-OPEN-------------------------------
@@ -289,9 +289,9 @@ ImageMask* tif_to_labels(char* tif_file_name, uint32_t *width, uint32_t *height,
     TIFFClose(tif);
     return NULL;
   }
-  ImageMaskData_t *labels = im_data->image[0];
+  MaskData_t *labels = im_data->image[0];
   /*
-  labels = (ImageMaskData_t*)calloc((*width)*(*height),sizeof(ImageMaskData_t));
+  labels = (MaskData_t*)calloc((*width)*(*height),sizeof(MaskData_t));
   if (labels == NULL) {
     fprintf(stderr, "Memory allocation error\n");
     free(image_data);
@@ -316,7 +316,7 @@ ImageMask* tif_to_labels(char* tif_file_name, uint32_t *width, uint32_t *height,
 }
 
 // Convert mask to bitmap
-Bitmap* image_mask_data_to_bitmap(ImageMaskData_t* buffer, uint32_t width, uint32_t height)
+Bitmap* image_mask_data_to_bitmap(MaskData_t* buffer, uint32_t width, uint32_t height)
 {
   Pixel* out_buffer = (Pixel*)calloc(width*height, sizeof(Pixel));
   if (out_buffer == NULL) {
@@ -345,17 +345,17 @@ Bitmap* image_mask_data_to_bitmap(ImageMaskData_t* buffer, uint32_t width, uint3
 }
 
 // Reduce a mask to the contiguous regions
-ImageMaskData_t* _reduce_contiguous_regions(ImageMaskData_t* masks, uint32_t width, uint32_t height, ImageMaskData_t* total_labels)
+MaskData_t* _reduce_contiguous_regions(MaskData_t* masks, uint32_t width, uint32_t height, MaskData_t* total_labels)
 {
-  ImageMaskData_t starting_label = 1;
-  ImageMaskData_t* new_masks = (ImageMaskData_t*)calloc(width*height, sizeof(ImageMaskData_t));
+  MaskData_t starting_label = 1;
+  MaskData_t* new_masks = (MaskData_t*)calloc(width*height, sizeof(MaskData_t));
   if (new_masks == NULL) {
     return NULL;
   }
   for (size_t y = 0; y < height; y++) {
     for (size_t x = 0; x < width; x++) {
       size_t coord = x + y*width;
-      ImageData_t channels = 2; // ImageMaskData_t = 2*uint8_t
+      ImageData_t channels = 2; // MaskData_t = 2*uint8_t
       if (flood((ImageData_t*)masks, new_masks, width, height, channels, x, y, &(((ImageData_t*)masks)[coord*channels]), starting_label)) {
 	starting_label++;
       }
@@ -370,12 +370,12 @@ ImageMaskData_t* _reduce_contiguous_regions(ImageMaskData_t* masks, uint32_t wid
 // Reduce a mask to the contiguous regions
 //  Automatically update pointer to contiguous mask
 //  Freeing previous mask
-void reduce_contiguous_regions(ImageMaskData_t** masks_p, uint32_t width, uint32_t height, ImageMaskData_t* total_labels)
+void reduce_contiguous_regions(MaskData_t** masks_p, uint32_t width, uint32_t height, MaskData_t* total_labels)
 {
   if (masks_p == NULL) {
     return;
   }
-  ImageMaskData_t* new_masks = _reduce_contiguous_regions(*masks_p, width, height, total_labels);
+  MaskData_t* new_masks = _reduce_contiguous_regions(*masks_p, width, height, total_labels);
   if (new_masks != NULL) {
     free(*masks_p);
     *masks_p = new_masks;