The output buffer is no longer allocated by the distance transform

function.
Minor cmake and msvc build fixes.

Author: BlockoS

CMakeLists.txt

@@ -1,11 +1,10 @@
-cmake_minimum_required (VERSION 3.12)
+cmake_minimum_required (VERSION 3.20)
 
 project(distance C)
 
-find_package(Doxygen)
-
 file(WRITE ${CMAKE_BINARY_DIR}/distance.c "#define DISTANCE_TRANSFORM_IMPLEMENTATION\n#include \"${CMAKE_CURRENT_SOURCE_DIR}/distance.h\"")
-add_library(distance STATIC ${CMAKE_BINARY_DIR}/distance.c)
-target_compile_options(distance PUBLIC -Wall -Wshadow -Wextra)
-
+add_library(distance STATIC ${CMAKE_BINARY_DIR}/distance.c distance.h)
+target_include_directories(distance PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> )
+target_compile_options(distance PRIVATE $<IF:$<C_COMPILER_ID:MSVC>,/W4,-Wall -Wshadow -Wextra>)
+set_property(TARGET distance PROPERTY C_STANDARD 11)
 add_subdirectory(test)

distance.h

@@ -1,9 +1,9 @@
 /*
  Distance_transform computation using the fast sweeping method 
  =========================================================================
- v0.0.1
+ v0.1.0
  Licensed under the MIT License
- (c) 2020 Vincent Cruz
+ (c) 2020-2023 Vincent Cruz
  
  This header file provides a function to compute the distance transform of an image.
  The implementation is based upon the following papers:
@@ -20,25 +20,19 @@
  Before including this file, add the following line in the file where you want to have the 
  implementation.
 	#define DISTANCE_TRANSFORM_IMPLEMENTATION
-
- You can define DISTANCE_TRANSFORM_MALLOC and DISTANCE_TRANSFORM_FREE before the include
- to replace malloc and free.
  
  * Usage:
  
- 	float* distance_transform(const uint8_t *in, int width, int height);
+ 	void distance_transform(const uint8_t *in, float *out, int width, int height);
 
  "in" is the pointer an 8bpp greyscale image.
+ "output" is the pointer to the a floating point array of at least width*height elements. 
+ It will contain the distance map.
  "width" and "height" are its dimension.
  All pixels with a value of 0 are considered to be "inside", whereas any non-zero pixel is
  considered outside. As a consequence, a pixel is considered to be on the boundary if its
  value is 0 and at least one of its 8-neighbour is not zero.
- 
- "distance_transform" returns a pointer to an array of "width*height" floating point numbers
- containing for each pixel the distance to the closest boundary point.
- This array is allocated with `DISTANCE_TRANSFORM_MALLOC`. Use `DISTANCE_TRANSFORM_FREE`
- to delete it.
- 
+  
  * Note:
  This piece of code is not meant to be "production ready".
 
@@ -55,7 +49,7 @@
 extern "C" {
 #endif
 
-float* distance_transform(const uint8_t *in, int width, int height);
+void distance_transform(const uint8_t *in, float *output, int width, int height);
 
 #ifdef __cplusplus
 }
@@ -65,31 +59,13 @@ float* distance_transform(const uint8_t *in, int width, int height);
 
 #ifdef DISTANCE_TRANSFORM_IMPLEMENTATION
 
-#if defined(DISTANCE_TRANSFORM_MALLOC) && defined(DISTANCE_TRANSFORM_FREE)
-// ok
-#elif !defined(DISTANCE_TRANSFORM_MALLOC) && !defined(DISTANCE_TRANSFORM_FREE)
-// ok
-#else
-#error "Must define all or none of DISTANCE_TRANSFORM_MALLOC and DISTANCE_TRANSFORM_FREE"
-#endif
-
-#if !defined(DISTANCE_TRANSFORM_MALLOC)
-#define DISTANCE_TRANSFORM_MALLOC(sz) malloc(sz)
-#define DISTANCE_TRANSFORM_FREE(p)    free(p)
-#endif
-
-float* distance_transform(const uint8_t *in, int width, int height) {
+void distance_transform(const uint8_t *in, float *out, int width, int height) {
 	int i, j;
 	uint8_t c;
-	const float max_dist = width*width + height*height;
-	float *out = (float*)DISTANCE_TRANSFORM_MALLOC(width * height * sizeof(float));
+	const float max_dist = (float)(width*width + height*height);
 	float *ptr = out;
 	float *line;
 
-	if(out == NULL) {
-		return NULL;
-	}
-
 	// Initialize distance map by setting distance at boundary point to 0 and any other points to the maximal possible distance (width^2 + height^2).
 	// A boundary point is a pixel with a value of 0 and with a least one of its 8-neightbours different from 0.
 	c = ~in[0] & (in[1] | in[width] | in[width+1]);
@@ -137,110 +113,108 @@ float* distance_transform(const uint8_t *in, int width, int height) {
 	// Update distance in the 4 sweeping directions.
 #define update_distance(dx,dy,inc) \
 do { \
-	ptr[0] = fmin(ptr[0], (fabs((dx)-(dy)) >= 1) ? (fmin((dx), (dy)) + 1.f) : (((dx) + (dy) + sqrt(2.f - ((dx)-(dy))*((dx)-(dy)))) / 2.f)); \
+	ptr[0] = fminf(ptr[0], (fabs((dx)-(dy)) >= 1) ? (fminf((dx), (dy)) + 1.f) : (((dx) + (dy) + sqrtf(2.f - ((dx)-(dy))*((dx)-(dy)))) / 2.f)); \
 	ptr += (inc); \
 } while(0)
 
 	// y=[0,height[ x=[0,width[
 	ptr = out;
 	update_distance(ptr[1], ptr[width], +1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[width], +1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[width], +1);
 	}
 	update_distance(ptr[-1], ptr[width], +1);
 
 	line = ptr;
 	for(j=1; j<(height-1); j++, line+=width) {
 		ptr = line;
-		update_distance(ptr[1], fmin(ptr[-width], ptr[width]), +1);
+		update_distance(ptr[1], fminf(ptr[-width], ptr[width]), +1);
 		for(i=1; i<(width-1); i++) {
-			update_distance(fmin(ptr[-1], ptr[1]), fmin(ptr[-width], ptr[width]), +1);
+			update_distance(fminf(ptr[-1], ptr[1]), fminf(ptr[-width], ptr[width]), +1);
 		}
-		update_distance(ptr[-1], fmin(ptr[-width], ptr[width]), +1);
+		update_distance(ptr[-1], fminf(ptr[-width], ptr[width]), +1);
 	}
 
 	update_distance(ptr[1], ptr[-width], +1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[-width], +1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[-width], +1);
 	}
 	update_distance(ptr[-1], ptr[-width], +1);
 
 	// y=[0,height[ x=]width,0]
 	ptr = out+width-1;
 	update_distance(ptr[-1], ptr[width], -1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[width], -1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[width], -1);
 	}
 	update_distance(ptr[1], ptr[width], -1);
 
 	line = out+width;
 	for(j=1; j<(height-1); j++, line+=width) {
         ptr = line+width-1;
 
-		update_distance(ptr[-1], fmin(ptr[-width], ptr[width]), -1);
+		update_distance(ptr[-1], fminf(ptr[-width], ptr[width]), -1);
 		for(i=1; i<(width-1); i++) {
-			update_distance(fmin(ptr[-1], ptr[1]), fmin(ptr[-width], ptr[width]), -1);
+			update_distance(fminf(ptr[-1], ptr[1]), fminf(ptr[-width], ptr[width]), -1);
 		}
-		update_distance(ptr[1], fmin(ptr[-width], ptr[width]), -1);
+		update_distance(ptr[1], fminf(ptr[-width], ptr[width]), -1);
 	}
 
 	ptr = line + width-1;
 	update_distance(ptr[-1], ptr[-width], -1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[-width], -1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[-width], -1);
 	}
 	update_distance(ptr[1], ptr[-width], -1);
 
 	// y=]height,0] x=]width,0]
 	ptr = out+width-1+(height-1)*width;
 	update_distance(ptr[-1], ptr[-width], -1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[-width], -1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[-width], -1);
 	}
 	update_distance(ptr[1], ptr[-width], -1);
 
 	for(j=1; j<(height-1); j++) {
-		update_distance(ptr[-1], fmin(ptr[-width], ptr[width]), -1);
+		update_distance(ptr[-1], fminf(ptr[-width], ptr[width]), -1);
 		for(i=1; i<(width-1); i++) {
-			update_distance(fmin(ptr[-1], ptr[1]), fmin(ptr[-width], ptr[width]), -1);
+			update_distance(fminf(ptr[-1], ptr[1]), fminf(ptr[-width], ptr[width]), -1);
 		}
-		update_distance(ptr[1], fmin(ptr[-width], ptr[width]), -1);
+		update_distance(ptr[1], fminf(ptr[-width], ptr[width]), -1);
 	}
 
 	update_distance(ptr[-1], ptr[width], -1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[width], -1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[width], -1);
 	}
 	update_distance(ptr[1], ptr[width], -1);
 
 	// y=]height,0] x=[0,width[
 	line = ptr = out+(height-1)*width;
 	update_distance(ptr[1], ptr[-width], +1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[-width], +1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[-width], +1);
 	}
 	update_distance(ptr[-1], ptr[-width], +1);
 
 	line -= width;
 	for(j=1; j<(height-1); j++, line-=width) {
 		ptr = line;
-		update_distance(ptr[1], fmin(ptr[-width], ptr[width]), +1);
+		update_distance(ptr[1], fminf(ptr[-width], ptr[width]), +1);
 		for(i=1; i<(width-1); i++) {
-			update_distance(fmin(ptr[-1], ptr[1]), fmin(ptr[-width], ptr[width]), +1);
+			update_distance(fminf(ptr[-1], ptr[1]), fminf(ptr[-width], ptr[width]), +1);
 		}
-		update_distance(ptr[-1], fmin(ptr[-width], ptr[width]), +1);
+		update_distance(ptr[-1], fminf(ptr[-width], ptr[width]), +1);
 	}
 
 	ptr = line;
 	update_distance(ptr[1], ptr[width], +1);
 	for(i=1; i<(width-1); i++) {
-		update_distance(fmin(ptr[-1], ptr[1]), ptr[width], +1);
+		update_distance(fminf(ptr[-1], ptr[1]), ptr[width], +1);
 	}
 	update_distance(ptr[-1], ptr[width], +1);
 
 #undef update_distance
-
-	return out;
 }
 
 #endif /* DISTANCE_TRANSFORM_IMPLEMENTATION */

test/CMakeLists.txt

@@ -1,5 +1,4 @@
-
 add_library(stb_image STATIC stb_image.c stb_image.h stb_image_write.h)
 
 add_executable(compute main.c)
-target_link_libraries(compute stb_image distance m)
+target_link_libraries(compute stb_image distance)

test/main.c

@@ -35,11 +35,14 @@ int main(int argc, char **argv) {
 		return EXIT_FAILURE;
 	}
 
-	distance = distance_transform(input, width, height);
+	distance = (float*)malloc(width * height * sizeof(float));
 	if(distance == NULL) {
+		fprintf(stderr, "Failed to allocate distance map\n");
 		return EXIT_FAILURE;
 	}
 
+	distance_transform(input, distance, width, height);
+	
 	// find the maximum distance in order to scale the values to [0,1]
 	float max_dist = -1.f;
 	float *ptr = distance;
@@ -68,7 +71,7 @@ int main(int argc, char **argv) {
 
 	stbi_image_free(input);
 
-	DISTANCE_TRANSFORM_FREE(distance);
+	free(distance);
 
 	free(output);