fr.geologyidea.com
Suite

Modification de l'attribut de largeur et de hauteur avec l'API Javascript d'ArcGIS ?

Modification de l'attribut de largeur et de hauteur avec l'API Javascript d'ArcGIS ?


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.


Nous avons une application de dessin côté client fonctionnant avec l'API Javascript d'Arcgis, qui fonctionne assez bien avec la plupart des composants standard jusqu'à présent. Il s'agit de notre première application Arcgis et nous aimons beaucoup l'API. Maintenant, j'ai une demande de notre client qui veut pouvoir changer la largeur et la longueur d'un graphique à partir d'une fenêtre d'information/d'un attribut.

Si vous avez déjà joué et regardé d'abord obtenir l'étendue du graphique, puis utilisez getWidth et getHeight, mais il semble que cela donne avec le cadre de délimitation et non le graphique. Une autre option à laquelle je pensais consiste à calculer les longueurs de ligne de chaque côté, puis à modifier les points, mais j'ai l'impression que cela pourrait être une solution trop complexe.

C'est bien si cela n'est possible qu'avec un polygone dessiné avec l'outil de dessin rectangle, cependant il devrait être possible de faire pivoter cet élément. Donc, ce que je veux atteindre, c'est un peu quelque chose comme la capture d'écran ci-dessous.


(source : kabelfoon.nl)

Avez-vous des opinions sur la meilleure façon de résoudre ce problème avec l'API Arcgis


J'ai fini par régler ça moi-même. Ce que j'ai fini par faire :

  1. Obtenez le xmin, ymin du graphique lors de la création et enregistrez-le dans les attributs graphiques (obtenu à partir de l'anneau graphique). Chaque fois que l'objet est déplacé avec le widget Esri Editor, j'ai mis à jour les valeurs xmin et ymin en m'accrochant à l'événement 'graphic-move-stop'.
  2. À côté de cela, j'ai défini la largeur, la hauteur et la rotation du graphique en tant qu'attributs. La largeur et la hauteur ont des valeurs par défaut.
  3. La largeur est xmin + largeur, la hauteur est ymin + hauteur. Lorsque la rotation est définie, je mute tous les points d'anneau du graphique avec cette matrice de rotation 2D de base : https://stackoverflow.com/questions/17410809/how-to-calculate-rotation-in-2d-in-javascript. Veuillez vous assurer d'avoir les xmin et ymin d'origine après la rotation.
  4. Lorsque l'objet est tourné avec l'outil de rotation esri, je laisse l'implémentation Esri faire toute la rotation et je recalcule la largeur et la hauteur par Pythagore de base. c'est à dire

    var a = graphic.geometry.rings[0][3][0]-graphic.geometry.rings[0][0][0] ; var b = graphic.geometry.rings[0][3][1]-graphic.geometry.rings[0][0][1] ; var largeur = Math.round(pyth(a,b));
  5. La mise à l'échelle basée sur Esri recalcule également la largeur et la hauteur. Cependant, je dois obtenir les nouveaux xmin et ymin.

S'il y a un intérêt de la part de la communauté, je peux jeter un œil à la sortie du code de notre projet et le partager avec vous.


Une fois que vous avez une référence à votre image, vous pouvez définir sa hauteur et sa largeur comme suit :

Dans le html, cela ressemblerait à ceci :

Vous pouvez modifier les attributs de largeur/hauteur réels comme ceci :

Si vous souhaitez redimensionner une image après son chargement, vous pouvez l'attacher à l'événement onload de la balise <img>. Notez qu'il peut ne pas être pris en charge dans tous les navigateurs (la référence de Microsoft prétend qu'il fait partie de la spécification HTML 4.0, mais la spécification HTML 4.0 ne répertorie pas l'événement onload pour <img> ).

Le code ci-dessous est testé et fonctionne dans : IE 6, 7 & 8, Firefox 2, 3 & 3.5, Opera 9 & 10, Safari 3 & 4 et Google Chrome :

Changer une image est facile, mais comment la ramener à sa taille d'origine une fois qu'elle a été modifiée ? Vous pouvez essayer ceci pour remettre toutes les images d'un document à leur taille d'origine :

vous pouvez voir le résultat ici Dans ce simple bloc de code, vous pouvez modifier la taille de votre image et l'agrandir lorsque la souris passe sur l'image, et elle reviendra à sa taille d'origine lorsque vous la quitterez.


Vous pouvez utiliser clientWidth ou offsetWidth Référence du réseau de développeurs Mozilla

Toutes les réponses sont correctes, mais je veux quand même donner d'autres alternatives qui peuvent fonctionner.

Si vous recherchez la largeur attribuée (en ignorant le remplissage, la marge, etc.), vous pouvez l'utiliser.

getComputedStyle vous permet d'accéder à tous les styles de ces éléments. Par exemple : padding, paddingLeft, margin, border-top-left-radius et ainsi de suite.

Vous pouvez également rechercher le DOM en utilisant ClassName. Par exemple:

Cela retournera un tableau. S'il y a une propriété en particulier qui vous intéresse. Par exemple :

divWidth sera désormais égal à la largeur du premier élément de votre tableau div.

Une autre option consiste à utiliser la fonction getBoundingClientRect. Veuillez noter que getBoundingClientRect renverra un rect vide si l'affichage de l'élément est « aucun ».


Les propriétés que vous utilisez peuvent ne pas fonctionner dans Firefox, Chrome et d'autres navigateurs non IE. Pour que cela fonctionne dans tous les navigateurs, je suggère également d'ajouter les éléments suivants :

Pour la compatibilité croisée, vous devrez toujours utiliser la propriété. L'ordre peut aussi avoir de l'importance. Par exemple, dans mon code, lors de la définition des propriétés de style avec JavaScript, je définis d'abord l'attribut style, puis je définis les propriétés :

Ainsi, l'exemple le plus compatible avec plusieurs navigateurs pour vous serait :

Je tiens également à souligner qu'une méthode beaucoup plus simple de gestion des styles consiste à utiliser un sélecteur de classe CSS et à placer vos styles dans des fichiers CSS externes. Non seulement votre code sera beaucoup plus facile à maintenir, mais vous vous ferez des amis avec vos concepteurs Web !

Maintenant, je peux facilement ajouter et supprimer un attribut de classe, une seule propriété, au lieu d'appeler plusieurs propriétés. De plus, lorsque votre concepteur Web souhaite modifier la définition de ce que signifie être large, il n'a pas besoin de fouiller dans votre code JavaScript magnifiquement entretenu. Votre code JavaScript reste intact, mais le thème de votre application peut être facilement personnalisé.

Cette technique suit la règle de séparation de votre contenu (HTML) de votre comportement (JavaScript), et de votre présentation (CSS).


"Meilleurs "couches disponibles

Comme cela a été discuté, des couches d'imagerie visualisant le même paramètre scientifique à partir d'un instrument et d'une plate-forme spécifiques peuvent être disponibles pour plusieurs versions et/ou latences de données. Un accès direct à ces différentes saveurs de la même visualisation est directement disponible. Cependant, de nombreux utilisateurs souhaitent simplement voir une couche d'images cohérente "meilleure disponible". Les détails de ce qui est "le mieux" sont déterminés par l'équipe GIBS. Par conséquent, GIBS fournit un ensemble unique de couches d'imagerie "Best Available" pour toutes ses couches d'imagerie, en faisant abstraction des versions et des latences individuelles. Une convention de nommage similaire est utilisée, comme décrit dans la section précédente, mais les identifiants ne spécifient pas la version ou la latence (par exemple MODIS_Terra_Aerosol_Optical_Depth).

Pour chaque couche "best available", la "best" image sera déterminée en fonction de l'évaluation de la disponibilité des produits d'imagerie suivants :

  1. Dernière version du produit standard
  2. Dernière version NRT
  3. Version précédente du produit standard
  4. Version précédente NRT

Voir l'image à droite pour un exemple visuel. Les quatre barres du haut montrent la couverture temporelle des produits d'imagerie associés. La barre inférieure affiche les produits d'imagerie qui seront renvoyés en fonction de la détermination de la "meilleure disponibilité".


1 réponse 1

utiliser le filtre d'échelle le fera, mais il y a un peu plus.

créera un film avec les dimensions de pixels requises, mais si vous regardez le résultat, vous constaterez qu'il ajoute des informations dans les métadonnées afin qu'il soit lu au même format que l'original, en utilisant des pixels non carrés. Donc, si vous souhaitez étirer le film de manière anamorphique vers un nouveau rapport hauteur/largeur, vous devez définir manuellement le rapport hauteur/largeur des pixels, appelé SAR pour "Sample Aspect Ratio", donc pour les pixels carrés, utilisez :

Alternativement, vous pouvez définir le rapport hauteur/largeur d'affichage à ce que vous voulez, ainsi :

Ce que je fais avec la commande -vf et les expressions x=y,z=a qui suivent crée une chaîne de filtres. Les filtres peuvent être assez complexes, mais dans leur utilisation la plus simple, ils prennent la forme effect=parameter,nexteffect=anotherparameter , et ils sont traités dans l'ordre dans lequel vous les écrivez.

Vous voudrez peut-être mettre des commandes supplémentaires pour le codec et ainsi de suite, par exemple -c:v libx264 pour utiliser l'encodeur x264 mp4, et quelque chose comme -crf 20 pour définir le facteur de débit constant à 20 (généralement un assez bon compromis entre la taille et qualité). Ainsi, une commande raisonnablement complète ressemblerait à :

Le profil principal est bon pour la compatibilité des appareils, le préréglage lent pour l'encodeur libx264 est un assez bon équilibre entre vitesse et qualité, il s'agit donc d'un bon outil général d'encodage Web. Vous pouvez le rendre plus rapide en utilisant rapide ou très rapide ou plus lent avec veryslow et le placebo le rendra légèrement meilleur que veryslow au détriment de beaucoup plus de temps de traitement (d'où le nom).

d'ailleurs Ne pas utiliser -c copy, cela signifie simplement copier les flux vidéo et audio sans rien leur faire du tout, donc rien de ce que vous faites en termes d'échelle, de codec, de débit binaire, etc. tout effet.


Comme @sfdcfox l'a mentionné, il s'agit à la fois d'une fonctionnalité et d'une limitation de la fonctionnalité "shadow DOM" de LWC. Vous pouvez créer votre propre composant personnalisé. Mais, il existe une solution de contournement pour surmonter le « DOM fantôme » de LWC.

A. Création d'une approche de composant personnalisé

Scénario Vous devez modifier le style du composant, ce qui est simple à mettre en œuvre.

Vous pouvez créer une balise html standard et appliquer votre style personnalisé.

B. Contournement du shadow dom de LWC

Scénario Vous devez modifier le style du composant, ce qui est difficile à mettre en œuvre.

  1. Créez un fichier CSS séparé avec votre style. Rendez le sélecteur CSS aussi détaillé que possible. Les sélecteurs généraux comme div remplaceront le style de chaque élément div sur votre page (pas seulement sur votre composant).
  2. Téléchargez le fichier CSS en tant que ressource statique.
  3. Chargez votre style en JS comme ceci :

Il est possible d'accéder et de modifier le style des éléments internes du composant standard avec une ressource statique - comme indiqué dans la réponse de @BlackCat

Je vois que vous avez créé divers composants pour tester cela. Si vous essayez d'inspecter l'élément créé :

Ici, comme vous le voyez, la classe mytextarea est ajoutée au composant wrapper. Ainsi, même si vous augmentez la hauteur, les styles/hauteur de l'élément textarea interne ne changeront pas. La hauteur sera appliquée à l'élément d'enveloppe externe uniquement. Ainsi, lorsque vous modifiez les styles comme la couleur, la couleur d'arrière-plan, etc., il sera appliqué à l'élément wrapper.

Notez également que vous ne pouvez pas faire quelque chose comme

parce que c'est à l'intérieur du DOM fermé. Cela était possible auparavant avec le composant Aura, mais maintenant ce n'est plus possible car même Aura utilise le composant LWC en coulisse (selon le support non officiel de la force de vente)


Modifier l'attribut de largeur et de hauteur avec l'API Javascript ArcGIS ? - Systèmes d'information géographique

Open City Model est une initiative visant à fournir des données cityGML ouvertes pour tous les bâtiments aux États-Unis. En combinant d'autres jeux de données ouverts tels que USBuildingFootprints avec notre propre code et algorithmes, notre objectif est de fournir des géométries 3D pour chaque bâtiment aux États-Unis.

Ces données contiennent environ 125 millions de bâtiments.

Les données sont fournies via AWS S3 dans le bucket opencitymodel . Nous incluons trois formats de données : gml (CityGML), json (CityJSON) et parquet qui sont identiques dans leur contenu et varient purement dans leur structure. Dans le dossier d'un format de données, chaque État américain a son propre dossier avec tous ses fichiers. Les fichiers de chaque État américain sont ensuite séparés par comté américain, puis partitionnés en fichiers de 40 000 bâtiments pour que la taille des fichiers reste plus gérable. Veuillez noter que les fichiers GML sont compressés au format zip pour minimiser la taille des téléchargements.

Le chemin complet vers un seul fichier ressemble à ..

Nous fournissons également des index de fichiers plus faciles à parcourir pour chaque état. Si vous êtes habitué à accéder directement à AWS S3, vous pouvez simplement utiliser les outils AWS pour répertorier et télécharger directement les fichiers à partir du compartiment opencitymodel.

État Des dossiers Taille (GML compressé) Taille (JSON)
Alabama 102 495 Mo 2253 Mo
Alaska 31 26 Mo 122 Mo
Arizona 75 552 Mo 2555 Mo
Arkansas 88 282 Mo 1334 Mo
Californie 342 3632 Mo 13955 Mo
Colorado 97 443 Mo 2079 Mo
Connecticut 34 246 Mo 1116 Mo
Delaware 10 72 Mo 323 Mo
District de Colombie 5 48 Mo 195 Mo
Floride 215 1573 Mo 6924 Mo
Géorgie 206 771 Mo 3574 Mo
Hawaii 10 58 Mo 262 Mo
Idaho 52 161 Mo 802 Mo
Illinois 191 1025 Mo 4758 Mo
Indiana 131 616 Mo 2920 Mo
Iowa 111 365 Mo 1750 Mo
Kansas 118 268 Mo 1371 Mo
Kentucky 139 529 Mo 2395 Mo
Louisiane 91 427 Mo 1946MB
Maine 29 153 Mo 683 Mo
Maryland 68 535 Mo 2284 Mo
Massachusetts 72 683 Mo 2856 Mo
Michigan 166 936 Mo 4384 Mo
Minnesota 121 563 Mo 2649 Mo
Mississippi 93 304 Mo 1449 Mo
Missouri 149 591 Mo 2765 Mo
Montana 62 134 Mo 668 Mo
Nebraska 100 192 Mo 1002 Mo
Nevada 35 238 Mo 970 Mo
New Hampshire 20 122 Mo 539 Mo
New Jersey 77 515 Mo 2312 Mo
Nouveau Mexique 45 212 Mo 986 Mo
New York 170 1231 Mo 5386 Mo
Caroline du Nord 170 943 Mo 4256 Mo
Dakota du nord 55 106 Mo 531 Mo
Ohio 178 1101 Mo 5008 Mo
Oklahoma 99 396 Mo 1899 Mo
Oregon 70 417 Mo 1911 Mo
Pennsylvanie 160 1027 Mo 4609 Mo
RhodeIsland 11 81 Mo 343 Mo
Caroline du Sud 79 440 Mo 1964 Mo
Dakota du Sud 68 101 Mo 542 Mo
Tennessee 128 591 Mo 2710 Mo
Texas 424 2102 Mo 9625 Mo
Utah 45 216 Mo 995 Mo
Vermont 15 70 Mo 314 Mo
Virginie 162 678 Mo 3078 Mo
Washington 101 693 Mo 2967 Mo
Virginie-Occidentale 61 186 Mo 884 Mo
Wisconsin 123 699 Mo 3134Mo
Wyoming 25 74 Mo 349 Mo

Open City Model est fondamentalement un pipeline de données. Notre objectif est simplement de rassembler les nombreux jeux de données ouverts individuels décrivant les géométries des bâtiments et de produire une vue unifiée unique de ces données. En tant que tel, nous sommes extrêmement reconnaissants envers les personnes qui produisent les données qui entrent dans le modèle Open City, qui est répertorié ici. Nous cherchons toujours à ajouter plus de données sources, donc si vous avez une recommandation, publiez un problème et faites-le nous savoir !

La source Bâtiments (environ)
MS USBuildingFootprints 125m
Empreintes du bâtiment MS (2017) 9,8 m
Ouvrir la carte des rues 28,9 m
Comté de LA LARIAC4 (2014) 3,1 m

Comment lire les fichiers cityGML ?

Il existe de nombreuses options intéressantes sur le site Web de cityGML ainsi que sur le site Web de cityJSON.

Qu'est-ce qui est inclus dans les fichiers?

Les fichiers contiennent actuellement des données de construction et se concentrent spécifiquement sur la géométrie 3D du bâtiment. Nous incluons également quelques attributs utiles tels que la superficie de l'empreinte, la hauteur du bâtiment, l'état et le comté des États-Unis (code FIPS) et l'UBID (Universal Building ID).

Quelles unités sont utilisées dans les données ?

Les données sont écrites à l'aide du système de coordonnées epsg:4979 pour les positions géographiques. Cela signifie que toutes les coordonnées 2D utilisent les valeurs lat/lon WGS84 en degrés et que la coordonnée 3D est en mètres.

Quel est le niveau de détail (LOD) des données ?

Tous les fichiers ne contiennent actuellement que des bâtiments LOD1. Notre premier objectif est d'obtenir la meilleure couverture possible de LOD1 pour tous les bâtiments aux États-Unis. Une fois que nous nous sentons à l'aise avec notre couverture LOD1, nous nous intéressons à LOD2, mais nous considérons que c'est loin d'être le cas.

Puis-je accéder aux fichiers par programme ?

Certainement! Tous les fichiers sont disponibles sur S3 dans le bucket opencitymodel afin que vous puissiez répertorier le contenu de ce bucket à l'aide de n'importe quel client s3 pour obtenir les fichiers de cette façon si vous le souhaitez.

Publierez-vous plus de fichiers cityGML à l'avenir ?

Nos plans actuels incluent la publication de fichiers couvrant tous les bâtiments aux États-Unis. Au-delà, nous n'avons pas de plans, mais nous sommes ouverts à en parler.

Quelle est la précision des empreintes de bâtiment utilisées?

Nous recueillons des empreintes de différentes sources, donc la précision dépend de la source. Notre objectif est de fournir la meilleure précision possible tout en offrant une couverture complète de tous les bâtiments.

Actuellement, la majorité des empreintes de bâtiments ont été créées par Microsoft à l'aide d'images haute résolution et d'algorithmes avancés d'apprentissage automatique. Microsoft affirme que les empreintes sont dans la plupart des cas au moins aussi précises que celles créées par la numérisation manuelle sur le terrain dans Open Street Maps. Voir USBuildingFootprints de Microsoft pour plus de détails.

La source de chaque empreinte est attribuée dans les données.

Quelle est la source de données pour les hauteurs de bâtiment dans OCM ?

Dans la mesure du possible, nous essayons d'utiliser des données avec des hauteurs de bâtiments mesurées. Lorsque cela n'est pas possible, nous utilisons l'apprentissage automatique pour estimer la hauteur des bâtiments restants.

Actuellement, les hauteurs de bâtiments modélisées ont été générées à l'aide d'un algorithme d'analyse de régression simple comparant les surfaces au sol des bâtiments avec les hauteurs à l'aide d'un ensemble de données OSM de bâtiments de 4M. Il devrait être raisonnablement précis dans la grande majorité des bâtiments, à l'exception des environnements urbains denses avec des bâtiments hauts à plusieurs étages, c'est-à-dire des gratte-ciel.

La source de la hauteur du bâtiment pour chaque empreinte est attribuée dans les données.

Existe-t-il des plans pour augmenter la précision des hauteurs des bâtiments ?

Oui. Nous travaillons sur des ensembles de données et des algorithmes d'entraînement plus sophistiqués. Nous nous félicitons des contributions à cet effort. Nous prévoyons également d'incorporer des hauteurs de bâtiments supplémentaires mesurées à partir d'autres ensembles de données comme OSM lorsque cela est possible.

Qu'est-ce qu'un Universal Building ID (UBID) et pourquoi est-il important ?

UBID est une initiative du Département américain de l'énergie (DOE) visant à établir un système permettant de générer et de maintenir des identifiants uniques pour tous les bâtiments de la planète. L'algorithme UBID génère un identifiant unique basé sur l'emplacement géospatial et la forme d'une empreinte de bâtiment. Un identifiant de bâtiment unique fournira un mécanisme d'indexation universel pour la collecte, la liaison et l'agrégation de données centrées sur le bâtiment à partir de sources disparates.

CityGML est un modèle de données (schéma) pour décrire les environnements urbains. CityGML décrit des objets urbains comme des bâtiments, des routes, des ponts, des arbres, etc. dans un espace géographique 3D. Les classes d'attributs de données d'objets urbains CityGML incluent : la sémantique, la géométrie, la topologie et l'apparence. CityGML est une norme de consensus internationale ouverte avec plus de quinze ans de développement et d'utilisation en coopération. Il est reconnu et soutenu par l'Open Source Geospatial Foundation

Des extensions de domaine d'application (ADE) existent pour l'énergie, le bruit, les services publics et d'autres domaines d'application, et de nouveaux ADE sont en cours de développement. Les ADE fournissent des schémas qui étendent le modèle CityGML pour inclure des attributs de données qui prennent en charge des applications spécifiques à un domaine telles que la modélisation énergétique du bâtiment à l'échelle du bâtiment, du quartier et de la ville. Des informations détaillées sont disponibles sur CityGML.org.

Les environnements urbains sont très complexes et nécessitent des outils logiciels sophistiqués pour permettre une analyse et une conception appropriées. Un modèle de données urbaines standard stable, testé, ouvert et consensuel est essentiel pour un développement, une collaboration, un partage et une mise à l'échelle efficaces et efficients de logiciels à l'échelle mondiale. Les villes et les quartiers du monde entier sont confrontés à des défis de planification de taille dans les domaines de l'énergie, de la réduction des GES, de l'eau, des transports, du bruit, de la pollution, etc. CityGML fournit l'architecture de données nécessaire pour la planification et la modélisation urbaines complexes, ainsi que la plate-forme standard ouverte pour permettre une collaboration et un partage parties prenantes dans le monde entier.

Existe-t-il d'autres modèles de données urbaines à consensus ouvert comme CityGML ?

Non. À notre connaissance, CityGML est la norme mondiale de facto pour les modèles urbains 3D géospatialement activés. L'Union européenne a intégré CityGML dans son plan d'infrastructure de données spatiales, Inspire.

ESRI, le principal fournisseur du secteur privé de solutions logicielles SIG pour les gouvernements et l'industrie du monde entier, dispose de modèles de données urbaines en 3D. Cependant, il s'agit de normes propriétaires et non de consensus ouverts. Ils nécessitent l'utilisation du logiciel ESRI, par exemple ArcGIS.

Quel logiciel prend actuellement en charge le modèle de données CityGML ?

Le logiciel SIG d'ESRI reconnaît CityGML ainsi que d'autres normes de données SIG ouvertes et fournit des outils pour importer/exporter des ensembles de données CityGML. Par conséquent, les modèles urbains CityGML peuvent être importés et utilisés dans les applications ESRI. Inversement, les applications ESRI peuvent exporter des modèles urbains en tant que CityGML pour une utilisation avec d'autres logiciels.

AutoDesk, RevIt et la plupart des autres outils logiciels de modélisation des informations du bâtiment (BIM) reconnaissent CityGML et fournissent des outils d'import/export pour le prendre en charge.

Le logiciel d'extraction/transformation/chargement de données Safe Software FME prend en charge CityGML.

Virtual City Systems est l'un des principaux fournisseurs d'outils logiciels à utiliser avec CityGML.

CesiumJS est une bibliothèque javascript Open Source permettant de créer des applications géospatiales qui restituent des visualisations 3D dans un navigateur Web, y compris des modèles CityGML 3D. Cesium.com fournit des services de contenu et de création pour la création et la diffusion en continu d'ensembles de tuiles 3D pour le rendu des visualisations dans les navigateurs Web à l'aide de CesiumJS.

Consultez le site Web CityGML.org pour plus d'informations.

  • De nombreux pays européens, notamment : Royaume-Uni, Allemagne, Autriche, France, Suisse, Pays-Bas, Belgique, Suède, Finlande, Pologne et plus encore avec une variété d'applications
  • Union européenne : spécifié pour l'infrastructure de données spatiales
  • International Building Performance Simulation Association (IBPSA) : outils de modélisation énergétique de nouvelle génération
  • Lawrence Berkeley National Laboratory (LBNL) : analyse de la rénovation énergétique à l'échelle urbaine (CityBES)
  • BuildZero.Org : planification, conception et modélisation énergétiques des bâtiments
  • New York
  • Montréal Canada
  • Singapour

Quels types d'applications utilisent CityGML ?

Engagement des citoyens/parties prenantes et référence

Modélisation urbaine à l'échelle de l'individu, du quartier à la ville. énergie, utilité, bruit, etc.

Analyse de la rénovation énergétique des bâtiments à l'échelle urbaine

Outils de modélisation énergétique à l'échelle des bâtiments, des quartiers et des villes de nouvelle génération :

Planification, conception et modélisation énergétiques des bâtiments

Pourquoi l'Open City Model (OCM) a-t-il été créé ?

Open Street Maps a été l'inspiration pour la création du modèle Open City. Les applications 3D comprenant des modèles urbains pour divers cas d'utilisation sont en forte demande et évoluent rapidement. OCM a été créé pour accélérer le développement et l'utilisation de modèles urbains 3D pour des applications critiques liées à l'action climatique.

Quelle est la vision de l'évolution du modèle de ville ouverte ?

Nous espérons que l'établissement d'OCM en tant que plate-forme de données ouvertes utilisant le modèle de données urbaines standard de consensus CityGML accélérera le développement, la collaboration et le partage. Le temps presse pour l'action climatique. D'autres domaines de l'urbanisme peuvent certainement en bénéficier. Vive la « Smart City » !


Écrans haute résolution

Les écrans haute résolution ont une densité de pixels accrue par rapport aux écrans DPI standard.

La densité de pixels est mesurée en points par pouce (DPI) ou en pixels par pouce (PPI) et est déterminée par le nombre de pixels d'affichage et leur taille. Par conséquent, le nombre de pixels seul n'est pas suffisant pour déterminer si un écran appartient à la catégorie des hautes résolutions.

Un moniteur 4K a un nombre fixe de pixels (

8M), cependant son DPI varie entre 185 (23 pouces) et 110 (40 pouces). Le premier est environ le double de la résolution de bureau standard de 96 DPI, le dernier dépasse à peine cette résolution.

Défis avec un DPI élevé

Les écrans à haute résolution posent certains défis pour les applications existantes :

  • Les applications utilisant des conceptions d'interface utilisateur avec des coordonnées fixes semblent petites
    La combinaison de la spécification de la taille de police en points et d'autres tailles en pixels est particulièrement problématique car les points sont indépendants de la résolution du moniteur. Par exemple, supposons que nous ayons un cadre de 40x20 pixels autour du texte "bonjour". Si nous utilisons une police de 12 points, cela semblerait correct sur les moniteurs à faible résolution. Mais, sur les moniteurs à haute résolution, le cadre serait trop petit, ce qui entraînerait un écrêtage du texte.
  • Les applications doivent s'adapter aux situations où les utilisateurs ont plusieurs écrans avec des résolutions différentes
    Par exemple, un utilisateur peut utiliser un moniteur 4K pour la fenêtre de document d'un éditeur d'images mais un moniteur basse résolution pour la boîte à outils.

Traditionnellement, pour prendre en charge un DPI élevé, Qt met automatiquement à l'échelle les polices et fournit une valeur DPI que le code de l'application peut utiliser pour mettre à l'échelle le reste de l'interface utilisateur.

Prise en charge DPI élevée au niveau du système

Qt prend en charge un mode DPI élevé dans lequel le système de coordonnées principal est virtualisé et rendu indépendant de la densité de pixels d'affichage. Certains systèmes d'exploitation, comme macOS et iOS implémentent ce mode. De plus, si un système d'exploitation ne prend pas en charge ce mode, Qt dispose d'une implémentation sur laquelle se replier.

Désormais, la géométrie est spécifiée en pixels indépendants du périphérique. Cela inclut la géométrie des widgets et des éléments, la géométrie des événements, la géométrie du bureau, des fenêtres et des écrans, ainsi que les vitesses d'animation. La sortie est rendue en pixels de périphérique, ce qui correspond à la résolution d'affichage. Le appareilPixelRatio est le rapport entre les pixels indépendants du périphérique et le système de coordonnées des pixels du périphérique.

En règle générale, la plupart des applications fonctionnent avec des pixels indépendants du périphérique, à l'exception d'OpenGL et du code pour les graphiques raster.

Prise en charge du système d'exploitation

Les systèmes d'exploitation pris en charge par Qt offrent les fonctionnalités suivantes pour les écrans haute résolution :

MacOS et iOS

Les plates-formes Apple implémentent la mise à l'échelle et la virtualisation du système de coordination dans le système d'exploitation. Normalement, aucune configuration spéciale n'est requise.

Sur macOS, la prise en charge des hautes résolutions est activée par les paramètres du fichier Info.plist, assurez-vous donc que ces paramètres sont présents.

Les versions plus récentes de qmake généreront un fichier Info.plist avec la clé NSPrincipalClass, ce qui est suffisant car NSHighResolutionCapable est vrai par défaut.

Noter: MacOS et iOS peuvent appliquer une virtualisation supplémentaire, de sorte que les pixels de l'appareil ne correspondent plus aux pixels d'affichage 1:1. Cela se produit sur l'iPhone 6+ et sur macOS configuré avec la "mise à l'échelle de l'affichage" activée.

Microsoft Windows

Les utilisateurs choisissent un facteur d'échelle dans le Panneau de commande ou via le menu contextuel. Cela fonctionne en faisant en sorte que les fonctions d'interrogation des métriques système renvoient des valeurs différentes pour les tailles de police standard, les tailles des bordures de fenêtre, etc. Il n'effectue aucune mise à l'échelle réelle.

Une application sous Windows peut assumer l'un des niveaux suivants de "DPI Awareness" :

Niveau de sensibilisation DPISens
DPI inconscientCe niveau a été introduit dans Windows Vista. Pour l'application, Windows prétend qu'il s'exécute sur un écran standard de 96 DPI de 1920 x 1080 et met l'application à l'échelle en conséquence. Il est destiné à accueillir des applications plus anciennes conçues pour les écrans à faible DPI. Ce type de mise à l'échelle peut entraîner certains artefacts.
Compatible avec le système DPICe niveau a été introduit dans Windows Vista. Il diffère de Compatible DPI par moniteur uniquement lorsque plusieurs moniteurs sont connectés. Windows calcule une mise à l'échelle adaptée à tous les moniteurs connectés.
Compatible DPI par moniteurCe niveau a été introduit dans Windows 8.1. Windows n'effectue aucune mise à l'échelle.

Par défaut, les applications Qt sont définies sur DPI par moniteur sur Windows 8.1 ou Compatible avec le système DPI sur les anciennes versions de Windows. Depuis Qt 5.4, ce niveau peut être spécifié via un paramètre du plugin de plate-forme :

Prise en charge DPI élevée dans Qt

Qt fournit les moyens suivants pour vous permettre de gérer le support DPI élevé dans votre application.

  • La possibilité de fournir des pixmaps ou des illustrations pour une haute résolution. Pour plus de détails, voir Dessiner des versions haute résolution de Pixmaps et d'images.
  • Qt 5.6 prend en charge la mise à l'échelle multiplateforme haute résolution pour les applications héritées, similaire à la mise à l'échelle effectuée nativement dans macOS. Cela permet aux applications écrites pour les écrans à faible DPI de s'exécuter sans changement sur les appareils à haute DPI. Cette fonctionnalité est facultative et peut être activée à l'aide des variables d'environnement suivantes :
    • QT_AUTO_SCREEN_SCALE_FACTOR [booléen] active la mise à l'échelle automatique, basée sur la densité de pixels du moniteur. Cela ne changera pas la taille des polices de taille point, puisque le point est une unité de mesure physique. Plusieurs écrans peuvent avoir des facteurs d'échelle différents.
    • QT_SCALE_FACTOR [numérique] définit un facteur d'échelle global pour l'ensemble de l'application, y compris les polices de taille point.
    • QT_SCREEN_SCALE_FACTORS [liste] spécifie les facteurs d'échelle pour chaque écran. Cela ne changera pas la taille des polices de taille point. La variable d'environnement est principalement utile pour le débogage ou pour contourner les moniteurs avec des informations EDID erronées (données d'identification d'affichage étendues).

    Le format peut être soit une liste de facteurs d'échelle séparés par des points-virgules dans le même ordre que QGuiApplication::screens(), soit une liste de paires nom=valeur séparées par des points-virgules, où le nom est le même que QScreen::name().

    Alors que le style macOS prend entièrement en charge la résolution élevée, le style de bureau Windows présente actuellement certaines limitations avec certains facteurs d'échelle. Dans ces cas, envisagez d'utiliser le style Fusion à la place, qui prend en charge la résolution élevée dans tous les cas.

    Noter: Des facteurs d'échelle non entiers peuvent provoquer des artefacts de mise à l'échelle/de peinture importants.

    Migrer les applications existantes

    Pour exécuter rapidement une application conçue pour des valeurs DPI faibles sur des moniteurs haute résolution, envisagez l'une des solutions suivantes :

    • laissez l'application s'exécuter en tant que DPI inconscient sous Windows
    • définissez la variable d'environnement QT_AUTO_SCREEN_SCALE_FACTOR sur 1 .

    Cependant, ces options peuvent entraîner des artefacts de mise à l'échelle ou de peinture.

    À long terme, l'application doit être adaptée pour fonctionner sans modification :

    • Utilisez toujours les versions qreal de l'API de dessin QPainter.
    • Dimensionner les fenêtres et les boîtes de dialogue en fonction de la taille d'écran correspondante.
    • Remplacez les tailles codées en dur dans les mises en page et le code de dessin par des valeurs calculées à partir des mesures de police ou de la taille de l'écran.

    Glossaire des termes à haute résolution

    TermeDéfinition
    Pixels indépendants de l'appareilLes pixels qu'une application utilise (espace utilisateur), soumis à une mise à l'échelle par le système d'exploitation ou Qt.
    Pixels de l'appareilLes pixels du périphérique d'affichage.
    Ratio de pixels de l'appareilFacteur d'échelle appliqué par le système d'exploitation ou par Qt.
    DPI logiqueLa résolution utilisée pour convertir les tailles de police définies en points en tailles de police en pixels. Les valeurs standard sont 96, 128, . 192.
    PPP physiqueLa résolution physique obtenue en divisant la taille du moniteur par le nombre de pixels.
    Espace utilisateurL'espace de coordonnées qu'une application utilise dans Device Independent Pixels.

    © 2021 The Qt Company Ltd. Les contributions à la documentation incluses dans le présent document sont la propriété de leurs propriétaires respectifs. La documentation fournie ici est concédée sous licence selon les termes de la licence de documentation libre GNU version 1.3 publiée par la Free Software Foundation. Qt et les logos respectifs sont des marques déposées de The Qt Company Ltd. en Finlande et/ou dans d'autres pays du monde. Tous les autres marques appartiennent à leurs propriétaires respectifs.


    S'il te plaît toujours poster un document complet qui montre l'erreur. Si je crée un document à partir de vos fragments publiés, je n'obtiens aucune erreur, donc votre erreur se situe probablement dans une partie de votre document que vous n'avez pas affichée.

    Si vous pouvez reproduire l'erreur, veuillez modifier votre question pour inclure un document qui montre le problème.

    La classe de document aip-cp - pour les actes de conférence AIP - ne prend pas en charge l'utilisation de subfloat . De plus, il est préférable d'éviter d'utiliser des packages supplémentaires pour les actes de conférence ou les soumissions de revues lorsque vous n'y êtes pas obligé. Surtout avec les sous-figures quand on peut les placer dans d'autres structures sans problème.

    Ci-dessous, j'ai placé chaque sous-figure dans un tableau aligné sur la [b] aseline en utilisant la disposition par défaut suivante par sous-figure :