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()); }