万物分割（Segment Anything Model）C++模型推理部署

于 2024-08-02 22:47:08 发布
阅读量984 收藏 23
点赞数 20
分类专栏： 计算机视觉 文章标签： c++ 深度学习 人工智能 SAM 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/matt45m/article/details/140881488
版权

概述

SAM 是一种先进的人工智能模型，已经证明了在分割复杂和多样化图像方面具有优异的表现。该模型是计算机视觉和图像分割领域的一个重大突破。 SAM 的架构旨在处理各种图像分割任务，包括对象检测、实例分割和全景分割。这意味着该模型可以应用于各种用例，从医学图像分析到自主驾驶。
在这里插入图片描述

SAM 的独特之处之一是它具有执行全景分割的能力，这涉及将实例分割和语义分割相结合。实例分割涉及识别和划分图像内每个物体实例，而语义分割涉及为图像中的每个像素标记相应的类别标签。全景分割将这两种方法结合起来，以提供对图像更全面的理解。

SAM 的另一个关键特点是其灵活性。该模型可以针对特定的用例和领域进行微调，使其高度适应性。 SAM 的架构也非常高效，使其能够实时处理大量数据。这使其非常适合需要快速准确的图像分割的应用，例如安全监控、工业自动化和机器人技术。

在这里插入图片描述

SAM 如何运作：模型架构

SAM（Segment Anything Model）是用于图像分割任务的先进深度学习模型。 SAM 使用卷积神经网络（CNN）和基于 Transformer 的架构结合在一起以分层和多尺度的方式处理图像。以下是 SAM 如何工作的高级概述：

  1. 骨干网络：SAM 使用预训练的 Vision Transformer，即 ViT 作为其骨干网络。骨干网络用于从输入图像中提取特征。
  2. 特征金字塔网络（FPN）：SAM 使用特征金字塔网络（FPN）在多个尺度上生成特征映射。 FPN 是一系列卷积层，它们在不同尺度上运作，以从骨干网络的输出中提取特征。 FPN 确保 SAM 可以在不同细节层次上识别物体和边界。
  3. 解码器网络：SAM 使用解码器网络为输入图像生成分割掩模。解码器网络接受 FPN 的输出并将其上采样到原始图像大小。上采样过程使模型能够生成具有与输入图像相同分辨率的分割掩模。
  4. 基于 Transformer 的架构：SAM 还使用基于 Transformer 的架构来改进分割结果。 Transformer 是一种神经网络架构，非常有效地处理序列数据，例如文本或图像。使用基于 Transformer 的架构通过从输入图像中获取上下文信息来改进分割结果。
  5. 自监督学习：SAM 利用自监督学习从未标记的数据中学习。这涉及在大型未标记图像数据集上训练模型，以学习图像中的常见模式和特征。学习到的特征可以用于改善模型在特定图像分割任务上的性能。
  6. 全景分割：SAM 可以执行全景分割，这涉及结合实例和语义分割。实例分割涉及识别和划分图像内每个物体实例，而语义分割涉及为图像中的每个像素标记相应的类别标签。全景分割将这两种方法结合起来，以提供对图像更全面的理解。

SAM 的潜在用例

SAM（Segment Anything Model）是一种高度通用的图像分割模型，可应用于各种用例。以下是 SAM 的五个潜在用例：

  1. 自动驾驶车辆：SAM 可用于自动驾驶车辆中，以识别和分割环境中的不同物体，例如车辆、行人和路标。这些信息可用于帮助车辆做出有根据的导航和安全决策。
  2. 医学影像：SAM 可用于医学影像中，以分割图像中的不同结构和组织，例如肿瘤、血管和器官。这些信息可用于协助医生进行诊断和治疗计划。
  3. 对象检测：SAM 可用于识别和分割图像中的对象，用于对象检测任务。这可以在安全监控、工业自动化和机器人应用中很有用。
  4. 农业：SAM 可用于农业中，以监测作物的健康和生长情况。通过对田地或作物的不同区域进行分割，SAM 可以识别需要关注的区域，例如害虫侵害或营养不足的区域。
  5. 建筑工地监测：SAM 可用于监测建筑工地的进度，通过分割工地的不同组件，例如建筑物、设备和材料。这些信息可用于跟踪项目进度，确保项目按计划进行。

C++推理

ncnn

NCNN是一个为移动和嵌入式设备设计的高性能神经网络推理库，由腾讯的优图实验室（YouTu Lab）开发并开源。以下是对NCNN的简要概述：

  1. 目标：NCNN旨在提供快速、轻量级的深度学习模型部署方案，特别优化了在资源受限的设备上的性能。

  2. 性能优化：NCNN利用了多种硬件加速技术，包括NEON、Metal、OpenGL等，以实现在不同平台上的最优性能。

  3. 跨平台：支持跨平台使用，包括但不限于Android、iOS、Linux、Windows等操作系统。

  4. 模型支持：支持多种深度学习框架的模型转换，例如Caffe、TensorFlow等，方便开发者将不同来源的模型集成到NCNN中。

  5. 轻量化设计：NCNN的库文件体积小，适合移动设备和嵌入式设备，减少存储和内存占用。

  6. 灵活性：提供了灵活的输入输出接口，可以轻松地与现有的应用程序或系统进行集成。

  7. 易用性：NCNN提供了简洁的API，使得模型的加载、运行和推理过程简单明了。

  8. 硬件兼容性：针对不同的硬件平台进行了优化，包括CPU、GPU和DSP等，以充分利用各种硬件的计算能力。

  9. 社区支持：作为一个开源项目，NCNN拥有活跃的社区支持，不断有新的功能和优化被加入。

  10. 应用场景：适用于实时性要求高的场景，如视频流处理、图像识别、语音识别等。

NCNN的设计哲学是“小而美”，它专注于推理（inference）而非训练（training），并且特别注重在移动和嵌入式设备上的性能和效率。这使得NCNN成为在边缘设备上部署深度学习模型的理想选择。

C++ 推理

#include "pipeline.h"
#include <iostream>
namespace sam{
PipeLine::~PipeLine()
{

}
int PipeLine::Init(const std::string& image_encoder_param, 
    const std::string& image_encoder_bin, const std::string& mask_decoder_param,
    const std::string& mask_decoder_bin)
{
    sam_ = std::make_shared<SegmentAnything>();
    int ret = sam_->Load(image_encoder_param,image_encoder_bin,mask_decoder_param,mask_decoder_bin);
    return ret;
}

int PipeLine::ImageEmbedding(const cv::Mat& bgr, pipeline_result_t& pipeline_result)
{
    std::cout << "start image encoder..." << std::endl;
    sam_->ImageEncoder(bgr, pipeline_result.image_embeddings, pipeline_result.image_info);
    std::cout << "finish image encoder..." << std::endl;

    return 0;
}

int PipeLine::AutoPredict(const cv::Mat& bgr, pipeline_result_t& pipeline_result, int n_per_side)
{
    pipeline_result.prompt_info.prompt_type = PromptType::Point;

    //generate grid points
    std::vector<float> points_xy_vec;
    get_grid_points(points_xy_vec, n_per_side);

    std::vector<sam_result_t> proposals;
    for(int i = 0; i < n_per_side; ++i) {
        std::vector<sam_result_t> objects;
        for(int j = 0; j < n_per_side; ++j) {
            pipeline_result.prompt_info.points.clear();
            pipeline_result.prompt_info.labels.clear();
            pipeline_result.prompt_info.points.push_back(points_xy_vec[i * n_per_side * 2 + 2 * j] * pipeline_result.image_info.img_w);
            pipeline_result.prompt_info.points.push_back(points_xy_vec[i * n_per_side * 2 + 2 * j + 1] * pipeline_result.image_info.img_h);
            
            pipeline_result.prompt_info.points.push_back(0);
            pipeline_result.prompt_info.points.push_back(0);

            pipeline_result.prompt_info.labels.push_back(1);
            pipeline_result.prompt_info.labels.push_back(-1);

            sam_->MaskDecoder(pipeline_result.image_embeddings, pipeline_result.image_info, pipeline_result.prompt_info, objects);
        }
        proposals.insert(proposals.end(), objects.begin(), objects.end());
        std::cout<<"processing: "<< i <<"/"<<n_per_side<<std::endl;
    }

    std::vector<int> picked;
    sam_->NMS(bgr, proposals, picked);
    int num_picked = picked.size();
    
    for(int j = 0; j < num_picked; ++j){
        pipeline_result.sam_result.push_back(proposals[picked[j]]);
    }
    
    return 0;
}


int PipeLine::Predict(const cv::Mat& bgr, pipeline_result_t& pipeline_result)
{
    sam_->MaskDecoder(pipeline_result.image_embeddings, pipeline_result.image_info, pipeline_result.prompt_info, pipeline_result.sam_result);
    return 0;
}


void PipeLine::Draw(const cv::Mat& bgr, const pipeline_result_t& pipeline_result)
{
    static const unsigned char colors[81][3] = {
            {56,  0,   255},
            {226, 255, 0},
            {0,   94,  255},
            {0,   37,  255},
            {0,   255, 94},
            {255, 226, 0},
            {0,   18,  255},
            {255, 151, 0},
            {170, 0,   255},
            {0,   255, 56},
            {255, 0,   75},
            {0,   75,  255},
            {0,   255, 169},
            {255, 0,   207},
            {75,  255, 0},
            {207, 0,   255},
            {37,  0,   255},
            {0,   207, 255},
            {94,  0,   255},
            {0,   255, 113},
            {255, 18,  0},
            {255, 0,   56},
            {18,  0,   255},
            {0,   255, 226},
            {170, 255, 0},
            {255, 0,   245},
            {151, 255, 0},
            {132, 255, 0},
            {75,  0,   255},
            {151, 0,   255},
            {0,   151, 255},
            {132, 0,   255},
            {0,   255, 245},
            {255, 132, 0},
            {226, 0,   255},
            {255, 37,  0},
            {207, 255, 0},
            {0,   255, 207},
            {94,  255, 0},
            {0,   226, 255},
            {56,  255, 0},
            {255, 94,  0},
            {255, 113, 0},
            {0,   132, 255},
            {255, 0,   132},
            {255, 170, 0},
            {255, 0,   188},
            {113, 255, 0},
            {245, 0,   255},
            {113, 0,   255},
            {255, 188, 0},
            {0,   113, 255},
            {255, 0,   0},
            {0,   56,  255},
            {255, 0,   113},
            {0,   255, 188},
            {255, 0,   94},
            {255, 0,   18},
            {18,  255, 0},
            {0,   255, 132},
            {0,   188, 255},
            {0,   245, 255},
            {0,   169, 255},
            {37,  255, 0},
            {255, 0,   151},
            {188, 0,   255},
            {0,   255, 37},
            {0,   255, 0},
            {255, 0,   170},
            {255, 0,   37},
            {255, 75,  0},
            {0,   0,   255},
            {255, 207, 0},
            {255, 0,   226},
            {255, 245, 0},
            {188, 255, 0},
            {0,   255, 18},
            {0,   255, 75},
            {0,   255, 151},
            {255, 56,  0},
            {245, 255, 0}
    };

    cv::Mat img = bgr.clone();

    for(size_t n = 0; n < pipeline_result.sam_result.size(); ++n)
    {
        for (int y = 0; y < img.rows; ++y) {
            uchar* image_ptr = img.ptr(y);
            const uchar* mask_ptr = pipeline_result.sam_result[n].mask.ptr<uchar>(y);
            for (int x = 0; x < img.cols; ++x) {
                if (mask_ptr[x] > 0)
                {
                    image_ptr[0] = cv::saturate_cast<uchar>(image_ptr[0] * 0.5 + colors[n][0] * 0.5);
                    image_ptr[1] = cv::saturate_cast<uchar>(image_ptr[1] * 0.5 + colors[n][1] * 0.5);
                    image_ptr[2] = cv::saturate_cast<uchar>(image_ptr[2] * 0.5 + colors[n][2] * 0.5);
                }
                image_ptr += 3;
            }
        }

        //cv::rectangle(img, pipeline_result.sam_result[n].box, cv::Scalar(0,255,0), 2, 8,0);

        switch(pipeline_result.prompt_info.prompt_type)
        {
            case PromptType::Point:
                for(int i = 0; i < pipeline_result.prompt_info.points.size() / 2; ++i)
                {
                    cv::circle(img, cv::Point(pipeline_result.prompt_info.points[2 * i], pipeline_result.prompt_info.points[2 * i + 1]), 5, cv::Scalar(255,255,0),2,8);
                }
                break;
            case PromptType::Box:
                cv::rectangle(img, cv::Rect(cv::Point(pipeline_result.prompt_info.points[0], pipeline_result.prompt_info.points[1]), cv::Point(pipeline_result.prompt_info.points[2], pipeline_result.prompt_info.points[3])), cv::Scalar(255,255,0),2,8);
                break;
            default:
                break;
        }
    }

    cv::imshow("dst", img);
    //cv::imshow("mask", pipeline_result.sam_result.mask);
    cv::imwrite("dst.jpg",img);
    cv::waitKey();
}

void PipeLine::get_grid_points(std::vector<float>& points_xy_vec, int n_per_side)
{
    float offset = 1.f / (2 * n_per_side);
    
    float start = offset;
    float end = 1 - offset;
    float step = (end - start) / (n_per_side - 1);

    std::vector<float> points_one_side;
    for (int i = 0; i < n_per_side; ++i) {
        points_one_side.push_back(start + i * step);
    }

    points_xy_vec.resize(n_per_side * n_per_side * 2);
    for (int i = 0; i < n_per_side; ++i) {
        for (int j = 0; j < n_per_side; ++j) {
            points_xy_vec[i * n_per_side * 2 + 2 * j + 0] = points_one_side[j];
            points_xy_vec[i * n_per_side * 2 + 2 * j + 1] = points_one_side[i];
        }
    }
}

}

#include "segment_anything.h"

namespace sam
{
SegmentAnything::~SegmentAnything()
{
    image_encoder_net_.clear();
    mask_decoder_net_.clear();
}

static inline float intersection_area(const sam_result_t& a, const sam_result_t& b)
{
    cv::Rect_<float> inter = a.box & b.box;
    return inter.area();
}

static void qsort_descent_inplace(std::vector<sam_result_t>& faceobjects, int left, int right)
{
    int i = left;
    int j = right;
    float p = faceobjects[(left + right) / 2].iou_pred;

    while (i <= j)
    {
        while (faceobjects[i].iou_pred > p)
            i++;

        while (faceobjects[j].iou_pred < p)
            j--;

        if (i <= j)
        {
            // swap
            std::swap(faceobjects[i], faceobjects[j]);

            i++;
            j--;
        }
    }

    #pragma omp parallel sections
    {
        #pragma omp section
        {
            if (left < j) qsort_descent_inplace(faceobjects, left, j);
        }
        #pragma omp section
        {
            if (i < right) qsort_descent_inplace(faceobjects, i, right);
        }
    }
}

static void qsort_descent_inplace(std::vector<sam_result_t>& faceobjects)
{
    if (faceobjects.empty())
        return;

    qsort_descent_inplace(faceobjects, 0, faceobjects.size() - 1);
}

static void nms_sorted_bboxes(const cv::Mat& bgr,const std::vector<sam_result_t>& faceobjects, std::vector<int>& picked, float nms_threshold)
{
    picked.clear();

    const int n = faceobjects.size();

    std::vector<float> areas(n);
    for (int i = 0; i < n; i++)
    {
        areas[i] = faceobjects[i].box.area();
    }
    cv::Mat img = bgr.clone();
    for (int i = 0; i < n; i++)
    {
        const sam_result_t& a = faceobjects[i];

        int keep = 1;
        for (int j = 0; j < (int)picked.size(); j++)
        {
            const sam_result_t& b = faceobjects[picked[j]];

            // intersection over union
            float inter_area = intersection_area(a, b);
            float union_area = areas[i] + areas[picked[j]] - inter_area;
            // float IoU = inter_area / union_area
            if (inter_area / union_area > nms_threshold){
                keep = 0;
            }
                
        }

        if (keep)
            picked.push_back(i);
    }
}
int SegmentAnything::NMS(const cv::Mat& bgr, std::vector<sam_result_t>& proposals, std::vector<int>& picked, float nms_threshold)
{
    qsort_descent_inplace(proposals);
    nms_sorted_bboxes(bgr, proposals, picked, nms_threshold);
    
    return 0;
}

int SegmentAnything::Load(const std::string& image_encoder_param, const std::string& image_encoder_bin, const std::string& mask_decoder_param, const std::string& mask_decoder_bin)
{
    int ret = 0;
    ret = image_encoder_net_.load_param(image_encoder_param.c_str());
    if (ret < 0)
        return -1;
    ret = image_encoder_net_.load_model(image_encoder_bin.c_str());
    if (ret < 0)
        return -1;
    ret = mask_decoder_net_.load_param(mask_decoder_param.c_str());
    if (ret < 0)
        return -1;
    ret = mask_decoder_net_.load_model(mask_decoder_bin.c_str());
    if (ret < 0)
        return -1;

    return 0;
}
int SegmentAnything::ImageEncoder(const cv::Mat& bgr, ncnn::Mat& image_embeddings, image_info_t& image_info)
{
    const int target_size = 1024;
    int img_w = bgr.cols;
    int img_h = bgr.rows;

    int w = img_w;
    int h = img_h;
    float scale = 1.f;
    if (w > h)
    {
        scale = (float)target_size / w;
        w = target_size;
        h = h * scale;
    }
    else
    {
        scale = (float)target_size / h;
        h = target_size;
        w = w * scale;
    }

    ncnn::Mat in = ncnn::Mat::from_pixels_resize(bgr.data, ncnn::Mat::PIXEL_BGR2RGB, img_w, img_h, w, h);

    int wpad = target_size - w;
    int hpad = target_size - h;
    ncnn::Mat in_pad;
    ncnn::copy_make_border(in, in_pad, 0, hpad, 0, wpad, ncnn::BORDER_CONSTANT, 0.f);

    in_pad.substract_mean_normalize(means_, norms_);

    ncnn::Extractor image_encoder_ex = image_encoder_net_.create_extractor();

    image_encoder_ex.input("image", in_pad);
    image_encoder_ex.extract("image_embeddings", image_embeddings);

    image_info.img_h = img_h;
    image_info.img_w = img_w;
    image_info.pad_h = h;
    image_info.pad_w = w;
    image_info.scale = scale;

    return 0;
}

int SegmentAnything::embed_masks(const prompt_info_t& prompt_info, ncnn::Mat& mask_input, ncnn::Mat& has_mask)
{
    mask_input = ncnn::Mat(256, 256, 1);
    mask_input.fill(0.f);
    has_mask = ncnn::Mat(1);
    has_mask.fill(0.f);

    return 0;
}
int SegmentAnything::transform_coords(const image_info_t& image_info, ncnn::Mat& point_coords)
{
    for(int h = 0; h < point_coords.h; ++h){
        float* ptr = point_coords.row(h);
        ptr[0] *= image_info.scale;
        ptr[1] *= image_info.scale;
    }

    return 0;
}
int SegmentAnything::embed_points(const prompt_info_t& prompt_info, std::vector<ncnn::Mat>& point_labels, ncnn::Mat& point_coords)
{
    int num_points = prompt_info.points.size() / 2;
    point_coords = ncnn::Mat(num_points * 2, (void*)prompt_info.points.data()).reshape(2, num_points).clone();

    ncnn::Mat point_labels1 = ncnn::Mat(256, num_points);
    ncnn::Mat point_labels2 = ncnn::Mat(256, num_points);
    ncnn::Mat point_labels3 = ncnn::Mat(256, num_points);
    ncnn::Mat point_labels4 = ncnn::Mat(256, num_points);
    ncnn::Mat point_labels5 = ncnn::Mat(256, num_points);
    ncnn::Mat point_labels6 = ncnn::Mat(256, num_points);

    point_labels1.row_range(0, num_points - 1).fill(1.f);
    point_labels1.row_range(num_points - 1, 1).fill(0.f);

    for (int i = 0; i < num_points - 1; ++i) {
        if (prompt_info.labels[i] == -1)
            point_labels2.row_range(i, 1).fill(1.f);
        else
            point_labels2.row_range(i, 1).fill(0.f);
    }
    point_labels2.row_range(num_points - 1, 1).fill(1.f);

    for (int i = 0; i < num_points - 1; ++i) {
        if (prompt_info.labels[i] == 0)
            point_labels3.row_range(i, 1).fill(1.f);
        else
            point_labels3.row_range(i, 1).fill(0.f);
    }
    point_labels3.row_range(num_points - 1, 1).fill(0.f);

    for (int i = 0; i < num_points - 1; ++i) {
        if (prompt_info.labels[i] == 1)
            point_labels4.row_range(i, 1).fill(1.f);
        else
            point_labels4.row_range(i, 1).fill(0.f);
    }
    point_labels4.row_range(num_points - 1, 1).fill(0.f);

    for (int i = 0; i < num_points - 1; ++i) {
        if (prompt_info.labels[i] == 2)
            point_labels5.row_range(i, 1).fill(1.f);
        else
            point_labels5.row_range(i, 1).fill(0.f);
    }
    point_labels5.row_range(num_points - 1, 1).fill(0.f);

    for (int i = 0; i < num_points - 1; ++i) {
        if (prompt_info.labels[i] == 3)
            point_labels6.row_range(i, 1).fill(1.f);
        else
            point_labels6.row_range(i, 1).fill(0.f);
    }
    point_labels6.row_range(num_points - 1, 1).fill(0.f);

    point_labels.push_back(point_labels1);
    point_labels.push_back(point_labels2);
    point_labels.push_back(point_labels3);
    point_labels.push_back(point_labels4);
    point_labels.push_back(point_labels5);
    point_labels.push_back(point_labels6);

    return 0;
}
int SegmentAnything::MaskDecoder(const ncnn::Mat& image_embeddings, image_info_t& image_info, 
    const prompt_info_t& prompt_info, std::vector<sam_result_t>& sam_results, float pred_iou_thresh, float stability_score_thresh)
{
    std::vector<ncnn::Mat> point_labels;
    ncnn::Mat point_coords;
    embed_points(prompt_info, point_labels, point_coords);

    transform_coords(image_info, point_coords);

    ncnn::Mat mask_input, has_mask;
    embed_masks(prompt_info, mask_input, has_mask);

    ncnn::Extractor mask_decoder_ex = mask_decoder_net_.create_extractor();
    mask_decoder_ex.input("mask_input", mask_input);
    mask_decoder_ex.input("point_coords", point_coords);
    mask_decoder_ex.input("point_labels1", point_labels[0]);
    mask_decoder_ex.input("point_labels2", point_labels[1]);
    mask_decoder_ex.input("point_labels3", point_labels[2]);
    mask_decoder_ex.input("point_labels4", point_labels[3]);
    mask_decoder_ex.input("point_labels5", point_labels[4]);
    mask_decoder_ex.input("point_labels6", point_labels[5]);
    mask_decoder_ex.input("image_embeddings", image_embeddings);
    mask_decoder_ex.input("has_mask_input", has_mask);

    ncnn::Mat scores;
    mask_decoder_ex.extract("scores", scores);

    ncnn::Mat masks;
    mask_decoder_ex.extract("masks", masks);

    //postprocess
    std::vector<std::pair<float, int>> scores_vec;
    for (int i = 1; i < scores.w; ++i) {
        scores_vec.push_back(std::pair<float, int>(scores[i], i));
    }

    std::sort(scores_vec.begin(), scores_vec.end(), std::greater<std::pair<float, int>>());

    if (scores_vec[0].first > pred_iou_thresh) {
        sam_result_t sam_result;
        ncnn::Mat mask = masks.channel(scores_vec[0].second);
        cv::Mat cv_mask_32f = cv::Mat::zeros(cv::Size(mask.w, mask.h), CV_32F);
        std::copy((float*)mask.data, (float*)mask.data + mask.w * mask.h, (float*)cv_mask_32f.data);
        
        cv::Mat single_mask_32f;
        cv::resize(cv_mask_32f(cv::Rect(0, 0, image_info.pad_w, image_info.pad_h)), single_mask_32f, cv::Size(image_info.img_w,image_info.img_h), 0, 0, 1);

        float stable_score = calculate_stability_score(single_mask_32f);
        if (stable_score < stability_score_thresh)
            return -1;

        single_mask_32f = single_mask_32f > 0;
        single_mask_32f.convertTo(sam_result.mask, CV_8UC1, 1, 0);
        
        if (postprocess_mask(sam_result.mask, sam_result.box) < 0)
            return -1;

        sam_results.push_back(sam_result);
    }
    else {
        return -1;
    }

    return 0;
}
int SegmentAnything::postprocess_mask(cv::Mat& mask, cv::Rect& box)
{
    std::vector<std::vector<cv::Point>> contours;
    std::vector<cv::Vec4i> hierarchy;
    cv::findContours(mask.clone(), contours, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    if(contours.size() == 0)
        return -1;

    if (contours.size() > 1) {
        float max_area = 0;
        int max_idx = 0;
        std::vector<std::pair<float,int>> areas;
        for (size_t i = 0; i < contours.size(); ++i) {
            float area = cv::contourArea(contours[i]);
            if (area > max_area) {
                max_idx = i;
                max_area = area;
            }
            areas.push_back(std::pair<float,int>(area,i));
        }
        
        for (size_t i = 0; i < areas.size(); ++i) {
            //if (i == max_idx)
            //    continue;
            //else {
            //    cv::drawContours(mask, contours, i, cv::Scalar(0), -1);
            //}
            if(areas[i].first < max_area * 0.3){
                cv::drawContours(mask, contours, i, cv::Scalar(0), -1);
            }
            else{
                box = box | cv::boundingRect(contours[i]);
            }
        }
    }
    else {
        box = cv::boundingRect(contours[0]);
    }
    return 0;
}
float SegmentAnything::calculate_stability_score(cv::Mat& mask, float mask_threshold, float stable_score_offset)
{
    float intersections = (float)cv::countNonZero(mask > (mask_threshold + stable_score_offset));
    float unions = (float)cv::countNonZero(mask > (mask_threshold - stable_score_offset));
    
    return intersections / unions;
}
}

调用模型

#include "pipeline.h"
#include <iostream>

int main()
{
    int type = 1;
    cv::Mat bgr = cv::imread("2.jpg");

    std::shared_ptr<sam::PipeLine> pipe(new sam::PipeLine());

    pipe->Init("models/encoder-matmul.param","models/encoder-matmul.bin", 
        "models/decoder.param", "models/decoder.bin");
    

    pipeline_result_t pipe_result;
    pipe->ImageEmbedding(bgr, pipe_result);
    switch (type)
    {
    case 1://automatic mask
        pipe_result.sam_result.clear();
        pipe_result.prompt_info.points.clear();
        pipe_result.prompt_info.labels.clear();
        pipe->AutoPredict(bgr, pipe_result);
        pipe->Draw(bgr, pipe_result);
        break;
    case 2://prompt input: points
        pipe_result.prompt_info.prompt_type = PromptType::Point;
        pipe_result.prompt_info.points.push_back(497);
        pipe_result.prompt_info.points.push_back(220);
        pipe_result.prompt_info.points.push_back(455);
        pipe_result.prompt_info.points.push_back(294);
        pipe_result.prompt_info.points.push_back(0);
        pipe_result.prompt_info.points.push_back(0);

        pipe_result.prompt_info.labels.push_back(1);
        pipe_result.prompt_info.labels.push_back(1);
        pipe_result.prompt_info.labels.push_back(-1);

        pipe->Predict(bgr, pipe_result);

        pipe->Draw(bgr, pipe_result);
        break;


    case 3://prompt input: box
        pipe_result.prompt_info.prompt_type = PromptType::Box;
		pipe_result.prompt_info.points.push_back(344);
		pipe_result.prompt_info.points.push_back(144);
		pipe_result.prompt_info.points.push_back(607);
		pipe_result.prompt_info.points.push_back(582);
		pipe_result.prompt_info.points.push_back(0);
		pipe_result.prompt_info.points.push_back(0);

		pipe_result.prompt_info.labels.push_back(2);
		pipe_result.prompt_info.labels.push_back(3);
		pipe_result.prompt_info.labels.push_back(-1);

		pipe->Predict(bgr, pipe_result);
		pipe->Draw(bgr, pipe_result);
        break;
    default:
        break;
    }
  
    return 0;
}

点选择：
在这里插入图片描述
矩形选择：
在这里插入图片描述

知来者逆
关注
  • 20
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
机器学习笔记 - 基于百度飞桨PaddleSeg的人体分割模型以及TensorRT部署说明
学以致用 知行合一
11-29 791
虽然Segment Anything用于图像分割的通用大模型看起来很酷（飞桨也提供分割一切的模型），但是个人感觉落地应用的时候心里还是更倾向于飞桨这种场景式的，因为需要用到一些人体分割的需求，所以这里主要是对飞桨高性能图像分割开发套件进行了解和使用，但是暂时不训练，因为搞数据集挺费劲。内置及最新发布HumanSeglite模型超轻量级人像分割模型，可支持移动端场景的实时分割。
Segment Anything Model自动全局语义分割
11-08
Segment Anything Model自动全局语义分割，包含彩色掩膜导出代码，包含二值化掩膜代码。 Segment Anything Model是一种端到端的深度学习模型，它以全局的方式对图像进行语义分割。这意味着它不仅可以识别和分割预定义的类别，还可以对任意形状和类别的对象进行分割。这种能力使得它在许多应用领域中具有巨大的潜力，如目标检测、图像理解、机器人视觉等。 全局性：Segment Anything Model从全局角度出发，对整个图像进行语义分割，而不仅仅是局部的片段。这使得它可以更好地理解和解释复杂的图像场景。 自动性：该模型具有自动学习能力，能够自动识别和分割图像中的对象，无需人工干预。这大大减少了开发时间和人力成本。 高精度：通过使用深度学习技术，Segment Anything Model可以实现高精度的语义分割，准确地区分不同的对象和背景。 灵活性：该模型具有强大的可扩展性，可以轻松地适应不同的任务和数据集，并且可以方便地进行训练和优化。
分割一切模型 Fast SAM C++推理部署---TensorRT （有核心代码）
勿忘初心,方得始终
08-12 2028
使用C++部署分割一切模型FastSAM
AI分割一切模型SAM(Segment Anything Model)的C++部署
tanmx219的博客
01-22 2541
2023年最火爆的分割模型莫过于SAM，截止今天2024年1月19日，github上的star已经达到了41.7k的惊人数量。项目中有一个export_pre_model.py文件，我略改了一下，因为我没有用hq-sam，直接用的segment-anything，改后内容如下，安装完毕后，用vscode直接打开segment-anything文件夹，选择要测试运行的amg.py文件，然后cmake生成项目，就可以把项目跑起来了，最后的视频效果如下所示。去下载windows上的动态库，我这里的本机地址是，
Meta AI 开源万物可分割 AI 模型(SAM)
2301_77550592的博客
08-02 196
用起来感觉效果不错，毕竟本人不是做ps或者图片处理的，对图片的质量要求不算高，不过Meta开源了segment-anything框架，属实佩服，毕竟连数据集也可以进行下载，下载地址在github主页下方，目前已经21k+star。希望AI可以继续发展，让「玩具」变成工具。
Segment Anything C++ ONNX 部署
2304_76315370的博客
08-25 1541
最近做了几个测试, Segment Anything在工业上做些简单的预处理分割效果是很不错的,而且通过点输入提示,由于工业上拍摄的东西一般位置相对固定,因此可以有广泛的应用. 比如在分割一个轮廓模糊的区域,这样对比下来,如果SAM可以提供C++的部署方案的化,其实可以将分割这个工作量大大降低,最重要的是: 无需调整参数 使用Halcon的化,当图像亮度或者其它条件变化时,需要调整参数的.这里需要onnxruntime的配置,原项目是配置到了根目录下,这里你需要根据实际的路径。
图像万物分割——Segment Anything算法解析与模型推理
知来者逆的博客
12-05 3773
这个模型(SAM)训练完成之后，以使其具备"promptable"（可提示）的性质，因此意味着它可以零样本（zero-shot）地适应新的数据集和任务，而无需先对数据进行标注和训练。作者对该模型进行了广泛的评估，发现它在许多任务上的零样本表现通常与完全监督的性能相媲美，甚至更好。
使用C++纯实现的Meta Segment Anything模型-SAM.cpp
最新发布
gitblog_00007的博客
05-09 450
使用C++纯实现的Meta Segment Anything模型-SAM.cpp sam.cpp项目地址:https://gitcode.com/gh_mirrors/sa/sam.cpp 在这个快速发展的技术世界中，高效的计算机视觉工具对于许多应用程序至关重要。今天，我们向您推荐一个令人印象深刻的开源项目——SAM.cpp，它是一个由C++编写的纯实现版本，将Meta的Segment Anyt...
万物皆可分割——用OpenVINO加速Segment Anything
英特尔开发人员专区
04-19 4948
为了方便各位开发者的使用，我们同样提供了Jupyter Notebook形式的源代码，大家只需要跟随我们代码里的步骤，就可以在自己的机器上运行SAM，对图像进行任意分割了。其实除了以上我们介绍的代码内容，在我们的Jupyter Notebook代码里，还为大家提供了窗口式鼠标点击输入提示的交互式分割体验，甚至可以在手机端输入URL地址体验即时的互动效果，如下图所示。这么多有趣又快速的OpenVINO运行物体分割的方式，快在你本地的机器上克隆我们的代码示例，自己动手试试SAM的效果吧。
Android+OnnxRuntime+Opencv+Onnx模型操作图片擦除多余内容
qq_41294019的博客
04-01 1723
今年来AI的发展非常迅速，在工业、医疗等等行业逐渐出现相应的解决方案，AI也逐渐成为各行业基础设施建设重要的一环，未来发展的大趋势，不过这也需要一个漫长的过程，需要很多技术型人才加入其中，除了工业设施的基础建设，在娱乐方向也有很多有趣的能力，不如图片/视频换背景、人像(图片/视频)动漫化、图片内容擦除等等。
目标跟踪论文代码汇总
如果想成为中心，那么就到中心去吧。
07-21 520
近年来，分割任意模型（SAM）因其对图像分割性能而迅速获得了广泛的关注。由于其较强的图像分割能力和不同提示的高交互性，我们发现其在视频一致性分割效果较差。因此，在本报告中，我们提出了跟踪任何事物模型（TAM），它可以在视频中实现高性能的交互式跟踪和分割。详细地说，给定一个视频序列，只有很少的人类参与，也就是说，几次点击，人们可以跟踪任何他们感兴趣的东西，并在本体推理中得到令人满意的结果。没有额外的训练，这种交互式设计执行的视频对象跟踪和分割令人印象深刻。
lama cleaner
EmoC的博客
07-25 446
如果是GPU的，一定要装GPU版本的pytorch: (我用的11.8版本)如果要使用以上的内容，需要在parse_args.py 这个文件里添加。把这些内容打开后，这个包会自动下载所有相关权重。
轻量级万物分割SAM模型——MobileSAM安装实测摘要
JAMES费的空间
12-02 1105
本文将介绍一种轻量级万物分割SAM模型——MobileSAM的安装和实测情况。SAM是meta公司的一种图像分割大模型，它可以将图像中自带分割物体，他们号称“SAM已经学会了物体的概念”，诸如此类视觉大模型是目前图像分割领域的研究热点之一。然而，SAM模型存在着模型过于庞大对平民不太友好，只能运行在不差钱的人和公司的服务器上，这对于实际应用来说是不可接受的。然而，MobileSAM出现了，诸如此类的量化模型的出现给平民带来了福音，使得模型在保证准确率的同时，运行速度更快，更加适合实际应用。
万物分割SAM使用教程
持续关注并分享目标检测、数据生成、视频驱动、跨模态、分割、关键点等领域前沿技术
05-30 1279
万物分割SAM使用教程，支持框、点、文本输入
分割一切模型 Fast SAM C++推理部署---onnxruntime（有核心代码）
勿忘初心,方得始终
08-12 2380
使用C++部署FastSAM模型
Segment Anything中将生成的多个mask结果拼接在一起，可视化（批量处理）
java_pythons的博客
04-13 2263
Segment Anything中将生成的多个mask结果拼接在一起，可视化（批量处理）
用自然语言分割一切图像【lang-segment-anything】
新缸中之脑
06-03 1513
SAM 使用图像编码器（通常是视觉转换器 (ViT)）来提取图像嵌入，作为掩码预测的基础。该模型还包含一个提示编码器，它对各种类型的输入提示进行编码，例如点坐标、边界框和低分辨率掩码输入。然后将这些编码的提示连同图像嵌入一起输入掩码解码器以生成最终的对象掩码。上述架构允许在已经编码的图像上进行快速和轻便的提示。Mask：可以提供一个粗糙的、低分辨率的二进制掩码作为初始输入来指导模型。Point：用户可以输入 [x, y] 坐标及其类型（前景或背景）以帮助定义对象边界。
segment anything model，用flask部署
04-24
好的，您需要一个基于 Flask 的部署段分词 AI 模型。简单来说，您需要一个能够将输入文本分割成单词或词组的模型，以便您可以分析和处理该文本。以下是您可能需要执行的步骤： 1. 选择合适的分词模型并训练它，这里建议使用中文分词模型，例如 jieba、THULAC 等模型。 2. 将模型封装成简单易用的 Python 包，并使用 Flask 提供的框架完成服务端部署。 3. 编写一个 Flask 应用程序，该应用程序将负责帮助您使用分词模型，并将其应用到您的所有请求中。 4. 在您的服务器上安装 Flask、分词模型、Python 和其他必需的软件包，以便能够运行您的应用程序。 在完成上述步骤后，您将能够使用 HTTP 请求与您的 AI 进行对话，从而实现分词功能。注意，这只是一个简单的示例，您需要根据您的实际需求进行修改和调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

知来者逆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值