Commit 2c736b38 authored by Cornic Alexia's avatar Cornic Alexia
Browse files

initialisation dossiers scripts

parents
-- Requête : 01_Requete_dissolve.sql
-- ===
-- Fusion (dissolve) des entités contigues de la table spatiale en entrée
-- Les entités qui se touchent sont fusionnées quelle que soit la classe
-- Input parameters :
-- 0 = input table
-- 1 = output table
-- =======================================================================
-- suppresion de la table output si elle existe
DROP TABLE IF EXISTS {1};
-- creation de multipolygones fonction de la géométrie :
-- * st_accum : fonction d'aggrégation pour construire des geometrycollection
-- * st_clusterintersecting : fonction d'aggrégation qui retourne un array de geometrycollections
-- * unnest : convertit un array en un jeu de lignes
-- * st_collectionextract : retourne une (multi-)géométrie en fonction d'un type (ici 3 = polygone)
WITH collect_extract AS
(SELECT st_collectionextract(unnest(st_clusterintersecting(st_accum(geom))),3) as geom FROM {0}),
-- creation d'un gid pour chaque entite de la table
prod_row_nb as (SELECT row_number() OVER() as gid, geom FROM collect_extract )
-- recuperation du gid commun, et de la géométrie d'origine
-- * st_dump : retourne les géométries constitutives d'une (multi-)géométrie
SELECT gid, ((st_dump(geom)).geom) as geom
INTO table_temp
FROM prod_row_nb;
-- Fusion des polygones contingues et creation d'une nouvelle géométrie (enveloppe englobante)
SELECT gid, st_union(st_makevalid(geom)) as geom
INTO {1}
FROM table_temp
GROUP BY gid;
-- suppression de la table temporaire
DROP TABLE table_temp;
-- creation d'un index spatial
CREATE INDEX {1}_geom_gist ON {1} USING GIST (geom);
\ No newline at end of file
-- Requête : 02_Requete_IOU.sql
-- ===
-- Création d'une nouvelle table qui comporte toutes les intersections 2 à 2 possibles
-- entre la table produite fusionnée (prod_fusion_xx) et la table test fusionnée (test_fusion_xx)
-- Input parameters :
-- 0 = prod table
-- 1 = test table
-- 2 = output table (iou)
-- =======================================================================
-- Intersection par jointure gauche des 2 tables pour avoir les faux négatifs (entités non détectées par le classifieur).
-- Conservation de toutes les entités test (référence), intersectées et non intersectées (valeur NULL dans colonne prod).
-- Calcul des superficies des entités de chacune des couches, des intersections, des unions d’entités 2 à 2
-- Calcul de l’IoU ligne par ligne, entités 2 à 2.
-- LEFT JOIN
DROP TABLE IF EXISTS left_join;
CREATE TEMPORARY TABLE left_join AS (
SELECT prod.gid as prod_id, test.gid as test_id, prod.geom as prod_geom, test.geom as test_geom,
ST_Area(prod.geom) as prod_surf,
ST_Area(test.geom) as test_surf,
ST_Area(ST_Intersection(ST_MakeValid(prod.geom), ST_MakeValid(test.geom))) as surf_int,
ST_Area(ST_Union(ST_MakeValid(prod.geom), ST_MakeValid(test.geom))) as surf_uni
FROM {1} AS test
LEFT JOIN {0} AS prod ON
ST_intersects(prod.geom, test.geom)
GROUP BY prod_id, test_id, test.geom, prod.geom
ORDER BY test_id
);
-- ADD IoU COLUMN ON LEFT_JOIN
ALTER TABLE left_join
ADD COLUMN IoU double precision;
UPDATE left_join
SET IoU=100*surf_int/surf_uni;
-- Intersection par jointure droitedes 2 tables pour avoir les faux positifs (entités détectées à tort par le classifieur).
-- Conservation de toutes les entités produites, intersectées et non intersectées (valeur NULL dans la colonne test).
-- Calcul des superficies des entités de chacune des couches, des intersections, des unions d’entités 2 à 2
-- Calcul de l’IoU ligne par ligne, entités 2 à 2.
-- RIGHT JOIN
DROP TABLE IF EXISTS right_join;
CREATE TEMPORARY TABLE right_join AS (
SELECT prod.gid as prod_id, test.gid as test_id, prod.geom as prod_geom, test.geom as test_geom,
ST_Area(prod.geom) as prod_surf,
ST_Area(test.geom) as test_surf,
ST_Area(ST_Intersection(ST_MakeValid(prod.geom), ST_MakeValid(test.geom))) as surf_int,
ST_Area(ST_Union(ST_MakeValid(prod.geom), ST_MakeValid(test.geom))) as surf_uni
FROM {1} AS test
RIGHT JOIN {0} AS prod ON
ST_intersects(prod.geom, test.geom)
GROUP BY prod_id, test_id, test.geom, prod.geom
ORDER BY prod_id
);
-- ADD IoU COLUMN ON RIGHT_JOIN
ALTER TABLE right_join
ADD COLUMN IoU double precision;
UPDATE right_join
SET IoU=100*surf_int/surf_uni;
-- Union des tables left_join et right_join
-- UNION OF TABLES LEFT/RIGHT JOIN
DROP TABLE IF EXISTS {2};
CREATE TABLE {2} AS (
SELECT * FROM left_join
UNION
SELECT * FROM right_join
ORDER BY test_id);
-- creation d'un index spatial
CREATE INDEX {2}_prod_geom_gist ON {2} USING GIST (prod_geom);
CREATE INDEX {2}_test_geom_gist ON {2} USING GIST (test_geom);
UPDATE {2}
SET iou=NULL WHERE iou =0;
\ No newline at end of file
-- Requête : 03_Requete_fp_tp_fn.sql
-- ===
-- Classification des résultats de classification en 3 classes :
-- * faux positifs
-- * faux négatifs
-- * vrais positifs
-- Input parameters :
-- 0 = iou table
-- =======================================================================
-- Mise à jour de la table IoU
ALTER TABLE {0}
DROP COLUMN IF EXISTS result_classif;
ALTER TABLE {0}
ADD COLUMN result_classif varchar;
UPDATE {0}
SET result_classif = 'faux negatif'
WHERE {0}.prod_id IS NULL;
UPDATE {0}
SET result_classif = 'faux positif'
WHERE {0}.test_id IS NULL;
UPDATE {0}
SET result_classif = 'vrai positif'
WHERE {0}.test_id IS NOT NULL AND {0}.prod_id IS NOT NULL;
\ No newline at end of file
-- Requête : 04_Requete_seuil_iou.sql
-- ===
-- Suppression des entités peu représentatives en fonction d'un seuil sur l'iou
-- n.b. cette opération ne conserve que les intersections valides (vrais positifs)
-- Input parameters :
-- 0 = input table (output de 03_Requete_fp_tp_fn.sql)
-- 1 = output table
-- 2 = seuil (en %)
-- =======================================================================
DROP TABLE IF EXISTS {1};
CREATE TABLE {1} AS (
SELECT * FROM {0} WHERE iou >{2});
-- creation d'un index spatial
CREATE INDEX {1}_prod_geom_gist ON {1} USING GIST (prod_geom);
CREATE INDEX {1}_test_geom_gist ON {1} USING GIST (test_geom);
\ No newline at end of file
-- Requête : 05_Requete_multi_iou.sql
-- ===
-- Calcul de l'IoU par entité produite en fonction de toutes les entités test intersectées (plusieurs entités test intersectées pour une entité prod)
-- expression :
-- soit * SI : surface intersectée
-- * SP : surface de l'entité produite
-- * ST : surface de l'entité test intersectée
-- IoU = SOMME(SI) / (SP + SOMME(ST) - SOMME(SI))
-- Input parameters :
-- 0 = input table
-- 1 = output table
-- =======================================================================
DROP TABLE IF EXISTS {1};
CREATE TABLE {1} AS (
SELECT prod_id,
SUM(surf_int) AS sum_int,
(prod_surf+SUM(test_surf)-SUM(surf_int)) AS sum_union
FROM {0}
GROUP BY prod_id, prod_surf
ORDER BY prod_id
);
-- ADD IoU COLUMN
ALTER TABLE {1}
ADD COLUMN IoU double precision;
UPDATE {1}
SET IoU=100*sum_int/sum_union;
\ No newline at end of file
-- Requête : 06_Requete_type_intersection.sql
-- ===
-- Classification des types d'intersection (fonction du nombre d'intersections en prod ou test) :
-- * agrégation
-- * fragmentation
-- * équivalent
-- * mixte (fragmentation et agrégation)
-- Input parameters :
-- 0 = input table (output de 04_Requete_seuil_iou.sql)
-- 1 = output table
-- =======================================================================
-- Création de la table des types d'intersection à partir de la table
-- créée dans la requête 04_Requete_seuil_iou.sql
-- (uniquement les vrais positifs au-delà d'un seuil d'IoU)
DROP TABLE IF EXISTS {1};
CREATE TABLE {1} AS (
SELECT prod_id, test_id, prod_geom, test_geom, prod_surf, test_surf, iou
FROM {0}
);
-- Comptage du nombre d’intersections des entités produites
ALTER TABLE {1}
DROP COLUMN IF EXISTS nb_prod;
ALTER TABLE {1}
ADD COLUMN nb_prod smallint DEFAULT 0;
UPDATE {1}
SET nb_prod = (
SELECT COUNT (t1.test_id)
FROM {0} AS t1
WHERE ST_Intersects(prod_geom, test_geom) AND {1}.prod_id = t1.prod_id);
-- Comptage du nombre d’intersections des entités test
ALTER TABLE {1}
DROP COLUMN IF EXISTS nb_test;
ALTER TABLE {1}
ADD COLUMN nb_test smallint DEFAULT 0;
UPDATE {1}
SET nb_test = (
SELECT COUNT (t1.prod_id)
FROM {0} AS t1
WHERE ST_Intersects(prod_geom, test_geom) AND {1}.test_id=t1.test_id);
-- Définition du type d’intersection (fragmentation, agrégation, équivalence et mixte).
-- * fragmentation : nb INT(entités test) > nb INT(entités produites)
-- * agrégation : nb INT(entités test) < nb INT(entités produites)
-- * équivalent : nb INT(entités test) = 1 AND nb INT(entités prod) = 1
-- * mixte : nb INT(entités test) > 1 AND nb INT(entités prod) > 1
ALTER TABLE {1}
DROP COLUMN IF EXISTS type_int;
ALTER TABLE {1}
ADD COLUMN type_int varchar;
UPDATE {1}
SET type_int = 'fragmentation'
WHERE {1}.nb_test > {1}.nb_prod;
UPDATE {1}
SET type_int = 'agregation'
WHERE {1}.nb_test < {1}.nb_prod;
UPDATE {1}
SET type_int = 'equivalent'
WHERE {1}.nb_test = 1 AND {1}.nb_prod =1;
UPDATE {1}
SET type_int = 'mixte'
WHERE {1}.nb_test > 1 AND {1}.nb_prod >1;
\ No newline at end of file
-- Requête : 07_Requete_rm_double.sql
-- ===
-- Gestion des doublons liés à la catégorie mixte
-- Description :
-- Les entités mixtes agrègent ou fragmentent également. Il y a donc des doublons dans la table.
-- 2 cas possibles :
-- * laisser de côté le type de qualification mixte et considérer uniquement l'entité comme agrégeant ou fragmentant.
-- -> suppression des lignes où le type_int = 'mixte'
-- * considérer ces entités comme étant uniquement des entités mixtes (chose faite ici)
-- -> créer d'une table temporaire dans laquelle sont recensées les entités en doublon
-- (même id mais type_int différent, c'est-à-dire agrégation/fragmentation ET mixte)
-- -> suppression du doublon, soit la ligne où l'entité est référencée en fragmentation ou agrégation
-- Input parameters :
-- 0 = input table
-- =======================================================================
-- Création d'une table temporaire pour extraire uniquement les doublons
DROP TABLE IF EXISTS doublon;
CREATE TABLE doublon AS (
SELECT DISTINCT *
FROM {0} AS t1
WHERE EXISTS (
SELECT *
FROM {0} AS t2
WHERE t1.prod_id = t2.prod_id AND t1.type_int <> t2.type_int )
)
ORDER BY prod_id;
-- Création d'une table temporaire à partir de la table temporaire dans laquelle
-- sont supprimées les lignes de type_int = 'mixte' (conserve uniquement le type agrégation ou fragmentation)
DROP TABLE IF EXISTS doublon_ok;
CREATE TABLE doublon_ok AS (
SELECT *
FROM doublon
WHERE type_int != 'mixte'
)
ORDER BY prod_id;
-- Suppression, dans la table sortie de la requête 06_Requete_{0}ion.sql, des entités
-- référencées dans la table doublon_ok. Restent uniquement des occurrences uniques d'entités avec un
-- seul et unique type d'intersection.
DELETE FROM {0} AS t1 WHERE EXISTS (
SELECT *
FROM doublon_ok AS t2
WHERE t1.prod_id = t2.prod_id AND t1.test_id = t2.test_id AND t1.type_int = t2.type_int
ORDER BY prod_id
);
DROP TABLE doublon;
DROP TABLE doublon_ok;
\ No newline at end of file
-- Requête : 08_Requete_synthese_results.sql
-- ===
-- Table de synthèse avec :
-- * nombre et % d'entités test et prod
-- * nombre et % de faux positifs
-- * nombre et % de faux négatifs
-- * nombre et % de vrais positifs
-- * nombre et % d'agrégation
-- * nombre et % de fragmentation
-- * nombre et % d'équivalent (test et prod)
-- * nombre et % de mixte
-- * rappel, précision et f-score
-- Input parameters :
-- 0 = input table iou
-- 1 = input table type_intersect
-- 2 = output table
-- =======================================================================
DROP TABLE IF EXISTS {2};
CREATE TABLE {2} (
fp double precision,
fp_percent double precision,
fn double precision,
fn_percent double precision,
tp_prod double precision,
tp_prod_percent double precision,
tp_test double precision,
entites_prod double precision,
entites_test double precision,
rappel double precision,
preciz double precision,
fscore double precision,
nb_agreg double precision,
nb_fragment double precision,
nb_equivalent double precision,
nb_mixte double precision,
agreg_percent double precision,
fragment_percent double precision,
equivalent_percent_prod double precision,
equivalent_percent_test double precision,
mixte_percent double precision);
INSERT INTO {2}(fp) VALUES(
(SELECT COUNT(test.*) FROM {0} AS test WHERE test_id is null)
);
UPDATE {2}
SET fn = (SELECT COUNT(test.*)
FROM {0} AS test
WHERE prod_id is null),
tp_prod = (SELECT COUNT(DISTINCT test.prod_id)
FROM {0} AS test
WHERE test_id is not null and prod_id is not null),
tp_test = (SELECT COUNT(DISTINCT test.test_id)
FROM {0} AS test
WHERE test_id is not null and prod_id is not null),
nb_agreg = (SELECT COUNT(DISTINCT typ.prod_id)
FROM {1} AS typ
WHERE type_int = 'agregation'),
nb_fragment = (SELECT COUNT(DISTINCT typ.prod_id)
FROM {1} AS typ
WHERE type_int = 'fragmentation'),
nb_equivalent = (SELECT COUNT(DISTINCT typ.prod_id)
FROM {1} AS typ
WHERE type_int = 'equivalent'),
nb_mixte = (SELECT COUNT(DISTINCT typ.prod_id)
FROM {1} AS typ
WHERE type_int = 'mixte');
UPDATE {2}
SET entites_prod = fp+tp_prod,
entites_test = fn + tp_test;
UPDATE {2}
SET fp_percent = 100*fp/NULLIF(entites_prod,0),
tp_prod_percent = 100*tp_prod/NULLIF(entites_prod,0),
fn_percent = 100*fn/NULLIF(entites_test,0),
agreg_percent = 100*nb_agreg/NULLIF(entites_prod,0),
fragment_percent = 100*nb_fragment/NULLIF(entites_prod,0),
equivalent_percent_prod = 100*nb_equivalent/NULLIF(entites_prod,0),
equivalent_percent_test = 100*nb_equivalent/NULLIF(entites_test,0),
mixte_percent = nb_mixte/100*NULLIF(entites_prod,0);
UPDATE {2}
SET rappel = tp_test/NULLIF(tp_test+fn,0),
preciz = tp_prod/NULLIF(entites_prod,0);
UPDATE {2}
SET fscore = 2*(preciz*rappel)/NULLIF(preciz+rappel,0);
\ No newline at end of file
-- Requête : 09_Requete_synthese_results_fscore_surf.sql
-- ===
-- Table de synthèse avec, par range de surface :
-- * nombre faux positifs
-- * nombre de faux négatifs
-- * nombre de vrais positifs
-- * rappel, précision et f-score
-- Input parameters :
-- 0 = input table iou
-- 1 = output table
-- =======================================================================
DROP TABLE IF EXISTS {1};
CREATE TABLE {1} (
tp_prod_surf1 double precision,
tp_test_surf1 double precision,
tp_prod_surf2 double precision,
tp_test_surf2 double precision,
tp_prod_surf3 double precision,
tp_test_surf3 double precision,
tp_prod_surf4 double precision,
tp_test_surf4 double precision,
tp_prod_surf5 double precision,
tp_test_surf5 double precision,
tp_prod_surf6 double precision,
tp_test_surf6 double precision,
tp_prod_surf7 double precision,
tp_test_surf7 double precision,
tp_prod_surf8 double precision,
tp_test_surf8 double precision,
fn_surf1 double precision,
fn_surf2 double precision,
fn_surf3 double precision,
fn_surf4 double precision,
fn_surf5 double precision,
fn_surf6 double precision,
fn_surf7 double precision,
fn_surf8 double precision,
fp_surf1 double precision,
fp_surf2 double precision,
fp_surf3 double precision,
fp_surf4 double precision,
fp_surf5 double precision,
fp_surf6 double precision,
fp_surf7 double precision,
fp_surf8 double precision,
fscore_surf1 double precision,
fscore_surf2 double precision,
fscore_surf3 double precision,
fscore_surf4 double precision,
fscore_surf5 double precision,
fscore_surf6 double precision,
fscore_surf7 double precision,
fscore_surf8 double precision,
rappel_surf1 double precision,
preciz_surf1 double precision,
rappel_surf2 double precision,
preciz_surf2 double precision,
rappel_surf3 double precision,
preciz_surf3 double precision,
rappel_surf4 double precision,
preciz_surf4 double precision,
rappel_surf5 double precision,
preciz_surf5 double precision,
rappel_surf6 double precision,
preciz_surf6 double precision,
rappel_surf7 double precision,
preciz_surf7 double precision,
rappel_surf8 double precision,
preciz_surf8 double precision)
;
INSERT INTO {1}(tp_prod_surf1) VALUES(
(SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 2.25 and test_surf < 10)
);
UPDATE {1}
SET tp_prod_surf2 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 10 and test_surf < 100),
tp_prod_surf3 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 100 and test_surf < 200),
tp_prod_surf4 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 200 and test_surf < 500),
tp_prod_surf5 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 500 and test_surf < 1000),
tp_prod_surf6 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 1000 and test_surf < 50000),
tp_prod_surf7 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 50000 and test_surf < 100000),
tp_prod_surf8 = (SELECT COUNT(DISTINCT bati.prod_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 100000 and test_surf < 125000),
tp_test_surf1 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 2.25 and test_surf < 10),
tp_test_surf2 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 10 and test_surf < 100),
tp_test_surf3 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 100 and test_surf < 200),
tp_test_surf4 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 200 and test_surf < 500),
tp_test_surf5 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 500 and test_surf < 1000),
tp_test_surf6 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 1000 and test_surf < 50000),
tp_test_surf7 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 50000 and test_surf < 100000),
tp_test_surf8 = (SELECT COUNT(DISTINCT bati.test_id) FROM {0} AS bati WHERE test_id is not null and prod_id is not null and test_surf >= 100000 and test_surf < 125000),
fn_surf1 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 2.25 and test_surf < 10),
fn_surf2 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 10 and test_surf < 100),
fn_surf3 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 100 and test_surf < 200),
fn_surf4 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 200 and test_surf < 500),
fn_surf5 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 500 and test_surf < 1000),
fn_surf6 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 1000 and test_surf < 50000),
fn_surf7 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 50000 and test_surf < 100000),
fn_surf8 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE prod_id is null and test_surf >= 100000 and test_surf < 125000),
fp_surf1 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 2.25 and prod_surf < 10),
fp_surf2 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 10 and prod_surf < 100),
fp_surf3 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 100 and prod_surf < 200),
fp_surf4 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 200 and prod_surf < 500),
fp_surf5 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 500 and prod_surf < 1000),
fp_surf6 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 1000 and prod_surf < 50000),
fp_surf7 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 50000 and prod_surf < 100000),
fp_surf8 = (SELECT COUNT(bati.*) FROM {0} AS bati WHERE test_id is null and prod_surf >= 100000 and prod_surf < 125000);
UPDATE {1}
SET rappel_surf1 = tp_test_surf1/NULLIF(tp_test_surf1+fn_surf1,0),
preciz_surf1 = tp_prod_surf1/NULLIF(tp_prod_surf1+fp_surf1,0),
rappel_surf2 = tp_test_surf2/NULLIF(tp_test_surf2+fn_surf2,0),
preciz_surf2 = tp_prod_surf2/NULLIF(tp_prod_surf2+fp_surf2,0),
rappel_surf3 = tp_test_surf3/NULLIF(tp_test_surf3+fn_surf3,0),
preciz_surf3 = tp_prod_surf3/NULLIF(tp_prod_surf3+fp_surf3,0),
rappel_surf4 = tp_test_surf4/NULLIF(tp_test_surf4+fn_surf4,0),
preciz_surf4 = tp_prod_surf4/NULLIF(tp_prod_surf4+fp_surf4,0),
rappel_surf5 = tp_test_surf5/NULLIF(tp_test_surf5+fn_surf5,0),
preciz_surf5 = tp_prod_surf5/NULLIF(tp_prod_surf5+fp_surf5,0),
rappel_surf6 = tp_test_surf6/NULLIF(tp_test_surf6+fn_surf6,0),
preciz_surf6 = tp_prod_surf6/NULLIF(tp_prod_surf6+fp_surf6,0),
rappel_surf7 = tp_test_surf7/NULLIF(tp_test_surf7+fn_surf7,0),
preciz_surf7 = tp_prod_surf7/NULLIF(tp_prod_surf7+fp_surf7,0),
rappel_surf8 = tp_test_surf8/NULLIF(tp_test_surf8+fn_surf8,0),
preciz_surf8 = tp_prod_surf8/NULLIF(tp_prod_surf8+fp_surf8,0);
UPDATE {1}
SET fscore_surf1 = 2*(preciz_surf1*rappel_surf1)/NULLIF(preciz_surf1+rappel_surf1,0),
fscore_surf2 = 2*(preciz_surf2*rappel_surf2)/NULLIF(preciz_surf2+rappel_surf2,0),
fscore_surf3 = 2*(preciz_surf3*rappel_surf3)/NULLIF(preciz_surf3+rappel_surf3,0),
fscore_surf4 = 2*(preciz_surf4*rappel_surf4)/NULLIF(preciz_surf4+rappel_surf4,0),
fscore_surf5 = 2*(preciz_surf5*rappel_surf5)/NULLIF(preciz_surf5+rappel_surf5,0),
fscore_surf6 = 2*(preciz_surf6*rappel_surf6)/NULLIF(preciz_surf6+rappel_surf6,0),
fscore_surf7 = 2*(preciz_surf7*rappel_surf7)/NULLIF(preciz_surf7+rappel_surf7,0),
fscore_surf8 = 2*(preciz_surf8*rappel_surf8)/NULLIF(preciz_surf8+rappel_surf8,0);
\ No newline at end of file
<
-- Requête : 09_Requete_synthese_results_fscore_surf_equi.sql
-- ===
-- Table de synthèse avec, par range de surface (intersections 1 à 1):
-- * nombre faux positifs
-- * nombre de faux négatifs
-- * nombre de vrais positifs