CCLayer* RestartAction()
{
CCLayer* pLayer = CreateLayer(s_nActionIdx);
pLayer->autorelease();
return pLayer;
}
//=============================================================================
void FSteamVRHMD::UpdateSplashScreen()
{
FTexture2DRHIRef Texture = (bSplashShowMovie && SplashMovie.IsValid()) ? SplashMovie : SplashTexture;
if (bSplashIsShown && Texture.IsValid())
{
FLayerDesc LayerDesc;
LayerDesc.Flags = ELayerFlags::LAYER_FLAG_TEX_NO_ALPHA_CHANNEL;
LayerDesc.PositionType = ELayerType::TrackerLocked;
LayerDesc.Texture = Texture;
LayerDesc.UVRect = FBox2D(SplashOffset, SplashScale);
LayerDesc.Transform.SetTranslation(FVector(500.0f, 0.0f, 0.0f));
LayerDesc.QuadSize = FVector2D(800.0f, 450.0f);
if (SplashLayerHandle)
{
SetLayerDesc(SplashLayerHandle, LayerDesc);
}
else
{
SplashLayerHandle = CreateLayer(LayerDesc);
}
}
else
{
if (SplashLayerHandle)
{
DestroyLayer(SplashLayerHandle);
SplashLayerHandle = 0;
}
}
}
SnippingWindow::SnippingWindow(HWND _parent)
:WindowBase()
{
auto up = std::make_unique<Yupei::CreateParam>(L"YupeiWindow");
up->ParentWindow = _parent;
SetCreateParam(std::move(up));
auto rect = Yupei::DeviceHelper::GetResolution(GetWindowHandle());
resolutionX = Yupei::GetRECTWidth<UINT>(rect);
resolutionY = Yupei::GetRECTHeight<UINT>(rect);
auto rt = GetRenderTarget();
rt->CreateLayer(&topLayer);
rt->CreateLayer(&shownLayer);
rt->CreateSolidColorBrush(
D2D1::ColorF(D2D1::ColorF::White, 0.5f), &whiteBrush);
}
TWeakObjectPtr< ULayer > FLayers::EnsureLayerExists( const FName& LayerName )
{
TWeakObjectPtr< ULayer > Layer;
if( !TryGetLayer( LayerName, Layer ) )
{
Layer = CreateLayer( LayerName );
}
return Layer;
}
CCLayer* NextAction()
{
++s_nActionIdx;
s_nActionIdx = s_nActionIdx % ACTION_LAYER_COUNT;
CCLayer* pLayer = CreateLayer(s_nActionIdx);
pLayer->autorelease();
return pLayer;
}
CCLayer* BackAction()
{
--s_nActionIdx;
if( s_nActionIdx < 0 )
s_nActionIdx += ACTION_LAYER_COUNT;
CCLayer* pLayer = CreateLayer(s_nActionIdx);
pLayer->autorelease();
return pLayer;
}
XBaseLayer *XActObj::CreateLayer( int idx, const LAYER_INFO* pLayerInfo )
{
auto pLayer = CreateLayer( idx
, pLayerInfo->type
, pLayerInfo->nLayer
, pLayerInfo->fAdjustAxisX
, pLayerInfo->fAdjustAxisY ); // 실제 레이어를 만들어준다
if( pLayer ) {
XBREAK( pLayerInfo->idLayer == 0 );
pLayer->SetidLayer( pLayerInfo->idLayer );
}
return pLayer;
}
MultilayerNET* CreateNewMultilayerNET(uint layersCount, uint inputDimension, ActivationFunctionPtr actFunction, uint* layersParams)
{
uint i;
MultilayerNET* newNET;
if(!CheckParams(layersCount, inputDimension, actFunction, layersParams))
{
newNET = ALLOC_OBJ(MultilayerNET);
newNET->InputDimension = inputDimension;
newNET->LayersCount = layersCount;
newNET->OutputDimension = layersParams[layersCount-1];
newNET->Layers = ALLOC_ARRAY(Layer*, layersCount);
newNET->Layers[0] = CreateLayer(layersParams[0], actFunction, inputDimension);
for(i = 1; i < newNET->LayersCount; i++)
{
newNET->Layers[i] = CreateLayer(layersParams[i], actFunction, newNET->Layers[i-1]->NeuronsCount);
}
newNET->LastOutput = newNET->Layers[newNET->LayersCount-1]->LastOutput; // output of NET is output of her last layer
return newNET;
}
TYPED_TEST(HDF5DataLayerTest, TestSkip) {
typedef typename TypeParam::Dtype Dtype;
LayerParameter param;
param.set_type("HDF5Data");
param.add_top("data");
param.add_top("label");
if (std::is_same<Dtype, half_fp>::value) {
param.set_bottom_data_type(CAFFE_FLOAT);
param.set_compute_data_type(CAFFE_FLOAT);
param.set_top_data_type(proto_data_type<Dtype>());
}
HDF5DataParameter* hdf5_data_param = param.mutable_hdf5_data_param();
int batch_size = 5;
hdf5_data_param->set_batch_size(batch_size);
hdf5_data_param->set_source(*(this->filename));
int_tp num_cols = 8;
int_tp height = 6;
int_tp width = 5;
Caffe::set_solver_count(8);
for (int dev = 0; dev < Caffe::solver_count(); ++dev) {
Caffe::set_solver_rank(dev);
shared_ptr<LayerBase> layer = CreateLayer(param);
layer->SetUp(this->blob_bottom_base_vec_, this->blob_top_base_vec_);
EXPECT_EQ(this->blob_top_data_->num(), batch_size);
EXPECT_EQ(this->blob_top_data_->channels(), num_cols);
EXPECT_EQ(this->blob_top_data_->height(), height);
EXPECT_EQ(this->blob_top_data_->width(), width);
EXPECT_EQ(this->blob_top_label_->num_axes(), 2);
EXPECT_EQ(this->blob_top_label_->shape(0), batch_size);
EXPECT_EQ(this->blob_top_label_->shape(1), 1);
int label = dev;
for (int iter = 0; iter < 1; ++iter) {
layer->Forward(this->blob_bottom_base_vec_, this->blob_top_base_vec_,
nullptr);
for (int i = 0; i < batch_size; ++i) {
EXPECT_EQ(1 + label, this->blob_top_label_->cpu_data()[i]);
label = (label + Caffe::solver_count()) % (batch_size * 2);
}
}
}
Caffe::set_solver_count(1);
Caffe::set_solver_rank(0);
}
RESULT
LayerManager::Init( IN const string& settingsFilename )
{
RETAILMSG(ZONE_INFO, "LayerManager::Init( %s )", settingsFilename.c_str());
RESULT rval = S_OK;
char path[MAX_PATH];
//
// Create a Settings object and load the file.
//
Settings mySettings;
if ( FAILED(mySettings.Read( settingsFilename )) )
{
RETAILMSG(ZONE_ERROR, "ERROR: LayerManager::Init( %s ): failed to load settings file", settingsFilename.c_str() );
return E_UNEXPECTED;
}
//
// Create each Layer.
//
UINT32 numLayers = mySettings.GetInt("/Layers.NumLayers");
for (int i = 0; i < numLayers; ++i)
{
sprintf(path, "/Layers/Layer%d", i);
//DEBUGMSG(ZONE_INFO, "Loading [%s]", path);
Layer *pLayer = NULL;
CreateLayer( &mySettings, path, &pLayer );
if (!pLayer)
{
RETAILMSG(ZONE_ERROR, "ERROR: LayerManager::Init( %s ): failed to create Layer", path);
// Continue loading other Layers rather than aborting.
continue;
}
//DEBUGMSG(ZONE_LAYER, "Created Layer [%s]", pLayer->GetName().c_str());
CHR(Add(pLayer->GetName(), pLayer));
}
Exit:
return rval;
}
void output_ogr(const std::string& filename, const std::string& driver_name, const segvec& removed_segments, const segvec& added_segments) {
OGRRegisterAll();
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str());
if (!driver) {
std::cerr << driver_name << " driver not available.\n";
exit(return_code_fatal);
}
//const char* options[] = { "SPATIALITE=yes", "OGR_SQLITE_SYNCHRONOUS=OFF", "INIT_WITH_EPSG=no", nullptr };
const char* options[] = { nullptr };
auto data_source = std::unique_ptr<OGRDataSource, OGRDataSourceDestroyer>(driver->CreateDataSource(filename.c_str(), const_cast<char**>(options)));
if (!data_source) {
std::cerr << "Creation of output file failed.\n";
exit(return_code_fatal);
}
SRS srs;
auto layer = data_source->CreateLayer("changes", srs.out(), wkbLineString, const_cast<char**>(options));
if (!layer) {
std::cerr << "Creating layer 'changes' failed.\n";
exit(return_code_fatal);
}
OGRFieldDefn field_change("change", OFTInteger);
field_change.SetWidth(1);
if (layer->CreateField(&field_change) != OGRERR_NONE ) {
std::cerr << "Creating field 'change' on 'changes' layer failed.\n";
exit(return_code_fatal);
}
layer->StartTransaction();
for (const auto& segment : removed_segments) {
add_segment(layer, 0, segment);
}
for (const auto& segment : added_segments) {
add_segment(layer, 1, segment);
}
layer->CommitTransaction();
}
void LayerSpeedTest(uint iterations, uint inputLength,uint neuronsCount, ActivationFunctionPtr actFunction)
{
Layer* layer;
uint i;
double* inputVector;
StopWatch stopWatch;
TimeInterval timeInterval;
inputVector = ALLOC_ARRAY(double, inputLength);
for(i = 0; i < inputLength; i++)
{
inputVector[i] = i;
}
layer = CreateLayer(neuronsCount, actFunction, inputLength);
Reset(&stopWatch);
Start(&stopWatch);
for(i = 0; i < iterations; i++)
{
ComputeLayerOutput(layer, inputVector);
}
Stop(&stopWatch);
CalcElapsedMilliSeconds(&stopWatch);
ToTimeIntervalStruct(&stopWatch, &timeInterval);
printf("LAYER SPEED TEST:\nPARAMETRS:\n iterations: %d\n input length: %d\n neuron's count: %d\n", iterations, inputLength, neuronsCount);
printf("ELAPSED TIME:\n");
printf(" milliseconds: %d\n", timeInterval.Miliseconds);
printf(" seconds: %d\n", timeInterval.Seconds);
printf(" minets: %d\n", timeInterval.Minets);
printf(" hours: %d\n", timeInterval.Hours);
printf("\n");
free(inputVector);
DisposeLayer(layer);
}
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer,
const char *pszNewName,
char **papszOptions )
{
OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn();
OGRLayer *poDstLayer = NULL;
/* -------------------------------------------------------------------- */
/* Create the layer. */
/* -------------------------------------------------------------------- */
if( !TestCapability( ODsCCreateLayer ) )
{
CPLError( CE_Failure, CPLE_NotSupported,
"This datasource does not support creation of layers." );
return NULL;
}
CPLErrorReset();
poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(),
poSrcDefn->GetGeomType(), papszOptions );
if( poDstLayer == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Add fields. Default to copy all field. */
/* If only a subset of all fields requested, then output only */
/* the selected fields, and in the order that they were */
/* selected. */
/* -------------------------------------------------------------------- */
int iField;
for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ )
poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) );
/* -------------------------------------------------------------------- */
/* Transfer features. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature;
poSrcLayer->ResetReading();
while( TRUE )
{
OGRFeature *poDstFeature = NULL;
poFeature = poSrcLayer->GetNextFeature();
if( poFeature == NULL )
break;
CPLErrorReset();
poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
{
delete poFeature;
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to translate feature %d from layer %s.\n",
poFeature->GetFID(), poSrcDefn->GetName() );
return poDstLayer;
}
poDstFeature->SetFID( poFeature->GetFID() );
OGRFeature::DestroyFeature( poFeature );
CPLErrorReset();
if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poDstFeature );
return poDstLayer;
}
OGRFeature::DestroyFeature( poDstFeature );
}
return poDstLayer;
}
// Get a layer using a prototxt which will be parsed into LayerParameter
static shared_ptr<Layer<Dtype> > CreateLayer(const string& prototxt) {
LayerParameter p;
bool success = google::protobuf::TextFormat::ParseFromString(prototxt, &p);
ASSERT(success, "Invalid prototxt string");
return CreateLayer(p);
}
//----------------------------------------------------------------------------
// Nome: InitializeInterface(void)
// Desc: Inicializa layer e sprites de interface.
// Pams: nenhum
//----------------------------------------------------------------------------
void CLevel::InitializeInterface(void)
{
int i = 0;
//17.1.
//1. criar a layer da interface
p_LayInterface = CreateLayer(CNGLVector(0,0));
//2. colocar a velocidade da layer como nula, para que ela não
//sofra deslocamento
p_LayInterface->Speed = CNGLVector(0,0);
//3. esconder a layer de interface
p_LayInterface->bVisible = false;
//17.2.1
//Abaixo a criação de um vetor com os números para as pontuações
for(int i = 0; i < NUM_ALGARISMS; i++){
p_SprNumbers[i] = p_LayInterface->CreateSprite(NUMBERS_SPR,CNGLVector(26,38));
if(p_SprNumbers[i]){
for(int j = 0; j < 10; j++){
p_SprNumbers[i]->AddAnimation(1,false,1,j);
}
p_SprNumbers[i]->Position.fy = 0.0f;
p_SprNumbers[i]->Position.fx = 300.0f + (float) (i*p_SprNumbers[i]->GetFrame().GetWidth());
}
}
//17.3.1.
//1. Criar um sprite para cada uma das três posições do vetor de vidas
for(i = 0; i < NUM_LIVES; i++)
{
//1. criar o sprite
p_SprLives[i] = p_LayInterface->CreateSprite(LIVES_SPR, CNGLVector(34,49));
//2. quadro 0 de animação é o vazio (vida vazia)
//2. quadro 1, 2 ou 3 corresponde a vida cheia -- Foda-se Quero vidas da mesma cor
p_SprLives[i]->AddAnimation(1,false,1,0);
p_SprLives[i]->AddAnimation(1,false,1,1);
//3 posiciona as vidas
p_SprLives[i]->Position.fy = 0.0f;
p_SprLives[i]->Position.fx = (float) (i*p_SprLives[i]->GetFrame().GetWidth());
}
//17.4.
//1. cria mensagem de pausa
p_MsgPaused = p_LayInterface->CreateSprite(PAUSED_MSG,CNGLVector(200,30));
p_MsgPaused->AddAnimation(1,false,1,0);
p_MsgPaused->bVisible = false;
Centralize(p_MsgPaused);
//2. cria mensagem de game over
p_MsgGameOver = p_LayInterface->CreateSprite(GAME_OVER_MSG,CNGLVector(148,26));
p_MsgGameOver->AddAnimation(1,false,1,0);
p_MsgGameOver->bVisible = false;
Centralize(p_MsgGameOver);
//3. cria mensagem de cangratulações
p_MsgCongrats = p_LayInterface->CreateSprite(CONGRATS_MSG,CNGLVector(246,66));
p_MsgCongrats->AddAnimation(1,false,1,0);
p_MsgCongrats->bVisible = false;
Centralize(p_MsgCongrats);
}
//----------------------------------------------------------------------------
// Nome: Initialize(void)
// Desc: Inicializa a cena. Inicializa cenários,interfaces, jogador, inimigos e itens.
// Pams: nenhum
//----------------------------------------------------------------------------
bool CLevel::Initialize(void)
{
//15.3.1
//Adiciona as imagens a cena
//imagem 0
AddTileImage("Surfaces/tile_Level.bmp",CNGLVector(32,32)); //tiles para compor cenário
//imagem 1
AddTileImage("Surfaces/tile_Background.bmp",CNGLVector(128,350)); //tile do fundo
//cria a layer de fundo (background). 1 único brick de 128x350
CNGLLayer *p_LayBkg = CreateLayer(CNGLVector(128,350),CNGLVector(1,1));
//cria a layer do meio. Bricks de 32x32
CNGLLayer *p_LayMiddle = CreateLayer(CNGLVector(32,32));
//cria layer da fase (cenário). Bricks de 32x32
p_LayLevel = CreateLayer(CNGLVector(32,32));
//configura as velocidades para as layers
//velocidade menor para dar impressão de profundidade
p_LayBkg->Speed = CNGLVector(0.5f,0.5f);
p_LayMiddle->Speed = CNGLVector(0.7f,0.7f);
//inicializa a layer de background
//o Brick da posição (0,0) utiliza a imagem 1 e o quadro 0
p_LayBkg->SetBrick(CNGLVector(0,0),1,0);
p_LayBkg->Offset.fy = 200.0f; //pequeno deslocamento para ajustar brick
//inicializa a layer intermediária
//estrutura de configuração de bricks
stNGLBrickConfig ConfigMiddle[3];
//cor vermelha refere-se ao quadro 16 da imagem 0
ConfigMiddle[0].uiColor = RGB(255,0,0);
ConfigMiddle[0].iImage = 0;
ConfigMiddle[0].iFrame = 16;
//cor verde refere-se ao quadro 17 da imagem 0
ConfigMiddle[1].uiColor = RGB(0,255,0);
ConfigMiddle[1].iImage = 0;
ConfigMiddle[1].iFrame = 17;
//cor azul refere-se ao quadro 18 da imagem 0
ConfigMiddle[2].uiColor = RGB(0,0,255);
ConfigMiddle[2].iImage = 0;
ConfigMiddle[2].iFrame = 18;
//faz a criação dos bricks configurados
p_LayMiddle->CreateBricksFromBitmap("Surfaces/lay_Middle.bmp",ConfigMiddle,3);
//inicializa a layer da frente (cenário da fase)
//estrutura de configuração de bricks
stNGLBrickConfig ConfigLevel[2];
//cor preta refere-se ao quadro 0 da imagem 0
ConfigLevel[0].uiColor = RGB(0,0,0);
ConfigLevel[0].iImage = 0;
ConfigLevel[0].iFrame = 0;
//cor vermelha refere-se ao quadro 4 da imagem 0
ConfigLevel[1].uiColor = RGB(255,0,0);
ConfigLevel[1].iImage = 0;
ConfigLevel[1].iFrame = 4;
p_LayLevel->CreateBricksFromBitmap("Surfaces/lay_Level.bmp",ConfigLevel,2);
//inicializa modelo de tiro (fica invisível)
p_SprShot = p_LayLevel->CreateSprite("Surfaces/spr_Shot.bmp",CNGLVector(9,9));
p_SprShot->bVisible = false;
//inicializa o modelo da explosão
p_SprShotExplode = p_LayLevel->CreateSprite("Surfaces/spr_Explosion.bmp",CNGLVector(64,64));
p_SprShotExplode->AddAnimation(30,false,17,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,-1);
p_SprShotExplode->SetCurrentAnimation(0);
p_SprShotExplode->bVisible = false;
//inicia o menu
Menu.pr_Level = this; //referência para classe CLevel
Menu.Initialize();
//iniciando interface
InitializeInterface();
//23.1.1.
//1. criar o sprite da moeda final
//1. adicionar sua animação contínua
//1. ajustar animação corrente como 0
//1. colocar moeda na posição (7235,430)
//2. carrega o som de congratulação
//3. criar o sprite da alavanca
//3. adicionar as animações da alavanca
//3. ajustar animação corrente como 0
//3. colocar a alavanca na posição (7314,224)
//4. carregar o som da alavanca
//5. carregar trilha sonora
return true;
}
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer,
const char *pszNewName,
char **papszOptions )
{
OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn();
OGRLayer *poDstLayer = NULL;
/* -------------------------------------------------------------------- */
/* Create the layer. */
/* -------------------------------------------------------------------- */
if( !TestCapability( ODsCCreateLayer ) )
{
CPLError( CE_Failure, CPLE_NotSupported,
"This datasource does not support creation of layers." );
return NULL;
}
CPLErrorReset();
poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(),
poSrcDefn->GetGeomType(), papszOptions );
if( poDstLayer == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Add fields. Default to copy all field. */
/* If only a subset of all fields requested, then output only */
/* the selected fields, and in the order that they were */
/* selected. */
/* -------------------------------------------------------------------- */
int iField;
for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ )
poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) );
/* -------------------------------------------------------------------- */
/* Check if the destination layer supports transactions and set a */
/* default number of features in a single transaction. */
/* -------------------------------------------------------------------- */
int nGroupTransactions = 0;
if( poDstLayer->TestCapability( OLCTransactions ) )
nGroupTransactions = 128;
/* -------------------------------------------------------------------- */
/* Transfer features. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature;
poSrcLayer->ResetReading();
if( nGroupTransactions <= 0 )
{
while( TRUE )
{
OGRFeature *poDstFeature = NULL;
poFeature = poSrcLayer->GetNextFeature();
if( poFeature == NULL )
break;
CPLErrorReset();
poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
{
delete poFeature;
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to translate feature %ld from layer %s.\n",
poFeature->GetFID(), poSrcDefn->GetName() );
return poDstLayer;
}
poDstFeature->SetFID( poFeature->GetFID() );
OGRFeature::DestroyFeature( poFeature );
CPLErrorReset();
if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poDstFeature );
return poDstLayer;
}
OGRFeature::DestroyFeature( poDstFeature );
}
}
else
{
int i, bStopTransfer = FALSE, bStopTransaction = FALSE;
int nFeatCount = 0; // Number of features in the temporary array
int nFeaturesToAdd = 0;
while( !bStopTransfer )
{
OGRFeature **papoDstFeature =
(OGRFeature **)CPLCalloc(sizeof(OGRFeature *), nGroupTransactions);
/* -------------------------------------------------------------------- */
/* Fill the array with features */
/* -------------------------------------------------------------------- */
for( nFeatCount = 0; nFeatCount < nGroupTransactions; nFeatCount++ )
{
poFeature = poSrcLayer->GetNextFeature();
if( poFeature == NULL )
{
bStopTransfer = 1;
break;
}
CPLErrorReset();
papoDstFeature[nFeatCount] =
OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() );
if( papoDstFeature[nFeatCount]->SetFrom( poFeature, TRUE ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poFeature );
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to translate feature %ld from layer %s.\n",
poFeature->GetFID(), poSrcDefn->GetName() );
bStopTransfer = TRUE;
break;
}
papoDstFeature[nFeatCount]->SetFID( poFeature->GetFID() );
OGRFeature::DestroyFeature( poFeature );
}
nFeaturesToAdd = nFeatCount;
CPLErrorReset();
bStopTransaction = FALSE;
while( !bStopTransaction )
{
bStopTransaction = TRUE;
poDstLayer->StartTransaction();
for( i = 0; i < nFeaturesToAdd; i++ )
{
if( poDstLayer->CreateFeature( papoDstFeature[i] ) != OGRERR_NONE )
{
nFeaturesToAdd = i;
bStopTransfer = TRUE;
bStopTransaction = FALSE;
}
}
if( bStopTransaction )
poDstLayer->CommitTransaction();
else
poDstLayer->RollbackTransaction();
}
for( i = 0; i < nFeatCount; i++ )
OGRFeature::DestroyFeature( papoDstFeature[i] );
}
}
return poDstLayer;
}
TYPED_TEST(HDF5DataLayerTest, TestRead) {
typedef typename TypeParam::Dtype Dtype;
this->blob_top_vec_.push_back(this->blob_top_label2_);
this->blob_top_base_vec_.push_back(this->blob_top_label2_);
// Create LayerParameter with the known parameters.
// The data file we are reading has 10 rows and 8 columns,
// with values from 0 to 10*8 reshaped in row-major order.
LayerParameter param;
param.set_type("HDF5Data");
param.add_top("data");
param.add_top("label");
param.add_top("label2");
if (std::is_same<Dtype, half_fp>::value) {
param.set_bottom_data_type(CAFFE_FLOAT);
param.set_compute_data_type(CAFFE_FLOAT);
param.set_top_data_type(proto_data_type<Dtype>());
}
HDF5DataParameter* hdf5_data_param = param.mutable_hdf5_data_param();
int_tp batch_size = 5;
hdf5_data_param->set_batch_size(batch_size);
hdf5_data_param->set_source(*(this->filename));
int_tp num_cols = 8;
int_tp height = 6;
int_tp width = 5;
// Test that the layer setup gives correct parameters.
shared_ptr<LayerBase> layer = CreateLayer(param);
layer->SetUp(this->blob_bottom_base_vec_, this->blob_top_base_vec_);
EXPECT_EQ(this->blob_top_data_->num(), batch_size);
EXPECT_EQ(this->blob_top_data_->channels(), num_cols);
EXPECT_EQ(this->blob_top_data_->height(), height);
EXPECT_EQ(this->blob_top_data_->width(), width);
EXPECT_EQ(this->blob_top_label_->num_axes(), 2);
EXPECT_EQ(this->blob_top_label_->shape(0), batch_size);
EXPECT_EQ(this->blob_top_label_->shape(1), 1);
EXPECT_EQ(this->blob_top_label2_->num_axes(), 2);
EXPECT_EQ(this->blob_top_label2_->shape(0), batch_size);
EXPECT_EQ(this->blob_top_label2_->shape(1), 1);
layer->SetUp(this->blob_bottom_base_vec_, this->blob_top_base_vec_);
// Go through the data 10 times (5 batches).
const int_tp data_size = num_cols * height * width;
for (int_tp iter = 0; iter < 10; ++iter) {
layer->Forward(this->blob_bottom_base_vec_,
this->blob_top_base_vec_, nullptr);
// On even iterations, we're reading the first half_fp of the data.
// On odd iterations, we're reading the second half_fp of the data.
// NB: label is 1-indexed
int_tp label_offset = 1 + ((iter % 2 == 0) ? 0 : batch_size);
int_tp label2_offset = 1 + label_offset;
int_tp data_offset = (iter % 2 == 0) ? 0 : batch_size * data_size;
// Every two iterations we are reading the second file,
// which has the same labels, but data is offset by total data size,
// which is 2400 (see generate_sample_data).
int_tp file_offset = (iter % 4 < 2) ? 0 : 2400;
for (int_tp i = 0; i < batch_size; ++i) {
if (label_offset + i <= type_max_integer_representable<Dtype>()) {
EXPECT_EQ(
label_offset + i,
this->blob_top_label_->cpu_data()[i]);
}
if (label2_offset + i <= type_max_integer_representable<Dtype>()) {
EXPECT_EQ(
label2_offset + i,
this->blob_top_label2_->cpu_data()[i]);
}
}
for (int_tp i = 0; i < batch_size; ++i) {
for (int_tp j = 0; j < num_cols; ++j) {
for (int_tp h = 0; h < height; ++h) {
for (int_tp w = 0; w < width; ++w) {
int_tp idx = (
i * num_cols * height * width +
j * height * width +
h * width + w);
if (file_offset + data_offset + idx
<= type_max_integer_representable<Dtype>()) {
EXPECT_EQ(
file_offset + data_offset + idx,
this->blob_top_data_->cpu_data()[idx])
<< "debug: i " << i << " j " << j
<< " iter " << iter;
}
}
}
}
}
}
}
/*!
\brief Open VFK datasource
\param pszNewName datasource name
\param bTextOpen True to test if datasource is possible to open
\return TRUE on success
\return FALSE on failure
*/
int OGRVFKDataSource::Open(const char *pszNewName, int bTestOpen)
{
FILE * fp;
char szHeader[1000];
/* open the source file */
fp = VSIFOpen(pszNewName, "r");
if (fp == NULL) {
if (!bTestOpen)
CPLError(CE_Failure, CPLE_OpenFailed,
"Failed to open VFK file `%s'.",
pszNewName);
return FALSE;
}
/* If we aren't sure it is VFK, load a header chunk and check
for signs it is VFK */
if (bTestOpen) {
size_t nRead = VSIFRead(szHeader, 1, sizeof(szHeader), fp);
if (nRead <= 0) {
VSIFClose(fp);
return FALSE;
}
szHeader[MIN(nRead, sizeof(szHeader))-1] = '\0';
// TODO: improve check
if (strncmp(szHeader, "&HVERZE;", 8) != 0) {
VSIFClose(fp);
return FALSE;
}
}
/* We assume now that it is VFK. Close and instantiate a
VFKReader on it. */
VSIFClose(fp);
pszName = CPLStrdup(pszNewName);
poReader = CreateVFKReader();
if (poReader == NULL) {
CPLError(CE_Failure, CPLE_AppDefined,
"File %s appears to be VFK but the VFK reader can't"
"be instantiated.",
pszNewName );
return FALSE;
}
/* load data (whole file) */
poReader->SetSourceFile(pszNewName);
poReader->LoadData();
/* get data blocks, i.e. &B */
poReader->LoadDataBlocks();
/* collect geometry properties
load on first request
*/
/* poReader->LoadGeometry(); */
/* get list of layers */
papoLayers = (OGRVFKLayer **) CPLCalloc(sizeof(OGRVFKLayer *), poReader->GetDataBlockCount());
for (int iLayer = 0; iLayer < poReader->GetDataBlockCount(); iLayer++) {
papoLayers[iLayer] = CreateLayer(poReader->GetDataBlock(iLayer));
nLayers++;
}
return TRUE;
}
