2楼: Originally posted by Mr__Right at 2017-08-18 11:00:47
首先你要识数，那是一共9个，相邻的是8个。

然后，找到中心位置指标，



然后,根据指标增减的2^3=8种排列组合，全部赋值为0

3楼: Originally posted by imyourkobe at 2017-08-18 21:50:25
很容易的。用二维数组或容器来存储数据，写一个简单的算法判断六个连续的数据为1的个数累加。满足则修改。不满足继续判断下一组。

2楼: Originally posted by Mr__Right at 2017-08-18 11:00:47
首先你要识数，那是一共9个，相邻的是8个。

然后，找到中心位置指标，



然后,根据指标增减的2^3=8种排列组合，全部赋值为0

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <math.h>
#include <iostream>
#include <fstream>
#include <string>  
#include <iostream>  
#include <vector>
using namespace std;

struct Location {
        double fai;                       
        int *grain_number;
}num[1000000];

#define seed 40000 //粒子个数
bool main(){
        int grain_num[seed], correction_num[seed], grain_size[seed],
                divided_grain_count[seed], div_area,
                grain_count, grain_sum, divided_grain_sum, cut_off,
                grain_size_distribution[seed], max_grain_size, div_distribution;

        double boundary_line, boundary_line1, boundary_line2;
        int count, count2, meshx, meshy, meshX, meshY;
        char        fname[100];
        FILE        *datin0;
        //        初期化
        grain_count = 0, count2 = 0, grain_sum = 0, divided_grain_sum = 0, count = 0;
        max_grain_size = 0;
        for (int i = 0; i < seed; i++){
                grain_num[i] = i;
                correction_num[i] = i;
                grain_size[i] = -1;
                divided_grain_count[i] = -1;
                grain_size_distribution[i] = 0;
        }
        // 指定文件夹和保存
        char*  file_name("C:\\testp.loc");
        ofstream fout1("save1.xls");
        ofstream fout2("save2.xls");
        ofstream fout3("save3.xls");
        ofstream fout4("save4.xls");
        ofstream fout5("save5.xls");

        boundary_line = 0.4;        // 判断数值大小
        cut_off = 0;        // cut_off以下的不计算

        //        边界设定
        meshx = 1200;
        meshy = 150;
        meshX = meshx + 2; meshY = meshy + 2;

        // 打开文件夹
        std::ifstream fin;
        fin.open(file_name, std::ios::in);
        // 文件夹确认
        if (!fin){
                std::cout << " file open error! " << "\n";
                return false;
        }
        if (!fout1){
                cerr << "open error!" << endl;
                exit(1);
        }
        if (!fout2){
                cerr << "open error!" << endl;
                exit(1);
        }
        if (!fout3){
                cerr << "open error!" << endl;
                exit(1);
        }
        if (!fout4){
                cerr << "open error!" << endl;
                exit(1);
        }
        if (!fout5){
                cerr << "open error!" << endl;
                exit(1);
        }
        //读入粒子
        for (int i = 0; i<meshY; i++){
                for (int j = 0; j<meshX; j++){
                        if (i <= 0 || i >= meshY - 1 || j <= 0 || j >= meshX - 1){
                                num[count].fai = 0;
                                count++;
                                continue;

                        }
                        else{
                                fin >> num[count].fai;

                                count++;


                        }
                }
        }

        //        判断数值大小大于0.4等于1小于0.4等于0
                count = 0;
        for (int i = 0; i<meshY; i++){
                for (int j = 0; j<meshX; j++){
                        if (num[count].fai < boundary_line)
                        {
                                num[count].fai = 0;
                        }
                        else{
                                num[count].fai = 1;
                        }
                        fout1 << num[count].fai << " ";
                        count++;
                }
                fout1 << endl;
        }
        // grain_number
        count = 0;
        for (int i = 0; i<meshY; i++){
                for (int j = 0; j<meshX; j++){
                        if (i == 0 || i == meshY - 1 || j == 0 || j == meshX - 1){
                                num[count].grain_number = &grain_num[0];
                                count++;
                                continue;
                        }
                        else{
                                if (j == 1){
                                        grain_count++;
                                }
                                num[count].grain_number = &grain_num[grain_count];

                                if (i > 1 && num[count - meshX].fai == 1. && num[count].fai == 1.){
                                        grain_num[grain_count] = *num[count - meshX].grain_number;
                                }
                                if (num[count].fai == 0){
                                        num[count].grain_number = &grain_num[0];
                                        if (num[count + 1].fai == 1 && j>2 && j<meshX - 2){
                                                grain_count++;
                                        }
                                }
                                count++;
                        }
                        fout2 << num[count].grain_number << " "; //号码赋值
                        //cout << grain_count << " ";
                }
                fout2 << endl;
        }
        count = 0;
        for (int i = 0; i<10; i++){
                for (int j = 0; j<meshX; j++){

                        if (i == 0 || i == meshY - 1 || j == 0 || j == meshX - 1){
                                count++;
                                continue;
                        }
                        else{
                                if (num[count - meshX].fai == 1 && num[count].fai == 1){            //上下值为1 有phase
                                        if (*num[count].grain_number < *num[count - meshX].grain_number){    //如果下面番号小于上面的番号
                                                correction_num[*num[count - meshX].grain_number] = *num[count].grain_number;//把*num[count].grain_number的值赋给correction_num[*num[count - meshX].grain_number]
                                        }
                                        else{
                                                correction_num[*num[count].grain_number] = *num[count - meshX].grain_number;//否则*num[count - meshX].grain_number赋给correction_num[*num[count].grain_number]
                                        }
                                }
                                count++;
                        }
                        fout3 << *num[count].grain_number << " ";
                }
                fout3 << endl;
        }
        // 计算grain_size粒径大小
        count = 0;
        for (int i = 0; i<meshY; i++){
                for (int j = 0; j<meshX; j++){
                        if (i == 0 || i == meshY - 1 || j == 0 || j == meshX - 1){
                                count++;
                                continue;
                        }
                        else{
                                grain_size[*num[count].grain_number] += 1;
                                count++;
                        }
                        fout4 << grain_size[*num[count].grain_number] << " ";
                }
                fout4 << endl;
        }
        //这里插入粒径长度小于9的小于等于0 大于9的值不变



        // grain_sum 计算个数
        count = 1;
        while (count<seed){
                if (grain_size[count] > cut_off){
                        grain_sum++;

                        if (grain_size[count] > max_grain_size){
                                max_grain_size = grain_size[count];
                                std::cout << "max = " << max_grain_size << "\n";
                        }
                }
                count++;
        }
}