9B534B8686E580E0E01768F00155B461

at path：ROOT / sistema / vendors / flot / jquery.flot.image.js

run：R W Run

examples

DIR

2026-04-09 04:12:40

R W Run

.bower.json

415 By

2018-11-08 02:46:18

R W Run

.gitignore

40 By

2018-11-08 02:46:18

R W Run

.travis.yml

35 By

2018-11-08 02:46:18

R W Run

API.md

52.32 KB

2018-11-08 02:46:18

R W Run

CONTRIBUTING.md

3.17 KB

2018-11-08 02:46:18

R W Run

FAQ.md

3.16 KB

2018-11-08 02:46:18

R W Run

LICENSE.txt

1.04 KB

2018-11-08 02:46:18

R W Run

Makefile

285 By

2018-11-08 02:46:18

R W Run

NEWS.md

39.35 KB

2018-11-08 02:46:18

R W Run

PLUGINS.md

4.24 KB

2018-11-08 02:46:18

R W Run

README.md

3.69 KB

2018-11-08 02:46:18

R W Run

component.json

114 By

2018-11-08 02:46:18

R W Run

excanvas.js

40.96 KB

2018-11-08 02:46:18

R W Run

excanvas.min.js

18.86 KB

2018-11-08 02:46:18

R W Run

flot.jquery.json

837 By

2018-11-08 02:46:18

R W Run

jquery.colorhelpers.js

6.01 KB

2018-11-08 02:46:18

R W Run

jquery.flot.canvas.js

9.37 KB

2018-11-08 02:46:18

R W Run

jquery.flot.categories.js

5.89 KB

2018-11-08 02:46:18

R W Run

jquery.flot.crosshair.js

5.29 KB

2018-11-08 02:46:18

R W Run

jquery.flot.errorbars.js

12.32 KB

2018-11-08 02:46:18

R W Run

jquery.flot.fillbetween.js

5.13 KB

2018-11-08 02:46:18

R W Run

jquery.flot.image.js

7.19 KB

2018-11-08 02:46:18

R W Run

jquery.flot.js

120.09 KB

2018-11-08 02:46:18

R W Run

jquery.flot.navigate.js

13.88 KB

2018-11-08 02:46:18

R W Run

jquery.flot.pie.js

23.25 KB

2018-11-08 02:46:18

R W Run

jquery.flot.resize.js

3.24 KB

2018-11-08 02:46:18

R W Run

jquery.flot.selection.js

12.83 KB

2018-11-08 02:46:18

R W Run

jquery.flot.stack.js

6.92 KB

2018-11-08 02:46:18

R W Run

jquery.flot.symbol.js

2.45 KB

2018-11-08 02:46:18

R W Run

jquery.flot.threshold.js

4.38 KB

2018-11-08 02:46:18

R W Run

jquery.flot.time.js

11.49 KB

2018-11-08 02:46:18

R W Run

jquery.js

259.82 KB

2018-11-08 02:46:18

R W Run

package.json

154 By

2018-11-08 02:46:18

R W Run

error_log

📄jquery.flot.image.js

/* Flot plugin for plotting images.

The data syntax is [ [ image, x1, y1, x2, y2 ], ... ] where (x1, y1) and
(x2, y2) are where you intend the two opposite corners of the image to end up
in the plot. Image must be a fully loaded Javascript image (you can make one
with new Image()). If the image is not complete, it's skipped when plotting.

There are two helpers included for retrieving images. The easiest work the way
that you put in URLs instead of images in the data, like this:

[ "myimage.png", 0, 0, 10, 10 ]

Then call $.plot.image.loadData( data, options, callback ) where data and
options are the same as you pass in to $.plot. This loads the images, replaces
the URLs in the data with the corresponding images and calls "callback" when
all images are loaded (or failed loading). In the callback, you can then call
$.plot with the data set. See the included example.

A more low-level helper, $.plot.image.load(urls, callback) is also included.
Given a list of URLs, it calls callback with an object mapping from URL to
Image object when all images are loaded or have failed loading.

The plugin supports these options:

series: {
		images: {
			show: boolean
			anchor: "corner" or "center"
			alpha: [ 0, 1 ]
		}
	}

They can be specified for a specific series:

$.plot( $("#placeholder"), [{
		data: [ ... ],
		images: { ... }
	])

Note that because the data format is different from usual data points, you
can't use images with anything else in a specific data series.

Setting "anchor" to "center" causes the pixels in the image to be anchored at
the corner pixel centers inside of at the pixel corners, effectively letting
half a pixel stick out to each side in the plot.

A possible future direction could be support for tiling for large images (like
Google Maps).

(function ($) {
    var options = {
        series: {
            images: {
                show: false,
                alpha: 1,
                anchor: "corner" // or "center"
            }
        }
    };

$.plot.image = {};

$.plot.image.loadDataImages = function (series, options, callback) {
        var urls = [], points = [];

var defaultShow = options.series.images.show;
        
        $.each(series, function (i, s) {
            if (!(defaultShow || s.images.show))
                return;
            
            if (s.data)
                s = s.data;

$.each(s, function (i, p) {
                if (typeof p[0] == "string") {
                    urls.push(p[0]);
                    points.push(p);
                }
            });
        });

$.plot.image.load(urls, function (loadedImages) {
            $.each(points, function (i, p) {
                var url = p[0];
                if (loadedImages[url])
                    p[0] = loadedImages[url];
            });

callback();
        });
    }
    
    $.plot.image.load = function (urls, callback) {
        var missing = urls.length, loaded = {};
        if (missing == 0)
            callback({});

$.each(urls, function (i, url) {
            var handler = function () {
                --missing;
                
                loaded[url] = this;
                
                if (missing == 0)
                    callback(loaded);
            };

$('<img />').load(handler).error(handler).attr('src', url);
        });
    };
    
    function drawSeries(plot, ctx, series) {
        var plotOffset = plot.getPlotOffset();
        
        if (!series.images || !series.images.show)
            return;
        
        var points = series.datapoints.points,
            ps = series.datapoints.pointsize;
        
        for (var i = 0; i < points.length; i += ps) {
            var img = points[i],
                x1 = points[i + 1], y1 = points[i + 2],
                x2 = points[i + 3], y2 = points[i + 4],
                xaxis = series.xaxis, yaxis = series.yaxis,
                tmp;

// actually we should check img.complete, but it
            // appears to be a somewhat unreliable indicator in
            // IE6 (false even after load event)
            if (!img || img.width <= 0 || img.height <= 0)
                continue;

if (x1 > x2) {
                tmp = x2;
                x2 = x1;
                x1 = tmp;
            }
            if (y1 > y2) {
                tmp = y2;
                y2 = y1;
                y1 = tmp;
            }
            
            // if the anchor is at the center of the pixel, expand the 
            // image by 1/2 pixel in each direction
            if (series.images.anchor == "center") {
                tmp = 0.5 * (x2-x1) / (img.width - 1);
                x1 -= tmp;
                x2 += tmp;
                tmp = 0.5 * (y2-y1) / (img.height - 1);
                y1 -= tmp;
                y2 += tmp;
            }
            
            // clip
            if (x1 == x2 || y1 == y2 ||
                x1 >= xaxis.max || x2 <= xaxis.min ||
                y1 >= yaxis.max || y2 <= yaxis.min)
                continue;

var sx1 = 0, sy1 = 0, sx2 = img.width, sy2 = img.height;
            if (x1 < xaxis.min) {
                sx1 += (sx2 - sx1) * (xaxis.min - x1) / (x2 - x1);
                x1 = xaxis.min;
            }

if (x2 > xaxis.max) {
                sx2 += (sx2 - sx1) * (xaxis.max - x2) / (x2 - x1);
                x2 = xaxis.max;
            }

if (y1 < yaxis.min) {
                sy2 += (sy1 - sy2) * (yaxis.min - y1) / (y2 - y1);
                y1 = yaxis.min;
            }

if (y2 > yaxis.max) {
                sy1 += (sy1 - sy2) * (yaxis.max - y2) / (y2 - y1);
                y2 = yaxis.max;
            }
            
            x1 = xaxis.p2c(x1);
            x2 = xaxis.p2c(x2);
            y1 = yaxis.p2c(y1);
            y2 = yaxis.p2c(y2);
            
            // the transformation may have swapped us
            if (x1 > x2) {
                tmp = x2;
                x2 = x1;
                x1 = tmp;
            }
            if (y1 > y2) {
                tmp = y2;
                y2 = y1;
                y1 = tmp;
            }

tmp = ctx.globalAlpha;
            ctx.globalAlpha *= series.images.alpha;
            ctx.drawImage(img,
                          sx1, sy1, sx2 - sx1, sy2 - sy1,
                          x1 + plotOffset.left, y1 + plotOffset.top,
                          x2 - x1, y2 - y1);
            ctx.globalAlpha = tmp;
        }
    }

function processRawData(plot, series, data, datapoints) {
        if (!series.images.show)
            return;

// format is Image, x1, y1, x2, y2 (opposite corners)
        datapoints.format = [
            { required: true },
            { x: true, number: true, required: true },
            { y: true, number: true, required: true },
            { x: true, number: true, required: true },
            { y: true, number: true, required: true }
        ];
    }
    
    function init(plot) {
        plot.hooks.processRawData.push(processRawData);
        plot.hooks.drawSeries.push(drawSeries);
    }
    
    $.plot.plugins.push({
        init: init,
        options: options,
        name: 'image',
        version: '1.1'
    });
})(jQuery);