3157 lines
71 KiB
C++
3157 lines
71 KiB
C++
// BaseFun.cpp : 定义 DLL 的初始化例程。
|
||
//
|
||
#include "BaseFun.h"
|
||
#include "math.h"
|
||
#include <QDir>
|
||
//#include "ObjectArchive.h"
|
||
#include <QCoreApplication>
|
||
#include <QTextStream>
|
||
#include <QTextCodec>
|
||
#include <QLibrary>
|
||
#define REPR_INT 1
|
||
#define REPR_SHORT 2
|
||
#define REPR_LONG 3
|
||
#define REPR_FLOAT 4
|
||
#define REPR_DOUBLE 5
|
||
#define REPR_STRING 6
|
||
#define REPR_CHAR 7
|
||
#define REPR_UCHAR 8
|
||
#define REPR_USHORT 9
|
||
#define REPR_UINT 10
|
||
#define REPR_ULONG 11
|
||
void removeStr(char* sdes,QString b,QString e)
|
||
{
|
||
QString des=sdes;
|
||
removeStr(des,b,e);
|
||
strcpy(sdes,des.toStdString().c_str());
|
||
}
|
||
void removeStr(QString &des,QString b,QString e)
|
||
{
|
||
while(1){
|
||
int ind1=des.indexOf(b);
|
||
if(ind1>-1) {
|
||
int indx=des.indexOf(e);
|
||
if(indx<0) des=des.left(ind1);
|
||
else {
|
||
des.remove(ind1,indx-ind1+1);
|
||
}
|
||
}
|
||
else break;
|
||
}
|
||
}
|
||
void CalTextAlign(int & hAlign, int &vAlign,bool isRot)
|
||
{
|
||
switch(hAlign)
|
||
{
|
||
|
||
case 1:
|
||
if(!isRot)
|
||
hAlign = Qt::AlignLeft;
|
||
else hAlign = Qt::AlignBottom;
|
||
break;
|
||
case 2:
|
||
if(!isRot)
|
||
hAlign = Qt::AlignRight;
|
||
else hAlign = Qt::AlignTop;
|
||
break;
|
||
case 0:
|
||
default:
|
||
if(!isRot)
|
||
hAlign = Qt::AlignHCenter;
|
||
else hAlign = Qt::AlignVCenter;
|
||
break;
|
||
}
|
||
switch(vAlign)
|
||
{
|
||
case 0:
|
||
if(!isRot)
|
||
vAlign = Qt::AlignTop;
|
||
else vAlign = Qt::AlignLeft;
|
||
break;
|
||
case 2:
|
||
if(!isRot)
|
||
vAlign = Qt::AlignBottom;
|
||
else vAlign = Qt::AlignRight;
|
||
break;
|
||
case 1:
|
||
default:
|
||
if(!isRot)
|
||
vAlign = Qt::AlignVCenter;
|
||
else vAlign = Qt::AlignHCenter;
|
||
break;
|
||
}
|
||
}
|
||
void CalTextWrap( QString &SrcText,double width,QFont font,QString &OutText,double &height,bool IsWellSectonHorizonLayout )
|
||
{
|
||
int len=SrcText.length();
|
||
if (len==0)
|
||
return;
|
||
QFontMetrics mt(font);
|
||
QString temp,temps;
|
||
QStringList tem;
|
||
for(int i=0;i<len;i++)
|
||
{
|
||
temps=temp;
|
||
temp.append(SrcText.at(i));
|
||
float w=mt.width(temp);
|
||
float h=mt.height();
|
||
if(w>width) {
|
||
temp=SrcText.at(i);
|
||
tem.append(temps);
|
||
}
|
||
if(i==len-1) {
|
||
tem.append(temp);
|
||
}
|
||
}
|
||
OutText=tem.join(" \n");
|
||
}
|
||
#include <iostream>
|
||
#include <string>
|
||
#include <stack>
|
||
#include <cmath>
|
||
#include <stdexcept>
|
||
#include <cctype>
|
||
|
||
using namespace std;
|
||
/*
|
||
class FormulaParser {
|
||
private:
|
||
string expression;
|
||
size_t index;
|
||
|
||
// 跳过空白字符
|
||
void skipWhitespace() {
|
||
while (index < expression.size() && isspace(expression[index])) {
|
||
index++;
|
||
}
|
||
}
|
||
|
||
// 获取当前字符
|
||
char peek() {
|
||
skipWhitespace();
|
||
return index < expression.size() ? expression[index] : '\0';
|
||
}
|
||
|
||
// 消费当前字符并前进
|
||
char consume() {
|
||
skipWhitespace();
|
||
return index < expression.size() ? expression[index++] : '\0';
|
||
}
|
||
|
||
// 解析数字
|
||
double parseNumber() {
|
||
string numStr;
|
||
while (index < expression.size() &&
|
||
(isdigit(expression[index]) || expression[index] == '.')) {
|
||
numStr += expression[index++];
|
||
}
|
||
return stod(numStr);
|
||
}
|
||
|
||
// 解析因子（数字或括号表达式）
|
||
double parseFactor()
|
||
{
|
||
char next = peek();
|
||
if (next == '(') {
|
||
consume(); // 消费 '('
|
||
double result = parseExpression();
|
||
if (peek() != ')') {
|
||
throw runtime_error("Missing closing parenthesis");
|
||
}
|
||
consume(); // 消费 ')'
|
||
return result;
|
||
} else if (isdigit(next)) {
|
||
return parseNumber();
|
||
} else if (next == '+' || next == '-') {
|
||
consume();
|
||
double factor = parseFactor();
|
||
return next == '+' ? factor : -factor;
|
||
} else {
|
||
throw runtime_error("Unexpected character in expression");
|
||
}
|
||
}
|
||
|
||
// 解析指数运算
|
||
double parseExponent() {
|
||
double left = parseFactor();
|
||
while (true) {
|
||
char op = peek();
|
||
if (op == '^') {
|
||
consume();
|
||
double right = parseFactor();
|
||
left = pow(left, right);
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return left;
|
||
}
|
||
|
||
// 解析乘除运算
|
||
double parseTerm() {
|
||
double left = parseExponent();
|
||
while (true) {
|
||
char op = peek();
|
||
if (op == '*' || op == '/') {
|
||
consume();
|
||
double right = parseExponent();
|
||
if (op == '*') {
|
||
left *= right;
|
||
} else {
|
||
if (right == 0) {
|
||
left=0;
|
||
// throw runtime_error("Division by zero");
|
||
}
|
||
else left /= right;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return left;
|
||
}
|
||
|
||
// 解析加减运算
|
||
double parseExpression() {
|
||
double left = parseTerm();
|
||
while (true) {
|
||
char op = peek();
|
||
if (op == '+' || op == '-') {
|
||
consume();
|
||
double right = parseTerm();
|
||
if (op == '+') {
|
||
left += right;
|
||
} else {
|
||
left -= right;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return left;
|
||
}
|
||
|
||
public:
|
||
FormulaParser(const string& expr) : expression(expr), index(0) {}
|
||
|
||
double evaluate() {
|
||
double result = parseExpression();
|
||
if (peek() != '\0') {
|
||
throw runtime_error("Unexpected characters at end of expression");
|
||
}
|
||
return result;
|
||
}
|
||
};
|
||
|
||
int main1() {
|
||
while (true) {
|
||
cout << "Enter an expression (or 'quit' to exit): ";
|
||
string input;
|
||
getline(cin, input);
|
||
|
||
if (input == "quit") {
|
||
break;
|
||
}
|
||
|
||
try {
|
||
FormulaParser parser(input);
|
||
double result = parser.evaluate();
|
||
cout << "Result: " << result << endl;
|
||
} catch (const exception& e) {
|
||
cerr << "Error: " << e.what() << endl;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
*/
|
||
#include <iostream>
|
||
#include <string>
|
||
#include <vector>
|
||
#include <map>
|
||
#include <cmath>
|
||
#include <stdexcept>
|
||
#include <cctype>
|
||
#include <functional> // 添加function头文件
|
||
|
||
using namespace std;
|
||
|
||
class FormulaParser {
|
||
public:
|
||
FormulaParser(const string& expression, const map<string, double>& variables)
|
||
: expr(expression), pos(0), variables(variables) {
|
||
// 预定义函数
|
||
functions["sin"] = [](double x) { return sin(x); };
|
||
functions["cos"] = [](double x) { return cos(x); };
|
||
functions["tan"] = [](double x) { return tan(x); };
|
||
functions["log"] = [](double x) { return log(x); };
|
||
functions["exp"] = [](double x) { return exp(x); };
|
||
functions["sqrt"] = [](double x) { return sqrt(x); };
|
||
// 可以添加更多函数...
|
||
functions["abs"] = [](double x) { return abs(x); };
|
||
}
|
||
|
||
double parse() {
|
||
pos = 0;
|
||
double result = parseExpression();
|
||
if (pos < expr.size()) {
|
||
throw runtime_error("Unexpected character at position " + to_string(pos));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private:
|
||
string expr;
|
||
size_t pos;
|
||
map<string, double> variables;
|
||
map<string, function<double(double)>> functions;
|
||
|
||
void skipWhitespace() {
|
||
while (pos < expr.size() && isspace(expr[pos])) {
|
||
pos++;
|
||
}
|
||
}
|
||
|
||
char peek() {
|
||
skipWhitespace();
|
||
return pos < expr.size() ? expr[pos] : '\0';
|
||
}
|
||
|
||
char consume() {
|
||
skipWhitespace();
|
||
return pos < expr.size() ? expr[pos++] : '\0';
|
||
}
|
||
|
||
double parseExpression() {
|
||
double left = parseTerm();
|
||
while (true) {
|
||
char op = peek();
|
||
if (op == '+' || op == '-') {
|
||
consume();
|
||
double right = parseTerm();
|
||
if (op == '+') {
|
||
left += right;
|
||
} else {
|
||
left -= right;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return left;
|
||
}
|
||
|
||
double parseTerm() {
|
||
double left = parseFactor();
|
||
while (true) {
|
||
char op = peek();
|
||
if (op == '*' || op == '/') {
|
||
consume();
|
||
double right = parseFactor();
|
||
if (op == '*') {
|
||
left *= right;
|
||
} else {
|
||
if (right == 0) {
|
||
throw runtime_error("Division by zero");
|
||
}
|
||
left /= right;
|
||
}
|
||
} else {
|
||
break;
|
||
}
|
||
}
|
||
return left;
|
||
}
|
||
|
||
double parseFactor() {
|
||
double left = parsePrimary();
|
||
while (peek() == '^') {
|
||
consume();
|
||
double right = parsePrimary();
|
||
left = pow(left, right);
|
||
}
|
||
return left;
|
||
}
|
||
|
||
double parsePrimary() {
|
||
char c = peek();
|
||
if (c == '(') {
|
||
consume();
|
||
double result = parseExpression();
|
||
if (peek() != ')') {
|
||
throw runtime_error("Expected ')'");
|
||
}
|
||
consume();
|
||
return result;
|
||
} else if (isalpha(c)) {
|
||
return parseIdentifier();
|
||
} else if (isdigit(c) || c == '.') {
|
||
return parseNumber();
|
||
} else if (c == '-') {
|
||
consume();
|
||
return -parsePrimary();
|
||
} else {
|
||
throw runtime_error("Unexpected character: " + string(1, c));
|
||
}
|
||
}
|
||
|
||
double parseNumber() {
|
||
string numStr;
|
||
while (isdigit(peek())) {
|
||
numStr += consume();
|
||
}
|
||
if (peek() == '.') {
|
||
numStr += consume();
|
||
while (isdigit(peek())) {
|
||
numStr += consume();
|
||
}
|
||
}
|
||
|
||
// 科学计数法支持
|
||
if (peek() == 'e' || peek() == 'E') {
|
||
numStr += consume();
|
||
if (peek() == '+' || peek() == '-') {
|
||
numStr += consume();
|
||
}
|
||
while (isdigit(peek())) {
|
||
numStr += consume();
|
||
}
|
||
}
|
||
|
||
return stod(numStr);
|
||
}
|
||
|
||
double parseIdentifier() {
|
||
string id;
|
||
while (isalnum(peek())) {
|
||
id += consume();
|
||
}
|
||
|
||
// 检查是否是函数调用
|
||
if (peek() == '(') {
|
||
consume();
|
||
double arg = parseExpression();
|
||
if (peek() != ')') {
|
||
throw runtime_error("Expected ')' after function argument");
|
||
}
|
||
consume();
|
||
|
||
auto it = functions.find(id);
|
||
if (it != functions.end()) {
|
||
return it->second(arg);
|
||
} else {
|
||
throw runtime_error("Unknown function: " + id);
|
||
}
|
||
} else {
|
||
// 变量处理
|
||
auto it = variables.find(id);
|
||
if (it != variables.end()) {
|
||
return it->second;
|
||
} else {
|
||
throw runtime_error("Unknown variable: " + id);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
float lst(int code,int point,float *data,char *fieldname,char *formu,float *value,float rlev)
|
||
{
|
||
int i,k=0,in1,in2,in3;
|
||
float br1,br2,br3;
|
||
if(point<=0) point=1;
|
||
switch(code) {
|
||
case 1:
|
||
br1=9999.;
|
||
for(i=0;i<point;i++)
|
||
{
|
||
if(data[i+k]<br1) br1=data[i+k];
|
||
}
|
||
return br1;
|
||
break;
|
||
case 2:
|
||
for(br1=0.0,i=0;i<point;i++) br1+=data[k+i];
|
||
br1=br1/point;
|
||
for(in2=0,br2=0.,i=0;i<point;i++) if(data[i+k]<=br1) {
|
||
in2++;
|
||
br2+=data[k+i];
|
||
}
|
||
if (in2 <= 0)return br1;
|
||
br2=br2/in2;
|
||
for(in3=0,br3=0,i=0;i<point;i++) if(data[i+k]<=br2) {
|
||
in3++;
|
||
br3+=data[i+k];
|
||
}
|
||
if (in3 <= 0)return br2;
|
||
br3=br3/in3;
|
||
if (in3>=(float)point/3. )return br3;
|
||
else return br2;
|
||
break;
|
||
case 3:
|
||
for(br1=0,i=0;i<point;i++) br1+=data[i+k];
|
||
br1/=point;
|
||
return br1;
|
||
case 4:
|
||
for(br1=0.,i=0;i<point;i++) br1+=data[i+k];
|
||
br1/=point;
|
||
for(in2=0,br2=0.,i=0;i<point;i++) if(data[k+i]>=br1) {
|
||
in2++; br2+=data[k+i];
|
||
}
|
||
if(in2 <= 0.0) return br1;
|
||
br2/=in2;
|
||
for(in3=0,br3=0.,i=0;i<point;i++) if(data[i+k]>=br2) {
|
||
in3++;
|
||
br3+=data[k+i];
|
||
}
|
||
if (in3 <=0.0) return br2;
|
||
br3/=in3;
|
||
if ( in3>= (float)point/3. ) return br3;
|
||
else return br2;
|
||
break;
|
||
case 5:
|
||
br1=-9999.;
|
||
for(i=0;i<point;i++) if(data[i+k]>br1) br1=data[i];
|
||
return br1;
|
||
break;
|
||
case 6:
|
||
br1=-9999.;
|
||
if(point>0) br1=data[0];
|
||
return br1;
|
||
break;
|
||
case 7:
|
||
br1=-9999.;
|
||
if(point>0) br1=data[point-1];
|
||
return br1;
|
||
break;
|
||
case 8:
|
||
{
|
||
br1=-9999.;
|
||
QString newFormu=formu;
|
||
newFormu=newFormu.toUpper();
|
||
QString Temp=fieldname;
|
||
QStringList Field,sss;
|
||
sss =Temp.split(",");
|
||
for(int i=0;i<sss.size();i++){
|
||
Field.append(sss[i].split(" "));
|
||
}
|
||
Field.removeAll("");
|
||
/*
|
||
qsort(Field,data,0,Field.size()-1,1);
|
||
char buf[200];
|
||
for(int i=0;i<Field.size();i++)
|
||
{
|
||
int pos=newFormu.indexOf(Field[i],0,Qt::CaseInsensitive);
|
||
if(pos>-1) {
|
||
// if(pos>0&&newFormu[pos-1].isLetter()) continue;
|
||
// if(pos+Field.length()<newFormu.length()&&newFormu[pos+Field.length()].isLetter()) continue;
|
||
}
|
||
else continue;
|
||
sprintf(buf,"%f",data[i]);
|
||
newFormu.replace(Field[i].toUpper(),buf);
|
||
}
|
||
*/
|
||
map<string, double> vars;
|
||
for(int i=0;i<Field.size();i++)
|
||
{
|
||
vars[Field[i].toUpper().toStdString()]=data[i];
|
||
}
|
||
try
|
||
{
|
||
FormulaParser parser(newFormu.toStdString(),vars);
|
||
br1 = parser.parse();
|
||
}
|
||
catch (const exception& e) {
|
||
cerr << "Error: " << e.what() << endl;
|
||
}
|
||
return br1;
|
||
}
|
||
break;
|
||
case 9:
|
||
br1=-9999.;
|
||
if(point>0) br1=data[1];
|
||
return br1;
|
||
break;
|
||
case 10:
|
||
br1=-9999.;
|
||
{
|
||
int first=0;
|
||
int end=point;
|
||
if(point*rlev>2) {
|
||
first=2;
|
||
end-=2;
|
||
}
|
||
float val=0;
|
||
for(int i=first;i<end;i++) {
|
||
val+=data[i];
|
||
}
|
||
int count=end-first;
|
||
if(count>0) br1=val/count;
|
||
}
|
||
return br1;
|
||
break;
|
||
}
|
||
return -9999;
|
||
}
|
||
|
||
char m_strValue[200];
|
||
QStringList GetStringList(QString line,bool IsSpa,bool IsTab,bool IsCom,bool IsSem,bool DelDubSpa)
|
||
{
|
||
if(!IsCom)line.replace(",","");//如果逗号不是分隔符，清除逗号
|
||
if(!IsSpa)line.replace(" ","");
|
||
else
|
||
{
|
||
//连续空格视为单个处理
|
||
if(DelDubSpa)while(line.indexOf(" ")>=0)line.replace(" "," ");
|
||
line=line.simplified();
|
||
//逗号空格连续存在的只留一个？？
|
||
while(line.indexOf(" ,")>=0)line.replace(" ,",",");//line.replace(" ,"," ");2020.5.9
|
||
while(line.indexOf(", ")>=0)line.replace(", ",",");//line.replace(", "," ");
|
||
line.replace(" ",",");
|
||
}
|
||
if(!IsTab)line.replace(" ","");//tab
|
||
else line.replace(" ",",");
|
||
if(!IsSem)line.replace(";","");
|
||
else line.replace(";",",");
|
||
QStringList List=line.split(",");
|
||
return List;
|
||
}
|
||
|
||
double GetData(int repCode,char *buffer,int repLen)
|
||
{
|
||
double yy=-99999;
|
||
if(!buffer)
|
||
{
|
||
return 0;
|
||
}
|
||
switch(repCode)
|
||
{
|
||
case REPR_INT: //0
|
||
yy=(double)(*((int*)buffer));
|
||
break;
|
||
case REPR_SHORT: //1
|
||
yy=(double)(*((short *)buffer));
|
||
break;
|
||
case REPR_LONG://2
|
||
yy=(double)(*((long *)buffer));
|
||
break;
|
||
case REPR_FLOAT://3
|
||
yy=(double)(*((float *)buffer));
|
||
break;
|
||
case REPR_DOUBLE://4
|
||
yy=(double)(*((double *)buffer));
|
||
break;
|
||
case REPR_CHAR://5
|
||
yy=(double)(*((char *)buffer));
|
||
break;
|
||
case REPR_UCHAR://6
|
||
yy=(double)(*((unsigned char *)buffer));
|
||
break;
|
||
case REPR_USHORT://7
|
||
yy=(double)(*((unsigned short *)buffer));
|
||
break;
|
||
case REPR_UINT://8
|
||
yy=(double)(*((unsigned int *)buffer));
|
||
break;
|
||
case REPR_ULONG://9
|
||
yy=(double)(*((unsigned long *)buffer));
|
||
break;
|
||
case REPR_STRING://10
|
||
if(repLen>=200) repLen=199;
|
||
if(repLen>0) {
|
||
memmove(m_strValue,buffer,repLen);
|
||
m_strValue[repLen]=0;
|
||
}
|
||
else m_strValue[0]=0;
|
||
break;
|
||
}
|
||
return yy;
|
||
}
|
||
void SetData(int repCode,char *buffer,double yy)
|
||
{
|
||
if(!buffer)
|
||
{
|
||
return;
|
||
}
|
||
switch(repCode)
|
||
{
|
||
case REPR_INT: //0
|
||
(*((int*)buffer))=(int)yy;
|
||
break;
|
||
case REPR_SHORT: //1
|
||
(*((short *)buffer))=(short)yy;
|
||
break;
|
||
case REPR_LONG://2
|
||
(*((long *)buffer))=(long)yy;
|
||
break;
|
||
case REPR_FLOAT://3
|
||
(*((float *)buffer))=yy;
|
||
break;
|
||
case REPR_DOUBLE://4
|
||
(*((double *)buffer))=(double)yy;
|
||
break;
|
||
case REPR_CHAR://5
|
||
(*((char *)buffer))=(char)yy;
|
||
break;
|
||
case REPR_UCHAR://6
|
||
(*((unsigned char *)buffer))=(unsigned char)yy;
|
||
break;
|
||
case REPR_USHORT://7
|
||
(*((unsigned short *)buffer))=(unsigned short)yy;
|
||
break;
|
||
case REPR_UINT://8
|
||
(*((unsigned int *)buffer))=(unsigned int)yy;
|
||
break;
|
||
case REPR_ULONG://9
|
||
(*((unsigned long *)buffer))=(unsigned long )yy;
|
||
break;
|
||
case REPR_STRING://10
|
||
// *yy=-99999;
|
||
break;
|
||
}
|
||
return;
|
||
}
|
||
|
||
int akima (float *x,float *y,int nx,float *c)
|
||
{
|
||
int i, no;
|
||
float t1, t2, b, rm1, rm2, rm3, rm4;
|
||
|
||
if (nx < 4) return (-1);
|
||
for (i = 1; i < nx; i++)
|
||
{
|
||
if (x[i] <= x[i-1])
|
||
{
|
||
return (-2);
|
||
}
|
||
}
|
||
|
||
rm3 = (y[1] - y[0])/(x[1] - x[0]);
|
||
t1 = rm3 - (y[1] - y[2])/(x[1] - x[2]);
|
||
rm2 = rm3 + t1;
|
||
rm1 = rm2 + t1;
|
||
|
||
/* get slopes */
|
||
|
||
no = nx - 2;
|
||
for (i = 0; i < nx; i++) {
|
||
if (i >= no)
|
||
rm4 = rm3 - rm2 + rm3;
|
||
else
|
||
rm4 = (y[i+2] - y[i+1])/(x[i+2] - x[i+1]);
|
||
t1 = (float)fabs(rm4 - rm3);
|
||
t2 = (float)fabs(rm2 - rm1);
|
||
b = t1 + t2;
|
||
c[3*i] =(float) ((b != 0.0) ? (t1*rm2 + t2*rm3) / b : 0.5*(rm2 + rm3));
|
||
rm1 = rm2;
|
||
rm2 = rm3;
|
||
rm3 = rm4;
|
||
}
|
||
no = nx - 1;
|
||
|
||
/* compute the coefficients for the nx-1 intervals */
|
||
|
||
for (i = 0; i < no; i++) {
|
||
t1 =(float) (1.0 / (x[i+1] - x[i]));
|
||
t2 = (y[i+1] - y[i])*t1;
|
||
b = (c[3*i] + c[3*i+3] - t2 - t2)*t1;
|
||
c[3*i+2] = b*t1;
|
||
c[3*i+1] = -b + (t2 - c[3*i])*t1;
|
||
}
|
||
return (0);
|
||
}
|
||
/*---------------------------------------------------------------------------------------------------------------
|
||
*/
|
||
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||
* CUBSPL computes the coefficients for a natural cubic spline. The
|
||
* algorithm is the same as the one in the IMSL library
|
||
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||
*/
|
||
|
||
int cubspl (float x[],float y[],int nx,float c[])
|
||
{
|
||
int im1, i, jj, j, mm1, mp1, m, nm1, nm2;
|
||
float divdf1, divdf3, dtau, g, cnx[3];
|
||
|
||
if (nx < 4) return (-1);
|
||
nm1 = nx - 1;
|
||
for (m = 1; m < nm1; m++) {
|
||
mm1 = m - 1;
|
||
c[3*m+1] = x[m] - x[mm1];
|
||
if (c[3*m+1] <= 0.0) return (-2);
|
||
c[3*m+2] = (y[m] - y[mm1])/c[3*m+1];
|
||
}
|
||
cnx[1] = x[nx-1] - x[nm1-1];
|
||
if (cnx[1] <= 0.0) return (-3);
|
||
cnx[2] = (y[nx-1] - y[nm1-1])/cnx[1];
|
||
nm2 = nx - 2;
|
||
c[2] = c[7];
|
||
c[1] = c[4] + c[7];
|
||
c[0] =(float) (((c[4] + 2.*c[1])*c[5]*c[7] + c[4]*c[4]*c[8])/c[1]);
|
||
for (m = 1; m < nm2; m++) {
|
||
mp1 = m + 1;
|
||
mm1 = m - 1;
|
||
g = -c[3*mp1+1]/c[3*mm1+2];
|
||
c[3*m] =(float) (g*c[3*mm1] + 3.*c[3*m+1]*c[3*mp1+2] + 3.*c[3*mp1+1]*c[3*m+2]);
|
||
c[3*m+2] =(float) (g*c[3*mm1+1] + 2.*c[3*m+1] + 2.*c[3*mp1+1]);
|
||
}
|
||
g = -cnx[1]/c[3*nm2-1];
|
||
c[3*nm1-3] =(float) (g*c[3*nm2-3] + 3.*c[3*nm1-2]*cnx[2] + 3.*cnx[1]*c[3*nm1-1]);
|
||
c[3*nm1-1] =(float) (g*c[3*nm2-2] + 2.*c[3*nm1-2] + 2.*cnx[1]);
|
||
g = c[3*nm1-2] + cnx[1];
|
||
cnx[0] =(float) (((cnx[1] + 2.*g)*cnx[2]*c[3*nm1-2] + cnx[1]*cnx[1]*(y[nm1-1]-y[nx-3])/c[3*nm1-2])/g);
|
||
g = -g/c[3*nm1-1];
|
||
cnx[2] = c[3*nm1-2] + g*c[3*nm1-2];
|
||
cnx[0] = (g*c[3*nm1-3] + cnx[0])/cnx[2];
|
||
c[3*nm1-3] = (c[3*nm1-3]-c[3*nm1-2]*cnx[0])/c[3*nm1-1];
|
||
for (jj = 0; jj < nm2; jj++) {
|
||
j = nm1 - jj - 1;
|
||
c[3*j] = (c[3*j]-c[3*j+1]*c[3*j+3])/c[3*j+2];
|
||
}
|
||
for (i = 1; i < nm1; i++) {
|
||
im1 = i-1;
|
||
dtau = c[3*i+1];
|
||
divdf1 = (y[i]-y[im1])/dtau;
|
||
divdf3 =(float) (c[3*im1] + c[3*i] - 2.*divdf1);
|
||
c[3*im1+1] = (divdf1 - c[3*im1] - divdf3)/dtau;
|
||
c[3*im1+2] = divdf3/(dtau*dtau);
|
||
}
|
||
dtau = cnx[1];
|
||
divdf1 = (y[nx-1]-y[nm1-1])/dtau;
|
||
divdf3 =(float) (c[3*nm1-3] + cnx[0] - 2.*divdf1);
|
||
c[3*nm1-2] = (divdf1-c[3*nm1-3]-divdf3)/dtau;
|
||
c[3*nm1-1] = divdf3/(dtau*dtau);
|
||
return (0);
|
||
}
|
||
|
||
/****************************************************************/
|
||
/** this program was refered to "Numerical Recipes in C
|
||
The Art of Scientific Computing Second Edition "
|
||
Wroted by W. H. Press, S. A. Teukolsky, W. T. Vetterling,
|
||
B. P. Flannery
|
||
**/
|
||
/**************************************************************/
|
||
|
||
int spline(float x[],float y[], int n,float yp1, float ypn,float y2[])
|
||
/* x[],y[]: input point data;
|
||
n: data bumber of input data;
|
||
yp1: the first rank differential of point 1;
|
||
ypn: the first rank differential of point 2;
|
||
*/
|
||
{
|
||
int i,k;
|
||
float p,qn,sig,un,*u;
|
||
if(n<4) return(-1);
|
||
u=(float *)malloc(sizeof(float)*n);
|
||
if(yp1>0.99e30) y2[0]=u[0]=0.0; /** the low boundery condition set to zero */
|
||
else {
|
||
y2[0]=-0.5;
|
||
u[0]=(float)((3.0/(x[1]-x[0]))*((y[1]-y[0])/(x[1]-x[0])-yp1));
|
||
}
|
||
for(i=1;i<n-1;i++){
|
||
sig=(x[i]-x[i-1])/(x[i+1]-x[i-1]);
|
||
p=sig*y2[i-1]+(float)2.0;
|
||
y2[i]=(sig-(float)1.0)/p;
|
||
u[i]=(y[i+1]-y[i])/(x[i+1]-x[i])-(y[i]-y[i-1])/(x[i]-x[i-1]);
|
||
u[i]=((float)6.0*u[i]/(x[i+1]-x[i-1])-sig*u[i-1])/p;
|
||
}
|
||
if(ypn>0.99e30) qn=un=0.0;
|
||
else {
|
||
qn=0.5;
|
||
un=((float)3.0/(x[n-1]-x[n-2]))*(ypn-(y[n-1]-y[n-2])/(x[n-1]-x[n-2]));
|
||
}
|
||
|
||
y2[n-1]=(un-qn*u[n-2])/(qn*y2[n-2]+(float)1.0);
|
||
for(k=n-2;k>=0;k--)
|
||
y2[k]=y2[k]*y2[k+1]+u[k];
|
||
|
||
free((char *)u);
|
||
return(0);
|
||
}
|
||
char *memory (char *prev_addr, int n, int size, char *progname)
|
||
{
|
||
char *tmp;
|
||
|
||
if (prev_addr) {
|
||
if ((tmp = (char *)realloc ((char *) prev_addr, (unsigned) (n * size))) == NULL) {
|
||
fprintf (stderr, "%s: Could not reallocate more memory, n = %d\n", progname, n);
|
||
return 0;
|
||
}
|
||
}
|
||
else {
|
||
if ((tmp = (char *)(char *)calloc ((unsigned) n, (unsigned) size)) == NULL) {
|
||
fprintf (stderr, "%s: Could not allocate memory, n = %d\n", progname, n);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
return (tmp);
|
||
}
|
||
|
||
int intpol (float *x,float *y,int n,int m,float *u,float *v,int mode)
|
||
{
|
||
int i, j, err_flag = 0;
|
||
float dx, *c, nanq, zip = 0.0;
|
||
float h,a,b;
|
||
char *CNULL = (char *)NULL;
|
||
|
||
if (n < 4) mode = 0;
|
||
char strTmp[7] = "intpol";
|
||
if (mode > 0) c = (float *) memory (CNULL, 3*n, sizeof(float), strTmp);
|
||
|
||
if (mode == 0) { /* Linear interpolation */
|
||
for (i = 1; i < n; i++)
|
||
if (x[i] <= x[i-1])
|
||
return (-1);
|
||
}
|
||
|
||
else if (mode == 1) /* Akimas spline */
|
||
err_flag = akima(x,y,n,c);
|
||
|
||
else if (mode == 2) /* Natural cubic spline */
|
||
/* err_flag = cubspl(xx,yy,n,c);
|
||
*/
|
||
err_flag=spline(x,y, n,(float)0.99e34,(float)0.99e34,c);
|
||
else if(mode==3) err_flag = cubspl(x,y,n,c);
|
||
else
|
||
err_flag = -4;
|
||
if (err_flag != 0) return (err_flag);
|
||
|
||
/* Compute the interpolated values from the coefficients */
|
||
|
||
j = 0;
|
||
nanq =(float) 1.0e-30;
|
||
for (i = 0; i < m; i++) {
|
||
if (u[i] < x[0] || u[i] > x[n-1]) { /* Desired point outside data range */
|
||
v[i] = nanq;
|
||
continue;
|
||
}
|
||
while (x[j] <= u[i] && j < n) j++;
|
||
if (j > 0) j--;
|
||
dx = u[i] - x[j];
|
||
if (mode == 0)
|
||
v[i] = (y[j+1]-y[j])*dx/(x[j+1]-x[j]) + y[j];
|
||
else if(mode ==2){
|
||
h=x[j+1]-x[j];
|
||
if(h==0.0) {fprintf(stderr,"Bad xa input ro routing splint\n");
|
||
v[i]=y[j];
|
||
}
|
||
else {a=(x[j+1]-u[i])/h;
|
||
b=(u[i]-x[j])/h;
|
||
v[i]=a*y[j]+b*y[j+1]+((a*a*a-a)*c[j]+(b*b*b-b)*c[j+1])*(h*h)/(float)6.0;
|
||
/*printf("a=%f b=%f v[%d]=%f\n",a,b,i,v[i]); */
|
||
|
||
}
|
||
}
|
||
else
|
||
v[i] = ((c[3*j+2]*dx + c[3*j+1])*dx + c[3*j])*dx + y[j];
|
||
}
|
||
if (mode > 0) free ((char *)c);
|
||
return (0);
|
||
}
|
||
///360度插值
|
||
int Resamples(char *Data0,char *Data1,int N0,int N1,int RepCode,int CodeLen)
|
||
{
|
||
float *InData=new float[N0];
|
||
float *OutData=new float[N1];
|
||
for(int i=0;i<N0;i++) {
|
||
InData[i]=GetData(RepCode,&Data0[i*CodeLen],CodeLen);
|
||
}
|
||
float ino=N0;
|
||
float ono=N1;
|
||
//Resamples(InData,OutData,ino,ono);
|
||
int pos=0;
|
||
float val1=0,val2=0,val=0;
|
||
for(int i=0;i<N1;i++) {
|
||
pos=i*N0/N1;
|
||
// val1=InData[pos];
|
||
// val2=InData[ps+1];
|
||
// Data1[i]=(i-i*N0/N1)/(1)*(val2-val1)+val1;
|
||
OutData[i]=InData[pos];
|
||
}
|
||
for(int i=0;i<N1;i++) {
|
||
SetData(RepCode,&Data1[i*CodeLen],OutData[i]);
|
||
}
|
||
delete InData;
|
||
delete OutData;
|
||
return 1;
|
||
}
|
||
int Resamples(float *Data0,float *Data1,float N0,float N1)
|
||
{
|
||
//Data0是原来的N0道数据
|
||
//Data1为插好的N1道数据
|
||
|
||
float *data0= (float*)malloc((N0+1)*sizeof(float));
|
||
float *x0=(float*)malloc((N0+1)*sizeof(float));
|
||
float *x1=(float*)malloc(N1*sizeof(float));
|
||
|
||
for(int i=0;i<N0+1;i++)
|
||
{
|
||
x0[i]=(i*1.0)*360.0/(1.0*N0);
|
||
if(i<N0)
|
||
data0[i]=Data0[i];
|
||
else
|
||
data0[i]=Data0[0];
|
||
}
|
||
|
||
for(int i=0;i<N1;i++)
|
||
{
|
||
x1[i]=(i*1.0)*360.0/(1.0*N1);
|
||
}
|
||
|
||
intpol(x0,data0,N0+1,N1,x1,Data1,1);
|
||
free(data0);
|
||
free(x0);
|
||
free(x1);
|
||
return 1;
|
||
}
|
||
void LeastSquare(int size,float *x, float* y,float &a,float &b)
|
||
{
|
||
double t1=0, t2=0, t3=0, t4=0;
|
||
for(int i=0; i<size; ++i)
|
||
{
|
||
t1 += x[i]*x[i];
|
||
t2 += x[i];
|
||
t3 += x[i]*y[i];
|
||
t4 += y[i];
|
||
}
|
||
a = (t3*size - t2*t4) / (t1*size - t2*t2);
|
||
//b = (t4 - a*t2) / x.size();
|
||
b = (t1*t4 - t2*t3) / (t1*size - t2*t2);
|
||
}
|
||
|
||
float GetMaxFreq(float m_min,float m_max,float *inFreq,int count)
|
||
{
|
||
float x=0;
|
||
int j=-1;
|
||
for(int i=0;i<count;i++) {
|
||
if(inFreq[i]>x) {
|
||
x=inFreq[i];
|
||
j=i;
|
||
}
|
||
}
|
||
float val=0;
|
||
if(j!=-1) val=j*(m_max-m_min)/count;
|
||
return val;
|
||
}
|
||
int GetFreq(float *pVal,int dataSize,float m_min,float m_max,int count,float *outFreq)
|
||
{
|
||
for (int j = 0; j < count; ++j)
|
||
{
|
||
outFreq[j] = 0;
|
||
}
|
||
//进行统计
|
||
int effectiveSize = 0;
|
||
//等于最大值得放入最后一个区间
|
||
for (int i = 0; i < (int)dataSize; ++i)
|
||
{
|
||
if (qAbs(pVal[i] - m_max) < 1e-10)
|
||
{
|
||
outFreq[count - 1]+= 1;
|
||
effectiveSize += 1;
|
||
continue;
|
||
}
|
||
int ss=(pVal[i]-m_min)/((m_max - m_min)/(float)count);
|
||
if(ss<0) continue;
|
||
if(ss>=count) continue;
|
||
outFreq[ss] += 1;
|
||
effectiveSize += 1;
|
||
}
|
||
return effectiveSize;
|
||
}
|
||
float mean(vector<float>resultSet)
|
||
{
|
||
std::vector<float>::iterator d=resultSet.begin();
|
||
double sum=0;
|
||
for (;d!=resultSet.end();d++) {
|
||
sum+=*d;
|
||
}
|
||
float mean1 = sum / resultSet.size(); //均值
|
||
return mean1;
|
||
}
|
||
float stdev(vector<float>resultSet)
|
||
{
|
||
double mean1=mean(resultSet);
|
||
double accum = 0.0;
|
||
std::vector<float>::iterator d=resultSet.begin();
|
||
for (;d!=resultSet.end();d++)
|
||
{
|
||
accum += (*d-mean1)*(*d-mean1);
|
||
};
|
||
double stdev1 = sqrt(accum/(resultSet.size()-1)); //方差
|
||
return stdev1;
|
||
}
|
||
int IsNumberic(QString src)
|
||
{
|
||
QByteArray ba = src.toLatin1();
|
||
const char *s = ba.data();
|
||
while(*s)
|
||
{
|
||
if(*s>='0'&& *s<='9')
|
||
s++;
|
||
else if(*s == '.')
|
||
s++;
|
||
else if(*s == '-')
|
||
s++;
|
||
else
|
||
break;
|
||
}
|
||
|
||
if(*s)
|
||
return -1;//不是纯数字
|
||
else
|
||
return 0;//纯数字
|
||
}
|
||
|
||
int binarySearch(float*darray, int n, float data,float err)//
|
||
{
|
||
int low, mid, high;
|
||
if(darray == NULL) return -1;//
|
||
low = 0;
|
||
high = n - 1;
|
||
while(low <= high) {
|
||
mid = (low + high) / 2;
|
||
if(fabs(data-darray[mid])<err) return mid; //
|
||
else if(data < darray[mid]) high = mid - 1;
|
||
else low = mid + 1;
|
||
}
|
||
return -1;//
|
||
}
|
||
int bSearch(double*darray, int n, double data,double err)//
|
||
{
|
||
int low, mid, high;
|
||
if(darray == NULL) return -1;//
|
||
low = 0;
|
||
high = n - 1;
|
||
while(low <= high) {
|
||
mid = (low + high) / 2;
|
||
if(fabs(data-darray[mid])<err) return mid;
|
||
if(mid+1<n&&data>darray[mid]&&data<darray[mid+1]) return mid; //
|
||
else if(data < darray[mid]) high = mid - 1;
|
||
else low = mid + 1;
|
||
}
|
||
return -1;//
|
||
}
|
||
|
||
|
||
//bool FLOATPROPERTY::Serialize( CObjectArchive &ar )
|
||
// {
|
||
// if(ar.IsStoring())
|
||
// {
|
||
// BEGIN_WRITE_OBJECT( ar , 1 );
|
||
// BEGIN_WRITE_BLOCK( ar , 1 );
|
||
// ar << m_size;
|
||
// ar.writeRawData((char *)m_vProperty,m_size*sizeof(float));
|
||
// END_WRITE_BLOCK( ar , 1);
|
||
// END_WRITE_OBJECT( ar );
|
||
// }
|
||
// else
|
||
// {
|
||
// BEGIN_READ_OBJECT( ar,1 );
|
||
// BEGIN_READ_BLOCK( 1 );
|
||
// ar >> m_size;
|
||
// if(m_vProperty) delete m_vProperty;
|
||
// m_vProperty =new float[m_size];//(float *)malloc(sizeof(float));
|
||
// ar.readRawData((char *)m_vProperty,m_size*sizeof(float));
|
||
// END_READ_BLOCK( 1 );
|
||
// END_READ_OBJECT( ar );
|
||
// }
|
||
// return true;
|
||
// }
|
||
|
||
// bool DOUBLEPROPERTY::Serialize( CObjectArchive &ar )
|
||
// {
|
||
// if(ar.IsStoring())
|
||
// {
|
||
// BEGIN_WRITE_OBJECT( ar , 1 );
|
||
// BEGIN_WRITE_BLOCK( ar , 1 );
|
||
// ar << m_size;
|
||
// ar.writeRawData((char *)m_vProperty,m_size*sizeof(double));
|
||
// END_WRITE_BLOCK( ar , 1);
|
||
// END_WRITE_OBJECT( ar );
|
||
// }
|
||
// else
|
||
// {
|
||
// BEGIN_READ_OBJECT( ar,1 );
|
||
// BEGIN_READ_BLOCK( 1 );
|
||
// ar >> m_size;
|
||
// if(m_vProperty) delete m_vProperty;
|
||
// m_vProperty =new double[m_size];//(float *)malloc(sizeof(float));
|
||
// ar.readRawData((char *)m_vProperty,m_size*sizeof(double));
|
||
// END_READ_BLOCK( 1 );
|
||
// END_READ_OBJECT( ar );
|
||
// }
|
||
|
||
// }
|
||
|
||
void CreateDir(char *buf)
|
||
{
|
||
char buf1[MAX_PATH+1];
|
||
QDir adir;
|
||
if(!adir.mkdir(buf)) {
|
||
int j=0;
|
||
int i=0;
|
||
CString cs=buf;
|
||
for(i=2;i<strlen(buf);i++) {
|
||
if(buf[i]=='\\'||buf[i]=='/') {
|
||
if(!j) {
|
||
j++;
|
||
continue;
|
||
}
|
||
strcpy(buf1,buf);
|
||
buf1[i]='\0';
|
||
if(!adir.mkdir(buf1)) {
|
||
/*
|
||
if(GetLastError()!=ERROR_ALREADY_EXISTS) {
|
||
CString cs;
|
||
cs.Format("新建目录%s错误",buf1);
|
||
AfxMessageBox(cs);
|
||
}
|
||
*/
|
||
}
|
||
}
|
||
else if(i!=0&&i==strlen(buf)-1) {
|
||
QDir adir;
|
||
adir.mkdir(buf);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// CBaseFunApp
|
||
void PutScanDepthMes(char *Message,float stdep,float endep,char *outfilename)
|
||
{
|
||
int len=strlen(Message);
|
||
Message[len]='\0';
|
||
len+=1;
|
||
char buf[128];
|
||
sprintf(buf,"%.6f\0",stdep);
|
||
strcpy(&Message[len],buf);//跳过\0
|
||
len+=strlen(buf)+1;//buf+1
|
||
sprintf(buf,"%.6f\0",endep);
|
||
strcpy(&Message[len],buf);
|
||
len+=strlen(buf)+1;
|
||
if(outfilename) {
|
||
sprintf(buf,"%.3f\0",endep);
|
||
strcpy(&Message[len],outfilename);
|
||
}
|
||
else strcpy(&Message[len],"");
|
||
}
|
||
void GetTranMes(char *p,float *x,float *y,float *outsdep,float *outedep)
|
||
{
|
||
sscanf(p,"%f",x);
|
||
int len=strlen(p)+1;
|
||
if(len<=1)*x=-99999.;
|
||
p+=len;
|
||
sscanf(p,"%f",y);
|
||
len=strlen(p)+1;
|
||
if(len<=1)*y=-99999.;
|
||
p+=len;
|
||
sscanf(p,"%f",outsdep);
|
||
len=strlen(p)+1;
|
||
p+=len;
|
||
sscanf(p,"%f",outedep);
|
||
/*
|
||
if(*outsdep>*outedep)
|
||
{
|
||
float temp=*outsdep;
|
||
*outsdep=*outedep;
|
||
*outedep=temp;
|
||
}
|
||
*/
|
||
}
|
||
|
||
float pe_axp_(int *cc)
|
||
{
|
||
union {
|
||
float x1;
|
||
int x2;
|
||
}zz;
|
||
int a,b,c,c1,c2,c3;
|
||
short a1=0,b1=0;
|
||
short i,j;
|
||
zz.x2=*cc;
|
||
if(zz.x2==0)return zz.x1;
|
||
a=0x00000080&zz.x2;
|
||
b1=zz.x2&0x0000007f;
|
||
c=0xffffff00&zz.x2;
|
||
c1=(c>>8)&0xff;
|
||
i=128;
|
||
for(j=0;j<3;++j){
|
||
if(c1>=i)break;
|
||
i=i/2;
|
||
};
|
||
c1=(c&0x00007f00)<<8;
|
||
c2=(c&0x00ff0000)>>8;
|
||
c3=(c&0xff000000)>>24;
|
||
c=((c1|c2|c3)&0X00ffffff)<<j;
|
||
if(b1>=0x41){
|
||
b=(b1-0x41)*4+0x7f+3-j;
|
||
}
|
||
else
|
||
{
|
||
b=0x7e-(0x40-b1)*4-j;
|
||
}
|
||
zz.x2=0x80000000&(a<<24);
|
||
zz.x2=zz.x2|((b<<23)&0x7f800000);
|
||
zz.x2=zz.x2|(c&0x007fffff);
|
||
return zz.x1;
|
||
}
|
||
int int32_pe_axp_(int *number)
|
||
{
|
||
int num,hi1,hi2,lo1,lo2;
|
||
num=*number;
|
||
hi1=(num&0x000000ff)<<24;
|
||
hi2=(num&0x0000ff00)<<8;
|
||
lo1=(num&0x00ff0000)>>8;
|
||
lo2=(num&0xff000000)>>24;
|
||
return hi1|hi2|lo1|lo2;
|
||
}
|
||
|
||
short int int16_pe_axp_(short int *number)
|
||
{
|
||
short num,hi,lo;
|
||
num=*number;
|
||
hi=(num&0xff00)>>8;
|
||
lo=(num&0x00ff)<<8;
|
||
return hi|lo;
|
||
}
|
||
CString GetBinDir()
|
||
{
|
||
char bindir[MAX_PATH+1];
|
||
bindir[0]=0;
|
||
CString cs=GetBinDir(bindir);
|
||
return cs;
|
||
}
|
||
char *GetBinDir(char *str)
|
||
{
|
||
QString strPathTmp = QCoreApplication::applicationDirPath()+ QDir::separator() ;
|
||
QString strConfPath = QDir::toNativeSeparators( strPathTmp );
|
||
strcpy(str,strConfPath.toStdString().c_str());
|
||
return str;
|
||
}
|
||
bool InRange(float val,float min,float max)
|
||
{
|
||
if(min==-9999)
|
||
{
|
||
if(val<=max)return 1;
|
||
else return 0;
|
||
}
|
||
else if(max==-9999)
|
||
{
|
||
if(val>=min)return 1;
|
||
else return 0;
|
||
}
|
||
else
|
||
{
|
||
if(val>=min&&val<=max)return 1;
|
||
else return 0;
|
||
}
|
||
}
|
||
int GetPos(DATAFORMATMESSAGE ms,char *buf)
|
||
{
|
||
CString Type[20]={"C","B","I2S","I2","I4S","I4","FPS","FP","UI4"};
|
||
int DataTypeId,starPos=0,pos=0;
|
||
int NumCTerm[10];//各条件中枚举字符串的个数，如果不是"C"型，NumCTerm[i]=0
|
||
CString Cstr[50][10];
|
||
for(int i=0;i<ms.TermNum;i++)
|
||
{
|
||
NumCTerm[i]=0;
|
||
if(strcmp(ms.m_Term[i].ValueType,"C")!=0)continue;
|
||
Cstr[i][0].Format("%s",ms.m_Term[i].ValueMin);
|
||
int n=1;
|
||
CString cmax;
|
||
cmax.Format("%s",ms.m_Term[i].ValueMax);
|
||
while(1)
|
||
{
|
||
char strTmp[5] = ".OR.";
|
||
int p=cmax.Find(strTmp);
|
||
if(p<=0)
|
||
{
|
||
//Cstr[i][n].Format("%s",cmax);
|
||
Cstr[i][n]=cmax;
|
||
n++;
|
||
break;
|
||
}
|
||
Cstr[i][n]=cmax.Left(p);
|
||
cmax=cmax.Right(cmax.GetLength()-p-4);
|
||
n++;
|
||
}
|
||
NumCTerm[i]=n;
|
||
}
|
||
while(1)
|
||
{
|
||
for(int i=0;i<ms.TermNum;i++)
|
||
{
|
||
char mbuf[5000];
|
||
int ist,iend;
|
||
if(ms.m_Term[i].SearchMode==0){ist=ms.m_Term[i].start-1;iend=ms.m_Term[i].end;}//strncpy(mbuf,&buf[ms.m_Term[i].start-1],ms.m_Term[i].end-ms.m_Term[i].start+1);//全范围搜索
|
||
else if(ms.m_Term[i].SearchMode==1){ist=ms.m_Term[i].start-1;iend=ms.m_Term[i].end;}//strncpy(mbuf,&buf[ms.m_Term[i].start-1],ms.m_Term[i].end-ms.m_Term[i].start+1);//定位搜索
|
||
else if(ms.m_Term[i].SearchMode==2){ist=starPos+ms.m_Term[i].start;iend=ms.m_Term[i].end;}//strncpy(mbuf,&buf[starPos+ms.m_Term[i].start-1],ms.m_Term[i].end);//在第一搜索基础上加偏移量搜索
|
||
for(int j=ist;j<iend;j++)mbuf[j-ist]=buf[j];
|
||
CString DataType;
|
||
DataType.Format("%s",ms.m_Term[i].ValueType);
|
||
DataTypeId=-1;
|
||
for(int j=0;j<20;j++)
|
||
{
|
||
if(DataType==Type[j])
|
||
{
|
||
DataTypeId=j;
|
||
break;
|
||
}
|
||
}
|
||
if(DataTypeId<0)return 0;
|
||
switch(DataTypeId)
|
||
{
|
||
case 0://C
|
||
{
|
||
for(int j=0;j<iend-ist;j++)
|
||
{
|
||
if(mbuf[j]==0)mbuf[j]=' ';
|
||
else if(mbuf[j]>='a'&&mbuf[j]<='z')
|
||
{
|
||
mbuf[j]-=32;
|
||
}
|
||
}
|
||
CString str1;
|
||
str1.Format("%s",mbuf);
|
||
int l=str1.GetLength();
|
||
for(int m=0;m<NumCTerm[i];m++)
|
||
{
|
||
pos=str1.Find(Cstr[i][m]);
|
||
if(pos>=0)break;
|
||
}
|
||
//pos=str1.Find(ms.m_Term[i].ValueMin);
|
||
//if(pos<0)pos=str1.Find(ms.m_Term[i].ValueMax);
|
||
if(pos<0)return 0;
|
||
break;
|
||
}
|
||
case 1://B
|
||
{
|
||
BYTE val=mbuf[0];
|
||
float min=atof(ms.m_Term[i].ValueMin);
|
||
float max=atof(ms.m_Term[i].ValueMax);
|
||
if(!InRange(val,min,max))goto loop1;
|
||
//if(val<min||val>max)goto loop1;
|
||
break;
|
||
}
|
||
case 2://I2S
|
||
{
|
||
short int val;
|
||
memcpy(&val,mbuf,2);
|
||
val=int16_pe_axp_(&val);
|
||
float min=atof(ms.m_Term[i].ValueMin);
|
||
float max=atof(ms.m_Term[i].ValueMax);
|
||
//if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
case 3://I2
|
||
{
|
||
short int val;
|
||
memcpy(&val,mbuf,2);
|
||
int min=atoi(ms.m_Term[i].ValueMin);
|
||
int max=atoi(ms.m_Term[i].ValueMax);
|
||
//if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
case 4://I4S
|
||
{
|
||
int val;
|
||
memcpy(&val,mbuf,2);
|
||
val=int32_pe_axp_(&val);
|
||
int min=atoi(ms.m_Term[i].ValueMin);
|
||
int max=atoi(ms.m_Term[i].ValueMax);
|
||
//if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
case 5://I4
|
||
{
|
||
int val;
|
||
memcpy(&val,mbuf,2);
|
||
int min=atoi(ms.m_Term[i].ValueMin);
|
||
int max=atoi(ms.m_Term[i].ValueMax);
|
||
//if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
case 6://FP
|
||
{
|
||
int ival;
|
||
float val;
|
||
memcpy(&ival,mbuf,4);
|
||
val=pe_axp_(&ival);
|
||
float min=atof(ms.m_Term[i].ValueMin);
|
||
float max=atof(ms.m_Term[i].ValueMax);
|
||
//if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
case 7://FPPC
|
||
{
|
||
float val;
|
||
memcpy(&val,mbuf,4);
|
||
float min=atof(ms.m_Term[i].ValueMin);
|
||
float max=atof(ms.m_Term[i].ValueMax);
|
||
// if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
case 8://unsigned long
|
||
{
|
||
unsigned long val;
|
||
memcpy(&val,mbuf,4);
|
||
float min=atof(ms.m_Term[i].ValueMin);
|
||
float max=atof(ms.m_Term[i].ValueMax);
|
||
//if(val<min||val>max)goto loop1;
|
||
if(!InRange(val,min,max))goto loop1;
|
||
break;
|
||
}
|
||
}
|
||
if(i==0)starPos=pos+ms.m_Term[i].start-1;
|
||
}
|
||
return starPos;
|
||
loop1: if(ms.m_Term[0].SearchMode==0)
|
||
{
|
||
CString ss;
|
||
ss.Format("%s",ms.m_Term[0].ValueMin);
|
||
int h=ss.GetLength();
|
||
ms.m_Term[0].start=starPos+1+h;
|
||
if(ms.m_Term[0].start>=ms.m_Term[0].end)return -1;
|
||
}
|
||
else return -1;
|
||
}
|
||
return starPos;
|
||
}
|
||
int GetBeginPosit(char *FileName,char* FormatName)
|
||
{
|
||
//读数据格式识别信息文件
|
||
char *pPath=new char[MAX_PATH+1];
|
||
GetBinDir(pPath);
|
||
CString csDir = pPath;
|
||
csDir+=CString("\\convertor\\");
|
||
CString csFile = csDir +"DataFormatMes.txt",str;
|
||
delete pPath;
|
||
FILE *fp=fopen(csFile.GetString(),"rt");
|
||
if(fp==NULL)
|
||
{
|
||
AfxMessageBox("打开数据格式识别信息文件DataFormatMes.txt出错");
|
||
return -1;
|
||
}
|
||
char strName[256],temp[256],buf[7][30];
|
||
fgets(strName,256,fp);
|
||
DATAFORMATMESSAGE ms;
|
||
int LenMax=0;
|
||
while ( !feof(fp) )
|
||
{
|
||
fgets(strName,256,fp);
|
||
CString str;
|
||
str.Format("%s",strName);
|
||
str.MakeUpper();
|
||
if(str.Find(FormatName,0)>=0)
|
||
{
|
||
sscanf(strName,"%s %d",temp,&ms.TermNum);
|
||
ms.FormatName.Format("%s",temp);
|
||
ms.FormatName.Delete(0,1);
|
||
ms.FormatName.Delete(ms.FormatName.GetLength()-1,1);
|
||
ms.m_Term=new TERM[ms.TermNum];
|
||
for(int i=0;i<ms.TermNum;i++)
|
||
{
|
||
fgets(strName,256,fp);
|
||
sscanf(strName,"%s%s%s%s%s%s%s",ms.m_Term[i].characterization,buf[0],buf[1],buf[2],
|
||
ms.m_Term[i].ValueType,ms.m_Term[i].ValueMin,ms.m_Term[i].ValueMax);//buf[3],buf[4],buf[5],buf[6]);//%d %d %d %d %s %s %s",temp,&ms.m_Term[i].SearchMode,&ms.m_Term[i].start,
|
||
// &ms.m_Term[i].end,&buf[0],&buf[1],&buf[2]);
|
||
sscanf(buf[0],"%d",&ms.m_Term[i].SearchMode);
|
||
sscanf(buf[1],"%d",&ms.m_Term[i].start);
|
||
sscanf(buf[2],"%d",&ms.m_Term[i].end);
|
||
if(LenMax<ms.m_Term[i].end)LenMax=ms.m_Term[i].end;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
fclose(fp);
|
||
//格式识别
|
||
char *buffer;
|
||
buffer=new char[LenMax+1];
|
||
fp=fopen(FileName,"rb");
|
||
fread(buffer,1,LenMax,fp);
|
||
fclose(fp);
|
||
buffer[LenMax]=0;
|
||
int pos=GetPos(ms,buffer);
|
||
delete ms.m_Term;
|
||
delete buffer;
|
||
return pos;
|
||
}
|
||
CString GetRegDir(char *Name)
|
||
{
|
||
// TODO: Add your control notification handler code here
|
||
char Path[MAX_PATH+1];
|
||
CString strDLL=GetBinDir(Path);
|
||
if(strDLL.ReverseFind('\\')>-1) {
|
||
strDLL=strDLL.Left(strDLL.ReverseFind('\\'));
|
||
strcpy(Path,strDLL.GetString());
|
||
}
|
||
strcat(Path,"\\");
|
||
strcat(Path,Name);
|
||
return Path;
|
||
}
|
||
bool HaveSameCurve(int NumLog,int *OutCurveNo,char **OutCurve)
|
||
{
|
||
if(NumLog>1024) return 1;
|
||
for(int i=0;i<NumLog-1;i++)
|
||
{
|
||
char temp[1000];
|
||
strcpy(temp,OutCurve[i]);
|
||
if(strlen(temp)==0&&OutCurveNo[i]>=0) {
|
||
AfxMessageBox("输出曲线名不能为空！");
|
||
return 1;
|
||
break;
|
||
}
|
||
for(int j=i+1;j<NumLog;j++)
|
||
{
|
||
if((strcmp(OutCurve[i],OutCurve[j])==0)&&(OutCurveNo[i]>=0))
|
||
{
|
||
strcat(temp,"_1");
|
||
delete OutCurve[i];
|
||
OutCurve[i]=new char[strlen(temp)+1];
|
||
strcpy(OutCurve[i],temp);
|
||
}
|
||
}
|
||
}
|
||
/*
|
||
CString str,mes="";
|
||
int SameNameCurveNum=0;
|
||
for(int i=0;i<NumLog-1;i++)
|
||
{
|
||
//SameNameCurveNum=0;
|
||
for(int j=i+1;j<NumLog;j++)
|
||
{
|
||
if((strcmp(OutCurve[i],OutCurve[j])==0)&&(OutCurveNo[i]>=0))
|
||
{
|
||
//OutCurveNo[j]=-1;
|
||
sprintf(OutCurve[j],"%s%d",OutCurve[j],SameNameCurveNum);
|
||
str.Format("第%d条曲线和第%d条曲线的输出曲线名相同,输出名字为%s\r\n",i,j,OutCurve[i]);
|
||
mes+=str;
|
||
SameNameCurveNum++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if(SameNameCurveNum>0)
|
||
{
|
||
for(int i=0;i<NumLog-1;i++)
|
||
{
|
||
char temp[64];
|
||
strcpy(temp,OutCurve[i]);
|
||
for(int j=i+1;j<NumLog;j++)
|
||
{
|
||
if((strcmp(OutCurve[i],OutCurve[j])==0)&&(OutCurveNo[i]>=0))
|
||
{
|
||
strcat(temp,"+");
|
||
strcpy(OutCurve[j],temp);
|
||
}
|
||
}
|
||
}
|
||
}*/
|
||
return 0;
|
||
}
|
||
|
||
void fft842(int INN, int N, float *X, float *Y)
|
||
{
|
||
int I,IJ,JI,IPASS,IW,J,J1,J2,J3,J4,J5,J6,J7,J8,J9,J10,J11,J12,J13,J14,
|
||
LENGT,M,M1,M2,M3,M4,N2POW,N8POW,NT,NTHPO,NXTLT,L[15];
|
||
float FI,FN,R;
|
||
float XX[1025],YY[1025];
|
||
IW=0;
|
||
// PI2=8.*atan(1.);
|
||
// PI7=1./sqrt(2.);
|
||
for(I=1;I<=15;I++)
|
||
{
|
||
M=I;
|
||
NT=pow(2.0,I);
|
||
if(N == NT) goto L_20;
|
||
}
|
||
// exit(0);
|
||
L_20:
|
||
N2POW=M;
|
||
NTHPO=N;
|
||
FN=1.0f*NTHPO;
|
||
if(INN != 1)
|
||
{
|
||
for(I=0;I<NTHPO;I++)
|
||
Y[I]=-Y[I];
|
||
}
|
||
N8POW=N2POW/3;
|
||
if(N8POW != 0)
|
||
{
|
||
for(IPASS=0;IPASS<N8POW;IPASS++)
|
||
{
|
||
NXTLT=pow(2.0,N2POW-3*(IPASS+1));
|
||
LENGT=8*NXTLT;
|
||
r8tx(NXTLT,NTHPO,LENGT,X,Y);//
|
||
//X+NXTLT,X+NXTLT*2,X+NXTLT*3,X+NXTLT*4,X+NXTLT*5,X+NXTLT*6,
|
||
// X+NXTLT*7,Y,Y+NXTLT,Y+NXTLT*2,Y+NXTLT*3,Y+NXTLT*4,Y+NXTLT*5,Y+NXTLT*6,Y+NXTLT*7);
|
||
}
|
||
}
|
||
M1=N2POW-3*N8POW-1;
|
||
if(M1==0)
|
||
r2tx(NTHPO,X,Y);//X+1,Y,Y+1);
|
||
else if(M1>0)
|
||
r4tx(NTHPO,X,Y);//X+1,X+2,X+3,Y,Y+1,Y+2,Y+3);
|
||
for(J=1;J<=15;J++)
|
||
{
|
||
L[J-1]=1;
|
||
M2=J-N2POW;
|
||
if(M2 <=0 )
|
||
{
|
||
M3=N2POW-J+1;
|
||
L[J-1]=pow(2.0,M3);
|
||
}
|
||
}
|
||
IJ=1;
|
||
for(J1=1;J1<=N;J1++)
|
||
{
|
||
XX[J1]=X[J1-1];
|
||
YY[J1]=Y[J1-1];
|
||
}
|
||
for(J1=1;J1<=L[14];J1++)
|
||
{
|
||
for(J2=J1;J2<=L[13];J2+=L[14])
|
||
{
|
||
for(J3=J2;J3<=L[12];J3+=L[13])
|
||
{
|
||
for(J4=J3;J4<=L[11];J4+=L[12])
|
||
{
|
||
for(J5=J4;J5<=L[10];J5+=L[11])
|
||
{
|
||
for(J6=J5;J6<=L[9];J6+=L[10])
|
||
{
|
||
for(J7=J6;J7<=L[8];J7+=L[9])
|
||
{
|
||
for(J8=J7;J8<=L[7];J8+=L[8])
|
||
{
|
||
for(J9=J8;J9<=L[6];J9+=L[7])
|
||
{
|
||
for(J10=J9;J10<=L[5];J10+=L[6])
|
||
{
|
||
for(J11=J10;J11<=L[4];J11+=L[5])
|
||
{
|
||
for(J12=J11;J12<=L[3];J12+=L[4])
|
||
{
|
||
for(J13=J12;J13<=L[2];J13+=L[3])
|
||
{
|
||
for(J14=J13;J14<=L[1];J14+=L[2])
|
||
{
|
||
for(JI=J14;JI<=L[0];JI+=L[1])
|
||
{
|
||
M4=IJ-JI;
|
||
if(M4<0)
|
||
{
|
||
R=XX[IJ];
|
||
XX[IJ]=XX[JI];
|
||
XX[JI]=R;
|
||
FI=YY[IJ];
|
||
YY[IJ]=YY[JI];
|
||
YY[JI]=FI;
|
||
}
|
||
IJ++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//
|
||
for(J1=1;J1<=N;J1++)
|
||
{
|
||
X[J1-1]=XX[J1];
|
||
Y[J1-1]=YY[J1];
|
||
}
|
||
if(INN == 1)
|
||
{
|
||
for(I=0;I<NTHPO;I++)
|
||
{
|
||
X[I]=X[I]/FN;
|
||
Y[I]=Y[I]/FN;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for(I=0;I<NTHPO;I++)
|
||
Y[I]=-Y[I];
|
||
}
|
||
}
|
||
|
||
void r2tx(int NTHPO, float *CR0, float *CI0)//1, float *CI0, float *CI1)
|
||
{
|
||
int K;
|
||
float FI1,R1;
|
||
|
||
for(K=0;K<NTHPO;K+=2)
|
||
{
|
||
R1=CR0[K]+CR0[K+1];
|
||
CR0[K+1]=CR0[K]-CR0[K+1];
|
||
CR0[K]=R1;
|
||
FI1=CI0[K]+CI0[K+1];
|
||
CI0[K+1]=CI0[K]-CI0[K+1];
|
||
CI0[K]=FI1;
|
||
}
|
||
return;
|
||
}
|
||
|
||
void r4tx(int NTHPO, float *CR0, float *CI0)//, float *CR2, float *CR3, float *CI0, float *CI1, float *CI2, float *CI3)
|
||
{
|
||
int K;
|
||
float FI1,FI2,FI3,FI4,R1,R2,R3,R4;
|
||
|
||
for(K=0;K<NTHPO;K+=4)
|
||
{
|
||
R1=CR0[K]+CR0[K+2];
|
||
R2=CR0[K]-CR0[K+2];
|
||
R3=CR0[K+1]+CR0[K+3];
|
||
R4=CR0[K+1]-CR0[K+3];
|
||
FI1=CI0[K]+CI0[K+2];
|
||
FI2=CI0[K]-CI0[K+2];
|
||
FI3=CI0[K+1]+CI0[K+3];
|
||
FI4=CI0[K+1]-CI0[K+3];
|
||
CR0[K]=R1+R3;
|
||
CI0[K]=FI1+FI3;
|
||
CR0[K+1]=R1-R3;
|
||
CI0[K+1]=FI1-FI3;
|
||
CR0[K+2]=R2-FI4;
|
||
CI0[K+2]=FI2+R4;
|
||
CR0[K+3]=R2+FI4;
|
||
CI0[K+3]=FI2-R4;
|
||
}
|
||
}
|
||
void r8tx(int NXTLT,int NTHPO,int LENGT,float *CR0,float *CI0)
|
||
{
|
||
float PI2=8.*atan(1.);
|
||
float PI7=1./sqrt(2.);
|
||
int J,K;
|
||
float AI0,AI1,AI2,AI3,AI4,AI5,AI6,AI7,
|
||
AR0,AR1,AR2,AR3,AR4,AR5,AR6,AR7,
|
||
BI0,BI1,BI2,BI3,BI4,BI5,BI6,BI7,
|
||
BR0,BR1,BR2,BR3,BR4, BR5,BR6,BR7,
|
||
C1,C2,C3,C4,C5,C6,C7,S1,S2,S3,S4,S5,S6,S7,ARG,SCALE,TI,TR;
|
||
|
||
SCALE=PI2/LENGT;
|
||
for(J=0;J<NXTLT;J++)
|
||
{
|
||
ARG=J*SCALE;
|
||
C1=cos(ARG);
|
||
S1=sin(ARG);
|
||
C2=C1*C1-S1*S1;
|
||
S2=C1*S1+C1*S1;
|
||
C3=C1*C2-S1*S2;
|
||
S3=C2*S1+S2*C1;
|
||
C4=C2*C2-S2*S2;
|
||
S4=C2*S2+C2*S2;
|
||
C5=C2*C3-S2*S3;
|
||
S5=C3*S2+S3*C2;
|
||
C6=C3*C3-S3*S3;
|
||
S6=C3*S3+C3*S3;
|
||
C7=C3*C4-S3*S4;
|
||
S7=C4*S3+S4*C3;
|
||
for(K=J;K<NTHPO;K=K+LENGT)
|
||
{
|
||
AR0=CR0[K]+CR0[K+4*NXTLT];
|
||
AR1=CR0[K+NXTLT]+CR0[K+5*NXTLT];
|
||
AR2=CR0[K+2*NXTLT]+CR0[K+6*NXTLT];
|
||
AR3=CR0[K+3*NXTLT]+CR0[K+7*NXTLT];
|
||
AR4=CR0[K]-CR0[K+4*NXTLT];
|
||
AR5=CR0[K+NXTLT]-CR0[K+5*NXTLT];
|
||
AR6=CR0[K+2*NXTLT]-CR0[K+6*NXTLT];
|
||
AR7=CR0[K+3*NXTLT]-CR0[K+7*NXTLT];
|
||
AI0=CI0[K]+CI0[K+4*NXTLT];
|
||
AI1=CI0[K+NXTLT]+CI0[K+5*NXTLT];
|
||
AI2=CI0[K+2*NXTLT]+CI0[K+6*NXTLT];
|
||
AI3=CI0[K+3*NXTLT]+CI0[K+7*NXTLT];
|
||
AI4=CI0[K]-CI0[K+4*NXTLT];
|
||
AI5=CI0[K+NXTLT]-CI0[K+5*NXTLT];
|
||
AI6=CI0[K+2*NXTLT]-CI0[K+6*NXTLT];
|
||
AI7=CI0[K+3*NXTLT]-CI0[K+7*NXTLT];
|
||
BR0=AR0+AR2;
|
||
BR1=AR1+AR3;
|
||
BR2=AR0-AR2;
|
||
BR3=AR1-AR3;
|
||
BR4=AR4-AI6;
|
||
BR5=AR5-AI7;
|
||
BR6=AR4+AI6;
|
||
BR7=AR5+AI7;
|
||
BI0=AI0+AI2;
|
||
BI1=AI1+AI3;
|
||
BI2=AI0-AI2;
|
||
BI3=AI1-AI3;
|
||
BI4=AI4+AR6;
|
||
BI5=AI5+AR7;
|
||
BI6=AI4-AR6;
|
||
BI7=AI5-AR7;
|
||
CR0[K]=BR0+BR1;
|
||
CI0[K]=BI0+BI1;
|
||
if(J > 0)
|
||
{
|
||
CR0[K+NXTLT]=C4*(BR0-BR1)-S4*(BI0-BI1);
|
||
CI0[K+NXTLT]=C4*(BI0-BI1)+S4*(BR0-BR1);
|
||
CR0[K+2*NXTLT]=C2*(BR2-BI3)-S2*(BI2+BR3);
|
||
CI0[K+2*NXTLT]=C2*(BI2+BR3)+S2*(BR2-BI3);
|
||
CR0[K+3*NXTLT]=C6*(BR2+BI3)-S6*(BI2-BR3);
|
||
CI0[K+3*NXTLT]=C6*(BI2-BR3)+S6*(BR2+BI3);
|
||
TR=PI7*(BR5-BI5);
|
||
TI=PI7*(BR5+BI5);
|
||
CR0[K+4*NXTLT]=C1*(BR4+TR)-S1*(BI4+TI);
|
||
CI0[K+4*NXTLT]=C1*(BI4+TI)+S1*(BR4+TR);
|
||
CR0[K+5*NXTLT]=C5*(BR4-TR)-S5*(BI4-TI);
|
||
CI0[K+5*NXTLT]=C5*(BI4-TI)+S5*(BR4-TR);
|
||
TR=-PI7*(BR7+BI7);
|
||
TI=PI7*(BR7-BI7);
|
||
CR0[K+6*NXTLT]=C3*(BR6+TR)-S3*(BI6+TI);
|
||
CI0[K+6*NXTLT]=C3*(BI6+TI)+S3*(BR6+TR);
|
||
CR0[K+7*NXTLT]=C7*(BR6-TR)-S7*(BI6-TI);
|
||
CI0[K+7*NXTLT]=C7*(BI6-TI)+S7*(BR6-TR);
|
||
}
|
||
else
|
||
{
|
||
CR0[K+NXTLT]=BR0-BR1;
|
||
CI0[K+NXTLT]=BI0-BI1;
|
||
CR0[K+2*NXTLT]=BR2-BI3;
|
||
CI0[K+2*NXTLT]=BI2+BR3;
|
||
CR0[K+3*NXTLT]=BR2+BI3;
|
||
CI0[K+3*NXTLT]=BI2-BR3;
|
||
TR=PI7*(BR5-BI5);
|
||
TI=PI7*(BR5+BI5);
|
||
CR0[K+4*NXTLT]=BR4+TR;
|
||
CI0[K+4*NXTLT]=BI4+TI;
|
||
CR0[K+5*NXTLT]=BR4-TR;
|
||
CI0[K+5*NXTLT]=BI4-TI;
|
||
TR=-PI7*(BR7+BI7);
|
||
TI=PI7*(BR7-BI7);
|
||
CR0[K+6*NXTLT]=BR6+TR;
|
||
CI0[K+6*NXTLT]=BI6+TI;
|
||
CR0[K+7*NXTLT]=BR6-TR;
|
||
CI0[K+7*NXTLT]=BI6-TI;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
bool IsNum(CString str)
|
||
{
|
||
for(int i=0;i<str.GetLength();i++)
|
||
{
|
||
char c=str.GetAt(i);
|
||
if((c<='0'||c>='9')&&c!='.')
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool MiddleSmooth(float* _SourceData,int Count,int WindowLen)
|
||
{
|
||
using namespace std;
|
||
if (_SourceData == NULL) return false;
|
||
if (WindowLen < 2) return false;
|
||
if (Count < WindowLen) return false;
|
||
int DataCount = Count;
|
||
float* RetData = new float[DataCount];
|
||
for(int k=0;k<DataCount;k++)RetData[k]=_SourceData[k];
|
||
for (int i = WindowLen / 2; i < DataCount - WindowLen / 2; i++)
|
||
{
|
||
list <float> l;
|
||
for (int k = i - WindowLen / 2; k < i + WindowLen / 2 + 1; k++)l.push_back(RetData[k]);
|
||
l.sort();
|
||
for(int kk=0;kk<WindowLen / 2;kk++)l.pop_back();
|
||
_SourceData[i] =l.back();
|
||
}
|
||
delete RetData;
|
||
return true;
|
||
}
|
||
QStringList GetStringList(QByteArray line,bool IsSpa,bool IsTab,bool IsCom,bool IsSem,bool DelDubSpa)
|
||
{
|
||
QTextCodec *codec = QTextCodec::codecForName("UTF8");
|
||
if(!IsCom)line.replace(",","");//如果逗号不是分隔符，清除逗号
|
||
if(!IsSpa)line.replace(" ","");
|
||
else
|
||
{
|
||
//连续空格视为单个处理
|
||
if(DelDubSpa)while(line.indexOf(" ")>=0)line.replace(" "," ");
|
||
// line=line.simplified();
|
||
line.replace(" ",",");
|
||
}
|
||
if(!IsTab)line.replace(" ","");//tab
|
||
else line.replace(" ",",");
|
||
if(!IsSem)line.replace(";","");
|
||
else line.replace(";",",");
|
||
// line.remove("\r");
|
||
// line.remove("\n");
|
||
QList<QByteArray> list=line.split(',');
|
||
QStringList List;
|
||
for(int i=0;i<list.size();i++)
|
||
{
|
||
if(list[i].size()) {
|
||
unsigned char c=list[i].at(0)&0xe0;
|
||
if(c==0xe0)
|
||
{
|
||
List.append(codec->toUnicode(list[i],list[i].size()));
|
||
}
|
||
else List.append(list[i]);
|
||
}
|
||
}
|
||
return List;
|
||
}
|
||
void valueperlayers(float *csdata,int cs,float *grm,float*dep,int mpoint,float *resc,float*res,float gryz,int isDelerr)
|
||
{
|
||
float*grmlb=new float[mpoint];
|
||
int lbn,n,aa,bb;
|
||
int i,j,k;
|
||
//!异常值剔除
|
||
if(isDelerr) for(i=1;i<mpoint;i++)
|
||
{
|
||
if(grm[i]>1000.0||grm[i]<=20.0) grm[i]=grm[i-1];
|
||
}
|
||
|
||
//!光滑滤波（去除毛刺）
|
||
for(int i=0;i<mpoint;i++) grmlb[i]=grm[i];
|
||
lbn=10;
|
||
float yz=10.0;
|
||
for(i=lbn;i<mpoint-lbn;i++)
|
||
{
|
||
double sum=0;
|
||
for(int j=i-lbn-1;j<i+lbn;j++){
|
||
sum+=grm[j];
|
||
}
|
||
float temp=sum/(2.0*lbn+1);
|
||
if(grm[i]>=temp+yz||grm[i]<=temp-yz) grmlb[i]=temp;
|
||
}
|
||
lbn=2;
|
||
res=grmlb;
|
||
for(i=lbn;i<mpoint-lbn;i++)
|
||
{
|
||
double sum=0;
|
||
for(int j=i-lbn-1;j<i+lbn;j++){
|
||
sum+=grmlb[j];
|
||
}
|
||
res[i]=sum/(2.0*lbn+1.0);
|
||
}
|
||
for(j=0;j<cs;j++){
|
||
aa=0;
|
||
bb=0;
|
||
for(i=1;i<mpoint-1;i++){
|
||
if(csdata[j]>=dep[i]&&csdata[j]<=dep[i+1]) aa=i;
|
||
if(csdata[j+1]>=dep[i]&&csdata[j+1]<=dep[i+1]) bb=i;
|
||
}
|
||
float temp=0;
|
||
n=0;
|
||
for(k=aa;k<bb;k++){
|
||
n=n+1;
|
||
temp=temp+res[k];
|
||
}
|
||
temp=res[(int)(aa+bb)/2];// !取层中间点
|
||
resc[j]=temp;
|
||
for(k=aa-1;k<bb-1;k++){
|
||
res[k]=temp;
|
||
}
|
||
}
|
||
|
||
for(i=1;i<mpoint;i++){
|
||
if(fabs(res[i]-res[i-1])<=gryz) {
|
||
res[i]=res[i-1];
|
||
}
|
||
}
|
||
for(j=1;j<cs;j++){
|
||
if(fabs(resc[j]-resc[j-1])<=gryz){
|
||
resc[j]=resc[j-1];
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
float* AutoCreateLayers(float *ldepth,float*grm,int lnsamp,float minceng,int &count,float gryz,int n,int isdellerr)
|
||
{
|
||
float *lwdgr=new float[lnsamp];
|
||
float *slwd=new float[lnsamp];
|
||
float *ratio=new float[lnsamp];
|
||
float *gedge=new float[lnsamp];
|
||
float *gratio=new float[lnsamp];
|
||
float *dd=new float[lnsamp];
|
||
float *gpratio=new float[lnsamp];
|
||
float *cengph=new float[lnsamp];
|
||
float *edge=new float[lnsamp];
|
||
float *cenggr=new float[lnsamp];
|
||
float *pratio=new float[lnsamp];
|
||
float *zceng=new float[lnsamp];
|
||
for(int i=0;i<lnsamp;i++)
|
||
{
|
||
slwd[i]=grm[i];
|
||
}
|
||
float ldet=ldepth[2]-ldepth[1];
|
||
// !按视电阻率分层
|
||
// int n=10;// !窗长
|
||
for(int i=n/2;i<lnsamp-n/2-1;i++)
|
||
{
|
||
gratio[i]=0.0;
|
||
for(int j=1-1;j<n/2;j++)
|
||
{
|
||
gratio[i]=gratio[i]+slwd[j+i]-slwd[i-j];
|
||
}
|
||
gratio[i]=fabs(gratio[i])/n/(n+1)/ldet;
|
||
dd[i]=ldepth[i];
|
||
}
|
||
int mm=0;
|
||
int bbrla=1;
|
||
gedge[0]=ldepth[0];
|
||
for(int i=n/2;i<lnsamp-n/2-1;i++)
|
||
{
|
||
mm=mm+1;
|
||
gedge[mm]=ldepth[i];
|
||
gpratio[mm]=gratio[i];
|
||
gpratio[mm+1]=gratio[i+1];
|
||
if((gedge[mm]-gedge[0])>=minceng)
|
||
{
|
||
if(mm>=1){
|
||
if(((gpratio[mm-1]+0.0001)<=gpratio[mm])&&(gpratio[mm]>=(gpratio[mm+1]+0.0001)))
|
||
{
|
||
bbrla=bbrla+1;
|
||
cengph[bbrla-1]=gedge[mm];
|
||
cengph[bbrla]=gedge[mm]+0.01;
|
||
gedge[0]=gedge[mm];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cengph[0]=ldepth[0];
|
||
cengph[bbrla]=ldepth[lnsamp-1];
|
||
/*
|
||
//!按视自然伽马曲线gr分层
|
||
n=3;
|
||
for(int i=n/2;i<lnsamp-n/2-1;i++)
|
||
{
|
||
ratio[i]=0.0;
|
||
for(int j=0;j<n/2;j++)
|
||
{
|
||
ratio[i]=ratio[i]+lwdgr[j+i]-lwdgr[i-j];
|
||
}
|
||
ratio[i]=fabs(ratio[i])/n/(n+1)/ldet;
|
||
dd[i]=ldepth[i];
|
||
}
|
||
mm=0;
|
||
int bbgr=1;
|
||
edge[0]=ldepth[0];
|
||
for(int i=n/2;i<lnsamp-n/2-1;i++){
|
||
mm=mm+1;
|
||
edge[mm]=ldepth[i];
|
||
pratio[mm]=ratio[i];
|
||
pratio[mm+1]=ratio[i+1];
|
||
if((edge[mm]-edge[0])>=minceng){
|
||
if(mm>=1){
|
||
if(((pratio[mm-1]+0.0001)<=pratio[mm])&&(pratio[mm]>=(pratio[mm+1]+0.0001))){
|
||
bbgr=bbgr+1;
|
||
cenggr[bbgr-1]=edge[mm];
|
||
cenggr[bbgr]=edge[mm]+0.01;
|
||
edge[0]=edge[mm];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cenggr[0]=ldepth[0];
|
||
cenggr[bbgr]=ldepth[lnsamp-1];
|
||
|
||
count=-1;
|
||
zceng[0]=cengph[0];
|
||
for(int i=0;i<bbrla-1;i++)
|
||
{
|
||
count=count+1;
|
||
zceng[count]=cengph[i];
|
||
for(int ii=0;ii<bbgr-1;ii++)
|
||
{
|
||
if(((cenggr[ii]-cengph[i])>=minceng)
|
||
&&((cengph[i+1]-cenggr[ii])>=minceng)
|
||
&&((cenggr[ii]-cenggr[ii-1])>=minceng))
|
||
{
|
||
count=count+1;
|
||
zceng[count]=cenggr[ii];
|
||
}
|
||
}
|
||
}
|
||
zceng[count+1]=cengph[bbrla];
|
||
*/
|
||
count=-1;
|
||
zceng[0]=cengph[0];
|
||
for(int i=0;i<bbrla-1;i++)
|
||
{
|
||
count=count+1;
|
||
zceng[i]=cengph[i];
|
||
}
|
||
// count=count+1;
|
||
if(cengph[bbrla-1]>zceng[bbrla-2])zceng[count+1]=cengph[bbrla-1];
|
||
delete slwd;
|
||
delete gedge;
|
||
delete gratio;
|
||
delete dd;
|
||
delete gpratio;
|
||
delete cengph;
|
||
delete edge;
|
||
delete cenggr;
|
||
delete pratio;
|
||
if(gryz == 0) return zceng;
|
||
float* resc = new float[count+1];
|
||
float* res = new float[lnsamp];
|
||
if(gryz == 0)
|
||
gryz = 5;
|
||
float *nceng=new float[count+1];
|
||
valueperlayers(zceng,count-1,grm,ldepth,lnsamp,resc,res,gryz,isdellerr);
|
||
int ncount=0;
|
||
for(int i =0;i<count+1;i++)
|
||
{
|
||
if(resc[i]==resc[i+1]) continue;
|
||
nceng[ncount++] = zceng[i];
|
||
}
|
||
if(nceng[ncount-1]!=zceng[count+1])
|
||
{
|
||
nceng[ncount++] = zceng[count+1];
|
||
}
|
||
delete[] resc;
|
||
delete[] res;
|
||
delete zceng;
|
||
zceng=nceng;
|
||
count=ncount;
|
||
return zceng;
|
||
}
|
||
|
||
int CalculateDataNo(double* data1,int nsamp1,double data)
|
||
{
|
||
if(data >= data1[nsamp1-1])
|
||
return nsamp1-1;
|
||
|
||
if(data <= data1[0])
|
||
return 0;
|
||
|
||
int No = -1;
|
||
double min = 9999;
|
||
for(int j = 0;j<nsamp1;j++)
|
||
{
|
||
if(data1[j] - data > 0 && data1[j] - data < min)
|
||
{
|
||
min = data1[j] - data;
|
||
No = j;
|
||
//break;
|
||
}
|
||
}
|
||
return No;
|
||
}
|
||
int CalculateDataNo(float* data1,int nsamp1,double data)
|
||
{
|
||
if(data >= data1[nsamp1-1])
|
||
return nsamp1-1;
|
||
|
||
if(data <= data1[0])
|
||
return 0;
|
||
|
||
int No = -1;
|
||
double min = 9999;
|
||
for(int j = 0;j<nsamp1;j++)
|
||
{
|
||
if(data1[j] - data > 0 && data1[j] - data < min)
|
||
{
|
||
min = data1[j] - data;
|
||
No = j;
|
||
//break;
|
||
}
|
||
}
|
||
return No;
|
||
}
|
||
|
||
void CalculateLayer(double* DepthData,double* ResData,int nsamp,char* LayerPath,int LayerPathLeng,float MinVAL,float MaxVAL,float minLayerThick)
|
||
{
|
||
typedef void(*LAYERSCOMPUTE)(double*,double*,int,double,char*,int);
|
||
char bin[256];
|
||
QString bin1 = GetBinDir(bin);
|
||
bin1 += "\\app\\GetEveryLayerFillValue.dll";
|
||
QLibrary lib(bin1);
|
||
if (!lib.load())
|
||
{
|
||
QMessageBox::information(NULL,"","加载GetEveryLayerFillValue.dll失败！");
|
||
return;
|
||
}
|
||
|
||
LAYERSCOMPUTE lc=(LAYERSCOMPUTE)lib.resolve("LAYERSCOMPUTE");
|
||
if (!lc)
|
||
{
|
||
QMessageBox::information(NULL,"","获取LAYERSCOMPUTE函数失败！");
|
||
return;
|
||
}
|
||
|
||
if(MinVAL > MaxVAL)
|
||
{
|
||
float temp = MaxVAL;
|
||
MaxVAL = MinVAL;
|
||
MinVAL = temp;
|
||
}
|
||
|
||
int staNo,endNo;
|
||
staNo = CalculateDataNo(DepthData,nsamp,MinVAL);
|
||
endNo = CalculateDataNo(DepthData,nsamp,MaxVAL);
|
||
nsamp = endNo-staNo;
|
||
double* DepthData1 = new double[nsamp];
|
||
double* ResData1 = new double[nsamp];
|
||
for(int i = staNo;i<staNo+nsamp;i++)
|
||
{
|
||
DepthData1[i-staNo] = DepthData[i];
|
||
ResData1[i-staNo] = ResData[i];
|
||
}
|
||
|
||
double minceng =minLayerThick;//最小层厚
|
||
if(minceng == 0)
|
||
minceng = 0.5;
|
||
lc(DepthData1,ResData1,nsamp,minceng,LayerPath,LayerPathLeng);
|
||
|
||
delete[] DepthData1;
|
||
delete[] ResData1;
|
||
}
|
||
void CalculateLayer(float* DepthData,float* ResData,int nsamp,char* LayerPath,int LayerPathLeng,float MinVAL,float MaxVAL,float minLayerThick)
|
||
{
|
||
typedef void(*LAYERSCOMPUTE)(double*,double*,int,double,char*,int);
|
||
char bin[256];
|
||
QString bin1 = GetBinDir(bin);
|
||
bin1 += "\\app\\GetEveryLayerFillValue.dll";
|
||
QLibrary lib(bin1);
|
||
if (!lib.load())
|
||
{
|
||
QMessageBox::information(NULL,"","加载GetEveryLayerFillValue.dll失败！");
|
||
return;
|
||
}
|
||
|
||
LAYERSCOMPUTE lc=(LAYERSCOMPUTE)lib.resolve("LAYERSCOMPUTE");
|
||
if (!lc)
|
||
{
|
||
QMessageBox::information(NULL,"","获取LAYERSCOMPUTE函数失败！");
|
||
return;
|
||
}
|
||
|
||
if(MinVAL > MaxVAL)
|
||
{
|
||
float temp = MaxVAL;
|
||
MaxVAL = MinVAL;
|
||
MinVAL = temp;
|
||
}
|
||
|
||
int staNo,endNo;
|
||
staNo = CalculateDataNo(DepthData,nsamp,MinVAL);
|
||
endNo = CalculateDataNo(DepthData,nsamp,MaxVAL);
|
||
nsamp = endNo-staNo;
|
||
if(nsamp<1) return;
|
||
double* DepthData1 = new double[nsamp];
|
||
double* ResData1 = new double[nsamp];
|
||
for(int i = staNo;i<staNo+nsamp;i++)
|
||
{
|
||
DepthData1[i-staNo] = DepthData[i];
|
||
ResData1[i-staNo] = ResData[i];
|
||
}
|
||
|
||
double minceng =minLayerThick;//最小层厚
|
||
if(minceng == 0)
|
||
minceng = 0.5;
|
||
lc(DepthData1,ResData1,nsamp,minceng,LayerPath,LayerPathLeng);
|
||
|
||
delete[] DepthData1;
|
||
delete[] ResData1;
|
||
}
|
||
void InstValue(float outsdep,float enddepth,std::vector<float> &md,std::vector<float> &_AryCurve,std::vector<float>&curAry,float rlev,int DataPoint,bool isAngle,bool isJG)
|
||
{
|
||
int size = (enddepth - outsdep) / rlev + 1.5 + 1;
|
||
curAry.clear();
|
||
float curdepth=outsdep;
|
||
curAry.reserve(size*DataPoint);
|
||
int index=0;
|
||
int indf=0;
|
||
int inde=0;
|
||
float depthf=curdepth;
|
||
float depthe=enddepth;
|
||
DWORD point=0;
|
||
while (curdepth<=enddepth)
|
||
{
|
||
if(index==md.size()-1)
|
||
{
|
||
if(curdepth==enddepth)
|
||
{
|
||
for(int n=0;n<DataPoint;n++)
|
||
{
|
||
float v=_AryCurve[index*DataPoint+n];
|
||
if(isJG) {
|
||
v=100;
|
||
}
|
||
curAry.push_back(v);
|
||
}
|
||
point++;
|
||
curdepth=outsdep+point*rlev;
|
||
continue;
|
||
}
|
||
while(curdepth<=enddepth)
|
||
{
|
||
float v=-9999.0;
|
||
if(isJG) {
|
||
v=0;
|
||
}
|
||
curAry.push_back(v);
|
||
point++;
|
||
curdepth=outsdep+point*rlev;
|
||
}
|
||
break;
|
||
}
|
||
|
||
float depth1=md[index];
|
||
if(fabsf(curdepth-depth1)>=rlev) {
|
||
index++;
|
||
if (index>=md.size())
|
||
break;
|
||
if(md[index-1] < curdepth && md[index] > curdepth)//后步过界，回退
|
||
index--;
|
||
else if(curdepth<md[index-1]){
|
||
|
||
}
|
||
else {
|
||
if (index>=md.size())
|
||
break;
|
||
continue;
|
||
}
|
||
}
|
||
if(index+1>=md.size()) break;
|
||
float depth2=md[index+1];
|
||
float rate=0;
|
||
if(depth2==depth1) {
|
||
for(int n=0;n<DataPoint;n++)
|
||
{
|
||
float val0=_AryCurve[index*DataPoint+n];
|
||
curAry.push_back(val0);
|
||
}
|
||
}
|
||
else {
|
||
rate=(curdepth-depth1)/(depth2-depth1);
|
||
for(int n=0;n<DataPoint;n++)
|
||
{
|
||
float val0=_AryCurve[index*DataPoint+n];
|
||
float val1=_AryCurve[(index+1)*DataPoint+n];
|
||
if(val0==-9999||val1==-9999||val1==-999.25||val0==-999.25)
|
||
{
|
||
float v=-9999.0;
|
||
if(isJG) {
|
||
if(curdepth==depth1||curdepth==depth2) {
|
||
if(curdepth<depth1) v=-100;
|
||
else if(curdepth>=depth1) v=100;
|
||
}
|
||
else if(fabs((int)(curdepth*1000+0.5)/1000.0-(int)(depth1*1000+0.5)/1000.0)<rlev-0.0001)
|
||
{
|
||
if(curdepth<depth1) v=-100;
|
||
else if(curdepth>=depth1) v=100;
|
||
}
|
||
else if(fabs((int)(curdepth*1000+0.5)/1000.0-(int)(depth2*1000+0.5)/1000.0)<rlev-0.0001)
|
||
{
|
||
if(curdepth<depth1) v=-100;
|
||
else if(curdepth>=depth1) v=100;
|
||
}
|
||
else v=0;
|
||
}
|
||
curAry.push_back(v);
|
||
}
|
||
else
|
||
{
|
||
if(isAngle) {
|
||
if(curdepth<depth2) rate=0;
|
||
else rate=1;
|
||
}
|
||
float v=val0+rate*(val1-val0);
|
||
if(isJG) {
|
||
if(fabs(curdepth-depth1)<rlev)
|
||
{
|
||
if(curdepth<depth1) v=-100;
|
||
else if(curdepth>=depth1) v=100;
|
||
}
|
||
else v=0;
|
||
}
|
||
curAry.push_back(v);
|
||
}
|
||
}
|
||
}
|
||
if(curdepth > enddepth && curdepth < enddepth+rlev){
|
||
for(int n=0;n<DataPoint;n++)
|
||
{
|
||
float v = _AryCurve[index*DataPoint+n];
|
||
if(isJG) curAry.push_back(0);
|
||
else curAry.push_back(v);
|
||
}
|
||
}
|
||
point++;
|
||
curdepth=outsdep+point*rlev;
|
||
while(curdepth>=depth2) {
|
||
index++;
|
||
if(index+1>=md.size()) break;
|
||
depth2=md[index+1];
|
||
}
|
||
if(index>=md.size()) break;
|
||
}
|
||
int count=curAry.size()/DataPoint;
|
||
if(count<size)
|
||
{
|
||
for(int j=count;j<size;j++)
|
||
{
|
||
for(int n=0;n<DataPoint;n++)
|
||
{
|
||
float v=-9999.0;
|
||
if(isJG) {
|
||
v=0;
|
||
}
|
||
curAry.push_back(v);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
float Filt(float* b, float* Fil)
|
||
{
|
||
float num = 0.0f;
|
||
int index = 0;
|
||
do
|
||
{
|
||
if (index == 0)
|
||
num += b[5] * Fil[index];
|
||
else
|
||
num = (float) ((double) num + (double) b[ (5 + index)] * (double) Fil[index] + (double) b[ (5 - index)] * (double) Fil[index]);
|
||
{ ++index; }
|
||
}
|
||
while (index <= 5);
|
||
return num;
|
||
}
|
||
|
||
void FilterCurve(
|
||
float* inpcurve,
|
||
enumFilterType Ftype,
|
||
int numrec,
|
||
float* fUDef,
|
||
float Empty)
|
||
{
|
||
float* numArray1 = new float[6];
|
||
float* numArray2 = new float[6];
|
||
float* numArray3 = new float[6];
|
||
float* numArray4 = new float[6];
|
||
float* numArray5 = new float[6];
|
||
float* b = new float[11];
|
||
float* numArray6 = new float[6];
|
||
numArray1[0] = 0.3292f;
|
||
numArray1[1] = 0.254f;
|
||
numArray1[2] = 0.1021f;
|
||
numArray1[3] = -0.0073f;
|
||
numArray1[4] = -0.017f;
|
||
numArray1[5] = 0.0036f;
|
||
numArray2[0] = 3.0f / 16.0f;
|
||
numArray2[1] = 0.1704f;
|
||
numArray2[2] = 0.1266f;
|
||
numArray2[3] = 0.0735f;
|
||
numArray2[4] = 0.0298f;
|
||
numArray2[5] = 0.0059f;
|
||
numArray3[0] = 0.14272f;
|
||
numArray3[1] = 0.1217f;
|
||
numArray3[2] = 0.11401f;
|
||
numArray3[3] = 0.09303f;
|
||
numArray3[4] = 0.06583f;
|
||
numArray3[5] = 89.0f / (961.0f * 2.71828);
|
||
float* numArray7 = fUDef;
|
||
numArray5[0] = 1.0f;
|
||
numArray5[1] = 0.0f;
|
||
numArray5[2] = 0.0f;
|
||
numArray5[3] = 0.0f;
|
||
numArray5[4] = 0.0f;
|
||
numArray5[5] = 0.0f;
|
||
float* numArray8 = new float[ (numrec + 1)];
|
||
float* Fil;
|
||
switch (Ftype)
|
||
{
|
||
case enumFilterType::fltWeak:
|
||
Fil = numArray1;
|
||
break;
|
||
case enumFilterType::fltNormal:
|
||
Fil = numArray2;
|
||
break;
|
||
case enumFilterType::fltStrong:
|
||
Fil = numArray3;
|
||
break;
|
||
case enumFilterType::fltUDef:
|
||
Fil = numArray7;
|
||
break;
|
||
case enumFilterType::fltNone:
|
||
Fil = numArray5;
|
||
break;
|
||
default:
|
||
int num1 = 0;//(int) Interaction.MsgBox((object) "Wrong Filter Type! Filter Set to Weak!");
|
||
Fil = numArray1;
|
||
break;
|
||
}
|
||
int num2 = numrec;
|
||
int index1 = 1;
|
||
while (index1 <= num2)
|
||
{
|
||
if ((double) inpcurve[index1] == (double) Empty)
|
||
{
|
||
numArray8[index1] = Empty;
|
||
}
|
||
else
|
||
{
|
||
int index2 = -1;
|
||
int num3 = (index1 - 5);
|
||
int num4 = (index1 + 5);
|
||
int index3 = num3;
|
||
while (index3 <= num4)
|
||
{
|
||
{ ++index2; }
|
||
b[index2] = !(index3 < 1 | index3 > numrec) ? ((double) inpcurve[index3] != (double) Empty ? inpcurve[index3] : inpcurve[index1]) : inpcurve[index1];
|
||
{ ++index3; }
|
||
}
|
||
numArray8[index1] = Filt(b, Fil);
|
||
}
|
||
{ ++index1; }
|
||
}
|
||
for(int i=0;i<numrec;i++) inpcurve[i] = numArray8[i+1];
|
||
delete numArray1;
|
||
delete numArray2;
|
||
delete numArray3;
|
||
delete numArray4;
|
||
delete numArray5;
|
||
delete b;
|
||
delete numArray6;
|
||
delete numArray8;
|
||
}
|
||
|
||
float FilterValue(
|
||
float* inpcurve,
|
||
enumFilterType Ftype,
|
||
float* fUDef,
|
||
float Empty)
|
||
{
|
||
float* numArray1 = new float[6];
|
||
float* numArray2 = new float[6];
|
||
float* numArray3 = new float[6];
|
||
float* numArray4 = new float[6];
|
||
float* numArray5 = new float[6];
|
||
float* numArray6 = new float[11];
|
||
float* numArray7 = new float[6];
|
||
numArray1[0] = 0.3292f;
|
||
numArray1[1] = 0.254f;
|
||
numArray1[2] = 0.1021f;
|
||
numArray1[3] = -0.0073f;
|
||
numArray1[4] = -0.017f;
|
||
numArray1[5] = 0.0036f;
|
||
numArray2[0] = 3.0f / 16.0f;
|
||
numArray2[1] = 0.1704f;
|
||
numArray2[2] = 0.1266f;
|
||
numArray2[3] = 0.0735f;
|
||
numArray2[4] = 0.0298f;
|
||
numArray2[5] = 0.0059f;
|
||
numArray3[0] = 0.14272f;
|
||
numArray3[1] = 0.1217f;
|
||
numArray3[2] = 0.11401f;
|
||
numArray3[3] = 0.09303f;
|
||
numArray3[4] = 0.06583f;
|
||
numArray3[5] = 89.0f / (961.0f * 2.71828);
|
||
float* numArray8 = fUDef;
|
||
numArray5[0] = 1.0f;
|
||
numArray5[1] = 0.0f;
|
||
numArray5[2] = 0.0f;
|
||
numArray5[3] = 0.0f;
|
||
numArray5[4] = 0.0f;
|
||
numArray5[5] = 0.0f;
|
||
float* Fil;
|
||
switch (Ftype)
|
||
{
|
||
case enumFilterType::fltWeak:
|
||
Fil = numArray1;
|
||
break;
|
||
case enumFilterType::fltNormal:
|
||
Fil = numArray2;
|
||
break;
|
||
case enumFilterType::fltStrong:
|
||
Fil = numArray3;
|
||
break;
|
||
case enumFilterType::fltUDef:
|
||
Fil = numArray8;
|
||
break;
|
||
case enumFilterType::fltNone:
|
||
Fil = numArray5;
|
||
break;
|
||
default:
|
||
int num = 0;//(int) Interaction.MsgBox((object) "Wrong Filter Type! Filter Set to Weak!");
|
||
Fil = numArray1;
|
||
break;
|
||
}
|
||
return Filt(inpcurve, Fil);
|
||
delete numArray1;
|
||
delete numArray2;
|
||
delete numArray3;
|
||
delete numArray4;
|
||
delete numArray5;
|
||
delete numArray6;
|
||
delete numArray7;
|
||
}
|
||
void FilterMatrixV(
|
||
float** inpcurve,
|
||
enumFilterType Ftype,
|
||
int numrec,
|
||
int numChannel,
|
||
float* fUDef,
|
||
float Empty)
|
||
{
|
||
float* numArray1 = new float[6];
|
||
float* numArray2 = new float[6];
|
||
float* numArray3 = new float[6];
|
||
float* numArray4 = new float[6];
|
||
float* b = new float[11];
|
||
float* numArray5 = new float[6];
|
||
numArray1[0] = 0.3292f;
|
||
numArray1[1] = 0.254f;
|
||
numArray1[2] = 0.1021f;
|
||
numArray1[3] = -0.0073f;
|
||
numArray1[4] = -0.017f;
|
||
numArray1[5] = 0.0036f;
|
||
numArray2[0] = 3.0f / 16.0f;
|
||
numArray2[1] = 0.1704f;
|
||
numArray2[2] = 0.1266f;
|
||
numArray2[3] = 0.0735f;
|
||
numArray2[4] = 0.0298f;
|
||
numArray2[5] = 0.0059f;
|
||
numArray3[0] = 0.14272f;
|
||
numArray3[1] = 0.1217f;
|
||
numArray3[2] = 0.11401f;
|
||
numArray3[3] = 0.09303f;
|
||
numArray3[4] = 0.06583f;
|
||
numArray3[5] = 89.0f / (961.0f * 2.71828);
|
||
float* numArray6 = fUDef;
|
||
float** numArray7 = new float*[ (numrec + 1)];
|
||
for(int j=0;j<numrec+1;j++) {
|
||
numArray7[j] = new float[(numChannel + 1)];
|
||
}
|
||
float* Fil;
|
||
switch (Ftype)
|
||
{
|
||
case enumFilterType::fltWeak:
|
||
Fil = numArray1;
|
||
break;
|
||
case enumFilterType::fltNormal:
|
||
Fil = numArray2;
|
||
break;
|
||
case enumFilterType::fltStrong:
|
||
Fil = numArray3;
|
||
break;
|
||
case enumFilterType::fltUDef:
|
||
Fil = numArray6;
|
||
break;
|
||
default:
|
||
int num1 =0;// (int) Interaction.MsgBox((object) "Wrong Filter Type! Filter Set to Weak!");
|
||
Fil = numArray1;
|
||
break;
|
||
}
|
||
int num2 = numChannel;
|
||
int index1 = 1;
|
||
while (index1 <= num2)
|
||
{
|
||
int num3 = numrec;
|
||
int index2 = 1;
|
||
while (index2 <= num3)
|
||
{
|
||
if ((double) inpcurve[index2][index1] == (double) Empty)
|
||
{
|
||
numArray7[index2][index1] = Empty;
|
||
}
|
||
else
|
||
{
|
||
int index3 = -1;
|
||
int num4 = (index2 - 5);
|
||
int num5 = (index2 + 5);
|
||
int index4 = num4;
|
||
while (index4 <= num5)
|
||
{
|
||
{ ++index3; }
|
||
b[index3] = !(index4 < 1 | index4 > numrec) ? ((double) inpcurve[index4][index1] != (double) Empty ? inpcurve[index4][index1] : inpcurve[index2][index1]) : inpcurve[index2][index1];
|
||
{ ++index4; }
|
||
}
|
||
numArray7[index2][index1] = Filt(b, Fil);
|
||
}
|
||
{ ++index2; }
|
||
}
|
||
{ ++index1; }
|
||
}
|
||
for(int i=0;i<numrec+1;i++) {
|
||
for(int j=0;j<numChannel+1;j++) inpcurve[i][j] = numArray7[i][j];
|
||
}
|
||
for(int j=0;j<numrec+1;j++) delete numArray7[j];
|
||
delete numArray1;
|
||
delete numArray2;
|
||
delete numArray3;
|
||
delete numArray4;
|
||
delete b;
|
||
delete numArray5;
|
||
}
|
||
|
||
void FilterMatrixH(
|
||
float** inpcurve,
|
||
enumFilterType Ftype,
|
||
int numrec,
|
||
int numChannel,
|
||
float* fUDef,
|
||
float Empty)
|
||
{
|
||
float* numArray1 = new float[6];
|
||
float* numArray2 = new float[6];
|
||
float* numArray3 = new float[6];
|
||
float* numArray4 = new float[6];
|
||
float* b = new float[11];
|
||
float* numArray5 = new float[6];
|
||
numArray1[0] = 0.3292f;
|
||
numArray1[1] = 0.254f;
|
||
numArray1[2] = 0.1021f;
|
||
numArray1[3] = -0.0073f;
|
||
numArray1[4] = -0.017f;
|
||
numArray1[5] = 0.0036f;
|
||
numArray2[0] = 3.0f / 16.0f;
|
||
numArray2[1] = 0.1704f;
|
||
numArray2[2] = 0.1266f;
|
||
numArray2[3] = 0.0735f;
|
||
numArray2[4] = 0.0298f;
|
||
numArray2[5] = 0.0059f;
|
||
numArray3[0] = 0.14272f;
|
||
numArray3[1] = 0.1217f;
|
||
numArray3[2] = 0.11401f;
|
||
numArray3[3] = 0.09303f;
|
||
numArray3[4] = 0.06583f;
|
||
numArray3[5] = 89.0f / (961.0f * 2.71828);
|
||
float* numArray6 = fUDef;
|
||
float** numArray7 = new float*[ (numrec + 1)];
|
||
for(int j=0;j<numrec+1;j++) {
|
||
numArray7[j] = new float[(numChannel + 1)];
|
||
}
|
||
float* Fil;
|
||
switch (Ftype)
|
||
{
|
||
case enumFilterType::fltWeak:
|
||
Fil = numArray1;
|
||
break;
|
||
case enumFilterType::fltNormal:
|
||
Fil = numArray2;
|
||
break;
|
||
case enumFilterType::fltStrong:
|
||
Fil = numArray3;
|
||
break;
|
||
case enumFilterType::fltUDef:
|
||
Fil = numArray6;
|
||
break;
|
||
default:
|
||
int num1 =0;// (int) Interaction.MsgBox((object) "Wrong Filter Type! Filter Set to Weak!");
|
||
Fil = numArray1;
|
||
break;
|
||
}
|
||
int num2 = numrec;
|
||
int index1 = 1;
|
||
while (index1 <= num2)
|
||
{
|
||
int num3 = numChannel;
|
||
int index2 = 1;
|
||
while (index2 <= num3)
|
||
{
|
||
if ((double) inpcurve[index1][index2] == (double) Empty)
|
||
{
|
||
numArray7[index1][index2] = Empty;
|
||
}
|
||
else
|
||
{
|
||
int index3 = -1;
|
||
int num4 = (index2 - 5);
|
||
int num5 = (index2 + 5);
|
||
int index4 = num4;
|
||
while (index4 <= num5)
|
||
{
|
||
{ ++index3; }
|
||
b[index3] = !(index4 < 1 | index4 > numChannel) ? ((double) inpcurve[index1][index4] != (double) Empty ? inpcurve[index1][index4] : inpcurve[index1][index2]) : inpcurve[index1][index2];
|
||
{ ++index4; }
|
||
}
|
||
numArray7[index1][index2] = Filt(b, Fil);
|
||
}
|
||
{ ++index2; }
|
||
}
|
||
{ ++index1; }
|
||
}
|
||
for(int i=0;i<numrec+1;i++) {
|
||
for(int j=0;j<numChannel+1;j++) inpcurve[i][j] = numArray7[i][j];
|
||
}
|
||
for(int j=0;j<numrec+1;j++) delete numArray7[j];
|
||
delete numArray1;
|
||
delete numArray2;
|
||
delete numArray3;
|
||
delete numArray4;
|
||
delete b;
|
||
delete numArray5;
|
||
}
|
||
|
||
float Sigma(float* x,int Length, float dt, float Min)
|
||
{
|
||
float num1 = dt / 2.0f;
|
||
int num2 = 0;
|
||
float num3 = 0.0f;
|
||
float x1 = 0.0f;
|
||
float num4 = 0.0f;
|
||
float num5 = 0.0f;
|
||
int num6 = (Length - 1);
|
||
int index = 1;
|
||
while (index <= num6)
|
||
{
|
||
if ((double) x[index] > (double) Min)
|
||
{
|
||
float num7 = (float) log((double) x[index]);
|
||
float x2 = (float) index * dt - num1;
|
||
num3 += num7;
|
||
x1 += x2;
|
||
num5 += x2 * num7;
|
||
num4 += (float) pow((double) x2, 2.0);
|
||
{ ++num2; }
|
||
}
|
||
{ ++index; }
|
||
}
|
||
return !(num2 <= 0 | (double) num2 * (double) num4 - pow((double) x1, 2.0) == 0.0) ? (float) (abs(((double) num2 * (double) num5 - (double) x1 * (double) num3) / ((double) num2 * (double) num4 - pow((double) x1, 2.0))) * 4550.0) : -9999.0f;
|
||
}
|
||
|
||
float Sigma(float* x, float dt, int fromI, int toI, float Min)
|
||
{
|
||
float* x1 = new float[ (toI - fromI + 1 + 1)];
|
||
int index1 = 0;
|
||
int num1 = fromI;
|
||
int num2 = toI;
|
||
int index2 = num1;
|
||
while (index2 <= num2)
|
||
{
|
||
{ ++index1; }
|
||
x1[index1] = x[index2];
|
||
{ ++index2; }
|
||
}
|
||
float val=Sigma(x1,(toI - fromI + 1 + 1), dt, Min);
|
||
delete x1;
|
||
return val;
|
||
}
|
||
void linearSmooth7( float in[], float out[], int N, float rate[], int count ){
|
||
float *temp = new float[N];
|
||
for(int j = 0; j < N; j++)
|
||
temp[j] = in[j];
|
||
float tmpY;
|
||
for(int c = 0; c < count; c++){
|
||
int i;
|
||
if (N <= 7)
|
||
for ( i = 0; i < N; i++ ) out[i] = temp[i];
|
||
else{
|
||
out[0] = temp[0];
|
||
out[1] = temp[1];
|
||
out[2] = temp[2];
|
||
for (int i = 3; i <= N - 4; i++){
|
||
tmpY = (rate[0] * temp[i-3] + rate[1] * temp[i-2] + rate[2] *temp[i-1] + rate[3] *temp[i] + rate[4] * temp[i+1] + rate[5] * temp[i+2] + rate[6] * temp[i+3]) / 7.0;
|
||
out[i] = tmpY;
|
||
}
|
||
out[N - 3] = temp[N - 3];
|
||
out[N - 2] = temp[N - 2];
|
||
out[N - 1] = temp[N - 1];
|
||
}
|
||
for(int j = 0; j < N; j++)
|
||
temp[j] = out[j];
|
||
}
|
||
|
||
delete []temp;
|
||
}
|
||
void linearSmooth3( float in[], float out[], int N, float rate[], int count){
|
||
float *temp = new float[N];
|
||
for(int j = 0; j < N; j++)
|
||
temp[j] = in[j];
|
||
|
||
for(int c = 0; c < count; c++){
|
||
int i;
|
||
if ( N < 3 ){
|
||
for ( i = 0; i <= N - 1; i++ )
|
||
out[i] = temp[i];
|
||
}
|
||
else{
|
||
out[0] = ( 5.0 * temp[0] + 2.0 * temp[1] - temp[2] ) / 6.0;
|
||
for ( i = 1; i <= N - 2; i++ )
|
||
out[i] = ( rate[0] * temp[i - 1] + rate[1] * temp[i] + rate[2] * temp[i + 1] ) / 3.0;
|
||
out[N - 1] = ( 5.0 * temp[N - 1] + 2.0 * temp[N - 2] - temp[N - 3] ) / 6.0;
|
||
}
|
||
for(int j = 0; j < N; j++)
|
||
temp[j] = out[j];
|
||
}
|
||
delete []temp;
|
||
}
|
||
void linearSmooth5( float in[], float out[], int N, float rate[], int count ){
|
||
float *temp = new float[N];
|
||
for(int j = 0; j < N; j++)
|
||
temp[j] = in[j];
|
||
|
||
for(int c = 0; c < count; c++){
|
||
int i;
|
||
if (N <= 5)
|
||
for ( i = 0; i < N; i++ ) out[i] = temp[i];
|
||
else{
|
||
float tmpY = (3.0 * temp[0] + 2.0 * temp[1] + temp[2] - temp[4]) / 5.0;
|
||
out[0] = tmpY;
|
||
tmpY = (4.0 * temp[0] + 3.0 * temp[1] + 2 * temp[2] + temp[3]) / 10.0;
|
||
out[1] = tmpY;
|
||
for (int i = 2; i <= N - 3; i++){
|
||
tmpY = (rate[0] * temp[i - 2] + rate[1] * temp[i - 1] + rate[2] *temp[i] + rate[3] *temp[i + 1] + rate[4] * temp[i + 2]) / 5.0;
|
||
out[i] = tmpY;
|
||
}
|
||
tmpY = (4.0 * temp[N - 1] + 3.0 * temp[N - 2] + 2 * temp[N - 3] + temp[N - 4]) / 10.0;
|
||
out[N - 2] = tmpY;
|
||
tmpY = (3.0 * temp[N - 1] + 2.0 * temp[N - 2] + temp[N - 3] - temp[N - 5]) / 5.0;
|
||
out[N - 1] = tmpY;
|
||
}
|
||
for(int j = 0; j < N; j++)
|
||
temp[j] = out[j];
|
||
}
|
||
|
||
delete []temp;
|
||
}
|
||
|
||
void DataSmooth(int cal,int mode,float *in,float *out,int n,int count)
|
||
{
|
||
float rate[7];
|
||
if(cal == 0)
|
||
for(int i = 0; i < 7; i++)
|
||
rate[i] = 1;
|
||
else if(cal == 2){
|
||
if(mode == 0){rate[0] = 0.5;rate[1] = 2;rate[2] = 0.5;}
|
||
else if(mode == 1){rate[0] = 0.4;rate[1] = 0.85;rate[2] = 2.5;rate[3] = 0.85;rate[4] = 0.4;}
|
||
else if(mode == 2){rate[0] = 0.25;rate[1] = 0.5;rate[2] = 1;rate[3] = 3.5;rate[4] = 1;rate[5] = 0.5;rate[6] = 0.25;}
|
||
}
|
||
else if(cal == 3){
|
||
if(mode == 0){rate[0] = 1.25;rate[1] = 0.5;rate[2] = 1.25;}
|
||
else if(mode == 1){rate[0] = 1.3;rate[1] = 0.9;rate[2] = 0.6;rate[3] = 0.9;rate[4] = 1.3;}
|
||
else if(mode == 2){rate[0] = 1.75;rate[1] = 0.9;rate[2] = 0.6;rate[3] = 0.5;rate[4] = 0.6;rate[5] = 0.9;rate[6] = 1.75;}
|
||
}
|
||
|
||
switch(mode){
|
||
case 0:
|
||
linearSmooth3(in, out, n, rate, count);
|
||
break;
|
||
case 1:
|
||
linearSmooth5(in, out, n, rate, count);
|
||
break;
|
||
case 2:
|
||
linearSmooth7(in, out, n, rate, count);
|
||
break;
|
||
}
|
||
}
|
||
void qsort(char**datx,int left,int right,int idx,int len,int pos)
|
||
{
|
||
if(right<left+1) return;
|
||
|
||
int i,j;
|
||
float x,y;
|
||
|
||
i=left;
|
||
j=right;
|
||
x=*(float*)(&datx[(left+right)/2][0]+pos);
|
||
|
||
do
|
||
{
|
||
if(idx==0)
|
||
{
|
||
while(*(float*)(&datx[i][0]+pos)<x && i<right) i++;
|
||
while(*(float*)(&datx[j][0]+pos)>x && j>left ) j--;
|
||
}
|
||
else
|
||
{
|
||
while(*(float*)(&datx[i][0]+pos)>x && i<right) i++;
|
||
while(*(float*)(&datx[j][0]+pos)<x && j>left ) j--;
|
||
}
|
||
if(i<=j)
|
||
{
|
||
char *yy=datx[i];
|
||
datx[i]=datx[j];
|
||
datx[j]=yy;
|
||
i++;j--;
|
||
}
|
||
} while(i<=j);
|
||
if(left<j) qsort(datx,left,j,idx,len,pos);
|
||
if(i<right) qsort(datx,i,right,idx,len,pos);
|
||
}
|
||
void qsort(QStringList &datx,float *daty,int left,int right,int idx)
|
||
{
|
||
if(right<left+1) return;
|
||
|
||
int i,j;
|
||
float x,y;
|
||
|
||
i=left;
|
||
j=right;
|
||
x=datx[(left+right)/2].length();
|
||
|
||
do
|
||
{
|
||
if(idx==0)
|
||
{
|
||
while(datx[i].length()<x && i<right) i++;
|
||
while(datx[j].length()>x && j>left ) j--;
|
||
}
|
||
else
|
||
{
|
||
while(datx[i].length()>x && i<right) i++;
|
||
while(datx[j].length()<x && j>left ) j--;
|
||
}
|
||
if(i<=j)
|
||
{
|
||
QString xx=datx[i];
|
||
datx[i]=datx[j];
|
||
datx[j]=xx;
|
||
float yy=daty[i];
|
||
daty[i]=daty[j];
|
||
daty[j]=yy;
|
||
i++;j--;
|
||
}
|
||
} while(i<=j);
|
||
if(left<j) qsort(datx,daty,left,j,idx);
|
||
if(i<right) qsort(datx,daty,i,right,idx);
|
||
}
|
||
void qsort_int(char**datx,int left,int right,int idx,int len,int pos)
|
||
{
|
||
if(right<left+1) return;
|
||
|
||
int i,j;
|
||
float x,y;
|
||
|
||
i=left;
|
||
j=right;
|
||
x=*(int*)(&datx[(left+right)/2][0]+pos);
|
||
|
||
do
|
||
{
|
||
if(idx==0)
|
||
{
|
||
while(*(int*)(&datx[i][0]+pos)<x && i<right) i++;
|
||
while(*(int*)(&datx[j][0]+pos)>x && j>left ) j--;
|
||
}
|
||
else
|
||
{
|
||
while(*(int*)(&datx[i][0]+pos)>x && i<right) i++;
|
||
while(*(int*)(&datx[j][0]+pos)<x && j>left ) j--;
|
||
}
|
||
if(i<=j)
|
||
{
|
||
char *yy=datx[i];
|
||
datx[i]=datx[j];
|
||
datx[j]=yy;
|
||
i++;j--;
|
||
}
|
||
} while(i<=j);
|
||
if(left<j) qsort_int(datx,left,j,idx,len,pos);
|
||
if(i<right) qsort_int(datx,i,right,idx,len,pos);
|
||
}
|
||
|