关闭Bright data

最新推荐文章于 2025-04-29 11:18:56 发布
最新推荐文章于 2025-04-29 11:18:56 发布
阅读量6.9k 收藏 4
点赞数 5
文章标签： 技巧
原文链接：https://jingyan.baidu.com/article/d5c4b52b8db34a9b570dc57a.html
版权

格式工厂安装完有个Bright data 的程序，这个程序其实是个数据收集工具，为保护个人隐私，我们今天就来为大家解决它！

我的电脑右键–管理-服务与应用程序-服务–在服务里找到Brightdata Service这个。

在这里插入图片描述
“属性”—“启动类型”里禁用掉

在这里插入图片描述
在上面的“恢复”里第一次第二次失败里选择“无操作”–应用–确定后就可以了。

在这里插入图片描述

智能家居生物节律调节创业：优化日常生活的生理韵律
AI天才研究院
10-26 767
《智能家居生物节律调节创业：优化日常生活的生理韵律》 关键词：智能家居、生物节律调节、物联网技术、创业、生理韵律优化 摘要：随着智能家居技术的快速发展
聊一聊BrightData亮数据这款浏览器
Ansel_csdn1的博客
05-07 981
亮数据浏览器是一个 GUI 浏览器（又名“headfull”浏览器），它使用图形用户界面，由 Puppeteer 或 Playwright API 控制，因其内置网站解锁功能，自动处理网站反爬机制的封禁， GUI 浏览器不太可能被机器人检测软件检测到。由于抓取浏览器是在亮数据服务器上打开的，因此这些自动化浏览器非常适合大规模网页数据抓取项目，“无头浏览器”是指没有图形用户界面的网络浏览器，与代理一起使用来抓取数据时，很容易被机器人软件检测到，使得大规模数据抓取变得困难。根据需要打开任意数量的抓取浏览器，
横空出世，Bright Data 低代码数据平台，即将颠覆你的认知！
java1234的博客
02-23 2803
大家好，我是锋哥，最近接了个监控平台的私活项目。由于监控公开的站点太多，在我无从下手迷茫之际，竟然无意中发现了这个宝藏级。！横空出世，Bright Data 低代码数据平台，即将颠覆你的认知！
2025海外代理IP测评：Bright Data，ipfoxy，smartproxy，ipipgo，kookeey，ipidea哪个值得推荐？
njmanong的博客
04-16 1677
近年来，随着全球化和跨境业务需求的不断扩大“海外代理IP”逐渐成为企业和个人在多样化场景中的重要工具。无论是进行数据采集、广告验证、社交媒体管理，还是跨境电商平台运营，选择合适的代理IP服务商都显得尤为重要。然而，市场上代理IP服务商种类繁多，要在众多选择中找到最符合自己需求的服务商，往往需要综合考虑多个因素。那么问题来了：Bright Data，ipfoxy，smartproxy，ipipgo，青果网络，kookeey，ipidea这些服务商到底有什么区别？哪家更值得推荐？今天，我们将基于2024-202
如何彻底关闭Bright Data
记录我目之所及的世界
12-14 4767
BrightData.exe关机弹窗警告问题
禁用格式工厂的Bright Data
NSJim的博客
09-07 7414
电脑在安装较新版本的格式工厂（例如V5.12）后，会自启Bright Data服务，并最小化到任务栏图标中。该服务是一个数据上传和下载工具，开启该服务可以获取格式工厂的白金功能。如果无需使用格式工厂的白金功能，例如：视频防抖、降噪、反向、等等。且比较注重用户数据隐私。则建议关闭Bright Data服务，当需要使用白金功能时可以再短期开启该服务。下面介绍如何关闭/开启格式工厂的Bright Data服务。
亮数据—数据采集工具全面评测
m0_73367097的博客
03-19 6900
数据采集工具全面评测
Bright Data--一个强大好用的超级ip代理软件
FunCrown的博客
12-20 5411
Luminati–一个强大好用的超级ip代理软件 Fun Crown 现在国内很多人都在各种国外平台做推广，比如亚马逊，Facebook，ebay等等。如果你的亚马逊或ebay不需要刷单，Facebook用企业号的话，后面的内容可以不看了。但反之，强烈建议看以下内容。 众所周知，如果需要刷单或者用Facebook个人号，一个稳定、干净的ip来维持登陆环境是必要条件（当然还有设备）。而Luminati的家庭静态和动态ip能达到这个要求（机房ip质量很差，手机ip太贵都不建议使用），他们的ip在每个国家每个大城
python零基础学习篇课程资料-CLASSDATA_ch05数据表达逻辑：结果输出及内容美化.zip
05-02
- 使用`Fore`类的属性（如`RED`, `GREEN`, `BLUE`等）和`Style`类的属性（如`BRIGHT`, `DIM`, `UNDERLINE`等）组合，如`print(Fore.RED + Back.GREEN + Style.BRIGHT + "Colorful Text")`。 6. **处理大型数据输出...
ax=sns.lineplot(x='hour',y='pv_behavior_hour',hue='pv_behavior_hour',data=pv_behavior_hour)
03-24
palette="bright", # 使用明亮色彩方案提升视觉效果 data=pv_behavior_hour ) plt.title('用户行为随小时变化趋势') plt.xlabel('Hour of Day') plt.ylabel('PV Behavior Count per Hour') plt.xticks(list(range...
#include "images.h" uint8 l_border[MT9V03X_H];//左线数组 uint8 r_border[MT9V03X_H];//右线数组 uint8 center_line[MT9V03X_H];//中线数组 /*变量声明*/ //uint8 original_image[MT9V03X_H][MT9V03X_W]; uint8 bin_image[MT9V03X_H][MT9V03X_W];//图像数组 uint8 image_thereshold_last = 0;// uint8 image_thereshold;//图像分割阈值 //------------------------------------------------------------------------------------------------------------------ // @函数功能 求绝对值 // @函数返回 绝对值 //------------------------------------------------------------------------------------------------------------------ int my_abs(int value) { if(value>=0) return value; else return -value; } //数值范围限制 int16 limit_a_b(int16 x, int a, int b) { if(x<a) x = a; if(x>b) x = b; return x; } //------------------------------------------------------------------------------------------------------------------ // @函数功能 求x,y中的最小值 // @函数返回 两值中的最小值 //------------------------------------------------------------------------------------------------------------------ int16 limit1(int16 x, int16 y) { if (x > y) return y; else if (x < -y) return -y; else return x; } //------------------------------------------------------------------------------------------------------------------ // @函数功能 获得一副灰度图像 // @函数返回 灰度图像数组original_image //------------------------------------------------------------------------------------------------------------------ void Get_image(uint8(*mt9v03x_image)[MT9V03X_W]) { uint8 i = 0, j = 0; for (i = 0; i < MT9V03X_H; i += 1) { for (j = 0; j <MT9V03X_W; j += 1) { bin_image[i][j] = mt9v03x_image[i][j]; } } } //将原始图像复制到bin_image数组 /*void gamma_correction(uint8(*image)[MT9V03X_W], float gamma)//（自己添加部分） { for(int i=0; i<MT9V03X_H; i++) { for(int j=0; j<MT9V03X_W; j++) { float normalized = image[i][j]/255; image[i][j] = pow(normalized, gamma) * 255; } } }*/ //------------------------------------------------------------------------------------------------------------------ // @函数功能 大津法求动态阈值 // @函数返回 动态阈值Threshold //------------------------------------------------------------------------------------------------------------------ uint8 OtsuThreshold(uint8 *image) { uint8 Pixel_Max = 0; uint8 Pixel_Min = 255; //uint16 width = MT9V03X_W / use_num; //uint16 height = MT9V03X_H / use_num; int pixelCount[GrayScale]; //各像素GrayScale的个数pixelCount 一维数组 float pixelPro[GrayScale]; //各像素GrayScale所占百分比pixelPro 一维数组 int16 i = 0; int16 j = 0; int16 pixelSum = MT9V03X_W * MT9V03X_H / 4; //pixelSum是获取总的图像像素个数的1/4，相应下面轮询时高和宽都是以2为单位自增 uint8 threshold = 0; uint8* data = image; //指向像素数据的指针 for(i = 0;i < GrayScale;i++) { pixelCount[i] = 0; pixelPro[i] = 0; } uint32 gray_sum = 0; //统计灰度图中每个像素在整幅图像中的个数 for(i = 0;i < MT9V03X_H;i += 2) { for(j = 0;j < MT9V03X_W; j += 2) { pixelCount[(int)data[i * MT9V03X_W + j]]++; //将当前的点的像素值作为计数数组的下标 gray_sum += (int)data[i * MT9V03X_W + j]; //灰度值总和 if(data[i * MT9V03X_W + j] > Pixel_Max) { Pixel_Max = data[i * MT9V03X_W + j]; } if(data[i * MT9V03X_W + j] < Pixel_Min) { Pixel_Min = data[i * MT9V03X_W + j]; } } } //计算每个像素值的点在整幅图像中的比例 for(i = Pixel_Min;i < Pixel_Max;i++) { pixelPro[i] = (float)pixelCount[i] / pixelSum; } //遍历灰度值 float w0,w1,u0tmp,u1tmp,u0,u1,deltaTmp,deltaMax = 0; w0 = w1 = u0tmp = u1tmp = u0 = u1 = deltaTmp = 0; for(j = Pixel_Min;j < Pixel_Max;j++) { w0 += pixelPro[j]; //背景部分每个灰度值的像素点所占比例之和 即背景部分的比例 u0tmp += j * pixelPro[j]; //背景部分 每个灰度值的点的比例 *灰度值 w1 = 1 - w0; u1tmp = gray_sum / pixelSum-u0tmp; u0 = u0tmp / w0; //背景平均灰度 u1 = u1tmp / w1; //前景平均灰度 deltaTmp = (float)(w0 * w1 * (u0 - u1) * (u0 - u1)); if(deltaTmp > deltaMax) { deltaMax = deltaTmp; threshold = (uint8)j; } if(deltaTmp < deltaMax) { break; } } //限幅 if(threshold > 25 && threshold < 235) { image_thereshold_last = threshold; } else { threshold = image_thereshold_last; } return threshold; } //------------------------------------------------------------------------------------------------------------------ // @函数功能 图像二值化，大津法 // @函数返回 二值化图像数组bin_image //------------------------------------------------------------------------------------------------------------------ void turn_to_bin(void) { uint8 i,j; image_thereshold = OtsuThreshold(bin_image[0]); //ips114_show_int(189,0,image_thereshold,5); for(i = 0;i < MT9V03X_H;i++) { for(j = 0;j < MT9V03X_W;j++) { if(bin_image[i][j] > image_thereshold) { bin_image[i][j] = 255; } else { bin_image[i][j] = 0; } } } /* for(i = 40;i < MT9V03X_H;i++) { for(j = 0;j < MT9V03X_W;j++) { if(bin_image[i][j] < image_thereshold) { bin_image[i][j] = 0; } else { bin_image[i][j] =255; } } }*/ } //------------------------------------------------------------------------------------------------------------------ // @函数功能 寻找两个边界的边界点作为八邻域循环的起始点 // @参数说明 输入任意行数 // @函数返回 无 //------------------------------------------------------------------------------------------------------------------ uint8 start_point_l[2] = { 0 };//左边起点的x，y值 uint8 start_point_r[2] = { 0 };//右边起点的x，y值 uint8 get_start_point(uint8 start_row) { uint8 i = 0,j = MT9V03X_W/2,l_found = 0,r_found = 0,num = 0; //清零 start_point_l[0] = 0;//左x start_point_l[1] = 0;//左y start_point_r[0] = 0;//右x start_point_r[1] = 0;//右y //大致定位白线 for(num = 0;num < MT9V03X_W/2 - 15;num = num + 10) { if(bin_image[start_row][j + num] == 255) { j = j + num; break; } if(bin_image[start_row][j - num] == 255) { j = j - num; break; } } //从中间往左边，先找起点 for (i = j; i > border_min; i--) { start_point_l[0] = i;//x start_point_l[1] = start_row;//y if (bin_image[start_row][i] == 255 && bin_image[start_row][i - 1] == 0) { //printf("找到左边起点image[%d][%d]\n", start_row,i); l_found = 1; break; } } for (i = j; i < border_max; i++) { start_point_r[0] = i;//x start_point_r[1] = start_row;//y if (bin_image[start_row][i] == 255 && bin_image[start_row][i + 1] == 0) { //printf("找到右边起点image[%d][%d]\n",start_row, i); r_found = 1; break; } } if(l_found&&r_found) { return 1; } else { //printf("未找到起点\n"); return 0; } } //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // @函数功能 八邻域正式开始找右边点的函数，左右线一次性找完。 Tip:特别注意，不要拿宏定义名字作为输入参数，否则数据可能无法传递过来 // @参数说明 // break_flag_r 最多需要循环的次数 // (*image)[image_w] 需要进行找点的图像数组，必须是二值图,填入数组名称即可 // *l_stastic 统计左边数据，用来输入初始数组成员的序号和取出循环次数 // *r_stastic 统计右边数据，用来输入初始数组成员的序号和取出循环次数 // l_start_x 左边起点横坐标 // l_start_y 左边起点纵坐标 // r_start_x 右边起点横坐标 // r_start_y 右边起点纵坐标 // hightest 循环结束所得到的最高高度 // @函数返回 无 // @备 注： //example：search_l_r((uint16)USE_num,image,&data_stastics_l, &data_stastics_r,start_point_l[0],start_point_l[1], start_point_r[0], start_point_r[1],&hightest); //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- #define USE_num MT9V03X_H*3 //定义找点的数组成员个数按理说300个点能放下，但是有些特殊情况确实难顶，多定义了一点 //存放点的x，y坐标 uint16 points_l[(uint16)USE_num][2] = { { 0 } };//左线 uint16 points_r[(uint16)USE_num][2] = { { 0 } };//右线 uint16 dir_r[(uint16)USE_num] = { 0 };//用来存储右边生长方向 uint16 dir_l[(uint16)USE_num] = { 0 };//用来存储左边生长方向 uint16 data_stastics_l = 0;//统计左边找到点的个数 uint16 data_stastics_r = 0;//统计右边找到点的个数 uint8 hightest = 0;//最高点 void search_l_r(uint16 break_flag, uint8(*image)[MT9V03X_W], uint16 *l_stastic, uint16 *r_stastic, uint8 l_start_x, uint8 l_start_y, uint8 r_start_x, uint8 r_start_y, uint8*hightest) { uint8 i = 0, j = 0; //左边变量 uint8 search_filds_l[8][2] = { { 0 } }; uint8 index_l = 0; uint8 temp_l[8][2] = { { 0 } }; uint8 center_point_l[2] = { 0 }; uint16 l_data_statics;//统计左边 //定义八个邻域 static int8 seeds_l[8][2] = {{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1},}; //{-1,-1} {0,-1} {+1,-1} //{-1, 0} {+1, 0} //{-1,+1} {0,+1} {+1,+1} //顺时针 //右边变量 uint8 search_filds_r[8][2] = { { 0 } }; uint8 center_point_r[2] = { 0 };//中心坐标点 uint8 index_r = 0;//索引下标 uint8 temp_r[8][2] = { { 0 } }; uint16 r_data_statics;//统计右边 //定义八个邻域 static int8 seeds_r[8][2] = { {0,1},{1,1},{1,0}, {1,-1},{0,-1},{-1,-1}, {-1,0},{-1,1}, }; //{-1,-1} {0,-1} {+1,-1}, //{-1, 0} {+1, 0} //{-1,+1} {0,+1} {+1,+1} //这个是逆时针 l_data_statics = *l_stastic;//统计找到了多少个点，方便后续把点全部画出来 r_data_statics = *r_stastic;//统计找到了多少个点，方便后续把点全部画出来 //第一次更新坐标点 将找到的起点值传进来 center_point_l[0] = l_start_x;//x center_point_l[1] = l_start_y;//y center_point_r[0] = r_start_x;//x center_point_r[1] = r_start_y;//y //开启邻域循环 while (break_flag--) { //左边 for (i = 0; i < 8; i++)//传递8F坐标 { search_filds_l[i][0] = center_point_l[0] + seeds_l[i][0];//x search_filds_l[i][1] = center_point_l[1] + seeds_l[i][1];//y } //中心坐标点填充到已经找到的点内 points_l[l_data_statics][0] = center_point_l[0];//x points_l[l_data_statics][1] = center_point_l[1];//y l_data_statics++;//索引加一 //右边 for (i = 0; i < 8; i++)//传递8F坐标 { search_filds_r[i][0] = center_point_r[0] + seeds_r[i][0];//x search_filds_r[i][1] = center_point_r[1] + seeds_r[i][1];//y } //中心坐标点填充到已经找到的点内 points_r[r_data_statics][0] = center_point_r[0];//x points_r[r_data_statics][1] = center_point_r[1];//y index_l = 0;//先清零，后使用 for (i = 0; i < 8; i++) { temp_l[i][0] = 0;//先清零，后使用 temp_l[i][1] = 0;//先清零，后使用 } //左边判断 for (i = 0; i < 8; i++) { if (image[search_filds_l[i][1]][search_filds_l[i][0]] == 0 && image[search_filds_l[(i + 1) & 7][1]][search_filds_l[(i + 1) & 7][0]] == 255) { temp_l[index_l][0] = search_filds_l[(i)][0]; temp_l[index_l][1] = search_filds_l[(i)][1]; index_l++; dir_l[l_data_statics - 1] = (i);//记录生长方向 } if (index_l) { //更新坐标点 center_point_l[0] = temp_l[0][0];//x center_point_l[1] = temp_l[0][1];//y for (j = 0; j < index_l; j++) { if (center_point_l[1] > temp_l[j][1]) { center_point_l[0] = temp_l[j][0];//x center_point_l[1] = temp_l[j][1];//y } } } } if ((points_r[r_data_statics][0]== points_r[r_data_statics-1][0]&& points_r[r_data_statics][0] == points_r[r_data_statics - 2][0] && points_r[r_data_statics][1] == points_r[r_data_statics - 1][1] && points_r[r_data_statics][1] == points_r[r_data_statics - 2][1]) ||(points_l[l_data_statics-1][0] == points_l[l_data_statics - 2][0] && points_l[l_data_statics-1][0] == points_l[l_data_statics - 3][0] && points_l[l_data_statics-1][1] == points_l[l_data_statics - 2][1] && points_l[l_data_statics-1][1] == points_l[l_data_statics - 3][1])) { //printf("三次进入同一个点，退出\n"); break; } if (my_abs(points_r[r_data_statics][0] - points_l[l_data_statics - 1][0]) < 2 && my_abs(points_r[r_data_statics][1] - points_l[l_data_statics - 1][1] < 2)) { //printf("\n左右相遇退出\n"); *hightest = (points_r[r_data_statics][1] + points_l[l_data_statics - 1][1]) >> 1;//取出最高点 //printf("\n在y=%d处退出\n",*hightest); break; } if ((points_r[r_data_statics][1] < points_l[l_data_statics - 1][1])) { //printf("\n如果左边比右边高了，左边等待右边\n"); continue;//如果左边比右边高了，左边等待右边 } if (dir_l[l_data_statics - 1] == 7 && (points_r[r_data_statics][1] > points_l[l_data_statics - 1][1]))//左边比右边高且已经向下生长了 { //printf("\n左边开始向下了，等待右边，等待中... \n"); center_point_l[0] = points_l[l_data_statics - 1][0];//x center_point_l[1] = points_l[l_data_statics - 1][1];//y l_data_statics--; } r_data_statics++;//索引加一 index_r = 0;//先清零，后使用 for (i = 0; i < 8; i++) { temp_r[i][0] = 0;//先清零，后使用 temp_r[i][1] = 0;//先清零，后使用 } //右边判断 for (i = 0; i < 8; i++) { if (image[search_filds_r[i][1]][search_filds_r[i][0]] == 0 && image[search_filds_r[(i + 1) & 7][1]][search_filds_r[(i + 1) & 7][0]] == 255) { temp_r[index_r][0] = search_filds_r[(i)][0]; temp_r[index_r][1] = search_filds_r[(i)][1]; index_r++;//索引加一 dir_r[r_data_statics - 1] = (i);//记录生长方向 //printf("dir[%d]:%d\n", r_data_statics - 1, dir_r[r_data_statics - 1]); } if (index_r) { //更新坐标点 center_point_r[0] = temp_r[0][0];//x center_point_r[1] = temp_r[0][1];//y for (j = 0; j < index_r; j++) { if (center_point_r[1] > temp_r[j][1]) { center_point_r[0] = temp_r[j][0];//x center_point_r[1] = temp_r[j][1];//y } } } } } //取出循环次数 *l_stastic = l_data_statics; *r_stastic = r_data_statics; } //------------------------------------------------------------------------------------------------------------------ // @函数功能 从八邻域边界里提取需要的左边线 // @参数说明 total_L ：找到的点的总数 // @函数返回 左边线数组l_border //------------------------------------------------------------------------------------------------------------------ uint16 border_to_edge_l[MT9V03X_H];//存放左边border和edge的映射关系的数组 void get_left(uint16 total_L) { uint8 i = 0; uint16 j = 0; uint8 h = 0; //初始化 for (i = 0;i<MT9V03X_H;i++) { l_border[i] = border_min; } h = MT9V03X_H - 2; //左边 for (j = 0; j < total_L; j++) { //printf("%d\n", j); if (points_l[j][1] == h) { l_border[h] = points_l[j][0]+1; border_to_edge_l[h] = j; } else continue; //每行只取一个点，没到下一行就不记录 h--; if (h == 0) { break;//到最后一行退出 } } } //------------------------------------------------------------------------------------------------------------------ // @函数功能 从八邻域边界里提取需要的右边线 // @参数说明 total_R ：找到的点的总数 // @函数返回 右边线数组r_border //------------------------------------------------------------------------------------------------------------------ uint16 border_to_edge_r[MT9V03X_H];//存放右边border和edge的映射关系的数组 void get_right(uint16 total_R) { uint8 i = 0; uint16 j = 0; uint8 h = 0; for (i = 0; i < MT9V03X_H; i++) { r_border[i] = border_max;//右边线初始化放到最右边，左边线放到最左边，这样八邻域闭合区域外的中线就会在中间，不会干扰得到的数据 } h = MT9V03X_H - 2; //右边 for (j = 0; j < total_R; j++) { if (points_r[j][1] == h) { r_border[h] = points_r[j][0] - 1; border_to_edge_r[h] = j; } else continue;//每行只取一个点，没到下一行就不记录 h--; if (h == 0)break;//到最后一行退出 } } //------------------------------------------------------------------------------------------------------------------ // @函数功能 滤波减少噪声 // @函数返回 经过滤波的图像数组bin_image //------------------------------------------------------------------------------------------------------------------ /* #define NEIGHBORS 8 // 8邻域 // 动态阈值结构体（存储计算参数） typedef struct { uint32_t threshold_max; uint32_t threshold_min; float max_coeff; // 最大阈值系数（默认0.75） float min_coeff; // 最小阈值系数（默认0.35） } DynamicThreshold; // 形态学控制参数 typedef struct { uint8_t erosion_iter; // 腐蚀迭代次数 uint8_t dilation_iter; // 膨胀迭代次数 uint8_t enable_diagonal_weight; // 对角线加权使能 } MorphControl; // 亮度补偿参数 typedef struct { uint16_t avg_brightness; float exposure_factor; uint16_t ref_brightness; // 参考亮度（默认128） } BrightnessComp; // 主处理函数 void morphological_filter(uint8_t bin_image[MT9V03X_H][MT9V03X_W]) { // 初始化控制参数 DynamicThreshold dyn_thresh = {0, 0, 0.75f, 0.35f}; MorphControl morph_ctrl = {1, 1, 1}; // 默认迭代1次，启用对角线加权 BrightnessComp bright_comp = {0, 1.0f, 128}; // 计算全局亮度（下采样加速） for(int i = 0; i < MT9V03X_H; i += 2) { for(int j = 0; j < MT9V03X_W; j += 2) { bright_comp.avg_brightness += bin_image[i][j]; } } bright_comp.avg_brightness /= (MT9V03X_H * MT9V03X_W / 4); bright_comp.exposure_factor = (float)bright_comp.avg_brightness / bright_comp.ref_brightness; // 动态调整阈值系数（根据曝光情况） if (bright_comp.exposure_factor > 1.2f) // 过曝场景 { dyn_thresh.max_coeff = 0.80f; // 降低膨胀阈值(降低 max_coeff（0.6-0.7）抑制白色扩张) dyn_thresh.min_coeff = 0.40f; //(提高 min_coeff（0.4-0.45）减少黑色噪点) morph_ctrl.dilation_iter = 0; // 禁用膨胀 morph_ctrl.erosion_iter = 2; // 增强腐蚀 } else if (bright_comp.exposure_factor < 0.8f) // 欠曝场景 { dyn_thresh.max_coeff = 0.80f; dyn_thresh.min_coeff = 0.45f; // 提高腐蚀阈值 morph_ctrl.erosion_iter = 0; // 禁用腐蚀 morph_ctrl.dilation_iter = 2; // 增强膨胀 } // 计算动态阈值 dyn_thresh.threshold_max = (uint32_t)(255 * NEIGHBORS * dyn_thresh.max_coeff); dyn_thresh.threshold_min = (uint32_t)(255 * NEIGHBORS * dyn_thresh.min_coeff); // 形态学滤波主循环 for (int i = 1; i < MT9V03X_H - 1; i++) { for (int j = 1; j < MT9V03X_W - 1; j++) { uint32_t num = 0; // 加权邻域计算（对角线权重2倍，正交方向1.5倍） if (morph_ctrl.enable_diagonal_weight) { num = bin_image[i-1][j-1]*2 + bin_image[i-1][j]*1.5 + bin_image[i-1][j+1]*2 + bin_image[i][j-1]*1.5 + bin_image[i][j+1]*1.5 + bin_image[i+1][j-1]*2 + bin_image[i+1][j]*1.5 + bin_image[i+1][j+1]*2; }else { // 标准8邻域计算（无加权） for (int di = -1; di <= 1; di++) { for (int dj = -1; dj <= 1; dj++) { if (di == 0 && dj == 0) continue; num += bin_image[i+di][j+dj]; } } } // 可控膨胀（抑制过曝白区） if (num >= dyn_thresh.threshold_max && bin_image[i][j] == 0) { uint8_t iter = morph_ctrl.dilation_iter; while (iter-- > 0) { bin_image[i][j] = 255; } } // 可控腐蚀（填充欠曝黑点） else if (num <= dyn_thresh.threshold_min && bin_image[i][j] == 255) { uint8_t iter = morph_ctrl.erosion_iter; while (iter-- > 0) { bin_image[i][j] = 0; } } } } } */ // 改进建议（根据曝光程度动态调整） /*#define neighbors 8 #define dynamic_threshold_max (uint32)(255 * neighbors * 0.75) // 原255 * 6=1530调整为可变参数 #define dynamic_threshold_min (uint32)(255 * neighbors * 0.35) // 原255 * 3=765调整为可变参数*/ #define threshold_max 255*4//定义膨胀的阈值区间（255*5） #define threshold_min 255*3//定义腐蚀的阈值区间（255*2） void image_filter(uint8(*bin_image)[MT9V03X_W])//形态学滤波，膨胀和腐蚀 { uint16 i, j; uint32 num = 0; for (i = 1; i < MT9V03X_H - 1; i++) { for (j = 1; j < (MT9V03X_W - 1); j++) { //统计八个方向的像素值 num = bin_image[i - 1][j - 1] + bin_image[i - 1][j] + bin_image[i - 1][j + 1] + bin_image[i][j - 1] + bin_image[i][j + 1] + bin_image[i + 1][j - 1] + bin_image[i + 1][j] + bin_image[i + 1][j + 1]; if (num >= threshold_max && bin_image[i][j] == 0) { bin_image[i][j] = 255;//白（膨胀） } if (num <= threshold_min && bin_image[i][j] == 255) { bin_image[i][j] = 0;//黑（腐蚀） } } } } /* 曝光问题调节：若图像过曝（白色区域过多），可减少 neighbors 值（如改用4邻域），从而降低threshold_max，增强腐蚀操作以消除白色噪点。 抗噪需求：若图像欠曝（黑色噪点多），可增加 neighbors 值（如8邻域），提高threshold_min，避免过度腐蚀。 */ //------------------------------------------------------------------------------------------------------------------ // @函数功能 给图像画一个黑框 // @函数返回 带有黑框的图像数组bin_image //------------------------------------------------------------------------------------------------------------------ void image_draw_rectan(uint8(*image)[MT9V03X_W]) { uint8 i = 0; for (i = 0; i < MT9V03X_H; i++) { image[i][0] = 0; image[i][1] = 0; image[i][MT9V03X_W - 1] = 0; image[i][MT9V03X_W - 2] = 0; } for (i = 0; i < MT9V03X_W; i++) { image[0][i] = 0; image[1][i] = 0; //image[image_h-1][i] = 0; } } //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // @函数功能 环岛元素识别处理 // @函数返回 无 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //全局状态变量 IslandState current_state = NORMAL; uint8_t island_type = 0; // 0:未确定 1:左环岛 2:右环岛 uint8 target_h = 0;//存放断裂点行数 uint16 A_edge = 0; uint16 V_edge = 0; uint8 A_point = 0; uint8 P_point = 0; uint8 V_point = 0; //------------------------------------------------------------------------------------------------------------------ // @函数功能 边界连续性判断 // @参数说明 需要寻找的边线 // @函数返回 有断裂返回0，无断裂返回1 //------------------------------------------------------------------------------------------------------------------ uint8 border_continuous(uint8 *border) { for(uint8 i = MT9V03X_H-1;i > 0;i--) { int8 diff = border[i] - border[i - 1]; if(diff < -4 || diff > 4) { target_h = i; return 0;//有断裂 } } return 1;//无断裂 } //------------------------------------------------------------------------------------------------------------------ // @函数功能 寻找A点 // @函数返回 A点 //------------------------------------------------------------------------------------------------------------------ //左圆环时寻找左边界A点 uint8 find_point_A_l(void) { uint16 j = border_to_edge_l[target_h];//映射 int16 search_min = j - search_range;//遍历点的最小编号 int16 search_max = j + search_range;//遍历点的最大编号 //限定查找区间 if(search_min < 3) { search_min = 3; } if(search_max > data_stastics_l - 2) { search_max = data_stastics_l - 2; } //遍历寻找A点 for(j = search_min;j <= search_max;j++) { if(points_l[j+2][0]<points_l[j][0] && points_l[j+2][1]<points_l[j][1] && points_l[j-2][1] < points_l[j][1]) { A_edge = j; return 1;//找到A点 } } return 0;//未找到A点 } //右圆环时寻找右边界A点 uint8 find_point_A_r(void) { uint16 j = border_to_edge_r[target_h];//映射 int16 search_min = j - search_range;//遍历点的最小编号 int16 search_max = j + search_range;//遍历点的最大编号 //限定查找区间 if(search_min < 3) { search_min = 3; } if(search_max > data_stastics_r - 2) { search_max = data_stastics_r - 2; } //遍历寻找A点 for(j = search_min;j <= search_max;j++) { if(points_l[j+2][0]>points_l[j][0] && points_l[j+2][1]<points_l[j][1] && points_l[j-2][1] < points_l[j][1]) { A_edge = j; return 1;//找到A点 } } return 0;//未找到A点 } //------------------------------------------------------------------------------------------------------------------ // @函数功能 寻找P点 // @函数返回 P点 //------------------------------------------------------------------------------------------------------------------ //左圆环时寻找左边界P点 uint8 find_point_P_l(void) { for(uint8 i = MT9V03X_H - 2;i > 1;i++) { if(l_border[i-2] < l_border[i] && l_border[i+2] < l_border[i]) { P_point = i; return 1;//找到P点 } } return 0;//未找到P点 } //右圆环时寻找左边界P点 uint8 find_point_P_r(void) { for(uint8 i = MT9V03X_H - 2;i > 1;i++) { if(l_border[i-2] > l_border[i] && l_border[i+2] > l_border[i]) { P_point = i; return 1;//找到P点 } } return 0;//未找到P点 } //------------------------------------------------------------------------------------------------------------------ // @函数功能 寻找V点 // @函数返回 V点 //------------------------------------------------------------------------------------------------------------------ //左边V点 uint8 find_point_V_l(void) { uint16 j = border_to_edge_l[target_h];//映射 int16 search_min = j - search_range;//遍历点的最小编号 int16 search_max = j + search_range;//遍历点的最大编号 //限定查找区间 if(search_min < 3) { search_min = 3; } if(search_max > data_stastics_l - 2) { search_max = data_stastics_l - 2; } //遍历寻找V点 for(j = search_min;j <= search_max;j++) { if(points_l[j+2][1]<points_l[j][1] && points_l[j-2][1] < points_l[j][1]) { V_edge = j; return 1;//找到V点 } } return 0;//未找到V点 } //右边V点 uint8 find_point_V_r(void) { uint16 j = border_to_edge_r[target_h];//映射 int16 search_min = j - search_range;//遍历点的最小编号 int16 search_max = j + search_range;//遍历点的最大编号 //限定查找区间 if(search_min < 3) { search_min = 3; } if(search_max > data_stastics_r - 2) { search_max = data_stastics_r - 2; } //遍历寻找V点 for(j = search_min;j <= search_max;j++) { if(points_l[j+2][1]<points_l[j][1] && points_l[j-2][1] < points_l[j][1]) { V_edge = j; return 1;//找到V点 } } return 0;//未找到V点 } //------------------------------------------------------------------------------------------------------------------ // @函数功能 补线 // @参数说明 m补线下方点，n补线上方点，border需要补线的边线数组，end_point需要补到的高度 // @函数返回 无 //------------------------------------------------------------------------------------------------------------------ void patching_line(uint8 m,uint8 n,uint8 *border,uint8 end_point) { float k = (float)( (m - n) / (border[n] - border[m]) ); for(uint8 h = m - 1;h > end_point;h--) { border[h] = (uint8)(border[m] + (m - h) / k); } } //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // @函数功能 总环岛识别处理函数 // @函数返回 无 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- void island_handler(void) { switch(current_state) { case NORMAL: //判断初见环岛条件 if(border_continuous(r_border) && !border_continuous(l_border) && find_point_A_l() && find_point_P_l())//判断是否为左环岛 { current_state = SEE_ISLAND; island_type = 1;//左环岛 } if(!border_continuous(r_border) && border_continuous(l_border) && find_point_A_r() && find_point_P_r())//判断是否为右环岛 { current_state = SEE_ISLAND; island_type = 2;//右环岛 } break; case SEE_ISLAND://初见环岛 if(island_type == 1)//左环岛 { //找A，P点 border_continuous(l_border); find_point_A_l(); find_point_P_l(); //补线 A_point = points_l[A_edge][1]; l_border[A_point] = points_l[A_edge][0]; patching_line(A_point,P_point,l_border,P_point); //判断初入环岛条件 if(l_border[MT9V03X_H-1] == border_min && l_border[MT9V03X_H-2] == border_min) { current_state = ENTER_ISLAND; } } if(island_type == 2)//右环岛 { //找A，P点 border_continuous(r_border); find_point_A_r(); find_point_P_r(); //补线 A_point = points_r[A_edge][1]; r_border[A_point] = points_r[A_edge][0]; patching_line(A_point,P_point,r_border,P_point); //判断初入环岛条件 if(r_border[MT9V03X_H-1] == border_max && r_border[MT9V03X_H-2] == border_max) { current_state = ENTER_ISLAND; } } break; case ENTER_ISLAND://初入环岛 if(island_type == 1)//左环岛 { //找P点 find_point_P_l(); //补线 A_point = MT9V03X_H-1; patching_line(A_point,P_point,l_border,P_point); //判断第一次到环岛出口条件 if(!border_continuous(l_border) && border_continuous(r_border) && find_point_V_l()) { current_state = EXIT_ISLAND1; } } if(island_type == 2)//右环岛 { //找P点 find_point_P_r(); //补线 A_point = MT9V03X_H-1; patching_line(A_point,P_point,r_border,P_point); //判断第一次到环岛出口条件 if(border_continuous(l_border) && !border_continuous(r_border) && find_point_V_r()) { current_state = EXIT_ISLAND1; } } break; case EXIT_ISLAND1://第一次到环岛出口 if(island_type == 1)//左环岛 { //找V点 border_continuous(l_border); find_point_V_l(); //补线 V_point = points_l[V_edge][1]; r_border[V_point] = points_l[A_edge][0]; patching_line(119,V_point,r_border,0); //判断即将入环条件 if(!border_continuous(r_border) && find_point_V_r()) { current_state = IN_ISLAND; } } if(island_type == 2)//右环岛 { //找V点 border_continuous(r_border); find_point_V_r(); //补线 V_point = points_r[V_edge][1]; l_border[V_point] = points_r[A_edge][0]; patching_line(119,V_point,l_border,0); //判断即将入环条件 if(!border_continuous(l_border) && find_point_V_l()) { current_state = IN_ISLAND; } } break; case PRE_ENTER://即将入环 if(island_type == 1)//左环岛 { //找V点 border_continuous(r_border); find_point_V_r(); //补线 V_point = points_r[V_edge][1]; r_border[V_point] = points_r[A_edge][0]; patching_line(119,V_point,r_border,0); //判断完全入环条件 if(border_continuous(r_border) && border_continuous(l_border)) { current_state = IN_ISLAND; } } if(island_type == 2)//右环岛 { //找V点 border_continuous(l_border); find_point_V_l(); //补线 V_point = points_l[V_edge][1]; l_border[V_point] = points_l[A_edge][0]; patching_line(119,V_point,l_border,0); //判断完全入环条件 if(border_continuous(r_border) && border_continuous(l_border)) { current_state = IN_ISLAND; } } break; case IN_ISLAND://完全入环 if(island_type == 1)//左环岛 { //条件补线 if(!border_continuous(r_border) && border_continuous(l_border)) { r_border[0] = border_min; patching_line(target_h,0,r_border,0); } //判断第二次到环岛出口条件 if( l_border[MT9V03X_H-1]>border_min && l_border[MT9V03X_H-2]>border_min && r_border[MT9V03X_H-1]==border_max && r_border[MT9V03X_H-1]==border_max) { current_state = EXIT_ISLAND2; } } if(island_type == 2)//右环岛 { //条件补线 if(!border_continuous(l_border) && border_continuous(r_border)) { l_border[0] = border_max; patching_line(target_h,0,l_border,0); } //判断第二次到环岛出口条件 if( l_border[MT9V03X_H-1]==border_min && l_border[MT9V03X_H-2]==border_min && r_border[MT9V03X_H-1]<border_max && r_border[MT9V03X_H-1]<border_max) { current_state = EXIT_ISLAND2; } } break; case EXIT_ISLAND2://第二次到环岛出口 if(island_type == 1)//左环岛 { //判断最终出环条件 if(!border_continuous(l_border) && border_continuous(r_border)) { current_state = FINAL_EXIT; } } if(island_type == 2)//右环岛 { //判断最终出环条件 if(border_continuous(l_border) && !border_continuous(r_border)) { current_state = FINAL_EXIT; } } break; case FINAL_EXIT://最终出环 if(island_type == 1)//左环岛 { //补线 border_continuous(l_border); patching_line(119,target_h,l_border,target_h); //结束条件 if(border_continuous(l_border) && border_continuous(r_border)) { current_state = NORMAL; island_type = 0; } } if(island_type == 2)//右环岛 { //补线 border_continuous(r_border); patching_line(119,target_h,r_border,target_h); //结束条件 if(border_continuous(l_border) && border_continuous(r_border)) { current_state = NORMAL; island_type = 0; } } break; } } //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // @函数功能 获取车身偏差 // @函数返回 车身偏差error //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- int16 error = 1000; //误差100 int16 error_last = 0; //上次误差 void car_error(void) { uint8 i = 0; int32 num = 0; //int16 num = 0 for(i = 1;i < MT9V03X_H;i++) { num += (center_line[i] - (MT9V03X_W / 2)); } error_last = error; error = num; } //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- // @函数功能 最终处理函数 // @函数返回 无 //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- uint8 change = 0; uint8 change_last = 0; void image_process(void) { uint16 i; uint8 hightest = 0;//定义一个最高行，tip：这里的最高指的是y值的最小 Get_image(mt9v03x_image);//获得一副灰度图像 turn_to_bin();//大津法二值化。 //提取赛道边界 image_filter(bin_image);//滤波减少噪声 //morphological_filter(bin_image); //(自己添加部分) image_draw_rectan(bin_image);//给图像画黑框为八领域做准备 //清零 data_stastics_l = 0; data_stastics_r = 0; if (get_start_point(MT9V03X_H - 2))//找到起点了，再执行八领域，没找到就一直找 { navigation_flag = 0; //判断直角弯 uint8 m = 0,n = 0, j = 0; for(j = 1;j < MT9V03X_W;j++) { if(bin_image[60][j] == 255) { break; } if(bin_image[62][j] == 255) { break; } } if(j == MT9V03X_W) { for(j = 119;j > 55;j--) { if(bin_image[j][5] == 255 && bin_image[j][7] == 255) { m = 1; } if(bin_image[j][115] == 255 && bin_image[j][113] == 255) { n = 1; } } } if(m == 1 && n == 0) { navigation_flag = 1; } if(m == 0 && n == 1) { navigation_flag = 2; } //八领域处理 search_l_r((uint16)USE_num, bin_image, &data_stastics_l, &data_stastics_r, start_point_l[0], start_point_l[1], start_point_r[0], start_point_r[1], &hightest); // 从爬取的边界线内提取边线 ， 这个才是最终有用的边线 get_left(data_stastics_l); get_right(data_stastics_r); //处理函数 island_handler();//环岛元素识别处理 } else { navigation_flag = 3; } for (i = hightest; i < MT9V03X_H-1; i++) { center_line[i] = (l_border[i] + r_border[i]) >> 1;//求中线 } if(bin_image[118][8] == 0 && bin_image[118][40] == 255 && bin_image[118][100] == 255 && bin_image[118][148] == 255 && bin_image[118][180] == 0 && bin_image[118][94] == 255) { change_last = change; change = 1; } else { change = 0; } if(change == 1 && change_last == 0) { stop++; } //显示图像 后期关掉 ips114_displayimage03x(bin_image[0], MT9V03X_W, MT9V03X_H); for (i = hightest; i < MT9V03X_H-1; i++) { ips114_draw_point(center_line[i], i, uesr_RED);//显示起点 显示中线 ips114_draw_point(l_border[i], i, uesr_GREEN);//显示起点 显示左边线 ips114_draw_point(r_border[i], i, uesr_BLUE);//显示起点 显示右边线 } ips114_show_int(189,0,stop,5); ips114_show_int(189,15,change,5); ips114_show_int(189,30,change_last,5); //获取车身偏差error car_error(); if(navigation_flag == 1) { error = -2000; } if(navigation_flag == 2) { error = 2000; } } 根据以上代码添加一份优化曝光问题的直方图均衡化、伽马校正或Retinex算法的代码方案
最新发布
06-04
我们之前讨论了膨胀和腐蚀在曝光调整中的表现，现在用户希望在实际代码中实现曝光优化，具体提到直方图均衡化、伽马校正和Retinex算法。用户提供了四个参考文献，其中引用[1][2][4]都涉及Retinex算法，引用[3]提到多...
Python编程数据分析篇之Seaborn绘图
weixin_49069669的博客
08-05 1650
Python编程数据分析篇之Seaborn绘图 文章目录Python编程数据分析篇之Seaborn绘图关系型绘图seaborn.relplot()基本使用分类绘图分类散点图分类分布图分类统计图分布绘图单变量分布二变量分布pairplot线性回归绘图FacetGrid结构图Axes绘图FacetGrid的使用设置图形的尺寸设置图例设置标题设置坐标轴Seaborn样式风格设置风格设置函数sns.axes.stylesns.set_style()sns.set调色盘设置定性调色盘连续的颜色盘离散的色盘官方文档2.
Bright Data — Data Collector-crx插件
04-03
语言:English 使用'click＆collect'技术在5分钟以下的5分钟内按需获取数据 bright data - Data Collector浏览器扩展数据收集器扩展是直接从Chrome浏览器收集Web数据的最简单方法之一。明亮的数据扩展使您可以为任何网站定义自定义数据收集器。一旦您的爬网程序创建，您就可以通过我们广泛的IPS网络发送无限数量的数据集请求，并自动获得对所需的数据集的访问。请求通过明亮数据对等对等网络上的节点进行路由，该节点由真实用户住宅IP组成。通过这些类型的IPS发送请求时，几乎无法被封锁或隐藏起来。我们的解决方案由财富500强公司使用，因为它是目前具有近乎完美成功率的最强大的工具。为了开始使用明亮的数据扩展，您需要拥有现有的明亮数据帐户。您可以在此处注册明亮的数据：https：//brightdata.com要了解有关此产品的更多信息，请访问我们的数据收集器产品页面。https://brightdata.com/products/data-collector.我们如何使用您的信息？我们使用您的信息来为您提供服务并遵守我们的法律要求和内部准则。这意味着
Bright Data-crx插件
04-03
语言:English 更改位置以进行手动数据收集 Bright Data业务代理网络是从世界任何地方匿名浏览的最强大方法。 Bright Data的扩展程序是将Bright Data直接集成到您的Chrome浏览器中的最简单方法。 Bright Data扩展程序使您可以直接从Chrome浏览器通过数百万个住宅IP发送并发URL请求。 您的请求将通过Bright Data P2P网络上的节点进行路由，这些节点是真正的住宅IP。 通过真实IP发送请求时，几乎不可能被阻塞或隐瞒。 我们的解决方案为财富500强公司所采用，因为它是目前可用的最强大的工具，成功率近乎完美。 要使用Bright Data扩展名，您必须有一个现有的Bright Data帐户。 您可以在此处注册Bright Data：https://brightdata.com Bright Data扩展包括以下功能：-支持数据中心，静态住宅，住宅和移动IP浏览-从任何国家/地区浏览-自定义DNS配置以最大程度地考虑或速度-设置IP随机轮播-调整用户代理-自定义会话长度配置-从特定城市或运营商浏览要了解有关我们的其他平台以利用Brig
全球数据爬取的解决方案-国外数据爬取(亮数据)
程序员蒋老湿的博客
04-27 3121
是一家在以色列的互联网公司，他们的主要产品是互联网数据服务，不少世界500强公司和欧美名校都是他们的客户，其实就是数据采集（爬虫），但是做到了很牛的程度。能提供各种已有收集到的互联网数据集诸如ShoppeeGoogleTikTok等电商、社交媒体、搜索引擎结果。还有各种的基础设施服务，用来给有定制开发能力公司提供获取开放数据解决方案。
搭建使用Brightdata（Luminti）
bmh18888的博客
08-16 1143
首选我们需要去腾讯云/阿里云官方去购买一台服务器，这里推荐经济实惠的轻量化服务器，推荐购买新加坡或者香港用来转寄，优点是不会被墙速度也是最快的，当然价格也很实惠。如果需要更多ip,可以去创建更多的端口。保存完我们就得到一条美国的Ip,接下来我们去配合adspower使用这条ip.后台的白名单才能链接成功，首选在自己的本地电脑通过百度搜索“我的ip”搭建的方式有很多种，今天就以腾讯云winds系统搭建的方式为例。的使用很迷茫，今天就出一个详细的搭建使用教程。因为我选择的通道在后台没有设置国家所以要去设置。
【实操指南】用Bright Data快速采集海量数据，打造AI观影推荐小助手！
热门推荐
陈老老老板的博客
04-29 1万+
我们利用亮数据提供的免费数据集以及相关工具，就完成了从数据获取、到AI 模型训练、再到最终创建观影小助手的全过程。
bright data，一个超赞的爬虫利器！
codingpy的博客
12-27 1489
你好，我是坚持分享干货的 EarlGrey，翻译出版过《Python编程无师自通》、《Python并行计算手册》等技术书籍。如果我的分享对你有帮助，请关注我，一起向上进击。创作不易，希望大家给一点鼓励，把公众号设置为“星标”，给文章点个“赞”和“在看”，谢谢大家啦~前言你是否曾为获取重要数据而感到困扰？是否因为数据封锁而无法获取所需信息？是否因为数据格式混乱而头疼？现在，所有这些问题都可以迎刃而解...
Bright Data(Luminati)怎么用呢？
FunCrown的博客
10-20 1056
很多人都知道Luminati是目前最好用的IP代理，但是很多人不知道怎么去注册使用，下面我就来简单讲解一下Luminati的注册使用制度和​常见的几种使用方法。 Luminati作为家庭IP的领头羊，其实名注册IP以及实名注册使用机制是保障用户和客户法律权益的必备项。如果没有实名制，那将会有很多不法份子利用这些IP去做一些违法乱纪的事情。这也是为什么Luminati备受世界500强​信赖的​原因，一切都合法守规。因此在注册Luminati，试用期结束后必须要做KYC方可使用，这既是为了保护客户，也是为了IP
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值