图像的四叉树广度优先存储

typedef struct quardresult_t
{
    int seq;
    char val;
}QuadResult;

#include <stdlib.h>
#include <iostream>
#include <vector>
#include<malloc.h>  
#include<stdio.h>
#include <string.h>
#include <queue>
#include <math.h>
using namespace std;
/* 象限 */
typedef enum
{
    TOP_RIGHT = 0,
    TOP_LEFT,
    BOTTOM_LEFT,
    BOTTOM_RIGHT
}BLOCKNAME;

typedef  unsigned char IMGTYPE;
class HeapNode
{
public:
    HeapNode(IMGTYPE* image,int imageSize):_image(image),_imageSize(imageSize)
    {
        //cout<<"constructor"<<endl;
    }
    /*~HeapNode()
    {
        if(_image!=NULL)
        {
            delete _image;
            _image=NULL;
        }
    }*/
    IMGTYPE* _image;
    int _imageSize;
    bool isLeaf()
    {
        if(_imageSize==1) return true;
        char pivot=_image[0];
        bool flag=true;
        for(int i=0;i<(_imageSize*_imageSize);i++)
        {    
            if((_image[i]-pivot)!=0)
            {
                flag=false;
            }
        }
        if(flag) return true;
        return false;
    }        
};

HeapNode* extractSubImg(HeapNode N,BLOCKNAME pos)
{
    IMGTYPE* nimage=new unsigned char[(N._imageSize)*(N._imageSize)/4];    
    int m=N._imageSize;
    int n=N._imageSize;

    int arow1[]={0,    0,     m/2,  m/2};
    int arow2[]={m/2-1,m/2-1 ,m-1,  m-1};
    int acol1[]={n/2,  0,     0,    n/2};
    int acol2[]={n-1,  n/2-1, n/2-1,n-1};

    int row1=arow1[pos];
    int row2=arow2[pos];
    int col1=acol1[pos];
    int col2=acol2[pos];


    int k=0;
    for(int i=row1;i<=row2;i++)
    {
        for(int j=col1;j<=col2;j++)
        {
            nimage[k++]=N._image[n*i+j];
        }
    }
    return new HeapNode(reinterpret_cast<IMGTYPE*>(nimage),m/2);
    
}





int checkAvailability(IMGTYPE* image, int imageSize)//判断入参的合法性
{
    if(image==NULL) return -1;
    int j=0;
    while(pow(float(2),float(j))<float(imageSize))
    {        
        j++;
    }
    if(imageSize!=pow(float(2),float(j))) return -1;    
    char pivot=image[0];
    bool flag=true;
    for(int i=0;i<(imageSize*imageSize);i++)
    {
        if(image[i]=='\0')
        {            
            return -1;            
        }
        if((image[i]-pivot)!=0)
        {
            flag=false;
        }
    }
    if(flag) return 1;
    return 0;    
}

int gcount=0;
int agcount=-1;

int CreateQTreeForGrayScaleImage(IMGTYPE* image, int imageSize, QuadResult *aRes,int t)
{    
    int flag=checkAvailability(image,imageSize);//对于本题的参数处理
    if(-1==flag) return -1; //  输入参数有误

    queue <HeapNode*> Q;
    
    Q.push(new HeapNode(image,imageSize)); //初始化队列

    while(!Q.empty())
    {
            HeapNode* pN=Q.front();//出队
            Q.pop();
            if(pN==NULL)
            {
                agcount++;
            }
            else if(pN->isLeaf()) // 叶子节点
            {    
                agcount++;
                aRes[gcount].seq=agcount;// 满四叉树的内部和外部节点的序号
                aRes[gcount].val=pN->_image[0];    
                gcount++;
                Q.push(NULL);// 叶子节点也要有孩子
                Q.push(NULL);
                Q.push(NULL);
                Q.push(NULL);
            }
            else  //非叶子节点
            {    
                agcount++;
                HeapNode* nn=extractSubImg(*pN,BLOCKNAME::TOP_RIGHT);
                Q.push(nn);
                nn=extractSubImg(*pN,BLOCKNAME::TOP_LEFT);
                Q.push(nn);
                nn=extractSubImg(*pN,BLOCKNAME::BOTTOM_LEFT);
                Q.push(nn);
                nn=extractSubImg(*pN,BLOCKNAME::BOTTOM_RIGHT);
                Q.push(nn);    
            }
            if((pN!=NULL)&&agcount!=0) delete pN->_image;
    }//while
    return 0;
}


/*
输入： asc_art － 是原始的ascii art图片，二维数组
           chart_size － asc_art的大小，chart_size * chart_size
处理:    将ascii_art映射成四叉树，叶子节点值即该区域的ascii值
输出：result －QuadResult类型结构体数组，用于存放四叉树处理结果，其中成员seq是叶子节点的编号
                  （在满四叉树中的位置），成员val 为叶子节点值。result数组要求从下标0开始按seq的升序排序。
          result_size  - 输出对应的四叉树的总叶子节点数
返回: 0 成功 1 失败
*/

char* to1D(unsigned int chart_size,char** ascii_art)// 将2维矩阵变成1维
{
    char* img=new char[chart_size*chart_size];
    img[chart_size*chart_size]='\0';
    for(unsigned int i=0;i<chart_size;i++)
    {
        for(unsigned int j=0;j<chart_size;j++)
        {
           img[i*chart_size+j]=ascii_art[i][j];
        }
    }
    return img;
}


int GetQuadResult(char **ascii_art,unsigned int chart_size, QuadResult **result, unsigned int *result_size)
{
    
    QuadResult* pRes=new QuadResult[chart_size*chart_size+1];
    
    char* img=to1D(chart_size,ascii_art);
    
    CreateQTreeForGrayScaleImage(reinterpret_cast<IMGTYPE*>(img), chart_size,pRes,0);
    
    QuadResult** temp=result;
    *temp=pRes;
    *result_size=gcount;
    

     /*cout<<endl;
    for (int i=0;i<gcount;i++)
    {
        cout<<"seq:"<<pRes[i].seq<<endl;
        cout<<"val:"<<pRes[i].val<<endl;
    }*/
    return 0;
}