int console_filter_selection(ContextPtr env, char *cmd) {
if(!cmd) return 0;
LinkList<Filter> &list = env->getFilters();
LinkList<Filter>::iterator it = std::find_if(list.begin(), list.end(), [&](FilterPtr filter) {
return filter->getName() == cmd;
});
if(it == list.end()) {
::error("filter not found: %s", cmd);
return 0;
}
FilterPtr filt = *it;
ViewPortPtr screen = getSelectedScreen();
if(!screen) {
::error("no screen currently selected");
return 0;
}
LayerPtr lay = getSelectedLayer();
if(!lay) {
::error("no layer selected for effect %s", filt->getName().c_str());
return 0;
}
if(!filt->new_instance()->apply(lay)) {
::error("error applying filter %s on layer %s", filt->getName().c_str(), lay->getName().c_str());
return 0;
}
// select automatically the new filter
// lay->filters.sel(0);
// ff->sel(true);
return 1;
}
///////////////////////////////////////////////////////////////////////////////
// Called when the "New Layer" button is clicked on the toolbar. Creates an
// un-doable command that adds a layer to the scene (thereby adding it to this
// control).
//
void LayersPanel::OnNewLayer( wxCommandEvent& event )
{
if ( m_Scene )
{
LayerPtr layer = new Layer();
layer->SetOwner( m_Scene );
m_Scene->Push( new SceneNodeExistenceCommand( Undo::ExistenceActions::Add, m_Scene, layer ) );
m_Scene->Execute( false );
}
}
int console_blit_param_selection(ContextPtr env, char *cmd) {
if(!cmd) return 0;
ViewPortPtr screen = getSelectedScreen();
if(!screen) {
::error("no screen currently selected");
return 0;
}
LayerPtr lay = getSelectedLayer();
if(!lay) {
::error("no layer currently selected");
return 0;
}
BlitInstancePtr b = lay->getCurrentBlit();
if(!b) {
::error("no blit selected on layer %s", lay->getName().c_str());
return 0;
}
// find the values after the first blank space
char *p;
for(p = cmd; *p != '\0'; p++)
if(*p == '=') {
*p = '\0';
if(*(p - 1) == ' ')
*(p - 1) = '\0';
p++;
break;
}
while(*p == ' ') p++; // jump all spaces
if(*p == '\0') return 0; // no value was given
LinkList<ParameterInstance> &list = b->getParameters();
LinkList<ParameterInstance>::iterator it = std::find_if(list.begin(), list.end(), [&](ParameterInstancePtr p) {
return p->getName() == cmd;
});
if(it == list.end()) {
error("parameter %s not found in blit %s", cmd, b->getName().c_str());
return 0;
}
ParameterInstancePtr param = *it;
func("parameter %s found in blit %s", param->getName().c_str(), b->getName().c_str());
param->parse(p);
return 1;
}
TEST(Layer, WarpCTCLayer) {
for (auto layerSize : {10, 64}) {
for (auto batchSize : {1, 10, 32}) {
for (auto normByTimes : {false, true}) {
for (auto useGpu : {false, true}) {
#ifndef PADDLE_WITH_CUDA
if (useGpu) continue;
#endif
LOG(INFO) << "layerSize=" << layerSize << " batchSize=" << batchSize
<< " normByTimes = " << normByTimes << " useGpu=" << useGpu;
FLAGS_use_gpu = useGpu;
Argument data0;
initArgument(batchSize, layerSize, useGpu, data0);
Argument data1;
data1.resizeAndCopyFrom(data0);
LayerPtr dataLayer0 =
createDataLayer("data", batchSize, layerSize, useGpu, data0);
LayerPtr dataLayer1 =
createDataLayer("data", batchSize, layerSize, useGpu, data1);
LayerPtr labelLayer =
createLabelLayer("label", batchSize, layerSize, useGpu);
LayerPtr warpctcLayer = createWarpCTCLayer(
"cost", layerSize, useGpu, normByTimes, dataLayer0, labelLayer);
LayerPtr ctcLayer = createCTCLayer(
"cost", layerSize, useGpu, normByTimes, dataLayer1, labelLayer);
/// Check cost
LOG(INFO) << "Check cost: "
<< checkError(*(warpctcLayer->getOutput().value),
*(ctcLayer->getOutput().value))
<< " different elements.";
/// Check gradients
LOG(INFO) << "Check gradients: "
<< checkError(*(dataLayer0->getOutput().grad),
*(dataLayer1->getOutput().grad))
<< " different elements";
}
}
}
}
}
void Layer::addSublayer(const LayerPtr& layer)
{
if(!isSublayer(layer))
{
if(layer->superlayer)
{
WOUT("added layer that already had superlayer: "<<layer->description());
}
layer->superlayer = this;
sublayers.push_back(layer);
}
else
{
WOUT("tried to add layer that was already sublayer: "<<layer->description());
}
}
void Node::visit(const Matrix4& newTransformMatrix, bool parentTransformDirty, const LayerPtr& currentLayer)
{
if (parentTransformDirty)
{
updateTransform(newTransformMatrix);
}
if (transformDirty)
{
calculateTransform();
}
if (currentLayer)
{
for (const NodePtr& child : children)
{
if (child->isVisible())
{
if (child->isGlobalOrder())
{
currentLayer->addGlobalNode(child);
}
child->visit(transform, updateChildrenTransform, currentLayer);
}
}
}
updateChildrenTransform = false;
}
// callbacks used by readline to handle input from console
int console_blit_selection(ContextPtr env, char *cmd) {
if(!cmd) return 0;
if(!strlen(cmd)) return 0;
ViewPortPtr screen = getSelectedScreen();
if(!screen) {
::error("no screen currently selected");
return 0;
}
LayerPtr lay = getSelectedLayer();
if(!lay) {
::error("no layer currently selected");
return 0;
}
lay->set_blit(cmd); // now this takes a string!
return 1;
}
// Do one forward pass of priorBox layer and check to see if its output
// matches the given result
void doOnePriorBoxTest(size_t feature_map_width,
size_t feature_map_height,
size_t image_width,
size_t image_height,
vector<int> min_size,
vector<int> max_size,
vector<real> aspect_ratio,
vector<real> variance,
bool use_gpu,
MatrixPtr& result) {
// Setting up the priorbox layer
TestConfig configt;
configt.layerConfig.set_type("priorbox");
configt.inputDefs.push_back({INPUT_DATA, "featureMap", 1, 0});
LayerInputConfig* input = configt.layerConfig.add_inputs();
configt.inputDefs.push_back({INPUT_DATA, "image", 1, 0});
configt.layerConfig.add_inputs();
PriorBoxConfig* pb = input->mutable_priorbox_conf();
for (size_t i = 0; i < min_size.size(); i++) pb->add_min_size(min_size[i]);
for (size_t i = 0; i < max_size.size(); i++) pb->add_max_size(max_size[i]);
for (size_t i = 0; i < variance.size(); i++) pb->add_variance(variance[i]);
for (size_t i = 0; i < aspect_ratio.size(); i++)
pb->add_aspect_ratio(aspect_ratio[i]);
// data layer initialize
std::vector<DataLayerPtr> dataLayers;
LayerMap layerMap;
vector<Argument> datas;
initDataLayer(
configt, &dataLayers, &datas, &layerMap, "priorbox", 1, false, use_gpu);
dataLayers[0]->getOutput().setFrameHeight(feature_map_height);
dataLayers[0]->getOutput().setFrameWidth(feature_map_width);
dataLayers[1]->getOutput().setFrameHeight(image_height);
dataLayers[1]->getOutput().setFrameWidth(image_width);
// test layer initialize
std::vector<ParameterPtr> parameters;
LayerPtr priorboxLayer;
initTestLayer(configt, &layerMap, ¶meters, &priorboxLayer);
priorboxLayer->forward(PASS_GC);
checkMatrixEqual(priorboxLayer->getOutputValue(), result);
}
void Node::process(const LayerPtr& currentLayer)
{
if (children.empty())
{
if (currentLayer->checkVisibility(std::static_pointer_cast<Node>(shared_from_this())))
{
currentLayer->addToDrawQueue(std::static_pointer_cast<Node>(shared_from_this()));
}
}
else
{
std::stable_sort(children.begin(), children.end(), [](const NodePtr& a, const NodePtr& b) {
return a->getZ() > b->getZ();
});
auto i = children.begin();
NodePtr node;
for (; i != children.end(); ++i)
{
node = *i;
if (node->getZ() < 0.0f)
{
if (!node->isGlobalOrder() && node->isVisible() && currentLayer->checkVisibility(node))
{
currentLayer->addToDrawQueue(node);
}
}
else
{
break;
}
}
if (currentLayer->checkVisibility(std::static_pointer_cast<Node>(shared_from_this())))
{
currentLayer->addToDrawQueue(std::static_pointer_cast<Node>(shared_from_this()));
}
for (; i != children.end(); ++i)
{
node = *i;
if (!node->isGlobalOrder() && node->isVisible() && currentLayer->checkVisibility(node))
{
currentLayer->addToDrawQueue(node);
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Called when the "New Layer From Selection" button is clicked on the toolbar.
//
void LayersPanel::OnNewLayerFromSelection( wxCommandEvent& dummyEvt )
{
if ( m_Scene )
{
if(IsSelectionValid() == false)
{
return;
}
BatchUndoCommandPtr batch = new BatchUndoCommand ();
LayerPtr layer = new Layer();
layer->SetOwner( m_Scene );
layer->Initialize();
// Generate a name for this layer
GenerateLayerName(layer);
batch->Push( new SceneNodeExistenceCommand( ExistenceActions::Add, m_Scene, layer ) );
// Step 2: add all the selected items to the layer
const OS_ObjectDumbPtr& selection = m_Scene->GetSelection().GetItems();
OS_ObjectDumbPtr::Iterator itr = selection.Begin();
OS_ObjectDumbPtr::Iterator end = selection.End();
for ( ; itr != end; ++itr )
{
//If the element is a supported type
if( *itr )
{
SceneNode* node = Reflect::SafeCast< SceneNode >( *itr );
if ( node )
{
batch->Push( new DependencyCommand( DependencyCommand::Connect, layer, node ) );
}
}
}
m_Scene->Push( batch );
m_Scene->Execute( false );
}
}
bool FreeframeInstance::apply(LayerPtr lay) {
if(!FilterInstance::apply(lay)) {
return false;
}
auto freeframe = DynamicPointerCast<Freeframe>(proto);
auto &geo = lay->getGeometry();
VideoInfoStruct vidinfo;
vidinfo.frameWidth = geo.w;
vidinfo.frameHeight = geo.h;
vidinfo.orientation = 1;
vidinfo.bitDepth = FF_CAP_32BITVIDEO;
core = freeframe->plugmain(FF_INSTANTIATE, &vidinfo, 0).ivalue;
return core != FF_FAIL;
}
void Node::draw(const LayerPtr& currentLayer)
{
if (transformDirty)
{
calculateTransform();
}
if (currentLayer)
{
if (currentLayer->getCamera())
{
graphics::Color drawColor(color.r, color.g, color.b, static_cast<uint8_t>(color.a * opacity));
for (const DrawablePtr& drawable : drawables)
{
if (drawable->isVisible())
{
drawable->draw(currentLayer->getCamera()->getViewProjection(), transform, drawColor);
}
}
}
}
}
void Layer::removeSublayer(const LayerPtr& layer)
{
auto pos = std::find(sublayers.begin(), sublayers.end(), layer);
if(pos != sublayers.end())
{
LayerPtr sublayer = *pos;
sublayer->superlayer = NULL;
sublayers.erase(pos);
}
else
{
WOUT("tried to remove layer that wasn't sublayer: "<<layer->description());
}
}
/**
* \brief Add an image
*
* Adding an image to the stack means that we have to find the transform
* is needed to make the image congruent to the base image
*/
void Stack::add(ImagePtr image) {
debug(LOG_DEBUG, DEBUG_LOG, 0,
"adding %s-sized image to stack (already %d images)",
image->size().toString().c_str(), size());
// create a new layer
LayerPtr newlayer = LayerPtr(new Layer(image));
// get adapters for the two images to compare
StackingAdapter *baseadapter = StackingAdapter::get(_base);
StackingAdapterPtr baseadapterptr(baseadapter);
StackingAdapter *imageadapter = StackingAdapter::get(image);
StackingAdapterPtr imageadapterptr(imageadapter);
// use a transform analyzer to find the transform, add the transform
// to the layer
transform::TransformAnalyzer ta(*baseadapter, 2048, 2048);
newlayer->transform(ta(*imageadapter));
// add the layer to the stack
debug(LOG_DEBUG, DEBUG_LOG, 0, "adding layer %d: %s", size(),
newlayer->toString().c_str());
push_back(newlayer);
}
// Do one forward pass of convTrans layer and check to see if its output
// matches the given result
void doOneConvtTest(size_t imgSize,
size_t output_x,
size_t stride,
size_t padding,
size_t filter_size,
MatrixPtr& result) {
TestConfig configt;
configt.biasSize = 1;
configt.layerConfig.set_type("exconvt");
configt.layerConfig.set_num_filters(1);
configt.layerConfig.set_partial_sum(1);
configt.layerConfig.set_shared_biases(true);
configt.inputDefs.push_back(
{INPUT_DATA, "layer_0", output_x * output_x, filter_size * filter_size});
LayerInputConfig* input = configt.layerConfig.add_inputs();
ConvConfig* conv = input->mutable_conv_conf();
conv->set_filter_size(filter_size);
conv->set_filter_size_y(filter_size);
conv->set_channels(1);
conv->set_padding(padding);
conv->set_padding_y(padding);
conv->set_stride(stride);
conv->set_stride_y(stride);
conv->set_groups(1);
conv->set_filter_channels(1);
conv->set_img_size(imgSize);
conv->set_output_x(output_x);
configt.layerConfig.set_size(conv->img_size() * conv->img_size() *
configt.layerConfig.num_filters());
configt.layerConfig.set_name("convTrans");
std::vector<DataLayerPtr> dataLayers;
LayerMap layerMap;
vector<Argument> datas;
initDataLayer(
configt, &dataLayers, &datas, &layerMap, "convTrans", 1, false, false);
dataLayers[0]->getOutputValue()->zeroMem();
dataLayers[0]->getOutputValue()->add(1.0);
// test layer initialize
std::vector<ParameterPtr> parameters;
LayerPtr convtLayer;
initTestLayer(configt, &layerMap, ¶meters, &convtLayer);
convtLayer->getBiasParameter()->zeroMem();
convtLayer->getParameters()[0]->zeroMem();
convtLayer->getParameters()[0]->getBuf(PARAMETER_VALUE)->add(1.0);
convtLayer->forward(PASS_GC);
checkMatrixEqual(convtLayer->getOutputValue(), result);
}
LayerPtr createWarpCTCLayer(string name,
size_t numClasses,
bool useGpu,
bool normByTimes,
LayerPtr dataLayer,
LayerPtr labelLayer) {
LayerMap layerMap;
layerMap[dataLayer->getName()] = dataLayer;
layerMap[labelLayer->getName()] = labelLayer;
ParameterMap parameterMap;
LayerConfig layerConfig;
layerConfig.set_name(name);
layerConfig.set_type("warp_ctc");
layerConfig.set_size(numClasses);
layerConfig.set_blank(numClasses - 1);
layerConfig.set_norm_by_times(normByTimes);
layerConfig.add_inputs();
LayerInputConfig& input0 = *(layerConfig.mutable_inputs(0));
input0.set_input_layer_name(dataLayer->getName());
layerConfig.add_inputs();
LayerInputConfig& input1 = *(layerConfig.mutable_inputs(1));
input1.set_input_layer_name(labelLayer->getName());
LayerPtr layer = LayerPtr(new WarpCTCLayer(layerConfig));
layerMap[layer->getName()] = layer;
layer->init(layerMap, parameterMap);
layer->forward(PASS_GC);
layer->backward();
return layer;
}
/// Initialize this system.
///
/// @param[in] rCommandLineInitialization Interface for initializing command-line parameters.
/// @param[in] rObjectTypeRegistration Interface for registering GameObject-based types. Note that this must
/// remain valid until Shutdown() is called on this system, as a reference
/// to it will be held by this system.
/// @param[in] rMemoryHeapPreInitialization Interface for performing any necessary pre-initialization of dynamic
/// memory heaps.
/// @param[in] rObjectLoaderInitialization Interface for creating and initializing the main GameObjectLoader instance.
/// Note that this must remain valid until Shutdown() is called on this
/// system, as a reference to it will be held by this system.
/// @param[in] rConfigInitialization Interface for initializing application configuration settings.
/// @param[in] rWindowManagerInitialization Interface for creating and initializing the global window manager
/// instance.
/// @param[in] rRendererInitialization Interface for creating and initializing the global renderer instance.
/// @param[in] pWorldType Type of World to create for the main world. If this is null, the
/// actual World type will be used.
bool GameSystem::Initialize(
CommandLineInitialization& rCommandLineInitialization,
ObjectTypeRegistration& rObjectTypeRegistration,
MemoryHeapPreInitialization& rMemoryHeapPreInitialization,
ObjectLoaderInitialization& rObjectLoaderInitialization,
ConfigInitialization& rConfigInitialization,
WindowManagerInitialization& rWindowManagerInitialization,
RendererInitialization& rRendererInitialization,
const GameObjectType* pWorldType )
{
// Initialize the timer first of all, in case someone wants to use it.
Timer::StaticInitialize();
// Initialize command-line parameters.
bool bCommandLineInitSuccess = rCommandLineInitialization.Initialize( m_moduleName, m_arguments );
HELIUM_ASSERT( bCommandLineInitSuccess );
if( !bCommandLineInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): Command-line initialization failed.\n" ) );
return false;
}
#if HELIUM_ENABLE_TRACE
HELIUM_TRACE( TRACE_INFO, TXT( "Module name: %s\n" ), *m_moduleName );
HELIUM_TRACE( TRACE_INFO, TXT( "Command-line arguments:\n" ) );
size_t argumentCount = m_arguments.GetSize();
for( size_t argumentIndex = 0; argumentIndex < argumentCount; ++argumentIndex )
{
HELIUM_TRACE( TRACE_INFO, TXT( "* %s\n" ), *m_arguments[ argumentIndex ] );
}
#endif
// Initialize the async loading thread.
bool bAsyncLoaderInitSuccess = AsyncLoader::GetStaticInstance().Initialize();
HELIUM_ASSERT( bAsyncLoaderInitSuccess );
if( !bAsyncLoaderInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): Async loader initialization failed.\n" ) );
return false;
}
//pmd - Initialize the cache manager
Path baseDirectory;
if ( !File::GetBaseDirectory( baseDirectory ) )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "Could not get base directory." ) );
return false;
}
HELIUM_VERIFY( CacheManager::InitializeStaticInstance( baseDirectory ) );
// Initialize the reflection type registry and register GameObject-based types.
Reflect::Initialize();
rObjectTypeRegistration.Register();
m_pObjectTypeRegistration = &rObjectTypeRegistration;
// Perform dynamic memory heap pre-initialization.
rMemoryHeapPreInitialization.PreInitialize();
// Create and initialize the main GameObjectLoader instance.
GameObjectLoader* pObjectLoader = rObjectLoaderInitialization.Initialize();
HELIUM_ASSERT( pObjectLoader );
if( !pObjectLoader )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): GameObject loader initialization failed.\n" ) );
return false;
}
m_pObjectLoaderInitialization = &rObjectLoaderInitialization;
// Initialize system configuration.
bool bConfigInitSuccess = rConfigInitialization.Initialize();
HELIUM_ASSERT( bConfigInitSuccess );
if( !bConfigInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): Failed to initialize configuration settings.\n" ) );
return false;
}
// Initialize the job manager.
bool bJobManagerInitSuccess = JobManager::GetStaticInstance().Initialize();
HELIUM_ASSERT( bJobManagerInitSuccess );
if( !bJobManagerInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): Job manager initialization failed.\n" ) );
return false;
}
// Create and initialize the window manager (note that we need a window manager for message loop processing, so
// the instance cannot be left null).
bool bWindowManagerInitSuccess = rWindowManagerInitialization.Initialize();
HELIUM_ASSERT( bWindowManagerInitSuccess );
if( !bWindowManagerInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): Window manager initialization failed.\n" ) );
return false;
}
WindowManager* pWindowManager = WindowManager::GetStaticInstance();
if( !pWindowManager )
{
HELIUM_TRACE(
TRACE_INFO,
( TXT( "GameSystem::Initialize(): No window manager created. A window manager is necessary for " )
TXT( "GameSystem execution.\n" ) ) );
return false;
}
// Create and initialize the renderer.
bool bRendererInitSuccess = rRendererInitialization.Initialize();
HELIUM_ASSERT( bRendererInitSuccess );
if( !bRendererInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "GameSystem::Initialize(): Renderer initialization failed.\n" ) );
return false;
}
Renderer* pRenderer = Renderer::GetStaticInstance();
if( !pRenderer )
{
HELIUM_TRACE( TRACE_INFO, TXT( "GameSystem::Initialize(): Using null renderer.\n" ) );
}
else
{
// Create the main application window.
Config& rConfig = Config::GetStaticInstance();
StrongPtr< GraphicsConfig > spGraphicsConfig(
rConfig.GetConfigObject< GraphicsConfig >( Name( TXT( "GraphicsConfig" ) ) ) );
HELIUM_ASSERT( spGraphicsConfig );
uint32_t displayWidth = spGraphicsConfig->GetWidth();
uint32_t displayHeight = spGraphicsConfig->GetHeight();
bool bFullscreen = spGraphicsConfig->GetFullscreen();
bool bVsync = spGraphicsConfig->GetVsync();
Window::Parameters windowParameters;
windowParameters.pTitle = TXT( "Lunar" );
windowParameters.width = displayWidth;
windowParameters.height = displayHeight;
windowParameters.bFullscreen = bFullscreen;
m_pMainWindow = pWindowManager->Create( windowParameters );
HELIUM_ASSERT( m_pMainWindow );
if( !m_pMainWindow )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "Failed to create main application window.\n" ) );
return false;
}
m_pMainWindow->SetOnDestroyed( boost::bind( &GameSystem::OnMainWindowDestroyed, this, _1 ) );
Renderer::ContextInitParameters contextInitParams;
contextInitParams.pWindow = m_pMainWindow->GetHandle();
contextInitParams.displayWidth = displayWidth;
contextInitParams.displayHeight = displayHeight;
contextInitParams.bFullscreen = bFullscreen;
contextInitParams.bVsync = bVsync;
bool bContextCreateResult = pRenderer->CreateMainContext( contextInitParams );
HELIUM_ASSERT( bContextCreateResult );
if( !bContextCreateResult )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "Failed to create main renderer context.\n" ) );
return false;
}
// Create and initialize the render resource manager.
RenderResourceManager& rRenderResourceManager = RenderResourceManager::GetStaticInstance();
rRenderResourceManager.Initialize();
// Create and initialize the dynamic drawing interface.
DynamicDrawer& rDynamicDrawer = DynamicDrawer::GetStaticInstance();
if( !rDynamicDrawer.Initialize() )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "Failed to initialize dynamic drawing support.\n" ) );
return false;
}
}
// Initialize the world manager and main game world.
WorldManager& rWorldManager = WorldManager::GetStaticInstance();
bool bWorldManagerInitSuccess = rWorldManager.Initialize();
HELIUM_ASSERT( bWorldManagerInitSuccess );
if( !bWorldManagerInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "World manager initialization failed.\n" ) );
return false;
}
if( !pWorldType )
{
pWorldType = World::GetStaticType();
HELIUM_ASSERT( pWorldType );
}
WorldPtr spDefaultWorld( rWorldManager.CreateDefaultWorld( pWorldType ) );
HELIUM_ASSERT( spDefaultWorld );
if( !spDefaultWorld )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "Failed to create the default world.\n" ) );
return false;
}
HELIUM_TRACE( TRACE_INFO, TXT( "Created default world \"%s\".\n" ), *spDefaultWorld->GetPath().ToString() );
bool bWorldInitSuccess = spDefaultWorld->Initialize();
HELIUM_ASSERT( bWorldInitSuccess );
if( !bWorldInitSuccess )
{
HELIUM_TRACE( TRACE_ERROR, TXT( "Failed to initialize default world.\n" ) );
return false;
}
PackagePtr spLayerPackage;
HELIUM_VERIFY( GameObject::Create< Package >( spLayerPackage, Name( TXT( "DefaultLayerPackage" ) ), NULL ) );
HELIUM_ASSERT( spLayerPackage );
LayerPtr spLayer;
HELIUM_VERIFY( GameObject::Create< Layer >( spLayer, Name( TXT( "Layer" ) ), spLayerPackage ) );
HELIUM_ASSERT( spLayer );
spLayer->BindPackage( spLayerPackage );
HELIUM_VERIFY( spDefaultWorld->AddLayer( spLayer ) );
// Initialization complete.
return true;
}
int console_blit_param_completion(ContextPtr env, char *cmd) {
ViewPortPtr screen = getSelectedScreen();
if(!screen) {
::error("no screen currently selected");
return 0;
}
LayerPtr lay = getSelectedLayer();
if(!lay) {
::error("no layer currently selected");
return 0;
}
BlitInstancePtr b = lay->getCurrentBlit();
if(!b) {
::error("no blit selected on layer %s", lay->getName().c_str());
return 0;
}
// Find completions
// Find completions
ParameterInstancePtr exactParam;
LinkList<ParameterInstance> retList;
LinkList<ParameterInstance> &list = b->getParameters();
std::string cmdString(cmd);
std::transform(cmdString.begin(), cmdString.end(), cmdString.begin(), ::tolower);
std::copy_if(list.begin(), list.end(), retList.begin(), [&] (ParameterInstancePtr param) {
std::string name = param->getName();
std::transform(name.begin(), name.end(), name.begin(), ::tolower);
if(name == cmdString) {
exactParam = param;
}
return name.compare(cmdString) == 0;
});
if(retList.empty()) return 0;
if(exactParam != NULL) {
snprintf(cmd, MAX_CMDLINE, "%s = ", exactParam->getName().c_str());
return 1;
}
if(cmdString.empty()) {
notice("List available blit parameters");
} else {
notice("List available blit parameters starting with \"%s\"", cmd);
}
int c = 0;
std::for_each(retList.begin(), retList.end(), [&] (ParameterInstancePtr p) {
switch(p->getType()) {
case Parameter::BOOL:
::act("(bool) %s = %s :: %s", p->getName().c_str(),
(*(bool*)p->get() == true) ? "true" : "false",
p->getDescription().c_str());
break;
case Parameter::NUMBER:
::act("(number) %s = %.2f :: %s", p->getName().c_str(),
*(float*)p->get(),
p->getDescription().c_str());
break;
case Parameter::STRING:
::act("(string) %s = %s :: %s", p->getName().c_str(), (char*)p->get(), p->getDescription().c_str());
break;
case Parameter::POSITION: {
float *val = (float*)p->get();
::act("(position) %s = %.2f x %.2f :: %s", p->getName().c_str(),
val[0], val[1],
p->getDescription().c_str());
}
break;
case Parameter::COLOR:
::act("%s (color) %s", p->getName().c_str(), p->getDescription().c_str());
break;
default:
::error("%s (unknown) %s", p->getName().c_str(), p->getDescription().c_str());
break;
}
++c;
});
return c;
}
int console_param_selection(ContextPtr env, char *cmd) {
if(!cmd) return 0;
if(!strlen(cmd)) return 0;
ViewPortPtr screen = getSelectedScreen();
if(!screen) {
::error("no screen currently selected");
return 0;
}
LayerPtr lay = getSelectedLayer();
if(!lay) {
::error("no layer currently selected");
return 0;
}
FilterInstancePtr filt = getSelectedFilter();
// find the values after the first blank space
char *p;
for(p = cmd; *p != '\0'; p++)
if(*p == '=') {
*p = '\0';
if(*(p - 1) == ' ')
*(p - 1) = '\0';
p++;
break;
}
while(*p == ' ') p++; // jump all spaces
if(*p == '\0') return 0; // no value was given
if(filt) { ///////////////////////// parameters for filter
LinkList<ParameterInstance> &list = filt->getParameters();
LinkList<ParameterInstance>::iterator it = std::find_if(list.begin(), list.end(), [&] (ParameterInstancePtr ¶m) {
return param->getName() == cmd;
});
if(it == list.end()) {
error("parameter %s not found in filter %s", cmd, filt->getName().c_str());
return 0;
} else {
ParameterInstancePtr param = *it;
func("parameter %s found in filter %s",
param->getName().c_str(), filt->getName().c_str());
// parse from the string to the value
param->parse(p);
}
} else { /////// parameters for layer
LinkList<ParameterInstance> &list = lay->getParameters();
LinkList<ParameterInstance>::iterator it = std::find_if(list.begin(), list.end(), [&] (ParameterInstancePtr ¶m) {
return param->getName() == cmd;
});
if(it == list.end()) {
error("parameter %s not found in layers %s", cmd, lay->getName().c_str());
return 0;
} else {
ParameterInstancePtr param = *it;
func("parameter %s found in layer %s at position %u",
param->getName().c_str(), lay->getName().c_str());
// parse from the string to the value
param->parse(p);
}
}
return 1;
}
LayerPtr createCTCLayer(string name,
size_t numClasses,
bool useGpu,
bool normByTimes,
LayerPtr dataLayer,
LayerPtr labelLayer) {
LayerMap layerMap;
layerMap[dataLayer->getName()] = dataLayer;
layerMap[labelLayer->getName()] = labelLayer;
ParameterMap parameterMap;
LayerConfig layerConfig;
layerConfig.set_name(name);
layerConfig.set_type("ctc");
layerConfig.set_size(numClasses);
layerConfig.set_norm_by_times(normByTimes);
layerConfig.add_inputs();
LayerInputConfig& input0 = *(layerConfig.mutable_inputs(0));
input0.set_input_layer_name(dataLayer->getName());
layerConfig.add_inputs();
LayerInputConfig& input1 = *(layerConfig.mutable_inputs(1));
input1.set_input_layer_name(labelLayer->getName());
LayerPtr layer = LayerPtr(new CTCLayer(layerConfig));
layerMap[layer->getName()] = layer;
layer->init(layerMap, parameterMap);
ActivationFunction* softmaxActivation = ActivationFunction::create("softmax");
softmaxActivation->forward(dataLayer->getOutput()).check();
layer->forward(PASS_GC);
layer->backward();
softmaxActivation->backward(dataLayer->getOutput()).check();
return layer;
}
// Test that the convTrans forward is the same as conv backward
TEST(Layer, convTransLayerFwd) {
// Setting up conv-trans layer
TestConfig configt;
configt.biasSize = 3;
configt.layerConfig.set_type("exconvt");
configt.layerConfig.set_num_filters(3);
configt.layerConfig.set_partial_sum(1);
configt.layerConfig.set_shared_biases(true);
configt.inputDefs.push_back({INPUT_DATA, "layer_0", 1024, 384});
LayerInputConfig* input = configt.layerConfig.add_inputs();
ConvConfig* conv = input->mutable_conv_conf();
conv->set_filter_size(2);
conv->set_filter_size_y(4);
conv->set_channels(16);
conv->set_padding(0);
conv->set_padding_y(1);
conv->set_stride(2);
conv->set_stride_y(2);
conv->set_groups(1);
conv->set_filter_channels(3 / conv->groups());
conv->set_img_size(16);
conv->set_output_x(outputSize(conv->img_size(), conv->filter_size(),
conv->padding(), conv->stride(),
/* caffeMode */ true));
configt.layerConfig.set_size(conv->img_size() * conv->img_size() *
configt.layerConfig.num_filters());
configt.layerConfig.set_name("convTrans");
// data layer initialize
std::vector<DataLayerPtr> dataLayers;
LayerMap layerMap;
vector<Argument> datas;
initDataLayer(configt, &dataLayers, &datas, &layerMap, "convTrans",
100, false, false);
// test layer initialize
std::vector<ParameterPtr> parameters;
LayerPtr convtLayer;
initTestLayer(configt, &layerMap, ¶meters, &convtLayer);
convtLayer->getBiasParameter()->zeroMem();
convtLayer->forward(PASS_GC);
// Setting up conv-layer config
TestConfig config;
config.biasSize = 16;
config.layerConfig.set_type("exconv");
config.layerConfig.set_num_filters(16);
config.layerConfig.set_partial_sum(1);
config.layerConfig.set_shared_biases(true);
config.inputDefs.push_back({INPUT_DATA, "layer_1", 768, 384});
input = config.layerConfig.add_inputs();
conv = input->mutable_conv_conf();
conv->set_filter_size(2);
conv->set_filter_size_y(4);
conv->set_channels(3);
conv->set_padding(0);
conv->set_padding_y(1);
conv->set_stride(2);
conv->set_stride_y(2);
conv->set_groups(1);
conv->set_filter_channels(conv->channels() / conv->groups());
conv->set_img_size(16);
conv->set_output_x(outputSize(conv->img_size(), conv->filter_size(),
conv->padding(), conv->stride(),
/* caffeMode */ true));
config.layerConfig.set_size(conv->output_x() * conv->output_x() *
config.layerConfig.num_filters());
config.layerConfig.set_name("conv");
// data layer initialize
std::vector<DataLayerPtr> dataLayers2;
LayerMap layerMap2;
vector<Argument> datas2;
initDataLayer(config, &dataLayers2, &datas2, &layerMap2, "conv",
100, false, false);
// test layer initialize
std::vector<ParameterPtr> parameters2;
LayerPtr convLayer;
initTestLayer(config, &layerMap2, ¶meters2, &convLayer);
// Sync convLayer and convtLayer parameter
convLayer->getBiasParameter()->zeroMem();
convLayer->getParameters()[0]->getBuf(PARAMETER_VALUE)->copyFrom(
*(convtLayer->getParameters()[0]->getBuf(PARAMETER_VALUE)));
// Set convLayer outputGrad as convTransLayer input value
convLayer->forward(PASS_GC);
convLayer->getOutput().grad->copyFrom(*(dataLayers[0]->getOutputValue()));
vector<int> callbackFlags(parameters2.size(), 0);
auto callback = [&](Parameter* para) { ++callbackFlags[para->getID()]; };
convLayer->backward(callback);
// Check that the convLayer backward is the same as convTransLayer forward
checkMatrixEqual(convtLayer->getOutputValue(),
dataLayers2[0]->getOutputGrad());
}
