Merge pull request #48 from saxbophone/develop

v0.11.1

Author: saxbophone

CMakeLists.txt

@@ -2,7 +2,7 @@
 cmake_minimum_required(VERSION 3.0)
 enable_language(C CXX)
 
-project(saxbospiral VERSION 0.11.0 LANGUAGES C)
+project(saxbospiral VERSION 0.11.1 LANGUAGES C)
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(

saxbospiral.png

@@ -12,6 +12,14 @@ const version_t VERSION = {
     .patch = SAXBOSPIRAL_VERSION_PATCH,
 };
 
+/*
+ * computes a version_hash_t for a given version_t,
+ * to be used for indexing and ordering
+ */
+version_hash_t version_hash(version_t version) {
+    return (version.major * 65536) + (version.minor * 256) + version.patch;
+}
+
 // vector direction constants
 const vector_t VECTOR_DIRECTIONS[4] = {
     // UP       RIGHT       DOWN        LEFT

saxbospiral/saxbospiral.c

@@ -22,6 +22,15 @@ typedef struct version_t {
 
 extern const version_t VERSION;
 
+// used for indexing and comparing different versions in order
+typedef uint32_t version_hash_t;
+
+/*
+ * computes a version_hash_t for a given version_t,
+ * to be used for indexing and ordering
+ */
+version_hash_t version_hash(version_t version);
+
 // type for representing a cartesian direction
 typedef uint8_t direction_t;
 

saxbospiral/saxbospiral.h

@@ -35,13 +35,20 @@ load_spiral(buffer_t buffer) {
         (strncmp((char *)buffer.bytes, "SAXBOSPIRAL", 11) == 0)
         && (buffer.size >= FILE_HEADER_SIZE + LINE_T_PACK_SIZE)
     ) {
-        // good to go
-        // TODO: Add checks for buffer data version compatibility
-        /*
-        version_t data_version = {
-            buffer.bytes[12], buffer.bytes[13], buffer.bytes[13],
+        // grab file version from header
+        version_t buffer_version = {
+            .major = buffer.bytes[12],
+            .minor = buffer.bytes[13],
+            .patch = buffer.bytes[14],
         };
-        */
+        // we don't accept anything over v0.11.x, so the max is v0.11.255
+        version_t max_version = { .major = 0, .minor = 11, .patch = 255, };
+        // check for version compatibility
+        if(version_hash(buffer_version) > version_hash(max_version)) {
+            // check failed
+            return output;
+        }
+        // good to go
         // get size of spiral object contained in buffer
         size_t spiral_size = 0;
         for(size_t i = 0; i < 8; i++) {

saxbospiral/serialise.c

@@ -75,9 +75,11 @@ spiral_collides(spiral_t spiral, size_t index) {
 }
 
 /*
- * given a spiral struct that is known to collide and the index of the 'last'
- * segment in the spiral (i.e. the one that was found to be colliding), return
- * a suggested length to set the segment before this line to.
+ * given a spiral struct that is known to collide, the index of the 'last'
+ * segment in the spiral (i.e. the one that was found to be colliding) and a
+ * perfection threshold (-1 for no perfection, or otherwise the maximmum line
+ * length at which to allow aggressive optimisation), return a suggested length
+ * to set the segment before this line to.
  *
  * NOTE: This function is not guaranteed to make suggestions that will not
  * collide. Every suggestion that is followed should then have the spiral
@@ -91,21 +93,31 @@ spiral_collides(spiral_t spiral, size_t index) {
  * line before the newly plotted line.
  */
 static length_t
-suggest_resize(spiral_t spiral, size_t index) {
+suggest_resize(spiral_t spiral, size_t index, int perfection_threshold) {
     // check if collides or not, return same size if no collision
     if(spiral.collides != -1) {
         /*
-         * if the colliding line's length is greater than 1, we cannot make any
-         * intelligent suggestions on the length to extend the previous line to
-         * (without the high likelihood of creating a line that wastes space),
-         * so we just return the previous line's length +1
+         * if the perfection threshold is -1, then we can just use our suggestion,
+         * as perfection is disabled.
+         * otherwise, if the colliding line's length is greater than our
+         * perfection threshold, we cannot make any intelligent suggestions on
+         * the length to extend the previous line to (without the high
+         * likelihood of creating a line that wastes space), so we just return
+         * the previous line's length +1
          */
-        if(spiral.lines[index].length > 1) {
+        if(
+            (perfection_threshold != -1) &&
+            (spiral.lines[index].length > (length_t)perfection_threshold)
+        ) {
             return spiral.lines[index - 1].length + 1;
         }
         // store the 'previous' and 'rigid' lines.
         line_t p = spiral.lines[index - 1];
         line_t r = spiral.lines[spiral.collides];
+        // if pr and r are not parallel, we can return early
+        if((p.direction % 2) != (r.direction % 2)) {
+            return spiral.lines[index - 1].length + 1;
+        }
         // create variables to store the start and end co-ords of these lines
         co_ord_t pa, pb, ra, rb;
         /*
@@ -155,11 +167,15 @@ suggest_resize(spiral_t spiral, size_t index) {
 
 /*
  * given a spiral struct, the index of one of it's lines and a target length to
- * set that line to, attempt to set the target line to that length,
- * back-tracking to resize the previous line if it collides.
+ * set that line to and a perfection threshold (-1 for no perfection, or
+ * otherwise the maximmum line length at which to allow aggressive optimisation)
+ * attempt to set the target line to that length, back-tracking to resize the
+ * previous line if it collides.
  */
 spiral_t
-resize_spiral(spiral_t spiral, size_t index, length_t length) {
+resize_spiral(
+    spiral_t spiral, size_t index, uint32_t length, int perfection_threshold
+) {
     /*
      * setup state variables, these are used in place of recursion for managing
      * state of which line is being resized, and what size it should be.
@@ -185,7 +201,9 @@ resize_spiral(spiral_t spiral, size_t index, length_t length) {
              * function to get the suggested length to resize the previous
              * segment to
              */
-            current_length = suggest_resize(spiral, current_index);
+            current_length = suggest_resize(
+                spiral, current_index, perfection_threshold
+            );
             current_index--;
         } else if(current_index != index) {
             /*
@@ -206,22 +224,24 @@ resize_spiral(spiral_t spiral, size_t index, length_t length) {
 }
 
 /*
- * given a spiral for which the length of all its lines are not yet known,
- * calculate the length needed for each line in the spiral (to avoid line overlap)
- * and store these in a spiral struct and return that
+ * given a spiral for which the length of all its lines are not yet known and
+ * a perfection threshold (-1 for no perfection, or otherwise the maximmum line
+ * length at which to allow aggressive optimisation) calculate the length needed
+ * for each line in the spiral (to avoid line overlap) and store these in a
+ * spiral struct and return that
  */
 spiral_t
-plot_spiral(spiral_t input) {
+plot_spiral(spiral_t spiral, int perfection_threshold) {
     // allocate new struct as copy of input struct
-    spiral_t output = { .size = input.size, };
+    spiral_t output = { .size = spiral.size, };
     output.lines = calloc(sizeof(line_t), output.size);
     // copy across the spiral lines
     for(size_t i = 0; i < output.size; i++) {
-        output.lines[i] = input.lines[i];
+        output.lines[i] = spiral.lines[i];
     }
     // calculate the length of each line
     for(size_t i = 0; i < output.size; i++) {
-        output = resize_spiral(output, i, 1);
+        output = resize_spiral(output, i, 1, perfection_threshold);
     }
     // free the co_ord_cache member's dynamic memory if required
     if(output.co_ord_cache.co_ords.size > 0) {

saxbospiral/solve.c

@@ -11,20 +11,26 @@ extern "C"{
 #endif
 
 /*
- * given a spiral for which the length of all its lines are not yet known,
- * calculate the length needed for each line in the spiral (to avoid line overlap)
- * and store these in a spiral struct and return that
+ * given a spiral for which the length of all its lines are not yet known and
+ * a perfection threshold (-1 for no perfection, or otherwise the maximmum line
+ * length at which to allow aggressive optimisation) calculate the length needed
+ * for each line in the spiral (to avoid line overlap) and store these in a
+ * spiral struct and return that
  */
 spiral_t
-plot_spiral(spiral_t spiral);
+plot_spiral(spiral_t spiral, int perfection_threshold);
 
 /*
  * given a spiral struct, the index of one of it's lines and a target length to
- * set that line to, attempt to set the target line to that length,
- * back-tracking to resize the previous line if it collides.
+ * set that line to and a perfection threshold (-1 for no perfection, or
+ * otherwise the maximmum line length at which to allow aggressive optimisation)
+ * attempt to set the target line to that length, back-tracking to resize the
+ * previous line if it collides.
  */
 spiral_t
-resize_spiral(spiral_t spiral, size_t index, uint32_t length);
+resize_spiral(
+    spiral_t spiral, size_t index, uint32_t length, int perfection_threshold
+);
 
 #ifdef __cplusplus
 } // extern "C"

saxbospiral/solve.h

@@ -85,7 +85,7 @@ buffer_to_file(buffer_t * buffer, FILE * file_handle) {
  */
 bool
 run(
-    bool prepare, bool generate, bool render,
+    bool prepare, bool generate, bool render, bool perfect, int perfect_threshold,
     const char * input_file_path, const char * output_file_path
 ) {
     // get input file handle
@@ -115,21 +115,31 @@ run(
         fprintf(stderr, "%s\n", "Couldn't read input file");
         return false;
     }
+    // resolve perfection threshold - set to -1 if disabled completely
+    int perfection = (perfect == false) ? -1 : perfect_threshold;
     if(prepare) {
         // we must build spiral from raw file first
         spiral_t spiral = init_spiral(input_buffer);
         if(generate) {
             // now we must plot all lines from spiral file
-            spiral = plot_spiral(spiral);
+            spiral = plot_spiral(spiral, perfection);
         }
         // TODO: Currently unable to generate and render all in one invocation
         // dump spiral
         output_buffer = dump_spiral(spiral);
     } else if(generate) {
         // try and load a spiral struct from input file
         spiral_t spiral = load_spiral(input_buffer);
+        // the spiral size will be set to 0 if buffer data was invalid
+        if(spiral.size == 0) {
+            fprintf(
+                stderr, "ERROR - File data was invalid (not a format accepted "
+                "by SAXBOSPIRAL " SAXBOSPIRAL_VERSION_STRING ")\n"
+            );
+            return false;
+        }
         // we must plot all lines from spiral file
-        spiral = plot_spiral(spiral);
+        spiral = plot_spiral(spiral, perfection);
         // dump spiral
         output_buffer = dump_spiral(spiral);
     } else if(render) {
@@ -189,18 +199,31 @@ main(int argc, char * argv[]) {
         "r", "render", "render the input spiral to an image (cannot be used "
         "with -p or -g options)"
     );
+    struct arg_lit * perfect = arg_lit0(
+        "D", "disable-perfection", "allow aggressive optimisations to take "
+        "place for a massive speed boost, at the cost of producing spirals that"
+        " are imperfect and waste some space with oversized lines"
+    );
+    struct arg_int * perfect_threshold = arg_int0(
+        "d", "perfection-threshold", NULL, "set a threshold above which length "
+        "lines are not optimised (default value is 1, which still yields "
+        "results)"
+    );
     // input file path option
     struct arg_file * input = arg_file0(
-        "i", "input", "<path>", "input file path"
+        "i", "input", NULL, "input file path"
     );
     // output file path option
     struct arg_file * output = arg_file0(
-        "o", "output", "<path>", "output file path"
+        "o", "output", NULL, "output file path"
     );
     // argtable boilerplate
     struct arg_end * end = arg_end(20);
     void * argtable[] = {
-        help, version, prepare, generate, render, input, output, end,
+        help, version,
+        prepare, generate, render,
+        perfect, perfect_threshold,
+        input, output, end,
     };
     const char * program_name = "sxp";
     // check argtable members were allocated successfully
@@ -211,8 +234,10 @@ main(int argc, char * argv[]) {
         );
         status_code = 2;
     }
+    // set default value of perfect_threshold argument
+    perfect_threshold->ival[0] = 1;
     // parse arguments
-    int count_errors = arg_parse(argc,argv,argtable);
+    int count_errors = arg_parse(argc, argv, argtable);
     // if we asked for the version, show it
     if(version->count > 0) {
         printf("Saxbospiral " SAXBOSPIRAL_VERSION_STRING "\n");
@@ -240,6 +265,8 @@ main(int argc, char * argv[]) {
         (prepare->count > 0) ? true : false,
         (generate->count > 0) ? true : false,
         (render->count > 0) ? true : false,
+        (perfect->count > 0) ? false : true,
+        perfect_threshold->ival[0],
         * input->filename,
         * output->filename
     );

sxp.c

@@ -38,7 +38,7 @@ buffer_to_file(buffer_t * buffer, FILE * file_handle);
  */
 bool
 run(
-    bool prepare, bool generate, bool render,
+    bool prepare, bool generate, bool render, bool perfect, int perfect_threshold,
     const char * input_file_path, const char * output_file_path
 );
 

sxp.h

@@ -206,7 +206,7 @@ test_plot_spiral() {
     }
 
     // call init_spiral with buffer and store result
-    spiral_t output = plot_spiral(input);
+    spiral_t output = plot_spiral(input, 1);
 
     // compare with expected struct
     for(uint8_t i = 0; i < 16; i++) {