Пример #1
0
LayerModel::LayerModel(QObject* parent) : QAbstractListModel(parent)
{
    addLayer(0,"Base",QColor("grey"),true,false);
    addLayer(1,"A",QColor("grey"),true,false);
    addLayer(2,"B",QColor("grey"),true,false);

    //updateLayers();
}
Пример #2
0
GlyphRendererShadowInset::GlyphRendererShadowInset(
	int          xOffset,
	int          yOffset,
	unsigned int radius,
	unsigned int deviation
) {
	if(!deviation) deviation = radius / 2;

	addLayer(new GlyphLayerShadowInset(xOffset, yOffset, radius, deviation));
	addLayer(new GlyphLayer());
}
Пример #3
0
	GlyphRendererMultiOutline(bool useCustomLayer = false) {
		addLayer(new osgPango::GlyphLayer());
		addLayer(new osgPango::GlyphLayerOutline(1.0f));
		addLayer(new osgPango::GlyphLayerOutline(3.0f));
		addLayer(new osgPango::GlyphLayerOutline(4.0f));

		osgPango::ShaderManager::instance().addShaderFile(
			"my-shader",
			osg::Shader::FRAGMENT,
			"../examples/osgpangoglsl/osgpangoglsl.glsl"
		);
	}
Пример #4
0
void QgsBrowserDockWidget::addLayerAtIndex( const QModelIndex &index )
{
  QgsDebugMsg( QString( "rowCount() = %1" ).arg( mModel->rowCount( mProxyModel->mapToSource( index ) ) ) );
  QgsDataItem *item = mModel->dataItem( mProxyModel->mapToSource( index ) );

  if ( item && item->type() == QgsDataItem::Project )
  {
    QgsProjectItem *projectItem = qobject_cast<QgsProjectItem *>( item );
    if ( projectItem )
    {
      QApplication::setOverrideCursor( Qt::WaitCursor );
      QgisApp::instance()->openFile( projectItem->path() );
      QApplication::restoreOverrideCursor();
    }
  }
  if ( item && item->type() == QgsDataItem::Layer )
  {
    QgsLayerItem *layerItem = qobject_cast<QgsLayerItem *>( item );
    if ( layerItem )
    {
      QApplication::setOverrideCursor( Qt::WaitCursor );
      addLayer( layerItem );
      QApplication::restoreOverrideCursor();
    }
  }
}
Пример #5
0
void SceneBuilder::pushColorFilter(CanvasColor color, TransferMode transferMode)
{
    std::unique_ptr<flow::ColorFilterLayer> layer(new flow::ColorFilterLayer());
    layer->set_color(color);
    layer->set_transfer_mode(transferMode);
    addLayer(std::move(layer));
}
Пример #6
0
void Chunk::loadFromPacket(sf::Packet& packet)
{
    // packet >> mCoords.x >> mCoords.y;   has already been read by the manager

    std::size_t layerCount;
    packet >> layerCount;
    for (std::size_t i = 0; i < layerCount; i++)
    {
        addLayer();
    }

    sf::Vector2i p;
    for (p.x = 0; p.x < Properties::getChunkSize().x; p.x++)
    {
        for (p.y = 0; p.y < Properties::getChunkSize().y; p.y++)
        {
            for (int z = 0; z < (int)getLayerCount(); z++)
            {
                int id;
                packet >> id;
                setTileId(p,z,id);
            }
        }
    }
}
Пример #7
0
    ParticleProducerResource(ptr<ResourceManager> manager, const string &name, ptr<ResourceDescriptor> desc, const TiXmlElement *e = NULL) :
        ResourceTemplate<50, ParticleProducer>(manager, name, desc)
    {
        e = e == NULL ? desc->descriptor : e;
        checkParameters(desc, e, "name,storage,");

        ptr<ParticleStorage> storage = manager->loadResource(getParameter(desc, e, "storage")).cast<ParticleStorage>();

        const TiXmlNode *n = e->FirstChild();
        while (n != NULL) {
            const TiXmlElement *f = n->ToElement();
            if (f == NULL) {
                n = n->NextSibling();
                continue;
            }

            ptr<ParticleLayer> l = manager->loadResource(desc, f).cast<ParticleLayer>();
            if (l != NULL) {
                addLayer(l);
            } else {
                if (Logger::WARNING_LOGGER != NULL) {
                    log(Logger::WARNING_LOGGER, desc, f, "Unknown scene node element '" + f->ValueStr() + "'");
                }
            }
            n = n->NextSibling();
        }

        init(storage);

    }
QgsSymbolV2PropertiesDialog::QgsSymbolV2PropertiesDialog( QgsSymbolV2* symbol, QWidget* parent )
    : QDialog( parent ), mSymbol( symbol )
{
  setupUi( this );

  // setup icons
  btnAddLayer->setIcon( QIcon( QgsApplication::iconPath( "symbologyAdd.png" ) ) );
  btnRemoveLayer->setIcon( QIcon( QgsApplication::iconPath( "symbologyRemove.png" ) ) );
  btnLock->setIcon( QIcon( QgsApplication::iconPath( "symbologyLock.png" ) ) );
  btnUp->setIcon( QIcon( QgsApplication::iconPath( "symbologyUp.png" ) ) );
  btnDown->setIcon( QIcon( QgsApplication::iconPath( "symbologyDown.png" ) ) );

  // set widget functions
  // (should be probably moved somewhere else)
  _initWidgetFunctions();

  loadSymbol();

  connect( btnUp, SIGNAL( clicked() ), this, SLOT( moveLayerUp() ) );
  connect( btnDown, SIGNAL( clicked() ), this, SLOT( moveLayerDown() ) );
  connect( btnAddLayer, SIGNAL( clicked() ), this, SLOT( addLayer() ) );
  connect( btnRemoveLayer, SIGNAL( clicked() ), this, SLOT( removeLayer() ) );
  connect( btnLock, SIGNAL( clicked() ), this, SLOT( lockLayer() ) );

  populateLayerTypes();
  connect( cboLayerType, SIGNAL( currentIndexChanged( int ) ), this, SLOT( layerTypeChanged() ) );

  loadPropertyWidgets();

  updateUi();

  // set first layer as active
  QModelIndex newIndex = listLayers->model()->index( 0, 0 );
  listLayers->setCurrentIndex( newIndex );
}
Пример #9
0
int StationBorehole::addStratigraphy(const std::string &path, StationBorehole* borehole)
{
    std::vector<std::list<std::string> > data;
    if (readStratigraphyFile(path, data))
    {
        std::size_t size = data.size();
        for (std::size_t i = 0; i < size; i++)
            addLayer(data[i], borehole);

        // check if a layer is missing
        // size = borehole->_soilName.size();
        INFO("StationBorehole::addStratigraphy ToDo");
        //    for (std::size_t i=0; i<size; i++)
        //    {
        //        if ((borehole->_soilLayerThickness[i] == -1) ||(borehole->_soilName[i].compare("") == 0))
        //        {
        //            borehole->_soilLayerThickness.clear();
        //            borehole->_soilName.clear();
        //
        //            WARN("StationBorehole::addStratigraphy() - Profile incomplete (Borehole %s, Layer %d missing)", borehole->_name.c_str(), i+1);
        //
        //            return 0;
        //        }
        //    }
    }
    else
        borehole->addSoilLayer(borehole->getDepth(), "depth");

    return 1;
}
Пример #10
0
Net& Net::extremeLayer(int units, ActivationFunction act, double stdDev,
                       bool bias)
{
  architecture << "extreme " << units << " " << (int) act << " " << stdDev
      << " " << bias << " ";
  return addLayer(new Extreme(infos.back(), units, bias, act, stdDev));
}
Пример #11
0
void Style::setJSON(const std::string& json, const std::string&) {
    sources.clear();
    layers.clear();

    rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc;
    doc.Parse<0>((const char *const)json.c_str());
    if (doc.HasParseError()) {
        Log::Error(Event::ParseStyle, "Error parsing style JSON at %i: %s", doc.GetErrorOffset(), rapidjson::GetParseError_En(doc.GetParseError()));
        return;
    }

    StyleParser parser;
    parser.parse(doc);

    for (auto& source : parser.sources) {
        addSource(std::move(source));
    }

    for (auto& layer : parser.layers) {
        addLayer(std::move(layer));
    }

    glyphStore->setURL(parser.glyphURL);
    spriteStore->setURL(parser.spriteURL);

    loaded = true;
}
Пример #12
0
Box& Draw::addPath(int ptx, int pty, int width, int length, bool border, direction d, layer_name l){
	Box tmp;
	switch(d){
		case N:	tmp.setY(pty+length/2);
		tmp.setX(ptx);
		tmp.setWidth(width);
		if(border) length+=width;
		tmp.setHeight(length);
		break;
		case S:	tmp.setY(pty-length/2);
		tmp.setX(ptx);
		if(border) length+=width;
		tmp.setWidth(width);
		tmp.setHeight(length);
		break;
		case E:	tmp.setX(ptx+length/2);
		tmp.setY(pty);
		if(border) length+=width;
		tmp.setWidth(length);
		tmp.setHeight(width);
		break;
		case W:	tmp.setX(ptx-length/2);
		tmp.setY(pty);
		if(border) length+=width;
		tmp.setWidth(length);
		tmp.setHeight(width);
		break;
	}
	return addLayer(tmp,l);
}
Пример #13
0
    void etch(int simType_, int IterCount, float* rates) {
        GRES::SimType sT = static_cast<GRES::SimType>(simType_);
        QTime t;
        // t.start();
        bool perfect = false;
        auto surface = surfaceXYZ;

        for (int n = 0; n < IterCount; ++n) {
            if (sT == GRES::SimType::KMC)
                perfect = surface->deleteRandomAtomKmc(neighbors, z_min, mask, rates);
            else if (sT == GRES::SimType::CA)
                perfect = surface->deleteRandomAtomCa(z_min, mask, rates);

            if (perfect) {
                surface->addLayer(neighbors, SIZE_X, SIZE_Y, SIZE_Z);
                ++SIZE_Z;
                perfect = true;
            }

            z_min = surface->findZmin(z_min);
            surface->optimize(z_min);
        }
        // qDebug() << "etch: " << t.elapsed();
        z_center = (SIZE_Z - 2 + z_min) / 2;
        drawResult();
    }
Пример #14
0
QgsWFSSourceSelect::QgsWFSSourceSelect( QWidget* parent, Qt::WindowFlags fl, bool embeddedMode )
    : QDialog( parent, fl )
    , mCapabilities( nullptr )
{
  setupUi( this );

  if ( embeddedMode )
  {
    buttonBox->button( QDialogButtonBox::Close )->hide();
  }

  mAddButton = new QPushButton( tr( "&Add" ) );
  mAddButton->setEnabled( false );

  mBuildQueryButton = new QPushButton( tr( "&Build query" ) );
  mBuildQueryButton->setToolTip( tr( "Build query" ) );
  mBuildQueryButton->setDisabled( true );


  buttonBox->addButton( mAddButton, QDialogButtonBox::ActionRole );
  connect( mAddButton, SIGNAL( clicked() ), this, SLOT( addLayer() ) );

  buttonBox->addButton( mBuildQueryButton, QDialogButtonBox::ActionRole );
  connect( mBuildQueryButton, SIGNAL( clicked() ), this, SLOT( buildQueryButtonClicked() ) );

  connect( buttonBox, SIGNAL( rejected() ), this, SLOT( reject() ) );
  connect( btnNew, SIGNAL( clicked() ), this, SLOT( addEntryToServerList() ) );
  connect( btnEdit, SIGNAL( clicked() ), this, SLOT( modifyEntryOfServerList() ) );
  connect( btnDelete, SIGNAL( clicked() ), this, SLOT( deleteEntryOfServerList() ) );
  connect( btnConnect, SIGNAL( clicked() ), this, SLOT( connectToServer() ) );
  connect( btnChangeSpatialRefSys, SIGNAL( clicked() ), this, SLOT( changeCRS() ) );
  connect( lineFilter, SIGNAL( textChanged( QString ) ), this, SLOT( filterChanged( QString ) ) );
  populateConnectionList();
  mProjectionSelector = new QgsGenericProjectionSelector( this );
  mProjectionSelector->setMessage();

  mItemDelegate = new QgsWFSItemDelegate( treeView );
  treeView->setItemDelegate( mItemDelegate );

  QSettings settings;
  QgsDebugMsg( "restoring settings" );
  restoreGeometry( settings.value( "/Windows/WFSSourceSelect/geometry" ).toByteArray() );
  cbxUseTitleLayerName->setChecked( settings.value( "/Windows/WFSSourceSelect/UseTitleLayerName", false ).toBool() );
  mHoldDialogOpen->setChecked( settings.value( "/Windows/WFSSourceSelect/HoldDialogOpen", false ).toBool() );

  mModel = new QStandardItemModel();
  mModel->setHorizontalHeaderItem( MODEL_IDX_TITLE, new QStandardItem( "Title" ) );
  mModel->setHorizontalHeaderItem( MODEL_IDX_NAME, new QStandardItem( "Name" ) );
  mModel->setHorizontalHeaderItem( MODEL_IDX_ABSTRACT, new QStandardItem( "Abstract" ) );
  mModel->setHorizontalHeaderItem( MODEL_IDX_FILTER, new QStandardItem( "Filter" ) );

  mModelProxy = new QSortFilterProxyModel( this );
  mModelProxy->setSourceModel( mModel );
  mModelProxy->setSortCaseSensitivity( Qt::CaseInsensitive );
  treeView->setModel( mModelProxy );

  connect( treeView, SIGNAL( doubleClicked( const QModelIndex& ) ), this, SLOT( treeWidgetItemDoubleClicked( const QModelIndex& ) ) );
  connect( treeView->selectionModel(), SIGNAL( currentRowChanged( QModelIndex, QModelIndex ) ), this, SLOT( treeWidgetCurrentRowChanged( const QModelIndex&, const QModelIndex& ) ) );
}
Пример #15
0
Net& Net::subsamplingLayer(int kernelRows, int kernelCols,
                           ActivationFunction act, double stdDev, bool bias)
{
  architecture << "subsampling " << kernelRows << " " << kernelCols << " "
      << (int) act << " " << stdDev << " " << bias << " ";
  return addLayer(new Subsampling(infos.back(), kernelRows, kernelCols, bias,
                                  act, stdDev, regularization));
}
Пример #16
0
Net& Net::restrictedBoltzmannMachineLayer(int H, int cdN, double stdDev,
                                          bool backprop)
{
  architecture << "rbm " << H << " " << cdN << " " << stdDev << " "
      << backprop << " ";
  return addLayer(new RBM(infos.back().outputs(), H, cdN, stdDev,
                          backprop, regularization));
}
Пример #17
0
void SceneBuilder::pushShaderMask(Shader* shader, const Rect& maskRect, TransferMode transferMode)
{
    std::unique_ptr<flow::ShaderMaskLayer> layer(new flow::ShaderMaskLayer());
    layer->set_shader(shader->shader());
    layer->set_mask_rect(maskRect.sk_rect);
    layer->set_transfer_mode(transferMode);
    addLayer(std::move(layer));
}
Пример #18
0
void SceneBuilder::pushOpacity(int alpha, const Rect& bounds)
{
    std::unique_ptr<sky::compositor::OpacityLayer> layer(new sky::compositor::OpacityLayer());
    if (!bounds.is_null)
      layer->set_paint_bounds(bounds.sk_rect);
    layer->set_alpha(alpha);
    addLayer(std::move(layer));
}
Пример #19
0
Net& Net::sparseAutoEncoderLayer(int H, double beta, double rho,
                                 ActivationFunction act)
{
  architecture << "sae " << H << " " << beta << " " << rho << " " << (int) act
      << " ";
  return addLayer(new SparseAutoEncoder(infos.back().outputs(), H, beta, rho,
                                        regularization.l2Penalty, act));
}
Пример #20
0
Net& Net::localReponseNormalizationLayer(double k, int n, double alpha,
                                         double beta)
{
  architecture << "local_response_normalization " << k << " " << n << " "
      << alpha << " " << beta << " ";
  return addLayer(new LocalResponseNormalization(infos.back(), k, n, alpha,
                                                 beta));
}
Пример #21
0
Net& Net::fullyConnectedLayer(int units, ActivationFunction act, double stdDev,
                              bool bias)
{
  architecture << "fully_connected " << units << " " << (int) act << " "
      << stdDev << " " << bias << " ";
  return addLayer(new FullyConnected(infos.back(), units, bias, act, stdDev,
                                     regularization));
}
Пример #22
0
Box& Draw::addPolygon(Point& pt1, Point& pt2, layer_name& l){
	Box tmp;
	tmp.setX((pt1.getX()+pt2.getX())/2);
	tmp.setY((pt1.getY()+pt2.getY())/2);
	tmp.setWidth(abs(pt2.getX()-pt1.getX()));
	tmp.setHeight(abs(pt2.getY()-pt1.getY()));
	return addLayer(tmp,l);
}
Пример #23
0
Net& Net::convolutionalLayer(int featureMaps, int kernelRows, int kernelCols,
                             ActivationFunction act, double stdDev, bool bias)
{
  architecture << "convolutional " << featureMaps << " " << kernelRows << " "
      << kernelCols << " " << (int) act << " " << stdDev << " " << bias << " ";
  return addLayer(new Convolutional(infos.back(), featureMaps, kernelRows,
                                    kernelCols, bias, act, stdDev, regularization));
}
Пример #24
0
void Sky::resetToDefaults()
{
    Definition::resetToDefaults();

    // Add all expected fields with their default values.
    def().addText  (VAR_ID, "");
    def().addNumber("flags", 0);
    def().addNumber("height", DEFAULT_SKY_HEIGHT);
    def().addNumber("horizonOffset", DEFAULT_SKY_HORIZON_OFFSET);
    def().addArray ("color", new ArrayValue(Vector3f()));
    def().addArray ("layer", new ArrayValue);
    def().addArray ("model", new ArrayValue);

    // Skies have two layers by default.
    addLayer();
    addLayer();
}
QgsSymbolV2SelectorDialog::QgsSymbolV2SelectorDialog( QgsSymbolV2* symbol, QgsStyleV2* style, const QgsVectorLayer* vl, QWidget* parent, bool embedded )
    : QDialog( parent )
    , mAdvancedMenu( NULL )
    , mVectorLayer( vl )
    , mMapCanvas( 0 )
{
#ifdef Q_OS_MAC
  setWindowModality( Qt::WindowModal );
#endif
  mStyle = style;
  mSymbol = symbol;
  mPresentWidget = NULL;

  setupUi( this );

  QSettings settings;
  restoreGeometry( settings.value( "/Windows/SymbolSelectorDialog/geometry" ).toByteArray() );

  // can be embedded in renderer properties dialog
  if ( embedded )
  {
    buttonBox->hide();
    layout()->setContentsMargins( 0, 0, 0, 0 );
  }
  // setup icons
  btnAddLayer->setIcon( QIcon( QgsApplication::iconPath( "symbologyAdd.svg" ) ) );
  btnRemoveLayer->setIcon( QIcon( QgsApplication::iconPath( "symbologyRemove.svg" ) ) );
  QIcon iconLock;
  iconLock.addFile( QgsApplication::iconPath( "locked.svg" ), QSize(), QIcon::Normal, QIcon::On );
  iconLock.addFile( QgsApplication::iconPath( "unlocked.svg" ), QSize(), QIcon::Normal, QIcon::Off );
  btnLock->setIcon( iconLock );
  btnUp->setIcon( QIcon( QgsApplication::iconPath( "symbologyUp.svg" ) ) );
  btnDown->setIcon( QIcon( QgsApplication::iconPath( "symbologyDown.svg" ) ) );

  model = new QStandardItemModel( layersTree );
  // Set the symbol
  layersTree->setModel( model );
  layersTree->setHeaderHidden( true );

  QItemSelectionModel* selModel = layersTree->selectionModel();
  connect( selModel, SIGNAL( currentChanged( const QModelIndex&, const QModelIndex& ) ), this, SLOT( layerChanged() ) );

  loadSymbol( symbol, static_cast<SymbolLayerItem*>( model->invisibleRootItem() ) );
  updatePreview();

  connect( btnUp, SIGNAL( clicked() ), this, SLOT( moveLayerUp() ) );
  connect( btnDown, SIGNAL( clicked() ), this, SLOT( moveLayerDown() ) );
  connect( btnAddLayer, SIGNAL( clicked() ), this, SLOT( addLayer() ) );
  connect( btnRemoveLayer, SIGNAL( clicked() ), this, SLOT( removeLayer() ) );
  connect( btnLock, SIGNAL( clicked() ), this, SLOT( lockLayer() ) );
  connect( btnSaveSymbol, SIGNAL( clicked() ), this, SLOT( saveSymbol() ) );

  updateUi();

  // set symbol as active item in the tree
  QModelIndex newIndex = layersTree->model()->index( 0, 0 );
  layersTree->setCurrentIndex( newIndex );
}
Пример #26
0
void SceneBuilder::pushColorFilter(SkColor color, SkXfermode::Mode transferMode, const Rect& bounds)
{
    std::unique_ptr<sky::compositor::ColorFilterLayer> layer(new sky::compositor::ColorFilterLayer());
    if (!bounds.is_null)
      layer->set_paint_bounds(bounds.sk_rect);
    layer->set_color(color);
    layer->set_transfer_mode(transferMode);
    addLayer(std::move(layer));
}
Пример #27
0
void SceneBuilder::pushTransform(const Float64List& matrix4, ExceptionState& es)
{
    SkMatrix sk_matrix = toSkMatrix(matrix4, es);
    if (es.had_exception())
        return;
    std::unique_ptr<sky::compositor::TransformLayer> layer(new sky::compositor::TransformLayer());
    layer->set_transform(sk_matrix);
    addLayer(std::move(layer));
}
Пример #28
0
Net& Net::compressedLayer(int units, int params, ActivationFunction act,
                          const std::string& compression, double stdDev,
                          bool bias)
{
  architecture << "compressed " << units << " " << params << " " << (int) act
      << " " << compression << " " << stdDev << " " << bias << " ";
  return addLayer(new Compressed(infos.back(), units, params, bias, act,
                                 compression, stdDev, regularization));
}
Пример #29
0
Net& Net::outputLayer(int units, ActivationFunction act, double stdDev, bool bias)
{
  architecture << "output " << units << " " << (int) act << " " << stdDev
      << " " << bias << " ";
  addLayer(new FullyConnected(infos.back(), units, bias, act, stdDev,
                              regularization));
  initializeNetwork();
  return *this;
}
Пример #30
0
MultiLayer::MultiLayer(ApplicationWindow* parent, int layers, int rows, int cols,
			const QString& label, const char* name, Qt::WFlags f)
: MdiSubWindow(label, parent, name, f),
active_graph(NULL),
d_cols(cols),
d_rows(rows),
graph_width(500),
graph_height(400),
colsSpace(5),
rowsSpace(5),
left_margin(5),
right_margin(5),
top_margin(5),
bottom_margin(5),
l_canvas_width(400),
l_canvas_height(300),
hor_align(HCenter),
vert_align(VCenter),
d_scale_on_print(true),
d_print_cropmarks(false),
d_scale_layers(parent->autoResizeLayers)
{
	layerButtonsBox = new QHBoxLayout();
	QHBoxLayout *hbox = new QHBoxLayout();
	hbox->addLayout(layerButtonsBox);
	hbox->addStretch();

	canvas = new QWidget();

	QWidget *mainWidget = new QWidget();
	mainWidget->setAutoFillBackground(true);
	mainWidget->setBackgroundRole(QPalette::Window);

	QVBoxLayout* layout = new QVBoxLayout(mainWidget);
	layout->addLayout(hbox);
	layout->addWidget(canvas, 1);
	layout->setMargin(0);
	layout->setSpacing(0);
	setWidget(mainWidget);

    int canvas_width = graph_width + left_margin + right_margin;
    int canvas_height = graph_height + top_margin + bottom_margin;
    setGeometry(QRect(0, 0, canvas_width, canvas_height + LayerButton::btnSize()));

    canvas->resize(canvas_width, canvas_height);
	canvas->installEventFilter(this);

	QPalette pal = palette();
	pal.setColor(QPalette::Window, QColor(Qt::white));
	setPalette(pal);

	for (int i = 0; i < layers; i++)
		addLayer();

	setFocusPolicy(Qt::StrongFocus);
	setFocus();
}