pointContainer.ts
4.14 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
/**
* @preserve
* Copyright 2015-2016 Igor Bezkrovnyi
* All rights reserved. (MIT Licensed)
*
* pointContainer.ts - part of Image Quantization Library
*/
import { Point } from "./point"
/**
* v8 optimizations done.
* fromXXX methods are static to move out polymorphic code from class instance itself.
*/
export class PointContainer {
private readonly _pointArray : Point[];
private _width : number;
private _height : number;
constructor() {
this._width = 0;
this._height = 0;
this._pointArray = [];
}
getWidth() : number {
return this._width;
}
getHeight() : number {
return this._height;
}
setWidth(width : number) : void {
this._width = width;
}
setHeight(height : number) : void {
this._height = height;
}
getPointArray() : Point[] {
return this._pointArray;
}
clone() : PointContainer {
const clone = new PointContainer();
clone._width = this._width;
clone._height = this._height;
for (let i = 0, l = this._pointArray.length; i < l; i++) {
clone._pointArray[ i ] = Point.createByUint32(this._pointArray[ i ].uint32 | 0); // "| 0" is added for v8 optimization
}
return clone;
}
toUint32Array() : Uint32Array {
const l = this._pointArray.length,
uint32Array = new Uint32Array(l);
for (let i = 0; i < l; i++) {
uint32Array[ i ] = this._pointArray[ i ].uint32;
}
return uint32Array;
}
toUint8Array() : Uint8Array {
return new Uint8Array(this.toUint32Array().buffer);
}
static fromHTMLImageElement(img : HTMLImageElement) : PointContainer {
const width = img.naturalWidth,
height = img.naturalHeight;
const canvas = document.createElement("canvas");
canvas.width = width;
canvas.height = height;
const ctx = <CanvasRenderingContext2D>canvas.getContext("2d");
ctx.drawImage(img, 0, 0, width, height, 0, 0, width, height);
return PointContainer.fromHTMLCanvasElement(canvas);
}
static fromHTMLCanvasElement(canvas : HTMLCanvasElement) : PointContainer {
const width = canvas.width,
height = canvas.height;
const ctx = <CanvasRenderingContext2D>canvas.getContext("2d"),
imgData = ctx.getImageData(0, 0, width, height);
return PointContainer.fromImageData(imgData);
}
static fromNodeCanvas(canvas : any) : PointContainer {
return PointContainer.fromHTMLCanvasElement(canvas);
}
static fromImageData(imageData : ImageData) : PointContainer {
const width = imageData.width,
height = imageData.height;
return PointContainer.fromCanvasPixelArray(imageData.data, width, height);
/*
var buf8;
if (Utils.typeOf(imageData.data) == "CanvasPixelArray")
buf8 = new Uint8Array(imageData.data);
else
buf8 = imageData.data;
this.fromUint32Array(new Uint32Array(buf8.buffer), width, height);
*/
}
static fromArray(byteArray : number[], width : number, height : number) : PointContainer {
const uint8array = new Uint8Array(byteArray);
return PointContainer.fromUint8Array(uint8array, width, height);
}
static fromCanvasPixelArray(data : any, width : number, height : number) : PointContainer {
return PointContainer.fromArray(data, width, height);
}
static fromUint8Array(uint8array : Uint8Array, width : number, height : number) : PointContainer {
return PointContainer.fromUint32Array(new Uint32Array(uint8array.buffer), width, height);
}
static fromUint32Array(uint32array : Uint32Array, width : number, height : number) : PointContainer {
const container = new PointContainer();
container._width = width;
container._height = height;
for (let i = 0, l = uint32array.length; i < l; i++) {
container._pointArray[ i ] = Point.createByUint32(uint32array[ i ] | 0); // "| 0" is added for v8 optimization
}
return container;
}
}