Le portail francophone de la géomatique

Bonjour Renard,

je n'ai pas la solution mais je recherche la même chose que toi (je pense).
J'ai posté également un message dans le sous-forum "Assistance et programmation".
Espérant que l'union de nos demandes vont aboutir à une solution.
Je jèterai un oeil à ton fil de discussion, en même temps que le mien.

Tu évoques MapFish. J'ai également entendu parler de TinyOWS.

Voyons ce qu'en pense les spécialistes SIG du forum.

Bonjour,

TinyOWS est un serveur proposant des services OGC, notamment WFS-T.

MapFish est un serveur spatial dans la mesure où on lui passe des géométries et des actions à réaliser. Là où il se différencie avec MapServer  est qu'il ne renvoie pas d'image. Comme dit dans un autre poste il ne gère que des données vecteurs (et encore je pense qu'il doit être possible de traiter des données raster, mais il faut pouvoir l'afficher côté client ).

MapFish permet donc de réaliser des traitements spatiaux distants : recherche (geocodage et reverse geocoding), intersection, etc. Par défaut après installation il vous permet de lire et d'écrire des données. Toutes les autres actions peuvent/doivent être codée. Pour "discuter" entre la partie serveur et client, MapFish utilise un protocole REST qui permet de savoir comment envoyer les informations vers le serveur. Celui-ci renvoie les données au format GeoJSON.

Il n'y a pas une solution, mais des solutions possibles, et une sera plus pertinente que les autres dans votre cas. La bonne solution dépend de vos compétences en programmation, de vos objectifs à long terme, des fonctionnalités nécessaires, etc.

Il n'y a pas de mauvaises solutions, il n'y a que des mauvais choix

Y.

Bonjour,

Yves a raison, vous avez a conduire une solide réflexion concernant les choix à faire en fonction de vos contraintes et de vos compétences, ainsi que de votre budget.
Si cela peut vous éclairer voici notre situation et les choix fait :

Structure générale :
stockage : postgres/postgis + shape progressivement migrées vers postgis selon besoin (qq anciennes données sous Excel, Access)
serveur : linux debian en local et chez un hébergeur (avec notamment : apache, mapserver, php, tilecache, subversion, postgres/postgis, mysql)
poste de travail : windows (ms4w, tortoise, notepad ++, putty, wincsp, pgadmin)

Niveau 1 = application "presse bouton" permettant de gérer des données métier (une application par thème, sujet) -> développement interne ou via prestataire : symphony (php), Extjs, geoExt ou mapfish client, openlayers (Javascripth). Toutes nos applications sont basées sur des bases postgis, les cartes rasters sont servies en wms par mapserver, les vecteurs sont produits par une requête sql à la base postgis qui renvoie du geojson pour les géométries. Ce geojson est lu par openlayers pour être affiché sur les fonds de cartes. Openlayers est capable d'éditer ces géométries et de les renvoyer à postgis pour enregistrement en base (format WKT). GeoExt ou mapfish ne font que marier Openlayers et ExtJs pour offrir des fonctionnalités étendues. PHP (framework symphony mais sans obligation) pilote les échanges (SQL) entre la base postgis et les librairies javascprit permettant aux clients de lire et éditer les données géographiques et attributaires. L'utilisation de ces outils demandes de bonnes compétences en développement que nous avons acquises progressivement en auto-formation et/ou via une prestation d'assistance avec des sociétés spécialisées.

Niveau 2 : certains utilisateurs ont des besoins au dela du niveau 1 et doivent pouvoir faire des traitements ou des production de couches eux mêmes : Qgis (ou GSVIG) + formation

Niveau 3 : administrateur(s) de données : Postgis - Arcgis - OGR2OGR - GDAL ...etc

Coté solution payantes, non retenue chez nous pour le moment mais permettant de mettre en oeuvre un websig ou des applications plus ou moins complexes : voir du coté de dynmap (de Symalis) ou de veremap pro (Veremmes). Existe aussi la solution Aigle (Cyril) et surement bien d'autres. Je crois avoir lu que Veremap doit ou est passé en Opensource.

Cordialement

Le plus simple serait que je t'envoie un script d'exemple complet mais en gros :
postgis possède une fonction ST_asgeojson qui retourne la géométrie directement au format geojson et une fonction st_geomfromtext qui permet d'enregistrer une géométrie à partir d'un format wkt qu'Openlayers est capable de retourner.
voici un exemple c'est toujours plus parlant (les géométries sont stockées dans un champ the_geom dans la base postgis) :
ma requete sql :

"SELECT st_asgeojson(a.the_geom) as geojson, a.id, t.nom_territoire, a.nom_aire, a.num_aire, 
        obs.prenom_role, obs.nom_role, a.altitude, a.hauteur_falaise, a.id_orientation, a.id_position, a.id_substrat, a.id_topologie, o.orientation, p.positionnement, s.substrat, g.topologie, a.annee_decouverte, validation, s.type_substrat
        FROM matable a
        join cor_aire_territoire c on c.id_aire = a.id_aire
        join t_territoires t on t.id_territoire = c.id_territoire
        left join bib_orientations o on o.id_orientation = a.id_orientation
        left join bib_positions p on p.id_position = a.id_position
        left join bib_substrats s on s.id_substrat = a.id_substrat
        left join bib_topologies g on g.id_topologie = a.id_topologie
        left join utilisateurs.t_roles obs on obs.id_role = a.id_observateur
        WHERE t.annee = 2010";

QQ extrait de php pour que tu comprennes un peu mieux ce que retourne postgis avec le st_asgeojson:

$prefix = '{"type": "FeatureCollection","features":[';
//$debut='{"geometry":{"type":"GeometryCollection","geometries":[';
$debut='{"geometry":';
$fin=',"type": "Feature","properties": {}}';
$suffix=']}';

Ici la requete sql dans une variable $sqliste

    //Executer la requete
    $result = pg_query($sqliste) or die ('Échec requête : ' . pg_last_error()) ;
    //Compter le nombre d'enregistrements renvoyés par la requete
    $nb = pg_numrows($result);
    
    while ($val = pg_fetch_assoc($result)){
        $compt++;
        $id = $val['id'];
        $num= $val['num'];
        $nom = $val['nom'];
        $nom_territoire = $val['nom_territoire'];
        $altitude = $val['altitude'];
        $hauteur_falaise = $val['hauteur_falaise'];
        $id_observateur = $val['id_observateur'];
        $decouvreur = $val['prenom_role']." ".$val['nom_role'];
        $orientation = $val['orientation'];
        $positionnement = $val['positionnement'];
        $substrat = $val['substrat'];
        $topologie = $val['topologie'];
        $id_orientation = $val['id_orientation'];
        $id_position = $val['id_position'];
        $id_substrat = $val['id_substrat'];
        $type_substrat = $val['type_substrat'];
        $id_topologie = $val['id_topologie'];
        $annee_decouverte = $val['annee_decouverte'];
        $validation = $val['validation'];
        if($validation=='t'){$validation ='true';}else{$validation='false';}
        $fin=',"type": "feature","id": '.$id.',"properties": {"nom": "'.$nom.'","id": "'.$id.'","num": "'.$num.'","territoire": "'.$nom_territoire.'","altitude": "'.$altitude.'","hauteur_falaise": "'.$hauteur_falaise.'","orientation": "'.$orientation.'","positionnement": "'.$positionnement.'","substrat": "'.$substrat.'","type_substrat":"'.$type_substrat.'","topologie": "'.$topologie.'","id_orientation": "'.$id_orientation.'","id_position": "'.$id_position.'","id_substrat": "'.$id_substrat.'","id_topologie": "'.$id_topologie.'","annee_decouverte": "'.$annee_decouverte.'","id_observateur": "'.$id_observateur.'","decouvreur": "'.$decouvreur.'","validation": "'.$validation.'"}}';
        $str = $debut.$val['geojson'].$fin;
        if ($compt >1){$virgule = ",";}
        $geojson = $geojson.$virgule.$str;
}
echo $prefix.$geojson.$suffix;

ce qu'elle retourne en geojson :

{"type": "FeatureCollection","features":[{"geometry":{"type":"Point","coordinates":[402225.554686374380253,1758054.555962574901059]},"type": "feature","id": 732,"properties": {"nom": "demo19","id": "732","num": "demo19","territoire": "toto","altitude": "1800","hauteur_falaise": "100","orientation": "Sud-Est","positionnement": "milieu","substrat": "calcaire","type_substrat":"sédimentaire","topologie": "falaise","id_orientation": "4","id_position": "2","id_substrat": "1","id_topologie": "1","annee_decouverte": "1978","id_observateur": "99","decouvreur": "Dupont","validation": "false"}}]}

Openlayers sait lire et charger les objets vecteurs de ce geojson, tu trouvera des exemples ici avec geoext : http://geotribu.net/taxonomy/term/14
Openlayers te permet maintenant d'éditer ces géométries de manière très intuitive : tu peux voir des exemples sur le site d'openlayers : http://openlayers.org/dev/examples/ par exemple regarde : "vector formats exemple", "GeoJSON Example", "editing toolbar Example" et bien d'autres (tout le code source est disponible)
Ensuite Openlayers peut te renvoyer en wkt ce qui est éditer par les outils d'édition.
PHP sera utilisé pour injecter ce wkt en SQL dans postgis :
exemple coté openlayers (c'est du javascript)

var format = new OpenLayers.Format.WKT();
var updateGeometryFormField = function() {
        if (layer.features[0]){
                        //récupération de la géométrie dessinée
            var geom = layer.features[0];
            if (geom == null) {
                wkt = '';
            } else {
                                //récupération en wkt de la géométrie dessinée
                var wkt = format.write(geom);
            }
            //mise à jour du champ hidden geometry du formulaire extjs
            Ext.getCmp('form-edit').getForm().findField('geometry').setValue(wkt);
        }
        else{return false;}
    };

Puis on récupère coté PHP ce que le formulaire à posté ($_GET['leChampDeMonFormulaire']) et on enregistre en SQL

$geometry=$_GET['geometry'];
$id =  $_GET['id'];
$nom_champ = $_GET['nom_champ'];
$sql = "Update matable 
set nom_champ = '$nom_champ', 
the_geom = st_geomfromtext('$geometry',27572)
WHERE id = $id";
$result = pg_query($sql) or die ('{success: false, msg:"ben ! pas bon."}') ;
$msg= "update ok !";
echo "{success: true, msg:'".$msg."'}";

Voilà en gros le cheminement serveur ->client -> édition coté client ->enregistrement des modifications en base

Il faut donc que tu soit familié avec le SQL, le PHP, les formulaires HTML et/ou EXTJS, que tu découvres progressivement Openlayers avec des tuto et que tu installes POstgres et Postgis (assez facile sur windows). Les fonctions de postgis sont bien documentées.

Pour répondre à ta question : la requete est faite en AJAX par EXTJS mais ce n'est pas obligatoire. Postgis stocke les géométries en WKB mais sais lire le WKT et écrire du WKB à partir du WKT (st_geomfromtext)

En espérant que cela t'éclaire.

Bonjour,
Le Conseil Régional de Bretagne en partenariat avec les services de l'Etat
ont développé des modules sur une base GEOSERVER.
Tout a été reversé dans le libre sous le nom de GEOORCHESTRA.
Vous pouvez contacter lydie.vinsonneau@texte-a-enlever.region-bretagne.fr à la région
bretagne. Les modules permettent en autre : D'avoir une base en
modification, attributaire/géométrique, de faire des extractions de données,
des requêtes etc...

Sylvaine DUCEUX
Responsable SIG-Bureau de dessin

Courriel : sduceux@texte-a-enlever.agglo-lorient.fr

aïe j'ai du mal à saisir.

Sur ce schéma http://mapfish.org/_images/mapfish_architecture_en.png paster serait où? Avec le mod_wsgi le python et php est interprété par apache et non plus par paster? ou apache se place comme un intermédiaire?
merci,

Bonsoir,

est-ce obligé de passer par le format geojson ? Je dis çà car je ne bénéficie pas de st_asgeojson dans mon postgis.

Je vois st_geomfromtext dans ton code php, mais ce n'est pas reconnu non ?

Merci d'avance.

bonjour,

Les fonctions commençant par ST_ ont été introduites pour des questions de compatibilités avec des normes. Elles existent généralement sous forme de fonction identique sans le st_.

Y.

geomfromtext va te permettre d'enregistrer dans postgis une géométrie produite par openlayers ; dans l'autre sens (postgis vers openlayers) si tu n'as pas le asgeojson dans postgtis, il faut que tu fasses comme je t'ai dis plus haut : utiliser PHP pour construire du geojson à partir de ce que peux te renvoyer postgis ou voir si openlayers sait lire autre chose que postgis serait en capacité de produire.
Je te conseille tout de même de voir pour une mise à jour de postgis. Je me souviens avoir galéré en voulant installer une version 1.4 et être revenu à une 1.3.6 qui comporte ce st_asgeojson aussi. Je n'ai pas fait de procédure mais tu devrais trouver ça qq part sur ce forum ou ailleurs. Il faut aussi que ta version de postgres soit compatible avec les nouvelles versions de postgis.
Tout dépend sur quel OS est ton postgres, si tu as ou non des bases déjà en prod, si tu as un serveur et un seul ou si tu un serveur de test.
Je te conseille de faire une install en local de postgres postgis tout neuf (version 9 ;-) )sur ton poste de travail et de voir avec ça si tu parviens à faire ce que tu enviseages. Si ça fonctionne, tu étudieras ensuite les solutions pour migrer ce qui est en prod.

Bonjour,

Delu, les performances sont-elles plus/moins/équivalentes au wms pour consulter des vecteurs (je pense apporter la modifications plus tard)?

merci.

merci, ca répond tout à fait à ma question, et j'appréhende un peu pour mon application webcarto qui doit comporter...3000polygones (mais souvent rectangulaire, ce sont des extraits de cadastres)+ pas mal de linéaire. Je te demandais ca pour gérer les données qui n'auront pas vocation à être être modifié, peut être alors le wms serait plus rapide (notamment grâce à tilecache). 

Tu obtiens ce résultat de 8 avec quel vitesse de connexion en up?

merci.