AIAA Client GA Release (#15)

* Support NVIDIA Segmentation+Annotation in AIAA Client+MITK Workbench
* Add and show extreme points into pointset interaction
* Fix URL for /models
* PY Client segmentation API + Test data
* Add Segmentation API example into tools
* Support label and type in ListModels tool
* support model type as optional field in models() API
* Fix UI refresh for MITK plugin
* Support model name instead of labels (design review) + fix color map for multi-labeled masks
* Support label based model filtering config + correct tooltips

Author: SachidanandAlle

cpp-client/include/nvidia/aiaa/client.h

@@ -70,6 +70,15 @@ class AIAA_CLIENT_API Client {
    */
   ModelList models() const;
 
+  /*!
+   @brief This API is used to fetch all the possible Models support by AIAA Server for matching label and model type
+   @return ModelList object representing a list of Models
+
+   @throw nvidia.aiaa.error.101 in case of connect error
+   @throw nvidia.aiaa.error.102 if case of response parsing
+   */
+  ModelList models(const std::string &label, const Model::ModelType type) const;
+
   /*!
    @brief This API is used to sample the input image
    @param[in] model  Model to be used
@@ -105,26 +114,25 @@ class AIAA_CLIENT_API Client {
                     const std::string &outputImageFile, ImageInfo &imageInfo) const;
 
   /*!
-   @brief 3D image segmentation over sampled input image and PointSet
-   @param[in] model  Model to be used
-   @param[in] pointSet  PointSet object which represents a set of points in 3-Dimensional for the organ. Minimum Client::MIN_POINTS_FOR_SEGMENTATION are expected
+   @brief 3D image segmentation/annotation over sampled input image and PointSet depending on input Model
+   @param[in] model  Model to be used (it can be for segmentation or annotation)
+   @param[in] pointSet  PointSet object which represents a set of points in 3-Dimensional for the organ.
    @param[in] dimension  Dimension for Input Image
    @param[in] inputImageFile  Sampled Input image filename where image is stored in itk::Image<unsigned short, *> format
    @param[in] outputImageFile  File name to store 3D binary mask image result from AIAA server in itk::Image<unsigned char, *> format
+   @param[in] imageInfo  Optional Original ImageInfo to recover in case of annotation models after inference
 
-   @retval 0 Success
-   @retval -1 Insufficient Points in the input
-   @retval -2 Input Model name is empty
+   @retval New/Updated Pointset in case of segmentation which represents a set of points in 3-Dimensional for the organ.
 
    @throw nvidia.aiaa.error.101 in case of connect error
    @throw nvidia.aiaa.error.102 if case of response parsing
    @throw nvidia.aiaa.error.103 if case of ITK error related to image processing
    */
-  int segmentation(const Model &model, const PointSet &pointSet, const std::string &inputImageFile, int dimension, const std::string &outputImageFile,
-                const ImageInfo &imageInfo) const;
+  PointSet segmentation(const Model &model, const PointSet &pointSet, const std::string &inputImageFile, int dimension, const std::string &outputImageFile,
+                const ImageInfo &imageInfo = ImageInfo()) const;
 
   /*!
-   @brief 3D image segmentation using DEXTR3D method  (this combines sampling + segmentation into single operation for 3D images)
+   @brief 3D image annotation using DEXTR3D method  (this combines sampling + segmentation into single operation for 3D images)
    @param[in] model  Model to be used
    @param[in] pointSet  PointSet object which represents a set of points in 3-Dimensional for the organ. Minimum Client::MIN_POINTS_FOR_SEGMENTATION are expected
    @param[in] inputImageFile  Input image filename where image is stored in itk::Image<?, 3> format

cpp-client/include/nvidia/aiaa/model.h

@@ -66,6 +66,18 @@ struct AIAA_CLIENT_API Model {
   /// Image ROI size used while training [x,y,z,w] Format;  This shall be used for dextr3D API
   std::vector<int> roi;
 
+  enum ModelType {
+    annotation,
+    segmentation,
+    unknown
+  };
+
+  /// Type of Model (segmentation/annotation)
+  ModelType type;
+
+  /// Version of Model
+  std::string version;
+
   /*!
    @brief create Model from JSON String
    @param[in] json  JSON String.
@@ -104,9 +116,16 @@ struct AIAA_CLIENT_API ModelList {
    First preference goes to exact match.  Otherwise prefix match will be preferred.
    @note Here, the matching type is case-insensitive
    @param[in] label  Organ Name
+   @param[in] type  Model Type
    @return Model
    */
-  Model getMatchingModel(const std::string &label);
+  Model getMatchingModel(const std::string &label, Model::ModelType type = Model::annotation);
+
+  /// Checks if Polygons list is empty
+  bool empty() const;
+
+  /// Count of Polygons list
+  size_t size() const;
 
   /*!
    @brief create Model from JSON String

cpp-client/src/client.cpp

@@ -37,7 +37,8 @@ namespace aiaa {
 
 const std::string EP_MODELS = "/models";
 const std::string EP_DEXTRA_3D = "/dextr3d";
-const std::string EP_MASK_2_POLYGON = "/mask2polygon";
+const std::string EP_SEGMENTATION = "/segmentation";
+const std::string EP_MASK_TO_POLYGON = "/mask2polygon";
 const std::string EP_FIX_POLYGON = "/fixpolygon";
 const std::string IMAGE_FILE_EXTENSION = ".nii.gz";
 
@@ -58,6 +59,16 @@ ModelList Client::models() const {
   return ModelList::fromJson(CurlUtils::doGet(uri, timeoutInSec));
 }
 
+ModelList Client::models(const std::string &label, const Model::ModelType type) const {
+  std::string uri = serverUri + EP_MODELS + "?label=" + label;
+  if (type != Model::unknown) {
+    uri += std::string("&type=") + (type == Model::segmentation ? "segmentation" : "annotation");
+  }
+  AIAA_LOG_DEBUG("URI: " << uri);
+
+  return ModelList::fromJson(CurlUtils::doGet(uri, timeoutInSec));
+}
+
 template<typename TPixel>
 PointSet samplingT(const Model &model, const PointSet &pointSet, void *inputImage, int dimension, const std::string &outputImageFile,
                    ImageInfo &imageInfo) {
@@ -171,27 +182,21 @@ PointSet Client::sampling(const Model &model, const PointSet &pointSet, const st
   throw exception(exception::INVALID_ARGS_ERROR, "UnSupported Pixel Type (only basic types are supported)");
 }
 
-int Client::segmentation(const Model &model, const PointSet &pointSet, const std::string &inputImageFile, int dimension,
-                         const std::string &outputImageFile, const ImageInfo &imageInfo) const {
+PointSet Client::segmentation(const Model &model, const PointSet &pointSet, const std::string &inputImageFile, int dimension,
+                         const std::string &outputImageFile, const ImageInfo &imageInfo /*= ImageInfo()*/) const {
   if (dimension != 3) {
     throw exception(exception::INVALID_ARGS_ERROR, "UnSupported Dimension (only 3D is supported)");
   }
   if (model.name.empty()) {
     AIAA_LOG_WARN("Selected model is EMPTY");
-    return -2;
-  }
-  if (pointSet.points.size() < MIN_POINTS_FOR_SEGMENTATION) {
-    std::string msg = "Insufficient Points; Minimum Points required for input PointSet: "
-        + Utils::lexical_cast<std::string>(MIN_POINTS_FOR_SEGMENTATION);
-    AIAA_LOG_WARN(msg);
-    throw exception(exception::INVALID_ARGS_ERROR, msg.c_str());
+    throw exception(exception::INVALID_ARGS_ERROR, "Model is EMPTY");
   }
 
   bool postProcess = imageInfo.empty() ? false : true;
   std::string tmpResultFile = postProcess ? (Utils::tempfilename() + IMAGE_FILE_EXTENSION) : outputImageFile;
   AIAA_LOG_DEBUG("TmpResultFile: " << tmpResultFile << "; PostProcess: " << postProcess);
 
-  std::string uri = serverUri + EP_DEXTRA_3D + "?model=" + model.name;
+  std::string uri = serverUri + (model.type == Model::segmentation ? EP_SEGMENTATION : EP_DEXTRA_3D) + "?model=" + model.name;
   std::string paramStr = "{\"sigma\":" + Utils::lexical_cast<std::string>(model.sigma) + ",\"points\":\"" + pointSet.toJson() + "\"}";
   std::string response = CurlUtils::doPost(uri, paramStr, inputImageFile, tmpResultFile, timeoutInSec);
 
@@ -200,7 +205,7 @@ int Client::segmentation(const Model &model, const PointSet &pointSet, const std
     ITKUtils3DUChar::imagePostProcess(tmpResultFile, outputImageFile, imageInfo);
     std::remove(tmpResultFile.c_str());
   }
-  return 0;
+  return PointSet::fromJson(response);
 }
 
 int Client::dextr3D(const Model &model, const PointSet &pointSet, const std::string &inputImageFile, Pixel::Type pixelType,
@@ -237,7 +242,7 @@ int Client::dextr3D(const Model &model, const PointSet &pointSet, const std::str
 }
 
 PolygonsList Client::maskToPolygon(int pointRatio, const std::string &inputImageFile) const {
-  std::string uri = serverUri + EP_MASK_2_POLYGON;
+  std::string uri = serverUri + EP_MASK_TO_POLYGON;
   std::string paramStr = "{\"more_points\":" + Utils::lexical_cast<std::string>(pointRatio) + "}";
 
   AIAA_LOG_DEBUG("URI: " << uri);

cpp-client/src/model.cpp

@@ -44,6 +44,7 @@ Model::Model() {
   sigma = DEFAULT_SIGMA;
   padding = DEFAULT_PADDING;
   roi = {DEFAULT_ROI, DEFAULT_ROI, DEFAULT_ROI, DEFAULT_ROI};  // support up-to 4-Dimension
+  type = ModelType::annotation;
 }
 
 // {"labels": ["brain_tumor_core"], "internal name": "Dextr3dCroppedEngine", "description": "", "name": "Dextr3DBrainTC", "padding": 20.0 "roi": [128,128,128], "sigma": 3.0}
@@ -54,9 +55,8 @@ Model Model::fromJson(const std::string &json) {
 
     Model model;
     model.name = j["name"].get<std::string>();
-    model.internal_name = j["internal name"].get<std::string>();
-    model.description = j.find("description") != j.end() ? j["description"].get<std::string>() : j["decription"].get<std::string>();
-    // TODO:: Ask server to correct the spelling for description
+    model.internal_name = j.find("internal name") != j.end() ? j["internal name"].get<std::string>() : std::string();
+    model.description = j.find("description") != j.end() ? j["description"].get<std::string>() : std::string();
 
     for (auto e : j["labels"]) {
       model.labels.insert(e.get<std::string>());
@@ -79,6 +79,10 @@ Model Model::fromJson(const std::string &json) {
       model.roi.push_back(model.roi[model.roi.size() - 1]);
     }
 
+    std::string type = j.find("type") != j.end() ? j["type"].get<std::string>() : std::string();
+    model.type = type == "segmentation" ? ModelType::segmentation : ModelType::annotation;
+    model.version = j.find("version") != j.end() ? j["version"].get<std::string>() : std::string();
+
     return model;
   } catch (nlohmann::json::parse_error& e) {
     AIAA_LOG_ERROR(e.what());
@@ -98,6 +102,8 @@ std::string Model::toJson(int space) const {
   j["sigma"] = sigma;
   j["padding"] = padding;
   j["roi"] = roi;
+  j["type"] = (type == Model::segmentation ? "segmentation" : "annotation");
+  j["version"] = version;
 
   std::string str = j.dump(space);
   if (!space) {
@@ -138,9 +144,13 @@ std::string ModelList::toJson(int space) const {
   return space ? j.dump(space) : j.dump();
 }
 
-Model ModelList::getMatchingModel(const std::string &labelName) {
+Model ModelList::getMatchingModel(const std::string &labelName, Model::ModelType type/* = Model::annotation*/) {
   // Exact Match (first preference)
   for (auto model : models) {
+    if (model.type != type) {
+      continue;
+    }
+
     for (auto label : model.labels) {
       AIAA_LOG_DEBUG("Exact Match: [" << label << "] vs [" << labelName << "]");
       if (Utils::iequals(labelName, label)) {
@@ -152,6 +162,10 @@ Model ModelList::getMatchingModel(const std::string &labelName) {
   // Prefix Match (find as prefix in either)
   std::string l1 = Utils::to_lower(labelName);
   for (auto model : models) {
+    if (model.type != type) {
+      continue;
+    }
+
     for (auto label : model.labels) {
       std::string l2 = Utils::to_lower(label);
       AIAA_LOG_DEBUG("Exact Match: [" << l2 << "] vs [" << l1 << "]");
@@ -164,6 +178,15 @@ Model ModelList::getMatchingModel(const std::string &labelName) {
   return Model();
 }
 
+bool ModelList::empty() const {
+  return models.empty();
+}
+
+size_t ModelList::size() const {
+  return models.size();
+}
+
+
 }
 }
 

cpp-client/tools/CMakeLists.txt

@@ -52,6 +52,9 @@ target_link_libraries(nvidiaAIAAListModels NvidiaAIAAClient ${CMAKE_DL_LIBS})
 add_executable(nvidiaAIAADEXTR3D aiaa/aiaa-dextra3d.cpp)
 target_link_libraries(nvidiaAIAADEXTR3D NvidiaAIAAClient ${CMAKE_DL_LIBS})
 
+add_executable(nvidiaAIAASegmentation aiaa/aiaa-segmentation.cpp)
+target_link_libraries(nvidiaAIAASegmentation NvidiaAIAAClient ${CMAKE_DL_LIBS})
+
 add_executable(nvidiaAIAASampling3D aiaa/aiaa-sampling3d.cpp)
 target_link_libraries(nvidiaAIAASampling3D NvidiaAIAAClient ${CMAKE_DL_LIBS})
 
@@ -63,10 +66,11 @@ target_link_libraries(nvidiaAIAAMaskPolygon NvidiaAIAAClient ${CMAKE_DL_LIBS})
 
 
 # Install Targets
-install(TARGETS DicomToNifti          DESTINATION bin)
-install(TARGETS NiftiToDicom          DESTINATION bin)
+install(TARGETS DicomToNifti           DESTINATION bin)
+install(TARGETS NiftiToDicom           DESTINATION bin)
 
-install(TARGETS nvidiaAIAAListModels  DESTINATION bin)
-install(TARGETS nvidiaAIAADEXTR3D     DESTINATION bin)
-install(TARGETS nvidiaAIAAFixPolygon  DESTINATION bin)
-install(TARGETS nvidiaAIAAMaskPolygon DESTINATION bin)
+install(TARGETS nvidiaAIAAListModels   DESTINATION bin)
+install(TARGETS nvidiaAIAADEXTR3D      DESTINATION bin)
+install(TARGETS nvidiaAIAASegmentation DESTINATION bin)
+install(TARGETS nvidiaAIAAFixPolygon   DESTINATION bin)
+install(TARGETS nvidiaAIAAMaskPolygon  DESTINATION bin)

cpp-client/tools/aiaa/aiaa-model.cpp

@@ -34,19 +34,21 @@
 int main(int argc, char **argv) {
   if (cmdOptionExists(argv, argv + argc, "-h")) {
     std::cout << "Usage:: <COMMAND> <OPTIONS>\n"
-              "  |-h        (Help) Print this information                                                |\n"
-              "  |-server   Server URI {default: http://10.110.45.66:5000/v1}                            |\n"
-              "  |-label    Find Matching Model for this label; If absent, output full Model List        |\n"
-              "  |-output   Output File Name to store result                                             |\n"
-              "  |-format   Format Output Json                                                           |\n"
-              "  |-timeout  Timeout In Seconds {default: 60}                                             |\n"
-              "  |-ts       Print API Latency                                                            |\n";
+        "  |-h        (Help) Print this information                                                |\n"
+        "  |-server   Server URI {default: http://10.110.45.66:5000/v1}                            |\n"
+        "  |-label    Find Matching Model for this label; If absent, output full Model List        |\n"
+        "  |-type     Find Matching Model of type (segmentation/annotation)                        |\n"
+        "  |-output   Output File Name to store result                                             |\n"
+        "  |-format   Format Output Json                                                           |\n"
+        "  |-timeout  Timeout In Seconds {default: 60}                                             |\n"
+        "  |-ts       Print API Latency                                                            |\n";
 
     return 0;
   }
 
   std::string serverUri = getCmdOption(argv, argv + argc, "-server", "http://10.110.45.66:5000/v1");
   std::string label = getCmdOption(argv, argv + argc, "-label");
+  std::string type = getCmdOption(argv, argv + argc, "-type");
   std::string outputJsonFile = getCmdOption(argv, argv + argc, "-output");
   int jsonSpace = cmdOptionExists(argv, argv + argc, "-format") ? 2 : 0;
   int timeout = nvidia::aiaa::Utils::lexical_cast<int>(getCmdOption(argv, argv + argc, "-timeout", "60"));
@@ -55,24 +57,15 @@ int main(int argc, char **argv) {
   try {
     auto begin = std::chrono::high_resolution_clock::now();
     nvidia::aiaa::Client client(serverUri, timeout);
-    nvidia::aiaa::ModelList modelList = client.models();
 
-    auto end = std::chrono::high_resolution_clock::now();
-    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
+    nvidia::aiaa::Model::ModelType mt = nvidia::aiaa::Model::unknown;
+    mt = type == "segmentation" ? nvidia::aiaa::Model::segmentation : mt;
+    mt = type == "annotation" ? nvidia::aiaa::Model::annotation : mt;
 
-    if (!label.empty()) {
-      nvidia::aiaa::Model model = modelList.getMatchingModel(label);
-      if (outputJsonFile.empty()) {
-        std::cout << model.toJson(jsonSpace) << std::endl;
-      } else {
-        stringToFile(model.toJson(jsonSpace), outputJsonFile);
-      }
+    nvidia::aiaa::ModelList modelList = type.empty() && label.empty() ? client.models() : client.models(label, mt);
 
-      if (printTs) {
-        std::cout << "API Latency (in milli sec): " << ms << std::endl;
-      }
-      return 0;
-    }
+    auto end = std::chrono::high_resolution_clock::now();
+    auto ms = std::chrono::duration_cast < std::chrono::milliseconds > (end - begin).count();
 
     if (outputJsonFile.empty()) {
       std::cout << modelList.toJson(jsonSpace) << std::endl;