source: spip-zone/_plugins_/adaptive_images/trunk/adaptive_images_options.php @ 115922

Last change on this file since 115922 was 115922, checked in by cedric@…, 6 weeks ago

Optimization de la rapidite de geometrize

File size: 13.0 KB
Line 
1<?php
2/**
3 * Options du plugin Adaptive Images
4 *
5 * @plugin     Adaptive Images
6 * @copyright  2013-2019
7 * @author     Cedric
8 * @licence    GNU/GPL
9 * @package    SPIP\Adaptive_Images\Options
10 */
11
12
13if (!defined('_ECRIRE_INC_VERSION')) return;
14
15include_once(_DIR_PLUGIN_ADAPTIVE_IMAGES."lib/AdaptiveImages/AdaptiveImages.php");
16class SPIPAdaptiveImages extends AdaptiveImages {
17        protected function URL2filepath($url){
18                $url = parent::URL2filepath($url);
19                // URL absolue en URL relative
20                if (preg_match(",^https?://,",$url)){
21                        $base = url_de_base();
22                        if (strncmp($url,$base,strlen($base))==0)
23                                $url = _DIR_RACINE . substr($url,strlen($base));
24                        elseif (defined('_ADAPTIVE_IMAGES_DOMAIN')
25                          AND strncmp($url,_ADAPTIVE_IMAGES_DOMAIN,strlen(_ADAPTIVE_IMAGES_DOMAIN))==0){
26                                $url = _DIR_RACINE . substr($url,strlen(_ADAPTIVE_IMAGES_DOMAIN));
27                        }
28                }
29                return $url;
30        }
31
32        protected function filepath2URL($filepath, $relative=false){
33                $filepath = parent::filepath2URL($filepath, $relative);
34                if (!$relative AND defined('_ADAPTIVE_IMAGES_DOMAIN')){
35                        $filepath = rtrim(_ADAPTIVE_IMAGES_DOMAIN,"/")."/".$filepath;
36                }
37                return $filepath;
38        }
39}
40$AdaptiveImages = SPIPAdaptiveImages::getInstance();
41
42
43// utiliser le progressive rendering sur PNG et GIF si pas de JS
44if (defined('_ADAPTIVE_IMAGES_NOJS_PNGGIF_PROGRESSIVE_RENDERING'))
45        $AdaptiveImages->nojsPngGifProgressiveRendering = _ADAPTIVE_IMAGES_NOJS_PNGGIF_PROGRESSIVE_RENDERING;
46
47$settings = (isset($GLOBALS['meta']['adaptive_images'])?unserialize($GLOBALS['meta']['adaptive_images']):false);
48if ($settings){
49        // couleur de background pour les images lowsrc
50        if (isset($settings['lowsrc_jpg_bg_color']) AND $settings['lowsrc_jpg_bg_color'])
51                $AdaptiveImages->lowsrcJpgBgColor = $settings['lowsrc_jpg_bg_color'];
52        // qualite de compression JPG pour les images 1x
53        if (isset($settings['10x_jpg_quality']) AND $q=intval($settings['10x_jpg_quality']))
54                $AdaptiveImages->x10JpgQuality = $q;
55        // qualite de compression JPG pour les images 1.5x
56        if (isset($settings['15x_jpg_quality']) AND $q=intval($settings['15x_jpg_quality']))
57                $AdaptiveImages->x15JpgQuality = $q;
58        // qualite de compression JPG pour les images 2x
59        if (isset($settings['20x_jpg_quality']) AND $q=intval($settings['20x_jpg_quality']))
60                $AdaptiveImages->x20JpgQuality = $q;
61        // Breakpoints de taille d'ecran pour lesquels on generent des images
62        if (isset($settings['default_bkpts']) AND $settings['default_bkpts'])
63                $AdaptiveImages->defaultBkpts = explode(",",$settings['default_bkpts']);
64        // les images 1x sont au maximum en max_width_1x px de large dans la page
65        if (isset($settings['max_width_1x']) AND $v=intval($settings['max_width_1x']))
66                $AdaptiveImages->maxWidth1x = $v;
67        // Pour les ecrans plus petits, c'est la version mobile qui est fournie (recadree)
68        if (isset($settings['max_width_mobile_version']) AND $v=intval($settings['max_width_mobile_version']))
69                $AdaptiveImages->maxWidthMobileVersion = $v;
70
71
72        // qualite des images lowsrc
73        if (isset($settings['lowsrc_jpg_quality']) AND $q=intval($settings['lowsrc_jpg_quality']))
74                $AdaptiveImages->lowsrcJpgQuality= $q;
75        if (isset($settings['lowsrc_width']) AND $v=intval($settings['lowsrc_width'])){
76                $AdaptiveImages->lowsrcWidth = $v;
77        }
78        else {
79                // fine tuning automatique si pas de config (up depuis une version existante) :
80                // on genere une miniature toute petite en ameliorant un peu la qualite de sortie,
81                // ce qui donne une taille beaucoup plus reduite
82                $AdaptiveImages->lowsrcWidth = 128;
83                $AdaptiveImages->lowsrcJpgQuality = min($AdaptiveImages->lowsrcJpgQuality + 30, 90);
84        }
85
86        // on ne traite pas les images de largeur inferieure a min_width_1x px
87        if (isset($settings['min_width_1x']) AND $v=intval($settings['min_width_1x']))
88                $AdaptiveImages->minWidth1x = $v;
89        // on ne traite pas les images de poids inferieur a min_filesize ko
90        if (isset($settings['min_filesize']) AND $v=intval($settings['min_filesize']))
91                $AdaptiveImages->minFileSize = $v*1024;
92
93
94        // Pour generer chaque variante d'image uniquement quand elle est demandee pour la premiere fois
95        // par defaut false : on genere toutes les images au calcul de la page (mais timeout possible)
96        // pour passer a true : ajouter la rewrite rule suivante dans .htaccess
97        /*
98        ###
99        # Adaptive Images
100
101        RewriteRule \badapt-img/(\d+/\d\dx/.*)$ spip.php?action=adapt_img&arg=$1 [QSA,L]
102
103        # Fin des Adaptive Images
104        ###
105        */
106        if (isset($settings['on_demand_production']) AND $settings['on_demand_production'])
107                $AdaptiveImages->onDemandImages = true;
108
109        if (isset($settings['lazy_load']) AND $settings['lazy_load'])
110                $AdaptiveImages->lazyload = true;
111
112        // Experimental : generer des thumbnails svg a base de gradients (mais resultat assez bof)
113        //$AdaptiveImages->thumbnailGeneratorCallback = "adaptive_images_preview_gradients";
114        // Experimental : generer des thumbnails svg a base de Potrace
115        //$AdaptiveImages->thumbnailGeneratorCallback = "adaptive_images_preview_potrace";
116        // Experimental : generer des thumbnails svg a base de Geometrize PHP
117        $AdaptiveImages->thumbnailGeneratorCallback = "adaptive_images_preview_geometrize";
118}
119
120
121
122// GD memory limit
123if (defined('_IMG_GD_MAX_PIXELS'))
124        $AdaptiveImages->maxImagePxGDMemoryLimit = intval(_IMG_GD_MAX_PIXELS);
125
126// dossier de stockage des images adaptatives
127$AdaptiveImages->destDirectory = _DIR_VAR . "adapt-img/";
128
129
130
131/**
132 * ?action=adapt_img
133 * Production d'une image a la volee a partir de son URL
134 * arg
135 *   local/adapt-img/w/x/file
136 *   ex : 320/20x/file
137 *   w est la largeur affichee de l'image
138 *   x est la resolution (10x => 1, 15x => 1.5, 20x => 2)
139 *   file le chemin vers le fichier source
140 */
141function action_adapt_img_dist(){
142
143        $AdaptiveImages = SPIPAdaptiveImages::getInstance();
144        try {
145                $AdaptiveImages->deliverBkptImage(_request('arg'));
146        }
147        catch (Exception $e){
148                http_status(404);
149                include_spip('inc/minipres');
150                echo minipres(_T('erreur').' 404',
151                        _T('medias:info_document_indisponible')."<br />".$e->getMessage(),"",true);
152        }
153        exit;
154}
155
156/**
157 * Fonction de base pour les filtres, ne pas utiliser directement
158 * @protected
159 *
160 * @param $texte
161 * @param $max_width_1x
162 * @param bool $background_only
163 * @return mixed|string
164 */
165function adaptive_images_base($texte, $max_width_1x, $background_only = false){
166        $bkpt = null;
167        // plusieurs valeurs separees par un / : ce sont les breakpoints, max_width_1x est la derniere valeur
168        if (strpos($max_width_1x,"/")!==false){
169                $bkpt = explode("/",$max_width_1x);
170                $bkpt = array_map("intval",$bkpt);
171                $max_width_1x = end($bkpt);
172                if (!$max_width_1x){
173                        $max_width_1x = null;
174                        $bkpt = null;
175                }
176        }
177        $AdaptiveImages = SPIPAdaptiveImages::getInstance();
178        $res = $AdaptiveImages->adaptHTMLPart($texte, $max_width_1x, $bkpt, $background_only);
179
180        if (!$background_only) {
181                // injecter la class filtre_inactif sur les balises img pour ne pas repasser un filtre image dessus
182                $imgs = extraire_balises($res, 'img');
183                foreach ($imgs as $img) {
184                        $class = extraire_attribut($img, "class");
185                        if (strpos($class, 'filtre_inactif') !== false) {
186                                $class = str_replace('adapt-img', 'no_image_filtrer filtre_inactif adapt-img', $class);
187                                $img2 = inserer_attribut($img, 'class', $class);
188                                if (strlen($img2) !== strlen($img)) {
189                                        $res = str_replace($img, $img2, $res);
190                                }
191                        }
192                }
193        }
194        return $res;
195}
196
197function adaptive_images_preview_gradients($image, $options) {
198        $gradients = charger_fonction("image_gradients", "preview");
199        //spip_timer('gradients');
200        if ($thumbnail = $gradients($image, $options)) {
201                //var_dump($thumbnail,filesize($thumbnail),spip_timer('gradients'));
202                return array($thumbnail, 'gradients');
203        }
204        return false;
205}
206
207function adaptive_images_preview_potrace($image, $options) {
208        $gradients = charger_fonction("image_potrace", "preview");
209        //spip_timer('potrace');
210        if ($thumbnail = $gradients($image, $options)) {
211                //var_dump($thumbnail,filesize($thumbnail),spip_timer('potrace'));
212                return array($thumbnail, 'potrace');
213        }
214        //spip_timer('potrace');
215        return false;
216}
217
218function adaptive_images_preview_geometrize($image, $options) {
219        $geometrize = charger_fonction("image_geometrize", "preview");
220        //spip_timer('geometrize');
221        if ($thumbnail = $geometrize($image, $options)) {
222                //var_dump($thumbnail,filesize($thumbnail),spip_timer('geometrize'));
223                return array($thumbnail, 'geometrize');
224        }
225        //spip_timer('geometrize');
226        return false;
227}
228
229/** Filtres  ***********************************************************************************************************/
230
231
232/**
233 * Rendre les images d'un texte adaptatives, en permettant de preciser la largeur maxi a afficher en 1x
234 * [(#TEXTE|adaptive_images{1024})]
235 * ou passer la liste des breakpoints (le dernier est la largeur maxi 1x)
236 * [(#TEXTE|adaptive_images{160/320/480/640/1024})]
237 * @param string $texte
238 * @param null|int $max_width_1x
239 * @return mixed
240 */
241function adaptive_images($texte, $max_width_1x=null){
242        return adaptive_images_base($texte, $max_width_1x);
243}
244
245/**
246 * Rendre les images d'un texte adaptatives mais en background sur des span seulement (pas de balise <img>)
247 * @param string $texte
248 * @param null|int $max_width_1x
249 * @param string $class
250 * @param string $bgcolor
251 * @return mixed
252 */
253function adaptive_images_background($texte, $max_width_1x=null, $class = '', $bgcolor=''){
254        $res = adaptive_images_base($texte, !empty($max_width_1x) ? $max_width_1x : null, true);
255        if ($class or $bgcolor) {
256                // injecter la class sur les balises span.adapt-img-background
257                $spans = extraire_balises($res, 'span');
258                foreach ($spans as $span) {
259                        if (strpos($span,'adapt-img-background') !== false) {
260                                $span = explode('>', $span, 2);
261                                $s = $span[0] . '>';
262                                $c = extraire_attribut($s, "class");
263                                if (strpos($c, 'adapt-img-background') !== false) {
264                                        $s2 = $s;
265                                        if ($class) {
266                                                $c = rtrim($c) . ' '. $class;
267                                                $s2 = inserer_attribut($s2, 'class', $c);
268                                        }
269                                        if ($bgcolor) {
270                                                $style = trim(extraire_attribut($s2, "style"));
271                                                if ($style) {
272                                                        $style = rtrim($style, ';') . ';';
273                                                }
274                                                $style .= "background-color:$bgcolor";
275                                                $s2 = inserer_attribut($s2, 'style', $style);
276                                        }
277                                        if ($s2 !== $s) {
278                                                $res = str_replace($s, $s2, $res);
279                                        }
280                                }
281                        }
282                }
283        }
284        return $res;
285}
286
287/**
288 * nommage alternatif
289 * @param $texte
290 * @param int $max_width_1x
291 * @return mixed
292 */
293function adaptative_images($texte, $max_width_1x=null){
294        return adaptive_images($texte, $max_width_1x);
295}
296
297/** Pipelines  ********************************************************************************************************/
298
299/**
300 * Completer la page d'edition d'un document
301 * pour joindre sous-titrage, audio-desc et transcript sur les videos
302 *
303 * @param array $flux
304 * @return array
305 */
306function adaptive_images_affiche_milieu($flux){
307        if (in_array($flux['args']['exec'],array('document_edit','documents_edit'))
308          AND $id_document=$flux['args']['id_document']){
309                $flux['data'] .= recuperer_fond('prive/squelettes/inclure/adapter-image',array('id_document'=>$id_document));
310        }
311        return $flux;
312}
313
314/**
315 * Injecter data-src-mobile="..." sur les modeles img/doc/emb quand une variante mobile existe
316 *
317 * @param array $flux
318 * @return array
319 */
320function adaptive_images_recuperer_fond($flux){
321        if (
322                strncmp($flux['args']['fond'],"modeles/img",11)==0
323                OR strncmp($flux['args']['fond'],"modeles/doc",11)==0
324                OR strncmp($flux['args']['fond'],"modeles/emb",11)==0){
325                if ($id_document = intval($flux['args']['contexte']['id_document'])){
326                        if ($mobileview = adaptive_images_variante($id_document,"mobileview")){
327                                $src_mobile = get_spip_doc($mobileview['fichier']);
328                                $imgs = extraire_balises($flux['data']['texte'],'img');
329                                foreach($imgs as $img){
330                                        $src = extraire_attribut($img,"src");
331                                        $src = set_spip_doc($src);
332                                        if (sql_getfetsel("id_document","spip_documents","id_document=".intval($id_document)." AND fichier=".sql_quote($src))){
333                                                $img2 = inserer_attribut($img,"data-src-mobile",$src_mobile);
334                                                $flux['data']['texte'] = str_replace($img,$img2,$flux['data']['texte']);
335                                        }
336                                }
337                        }
338                }
339        }
340        return $flux;
341}
342
343
344/**
345 * Trouver la variante $mode d'une image
346 * @param int $id_document
347 * @param string $mode
348 *   mobileview
349 * @return array
350 */
351function adaptive_images_variante($id_document,$mode){
352        return sql_fetsel('*',
353                'spip_documents as d JOIN spip_documents_liens as L on L.id_document=d.id_document',
354                "L.objet='document' AND L.id_objet=".intval($id_document)." AND d.mode=".sql_quote($mode));
355}
356
357
358
359/**
360 * Traiter les images de la page et les passer en responsive
361 * si besoin
362 *
363 * @param $texte
364 * @return mixed
365 */
366function adaptive_images_affichage_final($texte){
367        if ($GLOBALS['html']){
368                #spip_timer();
369                $AdaptiveImages = SPIPAdaptiveImages::getInstance();
370                $texte = $AdaptiveImages->adaptHTMLPage($texte);
371                #var_dump(spip_timer());
372        }
373        return $texte;
374}
375
376/**
377 * Inserer jquery.lazyload.js si besoin
378 * @param $texte
379 * @return string
380 */
381function adaptive_images_insert_head($texte){
382        $AdaptiveImages = SPIPAdaptiveImages::getInstance();
383        if ($AdaptiveImages->lazyload){
384                if ($js = find_in_path("javascript/jquery.lazyload.js"))
385                        $texte .= "<script type='text/javascript' src='$js'></script>\n";
386                if ($js = find_in_path("javascript/adaptive.lazyload.js"))
387                        $texte .= "<script type='text/javascript' src='$js'></script>\n";
388        }
389        return $texte;
390}
391
392?>
Note: See TracBrowser for help on using the repository browser.