Pré projet thèse SHS Big Data Institut de Géographie de Neuchâtel F.-F. FLUCK

1. #include "opencv/highgui.h"
#include "opencv/cv.h"
#include <windows.h>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#define abs(x) ((x) > 0 ? (x) : -(x))
#define sign(x) ((x) > 0 ? 1 : -1)
#define STEP_MIN 5
#define STEP_MAX 100
IplImage *image;
CvPoint position_objet = cvPoint(-1, -1);
int curseurX, curseurY;
void gestion_erreur(int etat);
void calibre();
void deplacement();
void calcul_ratio();
void clic();
int h = 0, s = 0, v = 0, tolerance = 5;
const char * TRACKEUR_COULEUR = "TRACKEUR_COULEUR";
const char * MASQUE = "MASQUE";
bool fin_selection = false;
bool fin_calibre = false;
bool fin_calcul = false;
int compt1 = 0;
int compt2 = 0;
int compt3 = 0;
bool etat_fenetre_calibration = false;
int ordre_calibre = 0;
//int calibration [9] [2];
int maxX, minX, maxY, minY;
float ratioX, ratioY;
float position_curseurX, position_curseurY;
float var_clic[20][2] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
int tempo_clic;
CvPoint binarisation(IplImage * image, int *nbPixels){
int x, y;
CvScalar pixel;
IplImage *hsv, *mask;
IplConvKernel *kernel;
int sommeX = 0, sommeY = 0;
*nbPixels = 0;
mask = cvCreateImage(cvGetSize(image), image->depth, 1);
hsv = cvCloneImage(image);
cvCvtColor(image, hsv, CV_BGR2HSV);
cvInRangeS(hsv, cvScalar(h - tolerance - 1, s - tolerance, 0), cvScalar(h + tolerance - 1, s + tolerance, 255), mask);
kernel = cvCreateStructuringElementEx(5, 5, 2, 2, CV_SHAPE_ELLIPSE);
///////
cvDilate(mask, mask, kernel, 1);
cvErode(mask, mask, kernel, 1);
for (x = 0; x < mask->width; x++) {
for (y = 0; y < mask->height; y++) {
if (((uchar *)(mask->imageData + y*mask->widthStep))[x] == 255) {
sommeX += x;
sommeY += y;
(*nbPixels)++;
}
}
}
///////////
cvShowImage(MASQUE, mask);
cvReleaseStructuringElement(&kernel);
cvReleaseImage(&mask);
cvReleaseImage(&hsv);
if (*nbPixels > 0)
return cvPoint((int)(sommeX / (*nbPixels)), (int)(sommeY / (*nbPixels)));
else
return cvPoint(-1, -1);
}
void ajouter_pointeur(IplImage* image, CvPoint Position_suivante_objet, int nbPixels){
int objet_prochaine_etapeX, objet_prochaine_etapeY;
if (nbPixels > 10)
{
if (position_objet.x == -1 || position_objet.y == -1){
position_objet.x = Position_suivante_objet.x;
position_objet.y = Position_suivante_objet.y;
}
if (abs(position_objet.x - Position_suivante_objet.x) > STEP_MIN){
objet_prochaine_etapeX = max(STEP_MIN, min(STEP_MAX, abs(position_objet.x - Position_suivante_objet.x) / 2));
position_objet.x += (-1) * sign(position_objet.x - Position_suivante_objet.x) * objet_prochaine_etapeX ;
curseurX = (-1) * sign(position_objet.x - Position_suivante_objet.x) * objet_prochaine_etapeX;
}
if (abs(position_objet.y - Position_suivante_objet.y) > STEP_MIN){
objet_prochaine_etapeY = max(STEP_MIN, min(STEP_MAX, abs(position_objet.y - Position_suivante_objet.y) / 2));
position_objet.y += (-1) * sign(position_objet.y - Position_suivante_objet.y) * objet_prochaine_etapeY ;
curseurY = position_objet.y += (-1) * sign(position_objet.y - Position_suivante_objet.y) * objet_prochaine_etapeY;
}
}
else {
position_objet.x = -1;
position_objet.y = -1;
}
if (nbPixels > 10)
cvDrawCircle(image, position_objet, 5, CV_RGB(0, 55, 255), -1);
CvPoint point1 = cvPoint(minX,minY);
CvPoint point2 = cvPoint(maxX, maxY);
//std::cout << minX << maxX << minY << maxY;
cvDrawRect(image, point1, point2, CV_RGB(0, 0, 255), 2);
cvShowImage(TRACKEUR_COULEUR, image);
}
void choisir_couleur(int event, int x, int y, int flags, void *param = NULL){
CvScalar pixel;
IplImage *hsv;
if (event == CV_EVENT_LBUTTONUP){
fin_selection = true;
hsv = cvCloneImage(image);
cvCvtColor(image, hsv, CV_BGR2HSV);
pixel = cvGet2D(hsv, y, x);
h = (int)pixel.val[0];
s = (int)pixel.val[1];
v = (int)pixel.val[2];
cvReleaseImage(&hsv);
}
}
int application(){
IplImage *hsv;
CvCapture *capture;
char touche;
int nbPixels;
CvPoint position_suivant;
capture = cvCreateCameraCapture(0);
if (!capture){
return 1;
}
#include "opencv/highgui.h"
#include "opencv/cv.h"
#include <windows.h>
}
if (abs(position_objet.x - Position_suivante_objet.x) > STEP_MIN){
objet_prochaine_etapeX = max(STEP_MIN, min(STEP_MAX, abs(position_objet.x - Position_suivante_objet.x) / 2));
position_objet.x += (-1) * sign(position_objet.x - Position_suivante_objet.x) * objet_prochaine_etapeX ;
curseurX = (-1) * sign(position_objet.x - Position_suivante_objet.x) * objet_prochaine_etapeX;
}
if (abs(position_objet.y - Position_suivante_objet.y) > STEP_MIN){
objet_prochaine_etapeY = max(STEP_MIN, min(STEP_MAX, abs(position_objet.y - Position_suivante_objet.y) / 2));
position_objet.y += (-1) * sign(position_objet.y - Position_suivante_objet.y) * objet_prochaine_etapeY ;
curseurY = position_objet.y += (-1) * sign(position_objet.y - Position_suivante_objet.y) * objet_prochaine_etapeY;
}
}
else {
position_objet.x = -1;
position_objet.y = -1;
}
if (nbPixels > 10)
cvDrawCircle(image, position_objet, 5, CV_RGB(0, 55, 255), -1);
CvPoint point1 = cvPoint(minX,minY);
CvPoint point2 = cvPoint(maxX, maxY);
//std::cout << minX << maxX << minY << maxY;
cvDrawRect(image, point1, point2, CV_RGB(0, 0, 255), 2);
cvShowImage(TRACKEUR_COULEUR, image);
}
void choisir_couleur(int event, int x, int y, int flags, void *param = NULL){
CvScalar pixel;
IplImage *hsv;
if (event == CV_EVENT_LBUTTONUP){
fin_selection = true;
hsv = cvCloneImage(image);
cvCvtColor(image, hsv, CV_BGR2HSV);
pixel = cvGet2D(hsv, y, x);
h = (int)pixel.val[0];
s = (int)pixel.val[1];
v = (int)pixel.val[2];
cvReleaseImage(&hsv);
}
}
int application(){
IplImage *hsv;
CvCapture *capture;
char touche;
int nbPixels;
CvPoint position_suivant;
capture = cvCreateCameraCapture(0);
if (!capture){
return 1;
}
cvNamedWindow(TRACKEUR_COULEUR, CV_WINDOW_AUTOSIZE);
cvNamedWindow(MASQUE, CV_WINDOW_AUTOSIZE);
cvMoveWindow(TRACKEUR_COULEUR, 0, 100);
cvMoveWindow(MASQUE, 650, 100);
cvSetMouseCallback(TRACKEUR_COULEUR, choisir_couleur);
while (1){
system("cls");
std::cout << "////CHOIX COULEUR REPERE>>>>" << fin_selection << "n ";
std::cout << "////CALIBRAGE>>>>" << fin_calibre << "n ";
std::cout << "n";
image = cvQueryFrame(capture);
if (!image){
return 2;
}
position_suivant = binarisation(image, &nbPixels);
ajouter_pointeur(image, position_suivant, nbPixels);
touche = cvWaitKey(5);
if (touche == 'c'){
break;
return 0;
}
if (fin_selection==true && fin_calibre == false){
if (compt3 < 100){
calibre();
compt3++;
}
else{
if (fin_calcul == false){
calcul_ratio();
}
else{
fin_calibre = true;
tempo_clic = 75;
}
}
}
if (fin_calibre == true){
deplacement();
clic();
}
}
cvDestroyWindow(TRACKEUR_COULEUR);
std::cout << "///1ER_FENETRE_DETRUITE" << "n";
cvWaitKey(500);
cvDestroyWindow(MASQUE);
std::cout << "///2EME_FENETRE_DETRUITE" << "n";
cvWaitKey(500);
cvReleaseCapture(&capture);
std::cout << "///WEBCAM_DELAISSE" << "n";
cvWaitKey(1000);
return 0;
}
int main(){
int etat =application();
if (etat != 0){
gestion_erreur(etat);
}
else{
std::cout << "++" ;
Sleep(1500);
return 0;
}
}
void gestion_erreur(int etat){
MessageBox(NULL, TEXT("FATAL ERROR"), NULL, MB_ICONSTOP);
std::cout << "FATAL_ERROR>>INTERUPTION_DE_L'APPLICATION>>ERREUR>REF::" << etat;
Sleep(5000);
}
void deplacement(){
if (!position_curseurX || !position_curseurY){
position_curseurX = position_objet.x;
position_curseurY = position_objet.y;
}
if (position_objet.x < position_curseurX){
position_curseurX = position_curseurX - ((position_curseurX - position_objet.x) / 10);
}
if (position_objet.x > position_curseurX){
position_curseurX = position_curseurX - ((position_curseurX - position_objet.x) / 10);
}
if (position_objet.y < position_curseurY){
position_curseurY = position_curseurY - ((position_curseurY - position_objet.y) / 10);
}
if (position_objet.y > position_curseurY){
position_curseurY = position_curseurY - ((position_curseurY - position_objet.y) / 10);
}
SetCursorPos( 1535-(ratioX*(position_curseurX-minX)), (ratioY*(position_curseurY-minY)));
Pré-projet thèse de doctorat
François-Florimond FLUCK
UNINE
FACULTÉ
DE
GÉOGRAPHIE
VILLE AGILE ET AGILITÉ URBAINE :
VERS UN NOUVEAU DESIGN MÉTROPOLITAIN AVEC LE BIG DATA ?
UNE ANALYSE PAR LES PRISMES DE LʼHYPERMODERNITÉ,
DE LA GOUVERNANCE, DE LA RÉSILIENCE ET DU CHRONO URBANISME

2. VILLE AGILE ET AGILITÉ URBAINE : VERS UN NOUVEAU DESIGN MÉTROPOLITAIN AVEC LE BIG DATA ?
UNE ANALYSE PAR LES PRISMES DE L’HYPERMODERNITÉ, DE LA GOUVERNANCE, DE LA RÉSILIENCE ET DU CHRONO URBANISME
Développer des systèmes de flux intelligents qui concourent en faveur d’un développement plus soutenable et de villes résilientes,
optimiser la sûreté en allant jusqu’à prédire la possibilité de production d’un délit, ou favoriser le confort et la qualité en façonnant
les aménités urbaines selon des approches spatiotemporelles représentent des défis que porte la fabrique et la gestion territoriale
adossée à la collecte et l’exploitation de Big Data.
Ville résiliente et gouvernance urbaine
Le paradigme de la résilience propose aujourd’hui par son pendant smart city que les territoires « s’augmentent » par l’installation
de capteurs (énergie, météo, caractérisation d’un site) et l’exploitation des données afférentes : les Big Data. Cette masse
d’information à maillage géospatial fin et qui s’appuie sur l’internet des objets suppose une adaptabilité des services et fonctions
urbaines optimisée. L’urbain alors envisagé comme un système évolutif cherchant l’ajustement des stocks et besoins en temps
réel poursuit l’objectif de la plus juste adéquation aux besoins et usages du système. Il apparaît en outre judicieux d’appréhender
les connected devices en tant qu’actant de l’intermédiation homme-système selon une approche latourienne.
Cette proposition projectuelle d’une ville plus intelligente – comprendre algorithmée – est aujourd’hui le fait d’une acception de la
ville numérique vue comme « celle qui est saisie par la révolution numérique »6
mais ne doit pas occulter que « c’est avant tout les
décideurs et les citoyens qui sont intelligents »7
; ceux-là même qui programment les codes et qui induisent donc une certaine
subjectivité dans ces automatismes. On peut alors envisager une matrice à quatre entrées avec le public face au privé et l’individu
vis à vis du collectif voire du commun.
Le citoyen peut représenter l’un des premiers maillons de la production de datas qui intéresse l’adaptation du collectif tandis que
des entreprises commerciales émettent des solutions affinées en fonction de la localisation des personnes et des espaces qui font
centralité. Ces acteurs qui pratiquent le marketing profilé et géolocalisé jouent aux côtés d’entreprises spécialisées dans la
gestion et les services urbains à l’instar de Véolia, Thalès, IBM ou Xerox qui s’invitent dans le jeu de la gouvernance urbaine. Les
initiatives publiques relatives à l’open data et à la modélisation urbaine ont à gagner en s’inspirant de l’expertise du privé qui en
attendant édifie son horizon propre pour les territoires contemporains.
Numérique et hypermodernité
La ville intelligente par ses complémentarités avec le Big Data est en outre chargée symboliquement. N’augure-t-elle pas
l’avènement d’un projet idéologique techniciste et hypermoderne qui contrarie des caractéristiques essentielles de la ville, à savoir
l’imprévu ou la surprise ? La finalité de rationalisation avec les smart grid concerne également les individus selon des logiques de
quantified self. En prenant l’exemple des villes qui déploient des systèmes de sureté complexes voire prédictifs, dans quelles
mesures les comportements des individus en sont modifiés selon une perspective foucaldienne ?
N’oublions pas de replacer la contemporanéité du Big Data dans une logique NBIC pour nanotechnologies, biotechnologies,
informatique et sciences cognitives. La vague Big Data s’appuie en effet sur les nanos dont on connaît les controverses et, comme
on l’observe avec les wearable devices bouleverse nos rapports cognitifs à l’espace et au temps8
.
Au travers de la rhétorique sur la ville augmentée, il est intéressant de changer notre focale et de s’intéresser aux corps humains.
Les nanos s’invitent dans les villes, et pourquoi pas dans les corps ? La smart city nourrirait-elle, dans le fond, le projet
transhumaniste ?
6
BARAUD-SERFATY, Isabelle. Keynote dans le cadre des 8e
entretiens de l’aménagement « Ensemble, la ville » : Avec qui ferons-nous la ville demain ?
Strasbourg, 8.04.2016.
7
DAMON, Julien et PAQUOT, Thierry. Smart city, In : Les 100 mots de la ville. Paris : Presses universitaires de France, 2014, p. 113-114.
8
JAURÉGUIBERRY, F. et LACHANCE, J. Le voyageur hypermoderne – Partir dans un monde connecté. Paris : ERES, 2016, 152p.

3. Planification spatiotemporelle
La dialectique géographie/Big Data invite aussi l’approche temporelle à la lecture urbaine en complément de l’appréhension
spatiale, plus usuelle. En cherchant à s’ajuster aux activités déployées par les agents urbains – fréquentation commerciale ou
récréative d’un lieu, production et consommation d’électricité en temps réel, migrations pendulaires — le territoire fait émerger
une appréhension spatiotemporelle de son fonctionnement.
La prise en compte en temps réel des flux qui animent les territoires, en cherchant la continuité d’usage et l’optimisation interroge
également la forme urbaine et son niveau de dilution. Modulariser les lieux, créer de nouvelles centralités chronotopiques à
l’image des hubs de mobilité ou des tiers lieux sont autant de pistes de solutions pour réguler l’étalement urbain et reconsidérer la
densité, l’intensité urbaine et les territorialités collectives. L’adossement à ces technologies disruptives peut-il augurer l’avènement
d’un temporal turn dans les sciences de la planification ?
La flexibilité, la souplesse, la réversibilité deviennent des axes forts préconisés par les acteurs de la fabrique urbaine, envisageant
le système urbain comme l’ajustement entre des stocks et des besoins alors que le partage, la mutualisation et la collaboration
s’érigent en nouvelles valeurs individuelles et collectives, dans les marges d’abord puis dans les centralités de plus en plus et
bientôt, peut-être, dans l’adn urbain. Le Big Data apporte un des matériaux de base au développement de ces postures.
Le triptyque passé-présent-futur fait aussi sens avec l’exploitation du Big Data : le code produit des modèles inspirés par l’avant
qui cherchent une prise réelle avec le pendant et ambitionnent d’anticiper l’avenir. Dans le cas où ces systèmes renferment une
autonomie décisionnelle et sont en mesure de profiler ce qui ressort du normal et de l’exceptionnel — donc potentiellement du
suspect —, doit-on craindre le retour d’une certaine forme de déterminisme avec une production automatisée de l’espace,
éventuellement hyperréelle ?
Avec les incroyables possibilités qu’offrent le numérique, n’est-ce pas aussi le sens du commun qui est posé ? Les gains urbains
que promet le Big Data bénéficieront-ils à certains privilégiés ou à une frange élargie de la société ? Quid de la gouvernance : doit-
on craindre « le passage du gouvernement urbain à la gouvernance urbaine ? »9
? La proposition émanant des entreprises spécialisés
dans les services urbains de prendre part à la fabrique et à la gestion urbaine est sérieuse. Par le jeu des délégations de services
publiques et en contrôlant des systèmes étendus — réseaux, chauffage, déchets —, celles-ci légitiment leurs vues projectuelles sur
les territoires et discutent les fondamentaux du public et du privé. Avec la décentralisation possible des datas, peut-on espérer une
dynamique d’empowerment de la part de groupes d’acteurs ou est-ce justifié de craindre une surveillance et un contrôle accrue de
la part des prestataires qui possèdent les précieuses données ? Comment la ville numérique peut-elle proposer un projet commun
? Entre l’accroissement du confort et de la qualité urbaine et au risque du développement de systèmes sécuritaires ou prédictifs,
cet horizon technologique et sociétal peut-il être audible et souhaitable ?
9
LE GALES, Patrick. Du gouvernement des villes à la gouvernance urbaine. In : Revue française de science politique, 45e année, n°1, 1995. p.
57-95.