Development Through Process Orchestration

{
  "objectdetection": {                // Change "objectdetection" to the name of the current inference process.
    "stream_config": {
      "deviceId": "0"                // "deviceId" indicates the ID of the processor to be used.
    },
    "appsrc0": {                     // "appsrc0" indicates the name of the input element.
      "props": {                     // "props" indicates the element attribute.
        "blocksize": "409600"        // Size of data read by each buffer
      },
      "factory": "appsrc",           // "factory" defines the element type.
      "next": "mxpi_imagedecoder0"   // Enter the connected downstream element. Here, an image decoding element is used.
    },
    "mxpi_imagedecoder0": {          // Name of the image decoding element. The value 0 indicates the ID. If multiple image decoding elements are used in a process, name elements as 0, 1, 2, and so on.
      "props": {
        "handleMethod": "ascend"     // The decoding method is ascend.
      },
      "factory": "mxpi_imagedecoder",    // Use an image decoding plugin.
      "next": "mxpi_imageresize0"    // Enter the connected downstream element. Here, an image resizing element is used.
    },
    "mxpi_imageresize0": {           // Name of the image resizing element
      "props": {
        "handleMethod": "ascend"    // The decoding method is ascend.
        "resizeHeight": "416",       // Height after resizing
        "resizeWidth": "416",        // Width after resizing
        "resizeType": "Resizer_Stretch"// The stretch mode is used for resizing.
      },
      "factory": "mxpi_imageresize",   // Use an image resizing plugin.
      "next": "mxpi_tensorinfer0"     // Enter the connected downstream element. Here, a model inference element is used.
    },
    "mxpi_tensorinfer0": {                                   // Name of the model inference element
      "props": {                                             // "props" indicates the element attribute, which can be used to load files in a specified directory.
        "dataSource": "mxpi_imageresize0",              // Enter the connected upstream element. Here, an image resizing element is used.
        "modelPath": "../models/yolov3_tf_bs1_fp16.om",    // "modelPath" defines the model used for the inference service. Change the file named based on the obtained model.
        "waitingTime": "2000",                               // Waiting time for batch combination allowed by the multi-batch model
        "outputDeviceId": "-1"                               // Copy the memory to the specified location. If this parameter is set to -1, the memory is copied to the host.
      },
      "factory": "mxpi_tensorinfer",                         // Use a model inference plugin.
      "next": "mxpi_objectdetection0"                     // Enter the connected downstream element. Here, a model postprocessing element is used.
    },
    "mxpi_objectdetection0": {                            // Name of the model postprocessing element
      "props": {                                             // "props" indicates the element attribute, which can be used to load files in a specified directory.
        "dataSource": "mxpi_tensorinfer0",                   // Enter the connected upstream element. Here, a model inference element is used.
        "postProcessConfigPath": "../models/yolov3_tf_bs1_fp16.cfg",// "postProcessConfigPath" specifies the postprocessing configuration file of the model.
        "labelPath": "../models/yolov3.names",    // "labelPath" specifies the category name file output by the model.
        "postProcessLibPath": "libyolov3postprocess.so"    // "postProcessLibPath" specifies the dynamic library on which model postprocessing depends.
      },
      "factory": "mxpi_objectpostprocessor",                  // Use a model postprocessing plugin.
      "next": "mxpi_dataserialize0"                          // Enter the connected downstream element. Here, a serialization element is used.
    },
    "mxpi_dataserialize0": {                                 // Name of the serialization element
      "props": {
        "outputDataKeys": "mxpi_objectdetection0"         // "outputDataKeys" specifies the index of the data to be output.
      },
      "factory": "mxpi_dataserialize",                       // Use a serialization plugin.
      "next": "appsink0"                                     // Enter the connected downstream element. Here, an output element is used.
    },
    "appsink0": {                                            // Name of the output element
      "props": {
        "blocksize": "4096000"                               // Size of data read by each buffer
      },
      "factory": "appsink"                                   // Use an output plugin.
    }
  }
}

int main(int argc, char* argv[])
 {
    // 1. Parse the pipeline file.
    std::string pipelineConfigPath = "../pipeline/Sample.pipeline";  // Modify the pipeline file path.
    std::string pipelineConfig = ReadPipeline(pipelineConfigPath);
    if (pipelineConfig == "") {
        LogError << "Read pipeline failed.";
        return APP_ERR_COMM_INIT_FAIL;
    }
    // 2. Initialize the stream manager.
    MxStream::MxStreamManager mxStreamManager;
    APP_ERROR ret = mxStreamManager.InitManager();
    if (ret != APP_ERR_OK) {
        LogError << GetErrorInfo(ret) << "Failed to init Stream manager.";
        return ret;
    }
    // 3. Create a stream.
    ret = mxStreamManager.CreateMultipleStreams(pipelineConfig);
    if (ret != APP_ERR_OK) {
        LogError << GetErrorInfo(ret) << "Failed to create Stream.";
        mxStreamManager.DestroyAllStreams();
        return ret;
    }
    // 4. Read the image to be inferred.
    MxStream::MxstDataInput dataBuffer;
    ret = ReadFile("../data/dog1_1024_683.jpg", dataBuffer);    // Change the input image path.
    if (ret != APP_ERR_OK) {
        LogError << GetErrorInfo(ret) << "Failed to read image file.";
        mxStreamManager.DestroyAllStreams();
        return ret;
    }
    std::string streamName = "objectdetection";    // Change the name of the inference process.
    int inPluginId = 0;
    // 5. Send the image to be inferred to the stream.
    ret = mxStreamManager.SendData(streamName, inPluginId, dataBuffer);
    if (ret != APP_ERR_OK) {
        LogError << GetErrorInfo(ret) << "Failed to send data to stream.";
        delete dataBuffer.dataPtr;
        dataBuffer.dataPtr = nullptr;
        mxStreamManager.DestroyAllStreams();
        return ret;
    }
    // 6. Obtain the inference result.
    MxStream::MxstDataOutput* output = mxStreamManager.GetResult(streamName, inPluginId);
    if (output == nullptr) {
        LogError << "Failed to get pipeline output.";
        delete dataBuffer.dataPtr;
        dataBuffer.dataPtr = nullptr;
        mxStreamManager.DestroyAllStreams();
        return ret;
    }
    std::string result = std::string((char *)output->dataPtr, output->dataSize);
    std::cout << "Results:" << result << std::endl;
    // 7. Destroy the stream and resources.
    mxStreamManager.DestroyAllStreams();
    delete dataBuffer.dataPtr;
    dataBuffer.dataPtr = nullptr;
    delete output;
    return 0;
 }