A signal processing approach to fair surface design

已于 2023-06-01 14:57:48 修改
阅读量166 收藏
点赞数 1
分类专栏： ZENO 文章标签： 数学建模 开发语言
于 2023-06-01 14:49:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelloveyatou/article/details/130987901
版权

SIGGRAPH 95 
A signal processing approach to fair surface design | Proceedings of the 22nd annual conference on Computer graphics and interactive techniques (acm.org)https://dl.acm.org/doi/10.1145/218380.218473

struct PrimAttribBlur : INode {
    void apply() override {
        auto prim = get_input<PrimitiveObject>("prim");
        auto prim_type = get_input2<std::string>("primType");

//        auto maskName = get_input2<std::string>("group");
//        if (!prim->verts.has_attr(maskName)) {
//            auto &_mask = prim->verts.add_attr<float>(maskName);
//            std::fill(_mask.begin(), _mask.end(), 1.0);
//        }
//        auto &mask = prim->verts.attr<float>(maskName);

        auto attr_name = get_input2<std::string>("attributes");
        auto attr_type = get_input2<std::string>("attributesType");

        auto useEdgeLength = get_input<NumericObject>("useEdgeLengthWeight")->get<bool>();

        auto iterations = get_input<NumericObject>("blurringIterations")->get<int>();

        auto mode = get_input2<std::string>("mode");
        auto mu = get_input<NumericObject>("stepSize")->get<float>();
        auto lambda = mu;
        if (mode == "VolumePreserving") {
            auto passband = get_input<NumericObject>("cutoffFrequency")->get<float>();
            if (passband < 1e-5) {
                float sqrt2_5 = 0.6324555320336758664;
                lambda = sqrt2_5;
                mu = -sqrt2_5;
            } else {
                // See:
                //   Gabriel Taubin. "A signal processing approach to fair surface design".
                //   SIGGRAPH 1995
                //
                // Let l be lambda, u be mu, and b be the passband frequency.
                // f(k) = (1-k*l)(1-k*u).  This function has maximum at 1/l + 1/u.
                // We want the maximum to occur at b, so we have the constraint
                //          1/l + 1/u = passband
                // so       u = l/(bl - 1)
                // We also want f(1) = -f(2).  This gives the constraint:
                //          u = (2-3l)/(3-5l)
                // Equating this equations gives:
                //          (3b-5)l^2 - 2bl + 2 = 0
                // Solve for l using the quadratic formula.  We want l>0.  Since b>0 and
                // 6b-10<0, subtract the square root of the discriminant to get a negative
                // numerator so the quotient is positive.
                auto discriminant = 4.0 * passband * passband - 24.0 * passband + 40.0;
                lambda = 2.0 * passband - sqrt(discriminant);
                lambda /= (6.0 * passband - 10.0);

                // Now solve for u.  Note that u is also the other root of the quadratic.
                mu = lambda / (passband * lambda - 1.0);
            }
        } else if (mode == "custom") {
            lambda = get_input<NumericObject>("oddStepSize")->get<float>();
            mu = get_input<NumericObject>("evenStepSize")->get<float>();
        }

        auto weightName = get_input2<std::string>("weightAttributes");
        if (!prim->verts.has_attr(weightName)) {
            auto &_weight = prim->verts.add_attr<float>(weightName);
            std::fill(_weight.begin(), _weight.end(), 1.0);
        }
        auto &weight = prim->verts.attr<float>(weightName);

        // 找临近点，假设最多 8 个临近点
        auto &neighbor_0 = prim->verts.add_attr<int>("_neighbor_0");
        auto &neighbor_1 = prim->verts.add_attr<int>("_neighbor_1");
        auto &neighbor_2 = prim->verts.add_attr<int>("_neighbor_2");
        auto &neighbor_3 = prim->verts.add_attr<int>("_neighbor_3");
        auto &neighbor_4 = prim->verts.add_attr<int>("_neighbor_4");
        auto &neighbor_5 = prim->verts.add_attr<int>("_neighbor_5");
        auto &neighbor_6 = prim->verts.add_attr<int>("_neighbor_6");
        auto &neighbor_7 = prim->verts.add_attr<int>("_neighbor_7");
        std::fill(neighbor_0.begin(), neighbor_0.end(), -1);
        std::fill(neighbor_1.begin(), neighbor_1.end(), -1);
        std::fill(neighbor_2.begin(), neighbor_2.end(), -1);
        std::fill(neighbor_3.begin(), neighbor_3.end(), -1);
        std::fill(neighbor_4.begin(), neighbor_4.end(), -1);
        std::fill(neighbor_5.begin(), neighbor_5.end(), -1);
        std::fill(neighbor_6.begin(), neighbor_6.end(), -1);
        std::fill(neighbor_7.begin(), neighbor_7.end(), -1);
        auto &edgeweight_0 = prim->verts.add_attr<float>("_edgeweight_0");
        auto &edgeweight_1 = prim->verts.add_attr<float>("_edgeweight_1");
        auto &edgeweight_2 = prim->verts.add_attr<float>("_edgeweight_2");
        auto &edgeweight_3 = prim->verts.add_attr<float>("_edgeweight_3");
        auto &edgeweight_4 = prim->verts.add_attr<float>("_edgeweight_4");
        auto &edgeweight_5 = prim->verts.add_attr<float>("_edgeweight_5");
        auto &edgeweight_6 = prim->verts.add_attr<float>("_edgeweight_6");
        auto &edgeweight_7 = prim->verts.add_attr<float>("_edgeweight_7");
        std::fill(edgeweight_0.begin(), edgeweight_0.end(), 0);
        std::fill(edgeweight_1.begin(), edgeweight_1.end(), 0);
        std::fill(edgeweight_2.begin(), edgeweight_2.end(), 0);
        std::fill(edgeweight_3.begin(), edgeweight_3.end(), 0);
        std::fill(edgeweight_4.begin(), edgeweight_4.end(), 0);
        std::fill(edgeweight_5.begin(), edgeweight_5.end(), 0);
        std::fill(edgeweight_6.begin(), edgeweight_6.end(), 0);
        std::fill(edgeweight_7.begin(), edgeweight_7.end(), 0);

        //========================================
//        LARGE_INTEGER t1_0,t2_0,tc_0;
//        LARGE_INTEGER t1_1,t2_1,tc_1;
//        LARGE_INTEGER t1_2,t2_2,tc_2;
        //========================================

        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//        QueryPerformanceFrequency(&tc_0);
//        QueryPerformanceCounter(&t1_0);

#pragma omp parallel for
        for (size_t point_idx = 0; point_idx < prim->verts.size(); point_idx++) {   // 遍历所有点，找它的邻居
            std::map<std::string, int> neighborVertID;
            std::map<std::string, float> neighborEdgeLength;
            for(int i = 0; i < 8; i++) {
                neighborVertID["neighbor_" + std::to_string(i)] = -1;
                neighborEdgeLength["edgeweight_" + std::to_string(i)] = 0;
            }

            int find_neighbor_count = 0;
            float edgeLengthSum = 0;
            volatile bool flag = false;

            if (prim_type == "line") {
#pragma omp parallel for shared(flag)
                for (size_t line_idx = 0; line_idx < prim->lines.size(); line_idx++) {
                    if(flag) continue;
                    if (prim->lines[line_idx][0] == point_idx) {
                        neighborVertID["neighbor_" + std::to_string(find_neighbor_count)] = prim->lines[line_idx][1];
                        if (useEdgeLength) {
                            float edgeLength = length(prim->verts[prim->lines[line_idx][1]] - prim->verts[point_idx]);
                            neighborEdgeLength["edgeweight_" + std::to_string(find_neighbor_count)] = edgeLength;
                            edgeLengthSum += edgeLength;
                        }
                        find_neighbor_count ++;
                    } else if (prim->lines[line_idx][1] == point_idx) {
                        neighborVertID["neighbor_" + std::to_string(find_neighbor_count)] = prim->lines[line_idx][0];
                        if (useEdgeLength) {
                            float edgeLength = length(prim->verts[prim->lines[line_idx][0]] - prim->verts[point_idx]);
                            neighborEdgeLength["edgeweight_" + std::to_string(find_neighbor_count)] = edgeLength;
                            edgeLengthSum += edgeLength;
                        }
                        find_neighbor_count++;
                    }
                    if (find_neighbor_count >= 7)
                        flag = true;
                }
            } else if (prim_type == "tri") {
                std::vector<int> pointNeighborSign(prim->verts.size());
                std::fill(pointNeighborSign.begin(), pointNeighborSign.end(), 0);

                //========================================
//                if (point_idx == 50000) {
//                    QueryPerformanceFrequency(&tc_1);
//                    QueryPerformanceCounter(&t1_1);
//                }
                //========================================

#pragma omp parallel for
                for (size_t tri_idx = 0; tri_idx < prim->tris.size(); tri_idx++) {
                    auto const &ind = prim->tris[tri_idx];
                    if (ind[0] == point_idx) {
                        pointNeighborSign[ind[1]] = 1;
                        pointNeighborSign[ind[2]] = 1;
                    } else if (ind[1] == point_idx) {
                        pointNeighborSign[ind[0]] = 1;
                        pointNeighborSign[ind[2]] = 1;
                    } else if (ind[2] == point_idx) {
                        pointNeighborSign[ind[0]] = 1;
                        pointNeighborSign[ind[1]] = 1;
                    }
                }

#pragma omp parallel for shared(flag)
                for (int i = 0; i < prim->verts.size(); i++) {
                    if(flag) continue;
                    if (pointNeighborSign[i]) {
                        neighborVertID["neighbor_" + std::to_string(find_neighbor_count)] = i;
                        if (useEdgeLength) {
                            float edgeLength = length(prim->verts[i] - prim->verts[point_idx]);
                            neighborEdgeLength["edgeweight_" + std::to_string(find_neighbor_count)] = edgeLength;
                            edgeLengthSum += edgeLength;
                        }
                        find_neighbor_count ++;
                    }
                    if (find_neighbor_count >= 7)
                        flag = true;
                }

                //========================================
//                if (point_idx == 50000) {
//                    QueryPerformanceCounter(&t2_1);
//                    double time_1 = (double)(t2_1.QuadPart - t1_1.QuadPart)/(double)tc_1.QuadPart;
//                    printf("time_1 = %f s\n", time_1);
//                }
                //========================================
            }

            neighbor_0[point_idx] = neighborVertID["neighbor_0"];
            neighbor_1[point_idx] = neighborVertID["neighbor_1"];
            neighbor_2[point_idx] = neighborVertID["neighbor_2"];
            neighbor_3[point_idx] = neighborVertID["neighbor_3"];
            neighbor_4[point_idx] = neighborVertID["neighbor_4"];
            neighbor_5[point_idx] = neighborVertID["neighbor_5"];
            neighbor_6[point_idx] = neighborVertID["neighbor_6"];
            neighbor_7[point_idx] = neighborVertID["neighbor_7"];

            if (useEdgeLength) {
                float min_length = (edgeLengthSum / (float)(find_neighbor_count)) * 0.001f;
                float sum = 0;

#pragma omp parallel for
                for (int i = 0; i < find_neighbor_count; i++)
                {
                    float length = neighborEdgeLength["edgeweight_" + std::to_string(i)];

                    if ( length > min_length )
                        neighborEdgeLength["edgeweight_" + std::to_string(i)] = 1.0 / length;
                    else    // 基本重合的点，不考虑其影响，权重打到 0
                        neighborEdgeLength["edgeweight_" + std::to_string(i)] = 0;

                    sum += neighborEdgeLength["edgeweight_" + std::to_string(i)];   // 累计总权重
                }
                if ( sum > 0 )
                {
#pragma omp parallel for
                    for (int i = 0; i < find_neighbor_count; ++i)
                    {
                        neighborEdgeLength["edgeweight_" + std::to_string(i)] /= sum;   // 权重归一化
                    }
                }

                edgeweight_0[point_idx] = neighborEdgeLength["edgeweight_0"];
                edgeweight_1[point_idx] = neighborEdgeLength["edgeweight_1"];
                edgeweight_2[point_idx] = neighborEdgeLength["edgeweight_2"];
                edgeweight_3[point_idx] = neighborEdgeLength["edgeweight_3"];
                edgeweight_4[point_idx] = neighborEdgeLength["edgeweight_4"];
                edgeweight_5[point_idx] = neighborEdgeLength["edgeweight_5"];
                edgeweight_6[point_idx] = neighborEdgeLength["edgeweight_6"];
                edgeweight_7[point_idx] = neighborEdgeLength["edgeweight_7"];
            }

        }

//        QueryPerformanceCounter(&t2_0);
//        double time_0 = (double)(t2_0.QuadPart - t1_0.QuadPart)/(double)tc_0.QuadPart;
//        printf("time_0 = %f s\n", time_0);
//        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//        QueryPerformanceFrequency(&tc_2);
//        QueryPerformanceCounter(&t1_2);

        // 平滑属性计算
        std::visit(
            [&](auto ty) {
              using T = decltype(ty);

              auto &data = prim->verts.attr<T>(attr_name);
              auto &data_temp = prim->verts.add_attr<T>("_data_temp");
              std::fill(data_temp.begin(), data_temp.end(), T(0));

              for (int loop = 0; loop < iterations; loop++) {
#pragma omp parallel for
                  // data => data_temp
                  for (size_t i = 0; i < prim->verts.size(); i++) {
                      std::vector<int> neighborIDs(8);
                      neighborIDs[0] = neighbor_0[i];
                      neighborIDs[1] = neighbor_1[i];
                      neighborIDs[2] = neighbor_2[i];
                      neighborIDs[3] = neighbor_3[i];
                      neighborIDs[4] = neighbor_4[i];
                      neighborIDs[5] = neighbor_5[i];
                      neighborIDs[6] = neighbor_6[i];
                      neighborIDs[7] = neighbor_7[i];
                      std::vector<T> neighborValues(8);
                      for (int i = 0; i < neighborIDs.size(); i++) {
                          if (neighborIDs[i] != -1)
                              neighborValues[i] = data[neighborIDs[i]];
                      }
                      std::vector<float> neighborEdgeWeights(8);
                      neighborEdgeWeights[0] = edgeweight_0[i];
                      neighborEdgeWeights[1] = edgeweight_1[i];
                      neighborEdgeWeights[2] = edgeweight_2[i];
                      neighborEdgeWeights[3] = edgeweight_3[i];
                      neighborEdgeWeights[4] = edgeweight_4[i];
                      neighborEdgeWeights[5] = edgeweight_5[i];
                      neighborEdgeWeights[6] = edgeweight_6[i];
                      neighborEdgeWeights[7] = edgeweight_7[i];
                      smooth(neighborIDs, neighborValues, neighborEdgeWeights, useEdgeLength, data[i], weight[i], lambda, data_temp[i]);
                  }
#pragma omp parallel for
                  // data_temp => data
                  for (size_t i = 0; i < prim->verts.size(); i++) {
                      std::vector<int> neighborIDs(8);
                      neighborIDs[0] = neighbor_0[i];
                      neighborIDs[1] = neighbor_1[i];
                      neighborIDs[2] = neighbor_2[i];
                      neighborIDs[3] = neighbor_3[i];
                      neighborIDs[4] = neighbor_4[i];
                      neighborIDs[5] = neighbor_5[i];
                      neighborIDs[6] = neighbor_6[i];
                      neighborIDs[7] = neighbor_7[i];
                      std::vector<T> neighborValues(8);
                      for(int i = 0; i < neighborIDs.size(); i++)
                      {
                          if (neighborIDs[i] != -1)
                              neighborValues[i] = data_temp[neighborIDs[i]];
                      }
                      std::vector<float> neighborEdgeWeights(8);
                      neighborEdgeWeights[0] = edgeweight_0[i];
                      neighborEdgeWeights[1] = edgeweight_1[i];
                      neighborEdgeWeights[2] = edgeweight_2[i];
                      neighborEdgeWeights[3] = edgeweight_3[i];
                      neighborEdgeWeights[4] = edgeweight_4[i];
                      neighborEdgeWeights[5] = edgeweight_5[i];
                      neighborEdgeWeights[6] = edgeweight_6[i];
                      neighborEdgeWeights[7] = edgeweight_7[i];
                      smooth(neighborIDs, neighborValues, neighborEdgeWeights, useEdgeLength, data_temp[i], weight[i], mu, data[i]);
                  }
              }
              prim->verts.erase_attr("_data_temp");

            },
            enum_variant<std::variant<float, vec3f>>(
                array_index({"float", "vec3f"}, attr_type)));

//        QueryPerformanceCounter(&t2_2);
//        double time_2 = (double)(t2_2.QuadPart - t1_2.QuadPart)/(double)tc_2.QuadPart;
//        printf("time_2 = %f s\n", time_2);
        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

        prim->verts.erase_attr("_neighbor_0");
        prim->verts.erase_attr("_neighbor_1");
        prim->verts.erase_attr("_neighbor_2");
        prim->verts.erase_attr("_neighbor_3");
        prim->verts.erase_attr("_neighbor_4");
        prim->verts.erase_attr("_neighbor_5");
        prim->verts.erase_attr("_neighbor_6");
        prim->verts.erase_attr("_neighbor_7");
        prim->verts.erase_attr("_edgeweight_0");
        prim->verts.erase_attr("_edgeweight_1");
        prim->verts.erase_attr("_edgeweight_2");
        prim->verts.erase_attr("_edgeweight_3");
        prim->verts.erase_attr("_edgeweight_4");
        prim->verts.erase_attr("_edgeweight_5");
        prim->verts.erase_attr("_edgeweight_6");
        prim->verts.erase_attr("_edgeweight_7");

        set_output("prim", std::move(prim));
    }
};
ZENDEFNODE(PrimAttribBlur,
           {/* inputs: */ {
                   "prim",
                   {"enum line tri", "primType", "tri"},
//                   {"string", "group", "mask"},
                   {"string", "attributes", "ratio"},
                   {"enum float vec3f ", "attributesType", "float"},
                   {"bool", "useEdgeLengthWeight", "false"},
                   {"int", "blurringIterations", "0"},
                   {"enum laplacian VolumePreserving custom", "mode", "laplacian"},
                   {"float", "stepSize", "0.683"},
                   {"float", "cutoffFrequency", "0.1"},
                   {"float", "evenStepSize", "0.5"},
                   {"float", "oddStepSize", "0.5"},
                   {"string", "weightAttributes", "weight"},
               }, /* outputs: */ {
                   "prim",
               }, /* params: */ {
               }, /* category: */ {
                   "primCurve",
               }});

SSRNet 三维重建
m0_37856424的博客
09-04 1070
#SSRNet: Scalable 3D Surface Reconstruction Network 论文目的：surface reconstruction SSRNet 核心是local geometry-aware features for octree vertices and designs a scalable reconstruction pipeline 优点： （1）提高顶点和曲面相对位置的重建质量，并行性好 （2）只需要several surface data 用来训练 （.
AR as a civil right
weixin_42786150的博客
02-16 4480
增强现实的民事权利与刑法程序
论文翻译-----《马尔可夫随机场在距离传感中的应用》
qq_46559411的博客
04-20 3034
论文翻译--马尔可夫
论文研究-一种保持特征的三角网格去噪方法 .pdf
08-21
一种保持特征的三角网格去噪方法，张三元，李强，大量的三维网格是建立在三维扫描数据的基础上，有效地去除在扫描过程中引入的噪声成为3D造型技术中的一个关键问题。双边滤波在图�
Diffussion Distance
zyjiang0571的专栏
06-05 822
源地址：http://www.cs.jhu.edu/~ming/Blog/DiffusionDistance.htm Mings Note  Diffusion DistanceA few weeks ago, we read two beautifullywrittenpapers in our graphics seminar. Bot
计算机视觉论文-2021-06-22
中科院AI算法工程师的博客
06-23 3229
本专栏是计算机视觉方向论文收集积累，时间：2021年6月22日，来源：paper digest 欢迎关注原创公众号【计算机视觉联盟】，回复【西瓜书手推笔记】可获取我的机器学习纯手推笔记！ 直达笔记地址：机器学习手推笔记（GitHub地址） 1, TITLE:One Million Scenes for Autonomous Driving: ONCE Dataset AUTHORS: JIAGENG MAO et. al. CATEGORY: cs.CV [cs.CV] HIGHLIG...
olga----Interactive Shape Modeling(1):classmaterials:Digital Geometry Processing
dfwz1971的博客
01-01 148
http://cs.nyu.edu/~sorkine/courses/shape_modeling/isp2009/pmwiki.php?n=ClassMaterial.DGPDigital geometry processing topics include mesh smoothing and denoising, mesh simplification and multireso...
今日arXiv精选 | 35篇顶会论文：ICCV/ CIKM/ ACM MM
Paper weekly
08-19 4635
关于#今日arXiv精选这是「AI 学术前沿」旗下的一档栏目，编辑将每日从arXiv中精选高质量论文，推送给读者。TSI: an Ad Text Strength Indicator...
CVPR2017论文摘要汇总
super_chicken的博客
04-09 1万+
1. Exclusivity-Consistency Regularized Multi-view Subspace Clustering Abstract: Multi-view subspace clustering aims to partition a set of multi-source data into their underlying groups. To boost the ...
2020-04-03-功能性光学脑成像
Chen Rui blog
04-16 6781
layout title subtitle date author header-img catalog istop music-id music-idfull apserver aptype apsongid tags post 功能性光学脑成像 Functional Optical Bra...
【论文阅读笔记】NeurIPS2020文章列表Part1
热门推荐
zincrain的博客
12-09 2万+
A graph similarity for deep learning An Unsupervised Information-Theoretic Perceptual Quality Metric Self-Supervised MultiModal Versatile Networks Benchmarking Deep Inverse Models over time, and the Neural-Adjoint method Off-Policy Evaluation and Learning.
python可视化将多张图整合到一起（画布）
2403_83182682的博客
11-04 1413
这周有点事忙着，没时间重温刚结束的Mathurcup数学建模，这两天也是再看了下，论文还是赶紧挺烂的，但比国赛又有进步（说起国赛又不得不抱怨了，基本其余省份都发了，但江西......哎）。哎，数模就是这样，想起刚接触数模，也是参加了Mathurcup，结果。。。 咳咳，跑偏了，就这次Mathurcup而言，还是感觉到了有些乏力，毕竟平常也都不会去专门看数模，都是比赛的时候临时学，有些模型、方法还是很生。但熬了这么久，也算学到了点啥，对于我来说，我是敲代码的，思路方面不用我操心，理解他思路就行，
数学建模模型算法-Python实现
2301_80401457的博客
11-12 481
层次分析法用来评价或选择一个更好更优的决策或方案通过找到可以衡量其好坏的指标，进而衡量指标，再形成评价体系。
Excel模板下载\数据导出
最新发布
a14654的博客
11-13 415
web程序excel模板下载及数据导出
AI企联系统 Ai企业级系统开心版 uniapp适配 Web+H5+微信小程序+抖音小程序+双端APP
11-12
AI企联系统 Ai企业级系统开心版 uniapp适配 Web+H5+微信小程序+抖音小程序+双端APP 一款市面上新出的AI企联系统，项目uniapp开发的，支持3.5 4.0 Mj，此套系统5端适配，Web+H5+微信小程序+抖音小程序+双端APP，支持流量主! 自己有能力的可以二开，UI后台也可以自己改。
2000d.doc
11-12
2000d
通过SpringCloud实现微服务：Eureka+Ribbon+Feign+Zuul.zip
11-12
根据书籍《Java微服务架构实践》提供源码，通过SpringCloud实现微服务：Eureka+Ribbon+Feign+Zuul
基于CNN-BiLSTM-Adaboost的自行车租赁数量预测研究附Matlab代码.rar
11-12
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
C2005.doc
11-12
C2005
spotlight-mode synthetic aperture radar: a signal processing approach
09-04
聚焦模式合成孔径雷达(Spotlight-mode Synthetic Aperture Radar)是一种信号处理方法，用于合成孔径雷达图像的获取。 合成孔径雷达(SAR)是一种通过发射和接收多个脉冲信号来生成高分辨率雷达图像的技术。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值