kev/Drawer/GVision/MLMicroStructure/GMLDimsIter.cpp

#include "GMLDimsIter.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stdint.h"

struct GML_FLAG
{
	bool valid;
	int	 flag;		//小网格四角有标识个数  0 无效区 1断层 2边界 
	float w[4];		/*网格四顶点属性标识 逆时针  1---0*/
	GML_FLAG()
	{
		valid = false;
		flag = 0;
		memset(w, 0, sizeof(float) * 4);
	}
};


GMLDimsIter::GMLDimsIter()
{
	m_nm = 0;
	m_pdu = nullptr;
	m_pFlag = nullptr;
}


GMLDimsIter::~GMLDimsIter()
{
}

void GMLDimsIter::setGridInfo(double* xyRange, int* nxny, double* inc, double*zRange)
{
	clearMemory();
	memcpy(m_xyRange, xyRange, 4 * sizeof(double));
	memcpy(m_nxny, nxny, 2 * sizeof(int));
	memcpy(m_inc, inc, 2 * sizeof(double));
	memcpy(m_zRange, zRange, 2 * sizeof(double));

	CreateGrid();
}

void GMLDimsIter::setZData(long num, float* data)
{
	memcpy(m_pdu, data, num * sizeof(float));
}

void GMLDimsIter::clearMemory()
{
	if (m_pdu)
	{
		delete[] m_pdu;
		m_pdu = nullptr;
	}

	if (m_pFlag)
	{
		delete[] m_pFlag;
		m_pFlag = nullptr;
	}
	m_nm = 0;
}

double* GMLDimsIter::getXYRange()
{
	return m_xyRange;
}

int* GMLDimsIter::getXnYn()
{
	return m_nxny;
}

long GMLDimsIter::getXnYnTotal()
{
	return m_nm;
}

double GMLDimsIter::getXmin()			//获得最小X
{
	return m_xyRange[0];
}
double GMLDimsIter::getXmax()			//获得最大X
{
	return m_xyRange[1];
}
double GMLDimsIter::getYmin()			//获得最小Y
{
	return m_xyRange[2];
}
double GMLDimsIter::getYmax()			//获得最大Y
{
	return m_xyRange[3];
}

int  GMLDimsIter::getGridX()			//X方向网格数
{
	return m_nxny[0];
}

int  GMLDimsIter::getGridY()			//Y方向网格数
{
	return m_nxny[1];
}

double GMLDimsIter::getDeltX()
{
	return m_inc[0];
}

double GMLDimsIter::getDeltY()
{
	return m_inc[1];
}
double GMLDimsIter::getX(int i)
{
	return getXmin() + i * getDeltX();
}

double GMLDimsIter::getY(int j)
{
	return getYmin() + j * getDeltY();
}

int GMLDimsIter::getIndexFrX(double x)
{
	if (x < getXmin())
		return 0;

	if (x > getXmax())
		return m_nxny[0];

	int idx = (int)((x - getXmin()) / m_inc[0]);
	if (idx < 0) idx = 0;
	if (idx > m_nxny[0]) idx = m_nxny[0];

	return idx;
}

int GMLDimsIter::getIndexFrY(double y)
{
	if (y < getYmin())
		return 0;

	if (y > getYmax())
		return m_nxny[1];

	int idx = (int)((y - getYmin()) / m_inc[1]);
	if (idx < 0) idx = 0;
	if (idx > m_nxny[1]) idx = m_nxny[1];
	return idx;
}

float GMLDimsIter::getZValue(int ij)
{
	if (ij < 0 || ij >= m_nm)
		return 1e30;

	return m_pdu[ij];
}

float GMLDimsIter::getZValue(int i, int j)
{
	if (i<0 || i>m_nxny[0] - 1)
		return 1e30;

	if (j<0 || j>m_nxny[1] - 1)
		return 1e30;

	return m_pdu[i + j * m_nxny[0]];
}

float GMLDimsIter::getZValue(double x0, double y0)
{
	double xy[2];
	int ip[2];
	xy[0] = x0;
	xy[1] = y0;

	xy[0] = (xy[0] - m_xyRange[0]) / m_inc[0];
	xy[1] = (xy[1] - m_xyRange[2]) / m_inc[1];
	ip[0] = (int)(xy[0]);
	ip[1] = (int)(xy[1]);

	if (ip[0]<-1 || ip[0]>m_nxny[0])
		return 1e30;

	if (ip[1]<-1 || ip[1]>m_nxny[1])
		return 1e30;

	if (ip[0] < 0)	ip[0] = 0;
	if (ip[0] > m_nxny[0] - 2) ip[0] = m_nxny[0] - 2;
	if (ip[1] < 0)	ip[1] = 0;
	if (ip[1] > m_nxny[1] - 2) ip[1] = m_nxny[1] - 2;

	xy[0] -= ip[0];
	xy[1] -= ip[1];

	return GetZValue(xy, ip, m_n - 1);
}

int GMLDimsIter::readDfgBinary(const char* file)
{
	FILE *fr;
	double dd, flen;
	unsigned long ll;
	unsigned short ss;
	int numx, numy;
	double xmin, ymin, zmin, zmax, dx, dy;
	fr = fopen(file, "rb");
	if (fr == NULL)	return 0;

	char m_stat = 8;
	char str[3] = { 0 };
	char str2[6] = { 0 };
	fread(str, 1, 3, fr);
	fread((char *)(&numx), sizeof(int), 1, fr);
	fread(str, 1, 3, fr);
	fread((char *)(&numy), sizeof(int), 1, fr);
	fread(str2, 1, 6, fr);
	fread((char *)(&xmin), sizeof(double), 1, fr);
	fread(str2, 1, 6, fr);
	fread((char *)(&ymin), sizeof(double), 1, fr);
	fread(str2, 1, 6, fr);
	fread((char *)(&dx), sizeof(double), 1, fr);
	fread(str2, 1, 6, fr);
	fread((char *)(&dy), sizeof(double), 1, fr);
	fread(str2, 1, 6, fr);
	fread((char *)(&zmin), sizeof(double), 1, fr);
	fread(str2, 1, 6, fr);
	fread((char *)(&zmax), sizeof(double), 1, fr);

	fread(&m_stat, sizeof(char), 1, fr);

	m_nxny[0] = numx;
	m_nxny[1] = numy;
	m_xyRange[0] = xmin;
	m_xyRange[2] = ymin;
	m_inc[0] = dx;
	m_inc[1] = dy;
	m_zRange[0] = zmin;
	m_zRange[1] = zmax;
	m_xyRange[1] = m_xyRange[0] + m_inc[0] * m_nxny[0];
	m_xyRange[3] = m_xyRange[2] + m_inc[1] * m_nxny[1];
	CreateGrid();
	flen = numx * numy;
	for (long i = 0; i < numx*numy; ++i)
	{
		fread((char *)(&dd), 8, 1, fr);
		m_pdu[i] = dd;
	}
	fclose(fr);
	return 1;
}

int GMLDimsIter::GetLocation(int *ip)
{
	int s;
	s = ip[0];
	for (int i = 1; i < m_n; ++i)
		s += m_pOffset[i] * ip[i];

	return s;
}

float GMLDimsIter::GetZValue(double xy[], int* ip, int j)
{
	if (j == 0)
	{
		int k;
		k = GetLocation(ip);
		return m_pdu[k] * (1.0 - xy[0]) + m_pdu[k + m_pOffset[j]] * xy[0];
	}

	double s;
	s = GetZValue(xy, ip, j - 1) * (1.0 - xy[j]);
	ip[j]++;

	s += GetZValue(xy, ip, j - 1) * xy[j];
	ip[j]--;

	return s;
}

void GMLDimsIter::CreateGrid()
{
	m_nm = m_nxny[0] * m_nxny[1];
	m_pdu = new float[m_nm];
	m_pFlag = new GML_FLAG[m_nm];

	m_pOffset[0] = 1;
	m_pOffset[1] = m_nxny[0];
	m_pOffset[2] = -1;
	m_pOffset[3] = -m_nxny[0];
}