void CoordinatedGraphicsScene::commitSceneState(const CoordinatedGraphicsState& state) { m_renderedContentsScrollPosition = state.scrollPosition; createLayers(state.layersToCreate); deleteLayers(state.layersToRemove); if (state.rootCompositingLayer != m_rootLayerID) setRootLayerID(state.rootCompositingLayer); syncImageBackings(state); syncUpdateAtlases(state); for (size_t i = 0; i < state.layersToUpdate.size(); ++i) setLayerState(state.layersToUpdate[i].first, state.layersToUpdate[i].second); commitPendingBackingStoreOperations(); removeReleasedImageBackingsIfNeeded(); // The pending tiles state is on its way for the screen, tell the web process to render the next one. RefPtr<CoordinatedGraphicsScene> protector(this); dispatchOnMainThread([=] { protector->renderNextFrame(); }); }
void CoordinatedGraphicsScene::commitSceneState(const CoordinatedGraphicsState& state) { m_renderedContentsScrollPosition = state.scrollPosition; createLayers(state.layersToCreate); deleteLayers(state.layersToRemove); if (state.rootCompositingLayer != m_rootLayerID) setRootLayerID(state.rootCompositingLayer); syncImageBackings(state); syncUpdateAtlases(state); #if ENABLE(CSS_SHADERS) syncCustomFilterPrograms(state); #endif for (size_t i = 0; i < state.layersToUpdate.size(); ++i) setLayerState(state.layersToUpdate[i].first, state.layersToUpdate[i].second); commitPendingBackingStoreOperations(); removeReleasedImageBackingsIfNeeded(); // The pending tiles state is on its way for the screen, tell the web process to render the next one. dispatchOnMainThread(bind(&CoordinatedGraphicsScene::renderNextFrame, this)); }
void CoordinatedGraphicsScene::commitSceneState(const CoordinatedGraphicsState& state) { m_renderedContentsScrollPosition = state.scrollPosition; createLayers(state.layersToCreate); deleteLayers(state.layersToRemove); if (state.rootCompositingLayer != m_rootLayerID) setRootLayerID(state.rootCompositingLayer); syncImageBackings(state); syncUpdateAtlases(state); for (auto& layer : state.layersToUpdate) setLayerState(layer.first, layer.second); commitPendingBackingStoreOperations(); removeReleasedImageBackingsIfNeeded(); }
void CINFO3D_VISU::InitSettings( REPORTER *aStatusTextReporter ) { wxLogTrace( m_logTrace, wxT( "CINFO3D_VISU::InitSettings" ) ); // Calculates the board bounding box // First, use only the board outlines EDA_RECT bbbox = m_board->ComputeBoundingBox( true ); // If no outlines, use the board with items if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) ) bbbox = m_board->ComputeBoundingBox( false ); // Gives a non null size to avoid issues in zoom / scale calculations if( ( bbbox.GetWidth() == 0 ) && ( bbbox.GetHeight() == 0 ) ) bbbox.Inflate( Millimeter2iu( 10 ) ); m_boardSize = bbbox.GetSize(); m_boardPos = bbbox.Centre(); wxASSERT( (m_boardSize.x > 0) && (m_boardSize.y > 0) ); m_boardPos.y = -m_boardPos.y; // The y coord is inverted in 3D viewer m_copperLayersCount = m_board->GetCopperLayerCount(); // Ensure the board has 2 sides for 3D views, because it is hard to find // a *really* single side board in the true life... if( m_copperLayersCount < 2 ) m_copperLayersCount = 2; // Calculate the convertion to apply to all positions. m_biuTo3Dunits = RANGE_SCALE_3D / std::max( m_boardSize.x, m_boardSize.y ); // Calculate factors for cicle segment approximation m_calc_seg_min_factor3DU = (float)( SEG_MIN_FACTOR_BIU * m_biuTo3Dunits ); m_calc_seg_max_factor3DU = (float)( SEG_MAX_FACTOR_BIU * m_biuTo3Dunits ); m_epoxyThickness3DU = m_board->GetDesignSettings().GetBoardThickness() * m_biuTo3Dunits; // !TODO: use value defined by user (currently use default values by ctor m_copperThickness3DU = COPPER_THICKNESS * m_biuTo3Dunits; m_nonCopperLayerThickness3DU = TECH_LAYER_THICKNESS * m_biuTo3Dunits; // Init Z position of each layer // calculate z position for each copper layer // Zstart = -m_epoxyThickness / 2.0 is the z position of the back (bottom layer) (layer id = 31) // Zstart = +m_epoxyThickness / 2.0 is the z position of the front (top layer) (layer id = 0) // all unused copper layer z position are set to 0 // ____==__________==________==______ <- Bottom = +m_epoxyThickness / 2.0, // | | Top = Bottom + m_copperThickness // |__________________________________| // == == == == <- Bottom = -m_epoxyThickness / 2.0, // Top = Bottom - m_copperThickness unsigned int layer; for( layer = 0; layer < m_copperLayersCount; ++layer ) { m_layerZcoordBottom[layer] = m_epoxyThickness3DU / 2.0f - (m_epoxyThickness3DU * layer / (m_copperLayersCount - 1) ); if( layer < (m_copperLayersCount / 2) ) m_layerZcoordTop[layer] = m_layerZcoordBottom[layer] + m_copperThickness3DU; else m_layerZcoordTop[layer] = m_layerZcoordBottom[layer] - m_copperThickness3DU; } #define layerThicknessMargin 1.1 const float zpos_offset = m_nonCopperLayerThickness3DU * layerThicknessMargin; // Fill remaining unused copper layers and back layer zpos // with -m_epoxyThickness / 2.0 for( ; layer < MAX_CU_LAYERS; layer++ ) { m_layerZcoordBottom[layer] = -(m_epoxyThickness3DU / 2.0f); m_layerZcoordTop[layer] = -(m_epoxyThickness3DU / 2.0f) - m_copperThickness3DU; } // This is the top of the copper layer thickness. const float zpos_copperTop_back = m_layerZcoordTop[B_Cu]; const float zpos_copperTop_front = m_layerZcoordTop[F_Cu]; // calculate z position for each non copper layer // Solder mask and Solder paste have the same Z position for( int layer_id = MAX_CU_LAYERS; layer_id < LAYER_ID_COUNT; ++layer_id ) { float zposTop; float zposBottom; switch( layer_id ) { case B_Adhes: zposBottom = zpos_copperTop_back - 2.0f * zpos_offset; zposTop = zposBottom - m_nonCopperLayerThickness3DU; break; case F_Adhes: zposBottom = zpos_copperTop_front + 2.0f * zpos_offset; zposTop = zposBottom + m_nonCopperLayerThickness3DU; break; case B_Mask: case B_Paste: zposBottom = zpos_copperTop_back; zposTop = zpos_copperTop_back - m_nonCopperLayerThickness3DU; break; case F_Mask: case F_Paste: zposTop = zpos_copperTop_front + m_nonCopperLayerThickness3DU; zposBottom = zpos_copperTop_front; break; case B_SilkS: zposBottom = zpos_copperTop_back - 1.0f * zpos_offset; zposTop = zposBottom - m_nonCopperLayerThickness3DU; break; case F_SilkS: zposBottom = zpos_copperTop_front + 1.0f * zpos_offset; zposTop = zposBottom + m_nonCopperLayerThickness3DU; break; // !TODO: review default: zposTop = zpos_copperTop_front + (layer_id - MAX_CU_LAYERS + 3.0f) * zpos_offset; zposBottom = zposTop - m_nonCopperLayerThickness3DU; break; } m_layerZcoordTop[layer_id] = zposTop; m_layerZcoordBottom[layer_id] = zposBottom; } m_boardCenter = SFVEC3F( m_boardPos.x * m_biuTo3Dunits, m_boardPos.y * m_biuTo3Dunits, 0.0f ); SFVEC3F boardSize = SFVEC3F( m_boardSize.x * m_biuTo3Dunits, m_boardSize.y * m_biuTo3Dunits, 0.0f ); boardSize /= 2.0f; SFVEC3F boardMin = (m_boardCenter - boardSize); SFVEC3F boardMax = (m_boardCenter + boardSize); boardMin.z = m_layerZcoordTop[B_Adhes]; boardMax.z = m_layerZcoordTop[F_Adhes]; m_boardBoudingBox = CBBOX( boardMin, boardMax ); #ifdef PRINT_STATISTICS_3D_VIEWER unsigned stats_startCreateBoardPolyTime = GetRunningMicroSecs(); #endif if( aStatusTextReporter ) aStatusTextReporter->Report( _( "Build board body" ) ); createBoardPolygon(); #ifdef PRINT_STATISTICS_3D_VIEWER unsigned stats_stopCreateBoardPolyTime = GetRunningMicroSecs(); unsigned stats_startCreateLayersTime = stats_stopCreateBoardPolyTime; #endif if( aStatusTextReporter ) aStatusTextReporter->Report( _( "Create layers" ) ); createLayers( aStatusTextReporter ); #ifdef PRINT_STATISTICS_3D_VIEWER unsigned stats_stopCreateLayersTime = GetRunningMicroSecs(); printf( "CINFO3D_VISU::InitSettings times\n" ); printf( " CreateBoardPoly: %.3f ms\n", (float)( stats_stopCreateBoardPolyTime - stats_startCreateBoardPolyTime ) / 1e3 ); printf( " CreateLayers and holes: %.3f ms\n", (float)( stats_stopCreateLayersTime - stats_startCreateLayersTime ) / 1e3 ); printf( "\n" ); #endif }
MapManager::MapManager(const std::string& fn) : Listener(), parser(XMLParser::getInstance()), numGridElements(0), player(NULL), dummyTile(NULL), tiles(), reserve(), updateTiles(), mapLayers(), gridElements(), tileWidth(), tileHeight(), tileRise(), mapWidth(), mapHeight(), origin(), weather() { // load map into parser parser.parse(fn); // Read in map constants std::stringstream strm; std::map<std::string, std::string> rootData = parser.parseNode(parser.findNodes("map").front()); strm<<rootData[std::string("tilewidth")]; strm >> tileWidth; strm.clear(); strm<<rootData[std::string("tileheight")]; strm >> tileHeight; strm.clear(); strm<<rootData[std::string("tileRise")]; strm >> tileRise; strm.clear(); strm << rootData[std::string("width")]; strm >> mapWidth; strm.clear(); strm<<rootData[std::string("height")]; strm >> mapHeight; strm.clear(); strm<<rootData[std::string("weather")]; strm >> weather; strm.clear(); // Fill vector with appropriate number of lists and then fill it gridElements.reserve(mapWidth*mapHeight); int i; for(i=0; i < mapHeight * mapWidth; i++) { gridElements.push_back( std::list<GridElement* >()); } // Empty tile, used in error handling dummyTile = new Tile(); // Read in tile data createTiles(); // Fill in map structure createLayers(); // coordinate of first tile on bottom layer origin = ( (*(*mapLayers.begin()).begin()).getCoord()) + Vector2f(tileWidth/2,0); // Register with the events we care about registerListeners(); }
void BackProp::train(Matrix& features, Matrix& labels) { createLayers(features, labels); if(_loggingOn) { std::cout << "Network created..." << std::endl; BackPropLayer* itr = &_layers[0]; while(itr != NULL) { std::cout << itr->toString() << std::endl; itr = itr->getNextLayer(); } } features.shuffleRows(_rand, &labels); double percentValidation = 0.25; size_t validationSetSize = static_cast<size_t>(std::max(percentValidation * features.rows(), 1.0)); size_t testSetSize = features.rows() - validationSetSize; assert(validationSetSize > 0 && validationSetSize < features.rows()); Matrix testSet; testSet.copyPart(features, 0, 0, testSetSize, features.cols()); Matrix testSetLabels; testSetLabels.copyPart(labels, 0, 0, testSetSize, labels.cols()); Matrix validationSet; validationSet.copyPart(features, testSetSize, 0, validationSetSize, features.cols()); Matrix validationSetLabels; validationSetLabels.copyPart(labels, testSetSize, 0, validationSetSize, labels.cols()); double bestValidationAccuracy = 0.0; BackPropLayer* bestSolutionSoFar = NULL; size_t bssfLen = 0; size_t epochsWithSameBssf = 0; long long iteration = 0; while(true) { testSet.shuffleRows(_rand, &testSetLabels); for(size_t i = 0; i < features.rows(); i++) { std::vector<double> targetOutput = targetNetworkOutput(labels.row(i), labels.valueCount(0)); /*std::vector<double> targetOutput(labels.valueCount(0), 0); size_t positiveLabelIndex = labels.row(i)[0]; targetOutput[positiveLabelIndex] = 1.0;*/ if(_loggingOn) { std::cout << "Training example input vector: " << vectorToString(features.row(i)) << std::endl; std::cout << "Target label: " << vectorToString(labels.row(i)) << std::endl; std::cout << "Target output: " << vectorToString(targetOutput) << std::endl; } _layers[0].trainOnExample(features.row(i), targetOutput, iteration); } iteration++; double tsAcc = measureAccuracy(testSet, testSetLabels); double tsMse = measureMse(testSet, testSetLabels); double vsAcc = measureAccuracy(validationSet, validationSetLabels); double vsMse = measureMse(validationSet, validationSetLabels); EpochStats epochStats(tsAcc, tsMse, vsAcc, vsMse); _logger.logStats(epochStats); //std::cout << "Validation set accuracy: " << validationAccuracy << std::endl; //std::cout << "Validation set mean squared error: " << mse << std::endl; if(vsAcc > bestValidationAccuracy) { epochsWithSameBssf = 0; copyLayers(_layers, _nLayers, &bestSolutionSoFar, bssfLen); bestValidationAccuracy = vsAcc; } else { epochsWithSameBssf += 1; if(epochsWithSameBssf > 100) { copyLayers(bestSolutionSoFar, bssfLen, &_layers, _nLayers); break; } } /*if(_loggingOn) { std::cout << "Network after epoch: " << std::endl; BackPropLayer* itr = &_layers[0]; while(itr != NULL) { std::cout << itr->toString() << std::endl; itr = itr->getNextLayer(); } }*/ } }