Fix linking issues on windows

CMake/kwant-depends-kwiver.cmake

@@ -9,4 +9,3 @@ link_directories("${KWIVER_LIBRARY_DIRS}")
 include(kwiver-cmake-future)
 include(kwiver-utils)
 include(kwiver-flags)
-include(kwiver-configcheck)

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
 project( KWANT )
 
@@ -10,6 +10,10 @@ set(KWANT_VERSION_MINOR 1)
 set(KWANT_VERSION_PATCH 0)
 set(KWANT_VERSION "${KWANT_VERSION_MAJOR}.${KWANT_VERSION_MINOR}.${KWANT_VERSION_PATCH}")
 
+# C++17 is required for latest KWIVER
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
 ###
 # Ask for kwiver build directory
 #

scoring_framework/CMakeLists.txt

@@ -173,38 +173,34 @@ target_link_libraries(score_tracks_hadwav
 # Scoring
 ########################################
 
-if (fletch_ENABLED_libjson)
-  set(scoring_json_src)
-  set(json_lib ${LIBJSON_LIBRARY})
-
-  kwiver_add_executable( score_tracks score_tracks.cxx)
-  target_link_libraries( score_tracks
-                         vital_logger
-                         score_tracks_loader
-                         score_tracks_hadwav
-                         track_oracle
-                         track_oracle_file_formats
-                         timestamp_utilities
-                         ${json_lib} )
-endif()
+set(scoring_json_src)
+set(json_lib ${LIBJSON_LIBRARY})
+
+add_definitions( -DJSON_NO_EXCEPTIONS )
+kwiver_add_executable( score_tracks score_tracks.cxx)
+target_link_libraries( score_tracks
+  PRIVATE              score_tracks_loader
+                       score_tracks_hadwav
+                       track_oracle
+                       track_oracle_file_formats
+                       timestamp_utilities
+                       vital_logger )
 
 kwiver_add_executable( score_events score_events.cxx )
 target_link_libraries( score_events
-                       vital_logger
-                       logging_map
+  PRIVATE              logging_map
                        data_terms
                        score_tracks_loader
                        score_tracks_hadwav
                        scoring_aries_interface
-                       timestamp_utilities track_oracle
-                       track_oracle_format_base
-                       track_oracle_file_formats
+                       timestamp_utilities
+                       track_oracle
+                       vital_logger
                        vibrant_descriptors
-                       vul
                        track_filter_kpf_activity
                        kwiver_algo_kpf
-                       kpf_yaml
                        kwiversys
+                       kpf_yaml
                        kpf_utils
                        ${YAML_CPP_LIBRARIES}
                        ${Boost_SYSTEM_LIBRARY} )

scoring_framework/quickfilter_box.cxx

@@ -388,7 +388,7 @@ ::mgrs_box_intersect( const track_handle_type& t1,
     vgl_box_2d<double> overlap = vgl_intersection( t1_box, t2_box );
     if (dbg) LOG_DEBUG( main_logger, "mgrs_box_intersect: boxes:\n" << t1_box << "\n" << t2_box << "\n" << overlap );
 
-    return (overlap.is_empty()) ? 0.0 : vgl_area( overlap );
+    return (overlap.is_empty()) ? 0.0 : overlap.volume();
   }
 
   // if we get this far, we found no overlapping zones; the caller will
@@ -430,7 +430,7 @@ ::img_box_intersect( const track_handle_type& t1,
     return -1.0;
   }
 
-  return vgl_area( vgl_intersection( box_1, box_2 ));
+  return vgl_intersection( box_1, box_2 ).volume();
 }
 
 double

scoring_framework/score_events.cxx

@@ -1218,14 +1218,14 @@ compute_normalization_factors(  const track_handle_list_type& truth_tracks,
   vgl_box_2d<double> ne_box;  // northing / easting box; assume the zones all match
   add_tracks_to_box( truth_tracks, ne_box );
   add_tracks_to_box( computed_tracks, ne_box );
-  LOG_INFO( main_logger, "Normalization: MGRS all-tracks AOI is " << vgl_area( ne_box ) << " m^2" );
+  LOG_INFO( main_logger, "Normalization: MGRS all-tracks AOI is " << ne_box.volume() << " m^2" );
 
   timestamp_utilities::track_timestamp_stats_type tst_t( truth_tracks ), tst_c( computed_tracks );
   tst_t.combine_with_other( tst_c );
   double time_window_secs = (tst_t.minmax_ts.second - tst_t.minmax_ts.first) / 1.0e6;
   LOG_INFO( main_logger, "Normalization: all-tracks time window is " << time_window_secs << " seconds" );
 
-  double kmsq_in_box = vgl_area( ne_box ) / 1.0e6;
+  double kmsq_in_box = ne_box.volume() / 1.0e6;
 
   // e.g. if area == 3 and time_window_secs = 120, then to get to FA / (km^2 per s),
   // divide FA count by (3 * 120)
@@ -2292,6 +2292,11 @@ int main( int argc, char *argv[] )
     return EXIT_SUCCESS;
   }
 
+  if (! input_args.sanity_check() )
+  {
+    return EXIT_SUCCESS;
+  }
+
   activity_selector_type what_act = scoring_args.deduce_activity();
   LOG_INFO( main_logger, "Activity deduction: " << what_act );
 

scoring_framework/score_frames_aipr.cxx

@@ -97,12 +97,11 @@ void compute_frame_based_metrics(vector<frame_based_metrics>& fbm,
         vgl_box_2d<unsigned> intersection = vgl_intersection(gt->history()[0]->amhi_bbox_,comp->history()[0]->amhi_bbox_);
 
         double overlap_score = 0;
-        if( vgl_area( intersection ) != 0)
+        if( intersection.volume() != 0 )
         {
-          overlap_score = ( vgl_area( gt->history()[0]->amhi_bbox_) +
-                            vgl_area( comp->history()[0]->amhi_bbox_) -
-                            vgl_area( intersection ))
-            / vgl_area( intersection );
+          overlap_score = ( gt->history()[0]->amhi_bbox_.volume() +
+                            comp->history()[0]->amhi_bbox_.volume() -
+                            intersection.volume() ) / intersection.volume();
         }
 
         if(!intersection.is_empty() && overlap_score >= min_overlap_ratio)

scoring_framework/score_phase1.cxx

@@ -656,9 +656,9 @@ ::compute_spatial_overlap( frame_handle_type t1, frame_handle_type t2, phase1_pa
   {
     // it's pretty annoying but some of the code (e.g. score_phase2_aipr.cxx:60)
     // seems to rely on these being set ONLY if there is overlap
-    ret.truth_area = vgl_area( b1 );
-    ret.computed_area = vgl_area( b2 );
-    ret.overlap_area = vgl_area( bi );
+    ret.truth_area = b1.volume();
+    ret.computed_area = b2.volume();
+    ret.overlap_area = bi.volume();
 
     double dx = b1.centroid_x() - b2.centroid_x();
     double d_center_y = b1.centroid_y() - b2.centroid_y();

scoring_framework/score_tracks.cxx

@@ -31,7 +31,6 @@
 #include <scoring_framework/timestamp_utilities.h>
 
 #include <vital/config/config_block.h>
-#include <json.h>
 
 #include <vital/logger/logger.h>
 static kwiver::vital::logger_handle_t main_logger( kwiver::vital::get_logger( __FILE__ ) );
@@ -64,14 +63,12 @@ struct output_args_type
 {
   vul_arg< string > track_stats_fn;
   vul_arg< string > target_stats_fn;
-  vul_arg< string > json_dump_fn;
   vul_arg< string > matches_dump_fn;
   vul_arg< string > frame_level_matches_fn;
 
   output_args_type()
     : track_stats_fn(  "--track-stats", "write track purity / continuity to file" ),
       target_stats_fn( "--target-stats", "write target purity / continuity to file" ),
-      json_dump_fn(    "--j", "write results in json format to file" ),
       matches_dump_fn( "--matches", "write track match info to file" ),
       frame_level_matches_fn( "--frame-level-match","writes out gt to cp frame level match information")
   {}
@@ -447,7 +444,7 @@ compute_normalization_factor( const phase1_parameters& p1_params,
     if (compute_norm)
     {
       double g = normalization_args.gsd(); // meters-per-pixel
-      double data_spatial_footprint = vgl_area( p1_params.b_aoi ) * g * g; // m^2
+      double data_spatial_footprint = p1_params.b_aoi.volume() * g * g; // m^2
       norm = data_spatial_footprint * normalization_args.norm_data_time(); // (m^2)*s
     }
   }
@@ -668,8 +665,6 @@ int main( int argc, char *argv[] )
     write_activity_overlay( os, aoi_filtered_truth_tracks, aoi_filtered_computed_tracks, p1 );
   }
 
-  JSONNode json_root(JSON_NODE);  // for json output option
-
   if(score_hadwav_flag())
   {
     track2track_phase2_hadwav p2( verbose_flag() );
@@ -755,61 +750,6 @@ int main( int argc, char *argv[] )
     cout << "  Avg target (continuity, purity ): " << p3.avg_target_continuity << ", "
              << p3.avg_target_purity << endl;
     cout <<  "  Track-frame-precision: " << p2.trackFramePrecision << endl;
-
-    if ( output_args.json_dump_fn.set() )
-    {
-      // Add json objects
-      JSONNode hadwav_node(JSON_NODE);
-      hadwav_node.set_name("hadwav-results");
-
-      hadwav_node.push_back(JSONNode("detection-pd", p2.detectionPD));
-      hadwav_node.push_back(JSONNode("detection-false-alarms", p2.detectionFalseAlarms));
-      hadwav_node.push_back(JSONNode("detection-probability-false-alarms", p2.detectionPFalseAlarm));
-      hadwav_node.push_back(JSONNode("track-pd", p3.trackPd));
-      hadwav_node.push_back(JSONNode("track-fa", p3.trackFA));
-      hadwav_node.push_back(JSONNode("track-fp", p2.trackFramePrecision));
-      if (norm.first)
-      {
-        hadwav_node.push_back(JSONNode("frame-nfar", p2.frameFA/norm.second));
-        hadwav_node.push_back(JSONNode("track-nfar", p3.trackFA/norm.second));
-      }
-      else
-      {
-        hadwav_node.push_back(JSONNode("frame-nfar", "not computed"));
-        hadwav_node.push_back(JSONNode("track-nfar", "not computed"));
-      }
-      hadwav_node.push_back(JSONNode("avg-track-continuity", p3.avg_track_continuity));
-      hadwav_node.push_back(JSONNode("avg-track-purity", p3.avg_track_purity));
-      hadwav_node.push_back(JSONNode("avg-target-continuity", p3.avg_target_continuity));
-      hadwav_node.push_back(JSONNode("avg-target-purity", p3.avg_target_purity));
-
-      json_root.push_back(hadwav_node);
-    }
-  }
-
-  if ( output_args.json_dump_fn.set() )
-  {
-    // Add json objects
-    JSONNode version_node(JSON_NODE);
-    version_node.set_name("vidtk-meta");
-    //    version_node.push_back(JSONNode("version", VIDTK_GIT_VERSION));
-    version_node.push_back(JSONNode("version", "not-available" ));
-    json_root.push_back(version_node);
-  }
-
-  if ( output_args.json_dump_fn.set() )
-  {
-    ofstream os( output_args.json_dump_fn().c_str() );
-    if ( ! os )
-    {
-      LOG_ERROR( main_logger, "Couldn't dump results to '" << output_args.json_dump_fn() << "'?");
-    }
-    else
-    {
-      string json_output = json_root.write_formatted();
-      os << json_output;
-      os.close();
-    }
   }
 
   if ( track_dump_fn_arg.set() )