Shorter type name

9 files changed, 71 insertions, 71 deletions

diff --git a/include/lib/algo/flood_fill.h b/include/lib/algo/flood_fill.h
index e9872eb..f446e3b 100644
--- a/include/lib/algo/flood_fill.h
+++ b/include/lib/algo/flood_fill.h
@@ -15,6 +15,6 @@
 //  4. Check if the (x,y) coordinate in the image is the same color as the fill color
 //  5. If all hold, set the label for the pixel, and check each neighbor
 //     Otherwise, stop flooding
-bool_t flood(ImageData_t* image, ImageMaskData_t* mask, size_t width, size_t height, size_t channels, size_t x, size_t y, ImageData_t* fill_color, ImageMaskData_t label);
+bool_t flood(ImageData_t* image, MaskData_t* mask, size_t width, size_t height, size_t channels, size_t x, size_t y, ImageData_t* fill_color, MaskData_t label);
 
 #endif
diff --git a/include/lib/data/image_types.h b/include/lib/data/image_types.h
index fdeeecc..79e395d 100644
--- a/include/lib/data/image_types.h
+++ b/include/lib/data/image_types.h
@@ -6,8 +6,8 @@
 
 #define ImageData_t uint8_t
 #define Image_t ImageData_t**
-#define ImageMaskData_t uint16_t
-#define ImageMask_t ImageMaskData_t**
+#define MaskData_t uint16_t
+#define ImageMask_t MaskData_t**
 
 typedef struct Image {
   size_t width;
diff --git a/include/lib/seg/mask_data.h b/include/lib/seg/mask_data.h
index 91b9074..72bd5f7 100644
--- a/include/lib/seg/mask_data.h
+++ b/include/lib/seg/mask_data.h
@@ -6,13 +6,13 @@
 #include <lib/monad.h>
 
 typedef struct MaskData {
-  ImageMaskData_t label;
+  MaskData_t label;
   size_t area;
   size_t perimeter;
 } MaskData;
 
 // Allocate Mask Data for Label
-MaskData* create_mask_data(ImageMaskData_t label);
+MaskData* create_mask_data(MaskData_t label);
 
 // Compare mask data labels
 bool_t compare_labels(MaskData* left, MaskData* right);
@@ -25,42 +25,42 @@ 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);
 
 // Print AVL Node Mask Data Label
 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);
 
 // 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);
 
 // 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);
 
 // 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);
 
-// 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);
 
 // In-order traversal print pointer
 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(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);
 
 // Filter out small masks
 //  Assumption: Contiguous labeling
 AVLNode* get_small_labels(AVLNode* removal_tree, AVLNode* label_tree, size_t min_area, size_t min_perimeter);
 
 // 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);
 
 // 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);
 
 #endif
diff --git a/include/lib/seg/util.h b/include/lib/seg/util.h
index 88389f6..db46e5a 100644
--- a/include/lib/seg/util.h
+++ b/include/lib/seg/util.h
@@ -12,16 +12,16 @@ 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);
 
 // 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);
 
 // 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);
 
 // Close up masks by N-pixels
-void closeup(ImageMaskData_t** mask, uint32_t width, uint32_t height, size_t count);
+void closeup(MaskData_t** mask, uint32_t width, uint32_t height, size_t count);
 
 // Combine Label Masks
 // For all empty spaces in the destination, put the extra label if it exists
@@ -31,14 +31,14 @@ 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);
 
 // 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);
 
 // 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);
 
 #endif
diff --git a/lib/algo/flood_fill.c b/lib/algo/flood_fill.c
index 0506532..d11b5aa 100644
--- a/lib/algo/flood_fill.c
+++ b/lib/algo/flood_fill.c
@@ -8,7 +8,7 @@
 //  4. Check if the (x,y) coordinate in the image is the same color as the fill color
 //  5. If all hold, set the label for the pixel, and check each neighbor
 //     Otherwise, stop flooding
-bool_t flood(ImageData_t* image, ImageMaskData_t* mask, size_t width, size_t height, size_t channels, size_t x, size_t y, ImageData_t* fill_color, ImageMaskData_t label)
+bool_t flood(ImageData_t* image, MaskData_t* mask, size_t width, size_t height, size_t channels, size_t x, size_t y, ImageData_t* fill_color, MaskData_t label)
 {
   if ((x >= width) | (y >= height)) {
     return FALSE;
diff --git a/lib/data/image_types.c b/lib/data/image_types.c
index 74c7ec4..b7be149 100644
--- a/lib/data/image_types.c
+++ b/lib/data/image_types.c
@@ -19,8 +19,8 @@ ImageMask* create_image_mask(size_t width, size_t height)
   ImageMask* ip = (ImageMask*)malloc(sizeof(ImageMask));
   ip->width = width;
   ip->height = height;
-  ip->image = (ImageMaskData_t**)malloc(sizeof(ImageMaskData_t*) * ip->height);
-  ImageMaskData_t* image_data = calloc(width*height, sizeof(ImageMaskData_t));
+  ip->image = (MaskData_t**)malloc(sizeof(MaskData_t*) * ip->height);
+  MaskData_t* image_data = calloc(width*height, sizeof(MaskData_t));
   for (size_t y = 0; y < height; y++) {
     ip->image[y] = &image_data[y*width];
   }
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;
diff --git a/src/prog.c b/src/prog.c
index 46e3eef..87b7bb3 100644
--- a/src/prog.c
+++ b/src/prog.c
@@ -86,8 +86,8 @@ int main(int argc, char** argv)
   //-----------------------------------------------
   char** file_list = NULL;
   uint32_t width, height;
-  ImageMaskData_t starting_label = 1;
-  ImageMaskData_t *masks = NULL;
+  MaskData_t starting_label = 1;
+  MaskData_t *masks = NULL;
   ImageMask *masks_im = NULL;
   // Expect a directory to be passed as the first argument
   if (directory != NULL) {
@@ -119,7 +119,7 @@ int main(int argc, char** argv)
 	  //-PROCESS-TIFF-TO-LABELS------------------------
 	  //-----------------------------------------------
 	  ImageMask *file_im = tif_to_labels(fpath, &width, &height, &starting_label);
-	  ImageMaskData_t *file_labels = file_im->image[0];
+	  MaskData_t *file_labels = file_im->image[0];
 	  if (file_labels == NULL) {
 	    free(fpath);
 	    free(file_list[index]);
@@ -206,7 +206,7 @@ int main(int argc, char** argv)
       save_png(bitmap, png_file);
       free(bitmap);
     }
-    write_array(bin_file, masks, width*height*sizeof(ImageMaskData_t));
+    write_array(bin_file, masks, width*height*sizeof(MaskData_t));
     free(masks);
   }
   TIME(ts_g_end);