filter_utils.c

图像处理的压缩算法

/*------------------------------------------------------------------------------*
 * File Name: filter_utils.c 													*
 * Creation: 																	*
 * Purpose:  functions for working with filters									*
 * Copyright (c)2003 OriginLab Corp.											*
 * All Rights Reserved															*
 * 																				*
 * Modification Log:															*
 * EJP 07-07-2003 v7.0619 QA70-4783 POST_IMPORT_EXECUTE							*
 * EJP 07-17-2003 v7.0627 QA70-4818 SAVE_FILTER_IN_WKS							*
 * EJP 07-22-2003 v7.0631 QA70-4073 USE_DATAFOLDER_FILTER_WHEN_ONLY_1_APPLICABLE*
 * EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP						*
 * EJP 09-09-2003 v7.5689 QA70-4818 UPDATE_ASCIMP_FROM_FILTER_SAVED_TO_WKS		*
 * EJP 09-24-2003 v7.5706 QA70-4073.55 ADD_FILTER_DESCRIPTION					*
 *------------------------------------------------------------------------------*/
 
#include <origin.h>
#include "Filter_Utils.h"
#include "App_Utils.h"
#include "OSelFilter.h"
#include <tree_utils.h>

// Include definitions of all localized strings. $ causes CodeBuilder to look for 
// correct version of Local.h depending on Windows Regional settings.
#include "$Local.h"


#define FILTER_HEADERPARAM_DEFINED		"Defined"

//------------------------------------------------------------
void fuPrepareDefault(TreeNode& trFilter)
{
	trFilter.Reset();

	trFilter.Type.nVal = FILTER_TYPE_ASCII;

	//---------- Common Settings based on ASCII being the default Type
	trFilter.Common.OCFile.Text = FILTER_ASCII_OCFILE;
	trFilter.Common.OCFunction.Text = FILTER_ASCII_OCFUNCTION;

	//---------- Common ASCIMP/BINIMP Settings
	fuSetImportMode(trFilter, ASCIMP_MODE_REPLACE_DATA);
	fuSetApplyRangeToGraph(trFilter, FALSE);
	trFilter.Common.Partial.nVal = 0;
	trFilter.Common.PartialC1.nVal = 0;
	trFilter.Common.PartialC2.nVal = -1;
	trFilter.Common.PartialR1.nVal = 0;
	trFilter.Common.PartialR2.nVal = -1;
	trFilter.Common.LinkWks.nVal = 0;
	trFilter.Common.RenameWks.nVal = 0;

	//---------- Common Other Settings
	fuSetDesignations(trFilter, "XY");
	fuSetRepetitive(trFilter, FALSE);
	fuSetFormats(trFilter, "9");
	fuSetPlotID(trFilter, IDM_PLOT_LINE);
	fuSetTargetWindow(trFilter, EXIST_WKS);
	
	//---------- ASCII Settings
	ASCIMP ascimp = {0};
	ascimp.iDelimited = 1;
	ascimp.iApplyRange = 0;
	fuSetASCIMP(trFilter, ascimp);
	
	//---------- Binary Settings
	BINIMP binimp = {0};
	fuSetBINIMP(trFilter, binimp);
}

//------------------------------------------------------------
int fuGetFilterType(TreeNode& trFilter)
{
	return tree_node_get_int(trFilter.Type, FILTER_TYPE_UNKNOWN);
}

bool fuGetFilterType(TreeNode &trFilter, string &strType)
{
	int iType = fuGetFilterType(trFilter);
	if( IS_FILTER_TYPE(iType) )
	{
		switch( iType )
		{
		case FILTER_TYPE_ASCII:
			strType = "ASCII";
			break;
		case FILTER_TYPE_BINARY:
			strType = "Binary";
			break;
		case FILTER_TYPE_USERDEFINED:
			strType = "User Defined";
			break;
		}
		return true;
	}
	return false;
}

//------------------------------------------------------------
BOOL fuIsRenameWks(TreeNode& trFilter)
{
	if( trFilter.Common && trFilter.Common.RenameWks )
		return trFilter.Common.RenameWks.nVal;
	return FALSE;
}

//------------------------------------------------------------
void fuSetRepetitive(TreeNode& trFilter, BOOL bRepetitive)
{
	trFilter.Common.ColDesignationsRepetitive.nVal = bRepetitive;
}

BOOL fuGetRepetitive(TreeNode& trFilter)
{
	if( trFilter.Common.ColDesignationsRepetitive )
		return trFilter.Common.ColDesignationsRepetitive.nVal;
	return FALSE; // default is off
}

//------------------------------------------------------------
void fuSetImportMode(TreeNode& trFilter, int iImportMode)
{
	if( !IS_IMPORT_MODE(iImportMode) )
		iImportMode = ASCIMP_MODE_REPLACE_DATA;
	trFilter.Common.ImportMode.nVal = iImportMode;
}

int fuGetImportMode(TreeNode& trFilter)
{
	if( trFilter.Common.ImportMode )
	{
		if( IS_IMPORT_MODE(trFilter.Common.ImportMode.nVal) )
			return trFilter.Common.ImportMode.nVal;
	}
	return ASCIMP_MODE_REPLACE_DATA;
}

//------------------------------------------------------------
BOOL fuGetApplyRangeToGraph(TreeNode& trFilter)
{
	if( trFilter.Common.ApplyRangeToGraph )
		return trFilter.Common.ApplyRangeToGraph.nVal;
	return FALSE; // default is off
}

void fuSetApplyRangeToGraph(TreeNode& trFilter, BOOL bEnable)
{
	trFilter.Common.ApplyRangeToGraph.nVal = bEnable;
}

//------------------------------------------------------------
void fuSetASCIMP(TreeNode& trFilter, ASCIMP& ascimp, BOOL bSetCommonNode)
{
	TreeNode trASCIMP = trFilter.GetNode(IMPORT_FILTER_ASCIMP);
	if( !trASCIMP )
		trASCIMP = trFilter.AddNode(IMPORT_FILTER_ASCIMP);
	trASCIMP = ascimp;
	if( bSetCommonNode )
	{
		trFilter.Common.ImportMode.nVal = ascimp.iMode;
		trFilter.Common.RenameWks.nVal = ascimp.iRenameWks;
		trFilter.Common.Partial.nVal = ascimp.iPartial;
		trFilter.Common.PartialC1.nVal = ascimp.iPartialC1;
		trFilter.Common.PartialC2.nVal = ascimp.iPartialC2;
		trFilter.Common.PartialR1.nVal = ascimp.iPartialR1;
		trFilter.Common.PartialR2.nVal = ascimp.iPartialR2;
		trFilter.Common.SkipRows.nVal = ascimp.iSkipRows; /// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP
	}
}

BOOL fuGetASCIMP(TreeNode& trFilter, ASCIMP& ascimp, BOOL bGetCommonNode)
{
	TreeNode trASCIMP = trFilter.GetNode(IMPORT_FILTER_ASCIMP);
	if( trASCIMP )
	{
		ascimp = trASCIMP;
		if( bGetCommonNode )
		{
			ascimp.iMode = trFilter.Common.ImportMode.nVal;
			ascimp.iRenameWks = trFilter.Common.RenameWks.nVal;
			ascimp.iPartial = trFilter.Common.Partial.nVal;
			ascimp.iPartialC1 = trFilter.Common.PartialC1.nVal;
			ascimp.iPartialC2 = trFilter.Common.PartialC2.nVal;
			ascimp.iPartialR1 = trFilter.Common.PartialR1.nVal;
			ascimp.iPartialR2 = trFilter.Common.PartialR2.nVal;
			ascimp.iSkipRows = tree_node_get_int(trFilter.Common.SkipRows, 0); /// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP
		}
		return TRUE;
	}
	return FALSE;
}

//------------------------------------------------------------
void fuSetBINIMP(TreeNode& trFilter, BINIMP& binimp, BOOL bSetCommonNode)
{
	TreeNode trBINIMP = trFilter.GetNode(IMPORT_FILTER_BINIMP);
	if( !trBINIMP )
		trBINIMP = trFilter.AddNode(IMPORT_FILTER_BINIMP);
	trBINIMP = binimp;
	if( bSetCommonNode )
	{
		trFilter.Common.ImportMode.nVal = binimp.iMode;
		trFilter.Common.RenameWks.nVal = binimp.iRenameWks;
		trFilter.Common.Partial.nVal = binimp.iPartial;
		trFilter.Common.PartialC1.nVal = binimp.iPartialC1;
		trFilter.Common.PartialC2.nVal = binimp.iPartialC2;
		trFilter.Common.PartialR1.nVal = binimp.iPartialR1;
		trFilter.Common.PartialR2.nVal = binimp.iPartialR2;
		trFilter.Common.SkipRows.nVal = binimp.iSkipRows; /// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP
	}
}

BOOL fuGetBINIMP(TreeNode& trFilter, BINIMP& binimp, BOOL bGetCommonNode)
{
	TreeNode trBINIMP = trFilter.GetNode(IMPORT_FILTER_BINIMP);
	if( trBINIMP )
	{
		binimp = trBINIMP;
		if( bGetCommonNode )
		{
			binimp.iMode = trFilter.Common.ImportMode.nVal;
			binimp.iRenameWks = trFilter.Common.RenameWks.nVal;
			binimp.iPartial = trFilter.Common.Partial.nVal;
			binimp.iPartialC1 = trFilter.Common.PartialC1.nVal;
			binimp.iPartialC2 = trFilter.Common.PartialC2.nVal;
			binimp.iPartialR1 = trFilter.Common.PartialR1.nVal;
			binimp.iPartialR2 = trFilter.Common.PartialR2.nVal;
			binimp.iSkipRows = tree_node_get_int(trFilter.Common.SkipRows, 0); /// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP
		}
		return TRUE;
	}
	return FALSE;
}

//------------------------------------------------------------
void fuSetDesignations(TreeNode& trFilter, LPCSTR lpcszDesignations)
{
	trFilter.Common.ColDesignations.strVal = lpcszDesignations;
}

string fuGetDesignations(TreeNode& trFilter)
{
	string str;
	if( trFilter.Common.ColDesignations )
		str = trFilter.Common.ColDesignations.strVal;
	return str;
}

//------------------------------------------------------------
void fuSetFormats(TreeNode& trFilter, LPCSTR lpcszFormats)
{
	trFilter.Common.ColFormats.strVal = lpcszFormats;
}

string fuGetFormats(TreeNode& trFilter)
{
	string str;
	if( trFilter.Common.ColFormats )
		str = trFilter.Common.ColFormats.strVal;
	return str;
}

//------------------------------------------------------------
void fuSetApplicability(TreeNode& trFilter, LPCSTR lpcszApplicability)
{
	trFilter.Common.FileSpec.strVal = lpcszApplicability;
}

string fuGetApplicability(TreeNode& trFilter)
{
	string str;
	if( trFilter.Common.FileSpec )
		str = trFilter.Common.FileSpec.strVal;
	return str;
}

BOOL fuIsApplicable(LPCSTR lpcszFilterFile, LPCSTR lpcszDataFile, int iFilterType)
{
	Tree trFilter(lpcszFilterFile);
	if( trFilter )
		return fuIsApplicable(trFilter, lpcszDataFile, iFilterType);
	return FALSE;
}

BOOL fuIsApplicable(TreeNode &trFilter, LPCSTR lpcszDataFile, int iFilterType)
{
	if( IS_FILTER_TYPE(iFilterType) )
		if( iFilterType != trFilter.Type.nVal )
			return FALSE;

	if( NULL == lpcszDataFile )
		return TRUE; // no file name to compare

	string strDataFile = GetFileName(lpcszDataFile);
	if( strDataFile.IsEmpty() )
		return TRUE; // no file name to compare

	if( strDataFile.Find('.') == -1 ) // if no extension
		strDataFile += '.';

	string strFileSpecs = fuGetApplicability(trFilter);
	
	StringArray saFileSpec;
	strFileSpecs.GetTokens(saFileSpec, ';');

	for( int n = 0; n < saFileSpec.GetSize(); n++ )
	{
		if( strDataFile.Match(saFileSpec[n]) )
			return TRUE;
	}
	return FALSE;
}

//------------------------------------------------------------
void fuGetFilterFiles(StringArray& sarrFilterFiles, LPCSTR lpcszFolderPath, LPCSTR lpcszDataFile, int iFilterType)
{
	sarrFilterFiles.SetSize(0);
	fuAppendFilterFiles(sarrFilterFiles, lpcszFolderPath, lpcszDataFile, iFilterType);
}

void fuAppendFilterFiles(StringArray& sarrFilterFiles, LPCSTR lpcszFolderPath, LPCSTR lpcszDataFile, int iFilterType)
{
	string strFileNames;
	auGetFilenamesInFolder(strFileNames, lpcszFolderPath, IMPORT_FILTER_EXTENSION_WILD, FALSE);
	if( strFileNames.IsEmpty() )
		return;

	StringArray sarrFilterFileNames;
	strFileNames.GetTokens(sarrFilterFileNames, '|');

	string strApplicability;
	if( lpcszDataFile )
		strApplicability = GetFileName(lpcszDataFile);
	
	if( strApplicability.IsEmpty() && FILTER_TYPE_IGNORE == iFilterType )
	{
		///sarrFilterFiles = sarrFilterFileNames;
		//sarrFilterFiles.Append(sarrFilterFileNames);
		for( int iFile = 0; iFile < sarrFilterFileNames.GetSize(); iFile++ )
			sarrFilterFiles.Add(sarrFilterFileNames[iFile]);
		return;
	}

	for( int iFile = 0; iFile < sarrFilterFileNames.GetSize(); iFile++ )
	{
		if( fuIsApplicable(sarrFilterFileNames[iFile], strApplicability, iFilterType) )
			sarrFilterFiles.Add(sarrFilterFileNames[iFile]);
	}
}

void fuGetFilterFiles(StringArray &saFilterFiles, int iFilterType, LPCSTR lpcszDataFile)
{
	saFilterFiles.SetSize(0);

	string strDataPath = GetFilePath(lpcszDataFile);
	if( !strDataPath.IsEmpty() )
		fuAppendFilterFiles(saFilterFiles, strDataPath, lpcszDataFile, iFilterType);

	string strUserPath;
	strUserPath.Format("%s%s", GetAppPath(), FILTERS_FOLDER_NAME);
	if( strUserPath != strDataPath )
		fuAppendFilterFiles(saFilterFiles, strUserPath, lpcszDataFile, iFilterType);

	string strExePath;
	strExePath.Format("%s%s", GetAppPath(TRUE), FILTERS_FOLDER_NAME);
	if( strExePath != strDataPath && strExePath != strUserPath )
		fuAppendFilterFiles(saFilterFiles, strExePath, lpcszDataFile, iFilterType);
}

void fuGetFilterList(StringArray &saFilterList, StringArray &saFilterFiles)
{
	int iPath;
	string str;
	string strLocPrefix(FILTER_LOCATION_PREFIX);
	
	string strUserPath;
	strUserPath.Format("%s%s", GetAppPath(), FILTERS_FOLDER_NAME);
	
	string strOriginPath;
	strOriginPath.Format("%s%s", GetAppPath(TRUE), FILTERS_FOLDER_NAME);

	saFilterList.SetSize(0);
	for( int i = 0; i < saFilterFiles.GetSize(); i++ )
	{
		if( 0 == strOriginPath.CompareNoCase(GetFilePath(saFilterFiles[i])) )
			iPath = FILTER_PATH_ORIGIN;
		else if( 0 == strUserPath.CompareNoCase(GetFilePath(saFilterFiles[i])) )
			iPath = FILTER_PATH_USER;
		else // Data
			iPath = FILTER_PATH_DATA;
		str.Format("%s: %s", strLocPrefix.GetToken(iPath, '|'), GetFileName(saFilterFiles[i], TRUE));
		saFilterList.Add(str);
	}
}