custompalettebuilder.java

电子地图服务器,搭建自己的地图服务

		final int rgba[] = new int[numBands];
		final boolean discriminantTransparency = transparency != Transparency.OPAQUE;
		final int transpBand = numBands - 1;
		final int minx_ = src.getMinX();
		final int miny_ = src.getMinY();
		final int srcW_ = src.getWidth();
		final int srcH_ = src.getHeight();
		final int maxx_ = minx_ + srcW_;
		final int maxy_ = miny_ + srcH_;
		final int minTileX = src.getMinTileX();
		final int minTileY = src.getMinTileY();
		final int tileW = src.getTileWidth();
		final int tileH = src.getTileHeight();
		final int maxTileX = minTileX + src.getNumXTiles();
		final int maxTileY = minTileY + src.getNumYTiles();
		for (int ty = minTileY; ty < maxTileY; ty++) {
			for (int tx = minTileX; tx < maxTileX; tx++) {
				// get the source raster
				final Raster r = src.getTile(tx, ty);

				int minx = r.getMinX();
				int miny = r.getMinY();
				minx = minx < minx_ ? minx_ : minx;
				miny = miny < miny_ ? miny_ : miny;
				int maxx = minx + tileW;
				int maxy = miny + tileH;
				maxx = maxx > maxx_ ? maxx_ : maxx;
				maxy = maxy > maxy_ ? maxy_ : maxy;
				for (int j = miny; j < maxy; j++) {
					if ((subsampley > 1) && ((j % subsampley) != 0)) {
						continue;
					}

					for (int i = minx; i < maxx; i++) {
						if ((subsampleX > 1) && ((i % subsampleX) != 0)) {
							continue;
						}
						r.getPixel(i, j, rgba);
						/*
						 * If transparency of given image is not opaque we
						 * assume all colors with alpha less than 1.0 as fully
						 * transparent.
						 */
						if (discriminantTransparency
								&& (rgba[transpBand] < alphaThreshold)) {
							transColor = insertNode(transColor, rgba, 0);
						} else {

							root = insertNode(root, rgba, 0);
						}

						if (currSize > requiredSize) {
							reduceTree();
						}

					}
				}

			}
		}
		return this;
	}

	protected ColorNode insertNode(ColorNode aNode, int[] rgba, int aLevel) {
		if (aNode == null) {
			aNode = new ColorNode();
			numNodes++;

			if (numNodes > maxNodes) {
				maxNodes = numNodes;
			}

			aNode.level = aLevel;
			aNode.isLeaf = (aLevel > maxLevel);

			if (aNode.isLeaf) {
				currSize++;
			}
		}

		aNode.colorCount++;
		aNode.red += rgba[0];
		aNode.green += rgba[1];
		aNode.blue += rgba[2];

		if (!aNode.isLeaf) {
			int branchIndex = getBranchIndex(rgba, aLevel);

			if (aNode.children[branchIndex] == null) {
				aNode.childCount++;

				if (aNode.childCount == 2) {
					aNode.nextReducible = reduceList[aLevel];
					reduceList[aLevel] = aNode;
				}
			}

			aNode.children[branchIndex] = insertNode(
					aNode.children[branchIndex], rgba, aLevel + 1);
		}

		return aNode;
	}

	public IndexColorModel getIndexColorModel() {
		int size = currSize;

		if (transparency == Transparency.BITMASK) {
			size++; // we need place for transparent color;
		}

		final byte[] red = new byte[size];
		final byte[] green = new byte[size];
		final byte[] blue = new byte[size];

		int index = 0;
		palette = new ColorNode[size];

		if (transparency == Transparency.BITMASK) {
			index++;
		}
		findPaletteEntry(root, index, red, green, blue);
		if (transparency == Transparency.BITMASK) {
			return new IndexColorModel(8, size, red, green, blue, 0);
		}
		return new IndexColorModel(8, currSize, red, green, blue);
	}

	protected int findPaletteEntry(ColorNode aNode, int index, byte[] red,
			byte[] green, byte[] blue) {
		if (aNode == null) {
			return index;
		}

		if (aNode.isLeaf) {
			red[index] = (byte) (aNode.red / aNode.colorCount);
			green[index] = (byte) (aNode.green / aNode.colorCount);
			blue[index] = (byte) (aNode.blue / aNode.colorCount);
			aNode.paletteIndex = index;

			palette[index] = aNode;

			index++;
		} else {
			for (int i = 0; i < 8; i++) {
				if (aNode.children[i] != null) {
					index = findPaletteEntry(aNode.children[i], index, red,
							green, blue);
				}
			}
		}

		return index;
	}

	protected int getBranchIndex(int[] rgba, int aLevel) {
		if ((aLevel > maxLevel) || (aLevel < 0)) {
			throw new IllegalArgumentException("Invalid octree node depth: "
					+ aLevel);
		}

		int shift = maxLevel - aLevel;
		int red_index = 0x1 & ((0xff & rgba[0]) >> shift);
		int green_index = 0x1 & ((0xff & rgba[1]) >> shift);
		int blue_index = 0x1 & ((0xff & rgba[2]) >> shift);
		int index = (red_index << 2) | (green_index << 1) | blue_index;

		return index;
	}

	protected void reduceTree() {
		int level = reduceList.length - 1;
		while ((reduceList[level] == null) && (level >= 0)) {
			level--;
		}

		ColorNode thisNode = reduceList[level];

		if (thisNode == null) {
			// nothing to reduce
			return;
		}

		// look for element with lower color count
		ColorNode pList = thisNode;
		int minColorCount = pList.colorCount;

		int cnt = 1;

		while (pList.nextReducible != null) {
			if (minColorCount > pList.nextReducible.colorCount) {
				thisNode = pList;
				minColorCount = pList.colorCount;
			}

			pList = pList.nextReducible;
			cnt++;
		}

		// save pointer to first reducible node
		// NB: current color count for node could be changed in future
		if (thisNode == reduceList[level]) {
			reduceList[level] = thisNode.nextReducible;
		} else {
			pList = thisNode.nextReducible; // we need to process it
			thisNode.nextReducible = pList.nextReducible;
			thisNode = pList;
		}

		if (thisNode.isLeaf) {
			return;
		}

		// reduce node
		int leafChildCount = thisNode.getLeafChildCount();
		thisNode.isLeaf = true;
		currSize -= (leafChildCount - 1);

		final int aDepth = thisNode.level;
		for (int i = 0; i < 8; i++) {
			thisNode.children[i] = freeTree(thisNode.children[i]);
		}
		thisNode.childCount = 0;
	}

	protected ColorNode freeTree(ColorNode aNode) {
		if (aNode == null) {
			return null;
		}

		for (int i = 0; i < 8; i++) {
			aNode.children[i] = freeTree(aNode.children[i]);
		}

		numNodes--;

		return null;
	}

	/**
	 * The node of color tree.
	 */
	protected class ColorNode {
		public boolean isLeaf;

		public int childCount;

		public ColorNode[] children;

		public int colorCount;

		public long red;

		public long blue;

		public long green;

		public int paletteIndex;

		public int level;

		public ColorNode nextReducible;

		public ColorNode() {
			isLeaf = false;
			level = 0;
			childCount = 0;
			children = new ColorNode[8];

			for (int i = 0; i < 8; i++) {
				children[i] = null;
			}

			colorCount = 0;
			red = green = blue = 0;

			paletteIndex = 0;
		}

		public int getLeafChildCount() {
			if (isLeaf) {
				return 0;
			}

			int cnt = 0;

			for (int i = 0; i < children.length; i++) {
				if (children[i] != null) {
					if (children[i].isLeaf) {
						cnt++;
					} else {
						cnt += children[i].getLeafChildCount();
					}
				}
			}

			return cnt;
		}

		public int getRGB() {
			int r = (int) red / colorCount;
			int g = (int) green / colorCount;
			int b = (int) blue / colorCount;

			int c = (0xff << 24) | ((0xff & r) << 16) | ((0xff & g) << 8)
					| (0xff & b);

			return c;
		}
	}

	public int findNearestColorIndex(int[] rgba, int transparentBand) {
		return findColorIndex(root, rgba, transparentBand);
	}

}