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