Find Original & JiFen

#include <QtCore/QCoreApplication>

#include <cmath>

typedef double DataType;

typedef long TimeType;

typedef struct

{

  DataType UA;

  DataType IA;

  DataType UB;

  DataType IB;

  DataType UC;

  DataType IC;

  TimeType T;

} Node;

typedef struct

{

    double HZ;

    double Voltage;

} ConfigType;

#define MAX_LEN 360

Node n[MAX_LEN];

void Init(Node * pN, int sz)

{

    for(int i = 0; i < sz; ++i)

    {

        pN[i].UA = ::sin(1.0+i);

        pN[i].IA = ::sin(2.0 + i);

        pN[i].UB = ::sin(3.0 + i);

        pN[i].IB = ::sin(4.0 + i);

        pN[i].UC = ::sin(5.0 + i);

        pN[i].IC = ::sin(6.0 + i);

        pN[i].T  = 1000 + i;

    }

}

#define MIN_DOUBLE_ZERO     0.000000001

bool IsOrignalUA(Node * pN, int i)

{

    if((pN[i].UA > -MIN_DOUBLE_ZERO && pN[i].UA <= MIN_DOUBLE_ZERO) && pN[i+1].UA > 0)

    {

        return true;

    }

    if(pN[i].UA <0 && pN[i+1].UA > 0)

    {

        return true;

    }

    return false;

}

bool IsValidWidth(int iLastUA, int iCurUA, Node * pN, double width)

{

    if(pN[iCurUA].T - pN[iLastUA].T <= width)

    {

        return false;

    }

    return true;

}

#define CIRCLE_TIME           8

#define tolence     0.20

int FindNextSpot(int iStart, Node *pN, int len)

{

    for(int i = iStart; i < len; ++i)

    {

        if(IsOrignalUA(pN, i))

        {

            return i;

        }

    }

    return -1;

}

int Run(Node * pN, int len)

{

    int cnt = 0;

    int i = 0;

    while(i < len)

    {

        int cur = FindNextSpot(i, pN, len);

        if(cur == -1) // no spot -> end

        {

            break;

        }

        int next = cur;

        do

        {

            next = FindNextSpot(next + 1, pN, len );

            if(next == -1)

            {

                break;

            }

        }while(false == IsValidWidth(cur, next, pN, CIRCLE_TIME*tolence));

        if(next == -1) // can not find the next, -> end

        {

            break;

        }

        cnt++;

        printf("id %d, cur %d, next %d, T %d, (%f, %f) \n", cnt, cur, next, pN[next].T - pN[cur].T, pN[cur].UA, pN[cur+1].UA);

        i = next;

    }

    printf("cnt %d\n", cnt);

    return 0;

}

#include <vector>

#include <utility>

std::vector<std::pair<int, int> > UAIndex;

#define TOP_HIGH    1

#define Ratio_Top_High 0.20

int NormalRun(Node * pN, int sz)

{

    double MinUA = 0;

    double MaxUA = 0;

    for(int i = 0; i < sz; ++i)

    {

        if(MinUA > pN[i].UA)

        {

            MinUA = pN[i].UA;

        }

        if(MaxUA < pN[i].UA)

        {

            MaxUA = pN[i].UA;

        }

        if(IsOrignalUA(pN, i))

        {

            unsigned int sz = UAIndex.size();

            if(sz == 0)

            {

                UAIndex.push_back(std::make_pair(i,0));

            }

            else

            {

                if(MaxUA - MinUA > TOP_HIGH * Ratio_Top_High)

                {

                    UAIndex[sz-1].second = i;

                    UAIndex.push_back(std::make_pair(i,0));

                }

            }

        }

    }

    if(UAIndex[UAIndex.size()-1].second == 0)

    {

       UAIndex.pop_back();

    }

    for(unsigned int i = 0; i < UAIndex.size(); ++i)

    {

        printf(" first %d second %d T %d (%f, %f) \n", UAIndex[i].first, UAIndex[i].second

               , pN[UAIndex[i].second].T - pN[UAIndex[i].first].T

               , pN[UAIndex[i].first].UA, pN[UAIndex[i].first+1].UA);

    }

    printf("Size of Zero Vector %d max %f, min %f\n", UAIndex.size(), MaxUA, MinUA);

    return 0;

}

void Angle()

{

    Init(n, MAX_LEN);

    Run(n, MAX_LEN);

    NormalRun(n, MAX_LEN);

    // Other

}

int main(int argc, char *argv[])

{

    QCoreApplication a(argc, argv);

    Angle();

    return a.exec();

}