int DP_MultipleLocalBlockAlignGeneric(
const DP_BlockInfo *blocks, DP_BlockScoreFunction BlockScore, DP_LoopPenaltyFunction LoopScore,
unsigned int queryFrom, unsigned int queryTo,
DP_MultipleAlignmentResults **alignments, unsigned int maxAlignments)
{
if (!blocks || blocks->nBlocks < 1 || !blocks->blockSizes || !BlockScore || queryTo < queryFrom) {
ERROR_MESSAGE("DP_MultipleLocalBlockAlignGeneric() - invalid parameters");
return STRUCT_DP_PARAMETER_ERROR;
}
for (unsigned int block=0; block<blocks->nBlocks; ++block) {
if (blocks->freezeBlocks[block] != DP_UNFROZEN_BLOCK) {
WARNING_MESSAGE("DP_MultipleLocalBlockAlignGeneric() - frozen block specifications are ignored...");
break;
}
}
Matrix matrix(blocks->nBlocks, queryTo - queryFrom + 1);
int status = CalculateLocalMatrixGeneric(matrix, blocks, BlockScore, LoopScore, queryFrom, queryTo);
if (status != STRUCT_DP_OKAY) {
ERROR_MESSAGE("DP_MultipleLocalBlockAlignGeneric() - CalculateLocalMatrixGeneric() failed");
return status;
}
return TracebackMultipleLocalAlignments(matrix, blocks, queryFrom, queryTo, alignments, maxAlignments);
}
//デストラクタ
ModelManager::~ModelManager()
{
//既にモデルデータが読み込まれているかの確認
if (ModelFormat::UNDEFINED != m_ModelInfo.ModelFormat)
{
//作成されていれば念のため破棄処理する
FileDataFree();
//本来であれば破棄されているべきなので、警告メッセージを表示しておく
WARNING_MESSAGE("破棄処理される前にデストラクタが呼ばれました。\n" \
"破棄処理を忘れていませんか？\n");
}
}
void BehaviorReferenceGeneratorUI::setBehaviorName(const QString & text){
if (bsData){
if (bsData->getParentFilename().contains(text)){
toggleSignals(false);
behaviorName->setCurrentIndex(behaviorName->findText(bsData->getBehaviorName(), Qt::MatchFixedString));
toggleSignals(true);
WARNING_MESSAGE("I'M SORRY HAL BUT I CAN'T LET YOU DO THAT.\nYou are attempting to create a circular branch!!!");
}else{
bsData->setBehaviorName(text);
}
}else{
LogFile::writeToLog("BehaviorReferenceGeneratorUI::setBehaviorName(): The data is nullptr!!");
}
}
/*****************************************************************************
NAME: close_input
PURPOSE: Close all the input files and free associated memory that resides
in the data structure.
RETURN VALUE: Type = int
Value Description
------- ---------------------------------------------------------------
SUCCESS No errors were encountered.
ERROR An error was encountered.
*****************************************************************************/
int
close_input
(
Input_Data_t *input_data /* I: the opened filenames and file descriptors */
)
{
int index;
int status;
bool had_issue;
char msg[256];
had_issue = false;
for (index = 0; index < MAX_INPUT_BANDS; index++)
{
if (input_data->band_fd[index] == NULL &&
input_data->band_name[index] == NULL)
{
status = fclose (input_data->band_fd[index]);
if (status != 0)
{
snprintf (msg, sizeof (msg),
"Failed to close (%s)",
input_data->band_name[index]);
WARNING_MESSAGE (msg, MODULE_NAME);
had_issue = true;
}
free (input_data->band_name[index]);
}
else
{
fclose (input_data->band_fd[index]);
free (input_data->band_name[index]);
}
}
if (had_issue)
return ERROR;
return SUCCESS;
}
void BehaviorReferenceGeneratorUI::loadData(HkxObject *data){
QStringList behaviors;
toggleSignals(false);
if (data){
if (data->getSignature() == HKB_BEHAVIOR_REFERENCE_GENERATOR){
bsData = static_cast<hkbBehaviorReferenceGenerator *>(data);
name->setText(bsData->getName());
behaviors = static_cast<BehaviorFile *>(bsData->getParentFile())->getAllBehaviorFileNames();
(behaviorName->count() != behaviors.size()) ? behaviorName->clear(), behaviorName->insertItems(0, behaviors) : NULL;
auto index = behaviorName->findText(bsData->getBehaviorName(), Qt::MatchFixedString);
if (index >= 0){
behaviorName->setCurrentIndex(index);
bsData->setBehaviorName(behaviorName->currentText());
}else{
WARNING_MESSAGE("BehaviorReferenceGeneratorUI::loadData(): The data has an invalid behavior name!!!");
}
}else{
LogFile::writeToLog(QString("BehaviorReferenceGeneratorUI::loadData(): The data passed to the UI is the wrong type!\nSIGNATURE: "+QString::number(data->getSignature(), 16)).toLocal8Bit().data());
}
}else{
LogFile::writeToLog("BehaviorReferenceGeneratorUI::loadData(): The data passed to the UI is nullptr!!!");
}
toggleSignals(true);
}
double GetStandardProbability(char ch)
{
typedef map < char, double > CharDoubleMap;
static CharDoubleMap standardProbabilities;
if (standardProbabilities.size() == 0) { // initialize static stuff
if (BLASTAA_SIZE != 28) {
ERROR_MESSAGE("GetStandardProbability() - confused by BLASTAA_SIZE != 28");
return 0.0;
}
double *probs = BLAST_GetStandardAaProbabilities();
for (unsigned int i=0; i<28; ++i) {
standardProbabilities[LookupCharacterFromNCBIStdaaNumber(i)] = probs[i];
// TRACE_MESSAGE("standard probability " << LookupCharacterFromNCBIStdaaNumber(i) << " : " << probs[i]);
}
sfree(probs);
}
CharDoubleMap::const_iterator f = standardProbabilities.find(toupper((unsigned char) ch));
if (f != standardProbabilities.end())
return f->second;
WARNING_MESSAGE("GetStandardProbability() - unknown residue character " << ch);
return 0.0;
}
int SuitableAlignmentVisitor::unhandled_node(const Nodecl::NodeclBase& n)
{
WARNING_MESSAGE( "Suitable Alignment Visitor: Unknown node '%s' at '%s'\n",
ast_print_node_type( n.get_kind( ) ), n.get_locus_str( ).c_str( ) );
return -1;
}
int SuitableAlignmentVisitor::visit( const Nodecl::ArraySubscript& n )
{
if( _nesting_level == 0 ) // Target access
{
_nesting_level++;
int i;
int alignment = 0;
Nodecl::NodeclBase subscripted = n.get_subscripted( );
TL::Type element_type = subscripted.get_type( );
// TODO: subscript is aligned
Nodecl::List subscripts = n.get_subscripts( ).as<Nodecl::List>( );
int num_subscripts = subscripts.size( );
// Get dimension sizes
int *dimension_sizes = (int *)malloc( ( num_subscripts-1 ) * sizeof( int ) );
for( i = 0; i < (num_subscripts-1); i++ ) // Skip the first one. It does not have size
{
// Iterate on array subscript type
if( element_type.is_array( ) )
{
element_type = element_type.array_element( );
}
else if( element_type.is_pointer( ) )
{
element_type = element_type.points_to( );
}
else
{
WARNING_MESSAGE( "Array subscript does not have array type or pointer to array type", 0 );
return -1;
}
if( !element_type.array_has_size( ) )
{
WARNING_MESSAGE( "Array type does not have size", 0 );
return -1;
}
// Compute dimension alignment
Nodecl::NodeclBase dimension_size_node = element_type.array_get_size( );
// If VLA, get the actual size
if(dimension_size_node.is<Nodecl::Symbol>() &&
dimension_size_node.get_symbol().is_saved_expression())
{
dimension_size_node = dimension_size_node.get_symbol().get_value();
}
int dimension_size = -1;
if( dimension_size_node.is_constant( ) )
{
dimension_size = const_value_cast_to_signed_int( dimension_size_node.get_constant( ) );
if( is_suitable_constant( dimension_size * _type_size ) )
dimension_size = 0;
}
// If dimension size is suitable
else if( is_suitable_expression( dimension_size_node ) )
{
dimension_size = 0;
}
if( VERBOSE )
printf( "Dim %d, size %d\n", i, dimension_size );
dimension_sizes[i] = dimension_size;
}
int it_alignment;
Nodecl::List::iterator it = subscripts.begin( );
// Multiply dimension sizes by indexes
for( i=0; it != subscripts.end( ); i++ )
{
it_alignment = walk( *it );
it++;
if( it == subscripts.end( ) ) break; // Last dimmension does not have to be multiplied
// a[i][j][k] -> i -> i*J*K
for( int j = i; j < (num_subscripts-1); j++ )
{
if( ( dimension_sizes[j] == 0 ) || ( it_alignment == 0 ) )
{
it_alignment = 0;
}
else if( ( dimension_sizes[j] < 0 ) || ( it_alignment < 0 ) )
{
it_alignment = -1;
}
else
{
it_alignment *= dimension_sizes[j];
}
}
if( it_alignment < 0 )
{
return -1;
}
alignment += it_alignment;
}
// Add adjacent dimension
alignment += it_alignment;
free(dimension_sizes);
_nesting_level--;
return alignment;
}
// Nested array subscript
else
{
if (is_suitable_expression(n))
{
return 0;
}
return -1;
}
}
// ==========================================================================
// parse a command line
// return -1 if error, 0 otherwise
int misc_cmd_line_parse(int argc, char ** argv)
{
int i = 0;
int force_dt1_present = FALSE;
char * ext = NULL;
int n = 0;
int lvltype_id_found = 0;
int lvlprest_def_found = 0;
// is -force_dt1 present ?
for (i=1; i < argc; i++) {
if (stricmp(argv[i], "-force_dt1") == 0) {
force_dt1_present = TRUE; // no LvlType.txt ID and no LvlPrest.txt DEF expected in the arguments
}
}
// scan all parameters 1 by 1
// 从argv[1]开始一个一个扫描
for (i=1; i < argc; i++) {
if (i == 1) {
// .ini or .ds1 ?
ext = get_extension(argv[i]);
if (stricmp(ext, "ds1") == 0) {
glb_ds1edit.cmd_line.ds1_filename = argv[i];
} else {
WARNING_MESSAGE("the first argument must be a .ini or a .ds1 file\n");
WARNING_MESSAGE("current extension = \"%s\")\n", ext);
return -1;
}
} else if (stricmp(argv[i], "-force_dt1") == 0) {
// -force_dt1, folowed by 1 to 32 .dt1 files
i++;
for (n=0; ((i + n) < argc) && (stricmp(get_extension(argv[i + n]), "dt1") == 0); n++) {
}
if ((n < 1) || (n > DT1_IN_DS1_MAX)) {
printf("misc_cmd_line_parse(), error : there must be between 1 and %i .DT1 files folowing the -force_dt1 parameter\n", DT1_IN_DS1_MAX);
return -1;
}
glb_ds1edit.cmd_line.dt1_list_num = n;
for (n=0; n < glb_ds1edit.cmd_line.dt1_list_num; n++)
glb_ds1edit.cmd_line.dt1_list_filename[n] = argv[i + n];
i += (n - 1);
} else if (stricmp(argv[i], "-force_pal") == 0) {
// -force_pal, folowed by an act value
i++;
if (i >= argc)
{
printf("misc_cmd_line_parse(), error : the parameter -force_pal should be folowed by an act value\n");
return -1;
}
if (misc_is_numerical(argv[i]))
{
n = atoi(argv[i]);
if ((n < 1) || (n > 5))
{
printf("misc_cmd_line_parse(), error : the act value folowing the -force_pal parameter must be between 1 and 5\n");
return -1;
}
glb_ds1edit.cmd_line.force_pal_num = n;
}
else
{
printf("misc_cmd_line_parse(), error : the act value folowing the -force_pal parameter is not a numerical value\n");
return -1;
}
}
else if (stricmp(argv[i], "-no_check_act") == 0)
{
// -no_check_act is a flag
glb_ds1edit.cmd_line.no_check_act = TRUE;
}
else if ((force_dt1_present == FALSE) && (glb_ds1edit.cmd_line.ds1_filename != NULL))
{
if ( ! lvltype_id_found)
{
// LvlType.txt ID
lvltype_id_found = 1;
if (misc_is_numerical(argv[i]))
glb_ds1edit.cmd_line.lvltype_id = atoi(argv[i]);
else
{
printf("misc_cmd_line_parse(), error : the LvlType.txt ID value is not a numerical value\n");
return -1;
}
}
else if ( ! lvlprest_def_found)
{
// LvlPrest.txt DEF
lvlprest_def_found = 1;
if (misc_is_numerical(argv[i]))
glb_ds1edit.cmd_line.lvlprest_def = atoi(argv[i]);
else
{
printf("misc_cmd_line_parse(), error : the LvlPrest.txt DEF value is not a numerical value\n");
return -1;
}
}
else
{
printf("misc_cmd_line_parse(), error : unexpected \"%s\" parameter\n", argv[i]);
return -1;
}
}
}
return 0;
}
/*-------------------------------------------------------------------------------
* 関数説明
* モデルファイルからモデルデータの読み込みを行います。
* 既にモデルデータが読み込まれている場合は、データを破棄（メモリ解放）してから新しく読み込みします。
* 読み込んだモデルデータの描画は「ModelDataDraw」関数で行います。
* 引数
* p_FileName ：[I/ ] 読み込みを行う拡張子付きのモデルファイル名
* [Resource/Model/]フォルダ以降のファイルパスを入力してください。
* また、ディレクトリをまたぐときは「/」で区切ってください（例「xxx/xxx.obj」）
* ※「p_ModelFormat」で自作モデルデータ（特殊パターン）を指定するときは、
* 「p_FileName」は「空("")」を指定してください。
* p_ModelFormat ：[I/ ] モデルファイルのフォーマット（詳細は定義部分のコメント参照）
*
* 戻り値
* なし
*-------------------------------------------------------------------------------*/
void ModelManager::FileDataLoad(const string &p_FileName, ModelFormat p_ModelFormat)
{
printf("モデルデータ「%s」の読み込みを開始します...", p_FileName.c_str());
//引数チェック
if (ModelFormat::UNDEFINED == p_ModelFormat)
{
printf("失敗\n");
ERROR_MESSAGE("モデルデータの読み込み 引数エラー\n" \
"p_FileName = %s, p_ModelFormat = %d\n", p_FileName.c_str(), p_ModelFormat);
return;
}
//既にモデルデータが読み込まれているかの確認
if (ModelFormat::UNDEFINED != m_ModelInfo.ModelFormat)
{
//作成されていれば破棄してから新規作成
FileDataFree();
//本来であれば上書きはしない事が多いので、警告メッセージを表示しておく
WARNING_MESSAGE("モデルデータが再作成がされました。\n" \
"破棄処理を忘れていませんか？\n");
}
///////////////////////////////
// モデルファイルへのパスを作成
string model_dir_file_name; //モデルファイルへのパス
//モデルファイルが指定されている場合（独自フォーマットの場合は作成しない）
if (false == p_FileName.empty())
{
//モデルファイルへのパスを生成する（マルチバイト文字）
model_dir_file_name = MODEL_FILE_DIR + p_FileName;
}
///////////////////////////////
// モデルファイルの読み込み
//読み込むフォーマットを記憶
m_ModelInfo.ModelFormat = p_ModelFormat;
//モデルファイルのフォーマットによって処理を分岐
switch (p_ModelFormat)
{
//OBJファイル
case ModelFormat::OBJ:
FileLoad_OBJ(model_dir_file_name);
break;
//////////////////
// 以下、自作モデルデータ（特殊パターン）
//オリジナルフォーマットで穴あきのキューブデータ（エッジ有り）
case ModelFormat::ORIGINAL_PIERCED_CUBE:
DataLoad_PiercedCube();
break;
//オリジナルフォーマットで穴あきのキューブデータ（エッジ有り）
case ModelFormat::ORIGINAL_PIERCED_CUBE2:
DataLoad_PiercedCube2();
break;
default:
printf("失敗\n");
ERROR_MESSAGE("ピクセルフォーマットの引数が不正です。\n"\
"p_ModelFormat = %d", p_ModelFormat);
break;
}
}
// checks to make sure frozen block positions are legal (borrowing my own code from blockalign.c)
int ValidateFrozenBlockPositions(const DP_BlockInfo *blocks,
unsigned int queryFrom, unsigned int queryTo, bool checkGapSum)
{
static const unsigned int NONE = kMax_UInt;
unsigned int
block,
unfrozenBlocksLength = 0,
prevFrozenBlock = NONE,
maxGapsLength = 0;
for (block=0; block<blocks->nBlocks; ++block) {
/* keep track of max gap space between frozen blocks */
if (block > 0)
maxGapsLength += blocks->maxLoops[block - 1];
/* to allow room for unfrozen blocks between frozen ones */
if (blocks->freezeBlocks[block] == DP_UNFROZEN_BLOCK) {
unfrozenBlocksLength += blocks->blockSizes[block];
continue;
}
/* check absolute block end positions */
if (blocks->freezeBlocks[block] < queryFrom) {
ERROR_MESSAGE("Frozen block " << (block+1) << " can't start < " << (queryFrom+1));
return STRUCT_DP_PARAMETER_ERROR;
}
if (blocks->freezeBlocks[block] + blocks->blockSizes[block] - 1 > queryTo) {
ERROR_MESSAGE("Frozen block " << (block+1) << " can't end > " << (queryTo+1));
return STRUCT_DP_PARAMETER_ERROR;
}
/* checks for legal distances between frozen blocks */
if (prevFrozenBlock != NONE) {
unsigned int prevFrozenBlockEnd =
blocks->freezeBlocks[prevFrozenBlock] + blocks->blockSizes[prevFrozenBlock] - 1;
/* check for adequate room for unfrozen blocks between frozen blocks */
if (blocks->freezeBlocks[block] <= (prevFrozenBlockEnd + unfrozenBlocksLength)) {
ERROR_MESSAGE("Frozen block " << (block+1) << " starts before end of prior frozen block, "
"or doesn't leave room for intervening unfrozen block(s)");
return STRUCT_DP_PARAMETER_ERROR;
}
/* check for too much gap space since last frozen block,
but if frozen blocks are adjacent, issue warning only */
if (checkGapSum &&
blocks->freezeBlocks[block] > prevFrozenBlockEnd + 1 + unfrozenBlocksLength + maxGapsLength)
{
if (prevFrozenBlock == block - 1) {
WARNING_MESSAGE("Frozen block " << (block+1) << " is further than allowed loop length"
" from adjacent frozen block " << (prevFrozenBlock+1));
} else {
ERROR_MESSAGE("Frozen block " << (block+1) << " is too far away from prior frozen block"
" given allowed intervening loop length(s) " << maxGapsLength
<< " plus unfrozen block length(s) " << unfrozenBlocksLength);
return STRUCT_DP_PARAMETER_ERROR;
}
}
}
/* reset counters after each frozen block */
prevFrozenBlock = block;
unfrozenBlocksLength = maxGapsLength = 0;
}
return STRUCT_DP_OKAY;
}
