Merge pull request #28 from minorsecond/develop

Release 1.2.2

Author: minorsecond

Diff for: src/job.cpp

@@ -86,14 +86,8 @@ std::string Job::get_location_path() const {
 std::string Job::find_gis_path() const {
     /*
      * Finds path to GIS directory inside documents directory
-     * @param job_number: The job number to search for
-     * @return: The path as a string
      */
 
-    /*
-     * Finds zip file in Downloads directory that contains job_number
-     * @param job_number: Job number to search for
-     */
     UtilityFunctions ut;
     const std::string download_path {ut.get_home_path() + "\\Documents\\Comsof_Jobs"};
     for (const auto & entry : std::filesystem::directory_iterator(download_path)) { // Iterate over states

Diff for: src/shapeeditor.cpp

@@ -23,6 +23,7 @@ OGRLayer* ShapeEditor::shapefile_reader(const std::string path) {
     poDataset = (GDALDataset *) GDALOpenEx(path.c_str(), GDAL_OF_ALL | GDAL_OF_UPDATE, NULL, NULL, NULL);
     OGRLayer *layer {poDataset->GetLayer(0)};
 
+
     return layer;
 }
 
@@ -39,78 +40,126 @@ OGRLayer* ShapeEditor::create_demand_point_fields(OGRLayer *dp_layer) {
     return dp_layer;
 }
 
-void ShapeEditor::process_demand_points(const std::string name_to_change, OGRLayer *in_layer) {
+void ShapeEditor::process_demand_points(OGRLayer *in_layer) {
     /*
      * Process demand points
      * @param name_to_change: The attribute name to change to all caps
      * @param in_layer: An OGRLayer that contains the attribute name to change
      */
+
+    /*
+     * All field searches assume that CGIS provides attribute names in lowercase, which has
+     * been the case so far. If they begin also providing them in uppercase, we'll need to
+     * add nested if/else statements to try to determine if the field exists in whichever
+     * case.
+     */
+
     ErrorWindow er;
     const std::string input_streetname_field_name {"street_nam"};
-    int include_field_idx {find_field_index("include", in_layer)};  // Find include field. Returns -1 if "include" isn't present
+    const int include_field_idx {find_field_index("include", in_layer)};  // Find include field. Returns -1 if "include" isn't present
+    int pon_homes_field_idx {-1};
     bool all_pon_homes_zero {true};
     bool override_pon_homes {false};
 
     if (include_field_idx == -1) {
-        er.set_error_message("Error: could not find " + name_to_change + " in demand points layer. Defaulting to True.");
+        er.set_error_message("Error: could not find include field in demand points layer. Defaulting to True.");
         er.exec();
     }
 
     // Create tmp field to store original include field and populate it with original include values
     // This is done to switch from the lowercase "include" field to uppercase "INCLUDE"
+    create_tmp_include_field(include_field_idx, in_layer);
+
+    // Create tmp field to store original pon_homes values, just as we did for the inlude field
+    create_tmp_pon_homes_field(in_layer, pon_homes_field_idx, all_pon_homes_zero);
+
+    // Prompt user if they want to set PON_HOMES to 1 if CGIS has set them all to 0.
+    if (all_pon_homes_zero && pon_homes_field_idx != -1) {
+        OverridePonHomes override = OverridePonHomes();
+        override.setModal(true);
+        if (override.exec() == QDialog::Accepted) {
+            override_pon_homes = true;
+        }
+    }
+
+    int streetname_idx {find_street_name_field(in_layer)};
+    add_dp_fields(in_layer, include_field_idx, override_pon_homes, pon_homes_field_idx, streetname_idx);
+
+    delete_tmp_dp_fields(in_layer, include_field_idx, pon_homes_field_idx);
+}
+
+void ShapeEditor::create_tmp_include_field(const int include_field_idx, OGRLayer *in_layer) {
+    /*
+     * Create tmp field to store original include field and populate it with original include values
+     * This is done to switch from the lowercase "include" field to uppercase "INCLUDE"
+     */
+
     if (include_field_idx != -1) {
         OGRFieldDefn tmp_include_field_def("tmp_inc", OFTString);
         in_layer->CreateField(&tmp_include_field_def);
 
         for (OGRFeatureUniquePtr &feature : in_layer) {
-            std::string include_attr {feature->GetFieldAsString(include_field_idx)};
+            const std::string include_attr {feature->GetFieldAsString(include_field_idx)};
             std::cout << "Include attr: " << include_attr << std::endl;
             feature->SetField("tmp_inc", include_attr.c_str());
             in_layer->SetFeature(feature.release());
         }
         std::cout << "Deleting include field at index " << include_field_idx << std::endl;
         in_layer->DeleteField(include_field_idx);  // Delete original include field
     }
+}
 
-    // Create tmp field to store original pon_homes values, just as we did for the inlude field
-    int pon_homes_field_idx {find_field_index("pon_homes", in_layer)};  // Find pon_homes field
-    if (pon_homes_field_idx != -1) {
+void ShapeEditor::create_tmp_pon_homes_field(OGRLayer *in_layer, int &pon_homes_idx, bool &all_zero) {
+    /* Create tmp pon_homes field and set pon_homes idx and all_zero
+     * @param in_layer: The layer to modify (create tmp pon homes field in)
+     * @param pon_homes_idx: The column number of the pon_homes attribute
+     * @param all_zero: a bool denoting whether all pon_home values are 0
+     */
+
+    pon_homes_idx = find_field_index("pon_homes", in_layer);  // Find pon_homes field
+
+    if (pon_homes_idx != -1) {
         OGRFieldDefn tmp_pon_homes_field_defn("tmp_ph", OFTInteger);
         in_layer->CreateField(&tmp_pon_homes_field_defn);
 
         for (OGRFeatureUniquePtr &feature : in_layer) {
-            int ph_attr {feature->GetFieldAsInteger(pon_homes_field_idx)};
+            const int ph_attr {feature->GetFieldAsInteger(pon_homes_idx)};
             if (ph_attr == 1) {
-                all_pon_homes_zero = false;
+                all_zero = false;
             }
 
             feature->SetField("tmp_ph", ph_attr);
             in_layer->SetFeature(feature.release());
         }
-        std::cout << "Deleting pon_homes field at index " << pon_homes_field_idx << std::endl;
-        in_layer->DeleteField(pon_homes_field_idx);
+        std::cout << "Deleting pon_homes field at index " << pon_homes_idx << std::endl;
+        in_layer->DeleteField(pon_homes_idx);
     }
 
-    // Prompt user if they want to set PON_HOMES to 1 if CGIS has set them all to 0.
-    if (all_pon_homes_zero && pon_homes_field_idx != -1) {
-        OverridePonHomes override = OverridePonHomes();
-        override.setModal(true);
-        if (override.exec() == QDialog::Accepted) {
-            override_pon_homes = true;
-        }
-    }
+}
 
-    // Find street name field
-    int streetname_idx {find_field_index("street_nam", in_layer)};
-    if (streetname_idx == -1) {
-        streetname_idx = find_field_index("street", in_layer);
+int ShapeEditor::find_street_name_field(OGRLayer *in_layer) {
+    /*
+     * Find the streetname field
+     * @param in_layer: The layer to search
+     */
+
+    std::array<std::string, 2> streetname_attr_names {"street_nam", "street"};
+    int streetname_idx {-1};
+    for (std::string attr_name : streetname_attr_names) {
         if (streetname_idx == -1) {
-            er.set_error_message("Warning: could not find streetname field");
-            er.exec();
+            streetname_idx = find_field_index(attr_name, in_layer);
         }
     }
 
-    // Add the new fields
+    return streetname_idx;
+}
+
+void ShapeEditor::add_dp_fields(OGRLayer *in_layer, const int include_field_idx, const bool override_pon_homes, const int pon_homes_field_idx, const int streetname_idx) {
+    /*
+     * Add new fields to demand points layer
+     * @param in_layer: The layer to add fields to
+     */
+
     OGRFieldDefn new_include_Field("INCLUDE", OFTString);
     OGRFieldDefn new_pon_homes_field("PON_HOMES", OFTString);
     OGRFieldDefn streetname_field("STREETNAME", OFTString);
@@ -121,11 +170,6 @@ void ShapeEditor::process_demand_points(const std::string name_to_change, OGRLay
 
     in_layer->ResetReading();  // Restart reading layer at beginning
 
-    // Ask user if they want to override the pon_homes attribute if CGIS has them all set to 0
-    if (all_pon_homes_zero) {
-        // Raise ask pon homes ui
-    }
-
     // Populate new field
     for (OGRFeatureUniquePtr &feature : in_layer) {
         std::string tmp_include_value {};
@@ -150,25 +194,38 @@ void ShapeEditor::process_demand_points(const std::string name_to_change, OGRLay
         }
         feature->SetField("PON_HOMES", tmp_ph_value);
 
+        // Here, we convert streetnames to uppercase, or set the field to UNKNOWN if
+        // the CGIS streetname attribute doesn't exist.
         std::string streetname {};
         if (streetname_idx != -1) {
-            streetname = uppercase_string(feature->GetFieldAsString(streetname_idx));
+            streetname = feature->GetFieldAsString(streetname_idx);
+            std::transform(streetname.begin(), streetname.end(), streetname.begin(), [] (unsigned char c) {return std::toupper(c);});
         } else {
             streetname = "UNKNOWN";
         }
 
         feature->SetField("STREETNAME", streetname.c_str());
         in_layer->SetFeature(feature.release());
     }
+}
 
+void ShapeEditor::delete_tmp_dp_fields(OGRLayer *in_layer, int include_field_idx, int pon_homes_field_idx) {
+    /*
+     * Delete temporary demand point fields.
+     * @param in_layer: The layer to delete from
+     */
+
+    // Find & delete tmp include field.
     if (include_field_idx != -1) {
-        int tmp_index {find_field_index("tmp_inc", in_layer)};
+        const int tmp_index {find_field_index("tmp_inc", in_layer)};
         if (tmp_index != -1) {  // Just in case we can't find the tmp_include attribute
             in_layer->DeleteField(find_field_index("tmp_inc", in_layer));
         }
     }
+
+    // Find & delete tmp pon_homes field.
     if (pon_homes_field_idx != -1) {
-        int tmp_index {find_field_index("tmp_ph", in_layer)};
+        const int tmp_index {find_field_index("tmp_ph", in_layer)};
         if (tmp_index != -1) {
             in_layer->DeleteField(tmp_index);
         }
@@ -184,21 +241,21 @@ void ShapeEditor::process_access_points(OGRLayer *in_layer) {
     OGRFieldDefn type_defn("TYPE", OFTString);
     type_defn.SetWidth(254);
     in_layer->CreateField(&type_defn);
-    int structur2_idx {find_field_index("structur_2", in_layer)};
+    const int structur2_idx {find_field_index("structur_2", in_layer)};
 
     if (find_field_index("structur_1", in_layer) == -1) {
         er.set_error_message("Error: Could not find structur_1 attribute in access_points layer.");
         er.exec();
         return;
     }
 
-
+    // Loop through AP features and add the TYPE attribute.
     for (OGRFeatureUniquePtr &feature : in_layer) {
         std::string size {};
         std::string new_type {};
         const std::string type {feature->GetFieldAsString("structur_1")};  // TODO: Handle different attribute names
         if (structur2_idx != -1) {
-            size = feature->GetFieldAsString(structur2_idx);
+            size = feature->GetFieldAsString(structur2_idx);  // Get size value from structur2 field.
         }
 
         if (!size.empty()) {
@@ -295,18 +352,18 @@ void ShapeEditor::process_fdt_boundaries(OGRLayer *in_layer) {
 
 int ShapeEditor::find_field_index(const std::string field_name, OGRLayer *in_layer) {
     /*
-     * Find the index of field
+     * Find the index of field. Returns -1 if field could not be found.
      * @param in_layer: The layer to search
      * @param field_name: Field to search for
      */
     int field_idx {NULL};
     bool field_found {false};
     OGRFeatureDefn *lyr_def {in_layer->GetLayerDefn()};
-    int field_count {lyr_def->GetFieldCount()};
+    const int field_count {lyr_def->GetFieldCount()};
     std::cout << "Field count: " << field_count << std::endl;
     for (int idx {0}; idx < field_count; idx ++) {
         OGRFieldDefn field_def {lyr_def->GetFieldDefn(idx)};
-        std::string shp_name {field_def.GetNameRef()};
+        const std::string shp_name {field_def.GetNameRef()};
         if (shp_name == field_name) {
             field_idx = idx;  // This is the field index that will be changed
             field_found = true;
@@ -319,21 +376,7 @@ int ShapeEditor::find_field_index(const std::string field_name, OGRLayer *in_lay
     return field_idx;
 }
 
-std::string ShapeEditor::uppercase_string(std::string input_string) {
-    /*
-     * Convert string to an uppercase string
-     * @param input_string: Input string
-     * @return string: Input string as all uppercase
-     */
-
-    std::string uppercase_string {input_string};
-    for (int i {0}; i < uppercase_string.size(); i++) {
-        uppercase_string[i] = std::toupper(uppercase_string[i]);
-    }
-    return uppercase_string;
-}
-
-void ShapeEditor::reproject(OGRLayer *in_layer, int utm_zone, std::string path) {
+void ShapeEditor::reproject(OGRLayer *in_layer, const int utm_zone, const std::string &path) {
     /*
      * Reproject the layer.
      * @param in_layer: The layer to reproject
@@ -346,15 +389,15 @@ void ShapeEditor::reproject(OGRLayer *in_layer, int utm_zone, std::string path)
     poDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName);
 
     // Convert UTM zone integer into the EPSG code. This map will be updated
-    // as new areas become active. the N specifier, e.g. 10N, is taken for
-    // granted.
+    // as new areas become active. the N specifier, e.g. 10N, is assumed.
 
     // Proj library path
     const std::string ppath {std::filesystem::current_path().string()};
     const char * proj_path[] {ppath.c_str(), nullptr};
     std::cout << "Searching for proj.db in " << ppath << std::endl;
     OSRSetPROJSearchPaths(proj_path);
 
+    // Convert UTM zone string into CRS integer for GDAL
     int crs {};
     for (auto it {utm_zones.begin()}; it != utm_zones.end(); it++) {
         if (it->first == utm_zone) {
@@ -364,8 +407,7 @@ void ShapeEditor::reproject(OGRLayer *in_layer, int utm_zone, std::string path)
 
     // Get projection data
     OGRSpatialReference *srFrom {in_layer->GetSpatialRef()};
-    //OGRSpatialReference *srTo = new OGRSpatialReference;
-    auto srTo = std::make_unique<OGRSpatialReference>();
+    auto srTo {std::make_unique<OGRSpatialReference>()};
 
     std::cout << "Converting to EPSG: " << crs << std::endl;
     srTo->importFromEPSG(crs);
@@ -392,7 +434,7 @@ void ShapeEditor::reproject(OGRLayer *in_layer, int utm_zone, std::string path)
         poLayer->SetFeature(feature.release());
     }
     // Cleanup
+    delete coordTrans;
     poLayer->SyncToDisk();
     GDALClose(poDS);
-    //delete srTo;
 }

Diff for: src/shapeeditor.h

@@ -22,16 +22,22 @@ class ShapeEditor
 public:
     GDALDriverH gdaldriver {GDALGetDriverByName("ESRI Shapefile")};
     static OGRLayer* shapefile_reader(const std::string path);
-    static OGRLayer* create_demand_point_fields(OGRLayer *dp_layer);
-    static void process_demand_points(const std::string name_to_change, OGRLayer *in_layer);
+    static void process_demand_points(OGRLayer *in_layer);
     static void process_access_points(OGRLayer *in_layer);
     static void process_poles(OGRLayer *in_layer);
     static void process_aerial_connections(OGRLayer *in_layer);
     static void process_fdt_boundaries(OGRLayer *in_layer);
-    static void reproject(OGRLayer *in_layer, int utm_zone, std::string path);
-    static int find_field_index (const std::string field_name, OGRLayer *in_layer);
-    static std::string uppercase_string(std::string input_string);
+    static void reproject(OGRLayer *in_layer, const int utm_zone, const std::string &path);
     ShapeEditor();
+
+private:
+    static OGRLayer* create_demand_point_fields(OGRLayer *dp_layer);
+    static void create_tmp_include_field(const int include_field_idx, OGRLayer *in_layer);
+    static void create_tmp_pon_homes_field(OGRLayer *in_layer, int &pon_homes_idx, bool &all_zero);
+    static int find_street_name_field(OGRLayer *in_layer);
+    static void add_dp_fields(OGRLayer *in_layer, const int include_field_idx, const bool override_pon_homes, const int pon_homes_field_idx, const int streetname_idx);
+    static void delete_tmp_dp_fields(OGRLayer *in_layer, int include_field_idx, int pon_homes_field_idx);
+    static int find_field_index (const std::string field_name, OGRLayer *in_layer);
 };
 
 #endif // SHAPEEDITOR_H