Userspace types

12 files changed, 130 insertions, 128 deletions

diff --git a/include/lib/algo/avl_tree.h b/include/lib/algo/avl_tree.h
index 4400aa6..0221952 100644
--- a/include/lib/algo/avl_tree.h
+++ b/include/lib/algo/avl_tree.h
@@ -2,6 +2,7 @@
 #define INC_LIB_ALGO_AVL_TREE_H
 
 #include <lib/bool.h>
+#include <lib/monad.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -10,42 +11,42 @@
 
 typedef bool_t (*AvlComparator)(void*, void*);
 
-struct AVLNode {
+typedef struct AVLNode {
   void* data;
   AvlComparator compare;
   struct AVLNode* left;
   struct AVLNode* right;
   AvlHeight_t height;
-};
+} AVLNode;
 
 // Get the height of an AVL node
-AvlHeight_t get_height(struct AVLNode* node);
+AvlHeight_t get_height(AVLNode* node);
 
 // Get the Maximum Height between two
 AvlHeight_t max_height(AvlHeight_t a, AvlHeight_t b);
 
 // Get the balance factor of a node
-ssize_t get_balance_factor(struct AVLNode* node);
+ssize_t get_balance_factor(AVLNode* node);
 
 // Rotate an AVL node right
-struct AVLNode* right_rotate(struct AVLNode* parent);
+AVLNode* right_rotate(AVLNode* parent);
 
 // Rotate an AVL node left
-struct AVLNode* left_rotate(struct AVLNode* parent);
+AVLNode* left_rotate(AVLNode* parent);
 
 // Create AVL node
-struct AVLNode* create_avl_node(void* data, AvlComparator compare);
+AVLNode* create_avl_node(void* data, AvlComparator compare);
 
 // Insert data into AVL tree
-struct Result avl_insert(struct AVLNode* node, void* data, AvlComparator compare);
+Result avl_insert(AVLNode* node, void* data, AvlComparator compare);
 
 // In-order traversal print pointer
-void print_in_order(struct AVLNode* root);
+void print_in_order(AVLNode* root);
 
 // Free avl tree nodes starting at root
-void free_avl_tree(struct AVLNode* root);
+void free_avl_tree(AVLNode* root);
 
 // Free avl tree and their data starting at root
-void free_avl_tree_nodes(struct AVLNode* root);
+void free_avl_tree_nodes(AVLNode* root);
 
 #endif
diff --git a/include/lib/data/image_types.h b/include/lib/data/image_types.h
index 020dd59..ca97d21 100644
--- a/include/lib/data/image_types.h
+++ b/include/lib/data/image_types.h
@@ -7,22 +7,22 @@
 #define ImageData_t uint8_t
 #define ImageMaskData_t uint16_t
 
-struct Image {
+typedef struct Image {
   size_t width;
   size_t height;
   ImageData_t** image;
-};
+} Image;
 
-struct ImageMask {
+typedef struct ImageMask {
   size_t width;
   size_t height;
   ImageMaskData_t** mask;
-};
+} ImageMask;
 
-struct Image* create_image(size_t width, size_t height);
-struct ImageMask* create_image_mask(size_t width, size_t height);
+Image* create_image(size_t width, size_t height);
+ImageMask* create_image_mask(size_t width, size_t height);
 
-void free_image(struct Image* image);
-void free_image_mask(struct ImageMask* image_mask);
+void free_image(Image* image);
+void free_image_mask(ImageMask* image_mask);
 
 #endif
diff --git a/include/lib/monad.h b/include/lib/monad.h
index 74db079..af5eb3a 100644
--- a/include/lib/monad.h
+++ b/include/lib/monad.h
@@ -3,9 +3,9 @@
 
 #include <lib/bool.h>
 
-struct Result {
+typedef struct Result {
   void* data;
   bool_t success;
-};
+} Result;
 
 #endif
diff --git a/include/lib/png.h b/include/lib/png.h
index ddc1db3..c21fede 100644
--- a/include/lib/png.h
+++ b/include/lib/png.h
@@ -8,19 +8,19 @@
 #define PixelSize_t uint8_t
 #define PixelDepth_t uint8_t
 
-struct pixel_t {
+typedef struct pixel_t {
   PixelChannel_t red;
   PixelChannel_t green;
   PixelChannel_t blue;
-};
+} Pixel;
 
-struct bitmap_t {
-  struct pixel_t* image_buffer;
+typedef struct bitmap_t {
+  Pixel* image_buffer;
   size_t width;
   size_t height;
-};
+} Bitmap;
 
 // Save bitmap to file
-void save_png(struct bitmap_t* bitmap, char* fname);
+void save_png(Bitmap* bitmap, char* fname);
 
 #endif
diff --git a/include/lib/seg/mask_data.h b/include/lib/seg/mask_data.h
index bbaf38c..91b9074 100644
--- a/include/lib/seg/mask_data.h
+++ b/include/lib/seg/mask_data.h
@@ -5,60 +5,60 @@
 #include <lib/data/image_types.h>
 #include <lib/monad.h>
 
-struct MaskData {
+typedef struct MaskData {
   ImageMaskData_t label;
   size_t area;
   size_t perimeter;
-};
+} MaskData;
 
 // Allocate Mask Data for Label
-struct MaskData* create_mask_data(ImageMaskData_t label);
+MaskData* create_mask_data(ImageMaskData_t label);
 
 // Compare mask data labels
-bool_t compare_labels(struct MaskData* left, struct MaskData* right);
+bool_t compare_labels(MaskData* left, MaskData* right);
 
 // Create AVL Mask node
-struct AVLNode* create_avl_mask_node(struct MaskData* data);
+AVLNode* create_avl_mask_node(MaskData* data);
 
 // Insert MaskData into the AVL Tree
-struct Result insert_mask(struct AVLNode* node, struct MaskData* data);
+Result insert_mask(AVLNode* node, MaskData* data);
 
 // Allocate a label's Mask data in a tree
 //  If it already exists, skip the allocation
-struct AVLNode* insert_mask_alloc(struct AVLNode* node, ImageMaskData_t label);
+AVLNode* insert_mask_alloc(AVLNode* node, ImageMaskData_t label);
 
 // Print AVL Node Mask Data Label
-void print_label(struct AVLNode* root);
+void print_label(AVLNode* root);
 
 // Increase the label's area
-bool_t increase_label_area(struct AVLNode* root, ImageMaskData_t label);
+bool_t increase_label_area(AVLNode* root, ImageMaskData_t label);
 
 // Increase the label's perimeter
-bool_t increase_label_perimeter(struct AVLNode* root, ImageMaskData_t label);
+bool_t increase_label_perimeter(AVLNode* root, ImageMaskData_t label);
 
 // Increase the label's area
 //  Create an AVL node if it doesn't exist
-struct AVLNode* increase_label_area_alloc(struct AVLNode* root, ImageMaskData_t label);
+AVLNode* increase_label_area_alloc(AVLNode* root, ImageMaskData_t label);
 
 // Increase the label's perimeter
 //  Create an AVL node if it doesn't exist
-struct AVLNode* increase_label_perimeter_alloc(struct AVLNode* root, ImageMaskData_t label);
+AVLNode* increase_label_perimeter_alloc(AVLNode* root, ImageMaskData_t label);
 
 // Comparison of ImageMaskData_ts
 bool_t compare_image_mask_data_t(ImageMaskData_t* s1, ImageMaskData_t* s2);
 
 // In-order traversal print pointer
-void print_in_order_image_mask_data_t(struct AVLNode* root);
+void print_in_order_image_mask_data_t(AVLNode* root);
 
 // Check if ImageMaskData_t in AVLTree with ImageMaskData_t* data
-bool_t in_image_mask_data_t_tree(struct AVLNode* root, ImageMaskData_t value);
+bool_t in_image_mask_data_t_tree(AVLNode* root, ImageMaskData_t value);
 
 // Filter out small masks
 //  Assumption: Contiguous labeling
-struct AVLNode* get_small_labels(struct AVLNode* removal_tree, struct AVLNode* label_tree, size_t min_area, size_t min_perimeter);
+AVLNode* get_small_labels(AVLNode* removal_tree, AVLNode* label_tree, size_t min_area, size_t min_perimeter);
 
 // Get mask label data
-struct AVLNode* get_mask_data(ImageMaskData_t* masks, uint32_t width, uint32_t height);
+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);
diff --git a/include/lib/seg/util.h b/include/lib/seg/util.h
index 395c5cd..88389f6 100644
--- a/include/lib/seg/util.h
+++ b/include/lib/seg/util.h
@@ -2,6 +2,7 @@
 #define INC_LIB_SEG_UTIL_H
 
 #include <lib/bool.h>
+#include <lib/png.h>
 #include <lib/data/image_types.h>
 #include <stdint.h>
 #include <stddef.h>
@@ -25,15 +26,15 @@ void closeup(ImageMaskData_t** mask, uint32_t width, uint32_t height, size_t cou
 // Combine Label Masks
 // For all empty spaces in the destination, put the extra label if it exists
 // Allocates an array if destination is unallocated
-struct ImageMask* combine_masks(struct ImageMask *destination, struct ImageMask *extra_labels);
+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
-struct 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, ImageMaskData_t *starting_label_p);
 
 // Convert mask to bitmap
-struct bitmap_t* image_mask_data_to_bitmap(ImageMaskData_t* buffer, uint32_t width, uint32_t height);
+Bitmap* image_mask_data_to_bitmap(ImageMaskData_t* buffer, uint32_t width, uint32_t height);
 
 // Reduce a mask to the contiguous regions
 //  Automatically update pointer to contiguous mask
diff --git a/lib/algo/avl_tree.c b/lib/algo/avl_tree.c
index 9ac5d47..7b86bab 100644
--- a/lib/algo/avl_tree.c
+++ b/lib/algo/avl_tree.c
@@ -5,7 +5,7 @@
 #include <stdio.h>
 
 // Get the height of an AVL node
-AvlHeight_t get_height(struct AVLNode* node)
+AvlHeight_t get_height(AVLNode* node)
 {
   if (node == NULL) {
     return 0;
@@ -20,7 +20,7 @@ AvlHeight_t max_height(AvlHeight_t a, AvlHeight_t b)
 }
 
 // Get the balance factor of a node
-ssize_t get_balance_factor(struct AVLNode* node)
+ssize_t get_balance_factor(AVLNode* node)
 {
   if (node == NULL) {
     return 0;
@@ -29,10 +29,10 @@ ssize_t get_balance_factor(struct AVLNode* node)
 }
 
 // Rotate an AVL node right
-struct AVLNode* right_rotate(struct AVLNode* parent)
+AVLNode* right_rotate(AVLNode* parent)
 {
-  struct AVLNode* child1 = parent->left;
-  struct AVLNode* child2 = child1->right;
+  AVLNode* child1 = parent->left;
+  AVLNode* child2 = child1->right;
 
   child1->right = parent;
   parent->left = child2;
@@ -43,10 +43,10 @@ struct AVLNode* right_rotate(struct AVLNode* parent)
 }
 
 // Rotate an AVL node left
-struct AVLNode* left_rotate(struct AVLNode* parent)
+AVLNode* left_rotate(AVLNode* parent)
 {
-  struct AVLNode* child1 = parent->right;
-  struct AVLNode* child2 = child1->left;
+  AVLNode* child1 = parent->right;
+  AVLNode* child2 = child1->left;
 
   child1->left = parent;
   parent->right = child2;
@@ -57,9 +57,9 @@ struct AVLNode* left_rotate(struct AVLNode* parent)
 }
 
 // Create AVL node
-struct AVLNode* create_avl_node(void* data, AvlComparator compare)
+AVLNode* create_avl_node(void* data, AvlComparator compare)
 {
-  struct AVLNode* node = (struct AVLNode*)malloc(sizeof(struct AVLNode));
+  AVLNode* node = (AVLNode*)malloc(sizeof(AVLNode));
   if (node == NULL) {
     return NULL;
   }
@@ -72,12 +72,12 @@ struct AVLNode* create_avl_node(void* data, AvlComparator compare)
 }
 
 // Insert data into AVL tree
-struct Result avl_insert(struct AVLNode* node, void* data, AvlComparator compare)
+Result avl_insert(AVLNode* node, void* data, AvlComparator compare)
 {
-  struct Result result;
+  Result result;
   // 1. Standard BST insertion
   if (node == NULL) {
-    return (struct Result) {create_avl_node(data, compare), TRUE};
+    return (Result) {create_avl_node(data, compare), TRUE};
   }
 
   if (node->compare(data, node->data)) {
@@ -86,16 +86,16 @@ struct Result avl_insert(struct AVLNode* node, void* data, AvlComparator compare
       fprintf(stderr, "Failed to insert!");
       return result;
     }
-    node->left = (struct AVLNode*)result.data;
+    node->left = (AVLNode*)result.data;
   } else if (node->compare(node->data, data)) {
     result = avl_insert(node->right, data, compare);
     if (!result.success) {
       fprintf(stderr, "Failed to insert!");
       return result;
     }
-    node->right = (struct AVLNode*)result.data;
+    node->right = (AVLNode*)result.data;
   } else {
-    return (struct Result) {node, FALSE};
+    return (Result) {node, FALSE};
   }
 
   // 2. Update height of the ancestor node
@@ -107,25 +107,25 @@ struct Result avl_insert(struct AVLNode* node, void* data, AvlComparator compare
 
   // LeftLeft
   if ((balance > 1) && node->compare(data, node->left->data)) {
-    return (struct Result) {right_rotate(node), TRUE};
+    return (Result) {right_rotate(node), TRUE};
   }
   // RightRight
   if ((balance < -1) && node->compare(node->right->data, data)) {
-    return (struct Result) {left_rotate(node), TRUE};
+    return (Result) {left_rotate(node), TRUE};
   }
   // LeftRight
   if ((balance > 1) && node->compare(node->left->data, data)) {
-    return (struct Result) {right_rotate(node), TRUE};
+    return (Result) {right_rotate(node), TRUE};
   }
   // RightLeft
   if ((balance < -1) && node->compare(data,node->right->data)) {
-    return (struct Result) {left_rotate(node), TRUE};
+    return (Result) {left_rotate(node), TRUE};
   }
-  return (struct Result) {node, TRUE};
+  return (Result) {node, TRUE};
 }
 
 // In-order traversal print pointer
-void print_in_order(struct AVLNode* root)
+void print_in_order(AVLNode* root)
 {
   if (root != NULL) {
     print_in_order(root->left);
@@ -135,7 +135,7 @@ void print_in_order(struct AVLNode* root)
 }
 
 // Free avl tree nodes starting at root
-void free_avl_tree(struct AVLNode* root)
+void free_avl_tree(AVLNode* root)
 {
   if (root != NULL) {
     free_avl_tree(root->left);
@@ -145,7 +145,7 @@ void free_avl_tree(struct AVLNode* root)
 }
 
 // Free avl tree and their data starting at root
-void free_avl_tree_nodes(struct AVLNode* root)
+void free_avl_tree_nodes(AVLNode* root)
 {
   if (root != NULL) {
     free_avl_tree_nodes(root->left);
diff --git a/lib/data/image_types.c b/lib/data/image_types.c
index c33a88e..0375a24 100644
--- a/lib/data/image_types.c
+++ b/lib/data/image_types.c
@@ -1,9 +1,9 @@
 #include <lib/data/image_types.h>
 #include <stdlib.h>
 
-struct Image* create_image(size_t width, size_t height)
+Image* create_image(size_t width, size_t height)
 {
-  struct Image* ip = (struct Image*)malloc(sizeof(struct Image));
+  Image* ip = (Image*)malloc(sizeof(Image));
   ip->width = width;
   ip->height = height;
   ip->image = (ImageData_t**)malloc(sizeof(ImageData_t*) * ip->height);
@@ -14,9 +14,9 @@ struct Image* create_image(size_t width, size_t height)
   return ip;
 }
 
-struct ImageMask* create_image_mask(size_t width, size_t height)
+ImageMask* create_image_mask(size_t width, size_t height)
 {
-  struct ImageMask* ip = (struct ImageMask*)malloc(sizeof(struct ImageMask));
+  ImageMask* ip = (ImageMask*)malloc(sizeof(ImageMask));
   ip->width = width;
   ip->height = height;
   ip->mask = (ImageMaskData_t**)malloc(sizeof(ImageMaskData_t*) * ip->height);
@@ -27,7 +27,7 @@ struct ImageMask* create_image_mask(size_t width, size_t height)
   return ip;
 }
 
-void free_image(struct Image* image)
+void free_image(Image* image)
 {
   if (image->image[0] != NULL) {
     free(image->image[0]);
@@ -42,7 +42,7 @@ void free_image(struct Image* image)
   }
 }
 
-void free_image_mask(struct ImageMask* image_mask)
+void free_image_mask(ImageMask* image_mask)
 {
   if (image_mask->mask[0] != NULL) {
     free(image_mask->mask[0]);
diff --git a/lib/png.c b/lib/png.c
index 8d71ac8..5da0b95 100644
--- a/lib/png.c
+++ b/lib/png.c
@@ -4,7 +4,7 @@
 #include <png.h>
 
 // Save bitmap to file
-void save_png(struct bitmap_t* bitmap, char* fname)
+void save_png(Bitmap* bitmap, char* fname)
 {
   FILE *fp;
   png_structp png_ptr = NULL;
diff --git a/lib/seg/mask_data.c b/lib/seg/mask_data.c
index dc3a811..52a3ac4 100644
--- a/lib/seg/mask_data.c
+++ b/lib/seg/mask_data.c
@@ -4,9 +4,9 @@
 #include <stdio.h>
 
 // Allocate Mask Data for Label
-struct MaskData* create_mask_data(ImageMaskData_t label)
+MaskData* create_mask_data(ImageMaskData_t label)
 {
-  struct MaskData *data = (struct MaskData*)malloc(sizeof(struct MaskData));
+  MaskData *data = (MaskData*)malloc(sizeof(MaskData));
   data->label = label;
   data->area = 0;
   data->perimeter = 0;
@@ -14,15 +14,15 @@ struct MaskData* create_mask_data(ImageMaskData_t label)
 }
 
 // Compare mask data labels
-bool_t compare_labels(struct MaskData* left, struct MaskData* right)
+bool_t compare_labels(MaskData* left, MaskData* right)
 {
   return left->label < right->label;
 }
 
 // Create AVL Mask node
-struct AVLNode* create_avl_mask_node(struct MaskData* data)
+AVLNode* create_avl_mask_node(MaskData* data)
 {
-  struct AVLNode* node = (struct AVLNode*)malloc(sizeof(struct AVLNode));
+  AVLNode* node = (AVLNode*)malloc(sizeof(AVLNode));
   if (node == NULL) {
     return NULL;
   }
@@ -35,31 +35,31 @@ struct AVLNode* create_avl_mask_node(struct MaskData* data)
 }
 
 // Insert MaskData into the AVL Tree
-struct Result insert_mask(struct AVLNode* node, struct MaskData* data)
+Result insert_mask(AVLNode* node, MaskData* data)
 {
-  struct Result result;
+  Result result;
   // 1. Standard BST insertion
   if (node == NULL) {
-    return (struct Result) {create_avl_mask_node(data), TRUE};
+    return (Result) {create_avl_mask_node(data), TRUE};
   }
 
-  struct MaskData *node_data = (struct MaskData*)node->data;
+  MaskData *node_data = (MaskData*)node->data;
   if (node->compare(data, node_data)) {
     result = insert_mask(node->left, data);
     if (!result.success) {
       fprintf(stderr, "Failed to insert!");
       return result;
     }
-    node->left = (struct AVLNode*)result.data;
+    node->left = (AVLNode*)result.data;
   } else if (node->compare(node->data, data)) {
     result = insert_mask(node->right, data);
     if (!result.success) {
       fprintf(stderr, "Failed to insert!");
       return result;
     }
-    node->right = (struct AVLNode*)result.data;
+    node->right = (AVLNode*)result.data;
   } else {
-    return (struct Result) {node, FALSE};
+    return (Result) {node, FALSE};
   }
 
   // 2. Update height of the ancestor node
@@ -71,53 +71,53 @@ struct Result insert_mask(struct AVLNode* node, struct MaskData* data)
 
   // LeftLeft
   if ((balance > 1) && node->compare(data, node->left->data)) {
-    return (struct Result) {right_rotate(node), TRUE};
+    return (Result) {right_rotate(node), TRUE};
   }
   // RightRight
   if ((balance < -1) && node->compare(node->right->data, data)) {
-    return (struct Result) {left_rotate(node), TRUE};
+    return (Result) {left_rotate(node), TRUE};
   }
   // LeftRight
   if ((balance > 1) && node->compare(node->left->data, data)) {
-    return (struct Result) {right_rotate(node), TRUE};
+    return (Result) {right_rotate(node), TRUE};
   }
   // RightLeft
   if ((balance < -1) && node->compare(data,node->right->data)) {
-    return (struct Result) {left_rotate(node), TRUE};
+    return (Result) {left_rotate(node), TRUE};
   }
-  return (struct Result) {node, TRUE};
+  return (Result) {node, TRUE};
 }
 
 // Allocate a label's Mask data in a tree
 //  If it already exists, skip the allocation
-struct AVLNode* insert_mask_alloc(struct AVLNode* node, ImageMaskData_t label)
+AVLNode* insert_mask_alloc(AVLNode* node, ImageMaskData_t label)
 {
-  struct MaskData* data = create_mask_data(label);
-  struct Result result = insert_mask(node, data);
+  MaskData* data = create_mask_data(label);
+  Result result = insert_mask(node, data);
   if (!result.success) {
     free(data);
   }
-  return (struct AVLNode*)result.data;
+  return (AVLNode*)result.data;
 }
 
 // Print AVL Node Mask Data Label
-void print_label(struct AVLNode* root)
+void print_label(AVLNode* root)
 {
   if (root != NULL) {
     print_label(root->left);
-    struct MaskData* data = root->data;
+    MaskData* data = root->data;
     printf("%d: (%zu, %zu) ", data->label, data->area, data->perimeter);
     print_label(root->right);
   }
 }
 
 // Increase the label's area
-bool_t increase_label_area(struct AVLNode* root, ImageMaskData_t label)
+bool_t increase_label_area(AVLNode* root, ImageMaskData_t label)
 {
   if (root == NULL) {
     return FALSE;
   }
-  struct MaskData* data = (struct MaskData*)root->data;
+  MaskData* data = (MaskData*)root->data;
   if (data->label == label) {
     data->area++;
   }
@@ -131,12 +131,12 @@ bool_t increase_label_area(struct AVLNode* root, ImageMaskData_t label)
 }
 
 // Increase the label's perimeter
-bool_t increase_label_perimeter(struct AVLNode* root, ImageMaskData_t label)
+bool_t increase_label_perimeter(AVLNode* root, ImageMaskData_t label)
 {
   if (root == NULL) {
     return FALSE;
   }
-  struct MaskData* data = (struct MaskData*)root->data;
+  MaskData* data = (MaskData*)root->data;
   if (data->label == label) {
     data->perimeter++;
   }
@@ -151,9 +151,9 @@ bool_t increase_label_perimeter(struct AVLNode* root, ImageMaskData_t label)
 
 // Increase the label's area
 //  Create an AVL node if it doesn't exist
-struct AVLNode* increase_label_area_alloc(struct AVLNode* root, ImageMaskData_t label)
+AVLNode* increase_label_area_alloc(AVLNode* root, ImageMaskData_t label)
 {
-  struct AVLNode* new_root = root;
+  AVLNode* new_root = root;
   bool_t success = increase_label_area(new_root, label);
   if (success == FALSE) {
     new_root = insert_mask_alloc(new_root, label);
@@ -164,9 +164,9 @@ struct AVLNode* increase_label_area_alloc(struct AVLNode* root, ImageMaskData_t
 
 // Increase the label's perimeter
 //  Create an AVL node if it doesn't exist
-struct AVLNode* increase_label_perimeter_alloc(struct AVLNode* root, ImageMaskData_t label)
+AVLNode* increase_label_perimeter_alloc(AVLNode* root, ImageMaskData_t label)
 {
-  struct AVLNode* new_root = root;
+  AVLNode* new_root = root;
   bool_t success = increase_label_perimeter(new_root, label);
   if (success == FALSE) {
     new_root = insert_mask_alloc(new_root, label);
@@ -182,7 +182,7 @@ bool_t compare_image_mask_data_t(ImageMaskData_t* s1, ImageMaskData_t* s2)
 }
 
 // In-order traversal print pointer
-void print_in_order_image_mask_data_t(struct AVLNode* root)
+void print_in_order_image_mask_data_t(AVLNode* root)
 {
   if (root != NULL) {
     print_in_order_image_mask_data_t(root->left);
@@ -192,7 +192,7 @@ void print_in_order_image_mask_data_t(struct AVLNode* root)
 }
 
 // Check if ImageMaskData_t in AVLTree with ImageMaskData_t* data
-bool_t in_image_mask_data_t_tree(struct AVLNode* root, ImageMaskData_t value)
+bool_t in_image_mask_data_t_tree(AVLNode* root, ImageMaskData_t value)
 {
   if (root == NULL) {
     return FALSE;
@@ -208,15 +208,15 @@ bool_t in_image_mask_data_t_tree(struct AVLNode* root, ImageMaskData_t value)
 
 // Filter out small masks
 //  Assumption: Contiguous labeling
-struct AVLNode* get_small_labels(struct AVLNode* removal_tree, struct AVLNode* label_tree, size_t min_area, size_t min_perimeter)
+AVLNode* get_small_labels(AVLNode* removal_tree, AVLNode* label_tree, size_t min_area, size_t min_perimeter)
 {
-  struct AVLNode* return_tree = removal_tree;
+  AVLNode* return_tree = removal_tree;
   if (label_tree != NULL) {
     return_tree = get_small_labels(return_tree, label_tree->left, min_area, min_perimeter);
-    struct MaskData* node_data = (struct MaskData*)label_tree->data;
+    MaskData* node_data = (MaskData*)label_tree->data;
     if ((node_data->area < min_area) || (node_data->perimeter < min_perimeter)) {
       // Insert
-      struct Result result = avl_insert(return_tree, &node_data->label, (bool_t (*)(void*,void*))compare_image_mask_data_t);
+      Result result = avl_insert(return_tree, &node_data->label, (bool_t (*)(void*,void*))compare_image_mask_data_t);
       if (result.success) {
 	return_tree = result.data;
       }
@@ -227,9 +227,9 @@ struct AVLNode* get_small_labels(struct AVLNode* removal_tree, struct AVLNode* l
 }
 
 // Get mask label data
-struct AVLNode* get_mask_data(ImageMaskData_t* masks, uint32_t width, uint32_t height)
+AVLNode* get_mask_data(ImageMaskData_t* masks, uint32_t width, uint32_t height)
 {
-  struct AVLNode* root = NULL;
+  AVLNode* root = NULL;
   for (size_t y = 0; y < height; y++) {
     for (size_t x = 0; x < width; x++) {
       size_t coord = x + y*width;
@@ -247,8 +247,8 @@ struct AVLNode* get_mask_data(ImageMaskData_t* masks, uint32_t width, uint32_t h
 // 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)
 {
-  struct AVLNode* root = get_mask_data(masks, width, height);
-  struct AVLNode* small_label_tree = NULL;
+  AVLNode* root = get_mask_data(masks, width, height);
+  AVLNode* small_label_tree = NULL;
   small_label_tree = get_small_labels(NULL, root, min_area, min_perimeter);
   for (size_t y = 0; y < height; y++) {
     for (size_t x = 0; x < width; x++) {
diff --git a/lib/seg/util.c b/lib/seg/util.c
index 2952952..6eee1a2 100644
--- a/lib/seg/util.c
+++ b/lib/seg/util.c
@@ -202,7 +202,7 @@ void closeup(ImageMaskData_t** mask, uint32_t width, uint32_t height, size_t num
 // Combine Label Masks
 // For all empty spaces in the destination, put the extra label if it exists
 // Allocates an array if destination is unallocated
-struct ImageMask* combine_masks(struct ImageMask *destination, struct ImageMask *extra_labels)
+ImageMask* combine_masks(ImageMask *destination, ImageMask *extra_labels)
 {
   if (destination == NULL) {
     destination = create_image_mask(extra_labels->width, extra_labels->height);
@@ -220,7 +220,7 @@ struct ImageMask* combine_masks(struct ImageMask *destination, struct ImageMask
 // 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
-struct 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, ImageMaskData_t *starting_label_p)
 {
   TIFFSetWarningHandler(TiffDummyHandler);
   //-TIFF-IMAGE-OPEN-------------------------------
@@ -268,7 +268,7 @@ struct ImageMask* tif_to_labels(char* tif_file_name, uint32_t *width, uint32_t *
 
   //-FLOOD-FILL-SEGMENTATION-----------------------
   //-CONTIGUOUS-REGION-FINDING---------------------
-  struct ImageMask *im_data = create_image_mask((size_t)*width, (size_t)*height);
+  ImageMask *im_data = create_image_mask((size_t)*width, (size_t)*height);
   if (im_data == NULL) {
     fprintf(stderr, "Memory allocation error\n");
     free(image_data);
@@ -316,13 +316,13 @@ struct ImageMask* tif_to_labels(char* tif_file_name, uint32_t *width, uint32_t *
 }
 
 // Convert mask to bitmap
-struct bitmap_t* image_mask_data_to_bitmap(ImageMaskData_t* buffer, uint32_t width, uint32_t height)
+Bitmap* image_mask_data_to_bitmap(ImageMaskData_t* buffer, uint32_t width, uint32_t height)
 {
-  struct pixel_t* out_buffer = (struct pixel_t*)calloc(width*height, sizeof(struct pixel_t));
+  Pixel* out_buffer = (Pixel*)calloc(width*height, sizeof(Pixel));
   if (out_buffer == NULL) {
     return NULL;
   }
-  struct bitmap_t* bitmap = (struct bitmap_t*)malloc(sizeof(struct bitmap_t));
+  Bitmap* bitmap = (Bitmap*)malloc(sizeof(Bitmap));
   if (bitmap == NULL) {
     free(out_buffer);
     return NULL;
diff --git a/src/prog.c b/src/prog.c
index b118a22..e7f16ab 100644
--- a/src/prog.c
+++ b/src/prog.c
@@ -88,7 +88,7 @@ int main(int argc, char** argv)
   uint32_t width, height;
   ImageMaskData_t starting_label = 1;
   ImageMaskData_t *masks = NULL;
-  struct ImageMask *masks_im = NULL;
+  ImageMask *masks_im = NULL;
   // Expect a directory to be passed as the first argument
   if (directory != NULL) {
     // Ensure the directory exists
@@ -118,7 +118,7 @@ int main(int argc, char** argv)
 	  //-----------------------------------------------
 	  //-PROCESS-TIFF-TO-LABELS------------------------
 	  //-----------------------------------------------
-	  struct ImageMask *file_im = tif_to_labels(fpath, &width, &height, &starting_label);
+	  ImageMask *file_im = tif_to_labels(fpath, &width, &height, &starting_label);
 	  ImageMaskData_t *file_labels = file_im->mask[0];
 	  if (file_labels == NULL) {
 	    free(fpath);
@@ -175,7 +175,7 @@ int main(int argc, char** argv)
   //-OPTIONAL:-------------------------------------
   //-GET-MASK-META-INFORMATION---------------------
   //-----------------------------------------------
-  struct AVLNode* root = NULL;
+  AVLNode* root = NULL;
   root = get_mask_data(masks, width, height);
   if (!silent) {
     printf("Inorder traversal of AVL tree: ");
@@ -201,7 +201,7 @@ int main(int argc, char** argv)
   //-SAVE-MASK-AS-BINARY-AND-PNG-------------------
   //-----------------------------------------------
   if (masks != NULL) {
-    struct bitmap_t* bitmap = image_mask_data_to_bitmap(masks, width, height);
+    Bitmap* bitmap = image_mask_data_to_bitmap(masks, width, height);
     if (bitmap != NULL) {
       save_png(bitmap, png_file);
       free(bitmap);